simt-dev 0.6.2 → 0.7.0

package/src/commands/skillscompile.mjs

@@ -20,7 +20,8 @@ import { resolveVaultDir } from '../bench/mine.mjs';
 import { locateSource, sourceHeldLocally } from '../resolve/source.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
-import { CLI, STATE_DIR } from '../name.mjs';
+import { CLI } from '../name.mjs';
+import { LOCAL_DIR } from '../state.mjs';
 
 async function readSkillRawText(skill, workspaceRoot, root) {
   const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
@@ -44,7 +45,7 @@ async function readSkillRawText(skill, workspaceRoot, root) {
 
 async function loadGoldPathsByTask(root) {
   const map = new Map();
-  const tasksDir = join(root, STATE_DIR, 'bench', 'tasks');
+  const tasksDir = join(root, '.simt', 'bench', 'tasks');
   const vaultRoot = resolveVaultDir(root);
   const entries = (await readdir(tasksDir).catch(() => [])).filter((f) => f.endsWith('.json')).sort();
   for (const entry of entries) {
@@ -172,26 +173,26 @@ async function runSingleSkillCompile(skill, registry, { root, workspaceRoot, fla
     triggerStats,
   });
 
-  const outDir = join(root, STATE_DIR, 'compiled', 'skills', skill.name);
-  const proposalPath = join(root, STATE_DIR, 'proposals', 'skills', `${skill.name}.json`);
+  const outDir = join(root, LOCAL_DIR, 'compiled', 'skills', skill.name);
+  const proposalPath = join(root, LOCAL_DIR, 'proposals', 'skills', `${skill.name}.json`);
   const writtenFiles = [];
 
   if (mode.apply) {
     await mkdir(outDir, { recursive: true });
     await writeFile(join(outDir, 'SKILL.md'), compiled.mainText, 'utf8');
-    writtenFiles.push(`${STATE_DIR}/compiled/skills/${skill.name}/SKILL.md`);
+    writtenFiles.push(`${LOCAL_DIR}/compiled/skills/${skill.name}/SKILL.md`);
 
     for (const ref of compiled.references) {
       if (!ref.content) continue;
       const refFull = join(outDir, ref.path);
       await mkdir(dirname(refFull), { recursive: true });
       await writeFile(refFull, ref.content, 'utf8');
-      writtenFiles.push(`${STATE_DIR}/compiled/skills/${skill.name}/${ref.path}`);
+      writtenFiles.push(`${LOCAL_DIR}/compiled/skills/${skill.name}/${ref.path}`);
     }
 
     await mkdir(dirname(proposalPath), { recursive: true });
     await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
-    writtenFiles.push(`${STATE_DIR}/proposals/skills/${skill.name}.json`);
+    writtenFiles.push(`${LOCAL_DIR}/proposals/skills/${skill.name}.json`);
   }
 
   if (isJson(flags)) {

package/src/commands/skillsinstall.mjs

@@ -20,15 +20,17 @@
 //   3. References come with the skill. A skill whose reference files are missing
 //      is worse than one that was never installed, because it looks installed.
 
-import { cp, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, stat } from 'node:fs/promises';
+import { commitJournal, journaledCopyDir, journaledWriteFile } from '../journal.mjs';
+import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative, sep } from 'node:path';
 
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { loadRegistry, measureSkill } from '../graph/load.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { readCapability } from '../hooks/capability.mjs';
-import { MANIFEST, buildManifest, readManifest, writeManifest } from '../projection/manifest.mjs';
+import { MANIFEST, buildManifest, manifestPath, manifestText, readManifest, writeManifest } from '../projection/manifest.mjs';
 import { provenanceDigest } from '../projection/project.mjs';
 import { locateSource, sourceHeldLocally } from '../resolve/source.mjs';
 import { nearMatches } from '../resolve/near.mjs';
@@ -87,6 +89,18 @@ export async function installCommand(args, flags) {
 
   const found = await locateSource(pick.source, { workspaceRoot: ws.root, root });
   if (!found.path) {
+    // A repo-side candidate with the wrong size is a third reason, and it needs
+    // its own wording: the file is on the reader's disk, so "this repo does not
+    // hold it" would send them looking for a file that is already there. The
+    // variant path calls the same failure an impostor (chooseSource).
+    const impostor = found.candidates.find((c) => c.how === 'repo');
+    if (impostor) {
+      return fail(
+        `${skill.name}: ${root}/${pick.source.path} exists but is not the declared body (${pick.source.bytes} bytes declared)`,
+        EXIT.USAGE,
+        `run: ${CLI} graph lint --workspace <path>  to see what the registry expects, or delete the local copy`,
+      );
+    }
     // Two reasons land here and they need different wording: no workspace at all,
     // or a workspace that should hold this body and does not. An install that
     // cannot read a body has failed, so this is never a degraded mode - the
@@ -161,10 +175,18 @@ export async function installCommand(args, flags) {
   // `--yes --json` a command that reported a plan and changed nothing - the one
   // combination a script writes. The payload is now emitted once, at the end,
   // after the write it describes.
+  const mode = writeMode(flags);
+  // The `--diff` pairs, read before anything is written so the before side is
+  // true in preview and in apply alike (R50). Built before the early returns
+  // below so the shared `report()` can carry the field in every mode.
+  const diffs = flags.diff === true ? await skillDiffs(root, { src, dest, destRel: payload.dest, flat: measured.flat, name, record, repo }) : [];
   const report = () => {
-    if (isJson(flags)) emitJson(payload);
+    // `--json` used to return here, before anything was written, which made
+    // `--yes --json` a command that reported a plan and changed nothing - the one
+    // combination a script writes. The payload is now emitted once, at the end,
+    // after the write it describes.
+    if (isJson(flags)) emitJson({ ...payload, ...diffField(diffs, flags) });
   };
-  const mode = writeMode(flags);
 
   if (!isJson(flags)) {
     emit(
@@ -213,18 +235,22 @@ export async function installCommand(args, flags) {
   // "nothing written" and then wrote. It belongs on the path that does not write.
   if (!mode.apply) {
     note(`note    dry-run  nothing written; apply with: ${CLI} skills install ${name} --yes`);
+    // After the report: the report says what, the diff shows it (R50).
+    emitDiffs(diffs, flags);
     report();
     return EXIT.OK;
   }
 
+  // Every repo write below is journaled, so `undo` restores this run (R49).
+  const journal = [];
   await mkdir(dirname(join(dest, 'SKILL.md')), { recursive: true });
   try {
     if (measured.flat) {
-      await writeFile(join(dest, 'SKILL.md'), await wrapFlat(src, name), 'utf8');
+      await journaledWriteFile(root, journal, join(dest, 'SKILL.md'), await wrapFlat(src, name));
     } else {
       // References come with the skill: a skill whose reference files are missing
       // is worse than one that was never installed, because it looks installed.
-      await cp(src, dest, { recursive: true });
+      await journaledCopyDir(root, journal, src, dest);
     }
   } catch (error) {
     return fail(
@@ -236,12 +262,15 @@ export async function installCommand(args, flags) {
   payload.written = true;
   note(`wrote   ${payload.dest}`);
 
-  const recorded = await recordLocal(root, record, skill.name, repo);
+  const recorded = await recordLocal(root, record, skill.name, repo, journal);
   note(`${recorded.created ? 'created' : 'updated'} ${MANIFEST_FILE} localSkills`);
   if (recorded.created) {
     note(`note    this repo had no manifest; ${CLI} init still needs to run to project the rules`);
   }
   note(`note    ${name} is now repo-local and is excluded from central-drift accounting`);
+  await commitJournal(root, 'skills install', journal);
+  // After the report: the report says what, the diff shows it (R50).
+  emitDiffs(diffs, flags);
   report();
   return EXIT.OK;
 }
@@ -502,29 +531,82 @@ async function fileSha(path) {
  * default gates in it is a promise the repo cannot keep, and a command that installs one
  * skill is not entitled to make it.
  */
-async function recordLocal(root, record, name, repo) {
+/** Every regular file under a directory, absolute paths. Missing dir → []. */
+async function treeFiles(dir) {
+  let st;
+  try {
+    st = await stat(dir);
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+  if (!st.isDirectory()) return [dir];
+  const out = [];
+  for (const name of await readdir(dir)) {
+    out.push(...(await treeFiles(join(dir, name))));
+  }
+  return out;
+}
+
+function rel(root, path) {
+  return relative(root, path).split(sep).join('/');
+}
+
+/**
+ * The `--diff` pairs for an install: the skill files plus the manifest record
+ * (plan 0003 R50). The manifest pair needs the same object the write applies,
+ * so the plan is shared with `recordLocal` rather than derived twice.
+ */
+async function skillDiffs(root, { src, dest, destRel, flat, name, record, repo }) {
+  const pairs = [];
+  if (flat) {
+    pairs.push({
+      path: `${destRel}/SKILL.md`,
+      before: await readBefore(join(dest, 'SKILL.md')),
+      after: await wrapFlat(src, name),
+    });
+  } else {
+    // References come with the skill, so the diff walks the whole tree: only
+    // changed files render, the rest filter out as equal.
+    for (const abs of await treeFiles(src)) {
+      const destAbs = join(dest, relative(src, abs));
+      pairs.push({ path: rel(root, destAbs), before: await readBefore(destAbs), after: await readFile(abs, 'utf8') });
+    }
+  }
+  const planned = await planLocalRecord(root, record, name, repo);
+  if (!planned.error) {
+    pairs.push({
+      path: rel(root, await manifestPath(root)),
+      before: planned.manifest === null ? null : await readBefore(await manifestPath(root)),
+      after: manifestText(planned.next),
+    });
+  }
+  return pairs;
+}
+
+/**
+ * What `recordLocal` will write, computed without writing (plan 0003 R50).
+ * The diff shares this so the pair shows the same object the write applies.
+ */
+async function planLocalRecord(root, record, name, repo) {
   const { manifest, error } = await readManifest(root);
-  if (error) return { written: false, reason: error };
-
-  // A repo with no manifest gets one here, so this function writes a *promise* on that
-  // repo's behalf: it decides which gates the repo claims to run. Without a capability
-  // probe it wrote `format`, `lint`, `test` and `typecheck` into a repository with no
-  // scripts and no formatter, and `check` then reported four UNRUNNABLE gates. The moment
-  // hooks route through the manifest - which is the entire point of a gate - every commit
-  // in that repo is blocked, over gates nobody declared. ADR-017 exists to prevent exactly
-  // that, and a manifest written by a command that installs one skill was the way round it.
-  // `init` probes for the same reason; a second writer that does not is a defect waiting
-  // for the next command that needs a manifest.
-  const base =
-    manifest ??
-    (await buildManifest({
-      root,
-      stack: repo.stack,
-      sha: await provenanceDigest(),
-      capability: await readCapability(root),
-    }));
+  if (error) return { error };
+  const base = manifest ?? (await buildManifest({ root, stack: repo.stack, sha: await provenanceDigest(), capability: await readCapability(root) }));
   const existing = Array.isArray(base.localSkills) ? base.localSkills : [];
   const kept = existing.filter((e) => (typeof e === 'string' ? e : e?.name) !== name);
-  await writeManifest(root, { ...base, localSkills: [...kept, record] });
-  return { written: true, created: manifest === null };
+  return { manifest, next: { ...base, localSkills: [...kept, record] }, created: manifest === null };
+}
+
+async function recordLocal(root, record, name, repo, journal) {
+  // The manifest this writes is `planned.next`, built by `planLocalRecord`:
+  // a repo with no manifest gets one here, which is a promise about which
+  // gates the repo claims to run. Without the capability probe inside the
+  // plan it wrote `format`, `lint`, `test` and `typecheck` into a repository
+  // with no scripts and no formatter, and `check` then reported four
+  // UNRUNNABLE gates that blocked every commit (ADR-017). Deriving the object
+  // a second way here would be a second answer to what the repo promises.
+  const planned = await planLocalRecord(root, record, name, repo);
+  if (planned.error) return { written: false, reason: planned.error };
+  await writeManifest(root, planned.next, journal);
+  return { written: true, created: planned.created };
 }