simt-dev 0.2.2 → 0.3.1

package/src/kernel/card.mjs

@@ -0,0 +1,254 @@
+// The command card: the exact commands for THIS repository, at the top of the
+// projected region (plan 0003 R10).
+//
+// The card holds the bytes a reader cannot infer. "Run the tests" is useless advice in a
+// repository whose test command is `./gradlew :app:testDebugUnitTest`; the runner, the
+// wrapper and the task name are facts about this repository, and none of them are in the
+// rules, which are the same in every repository. So the card is derived rather than
+// written: from the manifest's declared gates, the repository's own `package.json`
+// scripts, and the marker files that name its ecosystem.
+//
+// It reads committed evidence ONLY. It must never consult PATH or `node_modules`, because
+// the projected region is required to be byte-identical on two machines (plan 0003 P4,
+// R13) and a card that named whichever linter happened to be installed would differ
+// between a laptop and CI for no reason a diff could explain. Runnability is a property
+// of the machine; a command is a property of the repository.
+//
+// The focused-test entries are TEMPLATES. `{file}`, `{pkg}`, `{Test}` and `{class}` are
+// placeholders the reader fills from the file they are editing, and the label names the
+// path kind so a template is never mistaken for a command that can be pasted as-is.
+// Refining which test a given `{file}` maps to is R24's job, not R10's.
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { ECOSYSTEMS } from '../projection/manifest.mjs';
+
+/**
+ * The card's ceiling in bytes (plan 0003 R10). Over it, the least valuable lines are
+ * dropped rather than the ceiling raised: the point of the card is the bytes a reader
+ * most needs, and an unbounded card is a second copy of the rules.
+ */
+export const CARD_LIMIT_BYTES = 600;
+
+/**
+ * The verbs the card carries, in the order a reader meets them. The plan names exactly
+ * these five. A `build` command exists only where a repository declares one, so the order
+ * is a priority as well as a sequence: the most universally true verb comes first.
+ *
+ * Exported because a second reader has to agree with it: a rule may declare `card:<verb>`
+ * as the evidence that makes its line redundant (R09), and a copy of this list living in
+ * the filter would let the card name a verb the filter called unknown.
+ */
+export const CARD_VERBS = ['build', 'test', 'lint', 'format', 'typecheck'];
+
+const VERBS = CARD_VERBS;
+
+/**
+ * The order verbs are dropped in when the card is over its ceiling: the verb whose loss a
+ * reader misses least goes first. `test` is absent on purpose — a card that dropped the
+ * test command would have dropped the one command it exists to carry.
+ */
+const DROP_ORDER = ['format', 'typecheck', 'lint', 'build'];
+
+/**
+ * Build commands for ecosystems whose build entrypoint is not a package script. Keyed by
+ * a marker fact or stack tag, whichever the ecosystem is identified by. `npm` is handled
+ * before this table, because a Node repository states its own build script and stating it
+ * again here would be a second answer to the same question.
+ */
+const BUILDS = [
+  { fact: 'has-cargo-toml', command: 'cargo build' },
+  { fact: 'has-go-mod', command: 'go build ./...' },
+  { fact: 'has-nuget', command: 'dotnet build' },
+  { fact: 'has-swift-package', command: 'swift build' },
+  { fact: 'has-mix', command: 'mix compile' },
+  { stack: 'gradle', command: './gradlew build' },
+];
+
+/**
+ * One focused-test template per path kind. Entries are ordered, and the FIRST match wins,
+ * so a repository that carries more than one marker gets the more specific template:
+ * `has-uv-lock` before `has-pyproject`, `has-android-manifest` before the plain `gradle`
+ * tag, `has-deno-config` before the Node fallback. A duplicate template for the same path
+ * kind would be two answers, and the second is the wrong one.
+ */
+const FOCUSED = [
+  { kind: 'Android', when: (s, f) => f.has('has-android-manifest'), template: () => './gradlew :{module}:testDebugUnitTest --tests {class}' },
+  { kind: 'JVM', when: (s) => s.has('gradle'), template: () => './gradlew test --tests {class}' },
+  { kind: 'Maven', when: (s, f) => f.has('has-maven-pom'), template: () => './mvnw test -Dtest={class}' },
+  { kind: 'Go package', when: (s, f) => f.has('has-go-mod'), template: () => 'go test ./{pkg} -run {Test}' },
+  { kind: 'Rust', when: (s, f) => f.has('has-cargo-toml'), template: () => 'cargo test {name}' },
+  { kind: 'Python', when: (s, f) => f.has('has-uv-lock'), template: () => 'uv run -m pytest {file}::{test}' },
+  { kind: 'Python', when: (s, f) => f.has('has-pyproject') || f.has('has-requirements'), template: () => 'pytest {file}::{test}' },
+  { kind: '.NET', when: (s, f) => f.has('has-nuget'), template: () => 'dotnet test --filter {test}' },
+  { kind: 'Swift', when: (s, f) => f.has('has-swift-package'), template: () => 'swift test --filter {test}' },
+  { kind: 'Deno', when: (s, f) => f.has('has-deno-config'), template: () => 'deno test {file}' },
+  { kind: 'Ruby', when: (s, f) => f.has('has-gemfile'), template: () => 'bundle exec rspec {file}' },
+  { kind: 'Dart', when: (s, f) => f.has('has-pubspec'), template: () => 'dart test {file}' },
+  { kind: 'Elixir', when: (s, f) => f.has('has-mix'), template: () => 'mix test {file}' },
+  {
+    kind: 'Node',
+    when: (s) => s.has('node'),
+    // The repo's own runner decides the shape. A repository whose test script is vitest
+    // or jest takes a file argument through the script; one with no such script gets the
+    // built-in runner, which is the only answer that needs nothing installed to already
+    // be true. `npm test -- <file>` is the ADR-010 shape (never `npx`).
+    template: (s, f, scripts) => {
+      const test = scripts?.test ?? '';
+      return /vitest|jest/.test(test) ? 'npm test -- {file}' : 'node --test {file}';
+    },
+  },
+];
+
+/**
+ * Verbs for ecosystems the gate table does not seed, used by the card alone.
+ *
+ * Python is the case, and it is not an oversight that the tool seeds no Python gate: the
+ * runner genuinely varies (uv, poetry, tox, nox, a project wrapper), so a seeded gate would
+ * be wrong in the repositories it guessed about. The card can still name the one command a
+ * repository has proved: a committed `uv.lock` means uv, and the uv profile is explicit
+ * that `uv run -m pytest` is correct and `uv run pytest` is not — the console entrypoint
+ * can miss the `uv` import path and run a different copy of the package than the one under
+ * test. Without a lockfile the card names the plain runner, which is what the python
+ * profile assumes when it says "no `pytest.skip`".
+ */
+const CARD_FALLBACKS = [
+  { when: (s, f) => f.has('has-uv-lock'), commands: { test: 'uv run -m pytest' } },
+  { when: (s, f) => f.has('has-pyproject') || f.has('has-requirements'), commands: { test: 'pytest' } },
+];
+
+/** A non-empty string, or null. Guards JSON that is present but not a command. */
+function text(value) {
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : null;
+}
+
+/** The repository's own `package.json` scripts, or an empty map. */
+async function readScripts(root) {
+  try {
+    const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+    return pkg && typeof pkg.scripts === 'object' && pkg.scripts ? pkg.scripts : {};
+  } catch {
+    // No package.json is a normal shape (a Python or Go repository), and an unreadable one
+    // is reported by the manifest path. Either way the card has no scripts to draw on.
+    return {};
+  }
+}
+
+/**
+ * The command for one verb, or null when this repository proves none.
+ *
+ * Precedence is deliberate and mirrors the manifest's own. A declared `gates.commands`
+ * entry is the repository naming its own program and wins over anything inferred; a
+ * `package.json` script is the repository's declared entrypoint (`npm run <verb>`); and
+ * the ecosystem table is the canonical command for a marker that is present but whose
+ * repository has declared nothing. The last is the same table the tool seeds gates from,
+ * so the card and the gate list cannot name two different commands for one repository.
+ */
+function resolveVerb(verb, { manifest, facts, stack, scripts }) {
+  const declared = text(manifest?.gates?.commands?.[verb]);
+  if (declared) return declared;
+
+  // The script a verb maps to. `format` is a staged gate rather than a script gate, so its
+  // two conventional script names are tried directly — `format:check` first, because that
+  // is the one a hook and CI run, which is what the card is reporting.
+  const scriptNames = verb === 'format' ? ['format:check', 'format'] : [verb];
+  for (const name of scriptNames) {
+    if (text(scripts?.[name])) return `npm run ${name}`;
+  }
+
+  if (verb === 'build') {
+    if (text(scripts?.build)) return 'npm run build';
+    for (const row of BUILDS) {
+      if (row.fact && facts.has(row.fact)) return row.command;
+      if (row.stack && stack.has(row.stack)) return row.command;
+    }
+    return null;
+  }
+
+  for (const eco of ECOSYSTEMS) {
+    if (!facts.has(eco.fact)) continue;
+    const command = text(eco.commands?.[verb]);
+    if (command) return command;
+  }
+  for (const row of CARD_FALLBACKS) {
+    if (!row.when(stack, facts, scripts)) continue;
+    const command = text(row.commands?.[verb]);
+    if (command) return command;
+  }
+  return null;
+}
+
+/** The text a set of lines renders to. Kept beside `commandCard` so both agree. */
+function renderCard(lines) {
+  const body = lines.map((l) => `- ${l.label}: \`${l.command}\``).join('\n');
+  return `Commands for this repository:\n\n${body}`;
+}
+
+function renderBytes(lines) {
+  return lines.length === 0 ? 0 : Buffer.byteLength(renderCard(lines));
+}
+
+/**
+ * The index of the next line to drop, or -1 when nothing may be dropped.
+ *
+ * Verbs drop in `DROP_ORDER`. Focused templates drop only after every verb, from the last
+ * first, because a focused template is the plan's headline content and a repository with
+ * several is the one case where dropping one still leaves the reader a template.
+ */
+function pickDroppable(lines) {
+  for (const verb of DROP_ORDER) {
+    const at = lines.findIndex((l) => l.verb === verb);
+    if (at !== -1) return at;
+  }
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].verb === 'focused') return i;
+  }
+  return -1;
+}
+
+/**
+ * Build the card for one repository.
+ *
+ * @param {{root: string, manifest?: object, stack?: string[], facts?: string[]}} input
+ * @returns {Promise<{text: string, bytes: number, lines: {label: string, command: string,
+ *   verb: string}[], dropped: string[]}>}
+ */
+export async function commandCard({ root, manifest = null, stack = [], facts = [] }) {
+  const factSet = new Set(facts);
+  const stackSet = new Set(stack);
+  const scripts = await readScripts(root);
+
+  const lines = [];
+  for (const verb of VERBS) {
+    const command = resolveVerb(verb, { manifest, facts: factSet, stack: stackSet, scripts });
+    if (command) lines.push({ label: verb, command, verb });
+  }
+  for (const entry of FOCUSED) {
+    if (!entry.when(stackSet, factSet, scripts)) continue;
+    // One template per path kind: `has-uv-lock` and `has-pyproject` both match a uv repo,
+    // and two Python lines would be two answers with the second one wrong.
+    if (lines.some((l) => l.kind === entry.kind)) continue;
+    lines.push({
+      label: `focused test (${entry.kind})`,
+      command: entry.template(stackSet, factSet, scripts),
+      kind: entry.kind,
+      verb: 'focused',
+    });
+  }
+
+  // Fit under the ceiling by dropping whole lines, least valuable first. Nothing is cut
+  // silently: `dropped` names every line removed so the caller can say so, because a card
+  // that quietly lost a command is a card a reader cannot tell is incomplete.
+  const dropped = [];
+  let kept = lines.slice();
+  while (renderBytes(kept) > CARD_LIMIT_BYTES) {
+    const victim = pickDroppable(kept);
+    if (victim === -1) break;
+    dropped.push(kept[victim].label);
+    kept = kept.filter((_, i) => i !== victim);
+  }
+
+  const text = kept.length > 0 ? renderCard(kept) : '';
+  return { text, bytes: Buffer.byteLength(text), lines: kept, dropped };
+}

