@intentius/chant 0.56.0 → 0.58.0

package/src/cli/main.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from "vitest";
 import { EventEmitter } from "node:events";
-import { parseArgs, waitForStreamDrain } from "./main";
+import { parseArgs, waitForStreamDrain, usesRemovedTemporalFlag, REMOVED_TEMPORAL_FLAG, REMOVED_FLAG_EXIT_CODE } from "./main";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
 
 describe("parseArgs", () => {
@@ -10,6 +10,17 @@ describe("parseArgs", () => {
     expect(parseArgs(["build", "src", "--no-fold"]).fold).toBe(false);
   });
 
+  // #2192 — #2130 deleted `-p/--profile` with the Temporal runtime, on the
+  // belief nothing outside it read the flag. #2124 had already documented it
+  // for fountain, so the flag is back and reaches the runtime seam.
+  test("-p/--profile carries the runtime's connection profile (#2124)", () => {
+    expect(parseArgs(["run", "prod-apply", "--on", "fountain"]).profile).toBeUndefined();
+    expect(parseArgs(["run", "prod-apply", "--on", "fountain", "--profile", "staging"]).profile).toBe("staging");
+    expect(parseArgs(["run", "prod-apply", "--on", "fountain", "-p", "staging"]).profile).toBe("staging");
+    // The joined form `splitJoinedFlags` rewrites into two tokens.
+    expect(parseArgs(["run", "prod-apply", "--profile=staging"]).profile).toBe("staging");
+  });
+
   test("--namespace carries the live read's namespace default (#1629)", () => {
     expect(parseArgs(["graph", "--live", "--env", "prod"]).namespace).toBeUndefined();
     expect(parseArgs(["graph", "--live", "--env", "prod", "--namespace", "app-b"]).namespace).toBe("app-b");
@@ -578,19 +589,21 @@ describe("resolveCommand", () => {
   });
 });
 
-describe("parseArgs — run flags", () => {
-  test("parses --profile flag", () => {
-    const result = parseArgs(["run", "alb-deploy", "--profile", "local"]);
-    expect(result.command).toBe("run");
-    expect(result.path).toBe("alb-deploy");
-    expect(result.profile).toBe("local");
+describe("--temporal, removed in #2116", () => {
+  test("the flag is caught before parseArgs, with the line that says where the runtime went", () => {
+    expect(usesRemovedTemporalFlag(["run", "alb-deploy", "--temporal"])).toBe(true);
+    expect(usesRemovedTemporalFlag(["run", "alb-deploy", "--temporal=true"])).toBe(true);
+    expect(REMOVED_TEMPORAL_FLAG).toBe("--temporal was removed in #2116; use --on fountain");
+    expect(REMOVED_FLAG_EXIT_CODE).toBe(2);
   });
 
-  test("parses -p shorthand for --profile", () => {
-    const result = parseArgs(["run", "alb-deploy", "-p", "cloud"]);
-    expect(result.profile).toBe("cloud");
+  test("an invocation without it is untouched, and the parser has forgotten the flag", () => {
+    expect(usesRemovedTemporalFlag(["run", "alb-deploy", "--on", "fountain"])).toBe(false);
+    expect(() => parseArgs(["run", "alb-deploy", "--temporal"])).toThrow(/Unknown flag/);
   });
+});
 
+describe("parseArgs — run flags", () => {
   test("parses --report flag", () => {
     const result = parseArgs(["run", "alb-deploy", "--report"]);
     expect(result.command).toBe("run");
@@ -603,11 +616,6 @@ describe("parseArgs — run flags", () => {
     expect(result.report).toBe(undefined);
   });
 
-  test("profile is undefined when not provided", () => {
-    const result = parseArgs(["run", "alb-deploy"]);
-    expect(result.profile).toBe(undefined);
-  });
-
   test("run signal parses op name and signal into positionals", () => {
     const result = parseArgs(["run", "signal", "alb-deploy", "gate-dns"]);
     expect(result.command).toBe("run");

package/src/cli/main.ts

@@ -30,7 +30,7 @@ import { runScenarioCheck, runScenarioUnknown } from "./handlers/scenario";
 import { runGraph } from "./handlers/graph";
 import { runExplain } from "./handlers/explain";
 import { runSearch } from "./handlers/search";
-import { runOp, runOpList, runOpStatus, runOpSignal, runOpCancel, runOpLog } from "./handlers/run";
+import { runOp, runOpList, runOpStatus, runOpApprove, runOpSignalRenamed, runOpCancel, runOpLog } from "./handlers/run";
 import { runOperator, runOperatorStatus, runOperatorLog, runApprove } from "./handlers/operator";
 import { runEmulator } from "./handlers/emulator";
 import { splitJoinedFlags, dispatchCommandGroup, collectCommandGroups, formatCommandGroupsHelp, type CommandGroup } from "./command-group";
@@ -71,7 +71,6 @@ const BOOLEAN_FLAGS = new Set([
   "--down",
   "--include-dependents",
   "--local",
-  "--temporal",
   "--json",
   "--progress-json",
   "--update-snapshot",
@@ -86,14 +85,37 @@ const BOOLEAN_FLAGS = new Set([
   "--yes",
   "--confirm-prod",
   "--once",
+  "--expire",
   "--check-live",
   "--check-snapshot",
   "--fail-on-drift",
+  "--durable-requests",
 ]);
 
 /**
  * Parse command line arguments
  */
+/**
+ * `--temporal` picked the Temporal runtime, which #2116 deleted. It is caught
+ * ahead of {@link parseArgs} — which no longer knows the flag at all — for one
+ * minor version, so an invocation that still carries it is told where the
+ * runtime went instead of getting "Unknown flag: --temporal" and a pointer at
+ * `--help`. Delete this, its test and the constants below once that version
+ * has shipped.
+ */
+export const REMOVED_TEMPORAL_FLAG = "--temporal was removed in #2116; use --on fountain";
+
+/**
+ * Not 1: a removed flag means the command never started, so a CI job that
+ * retries a failed run has nothing to retry here.
+ */
+export const REMOVED_FLAG_EXIT_CODE = 2;
+
+/** Matches the bare flag and the joined `--temporal=…` form `splitJoinedFlags` would otherwise split. */
+export function usesRemovedTemporalFlag(argv: string[]): boolean {
+  return argv.some((arg) => arg === "--temporal" || arg.startsWith("--temporal="));
+}
+
 export function parseArgs(args: string[]): ParsedArgs {
   // Local mutable copy — chant #1127's joined-`--flag=value` splitting below
   // rewrites the array in place (one token becomes two), so this must not
@@ -115,12 +137,11 @@ export function parseArgs(args: string[]): ParsedArgs {
     watch: false,
     verbose: false,
     help: false,
-    profile: undefined,
     param: undefined,
     paramsFile: undefined,
     report: undefined,
     local: undefined,
-    temporal: undefined,
+    profile: undefined,
     json: undefined,
     live: false,
     migrateFrom: undefined,
@@ -303,12 +324,16 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.includeDependents = true;
     } else if (arg === "--local") {
       result.local = true;
-    } else if (arg === "--temporal") {
-      result.temporal = true;
     } else if (arg === "--json") {
       result.json = true;
     } else if (arg === "--progress-json") {
       result.progressJson = true;
+    } else if (arg === "--durable-requests") {
+      // `chant run approve ... --on <lexicon> --durable-requests` (#2126) —
+      // resolve the gate on the hosting runtime's own request path rather
+      // than by posting a follow-up prompt. Core only carries the flag; the
+      // runtime decides whether it has such a path.
+      result.durableRequests = true;
     } else if (arg === "--update-snapshot") {
       result.updateSnapshot = true;
     } else if (arg === "--update-baseline") {
@@ -345,6 +370,10 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.actor = args[++i];
     } else if (arg === "--approver") {
       result.approver = args[++i];
+    } else if (arg === "--on") {
+      // `chant run ... --on <lexicon>` (#2121) — which runtime hosts the run.
+      result.on = args[++i];
+      if (!result.on || result.on.startsWith("-")) throw new Error("--on needs a runtime name: --on <lexicon>");
     } else if (arg === "--compare-to") {
       result.compareTo = args[++i];
     } else if (arg === "--no-release-record") {
@@ -389,6 +418,8 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.once = true;
     } else if (arg === "--note") {
       result.note = args[++i];
+    } else if (arg === "--expire") {
+      result.expire = true;
     } else if (arg === "--url") {
       result.url = args[++i];
     } else if (arg === "--op") {
@@ -463,7 +494,7 @@ Commands:
                          chant code instead of reading a template file)
   audit [path|url]      Audit a repo's CI YAML for security issues
                         (--format stylish|json|sarif|markdown|html, -o <file>,
-                         --tier merge-worthy|all, --fail-on merge-worthy|warning|none,
+                         --tier merge-worthy|all, --fail-on merge-worthy|warning|error|none,
                          --template <file> / --theme <file> for the html report)
                         --agents audits this machine's agent configuration —
                         instruction files, MCP servers, skills, plugins,
@@ -505,18 +536,12 @@ Commands:
                                           applied) and path. Read-only.
 
 Ops:
-  run <name>            Start an Op workflow (spawns worker + submits to Temporal)
-  run list              List all Ops with current run status
-                        --components: list discovered Components instead (--temporal
-                        also annotates each with its latest run status; #599)
-  run status <name>     Show current workflow run state
-                        --components: show a Component's durable run state instead (#599)
-  run signal <name> <signal>  Send a named signal to unblock a gate
-                        --components: signal a Component's workflow instead (#589)
-  run cancel <name>     Cancel the active workflow run (requires --force)
-                        --components: cancel a Component's workflow instead (#589)
+  run <name>            Run an Op on the resolved runtime (--on; local by default)
+  run list              List all Ops with the runtime's state for each
+  run status <name>     Show the runtime's state for one Op's latest run
+  run approve <op> <gate>  Record a gate's resolution and wake the runtime
+  run cancel <name>     Cancel the active run (requires --force)
   run log <name>        Show run history for an Op
-                        --components: show a Component's run history instead (#599)
   run --components <name|all>  Run discovered Component(s) through the interpret
                         driver on the local executor (--env <env>; #585).
                         On success, auto-emits a release-ledger record per
@@ -528,7 +553,7 @@ Ops:
                         progress instead of tailing raw logs (additive; run
                         semantics/exit code unchanged)
   operator               Run scheduled ticks for discovered ConvergeOps
-                        locally, no Temporal (#1485): acquire/renew a per-op
+                        locally (#1485): acquire/renew a per-op
                         lease (git ref CAS), tick on --interval, record every
                         result as a ledger fact. --env <env> scopes to one
                         environment; --interval <dur> (default 60s) and
@@ -548,13 +573,14 @@ Ops:
                         silently short
   approve <op> <gate>    Record a gate's out-of-band resolution fact
                         (--actor <name>, --note <text>, --url <url>) — the
-                        durable counterpart to a converge tick's
-                        gate-as-fact outcome; see the pending-gates list in
-                        operator status. --url is the PR/MR the resolution
+                        durable counterpart to the pending fact a run records
+                        when it reaches the gate; see the pending-gates list
+                        in operator status. --url is the PR/MR the resolution
                         happened at, recorded typed rather than as free text,
                         and defaults to the PR/MR of the surrounding CI job.
-                        Does not itself unblock the gated op's local
-                        dispatch (re-run --temporal, or merge its PR)
+                        The next "chant run <op>" walks through the gate.
+                        --expire clears a pending fact without approving it,
+                        so the gate is re-decided from scratch next run
 
   graph                 Show Op dependency graph (--stacks for cross-stack order,
                         --format ir|mermaid|dot|layout for the lint-gated graph IR,
@@ -663,12 +689,15 @@ Options:
                         resolved build parameter and per-file fold decision
                         instead of the one-line summaries
   -h, --help            Show this help message
-  -p, --profile <name>  Temporal worker profile to use (run command)
+  --on <lexicon>        Which runtime hosts the run: a configured lexicon with
+                        an opRuntime, or the built-in local runtime when
+                        omitted (every run subcommand; #2121)
   --local               Run an Op with the local in-process executor (default)
-  --temporal            Run an Op via a Temporal cluster (gates, schedules, durable resume)
+  -p, --profile <name>  Named connection profile the hosting runtime targets
+                        (fountain.profiles in chant.config.ts); each runtime's
+                        own default when omitted (#2124)
   --json                Emit the structured run result as JSON (run command)
-  --report              Print deployment report instead of running (run command)
-                        OR with a path arg: SARIF report destination (migrate)
+  --report              With a path arg: SARIF report destination (migrate)
                         OR '--report gitlab-mr': emit the GitLab MR plan-widget
                         JSON (lifecycle plan)
                         OR '--report markdown': emit a reviewer-facing markdown
@@ -794,8 +823,17 @@ async function tryPluginCommand(rawArgv: string[]): Promise<number | undefined>
   if (!groupName || groupName.startsWith("-")) return undefined;
 
   const plugins = await loadPluginsBestEffort();
-  const rawArgs = rawArgv.slice(2);
-  const result = await dispatchCommandGroup(plugins, groupName, verbName, rawArgs);
+
+  // A group declaring a `defaultVerb` (#2125) answers its bare name, so
+  // `chant acp` and `chant acp --durable-requests` both reach that verb. The
+  // slicing follows: with no verb token consumed, everything after the group
+  // name is the default verb's own argument list.
+  const group = collectCommandGroups(plugins).find((g) => g.name === groupName);
+  const useDefault =
+    group?.defaultVerb !== undefined && (verbName === undefined || verbName.startsWith("-"));
+  const verb = useDefault ? group?.defaultVerb : verbName;
+  const rawArgs = rawArgv.slice(useDefault ? 1 : 2);
+  const result = await dispatchCommandGroup(plugins, groupName, verb, rawArgs);
 
   if (result.kind === "no-group") return undefined;
   if (result.kind === "usage-error") {
@@ -852,7 +890,17 @@ async function loadPluginsOrExit(path: string): Promise<import("../lexicon").Lex
 
 // ── Command registry ──────────────────────────────────────────────
 
-const registry: CommandDef[] = [
+/**
+ * Every command word `chant` answers to, and the handler behind it.
+ *
+ * Exported because a caller other than `main()` now needs to ask "is this a
+ * chant verb, and what runs it?" — the fountain lexicon's ACP server (#2125)
+ * treats a prompt as a chant command line, and the only honest answer to
+ * whether `chant lifecycle diff` is a verb is this list. A hand-kept copy
+ * would be wrong the first time a command is added, and the ACP server would
+ * refuse a verb that works at the terminal.
+ */
+export const commandRegistry: CommandDef[] = [
   // Primary commands
   { name: "build", requiresPlugins: true, handler: runBuild },
   { name: "lint", handler: runLint },
@@ -897,7 +945,8 @@ const registry: CommandDef[] = [
   // Op / run subcommands
   { name: "run list", handler: runOpList },
   { name: "run status", handler: runOpStatus },
-  { name: "run signal", handler: runOpSignal },
+  { name: "run approve", handler: runOpApprove },
+  { name: "run signal", handler: runOpSignalRenamed },
   { name: "run cancel", handler: runOpCancel },
   { name: "run log", handler: runOpLog },
   { name: "run", handler: runOp },
@@ -957,6 +1006,12 @@ const registry: CommandDef[] = [
 async function main(): Promise<void> {
   const rawArgv = process.argv.slice(2);
 
+  if (usesRemovedTemporalFlag(rawArgv)) {
+    console.error(formatError({ message: REMOVED_TEMPORAL_FLAG }));
+    await flushAndExit(REMOVED_FLAG_EXIT_CODE);
+    return;
+  }
+
   let args: ParsedArgs;
   try {
     args = parseArgs(rawArgv);
@@ -1026,7 +1081,7 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  const match = resolveCommand(args, registry);
+  const match = resolveCommand(args, commandRegistry);
   if (!match) {
     // chant #1078 — not one of core's own commands; check whether a lexicon
     // mounted a command group under this name before giving up. This is the