Bohdan Triapitsyn
34d0ff7383
A diff is ordered by file path, which is almost never the order in which a change makes sense. This adds a Walkthrough surface that reorders it: the model groups related hunks into stops, explains what each group changes about behavior, and orders the stops so each builds on the last. It explains and orders; judging code stays with the existing Review action. Reviews uncommitted work (all, staged, unstaged), a branch against its base, or a pull request. Generation is always user-initiated — nothing runs on a timer, on a file change, or as a side effect of opening a panel. Invariants worth preserving: - Hunk identity is derived on the server and only there. Ids are content hashes, so an anchor that no longer resolves is proof the code it described changed, and staleness needs no heuristics. The client matches ids to ids and never recomputes them; two implementations would have to agree forever. - The digest is never truncated. A diff that does not fit the model's context is refused with an actionable reason, because a walkthrough written against half a diff reads as confident and is wrong. - Nothing disappears. Lockfiles and other generated output are excluded from the model's input by name — never by size — and everything no stop covers is listed at the end, so "have I seen all of it" stays answerable. - Cost is explicit. Results are content-addressed, so returning the working tree to an earlier state costs nothing; generation outlives its request, so a refresh detaches the client rather than discarding paid-for work, and only an explicit cancel stops it. Supporting changes to shared modules: - git: expose the existing getRangeDiff as GET /api/git listUntrackedPaths and getUntrackedDiffs. The latter resolve the repository once for a batch instead of per file, taking a panel ~340ms on an 80-file working tree. - small-model: structured output across four wire forma and abort signal, and an onOverflow policy so an oversized prompt fails loudly instead of being silently clipped. A provider remembered so the prompt-side fallback goes first next time. - models.dev metadata: surface structured_output as tri false blocks a model, a missing field does not, because the catalog omits it for roughly half of all models. Desktop and tablet only: VS Code serves Git through its these routes, and the mobile shell does not consume the surface registry. Docs: packages/docs walkthrough page in English and all eight locales.
74 lines
2.7 KiB
JavaScript
74 lines
2.7 KiB
JavaScript
import { isGeneratedArtifact } from './generated.js';
|
|
import { parseDiffFiles } from './hunks.js';
|
|
|
|
// The digest is what the model actually reads. Within what it covers there is
|
|
// no truncation: a diff that does not fit the model's context is refused
|
|
// upstream so the user can pick a roomier model, because a walkthrough written
|
|
// against a silently clipped diff is confidently wrong in a way nobody can see.
|
|
//
|
|
// The one thing it does not cover is tool-produced files (lockfiles, minified
|
|
// bundles, codegen). Those are excluded by name, not by size, and they are not
|
|
// hidden — they carry no hunk aliases, so nothing can anchor to them, and they
|
|
// surface in the uncovered tail like any other unreviewed change.
|
|
|
|
/**
|
|
* Parse sections into files and build the model-facing digest.
|
|
*
|
|
* Hunks are exposed to the model as request-local aliases (`h1`, `h2`, …)
|
|
* rather than their real ids: the aliases are far cheaper in tokens, and a
|
|
* model cannot invent a plausible-looking id for a hunk that does not exist.
|
|
*/
|
|
export function buildDigest(sections) {
|
|
const files = [];
|
|
for (const section of sections) {
|
|
const parsed = parseDiffFiles(section.patch, section.scope);
|
|
for (const file of parsed.files) {
|
|
files.push({ ...file, scope: section.scope, generated: isGeneratedArtifact(file.path) });
|
|
}
|
|
}
|
|
|
|
const idByAlias = new Map();
|
|
const aliasById = new Map();
|
|
let counter = 0;
|
|
|
|
const digestFiles = files
|
|
.filter((file) => !file.generated)
|
|
.map((file) => ({
|
|
path: file.path,
|
|
...(file.oldPath ? { oldPath: file.oldPath } : {}),
|
|
status: file.status,
|
|
...(file.scope !== 'branch' && !file.scope.startsWith('pr:') ? { scope: file.scope } : {}),
|
|
...(file.binary ? { binary: true } : {}),
|
|
hunks: file.hunks.map((hunk) => {
|
|
counter += 1;
|
|
const alias = `h${counter}`;
|
|
idByAlias.set(alias, hunk.id);
|
|
aliasById.set(hunk.id, alias);
|
|
return {
|
|
alias,
|
|
header: hunk.header,
|
|
oldLines: `${hunk.oldStart}-${hunk.oldStart + Math.max(0, hunk.oldLines - 1)}`,
|
|
newLines: `${hunk.newStart}-${hunk.newStart + Math.max(0, hunk.newLines - 1)}`,
|
|
added: hunk.added,
|
|
deleted: hunk.deleted,
|
|
patch: hunk.body,
|
|
};
|
|
}),
|
|
}));
|
|
|
|
const generatedFiles = files.filter((file) => file.generated);
|
|
|
|
return {
|
|
digest: { files: digestFiles },
|
|
files,
|
|
idByAlias,
|
|
aliasById,
|
|
// Reviewable counts: what the model is actually asked about. The excluded
|
|
// files still reach the client through `files`.
|
|
hunkCount: counter,
|
|
fileCount: digestFiles.length,
|
|
generatedFileCount: generatedFiles.length,
|
|
generatedPaths: generatedFiles.map((file) => file.path),
|
|
};
|
|
}
|