simt-dev 0.6.2 → 0.7.0

package/src/commands/index.mjs

@@ -31,6 +31,7 @@ import { initCommand } from './init.mjs';
 import { ciCommand } from './ci.mjs';
 import { hooksCommand } from './hooks.mjs';
 import { agentHookCommand, agentHooksCommand } from './agenthook.mjs';
+import { agentsCommand } from './agent.mjs';
 import { compareCommand } from './compare.mjs';
 import { upgradeCommand } from './upgrade.mjs';
 import { mcpCommand } from './mcp.mjs';
@@ -38,7 +39,7 @@ import { pluginCommand } from './plugin.mjs';
 import { packCommand } from './pack.mjs';
 import { installCommand } from './skillsinstall.mjs';
 import { compileCommand } from './skillscompile.mjs';
-import { listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
+import { decisionsCommand as rulesDecisions, listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
 import { tokensCommand } from './tokens.mjs';
 import { harnessCommand, harnessLoadersCommand } from './harness.mjs';
 import {
@@ -51,7 +52,11 @@ import {
   benchCriticCommand,
 } from './bench.mjs';
 import { planCommand } from './plan.mjs';
-import { sharedPlanCommand, sharedInstallCommand, sharedWarning } from './shared.mjs';
+import { sliceCommand } from './slice.mjs';
+import { leaseCommand } from './lease.mjs';
+import { sharedPlanCommand, sharedInstallCommand } from './shared.mjs';
+import { runDoctor } from './doctor.mjs';
+import { statusCommand } from './status.mjs';
 import { evidenceCommand } from './evidence.mjs';
 import { indexCommand } from './repoindex.mjs';
 import { mapCommand } from './map.mjs';
@@ -59,15 +64,18 @@ import { testsCommand } from './tests.mjs';
 import { whyCommand } from './why.mjs';
 import { gateCommand } from './gate.mjs';
 import { impactCommand } from './impact.mjs';
-import { lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
+import { lessonsCaptureCommand, lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
 import { decideCommand } from './decide.mjs';
+import { explainCommand } from './explain.mjs';
+import { undoCommand } from './undo.mjs';
+import { prBodyCommand } from './prbody.mjs';
+import { ignoreCommand } from './ignore.mjs';
+import { completionsCommand } from './completions.mjs';
 import { reviewCommand } from './review.mjs';
 import { localDoctorCommand } from './local.mjs';
 import { distillCommand } from './distill.mjs';
-import { parse } from '../argv.mjs';
+import { parse, rawJsonFlag } from '../argv.mjs';
 import { CLI } from '../name.mjs';
-import { fingerprint } from '../resolve/fingerprint.mjs';
-import { resolveWorkspace } from '../workspace.mjs';
 
 /** command path -> implementation sequence step (plan 0002 section 11). */
 // Every command named in plan 0002 section 5 is now implemented, so this map is empty.
@@ -83,7 +91,15 @@ const GROUPS = new Map([
   ['rules', 'list'],
   ['hooks', 'status'],
   ['plan', 'status'],
+  // Plan 0003 R53. Both halves write, so a bare `slice` has no read to default to.
+  // `start` is the default because with the id it is missing it fails with a usage
+  // error before anything is created — the one default here that cannot mutate.
+  ['slice', 'start'],
   ['agent-hooks', 'status'],
+  // A group like `agent-hooks`: `install` writes the agent file into each harness's
+  // own directory, `status` reports what each harness carries. The default is the
+  // read, the way `agent-hooks`'s is.
+  ['agents', 'status'],
   ['harness', 'detect'],
   ['bench', 'mine'],
   // ADR-084. `shared` is the one group whose default writes nothing, and it is `plan` for
@@ -114,6 +130,9 @@ const GROUPS = new Map([
 export const IMPLEMENTED = {
   brief: briefCommand,
   doctor: runDoctor,
+  // Plan 0003 R48. A bare command: the only mode is `--line`, so there is no
+  // group and no default subcommand to resolve.
+  status: statusCommand,
   'graph lint': lintCommand,
   'skills index': skillsIndex,
   'skills find': skillsFind,
@@ -123,6 +142,7 @@ export const IMPLEMENTED = {
   'skills eval': skillsEval,
   'skills install': installCommand,
   'skills compile': compileCommand,
+  'rules decisions': rulesDecisions,
   'rules list': rulesList,
   'rules show': rulesShow,
   'rules why': rulesWhy,
@@ -131,6 +151,13 @@ export const IMPLEMENTED = {
   'plan status': (args, flags) => planCommand('status', args, flags),
   'plan next': (args, flags) => planCommand('next', args, flags),
   'plan done': (args, flags) => planCommand('done', args, flags),
+  // Plan 0003 R53. A group: `start` isolates the work on a branch with its brief,
+  // `finish` runs the gates, commits and records the evidence, and `abandon`
+  // (review 0003 Q23) takes the slice back down. All three take the slice id
+  // as a positional.
+  'slice start': (args, flags) => sliceCommand('start', args, flags),
+  'slice finish': (args, flags) => sliceCommand('finish', args, flags),
+  'slice abandon': (args, flags) => sliceCommand('abandon', args, flags),
   'shared plan': sharedPlanCommand,
   'shared install': sharedInstallCommand,
   evidence: evidenceCommand,
@@ -140,9 +167,26 @@ export const IMPLEMENTED = {
   why: (args, flags) => whyCommand(args, flags, COMMANDS),
   gate: gateCommand,
   impact: (args, flags) => impactCommand(args, flags, COMMANDS),
+  'lessons capture': lessonsCaptureCommand,
   'lessons list': lessonsListCommand,
   'lessons review': lessonsReviewCommand,
   decide: decideCommand,
+  // Plan 0003 R46. A bare command: the code is a positional, so there is no
+  // group and no default subcommand to resolve.
+  explain: explainCommand,
+  // Plan 0003 R49. A bare command: restoring the last journaled set needs no
+  // subcommand, so there is no group and no default to resolve.
+  undo: undoCommand,
+  // Plan 0003 R55. A bare command: the body is derived from the tree, the
+  // ledger and the last check, so there is no subcommand to resolve and no
+  // write to confirm.
+  'pr-body': prBodyCommand,
+  // Plan 0003 R52. A bare command: the one list is `.simtignore`, so there is no
+  // group and no default subcommand to resolve.
+  ignore: ignoreCommand,
+  // Plan 0003 R54. A bare command: paths claim, no paths list, so the argument itself
+  // is the mode and there is no group to resolve.
+  lease: leaseCommand,
   distill: distillCommand,
   // R25 machinery needs the runnable command names for Affects command tokens,
   // same wiring `why` and `impact` get through their lambdas.
@@ -157,6 +201,10 @@ export const IMPLEMENTED = {
   'agent-hook': agentHookCommand,
   'agent-hooks install': (args, flags) => agentHooksCommand('install', args, flags),
   'agent-hooks status': (args, flags) => agentHooksCommand('status', args, flags),
+  // ADR-111. The one agent this tool ships, written into each harness's own agents
+  // directory. A group like `agent-hooks`: `install` writes, `status` reads.
+  'agents install': (args, flags) => agentsCommand('install', args, flags),
+  'agents status': (args, flags) => agentsCommand('status', args, flags),
   compare: compareCommand,
   tokens: tokensCommand,
   'harness detect': harnessCommand,
@@ -177,6 +225,9 @@ export const IMPLEMENTED = {
   // plan 0003 R43. A bare command: the kind is a positional, so there is no group and
   // no default subcommand to resolve.
   plugin: pluginCommand,
+  // Plan 0003 R51. A bare command: the shell is a positional. `COMMANDS` rides in
+  // from here so the engine keeps no second copy of the registry it completes.
+  completions: (args, flags) => completionsCommand(args, flags, COMMANDS),
   // Plan 0003 R45. A group, not a bare command: `new` and `publish` write (or
   // publish) and `lint` reads, and the dispatcher routes all three through one
   // subcommand switch the way `hooks` does.
@@ -192,7 +243,7 @@ export const IMPLEMENTED = {
 export const COMMANDS = Object.keys(IMPLEMENTED).sort();
 
 export async function dispatch(argv) {
-  const { flags, positional } = parseOrExit(argv);
+  const { flags, positional, parseError } = parseOrExit(argv);
 
   // The JSON shape is decided once, here, and every command inherits it. Threading a
   // `--pretty` through twenty-five call sites would mean twenty-five places to forget,
@@ -205,6 +256,10 @@ export async function dispatch(argv) {
   jsonIndentDefault(flags.pretty === true);
   jsonFailMode(flags.json === true);
 
+  // A parse failure is already the whole answer: report it once, in the asked-for
+  // shape, rather than falling through to `unknown command` on the empty path.
+  if (parseError !== undefined) return fail(parseError.message, parseError.code);
+
   // Help is shown only when explicitly asked for. An unknown command must fail with
   // a usage code, not print 40 lines of prose and exit 0 — an agent that mistyped
   // needs to be told so, not handed a wall of text it may misread as output.
@@ -267,102 +322,14 @@ function commandPath(first, second) {
 }
 
 function parseOrExit(argv) {
+  // Unreachable from `bin` (it renders the failure itself and exits), but `dispatch`
+  // is also called directly: carry the failure as data so the dispatcher reports it
+  // once, in the asked-for shape, instead of printing here and again below.
   const parsed = parse(argv);
-  if (!parsed.ok) return { flags: {}, positional: [] };
+  if (!parsed.ok) {
+    const json = rawJsonFlag(argv);
+    return { flags: { json }, positional: [], parseError: parsed.error };
+  }
   return parsed.value;
 }
 
-/**
- * Step 3 of the implementation sequence: classify a repo from marker files alone.
- * Deliberately shipped early — it needs no registry, no rules and no projection,
- * and it makes the tool useful before any content exists.
- */
-async function runDoctor(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
-  const result = await fingerprint(root);
-  // Which source answered the workspace question, and where it looked. A tool
-  // that silently fell back to the wrong directory would make every downstream
-  // answer confidently wrong, so the answer is reported rather than inferred
-  // (ADR-014).
-  const ws = await resolveWorkspace(flags);
-  // The shared file this repository hands rules to (ADR-084). Asked here and nowhere else
-  // because it is the one thing about a repository that is true of the reader's machine
-  // rather than of the tree: `check` must not read `$HOME`, so `doctor` is the only command
-  // that can notice a region that dropped rules into a file nobody has. Reported, never
-  // blocking — a stale copy costs a reader some of their rules, which is worth knowing and
-  // is not this repository's gate failing.
-  const shared = await sharedWarning(root, result.manifest ?? null, flags);
-
-  // Under `--json` the document is the whole report, so it has to carry both
-  // failures the text path reports AND the workspace answer the text path prints.
-  // This branch used to return before either check, with `ok` hardcoded true: a
-  // caller asking whether their config is readable was told yes, and given exit
-  // 0, while the same command in a terminal exited 3 and named the file. A
-  // scripted consumer has only this document to go on, so `ok` is derived from
-  // the exit code rather than written as a constant (S10).
-  const failure = result.error
-    ? { error: `${root}: ${result.error}`, remedy: null }
-    : ws.error
-      ? {
-          error: `workspace config ${ws.detail}: ${ws.error}`,
-          remedy: 'fix the JSON, or remove the file',
-        }
-      : null;
-  const code = failure ? EXIT.CONFIG : EXIT.OK;
-
-  if (isJson(flags)) {
-    emitJson({
-      ok: code === EXIT.OK,
-      command: 'doctor',
-      root,
-      ...result,
-      // The workspace answer is a fact about which directory the tool would
-      // act on next (ADR-014). It is printed in the text report; leaving it
-      // out of the JSON meant a machine-readable caller could not see it at
-      // all, which is the one-question-two-answers defect again.
-      workspace: {
-        root: ws.root ?? null,
-        source: ws.source,
-        detail: ws.detail,
-        error: ws.error ?? null,
-      },
-      shared,
-      ...(failure ?? {}),
-    });
-    return code;
-  }
-  if (result.error) {
-    return fail(`${root}: ${result.error}`, EXIT.CONFIG);
-  }
-  emit(
-    [
-      `root     ${root}`,
-      `stack    ${result.stack.length > 0 ? result.stack.join(', ') : '(undetected)'}`,
-      `evidence ${result.evidence.length > 0 ? result.evidence.join(' ') : '(none)'}`,
-      // Facts are what a profile selects on when it wants to survive the
-      // framework being replaced, so they are reported with the path that proved
-      // each one rather than as a bare list (ADR-013).
-      `facts    ${
-        result.facts.length > 0
-          ? result.facts.map((f) => `${f}(${result.factEvidence[f] ?? '?'})`).join(' ')
-          : '(none)'
-      }`,
-      `manifest ${result.manifest ? (result.manifest.error ?? result.manifest.id ?? 'present') : '(absent)'}`,
-      `workspace ${ws.root ?? '(none)'}  (${ws.source}: ${ws.detail})`,
-      // Printed only when this repository handed rules to a workspace copy: a line in
-      // every `doctor` is a line in every reader's terminal, and the reader who has
-      // nothing to install is not served by one (ADR-084).
-      ...(shared.declared ? [`shared    ${shared.state}  ${shared.detail}`] : []),
-    ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
-  );
-  // An unconfigured workspace is a fact, not a failure: a single repo with no
-  // workspace around it is a normal, supported case. A config file that EXISTS and
-  // does not parse is a real mistake, and that does fail - with the parse error,
-  // because naming the file without saying what is wrong with it sends the reader
-  // to the file and gives them nothing to look for.
-  if (ws.error) {
-    return fail(`workspace config ${ws.detail}: ${ws.error}`, EXIT.CONFIG, 'fix the JSON, or remove the file');
-  }
-  return EXIT.OK;
-}