ts-axi 0.1.11 → 0.1.13

package/dist/src/commands/impact.js

@@ -3,7 +3,7 @@ import { sourceFs } from "../fs.js";
 import { basename, dirname, join, relative, sep } from "node:path";
 import ts from "typescript";
 import { bool, flag, intFlag, parseArgs, parseFields } from "../args.js";
-import { changedRanges, parseUnifiedDiff } from "../diff.js";
+import { changedRanges, headRevOfRange, parseUnifiedDiff } from "../diff.js";
 import { AxiError, usageError } from "../errors.js";
 import { diffNameStatus, diffUnified, isGitRepo, resolveBaseRev, showFile, untrackedFiles } from "../git.js";
 import { allocateBudget, classifyFile, compareChanges, formatRanges, inRanges, localOnlyLine, matchKey, reverseApply, wordMatches, } from "../impact.js";
@@ -25,8 +25,8 @@ input:
   (none) = working tree vs HEAD (staged + unstaged + untracked); --staged = index vs HEAD
   <git-range> = any git diff range (main...HEAD, abc123, v1..v2); - = unified diff on stdin (needs the after side checked out)
   analysis is of the current checkout - for a range whose head is not the working tree, check that head out first
-flags[8]:
-  --staged, --via (adds References through an interface or base member to refs[n] with a via column), --depth <1-3> (callers_depthN[n]{file,count} for N > 1), --limit <1-${MAX_LIMIT}> (default ${DEFAULT_LIMIT} ref rows across the report), --grep (adds unresolved[n]{file,line,context} - textual matches that are not References; also searches .astro/.vue/.svelte/.mdx/.html), --test-glob <glob> (repeatable), --fields <kind,exported,refs_total,via,files,tests|all> (extra changed[n] columns), -P <tsconfig>, --json
+flags[9]:
+  --staged, --size (adds size{files,hunks,lines_added,lines_removed,patch_chars,exported_signature_changes,removed_symbols} - hunks are counted at zero context for a git source, as given for -; untracked files count as added),--via (adds References through an interface or base member to refs[n] with a via column), --depth <1-3> (callers_depthN[n]{file,count} for N > 1), --limit <1-${MAX_LIMIT}> (default ${DEFAULT_LIMIT} ref rows across the report), --grep (adds unresolved[n]{file,line,context} - textual matches that are not References; also searches .astro/.vue/.svelte/.mdx/.html), --test-glob <glob> (repeatable), --fields <kind,exported,refs_total,via,files,tests|all> (extra changed[n] columns), -P <tsconfig>, --json
 output:
   base, head, changes (count), changed[n]{symbol,change,at,refs_outside} by default; --fields adds columns in place, --fields all gives {symbol,kind,change,exported,at,refs_total,refs_outside,via,files,tests}
   change = signature | removed | type | added | body | modified (before unavailable) - riskiest first
@@ -41,10 +41,11 @@ output:
   skipped[n]{file,reason} = files in the diff that were not analysed (.astro, .json, outside the Project)
   tests: 0 on an exported signature or body change = no Test file references it (columns from --fields exported,tests)
   scope = in a monorepo without -P the program is the touched files + two levels of importers (scope_partial: true when capped)
-examples[5]:
+examples[6]:
   ts-axi impact
   ts-axi impact --staged
   ts-axi impact main...HEAD
