simt-dev 0.7.0 → 0.7.1

package/src/commands/hooks.mjs

@@ -12,7 +12,8 @@
 // DEFAULT location, which core.hooksPath being unset does not reveal, so a
 // foreign hook is found by asking git rather than by reading config.
 
-import { mkdir, readFile, realpath } from 'node:fs/promises';
+import { mkdir, readFile, readdir, realpath, rm, stat } from 'node:fs/promises';
+import { repoContext } from '../context.mjs';
 import { commitJournal, journaledGitConfig, journaledRemoveFile, journaledWriteFile } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { invalidateCheckCache } from '../status.mjs';
@@ -20,19 +21,23 @@ import { isAbsolute, join, relative } from 'node:path';
 
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { MANIFEST, readManifest } from '../projection/manifest.mjs';
-import { EVENTS, HOOKS_DIR, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderChainedShim, renderEvidenceShim, renderShim } from '../hooks/shim.mjs';
+import { CHAIN_MARKER, EVENTS, HOOKS_DIR, HOOKS_DIR_LEGACY, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderChainedShim, renderEvidenceShim, renderShim } from '../hooks/shim.mjs';
 import { GATE_KEY, gateCount, readHooksPath, readHooksState, wantsShim } from '../compare/hooksstate.mjs';
 import { GATES } from '../hooks/gates.mjs';
-import { knownGates } from '../hooks/resolve.mjs';
+import { gateNames } from '../hooks/gates.mjs';
 import { renderGateReport, runGates } from '../hooks/dispatcher.mjs';
 import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 import { packageVersion, hasNpm } from '../package-version.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function hooksCommand(sub, args, flags) {
-  const root = flags.root ?? args[0] ?? process.cwd();
-  if (sub === 'install') return installHooks(root, flags);
-  if (sub === 'status') return hooksStatus(root, flags);
+  const root = commandRoot(flags, args);
+  // One context for the subcommand: install and status each ask about the same
+  // repository, and `doctor --fix` asks alongside them (review 0003 Q67).
+  const ctx = repoContext(root);
+  if (sub === 'install') return installHooks(root, flags, ctx);
+  if (sub === 'status') return hooksStatus(root, flags, ctx);
   if (sub === 'run') return runHook(args, flags);
   return fail(`unknown hooks subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} hooks status`);
 }
