REPOSITORY ANALYSIS

jev-git

See how jev-git checks staged diffs for credentials and destructive payloads, including its 0.80 threshold, fail-closed policy, and pinned source.

Original source currently unavailable. The source returned 404 on 2026-10-24; this description concerns a historical revision. The offline lab below is this site’s implementation, not an upstream reproduction.

E2 · source reviewedPublic material or source evidence was reviewed. A fixed-version source review requires checking a pinned revision; this is not a reproduction, performance endorsement, or safety guarantee.

Review scope: pinned source read · offline contract check; see the limitations below.

Stars
2
Forks
0
License
MIT
Last commit
2026-09-21

What Jev does here

The reviewed revision sends up to 25,000 diff characters as state and evaluates has_secrets and has_destructive_payload in one request. It blocks at 0.80, warns from 0.55 to 0.80, and fails closed when answers, credentials, decoding, or the API are unavailable.

The project demonstrates placing Jev at an existing Git control point instead of letting a model execute Git operations. Its installer chains existing pre-commit content and adds a pre-push hook, while Git remains responsible for the actual commit and push.

README, Rust implementation, and tests at pinned commit d1b6732 were reviewed on 2026-09-26. This site did not run the binary or measure latency. README claims such as about 80 ms and a sub-2 MB static binary are author-reported, not independent benchmarks.

What does jev-git actually check?

It is neither a code generator nor a syntax linter. The reviewed revision truncates the staged or piped diff to 25,000 characters, uses it as one Jev state, and asks the has_secrets and has_destructive_payload Noul questions together.

Jev owns
Estimate whether a diff resembles exposed credentials or a destructive payload and return probabilities.
Code owns
Read the diff, apply 0.55/0.80 thresholds, install hooks, print warnings, and fail closed on errors.
Not established
This site did not run the binary; README latency and size figures are not independent benchmarks.

What can you inspect while the original repository is unavailable?

The pinned upstream README and main.rs returned 404 when checked on 2026-10-24. The preceding description is historical and does not establish current maintenance or runtime behavior. The lab below is this site’s own advisory Git implementation, not a reproduction of the Rust binary, its two Noul questions, or its performance claims.

Compare the responsibility boundaries

The historical project uses Noul for secret-like and destructive changes. Our example first blocks sensitive paths and common credential patterns locally, then asks three different questions about change type, risk and human review. The local layer decides whether sending is allowed; the model layer only supplies semantic suggestions. Pattern matching cannot establish the absence of secrets, so inspect inputs before a real upload.

Four cases check application behavior

Synthetic responses exercise a valid suggestion, missing credentials, a sensitive file and an incomplete response. None grants merge permission: blocking mode returns 1 for all four. A report-mode exit of 0 means the reporting step completed, not that the change is safe.

// This site's advisory Git lab, not the upstream Rust jev-git binary.
// Node 20+. Synthetic responses only; no key, network request or Git write.
import assert from 'node:assert/strict';
import { reviewDiff, exitCode } from './jev-pr-review.mjs';

const answers = {
  change_type: { type: 'choice', choice: 'fix', confidence: 0.8 },
  risk: { type: 'score', score: 1 },
  needs_human_review: { type: 'noul', noul: 0.6 },
};
const input = { names: 'M\0src/app.js\0', patch: '+return true;', apiKey: 'offline-only' };
const response = async () => ({ ok: true, json: async () => ({ answers }) });
const noUpload = async () => { throw new Error('Must not send this input'); };
const cases = [
  ['valid suggestion', await reviewDiff({ ...input, fetchImpl: response }), 'report_only'],
  ['missing key', await reviewDiff({ ...input, apiKey: '', fetchImpl: noUpload }), 'missing_credentials'],
  ['sensitive file', await reviewDiff({ ...input, names: 'M\0.env\0', fetchImpl: noUpload }), 'sensitive_input'],
  ['incomplete response', await reviewDiff({ ...input, fetchImpl: async () => ({ ok: true, json: async () => ({ answers: {} }) }) }), 'invalid_response'],
];
for (const [name, result, expected] of cases) {
  assert.equal(result.status, expected);
  assert.equal(exitCode(result, 'blocking'), 1);
  console.log(`${name}: ${result.status}; blocking exit=1`);
}
console.log('OFFLINE FIXTURES: four application checks passed; no upstream binary or model-quality test.');

Download the advisory implementation · Download the four-case lab

node jev-git-offline.mjs

Place both files in one directory and run with Node 20+. Expect four status lines and a final line beginning OFFLINE FIXTURES. The lab does not read a repository, write Git, contact a provider or establish model accuracy.

Continue to the Git workflow: inputs, reports and human gates →