+  ts-axi impact main...HEAD --size
   ts-axi impact HEAD~3 --depth 2 --grep
   bb-axi pr diff 42 --raw | ts-axi impact -
 `;
@@ -56,14 +57,24 @@ const SPECS = [
     { name: "--grep", boolean: true },
     { name: "--test-glob", repeatable: true },
     { name: "--fields" },
+    { name: "--size", boolean: true },
     { name: "-P" },
 ];
 // Opt-in columns of changed[n]; the default keeps symbol, change, at, refs_outside.
 const IMPACT_FIELDS = ["kind", "exported", "refs_total", "via", "files", "tests"];
 const OPT_IN = new Set(IMPACT_FIELDS);
-async function readStdin() {
+function diffSize(parsed, text) {
+    return {
+        files: parsed.length,
+        hunks: parsed.reduce((n, f) => n + f.hunks.length, 0),
+        lines_added: parsed.reduce((n, f) => n + f.hunks.reduce((m, h) => m + h.added.length, 0), 0),
+        lines_removed: parsed.reduce((n, f) => n + f.hunks.reduce((m, h) => m + h.removed.length, 0), 0),
+        patch_chars: text.length,
+    };
+}
+export async function readStdin(command = "impact", example = "git diff -U0 | ts-axi impact -") {
     if (process.stdin.isTTY) {
-        throw usageError("`impact -` reads a unified diff from stdin and nothing was piped", ["git diff -U0 | ts-axi impact -"]);
+        throw usageError(`\`${command} -\` reads a unified diff from stdin and nothing was piped`, [example]);
     }
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -79,16 +90,6 @@ function readText(abs) {
         return null;
     }
 }
