simt-dev 0.7.1 → 0.8.0

package/src/hooks/dispatcher.mjs

@@ -18,13 +18,12 @@
 //   Report what did not run. The summary names every gate, its disposition and
 //   its reason, so "passed" can never be mistaken for "only some of it passed".
 
-import { execFile, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { mkdtemp, readFile, rm, stat, symlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, join, matchesGlob, resolve, sep } from 'node:path';
-import { promisify } from 'node:util';
 
-import { GATES } from './gates.mjs';
+import { GATES, getGate } from './gates.mjs';
 import { resolveGate } from './resolve.mjs';
 import { resolveNodeRunner } from '../ecosystem/node-runner.mjs';
 import { CLI } from '../name.mjs';
@@ -32,8 +31,7 @@ import { MANIFEST_FILE } from '../name.mjs';
 import { assertVersionPin } from '../package-version.mjs';
 import { hasTestEvidence, readLedger, recordRun } from '../ledger/index.mjs';
 import { renderFindings, scanStaged } from '../secrets.mjs';
-
-const exec = promisify(execFile);
+import { git, gitPaths, gitText } from '../sys/git.mjs';
 
 /**
  * The default bound on one gate, in seconds, and the grace a killed gate gets before
@@ -194,15 +192,14 @@ export function parsePushedRefs(text) {
 async function tagCommitAccountedFor(root, tagSha, pushingTips) {
   let commit;
   try {
-    ({ stdout: commit } = await exec('git', ['rev-parse', `${tagSha}^{commit}`], { cwd: root }));
+    commit = await gitText(root, ['rev-parse', `${tagSha}^{commit}`]);
   } catch (error) {
     return { ok: false, reason: `the tag could not be resolved to a commit: ${String(error.stderr ?? error.message).trim()}` };
   }
-  commit = commit.trim();
 
   let remoteRefs;
   try {
-    ({ stdout: remoteRefs } = await exec('git', ['for-each-ref', 'refs/remotes/', '--format=%(refname)'], { cwd: root }));
+    remoteRefs = await gitText(root, ['for-each-ref', 'refs/remotes/', '--format=%(refname)']);
   } catch (error) {
     return { ok: false, reason: `the remote refs could not be listed: ${String(error.stderr ?? error.message).trim()}` };
   }
@@ -215,7 +212,7 @@ async function tagCommitAccountedFor(root, tagSha, pushingTips) {
   }
   for (const candidate of candidates) {
     try {
-      await exec('git', ['merge-base', '--is-ancestor', commit, candidate], { cwd: root });
+      await git(root, ['merge-base', '--is-ancestor', commit, candidate]);
       return { ok: true, reason: null };
     } catch {
       // not reachable from this ref; try the next candidate
@@ -257,17 +254,17 @@ export async function classifyPush(root, refs, { maxCommits, paths }) {
     }
     let count, names;
     try {
-      ({ stdout: count } = await exec('git', ['rev-list', '--count', `${remoteSha}..${localSha}`], { cwd: root }));
-      ({ stdout: names } = await exec('git', ['diff', '--name-only', '-z', `${remoteSha}..${localSha}`], { cwd: root }));
+      count = await gitText(root, ['rev-list', '--count', `${remoteSha}..${localSha}`]);
+      names = await gitPaths(root, ['diff', '--name-only', `${remoteSha}..${localSha}`]);
     } catch (error) {
       return { docsOnly: false, reason: `the push could not be diffed: ${String(error.stderr ?? error.message).trim()}` };
     }
-    commits += Number(count.trim());
-    // `-z` and no trimming: a path is NUL-terminated because a path can contain a
-    // newline, and git quotes such a name in the line-terminated form, so splitting on
-    // newlines compares a quoted path against an unquoted glob and never matches.
-    for (const name of names.split('\0')) {
-      if (name !== '') files.add(name);
+    commits += Number(count);
+    // NUL-separated paths because a path can contain a newline, and git quotes such a
+    // name in the line-terminated form, so splitting on newlines compares a quoted path
+    // against an unquoted glob and never matches.
+    for (const name of names) {
+      files.add(name);
     }
   }
 
@@ -339,11 +336,10 @@ async function resolveDocsOnlySkip(root, manifest, pushed) {
 async function resolveAlreadyPassedSkip(root) {
   let headTree;
   try {
-    ({ stdout: headTree } = await exec('git', ['rev-parse', 'HEAD^{tree}'], { cwd: root }));
+    headTree = await gitText(root, ['rev-parse', 'HEAD^{tree}']);
   } catch {
     return null;
   }
-  headTree = headTree.trim();
   if (!/^[0-9a-f]{40}$/.test(headTree)) return null;
   const { entries, errors } = await readLedger(root);
   if (errors.length > 0) return null;
@@ -508,8 +504,8 @@ async function runGatesAt(event, { root, ledgerRoot, manifest, declared, key, sk
   let formatted = [];
 
   for (const name of declared) {
-    const gate = GATES[name];
-    if (gate === undefined) {
+    const gate = getGate(name, commands);
+    if (gate === null) {
       results.push({
         name,
         status: 'failed',
@@ -727,7 +723,7 @@ async function runGatesAt(event, { root, ledgerRoot, manifest, declared, key, sk
 async function materializeHeadWorktree(root) {
   const path = await mkdtemp(join(tmpdir(), 'head-gate-'));
   try {
-    await exec('git', ['worktree', 'add', '--detach', path, 'HEAD'], { cwd: root });
+    await git(root, ['worktree', 'add', '--detach', path, 'HEAD']);
   } catch (error) {
     await rm(path, { recursive: true, force: true }).catch(() => {});
     return { path: null, error: `git worktree add failed: ${String(error.stderr ?? error.message).trim()}` };
@@ -752,9 +748,9 @@ async function materializeHeadWorktree(root) {
  * @param {string} path the worktree to remove
  */
 async function removeHeadWorktree(root, path) {
-  await exec('git', ['worktree', 'remove', '--force', path], { cwd: root }).catch(async () => {
+  await git(root, ['worktree', 'remove', '--force', path]).catch(async () => {
     await rm(path, { recursive: true, force: true }).catch(() => {});
-    await exec('git', ['worktree', 'prune'], { cwd: root }).catch(() => {});
+    await git(root, ['worktree', 'prune']).catch(() => {});
   });
 }
 
@@ -877,10 +873,9 @@ async function readPkg(root) {
 /** Staged paths, or [] when git cannot answer (an unborn branch, for instance). */
 export async function stagedFiles(root) {
   try {
-    // `-z`: git quotes a path containing a newline or a quote in the line form, and a
-    // quoted name is not the path the index holds, so it never matches a staged blob.
-    const { stdout } = await exec('git', ['diff', '--cached', '--name-only', '-z', '--diff-filter=ACMR'], { cwd: root });
-    return stdout.split('\0').filter(Boolean);
+    // NUL-separated: git quotes a path containing a newline or a quote in the line form,
+    // and a quoted name is not the path the index holds, so it never matches a staged blob.
+    return await gitPaths(root, ['diff', '--cached', '--name-only', '--diff-filter=ACMR']);
   } catch {
     return [];
   }
@@ -896,8 +891,7 @@ export async function stagedFiles(root) {
  */
 async function unstagedFiles(root) {
   try {
-    const { stdout } = await exec('git', ['diff', '--name-only', '-z'], { cwd: root });
-    return new Set(stdout.split('\0').filter(Boolean));
+    return new Set(await gitPaths(root, ['diff', '--name-only']));
   } catch {
     return new Set();
   }
@@ -907,7 +901,7 @@ async function unstagedFiles(root) {
 async function stagedBlobs(root, files) {
   if (files.length === 0) return new Map();
   try {
-    const { stdout } = await exec('git', ['ls-files', '-s', '--', ...files], { cwd: root });
+    const stdout = await git(root, ['ls-files', '-s', '--', ...files]);
     const blobs = new Map();
     for (const line of stdout.split('\n')) {
       const [meta, ...rest] = line.split('\t');
@@ -932,7 +926,7 @@ async function restage(root, files) {
   if (files.length === 0) return { restaged: [], error: null };
   const before = await stagedBlobs(root, files);
   try {
-    await exec('git', ['add', '--', ...files], { cwd: root });
+    await git(root, ['add', '--', ...files]);
   } catch (error) {
     return { restaged: [], error: String(error.stderr ?? error.message ?? error).trim() };
   }

package/src/hooks/gates.mjs

@@ -101,8 +101,18 @@ export const GATES = {
   },
 };
 
-export function getGate(name) {
-  return GATES[name] ?? null;
+export function getGate(name, commands = {}) {
+  const declared = GATES[name];
+  if (declared) return declared;
+  // Q70: a command the repository declared under gates.commands is a valid gate even when
+  // no central row knows it. The manifest is the source of truth for a repo's gates, and
+  // a name that resolves to a declared command must not read as unknown. Synthesized, not
+  // added to GATES: the central table stays the estate's gates, the record supplies the rest.
+  const cmd = commands?.[name];
+  if (typeof cmd === 'string' && cmd.trim() !== '') {
+    return { name, kind: 'command', adr: 'ADR-010', why: 'declared by the repository under gates.commands' };
+  }
+  return null;
 }
 
 export function gateNames() {

package/src/hooks/resolve.mjs

@@ -12,7 +12,7 @@
 
 import { access } from 'node:fs/promises';
 import { constants } from 'node:fs';
-import { join } from 'node:path';
+import { extname, join } from 'node:path';
 
 import { FORMATTABLE, GATES, gateNames } from './gates.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
@@ -139,7 +139,7 @@ export async function resolveGate(gate, { root, pkg, staged, commands, runner =
         remedy: `run the repo install command, or remove "format" from ${MANIFEST_FILE} gates`,
       };
     }
-    const files = staged.filter((f) => FORMATTABLE.has(extname(f)));
+    const files = staged.filter((f) => FORMATTABLE.has(extname(f).toLowerCase()));
     if (files.length === 0) {
       return {
         ok: true,
@@ -200,9 +200,4 @@ export async function resolveGate(gate, { root, pkg, staged, commands, runner =
     reason: `unknown gate kind "${gate.kind}"`,
     remedy: `this is a bug in simt-dev; )}', ')}`,
   };
-}
-
-function extname(path) {
-  const dot = path.lastIndexOf('.');
-  return dot > 0 ? path.slice(dot).toLowerCase() : '';
 }

package/src/hooks/where.mjs

@@ -19,17 +19,12 @@
 // ADR-012 dropped Windows, but nothing here is POSIX-specific; the worktree
 // handling is the only subtlety and it is the same on every platform.
 
-import { execFile } from 'node:child_process';
 import { readdir, stat } from 'node:fs/promises';
 import { isAbsolute, join, resolve } from 'node:path';
-import { promisify } from 'node:util';
 
-const exec = promisify(execFile);
+import { gitText } from '../sys/git.mjs';
 
-async function git(root, args) {
-  const { stdout } = await exec('git', args, { cwd: root });
-  return stdout.trim();
-}
+const git = (root, args) => gitText(root, args);
 
 /**
  * The directory git runs hooks from, and which of the two rules produced it.

package/src/identity.mjs

@@ -24,14 +24,12 @@
 // one; a repository that already tracks it is left that way, because removing a
 // tracked file is not something an adopting command should do silently.
 
-import { execFile } from 'node:child_process';
 import { readFile, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 
 import { journaledGitConfig, journaledWriteFile } from './journal.mjs';
+import { gitText } from './sys/git.mjs';
 
-const exec = promisify(execFile);
 
 /** The file, at the repository root. Named for what it is: a git config fragment. */
 export const IDENTITY_FILE = 'git.config';
@@ -50,14 +48,7 @@ export const INCLUDE_KEY = 'include.path';
  * @param {string[]} args
  * @returns {Promise<string|null>}
  */
-async function git(cwd, args) {
-  try {
-    const { stdout } = await exec('git', args, { cwd });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
+const git = (cwd, args) => gitText(cwd, args, { allowFailure: true });
 
 /**
  * Who last committed here.

package/src/index/coverage.mjs

@@ -0,0 +1,58 @@
+// Which tests a change should run, from one place (Q77).
+//
+// Four callers used to answer this question four ways: `tests` walked the stored test
+// edges directly, `gate` walked the import graph transitively over a re-read worktree,
+// `impact` asked `dependents` which asked `selectTests`, and `brief` used the edges again.
+// The answers disagreed — `simt tests src/index/persist.mjs` named one test where `simt
+// gate` on the same file named dozens — and every disagreement was a reader trusting the
+// wrong one.
+//
+// The two walks are not the same question, so they are not merged into one answer:
+// `transitive` is the import closure over changed paths, and the direct walk is the test
+// edges the index stores. Each caller keeps its default; what changes is that there is
+// now one implementation of each.
+
+import { selectTests } from './gate.mjs';
+import { testEdges, testsFor } from './tests.mjs';
+
+/**
+ * Tests that exercise `paths`.
+ *
+ * @param {{files?: {path: string}[]|string[], imports?: {src: string, dst: string, kind?: string}[],
+ *   coverage?: string[], commits?: string[][]}} graph
+ * @param {Iterable<string>} paths
+ * @param {{transitive?: boolean, cochange?: boolean}} [options]
+ *   `transitive` (default true) is the import closure; `cochange` adds files that land in
+ *   the same commits, and is only ever on when a caller asked for it.
+ * @returns {string[]}
+ */
+export function coverage(graph, paths, { transitive = true, cochange = false } = {}) {
+  const changed = [...new Set([...paths].filter(Boolean))];
+  const imports = graph.imports ?? [];
+  if (transitive) {
+    const selected = selectTests(changed, imports);
+    if (!cochange || graph.files === undefined) return selected;
+    const edges = testEdges({
+      files: graph.files,
+      imports,
+      coverage: graph.coverage ?? [],
+      commits: graph.commits ?? [],
+    });
+    const found = new Set(selected);
+    for (const path of changed) {
+      for (const test of testsFor(path, edges, { cochange: true })) found.add(test);
+    }
+    return [...found].sort();
+  }
+  const edges = testEdges({
+    files: graph.files ?? [],
+    imports,
+    coverage: graph.coverage ?? [],
+    commits: graph.commits ?? [],
+  });
+  const found = new Set();
+  for (const path of changed) {
+    for (const test of testsFor(path, edges, { cochange })) found.add(test);
+  }
+  return [...found].sort();
+}

package/src/index/extract.mjs

@@ -4,21 +4,14 @@
 // 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.
 
+import { cmp } from '../util/sort.mjs';
+// Q70: the extension table is the records' `languages[].exts` (ADR-013: content is data,
+// the engine is code). A new language lands in a record, not a row the extractor edits.
+import { languageExts } from '../ecosystem/records.mjs';
+
 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'],
-};
+const EXTS = languageExts();
 
 /**
  * Symbols and import specifiers in one blob.
@@ -261,9 +254,6 @@ 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);

package/src/index/gate.mjs

@@ -8,7 +8,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
-import { isTestPath } from '../bench/mine.mjs';
+import { isTestPath } from '../testing/paths.mjs';
 import { langOf } from './store.mjs';
 import { importsOf } from './tests.mjs';
 

package/src/index/govern.mjs

@@ -6,7 +6,9 @@
 // and a lesson do the same with their own path list. Nothing here is stored: the
 // answer is the records on disk.
 
-import { parseDecisionFrontmatter, splitFrontmatter } from '../memory/decide.mjs';
+import { parseDecisionFrontmatter } from '../memory/decide.mjs';
+import { parseFrontmatter } from '../text/frontmatter.mjs';
+import { cmp } from '../util/sort.mjs';
 
 const SIBLING = /^\*{0,2}[A-Z][\w-]*(?:[ \t]+[\w-]+){0,3}:\*{0,2}(?:[ \t]|$)/;
 const HEADING = /^#{1,6}\s/;
@@ -18,7 +20,7 @@ const TOOL = /^(?:simt-dev|simt)\b/;
  */
 export function affectsTokens(text) {
   const fm = parseDecisionFrontmatter(text);
-  const { body } = splitFrontmatter(text);
+  const { body } = parseFrontmatter(text);
   const lines = String(body).split('\n');
   const start = lines.findIndex((line) => /^\s*\*{0,2}Affects:\*{0,2}/.test(line));
   const proseTokens = [];
@@ -131,7 +133,27 @@ export function scopeHits(file, { rules = [], skills = [], gates = [], lessons =
   return hits;
 }
 
-export function sortHits(hits) {
+/**
+ * What governs one file: decisions whose Affects line names it, then the rules, skills,
+ * gates and lessons whose path lists match, in one stable order.
+ *
+ * `why`, `impact` and the critic each assembled this themselves, with different corpora
+ * and - in `why`'s case - a hard-coded list of this repository's own rule directories
+ * (Q77). The corpus is now the caller's, so a receiving repository's directories are the
+ * ones read.
+ *
+ * @param {string} file
+ * @param {{records?: {id: string, title: string, text: string}[], ctx: {files: Set<string>,
+ *   commands: Set<string>, roots: string[]}, rules?: object[], skills?: object[],
+ *   gates?: object[], lessons?: object[], commands?: Record<string, string>}} corpus
+ */
+export function governs(file, corpus) {
+  const { records = [], ctx, ...scopes } = corpus;
+  const { hits } = decisionHits(records, file, ctx);
+  return sortHits([...hits, ...scopeHits(file, scopes)]);
+}
+
+function sortHits(hits) {
   const order = { decision: 0, rule: 1, skill: 2, gate: 3, lesson: 4 };
   return [...hits].sort((a, b) => (order[a.kind] - order[b.kind]) || cmp(a.id, b.id));
 }
@@ -218,7 +240,7 @@ function extension(file) {
 }
 
 function frontmatter(text) {
-  return splitFrontmatter(text).front ?? '';
+  return parseFrontmatter(text).front ?? '';
 }
 
 function quotedList(front, key) {
@@ -227,8 +249,3 @@ function quotedList(front, key) {
   return [...match[1].matchAll(/['"]([^'"]+)['"]/g)].map((item) => item[1]);
 }
 
-function cmp(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}

package/src/index/impact.mjs

@@ -5,8 +5,9 @@
 // touches. The walk stops at a fixed count: an unbounded report is not an
 // answer a reader can use.
 
-import { isTestPath } from '../bench/mine.mjs';
-import { selectTests } from './gate.mjs';
+import { isTestPath } from '../testing/paths.mjs';
+import { coverage } from './coverage.mjs';
+import { cmp } from '../util/sort.mjs';
 
 const IMPACT_LIMIT = 64;
 
@@ -50,7 +51,7 @@ export function dependents(file, imports, limit = IMPACT_LIMIT) {
     }
   }
   importers.sort();
-  const tests = selectTests([file], imports).filter((path) => path !== file);
+  const tests = coverage({ imports }, [file]).filter((path) => path !== file);
   const shown = tests.length > limit ? tests.slice(0, limit) : tests;
   if (tests.length > limit) truncated = true;
   return { importers, tests: shown, truncated };
@@ -179,8 +180,3 @@ function glob(pattern, text) {
   return new RegExp(`^${body}$`).test(text);
 }
 
-function cmp(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}

package/src/index/map.mjs

@@ -9,7 +9,8 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
-import { isTestPath, resolveVaultDir } from '../bench/mine.mjs';
+import { isTestPath } from '../testing/paths.mjs';
+import { resolveVaultDir } from '../testing/vault.mjs';
 import { readLocalConfig } from '../local/config.mjs';
 import { localEmbed } from '../local/client.mjs';
 import {
@@ -22,6 +23,8 @@ import {
   scoreFtsBm25,
   searchFtsBm25,
 } from './store.mjs';
+import { cmp } from '../util/sort.mjs';
+import { INDEX_STOP as STOP } from '../text/tokens.mjs';
 
 export const ITERATIONS = 20;
 export const DAMPING = 0.85;
@@ -30,14 +33,6 @@ export const EMBED_RECALL_GAIN_BAR = 0.1;
 const TOP = 10;
 export const DEFAULT_BUDGET = 2048;
 
-const STOP = new Set([
-  'this', 'that', 'with', 'from', 'have', 'been', 'into', 'only', 'when', 'what',
-  'which', 'their', 'about', 'after', 'before', 'where', 'there', 'these', 'those',
-  'would', 'could', 'should', 'every', 'other', 'than', 'then', 'them', 'they',
-  'your', 'will', 'does', 'file', 'files', 'test', 'tests', 'line', 'lines', 'code',
-  'also', 'just', 'more', 'some', 'such', 'each', 'same', 'over', 'used', 'using',
-]);
-
 /**
  * Reciprocal-rank fusion (RRF) over multiple ranked lists.
  *
@@ -405,16 +400,25 @@ function pageRank(nodes, links, scores) {
   let rank = pers.slice();
   for (let iter = 0; iter < ITERATIONS; iter += 1) {
     const next = pers.map((value) => (1 - DAMPING) * value);
+    // Dangling nodes (no outgoing edges) spread their rank over the whole
+    // distribution. Accumulating their mass first makes that one pass over j
+    // instead of one pass per dangling node - the no-task rank of a 30k-file
+    // repo used to go quadratic here (Q76).
+    let danglingMass = 0;
     for (let i = 0; i < n; i += 1) {
       const outs = links[i];
       if (outs.length === 0) {
-        for (let j = 0; j < n; j += 1) next[j] += DAMPING * rank[i] * pers[j];
+        danglingMass += rank[i];
       } else {
         let sum = 0;
         for (const [, weight] of outs) sum += weight;
         for (const [j, weight] of outs) next[j] += (DAMPING * rank[i] * weight) / sum;
       }
     }
+    if (danglingMass > 0) {
+      const share = DAMPING * danglingMass;
+      for (let j = 0; j < n; j += 1) next[j] += share * pers[j];
+    }
     rank = next;
   }
   return rank;
@@ -620,8 +624,3 @@ function round6(value) {
   return Math.round(value * 1e6) / 1e6;
 }
 
-function cmp(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}