@@ -40,11 +45,12 @@ export async function hooksCommand(sub, args, flags) {
 /** The shim execs this; the event name is baked into the shim, so it is arg 0. */
 async function runHook(args, flags) {
   const event = args[0];
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
+  const ctx = repoContext(root);
   if (!EVENTS.includes(event)) {
     return fail(`unknown hook event ${event}`, EXIT.USAGE, `known events: ${EVENTS.join(', ')}`);
   }
-  const { manifest, exists, error } = await readManifest(root);
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
   if (!exists) {
     return fail(`${root} has no ${MANIFEST_FILE}; the hook cannot know its gate list`, EXIT.CONFIG, `run: ${CLI} init --root ${root}`);
@@ -64,7 +70,7 @@ async function runHook(args, flags) {
   }
 
   for (const n of result.notes ?? []) note(`note     ${n}`);
-  emit(renderGateReport(event, manifest.gates[GATE_KEY[event]] ?? [], result).join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(renderGateReport(event, manifest.gates[GATE_KEY[event]] ?? [], result).join('\n'));
   return result.failed ? EXIT.FAIL : EXIT.OK;
 }
 
@@ -135,7 +141,7 @@ async function relativeTarget(root, target) {
  *   caller enforces in its own voice (`takeover`, and the `wanted`/`obsolete`
  *   emptiness the command refuses on)
  */
-export async function planHooksInstall(root, { manifest, exists }) {
+export async function planHooksInstall(root, { manifest, exists }, ctx = null) {
   const declaresGate = (event) => wantsShim(manifest, exists, event);
   const state = await readHooksState(root, { declaresGate });
   const current = state.current;
@@ -159,8 +165,10 @@ export async function planHooksInstall(root, { manifest, exists }) {
     } catch {
       // Unreadable here leaves the npm default; the manifest path reports it.
     }
-    const { fingerprint } = await import('../resolve/fingerprint.mjs');
-    const detected = await fingerprint(root);
+    // The dynamic import stays: a hook run must not pull the fingerprint module in
+    // just by loading this one. A caller that already holds a context passes it and
+    // the walk is shared (review 0003 Q67).
+    const detected = ctx ? await ctx.fingerprint() : await (await import('../resolve/fingerprint.mjs')).fingerprint(root);
     manager = resolveNodeRunner({ facts: detected.facts, packageManager }).id;
   }
 
@@ -190,8 +198,8 @@ export async function planHooksInstall(root, { manifest, exists }) {
   //
   // `foreignHooks` lists every executable file in the directory git reads hooks from -
   // and when that directory is this tool's own, a file a person dropped in there is
-  // listed too. Chaining it means writing a shim at `.simt-hooks/<name>` whose TARGET is
-  // `.simt-hooks/<name>`: the same path. The shim overwrites the hook it was written to
+  // listed too. Chaining it means writing a shim at `.simt/hooks/<name>` whose TARGET is
+  // `.simt/hooks/<name>`: the same path. The shim overwrites the hook it was written to
   // preserve and then runs itself, so the hook stops working and git recurses in a loop
   // nothing reports. Confirmed at the previous release, which printed
   // `UPDATED .simt-hooks/mine (chained: runs .simt-hooks/mine)`.
@@ -298,9 +306,50 @@ export async function planHooksInstall(root, { manifest, exists }) {
     evidenceExisting,
     routed,
     takeover,
+    // The legacy directory's removal rides on the same planned write, so the
+    // scan is here and the deletion is in `applyHooksInstall` (ADR-122).
+    legacy: await legacyHooksScan(root),
   };
 }
 
+/**
+ * Scan the legacy top-level shim directory (ADR-122). A repository installed
+ * before the move into the state directory still carries it, and it is
+ * removable only when every entry in it is a regular file that carries a
+ * simt-dev marker: the install re-routes git to the new directory, and a
+ * file this tool cannot recognise as its own is never deleted on its way.
+ *
+ * @returns {Promise<{path: string, removable: boolean}|null>} null when the
+ *   directory is absent or empty; otherwise the directory and whether the
+ *   install may take it down. `applyHooksInstall` acts on this, so the
+ *   judgment is made once, in the plan. Module-local: one caller needs no
+ *   export, and an export is a promise to a caller (deadcode).
+ */
+async function legacyHooksScan(root) {
+  const dir = join(root, HOOKS_DIR_LEGACY);
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  if (entries.length === 0) return null;
+  let removable = true;
+  for (const name of entries) {
+    const st = await stat(join(dir, name));
+    if (!st.isFile()) {
+      removable = false;
+      break;
+    }
+    const text = await readFile(join(dir, name), 'utf8');
+    if (!text.includes(SHIM_MARKER) && !text.includes(CHAIN_MARKER)) {
+      removable = false;
+      break;
+    }
+  }
+  return { path: HOOKS_DIR_LEGACY, removable };
+}
+
 /**
  * Write a planned install: shims, chains, removals, and the git routing (plan 0003 R47).
  *
@@ -309,10 +358,11 @@ export async function planHooksInstall(root, { manifest, exists }) {
  * names the run that actually changed something. Reporting stays with the
  * caller for the same reason it does in `planHooksInstall`.
  *
- * @returns {{wrote: string[]}} the shim paths written, removed, or refreshed
+ * @returns {{wrote: string[], removed: string[]}} the shim paths written,
+ *   removed or refreshed, and the legacy-directory files taken down
  */
 export async function applyHooksInstall(root, planned, journal) {
-  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current } =
+  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current, legacy } =
     planned;
   // Shim and evidence bytes are journaled so `undo` restores them (R49), with
   // the executable bit they are written with: a shim the run chmodded is one
@@ -322,6 +372,7 @@ export async function applyHooksInstall(root, planned, journal) {
   // at their directory silently stops the repository's own hooks (review 0003
   // Q22).
   const wrote = [];
+  const removed = [];
   await mkdir(join(root, HOOKS_DIR), { recursive: true });
   for (const event of wanted) {
     const path = join(root, fileFor(event));
@@ -352,7 +403,19 @@ export async function applyHooksInstall(root, planned, journal) {
   } else if (current === wants) {
     await journaledGitConfig(root, journal, HOOKS_PATH_KEY, null);
   }
-  return { wrote };
+  // The move into the state directory (ADR-122): the routing now points
+  // elsewhere, so a legacy directory left behind is the only place that looks
+  // like a hooks directory while holding nothing git reads. The scan in the
+  // plan already judged it removable — every file a simt-dev marker — so
+  // deletion is journaled per file, and `undo` restores the directory.
+  if (legacy?.removable) {
+    for (const name of await readdir(join(root, HOOKS_DIR_LEGACY))) {
+      await journaledRemoveFile(root, journal, join(root, HOOKS_DIR_LEGACY, name));
+      removed.push(`${HOOKS_DIR_LEGACY}/${name}`);
+    }
+    await rm(join(root, HOOKS_DIR_LEGACY), { recursive: true });
+  }
+  return { wrote, removed };
 }
 
 /**
@@ -382,8 +445,8 @@ export async function plannedDiffs(root, planned) {
   return pairs;
 }
 
-async function installHooks(root, flags) {
-  const { manifest, exists, error } = await readManifest(root);
+async function installHooks(root, flags, ctx = repoContext(root)) {
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
   if (!exists) {
     return fail(`${root} has no ${MANIFEST_FILE}; gates must be declared before hooks can run them`, EXIT.CONFIG, `run: ${CLI} init --root ${root}`);
@@ -409,7 +472,8 @@ async function installHooks(root, flags) {
     evidenceExisting,
     routed,
     takeover,
-  } = await planHooksInstall(root, { manifest, exists });
+    legacy,
+  } = await planHooksInstall(root, { manifest, exists }, ctx);
 
   // Read through `writeMode` like every other writer, and only now: this command
   // used to consult `flags.yes` and `flags.dryRun` directly and write when neither
@@ -438,7 +502,6 @@ async function installHooks(root, flags) {
         '         and replace it with a gate that checks nothing.',
         `REMEDY  add the gates this repo can actually run to ${MANIFEST_FILE}, then re-run.`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -487,11 +550,21 @@ async function installHooks(root, flags) {
       note: 'commit-msg checks a verification claim against the ledger',
     });
   }
+  if (legacy?.removable) {
+    plan.push({
+      file: HOOKS_DIR_LEGACY,
+      action: 'removed',
+      // Named in the plan for the same reason the obsolete shims are: the
+      // reader approving this write is about to lose a directory, and the
+      // routing line above does not say the old one goes too (ADR-122).
+      note: `legacy shim directory; the shims now live in ${HOOKS_DIR}`,
+    });
+  }
 
   // The routing this install leaves behind, which is not always `wants`. A repository
   // that removed its last gate has no shims to route to, and leaving `core.hooksPath`
   // pointed at the directory would stop its own hooks running - the plan has to say so,
-  // because a plan that prints "core.hooksPath updated .simt-hooks -> .simt-hooks" while
+  // because a plan that prints "core.hooksPath updated .simt/hooks -> .simt/hooks" while
   // the command unsets it is worse than no plan.
   const leaves = routed ? wants : null;
   const pathAction =
@@ -521,7 +594,6 @@ async function installHooks(root, flags) {
         '         Taking over replaces that routing. Inspect the existing hooks first,',
         '         then re-run with --yes to accept, or set core.hooksPath yourself.',
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -566,7 +638,6 @@ async function installHooks(root, flags) {
           : `PLAN     nothing written; apply with: ${CLI} hooks install --root ${root} --yes`,
         manifest,
       ),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -578,7 +649,7 @@ async function installHooks(root, flags) {
   const journal = [];
   await applyHooksInstall(
     root,
-    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current },
+    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current, legacy },
     journal,
   );
   await commitJournal(root, 'hooks install', journal);
@@ -655,7 +726,6 @@ async function installHooks(root, flags) {
       routed ? 'WROTE    shims and set core.hooksPath' : 'WROTE    no shims remain; core.hooksPath unset',
       manifest,
     ),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
@@ -684,8 +754,8 @@ function describeGates(manifest, key) {
   }).join(', ');
 }
 
-async function hooksStatus(root, flags) {
-  const { manifest, exists, error } = await readManifest(root);
+async function hooksStatus(root, flags, ctx = repoContext(root)) {
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
 
   const state = await readHooksState(root, { declaresGate: (e) => wantsShim(manifest, exists, e) });
@@ -770,14 +840,14 @@ async function hooksStatus(root, flags) {
     const unknown = [...(manifest?.gates?.preCommit ?? []), ...(manifest?.gates?.prePush ?? [])].filter((n) => !GATES[n]);
     if (unknown.length > 0) {
       lines.push('', `unknown gates (the hook will fail): ${unknown.join(', ')}`);
-      lines.push(`known gates: ${knownGates().join(', ')}`);
+      lines.push(`known gates: ${gateNames().join(', ')}`);
     }
   }
   if (problems.length > 0) {
     lines.push('', 'problems:');
     for (const p of problems) lines.push(`  ${p}`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return code;
 }
 

package/src/commands/ignore.mjs

@@ -14,9 +14,10 @@ import { CLI } from '../name.mjs';
 import { commitJournal, journaledWriteFile } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { CLAUDE_SETTINGS, IGNORE_FILE, parseIgnoreList, planIgnore } from '../ignore.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function ignoreCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
 
   let source;
   try {

package/src/commands/impact.mjs

@@ -9,7 +9,7 @@ import { readFile } from 'node:fs/promises';
 import { basename, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, fail, present } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { discover } from '../compare/discover.mjs';
 import { extract } from '../index/extract.mjs';
@@ -25,6 +25,7 @@ import {
 import { decisionHits, scopeHits, sortHits, sourceRoots } from '../index/govern.mjs';
 import { decisionRecords, ruleScopes } from './why.mjs';
 import { resolveWorkspace } from '../workspace.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 const exec = promisify(execFile);
 const TEXT_EXT = new Set(['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'json', 'yaml', 'yml', 'md', 'toml', 'xml', 'py', 'go', 'kt', 'java', 'rs']);
@@ -35,7 +36,7 @@ export async function impactCommand(args, flags, commands = []) {
   if (args.length > 1) return fail(`unknown impact argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} impact <file|symbol>`);
   const target = args[0];
   if (!target) return fail(`a file or a symbol is required`, EXIT.USAGE, `run: ${CLI} impact <file|symbol>`);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const listed = await tracked(root);
   if (listed.error) return listed.error;
   const files = new Set(listed.files);
@@ -63,11 +64,7 @@ export async function impactCommand(args, flags, commands = []) {
     consumers: consumers.references,
     truncated,
   };
-  if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
-    return EXIT.OK;
-  }
-  emit(render(payload), { maxBytes: flags.maxBytes ?? 0 });
+  present(payload, () => render(payload), flags);
   return EXIT.OK;
 }