-/** Right side of a range; undefined when git diffs it against the working tree (`abc123`). */
-function headOfRange(range) {
-    const triple = range.indexOf("...");
-    if (triple > 0)
-        return range.slice(triple + 3) || "HEAD";
-    const double = range.indexOf("..");
-    if (double > 0)
-        return range.slice(double + 2) || "HEAD";
-    return undefined;
-}
 async function gitInput(cwd, root, range, staged) {
     if (!(await isGitRepo(cwd))) {
         throw new AxiError("not a git repository - impact needs git or a diff on stdin", "GIT_ERROR", [
@@ -97,8 +98,9 @@ async function gitInput(cwd, root, range, staged) {
     }
     const [diffText, names] = await Promise.all([diffUnified(cwd, range, staged), diffNameStatus(cwd, range, staged)]);
     const parsed = parseUnifiedDiff(diffText);
+    const size = diffSize(parsed, diffText);
     const base = staged ? "HEAD" : await resolveBaseRev(cwd, range);
-    const headRev = staged ? "" : range !== undefined ? headOfRange(range) : undefined;
+    const headRev = staged ? "" : range !== undefined ? headRevOfRange(range) : undefined;
     const files = [];
     for (const diff of parsed) {
         const { after, before } = changedRanges(diff);
@@ -113,16 +115,23 @@ async function gitInput(cwd, root, range, staged) {
                 continue;
             const lines = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
             files.push({ path, status: "added", after: lines > 0 ? [[1, lines]] : [], before: [], afterText: text, beforeText: null });
+            // Untracked files count as added, one hunk each; they are not in patch_chars.
+            size.files++;
+            size.hunks += lines > 0 ? 1 : 0;
+            size.lines_added += lines;
         }
     }
     const seen = new Set(parsed.map((d) => d.path));
+    const noText = names.filter((n) => !seen.has(n.path) && n.status !== "deleted").map((n) => n.path);
+    size.files += noText.length;
     return {
         base,
         head: staged ? "index" : headRev ?? "working tree",
         ...(headRev !== undefined ? { headRev } : {}),
         files,
-        noText: names.filter((n) => !seen.has(n.path) && n.status !== "deleted").map((n) => n.path),
+        noText,
         missing: [],
+        size,
     };
 }
 function stdinInput(text, root) {
@@ -139,7 +148,7 @@ function stdinInput(text, root) {
         const beforeText = diff.status === "added" ? null : reverseApply(afterText ?? "", diff.hunks) ?? undefined;
         files.push({ path: diff.path, ...(diff.oldPath ? { oldPath: diff.oldPath } : {}), status: diff.status, after, before, afterText, beforeText });
     }
-    return { base: "stdin diff", head: "working tree", files, noText: [], missing };
+    return { base: "stdin diff", head: "working tree", files, noText: [], missing, size: diffSize(parseUnifiedDiff(text, { binary: true }), text) };
 }
 function isSourcePath(path) {
     return SOURCE_EXTENSIONS.some((ext) => path.endsWith(ext));
@@ -270,6 +279,27 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
     }
     return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 }
+/** Whole-word matches of `name` in the Project files, one row per line: the fallback when no Declaration matches. */
+export function textualScan(opened, name) {
+    const rows = [];
+    sourceFs().prefetch(opened.index.files);
+    for (const abs of opened.index.files) {
+        const text = opened.index.text(abs);
+        if (text === undefined || !text.includes(name))
+            continue;
+        let last = 0;
+        for (const m of wordMatches(text, name)) {
+            if (m.line === last)
+                continue;
+            last = m.line;
+            rows.push({ file: opened.index.rel(abs), line: m.line, context: contextOf(lineOf(text, m.line), m.col) });
+        }
+    }
+    return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
+export function textualScanHint(label, matches) {
+    return `Run \`ts-axi refs ${label} --grep\` for ${matches} textual matches`;
+}
 /** Whether a whole-word count of the name says anything: not for router-called or by-name-injected members (`injected`). */
 export function isTextualCandidate(decl) {
     return decl?.injected !== true;
@@ -297,9 +327,66 @@ export function isUntyped(opened, decl, file) {
         return false;
     return decl?.nameless === true || opened.index.project.implicit || (file !== undefined && /\.[mc]?jsx?$/.test(file));
 }
-/** A non-exported, non-member, identifier-named Declaration: only its own file can name it. */
-export function isPlainLocal(decl) {
-    return decl !== undefined && !decl.exported && !decl.nameless && decl.parentName === undefined;
+/** The identifier starting at `pos`. */
+function identifierAt(node, pos, sf) {
+    if (ts.isIdentifier(node) && node.getStart(sf) === pos)
+        return node;
+    return ts.forEachChild(node, (child) => (child.pos <= pos && pos < child.end ? identifierAt(child, pos, sf) : undefined));
+}
+/** Names a CommonJS file hands out (`module.exports = { a, b: c }`, `exports.x = d`); undefined when not CommonJS. */
+function commonJsExports(sf) {
+    const names = new Set();
+    let cjs = /\brequire\s*\(/.test(sf.text);
+    // Values only: identifiers used inside exported function bodies do not leave the file.
+    const collect = (expr) => {
+        let e = expr;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isIdentifier(e))
+            names.add(e.text);
+        else if (ts.isObjectLiteralExpression(e)) {
+            for (const p of e.properties) {
+                if (ts.isShorthandPropertyAssignment(p))
+                    names.add(p.name.text);
+                else if (ts.isPropertyAssignment(p))
+                    collect(p.initializer);
+                else if (ts.isSpreadAssignment(p))
+                    collect(p.expression);
+            }
+        }
+    };
+    for (const st of sf.statements) {
+        if (!ts.isExpressionStatement(st) || !ts.isBinaryExpression(st.expression) || st.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+            continue;
+        const left = st.expression.left.getText(sf).replace(/\s+/g, "");
+        if (!/^(module\.exports|exports)(\.|$)/.test(left))
+            continue;
+        cjs = true;
+        collect(st.expression.right);
+    }
+    return cjs ? names : undefined;
+}
+/**
+ * A Declaration only its own file can name: a parameter or function-scoped binding, or a non-exported top-level
+ * binding of an ES module, or of a CommonJS file whose exports never mention it. Members, object properties,
+ * string registrations and script globals are not.
+ */
+export function isPlainLocal(index, decl) {
+    if (decl === undefined || decl.exported || decl.nameless || decl.parentName !== undefined)
+        return false;
+    const sf = index.sourceFile(index.abs(decl.file));
+    const id = sf && identifierAt(sf, decl.namePos, sf);
+    if (!sf || !id)
+        return false;
+    const owner = id.parent;
+    if (ts.isPropertyAssignment(owner) || ts.isShorthandPropertyAssignment(owner) || ts.isMethodDeclaration(owner) || ts.isPropertyAccessExpression(owner))
+        return false;
+    for (let n = owner.parent; !ts.isSourceFile(n); n = n.parent)
+        if (ts.isFunctionLike(n))
+            return true;
+    if (ts.isExternalModule(sf))
+        return true;
+    return commonJsExports(sf)?.has(decl.name) === false;
 }
 /**
  * Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded.
@@ -392,7 +479,7 @@ function capped(key, rows) {
     };
 }
 /** Quotes a value for a pasteable command. */
-function shellWord(value) {
+export function shellWord(value) {
     return /^[\w@%+=:,.\/-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
 }
 /** The same `impact` invocation with every given flag replayed, the one `extra` sets replaced by it. */
@@ -515,12 +602,22 @@ export async function impactCommand(args, ctx) {
         }
     }
     const total = declChanges.length + fileLevel.length;
+    const exportedOf = (c) => (c.after ?? c.before)?.exported ?? false;
     const header = {
         ...(warnings.length > 0 ? { warning: warnings.join("; ") } : {}),
         ...projectFields(opened),
         base: input.base,
         head: input.head,
         changes: total,
+        ...(bool(parsed, "--size")
+            ? {
+                size: {
+                    ...input.size,
+                    exported_signature_changes: declChanges.filter((c) => c.change === "signature" && exportedOf(c)).length,
+                    removed_symbols: declChanges.filter((c) => c.change === "removed").length,
+                },
+            }
+            : {}),
     };
     const skipTemplates = (used) => {
         for (const f of templateInputs)
@@ -592,7 +689,7 @@ export async function impactCommand(args, ctx) {
     for (const row of rows) {
         if (!row.live || !isUntyped(opened, row.live, row.live.file))
             continue;
-        const localTo = isPlainLocal(row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
+        const localTo = isPlainLocal(opened.index, row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
         const needle = textualNeedle(row.live);
         if (!needle)
             continue;
@@ -667,7 +764,7 @@ export async function impactCommand(args, ctx) {
         if (!textNames.has(needle.text))
             textNames.set(needle.text, needle);
         const abs = opened.index.abs(decl.file);
-        if (!isPlainLocal(decl) || (localTo.has(name) && localTo.get(name) !== abs))
+        if (!isPlainLocal(opened.index, decl) || (localTo.has(name) && localTo.get(name) !== abs))
             wide.add(name);
         else
             localTo.set(name, abs);

package/dist/src/commands/refs.js

@@ -1,7 +1,7 @@
 import { relative, sep } from "node:path";
 import { bool, expectPositionals, flag, intFlag, parseArgs } from "../args.js";
 import { importerClosure } from "../importers.js";
-import { isPlainLocal, isTextualCandidate, isUntyped, textualCount, textualNeedle, textualHint, textualLine, textualMatches } from "./impact.js";
+import { isPlainLocal, isTextualCandidate, isUntyped, textualCount, textualNeedle, textualHint, textualLine, textualMatches, textualScan, textualScanHint } from "./impact.js";
 import { findOutsideProject, nearestTsconfig } from "../project.js";
 import { viaLine } from "../references.js";
 import { block, helpBlock, out } from "../render.js";
@@ -10,7 +10,7 @@ import { loadTemplates, templatesLine, templateTarget, templateUsages } from "..
 import { byDepthThenPath } from "../walk.js";
 import { detectWorkspace, isMultiProject } from "../workspace.js";
 import { isTestFile } from "../settings.js";
-import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
+import { isFunctionLike, kindFromScriptElement, parseTarget, registrationOf } from "../symbols.js";
 import { contextOf, declarationAt, filterSuffix, lineOf, MATCH_ROWS, matchRows, narrowHints, open, positionStartDir, projectFields, readFilters, useRef, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, } from "./common.js";
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
@@ -23,8 +23,8 @@ const VIA_DOC = `via_interface: n (Iface.member) = References through an interfa
   refs_total: 0 under -P in a workspace lists found_outside_project[n]{file,line} = importers outside that Project
   scope = in a monorepo without -P the program is the declaring file + its importers (scope_partial: true when the importer scan was capped)
   tsconfig: x (n referenced configs) = a references-only tsconfig expanded to the configs it references
-  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects; a state counts its full dotted name as a whole token, templates included; not for a state's resolve keys and hooks - injected by name, not imported); 'n matches in this file' for a non-exported local; above refs_total = uses the checker cannot resolve - see refs --grep
-  templates: n usages in m files = template uses (.html .htm .ejs .hbs .njk .pug) of a directive or component (<wap-select / wap-select / data-wap-select), its bindings (fallback-display-property= on that tag), a controller (ng-controller) or a filter (| money); refs --grep lists them in unresolved`;
+  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects; a state counts its full dotted name as a whole token, templates included; not for a state's resolve keys and hooks - injected by name, not imported); 'n matches in this file' only for a real local (a parameter, a binding inside a function or IIFE, a non-exported top-level binding of an ES module or of a CommonJS file whose module.exports never hands it out) - members, object properties and script globals count Project-wide; above refs_total = uses the checker cannot resolve - see refs --grep
+  templates: n usages in m files = template uses (.html .htm .ejs .hbs .njk .pug) of a directive or component (<wap-select / wap-select / data-wap-select), its bindings (fallback-display-property= on that tag), a controller (ng-controller) or a filter (| money) - also for a function registered by identifier (.directive('fancyBox', fancyBox)), under the registered name; refs --grep lists them in unresolved`;
 export const REFS_HELP = `usage: ts-axi refs <name | Class.member | path:line[:col]> [flags]
 flags[13]:
   ${SHARED_FLAGS}
@@ -34,7 +34,9 @@ flags[13]:
 output:
   symbol, kind, declared_at, refs_total, files, tests, refs[n]{file,line,context} (Declarations excluded), elapsed_ms
   ${VIA_DOC}
-  note = the name is registered by a string ('Name' in .controller('Name', fn)) - its uses are textual; add --grep
+  note = the name is registered by a string ('Name' in .controller('Name', fn), or fn a same-file function named by identifier) - its uses are textual; add --grep
+  matches: 0 = no Declaration of the name; help counts its whole-word matches in Project files, and --grep lists them in unresolved with note 'no declaration found - textual matches only'
+  path:line = the declaration that starts the line (a function before its parameters, a property before its value's parameters; siblings like 'const a = 1, b = 2' list identifiers - add :col)
   an ambiguous name lists matches[n] (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms; nothing is analysed
 examples[4]:
   ts-axi refs User.save
@@ -111,8 +113,23 @@ async function run(args, ctx, invoked) {
                     `Run \`ts-axi ${name} ${outside[0].file}:${outside[0].nameLine}\` to use the nearest tsconfig of that file`,
                 ]));
             }
+            // No Declaration, but the name may still be written: an untyped property set up elsewhere.
+            const text = f.fuzzy ? [] : textualScan(opened, target.member ?? target.name);
+            if (show.grep) {
+                return out(block({
+                    ...warning,
+                    matches: 0,
+                    note: "no declaration found - textual matches only",
+                    unresolved: text.length === 0 ? 0 : text.slice(0, limit),
+                    ...(text.length > limit ? { unresolved_total: text.length } : {}),
+                }), helpBlock([
+                    ...(text.length > limit ? [`Showing ${limit} of ${text.length}; run \`ts-axi refs ${label} --grep --limit ${Math.min(MAX_LIMIT, text.length)}\` for more`] : []),
+                    `Run \`ts-axi def ${label} --fuzzy\` for substring matches`,
+                ]));
+            }
             const suggested = suggestions(opened, target);
             return out(block({ ...warning, matches: 0, ...(suggested.length > 0 ? { did_you_mean: suggested } : {}) }), helpBlock([
+                ...(text.length > 0 ? [textualScanHint(label, text.length)] : []),
                 ...suggested.slice(0, 2).map((s) => `Run \`ts-axi ${name} ${s}\``),
                 ...(f.fuzzy ? [] : [`Run \`ts-axi def ${label} --fuzzy\` for substring matches`]),
             ]));
@@ -143,15 +160,17 @@ async function run(args, ctx, invoked) {
     }
     const { semantic, scope } = built;
     const def = semantic.definitionAt(resolved.absFile, resolved.pos);
-    const decl = resolved.decl ??
+    const found = resolved.decl ??
         (def && def.line > 0 ? declarationAt(opened.index, def.absFile, def.pos, kindFromScriptElement(def.kind)) : undefined);
+    // A function registered by identifier is its registration: templates, note and textual use the registered name.
+    const decl = (found && registrationOf(found, opened.index.declarations(opened.index.abs(found.file)))) ?? found;
     const kind = decl?.kind ?? kindFromScriptElement(def?.kind ?? semantic.quickInfo(resolved.absFile, resolved.pos)?.kind ?? "");
     const symbol = decl?.qualifiedName ?? def?.name ?? label;
     const declaredAt = decl ? `${decl.file}:${decl.nameLine}` : def && def.line > 0 ? `${def.file}:${def.line}` : "(outside the Project)";
     const header = { ...warning, ...projectFields(opened), symbol, kind, declared_at: declaredAt };
     const explicit = Boolean(project || opened.settings.project);
     const declaredFile = decl?.file ?? (def && def.line > 0 ? def.file : undefined);
-    const localFile = isPlainLocal(decl) ? opened.index.abs(decl.file) : undefined;
+    const localFile = isPlainLocal(opened.index, decl) ? opened.index.abs(decl.file) : undefined;
     const needle = textualNeedle(decl ?? symbol, kind);
     const textual = declaredFile !== undefined && needle && isUntyped(opened, decl, declaredFile) ? textualCount(opened, needle, new Map(), localFile) : undefined;
     const tplTarget = decl ? templateTarget(decl, opened.index.declarations(opened.index.abs(decl.file))) : undefined;
@@ -249,7 +268,7 @@ function unresolvedOf(opened, semantic, o, known) {
     const needle = isTextualCandidate(o.decl) ? textualNeedle(o.decl ?? o.symbol, o.kind) : undefined;
     if (!needle)
         return [];
-    return textualMatches(opened, semantic, [needle], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map(), isPlainLocal(o.decl) ? new Map([[o.decl.name, opened.index.abs(o.decl.file)]]) : new Map());
+    return textualMatches(opened, semantic, [needle], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map(), isPlainLocal(opened.index, o.decl) ? new Map([[o.decl.name, opened.index.abs(o.decl.file)]]) : new Map());
 }
 /**
  * `textual` field and, when the name occurs more often than refs_total and some matches sit on no

package/dist/src/diff.js

@@ -40,8 +40,8 @@ function parseGitHeader(rest) {
     const m = /^"?a\/(.+?)"? "?b\/(.+?)"?$/.exec(rest);
     return m ? [m[1], m[2]] : [undefined, undefined];
 }
-function finish(draft) {
-    if (draft.binary)
+function finish(draft, keepBinary) {
+    if (draft.binary && !keepBinary)
         return undefined;
     const isNew = draft.newMode || draft.minus === null;
     const isDeleted = draft.deletedMode || draft.plus === null;
@@ -62,13 +62,15 @@ function finish(draft) {
         oldPath: status === "renamed" ? oldP : undefined,
         status,
         hunks: draft.hunks,
+        ...(draft.binary ? { binary: true } : {}),
     };
 }
 /**
- * Parse git-style unified diff text. Binary files are skipped; files with no
- * hunks (pure renames, mode changes) are kept with `hunks: []`.
+ * Parse git-style unified diff text. Binary files are skipped unless `binary` is set; files
+ * with no hunks (pure renames, mode changes) are kept with `hunks: []`. Splits on `\n` only,
+ * so `\r`, U+2028 or U+2029 inside a line never shift the numbering.
  */
-export function parseUnifiedDiff(text) {
+export function parseUnifiedDiff(text, options = {}) {
     const files = [];
     let draft;
     let hunk;
@@ -78,7 +80,7 @@ export function parseUnifiedDiff(text) {
     let newNo = 0;
     const flush = () => {
         if (draft) {
-            const file = finish(draft);
+            const file = finish(draft, options.binary === true);
             if (file)
                 files.push(file);
         }
@@ -104,6 +106,7 @@ export function parseUnifiedDiff(text) {
                 continue;
             }
             if (tag === " " || line === "") {
+                hunk.context.push({ oldLine: oldNo, newLine: newNo });
                 oldNo++;
                 newNo++;
                 oldLeft--;
@@ -130,6 +133,7 @@ export function parseUnifiedDiff(text) {
                 newLines: h[4] === undefined ? 1 : Number(h[4]),
                 removed: [],
                 added: [],
+                context: [],
             };
             draft.hunks.push(hunk);
             oldLeft = hunk.oldLines;
@@ -211,3 +215,13 @@ export function baseRevOfRange(range) {
         return range;
     return range.slice(0, index) || "HEAD";
 }
+/** Right side of a range; undefined when git diffs it against the working tree (`abc123`). */
+export function headRevOfRange(range) {
+    const triple = range.indexOf("...");
+    if (triple > 0)
+        return range.slice(triple + 3) || "HEAD";
+    const double = range.indexOf("..");
+    if (double > 0)
+        return range.slice(double + 2) || "HEAD";
+    return undefined;
+}

package/dist/src/errors.js

@@ -1,5 +1,7 @@
 import { AxiError, exitCodeForError as sdkExitCode } from "axi-sdk-js";
 export { AxiError };
+/** `anchor` exit code when an anchor is not commentable; set by the handler, the output still prints. */
+export const ANCHOR_INVALID_EXIT = 3;
 /** SDK mapping: 2 for usage errors, 1 otherwise (`GIT_ERROR` included). */
 export function exitCodeForError(error) {
     return sdkExitCode(error);

package/dist/src/git.js

@@ -155,10 +155,10 @@ export async function untrackedFiles(cwd) {
     const stdout = await runOrThrow(cwd, ["ls-files", "--others", "--exclude-standard", "-z", "--full-name", ":/"]);
     return stdout.split("\0").filter((p) => p !== "");
 }
-/** Raw unified diff with zero context lines; same target rules as `diffNameStatus`. */
-export async function diffUnified(cwd, range, staged) {
+/** Raw unified diff with `context` lines around each change (default 0); same target rules as `diffNameStatus`. */
+export async function diffUnified(cwd, range, staged, context = 0) {
     const target = await diffTarget(cwd, range, staged);
-    return runOrThrow(cwd, ["diff", "-U0", "--no-color", "--no-ext-diff", "-M", ...target, "--"]);
+    return runOrThrow(cwd, ["diff", `-U${context}`, "--no-color", "--no-ext-diff", "-M", ...target, "--"]);
 }
 /** File content at `rev`, or `null` when the path does not exist there. */
 export async function showFile(cwd, rev, path) {

package/dist/src/skill.js

@@ -3,7 +3,8 @@ import { DESCRIPTION } from "./cli.js";
 // outcome-focused so it fires on code-navigation and review intents.
 export const SKILL_DESCRIPTION = "Navigate TypeScript and JavaScript code and measure change impact through the ts-axi CLI - find where a symbol is declared, " +
     "list its references and callers, outline a file, and see which other code a diff affects. Use before reading many files to find " +
-    "callers or usages of a function, class or type; use `ts-axi impact` when reviewing a diff, a pull request or your own uncommitted changes.";
+    "callers or usages of a function, class or type; use `ts-axi impact` when reviewing a diff, a pull request or your own uncommitted changes, " +
+    "and `ts-axi anchor` to check that review-comment file:line anchors are in the diff before posting them.";
 // Hard cap so a regeneration cannot re-inflate the stub with CLI-owned
 // guidance. The home view and --help output are the source of truth.
 export const MAX_SKILL_MARKDOWN_CHARS = 2000;