simt-dev 0.2.2 → 0.3.1

package/src/index/compact.mjs

@@ -0,0 +1,228 @@
+// Compaction for output this tool itself produced (R18, ADR-095).
+//
+// Failures stay whole: the name, the assertion and the location are in the
+// block that is printed. Passing tests become a count. A stream that is not
+// one of the known formats is left alone, because a summary of an unknown
+// log is how a failure disappears.
+
+/**
+ * Compact a known test report. Returns null when the text is not one.
+ *
+ * @param {string} text
+ * @returns {string|null}
+ */
+export function compactOutput(text) {
+  const report = parseReport(text);
+  if (!report) return null;
+  const lines = [`failed  ${report.failures.length}`];
+  for (const failure of report.failures) lines.push(failure);
+  lines.push(`passed  ${report.passed}`);
+  if (report.skipped > 0) lines.push(`skipped  ${report.skipped}`);
+  return lines.join('\n');
+}
+
+function parseReport(text) {
+  const raw = String(text ?? '');
+  if (!raw.trim()) return null;
+  if (/^TAP version \d+/m.test(raw) || /^(?:not )?ok \d+/m.test(raw)) {
+    const tap = parseTap(raw);
+    if (tap) return tap;
+  }
+  const vitest = parseVitest(raw);
+  if (vitest) return vitest;
+  const go = parseGo(raw);
+  if (go) return go;
+  if (/<testcase\b/.test(raw)) return parseJunit(raw);
+  return null;
+}
+
+function parseTap(text) {
+  const lines = text.split('\n');
+  const failures = [];
+  let passed = 0;
+  let skipped = 0;
+  let saw = false;
+  for (let i = 0; i < lines.length; i++) {
+    const res = /^(\s*)(not ok|ok)\s+\d+(?:\s+-\s+(.*?))?(?:\s+#\s*(SKIP|TODO)\b.*)?\s*$/i.exec(lines[i]);
+    if (!res) continue;
+    saw = true;
+    const start = i > 0 && /^\s*# Subtest:/.test(lines[i - 1]) ? i - 1 : i;
+    let end = i;
+    if (i + 1 < lines.length && /^\s+---\s*$/.test(lines[i + 1])) {
+      end = i + 1;
+      while (end + 1 < lines.length && !/^\s+\.\.\.\s*$/.test(lines[end + 1])) end++;
+      if (end + 1 < lines.length) end++;
+      i = end;
+    }
+    const block = lines.slice(start, end + 1).join('\n');
+    if (/^\s*type:\s*['"]?suite['"]?\s*$/m.test(block)) continue;
+    if (res[4]) {
+      skipped++;
+      continue;
+    }
+    if (res[2].toLowerCase() === 'not ok') failures.push(block);
+    else passed++;
+  }
+  if (!saw) return null;
+  return { failures, passed, skipped };
+}
+
+function parseVitest(text) {
+  const raw = String(text).trim();
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start === -1 || end <= start) return null;
+  let doc;
+  try {
+    doc = JSON.parse(raw.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(doc.testResults)) return null;
+  const failures = [];
+  let passed = 0;
+  let skipped = 0;
+  let saw = false;
+  for (const suite of doc.testResults) {
+    const file = typeof suite?.name === 'string' ? suite.name : '';
+    for (const assertion of suite?.assertionResults ?? []) {
+      const name = assertionName(assertion);
+      if (!name) continue;
+      saw = true;
+      const status = String(assertion.status ?? '');
+      if (status === 'passed') {
+        passed++;
+        continue;
+      }
+      if (status === 'pending' || status === 'skipped' || status === 'todo') {
+        skipped++;
+        continue;
+      }
+      if (status !== 'failed') continue;
+      const messages = Array.isArray(assertion.failureMessages) ? assertion.failureMessages.filter(Boolean) : [];
+      const location = locationIn(messages.join('\n')) || fileLocation(file, assertion.location);
+      const lines = [`not ok  ${name}`];
+      if (location) lines.push(`  location: ${location}`);
+      if (messages.length > 0) lines.push(messages.join('\n'));
+      failures.push(lines.join('\n'));
+    }
+  }
+  if (!saw) return null;
+  return { failures, passed, skipped };
+}
+
+function assertionName(assertion) {
+  const parts = [...(assertion.ancestorTitles ?? []), assertion.title].filter(Boolean);
+  if (parts.length > 0) return parts.join(' > ');
+  return String(assertion.fullName ?? '').trim();
+}
+
+function fileLocation(file, location) {
+  if (!file) return '';
+  const line = location && Number.isFinite(location.line) ? `:${location.line}` : '';
+  const column = location && Number.isFinite(location.column) ? `:${location.column}` : '';
+  return `${file}${line}${column}`;
+}
+
+function parseGo(text) {
+  const output = new Map();
+  const failures = [];
+  let passed = 0;
+  let skipped = 0;
+  let saw = false;
+  for (const line of String(text).split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) continue;
+    let ev;
+    try {
+      ev = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof ev.Action !== 'string') continue;
+    if (typeof ev.Test !== 'string' || ev.Test.length === 0) continue;
+    saw = true;
+    const id = ev.Package ? `${ev.Package} > ${ev.Test}` : ev.Test;
+    if (ev.Action === 'output' && typeof ev.Output === 'string') {
+      output.set(id, `${output.get(id) ?? ''}${ev.Output}`);
+      continue;
+    }
+    if (ev.Action === 'pass') passed++;
+    else if (ev.Action === 'skip') skipped++;
+    else if (ev.Action === 'fail') {
+      const body = (output.get(id) ?? '').trimEnd();
+      failures.push(body ? `not ok  ${id}\n${body}` : `not ok  ${id}`);
+    }
+  }
+  if (!saw) return null;
+  return { failures, passed, skipped };
+}
+
+function parseJunit(text) {
+  const failures = [];
+  let passed = 0;
+  let skipped = 0;
+  let saw = false;
+  const tagRe = /<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+  for (const match of String(text).matchAll(tagRe)) {
+    const attrs = match[1] ?? '';
+    const inner = match[2] ?? '';
+    const name = xmlAttr(attrs, 'name');
+    if (!name) continue;
+    saw = true;
+    const classname = xmlAttr(attrs, 'classname');
+    const id = classname ? `${classname} > ${name}` : name;
+    if (/<skipped\b/i.test(inner)) {
+      skipped++;
+      continue;
+    }
+    if (!/<(?:failure|error)\b/i.test(inner)) {
+      passed++;
+      continue;
+    }
+    const file = xmlAttr(attrs, 'file');
+    const line = xmlAttr(attrs, 'line');
+    const fromAttrs = file ? `${file}${line ? `:${line}` : ''}` : '';
+    const body = failureBody(inner);
+    const location = fromAttrs || locationIn(body);
+    const lines = [`not ok  ${id}`];
+    if (location) lines.push(`  location: ${location}`);
+    if (body) lines.push(body);
+    failures.push(lines.join('\n'));
+  }
+  if (!saw) return null;
+  return { failures, passed, skipped };
+}
+
+function failureBody(inner) {
+  const chunks = [];
+  const re = /<(?:failure|error)\b([^>]*)(?:\/>|>([\s\S]*?)<\/(?:failure|error)>)/gi;
+  for (const match of String(inner).matchAll(re)) {
+    const message = xmlAttr(match[1] ?? '', 'message');
+    const body = decode(match[2] ?? '').trim();
+    if (message) chunks.push(message);
+    if (body && body !== message) chunks.push(body);
+  }
+  if (chunks.length > 0) return chunks.join('\n');
+  return decode(inner).trim();
+}
+
+function locationIn(text) {
+  const match = /[\w./-]+\.(?:java|kt|py|go|mjs|js|ts|tsx):\d+(?::\d+)?/.exec(text);
+  return match ? match[0] : '';
+}
+
+function xmlAttr(attrs, key) {
+  const match = new RegExp(`\\b${key}=["']([^"']*)["']`).exec(attrs);
+  if (!match) return '';
+  return decode(match[1]).trim();
+}
+
+function decode(text) {
+  return String(text)
+    .replaceAll('&quot;', '"')
+    .replaceAll('&apos;', "'")
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&amp;', '&');
+}

package/src/index/extract.mjs

@@ -0,0 +1,331 @@
+// Line extractors for the languages the index maps (plan 0003 R21, ADR-090).
+//
+// A structural parser is more accurate and is not a dependency. These read one
+// line at a time: an export, a definition, an import. That is enough for a map
+// and an import graph, and it is the same result on every machine.
+
+const IDENT = '[A-Za-z_$][\\w$]*';
+
+const EXTS = {
+  javascript: ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'],
+  typescript: ['.ts', '.tsx', '.js', '.mjs', '.jsx'],
+  kotlin: ['.kt', '.kts'],
+  java: ['.java'],
+  python: ['.py'],
+  go: ['.go'],
+  rust: ['.rs'],
+  swift: ['.swift'],
+  dart: ['.dart'],
+  ruby: ['.rb'],
+  csharp: ['.cs'],
+};
+
+/**
+ * Symbols and import specifiers in one blob.
+ *
+ * @param {string} filePath
+ * @param {string} text
+ * @param {string} lang
+ * @returns {{symbols: object[], imports: string[]}}
+ */
+export function extract(filePath, text, lang) {
+  const fn = BY_LANG[lang];
+  if (!fn || text.includes('\0')) return { symbols: [], imports: [] };
+  const found = fn(text);
+  const symbols = [];
+  const seen = new Set();
+  for (const row of found.symbols) {
+    const key = `${row.name}\0${row.kind}\0${row.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    symbols.push({
+      path: filePath,
+      name: row.name,
+      kind: row.kind,
+      line: row.line,
+      sig: row.sig,
+      exported: row.exported ? 1 : 0,
+    });
+  }
+  symbols.sort(bySymbol);
+  return { symbols, imports: found.imports };
+}
+
+/** Import specifiers become edges. A relative one points at a tracked file when one matches. */
+export function resolveImports(filePath, imports, files, lang) {
+  const have = files instanceof Set ? files : new Set(files);
+  const edges = [];
+  const seen = new Set();
+  for (const spec of imports) {
+    const dst = resolveOne(filePath, spec, have, lang);
+    if (seen.has(dst)) continue;
+    seen.add(dst);
+    edges.push({ src: filePath, dst, kind: 'import', weight: 1 });
+  }
+  edges.sort(byEdge);
+  return edges;
+}
+
+function resolveOne(filePath, spec, files, lang) {
+  const rel = relativeSpec(spec);
+  if (rel === null) return spec;
+  const dir = filePath.includes('/') ? filePath.slice(0, filePath.lastIndexOf('/')) : '';
+  const base = slash(dir, rel);
+  const candidates = [base];
+  const dot = base.lastIndexOf('.');
+  const bare = dot > base.lastIndexOf('/') ? null : base;
+  if (bare !== null) {
+    for (const ext of EXTS[lang] ?? []) {
+      candidates.push(bare + ext, `${bare}/index${ext}`);
+    }
+  }
+  for (const candidate of candidates) {
+    if (files.has(candidate)) return candidate;
+  }
+  return spec;
+}
+
+function relativeSpec(spec) {
+  if (spec.startsWith('./') || spec.startsWith('../')) return spec;
+  if (!spec.startsWith('.')) return null;
+  let dots = 0;
+  while (spec[dots] === '.') dots += 1;
+  const rest = spec.slice(dots).replaceAll('.', '/');
+  let prefix = '.';
+  for (let i = 1; i < dots; i += 1) prefix += '/..';
+  return rest === '' ? prefix : `${prefix}/${rest}`;
+}
+
+function slash(dir, rel) {
+  const parts = [];
+  if (dir !== '') parts.push(...dir.split('/'));
+  for (const part of rel.split('/')) {
+    if (part === '' || part === '.') continue;
+    if (part === '..') parts.pop();
+    else parts.push(part);
+  }
+  return parts.join('/');
+}
+
+function bySymbol(a, b) {
+  return a.line - b.line || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0) || (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0);
+}
+
+function byEdge(a, b) {
+  return cmp(a.src, b.src) || cmp(a.dst, b.dst) || cmp(a.kind, b.kind);
+}
+
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function sigOf(line) {
+  return line.trim().slice(0, 200);
+}
+
+function add(symbols, name, kind, line, raw, exported) {
+  if (!name) return;
+  symbols.push({ name, kind, line, sig: sigOf(raw), exported });
+}
+
+function skipLine(line) {
+  return line === '' || line.startsWith('//') || line.startsWith('#') || line.startsWith('/*') || line.startsWith('*');
+}
+
+function scan(text, onLine) {
+  const symbols = [];
+  const imports = [];
+  const lines = text.split('\n');
+  const state = {};
+  for (let i = 0; i < lines.length; i += 1) {
+    const raw = lines[i];
+    const line = raw.trim();
+    if (skipLine(line)) continue;
+    onLine(line, raw, i + 1, symbols, imports, state);
+  }
+  return { symbols, imports };
+}
+
+function script(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const from = line.match(/^(?:import|export)\s[\s\S]*?\sfrom\s+['"]([^'"]+)['"]/);
+    const side = line.match(/^import\s+['"]([^'"]+)['"]/);
+    const req = line.match(/\brequire\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (from) imports.push(from[1]);
+    else if (side) imports.push(side[1]);
+    else if (req) imports.push(req[1]);
+    let m;
+    if ((m = line.match(new RegExp(`^export\\s+(?:default\\s+)?(?:async\\s+)?function\\s*\\*?\\s*(${IDENT})`)))) {
+      add(symbols, m[1], 'function', lineNo, raw, 1);
+    } else if ((m = line.match(new RegExp(`^export\\s+(?:default\\s+)?(?:abstract\\s+)?class\\s+(${IDENT})`)))) {
+      add(symbols, m[1], 'class', lineNo, raw, 1);
+    } else if ((m = line.match(new RegExp(`^export\\s+(?:const|let|var)\\s+(${IDENT})`)))) {
+      add(symbols, m[1], 'const', lineNo, raw, 1);
+    } else if ((m = line.match(/^export\s+(type|interface|enum)\s+/))) {
+      const name = line.match(new RegExp(`^export\\s+${m[1]}\\s+(${IDENT})`));
+      if (name) add(symbols, name[1], m[1] === 'type' ? 'type' : m[1], lineNo, raw, 1);
+    } else if (/^export\s+(?:type\s+)?\{/.test(line)) {
+      const body = line.slice(line.indexOf('{') + 1, line.indexOf('}'));
+      for (const part of body.split(',')) {
+        const bit = part.trim();
+        if (bit === '') continue;
+        const sides = bit.split(/\s+as\s+/);
+        const name = (sides[1] ?? sides[0]).trim();
+        if (new RegExp(`^${IDENT}$`).test(name)) add(symbols, name, 'const', lineNo, raw, 1);
+      }
+    } else if ((m = line.match(new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s*\\*?\\s*(${IDENT})`)))) {
+      add(symbols, m[1], 'function', lineNo, raw, line.startsWith('export ') ? 1 : 0);
+    } else if ((m = line.match(new RegExp(`^(?:export\\s+)?(?:abstract\\s+)?class\\s+(${IDENT})`)))) {
+      add(symbols, m[1], 'class', lineNo, raw, line.startsWith('export ') ? 1 : 0);
+    }
+  });
+}
+
+const KT_MOD = '(?:public|private|internal|protected|open|data|sealed|abstract|enum|inner|value|annotation|suspend|override|operator|inline)';
+
+function kotlin(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const imp = line.match(/^import\s+([\w.]+)/);
+    if (imp) imports.push(imp[1]);
+    const m = line.match(new RegExp(`^(?:${KT_MOD}\\s+)*(class|interface|object|fun)\\s+(${IDENT})`));
+    if (!m) return;
+    const head = line.slice(0, line.indexOf(m[2]));
+    const exported = !/\b(?:private|internal)\b/.test(head);
+    add(symbols, m[2], m[1] === 'fun' ? 'function' : m[1], lineNo, raw, exported);
+  });
+}
+
+function java(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const imp = line.match(/^import\s+(?:static\s+)?([\w.]+)\s*;/);
+    if (imp) imports.push(imp[1]);
+    const m = line.match(new RegExp(`^(public\\s+)?(?:(?:abstract|final|sealed|static)\\s+)*(class|interface|enum|record)\\s+(${IDENT})`));
+    if (!m) return;
+    add(symbols, m[3], m[2], lineNo, raw, m[1] ? 1 : 0);
+  });
+}
+
+function python(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    if (raw[0] === ' ' || raw[0] === '\t') return;
+    const from = line.match(/^from\s+(\S+)\s+import\s+(.+)/);
+    const imp = line.match(/^import\s+(\S+)/);
+    if (from) {
+      if (from[1] === '.') {
+        for (const part of from[2].split(',')) {
+          const name = part.trim().split(/\s+as\s+/)[0].trim();
+          if (name !== '' && name !== '*') imports.push(`./${name}`);
+        }
+      } else imports.push(from[1]);
+    } else if (imp) imports.push(imp[1].replace(/,$/, ''));
+    let m;
+    if ((m = line.match(new RegExp(`^(?:async\\s+)?def\\s+(${IDENT})`)))) {
+      add(symbols, m[1], 'function', lineNo, raw, m[1].startsWith('_') ? 0 : 1);
+    } else if ((m = line.match(new RegExp(`^class\\s+(${IDENT})`)))) {
+      add(symbols, m[1], 'class', lineNo, raw, m[1].startsWith('_') ? 0 : 1);
+    }
+  });
+}
+
+function go(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports, state) => {
+    if (line === 'import (') {
+      state.group = true;
+      return;
+    }
+    if (state.group) {
+      if (line === ')') state.group = false;
+      else {
+        const q = line.match(/"([^"]+)"/);
+        if (q) imports.push(q[1]);
+      }
+      return;
+    }
+    const one = line.match(/^import\s+"([^"]+)"/);
+    if (one) imports.push(one[1]);
+    const fn = line.match(new RegExp(`^func\\s+(?:\\([^)]*\\)\\s*)?(${IDENT})`));
+    const type = line.match(new RegExp(`^type\\s+(${IDENT})`));
+    const name = fn?.[1] ?? type?.[1];
+    if (!name) return;
+    const exported = name[0] !== name[0].toLowerCase();
+    add(symbols, name, fn ? 'function' : 'type', lineNo, raw, exported);
+  });
+}
+
+function rust(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const use = line.match(/^use\s+([^;{]+)/);
+    if (use) imports.push(use[1].trim());
+    if (/^pub\s*\(/.test(line)) return;
+    const pub = line.match(new RegExp(`^pub\\s+(?:async\\s+)?(fn|struct|enum|trait|type|const|mod)\\s+(${IDENT})`));
+    if (pub) {
+      add(symbols, pub[2], pub[1] === 'fn' ? 'function' : pub[1], lineNo, raw, 1);
+      return;
+    }
+    const fn = line.match(new RegExp(`^(?:async\\s+)?fn\\s+(${IDENT})`));
+    if (fn) add(symbols, fn[1], 'function', lineNo, raw, 0);
+  });
+}
+
+function swift(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const imp = line.match(/^import\s+(\S+)/);
+    if (imp) imports.push(imp[1]);
+    const m = line.match(new RegExp(`^(?:(public|open|internal|private|fileprivate)\\s+)?(?:(?:static|class|final|override)\\s+)*(func|class|struct|enum|protocol|actor)\\s+(${IDENT})`));
+    if (!m) return;
+    add(symbols, m[3], m[2] === 'func' ? 'function' : m[2], lineNo, raw, m[1] === 'public' || m[1] === 'open' ? 1 : 0);
+  });
+}
+
+function dart(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const imp = line.match(/^import\s+['"]([^'"]+)['"]/);
+    if (imp) imports.push(imp[1]);
+    const type = line.match(new RegExp(`^(?:class|enum|mixin|extension|typedef)\\s+(${IDENT})`));
+    if (type) {
+      add(symbols, type[1], 'class', lineNo, raw, type[1].startsWith('_') ? 0 : 1);
+      return;
+    }
+    const fn = line.match(new RegExp(`^(?!if\\b|for\\b|while\\b|switch\\b|catch\\b)(?:[\\w.?<>]+\\s+)+(${IDENT})\\s*\\(`));
+    if (fn && raw[0] !== ' ' && raw[0] !== '\t') add(symbols, fn[1], 'function', lineNo, raw, fn[1].startsWith('_') ? 0 : 1);
+  });
+}
+
+function ruby(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const req = line.match(/^require(?:_relative)?\s+['"]([^'"]+)['"]/);
+    if (req) imports.push(req[1]);
+    if (raw[0] === ' ' || raw[0] === '\t') return;
+    const type = line.match(/^(class|module)\s+([A-Z]\w*)/);
+    if (type) {
+      add(symbols, type[2], type[1], lineNo, raw, 1);
+      return;
+    }
+    const fn = line.match(/^def\s+(?:self\.)?([A-Za-z_][\w?!]*)/);
+    if (fn) add(symbols, fn[1], 'function', lineNo, raw, 1);
+  });
+}
+
+function csharp(text) {
+  return scan(text, (line, raw, lineNo, symbols, imports) => {
+    const use = line.match(/^using\s+([A-Za-z0-9_.]+)\s*;/);
+    if (use) imports.push(use[1]);
+    const m = line.match(new RegExp(`^(?:(public|private|internal|protected)\\s+)?(?:(?:static|sealed|abstract|partial|readonly)\\s+)*(class|interface|enum|record|struct)\\s+(${IDENT})`));
+    if (!m) return;
+    add(symbols, m[3], m[2], lineNo, raw, m[1] === 'public' ? 1 : 0);
+  });
+}
+
+const BY_LANG = {
+  javascript: script,
+  typescript: script,
+  kotlin,
+  java,
+  python,
+  go,
+  rust,
+  swift,
+  dart,
+  ruby,
+  csharp,
+};