package/src/kernel/checks.mjs

@@ -0,0 +1,378 @@
+// A marked line is enforced by a checker, so the projection keeps its name and not
+// its prose (plan 0003 R19, ADR-088).
+//
+// The unit is one list item, including the wrapped lines under it. A blank-line
+// block would be the whole section: the core rules are consecutive bullets, and
+// marking one of them must not take its neighbours with it.
+//
+// `import-direction` records nothing about which way an import may point. The
+// index has the edges (R21). A direction still has to be named before the prose
+// can leave, or the line would say Enforced and nothing would be enforcing it.
+
+import { execFile } from 'node:child_process';
+import { readFile, stat } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
+
+const exec = promisify(execFile);
+
+export const CHECK_MARKER = 'simt-check';
+
+/** Checkers this tool can run. `import-direction` is recognised and waits on a named direction. */
+const RUNNABLE = new Set(['max-file-lines', 'forbid-regex', 'forbidden-path-edit', 'required-file']);
+
+const MARKER = /<!--\s*simt-check:\s*([^>]*?)\s*-->/g;
+const MARKER_AT = /\s*<!--\s*simt-check:\s*[^>]*?-->/g;
+const HAS_MARKER = /<!--\s*simt-check:/;
+const ITEM_START = /^(\s*)(?:[-*]|\d+\.)\s+/;
+
+/** ADR-005's two tiers, used when a repository has not named its own. */
+const DEFAULT_WARN = 400;
+const DEFAULT_ERROR = 1000;
+
+/**
+ * What is wrong with the markers in a body, or null. The same field as a
+ * frontmatter defect, so `check` needs no second way to see a broken rule.
+ */
+export function checkDefect(body) {
+  for (const unit of units(body)) {
+    if (fenced(unit)) continue;
+    const found = markersIn(unit);
+    if (found.length === 0) continue;
+    if (found.length > 1) {
+      return `carries more than one ${CHECK_MARKER} marker on one line; one line is one checker`;
+    }
+    const parsed = parseCheck(found[0]);
+    if (parsed.error) return parsed.error;
+  }
+  return null;
+}
+
+/**
+ * Replace each runnable check with one `Enforced:` line. A body with no marker
+ * is returned unchanged, so a rule nobody marked does not move a byte.
+ *
+ * @returns {{body: string, enforced: {name: string}[], changed: boolean}}
+ */
+export function foldChecks(body) {
+  if (checkDefect(body) !== null || !HAS_MARKER.test(body)) {
+    return { body, enforced: [], changed: false };
+  }
+  const enforced = [];
+  const kept = [];
+  for (const unit of units(body)) {
+    const found = fenced(unit) ? [] : markersIn(unit);
+    if (found.length === 0) {
+      kept.push(unit);
+      continue;
+    }
+    const parsed = parseCheck(found[0]);
+    if (!parsed.runnable) {
+      kept.push(stripMarkers(unit));
+      continue;
+    }
+    const indent = ITEM_START.exec(unit)?.[1] ?? '';
+    const bullet = ITEM_START.test(unit) ? '- ' : '';
+    kept.push(`${indent}${bullet}Enforced: ${parsed.name}`);
+    enforced.push({ name: parsed.name });
+  }
+  const next = kept.join('\n');
+  return { body: next, enforced, changed: next !== body };
+}
+
+/**
+ * Run the checkers the selected rules declare. A directory that is not a git
+ * repository has no tracked tree and no diff, so the checkers that need one
+ * report nothing rather than failing a repository they cannot see.
+ *
+ * @param {string} root
+ * @param {{id: string, source: string, body: string}[]} rules
+ * @param {object|null} manifest
+ */
+export async function runDeclaredChecks(root, rules, manifest) {
+  const declared = [];
+  const seen = new Set();
+  for (const rule of rules) {
+    if (checkDefect(rule.body) !== null) continue;
+    for (const unit of units(rule.body)) {
+      if (fenced(unit)) continue;
+      for (const expr of markersIn(unit)) {
+        const parsed = parseCheck(expr);
+        if (parsed.error) continue;
+        const key = `${parsed.name}\0${parsed.arg}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        declared.push({ ...parsed, source: rule.source });
+      }
+    }
+  }
+  const findings = [];
+  for (const check of declared) {
+    findings.push(...(await runOne(root, check, manifest)));
+  }
+  return findings;
+}
+
+async function runOne(root, check, manifest) {
+  if (check.name === 'import-direction') {
+    return [{
+      file: check.source,
+      status: 'check-unbuilt',
+      detail: 'import-direction has no direction to enforce; the index records imports and no rule names which way they may point',
+      remedy: 'leave the instruction in the rule until a direction is named',
+    }];
+  }
+  if (check.name === 'max-file-lines') return fileLines(root, check, manifest);
+  if (check.name === 'required-file') return requiredFile(root, check);
+  const diff = await workDiff(root);
+  if (diff === null) return [];
+  if (check.name === 'forbid-regex') return forbidRegex(check, diff);
+  return forbiddenPath(check, diff);
+}
+
+async function fileLines(root, check, manifest) {
+  const limits = manifest?.limits?.fileLines ?? {};
+  const generated = limits.generated;
+  if (generated !== undefined && !Array.isArray(generated)) {
+    return [{
+      file: 'simt.json',
+      status: 'invalid',
+      detail: 'limits.fileLines.generated must be a list of paths',
+      remedy: 'name each generated path, or remove the key',
+    }];
+  }
+  const warnAt = Number.isInteger(limits.warn) ? limits.warn : DEFAULT_WARN;
+  const errorAt = Number.isInteger(limits.error) ? limits.error : DEFAULT_ERROR;
+  const files = await tracked(root);
+  if (files === null) return [];
+  const findings = [];
+  const prefixes = Array.isArray(generated) ? generated.filter((g) => typeof g === 'string' && g !== '') : [];
+  for (const rel of files) {
+    // A committed dependency is not a file this repository wrote. Counting it
+    // fails every install of this package, because the package's own sources
+    // are longer than the ceiling the consumer declared.
+    if (rel.split('/').includes('node_modules')) continue;
+    if (exempt(rel, prefixes)) continue;
+    let text;
+    try {
+      text = await readFile(resolve(root, rel));
+    } catch {
+      continue;
+    }
+    if (text.includes(0)) continue;
+    const source = text.toString('utf8');
+    // The region marker is this tool naming itself as the generator. A path the
+    // repository names is the other exemption; a filename that looks generated is not.
+    if (source.includes('simt:generated')) continue;
+    const lines = lineCount(source);
+    if (lines > errorAt) {
+      findings.push({
+        file: rel,
+        status: 'file-lines',
+        detail: `${lines} lines, over the ceiling of ${errorAt}`,
+        remedy: 'split the file, or name its generator in limits.fileLines.generated',
+      });
+    } else if (lines > warnAt) {
+      findings.push({
+        file: rel,
+        status: 'file-lines-warn',
+        detail: `${lines} lines, over the review trigger of ${warnAt}`,
+        remedy: 'say why the file stays whole, or split it',
+      });
+    }
+  }
+  return findings;
+}
+
+async function requiredFile(root, check) {
+  const full = resolve(root, check.arg);
+  const rel = relative(root, full);
+  if (rel.startsWith('..') || rel.includes(`..${sep}`)) {
+    return [{
+      file: check.source,
+      status: 'required-file',
+      detail: `${check.arg} is outside the repository`,
+      remedy: 'name a path inside the repository',
+    }];
+  }
+  const info = await stat(full).catch(() => null);
+  if (info?.isFile()) return [];
+  return [{
+    file: check.arg,
+    status: 'required-file',
+    detail: 'a rule requires this file and it is absent',
+    remedy: `add ${check.arg}`,
+  }];
+}
+
+function forbidRegex(check, diff) {
+  let pattern;
+  try {
+    pattern = new RegExp(check.arg);
+  } catch {
+    return [];
+  }
+  const findings = [];
+  for (const file of diff.files) {
+    if (file.added.some((line) => pattern.test(line))) {
+      findings.push({
+        file: file.path,
+        status: 'forbid-regex',
+        detail: `an added line matches ${check.arg}`,
+        remedy: 'take the match out of the change',
+      });
+    }
+  }
+  return findings;
+}
+
+function forbiddenPath(check, diff) {
+  const hit = diff.files.find((file) => file.path === check.arg || file.path.startsWith(`${check.arg}/`));
+  if (!hit) return [];
+  return [{
+    file: hit.path,
+    status: 'forbidden-path',
+    detail: `${check.arg} is a path a rule says not to edit`,
+    remedy: 'edit the source the rule names, and leave this path unchanged',
+  }];
+}
+
+function parseCheck(expr) {
+  const parts = String(expr).trim().split(/\s+/);
+  const name = parts[0] ?? '';
+  const arg = parts.slice(1).join(' ');
+  if (name === 'import-direction') {
+    if (arg !== '') return { error: `${CHECK_MARKER} import-direction takes no argument` };
+    return { name, arg: '', runnable: false };
+  }
+  if (!RUNNABLE.has(name)) {
+    return { error: `${CHECK_MARKER} names "${name}", which is not a checker; the checkers are ${[...RUNNABLE, 'import-direction'].sort().join(', ')}` };
+  }
+  if (name !== 'max-file-lines' && arg === '') {
+    return { error: `${CHECK_MARKER} ${name} needs its argument` };
+  }
+  if (name === 'max-file-lines' && arg !== '') {
+    return { error: `${CHECK_MARKER} max-file-lines takes the repository's limits.fileLines, not an argument` };
+  }
+  if (name === 'forbid-regex') {
+    try {
+      RegExp(arg);
+    } catch (error) {
+      return { error: `${CHECK_MARKER} forbid-regex is not a regular expression (${error.message})` };
+    }
+  }
+  if ((name === 'forbidden-path-edit' || name === 'required-file') && (arg.startsWith('/') || arg.split('/').includes('..'))) {
+    return { error: `${CHECK_MARKER} ${name} needs a path inside the repository` };
+  }
+  return { name, arg, runnable: true };
+}
+
+function fenced(unit) {
+  return /^\s*(```|~~~)/.test(unit);
+}
+
+function markersIn(unit) {
+  return [...unit.matchAll(MARKER)].map((m) => m[1]);
+}
+
+function stripMarkers(unit) {
+  return unit.replace(MARKER_AT, '').replace(/[ \t]+$/gm, '');
+}
+
+/** Lines of a body, fences kept whole, list items split from their neighbours. */
+function units(body) {
+  const lines = String(body ?? '').split('\n');
+  const out = [];
+  let fenced = false;
+  let current = [];
+  const flush = () => {
+    if (current.length > 0) out.push(current.join('\n'));
+    current = [];
+  };
+  for (const line of lines) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      if (!fenced) flush();
+      current.push(line);
+      fenced = !fenced;
+      if (!fenced) flush();
+      continue;
+    }
+    if (fenced) {
+      current.push(line);
+      continue;
+    }
+    if (line.trim() === '') {
+      flush();
+      out.push(line);
+      continue;
+    }
+    if (ITEM_START.test(line) && current.length > 0) flush();
+    current.push(line);
+  }
+  flush();
+  return out;
+}
+
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  const n = text.split('\n').length;
+  return text.endsWith('\n') ? n - 1 : n;
+}
+
+function exempt(rel, prefixes) {
+  return prefixes.some((prefix) => rel === prefix || rel.startsWith(prefix.endsWith('/') ? prefix : `${prefix}/`));
+}
+
+async function tracked(root) {
+  try {
+    const { stdout } = await exec('git', ['ls-files', '-z'], { cwd: root });
+    return stdout.split('\0').filter((p) => p !== '');
+  } catch {
+    return null;
+  }
+}
+
+async function workDiff(root) {
+  let text = '';
+  try {
+    const { stdout } = await exec('git', ['diff', '--no-ext-diff', '--unified=0', 'HEAD'], { cwd: root, maxBuffer: 8 * 1024 * 1024 });
+    text = stdout;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    text = typeof error.stdout === 'string' ? error.stdout : '';
+  }
+  const files = parseDiff(text);
+  let untracked = [];
+  try {
+    const { stdout } = await exec('git', ['ls-files', '--others', '--exclude-standard', '-z'], { cwd: root });
+    untracked = stdout.split('\0').filter((p) => p !== '');
+  } catch {
+    return { files };
+  }
+  for (const path of untracked) {
+    let raw;
+    try {
+      raw = await readFile(resolve(root, path));
+    } catch {
+      continue;
+    }
+    if (raw.includes(0)) continue;
+    files.push({ path, added: raw.toString('utf8').split('\n') });
+  }
+  return { files };
+}
+
+function parseDiff(text) {
+  const files = [];
+  let current = null;
+  for (const line of text.split('\n')) {
+    const header = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+    if (header) {
+      current = { path: header[2], added: [] };
+      files.push(current);
+      continue;
+    }
+    if (current && line.startsWith('+') && !line.startsWith('+++')) current.added.push(line.slice(1));
+  }
+  return files;
+}