package/src/index/gate.mjs

@@ -0,0 +1,101 @@
+// Which tests a change should run (R16, ADR-094).
+//
+// A test is selected when an import reaches a changed file, directly or through
+// other files. The walk follows importers, so a test that imports a module that
+// imports the change is included, and a cycle cannot. Naming and co-change are
+// not imports, so they are not a selection.
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { isTestPath } from '../bench/mine.mjs';
+import { importsOf } from './tests.mjs';
+
+const LANG = {
+  js: 'javascript', mjs: 'javascript', cjs: 'javascript', jsx: 'javascript',
+  ts: 'typescript', tsx: 'typescript', kt: 'kotlin', kts: 'kotlin', java: 'java',
+  py: 'python', go: 'go', rs: 'rust', swift: 'swift', dart: 'dart', rb: 'ruby', cs: 'csharp',
+};
+
+/**
+ * Test files that import one of `changed`, directly or through other files.
+ * A changed file that is itself a test is included: the edit is the test.
+ *
+ * @param {Iterable<string>} changed
+ * @param {{src: string, dst: string, kind?: string}[]} imports importer, then imported
+ * @returns {string[]}
+ */
+export function selectTests(changed, imports) {
+  const reverse = new Map();
+  for (const edge of imports) {
+    if (edge.kind && edge.kind !== 'import') continue;
+    const list = reverse.get(edge.dst);
+    if (list) list.push(edge.src);
+    else reverse.set(edge.dst, [edge.src]);
+  }
+  const seen = new Set();
+  const tests = [];
+  const queue = [];
+  for (const file of changed) {
+    if (!file || seen.has(file)) continue;
+    seen.add(file);
+    queue.push(file);
+  }
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (isTestPath(file)) tests.push(file);
+    const importers = reverse.get(file);
+    if (!importers) continue;
+    for (const importer of importers) {
+      if (seen.has(importer)) continue;
+      seen.add(importer);
+      queue.push(importer);
+    }
+  }
+  tests.sort();
+  return tests;
+}
+
+/** Import edges for the texts the caller already read. One pass, no second parse. */
+export function importEdges(entries) {
+  const files = new Set(entries.map((entry) => entry.path));
+  const imports = [];
+  for (const entry of entries) {
+    if (!entry.lang || !entry.text) continue;
+    imports.push(...importsOf(entry.path, entry.text, entry.lang, files));
+  }
+  return imports;
+}
+
+/** Texts for tracked paths, read from the worktree. A missing file contributes none. */
+export async function readEntries(root, files) {
+  const entries = [];
+  const paths = [...files].sort();
+  const batch = 32;
+  for (let i = 0; i < paths.length; i += batch) {
+    const slice = paths.slice(i, i + batch);
+    const read = await Promise.all(slice.map(async (path) => {
+      const lang = langOf(path);
+      if (!lang) return { path, text: '', lang: '' };
+      try {
+        return { path, text: await readFile(join(root, path), 'utf8'), lang };
+      } catch {
+        return { path, text: '', lang };
+      }
+    }));
+    entries.push(...read);
+  }
+  return entries;
+}
+
+/** Import edges for tracked paths. A missing file contributes none. */
+export async function readImportEdges(root, files) {
+  return importEdges(await readEntries(root, files));
+}
+
+function langOf(file) {
+  const base = file.slice(file.lastIndexOf('/') + 1);
+  const dot = base.lastIndexOf('.');
+  if (dot <= 0) return '';
+  return LANG[base.slice(dot + 1)] ?? '';
+}