@intentius/chant 0.79.0 → 0.81.0

package/src/cli/handlers/init.ts

@@ -1,9 +1,11 @@
-import { formatError } from "../format";
+import { formatError, formatSuccess, formatWarning } from "../format";
 import type { CommandContext } from "../registry";
 
 export async function runInit(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
 
+  if (args.migrateFrom !== undefined) return runInitFrom(ctx);
+
   if (!args.lexicon) {
     console.error(formatError({
       message: "Missing --lexicon flag",
@@ -47,3 +49,54 @@ export async function runInitLexicon(ctx: CommandContext): Promise<number> {
   await printInitLexiconResult(result);
   return result.success ? 0 : 1;
 }
+
+/**
+ * `chant init --from <repo>@<ref>[#<member>] [--param <name>=<value>]... [path]`
+ * (#2540, #2627): copy a template repository at a ref, substitute the
+ * parameters its `chant.template.json` declares, and record its lineage.
+ * The template brings its own lexicons and configuration, so `--lexicon` and
+ * `--template` do not apply.
+ */
+async function runInitFrom(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+  const usage = "Usage: chant init --from <repo>@<ref>[#<member>] [--param <name>=<value>]... [path]";
+  if (!args.migrateFrom) {
+    console.error(formatError({ message: "--from needs a template: <repo>@<ref>[#<member>]", hint: usage }));
+    return 1;
+  }
+  if (args.lexicon || args.template) {
+    console.error(formatError({ message: "--from cannot be combined with --lexicon or --template", hint: usage }));
+    return 1;
+  }
+  if (args.paramsFile) {
+    console.error(formatError({ message: "--params-file does not apply to init --from; pass each value with --param <name>=<value>", hint: usage }));
+    return 1;
+  }
+  const { parseParamArgs } = await import("../../workspace/template-manifest");
+  let params: Record<string, string>;
+  try {
+    params = parseParamArgs(args.param ?? []);
+  } catch (err) {
+    console.error(formatError({ message: (err as Error).message, hint: usage }));
+    return 1;
+  }
+  const { initFromCommand } = await import("../../workspace/lineage-init");
+  const result = await initFromCommand({
+    from: args.migrateFrom,
+    path: args.path === "." ? undefined : args.path,
+    force: args.force,
+    params,
+  });
+  if (!result.success) {
+    console.error(formatError({ message: result.error ?? "init --from failed", hint: usage }));
+    return 1;
+  }
+  for (const warning of result.warnings) console.error(formatWarning({ message: warning }));
+  console.log(formatSuccess("Created:"));
+  for (const file of result.createdFiles) console.log(`  ${file}`);
+  console.log("");
+  console.log(`Lineage: ${result.spec!.id} at ${result.spec!.ref} (${result.commit!.slice(0, 12)}), recorded in .chant/workspace.lock.json`);
+  const parameters = Object.entries(result.parameters ?? {});
+  if (parameters.length > 0) console.log(`Parameters: ${parameters.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ")}`);
+  return 0;
+}

package/src/cli/handlers/lifecycle.ts

@@ -1,3 +1,4 @@
+import { lexiconNames } from "../../lexicon-module";
 import { resolve } from "node:path";
 import { commandBuildParams } from "../build-params-cli";
 import { build } from "../../build";
@@ -559,7 +560,7 @@ interface BetweenDiffArgs {
 async function runLifecycleDiffBetween(args: BetweenDiffArgs): Promise<number> {
   await fetchLifecycle();
   const { config } = await loadChantConfig(resolve("."));
-  const lexicons = args.lexiconFilter ? [args.lexiconFilter] : config.lexicons ?? [];
+  const lexicons = args.lexiconFilter ? [args.lexiconFilter] : lexiconNames(config.lexicons ?? []);
   if (lexicons.length === 0) {
     console.error(formatError({ message: "No lexicons to diff — pass a lexicon or declare `lexicons` in chant.config." }));
     return 1;

package/src/cli/handlers/misc.ts

@@ -114,6 +114,21 @@ export async function runAudit(ctx: CommandContext): Promise<number> {
     return result.exitCode;
   }
 
+  // `--max-files` (#2528) only means something to the local walk. A URL audit
+  // fetches through the host's tree API with its own caps, so the flag is
+  // refused there rather than silently ignored.
+  const maxFiles = args.maxFiles;
+  if (maxFiles !== undefined) {
+    if (!Number.isInteger(maxFiles) || maxFiles < 1) {
+      console.error(formatError({ message: `--max-files must be a positive integer (got "${maxFiles}")` }));
+      return 1;
+    }
+    if (/^https?:\/\//.test(args.path)) {
+      console.error(formatError({ message: "--max-files applies to a local path; a repository URL is fetched with its own limits." }));
+      return 1;
+    }
+  }
+
   // HTML report customization: --template <file> (full override) + --theme <file> (JSON knobs).
   let template: string | undefined;
   let theme: ReportTheme | undefined;
@@ -146,6 +161,7 @@ export async function runAudit(ctx: CommandContext): Promise<number> {
     template,
     theme,
     toolVersion: CHANT_VERSION,
+    maxFiles,
   });
   printAuditResult(result);
   return result.exitCode;

package/src/cli/handlers/operator.test.ts

@@ -897,6 +897,74 @@ describe("runApprove — the resolution names the plan it approves (#2300)", ()
   });
 });
 
+/**
+ * #2574 — a component's gate ledger holds every environment's pending facts.
+ * The approval records the environment it answers, and `--env` picks it.
+ */
+describe("runApprove — a component gate approval names its environment (#2574)", () => {
+  const PLAN_STAGING = `sha256:${"c".repeat(64)}`;
+  const PLAN_PROD = `sha256:${"d".repeat(64)}`;
+  function seedTwoEnvironments(): void {
+    readGateLedgerMock.mockResolvedValue({
+      resolutions: [],
+      pending: [
+        {
+          version: 1, kind: "pending", op: "search-service", gate: "release",
+          timestamp: "2026-01-01T00:00:00.000Z", expiresAt: "2099-01-01T00:00:00.000Z",
+          planDigest: PLAN_STAGING, environment: "staging",
+        },
+        {
+          version: 1, kind: "pending", op: "search-service", gate: "release",
+          timestamp: "2026-01-02T00:00:00.000Z", expiresAt: "2099-01-01T00:00:00.000Z",
+          planDigest: PLAN_PROD, environment: "prod",
+        },
+      ],
+      malformed: 0,
+    });
+    appendGateResolutionMock.mockImplementation(async (input: object) => ({ commit: "sha", record: { version: 1, ...input } }));
+  }
+
+  test("without --env it approves the newest pending fact and records its environment", async () => {
+    seedTwoEnvironments();
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    expect(await runApprove(ctx({ path: "search-service", extraPositional: "release", actor: "alex" }))).toBe(0);
+    expect(appendGateResolutionMock).toHaveBeenCalledWith(expect.objectContaining({ planDigest: PLAN_PROD, environment: "prod" }));
+    expect(errSpy.mock.calls.map((c) => String(c[0])).join("\n")).toContain(`approves the plan ${PLAN_PROD} in environment "prod"`);
+    errSpy.mockRestore();
+  });
+
+  test("--env picks that environment's pending fact", async () => {
+    seedTwoEnvironments();
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    expect(await runApprove(ctx({ path: "search-service", extraPositional: "release", actor: "alex", env: "staging" }))).toBe(0);
+    expect(appendGateResolutionMock).toHaveBeenCalledWith(expect.objectContaining({ planDigest: PLAN_STAGING, environment: "staging" }));
+    errSpy.mockRestore();
+  });
+
+  test("--env with no pending fact there refuses and writes nothing", async () => {
+    seedTwoEnvironments();
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    expect(await runApprove(ctx({ path: "search-service", extraPositional: "release", actor: "alex", env: "dev" }))).toBe(1);
+    expect(appendGateResolutionMock).not.toHaveBeenCalled();
+    expect(errSpy.mock.calls.map((c) => String(c[0])).join("\n")).toContain('no pending fact in environment "dev"');
+    errSpy.mockRestore();
+  });
+
+  test("--env is ignored for a gate whose pending facts record no environment", async () => {
+    seedPending("fountain-apply", "rollout-gate", PLAN_A);
+    appendGateResolutionMock.mockImplementation(async (input: object) => ({ commit: "sha", record: { version: 1, ...input } }));
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    expect(await runApprove(ctx({ path: "fountain-apply", extraPositional: "rollout-gate", actor: "alex", env: "prod" }))).toBe(0);
+    expect(appendGateResolutionMock.mock.calls[0][0]).toMatchObject({ planDigest: PLAN_A });
+    expect(appendGateResolutionMock.mock.calls[0][0]).not.toHaveProperty("environment");
+    errSpy.mockRestore();
+  });
+});
+
 describe("runApprove — the ledger branch is read before it is appended to (#2303)", () => {
   test("reads the branch before recording the resolution", async () => {
     seedPending("fountain-apply", "rollout-gate", PLAN_A);

package/src/cli/handlers/operator.ts

@@ -6,6 +6,7 @@
  * `run.ts`'s `runOpLocal` shape (SIGINT → AbortController, `loadActivities`/
  * `loadProfiles` from the project's configured lexicons).
  */
+import { lexiconNames } from "../../lexicon-module";
 import { loadChantConfig } from "../../config";
 import { build } from "../../build";
 import { isResourceDeclarable } from "../../declarable";
@@ -43,7 +44,7 @@ import {
   type GateApprover, type GatePolicyDecision, type GatePolicyEvaluator, type ResolvedGateApproval,
 } from "../../op/gate-approval";
 import { approverOf, tallyGateApprovals } from "../../op/gate";
-import { FAN_OUT_GATE_OP } from "../../op/gate-name";
+import { FAN_OUT_GATE_OP, WORKSPACE_UPGRADE_GATE_OP } from "../../op/gate-name";
 import { pushLifecycle, requireLifecycleLedger } from "../../lifecycle/git";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
 import type { CommandContext } from "../registry";
@@ -52,7 +53,7 @@ import type { CommandContext } from "../registry";
 async function loadOperatorActivities() {
   let lexicons: string[] = [];
   try {
-    lexicons = (await loadChantConfig(process.cwd())).config.lexicons ?? [];
+    lexicons = lexiconNames((await loadChantConfig(process.cwd())).config.lexicons ?? []);
   } catch {
     // No/invalid chant.config — fall back to base activities only.
   }
@@ -688,7 +689,9 @@ export async function runApprove(ctx: CommandContext): Promise<number> {
     console.error(formatInfo(
       opName === FAN_OUT_GATE_OP
         ? `The next \`chant components fan-out\` decides this gate from scratch and records a fresh pending fact.`
-        : `The next \`chant run ${opName}\` decides this gate from scratch and records a fresh pending fact.`,
+        : opName === WORKSPACE_UPGRADE_GATE_OP
+          ? `The next \`chant workspace upgrade ${gate}\` decides this gate from scratch and records a fresh pending fact.`
+          : `The next \`chant run ${opName}\` decides this gate from scratch and records a fresh pending fact.`,
     ));
     return 0;
   }
@@ -702,6 +705,7 @@ export async function runApprove(ctx: CommandContext): Promise<number> {
     note: ctx.args.note,
     url: ctx.args.url,
     plan: ctx.args.plan,
+    ...(ctx.args.env !== undefined ? { environment: ctx.args.env } : {}),
     allowSameOrigin: ctx.args.allowSameOrigin,
     ...(ctx.args.roles ? { roles: ctx.args.roles } : {}),
     ...(ctx.args.agent ? { agent: true } : {}),
@@ -712,7 +716,9 @@ export async function runApprove(ctx: CommandContext): Promise<number> {
     `This records the resolution as a fact; it does not itself re-run anything. ` +
       (opName === FAN_OUT_GATE_OP
         ? `Repeat the \`chant components fan-out\` command and it walks through gate "${gate}".`
-        : `Run \`chant run ${opName}\` and it walks through gate "${gate}".`),
+        : opName === WORKSPACE_UPGRADE_GATE_OP
+          ? `Repeat \`chant workspace upgrade ${gate}\` with the same target, and it applies the patch this approval names.`
+          : `Run \`chant run ${opName}\` and it walks through gate "${gate}".`),
   ));
   return 0;
 }
@@ -746,6 +752,13 @@ export interface GateApprovalOptions {
    * stays one command: run, read what it planned, approve it.
    */
   plan?: string;
+  /**
+   * `--env <env>` (#2574) — which environment's pending fact a component gate
+   * approval answers. A component's gate ledger holds every environment's
+   * facts, so without it the newest one is approved. Ignored for a gate whose
+   * pending facts record no environment (every Op gate).
+   */
+  environment?: string;
   /** `--role` (#2508) — roles the approver claims. */
   roles?: string[];
   /**
@@ -785,7 +798,7 @@ export async function recordGateApproval(
   // `fan-out` is the op name every `chant components fan-out` gate is recorded
   // under (../handlers/fan-out.ts). It is a command rather than a declaration,
   // so there is no `*.op.ts` to find and nothing is wrong when none is there.
-  if (!ops.has(opName) && opName !== FAN_OUT_GATE_OP) {
+  if (!ops.has(opName) && opName !== FAN_OUT_GATE_OP && opName !== WORKSPACE_UPGRADE_GATE_OP) {
     console.error(formatWarning({
       message: `Op "${opName}" was not found among discovered *.op.ts declarations — recording the resolution anyway`,
     }));
@@ -825,6 +838,18 @@ export async function recordGateApproval(
   // third fallback: approving with no plan in sight is the behaviour
   // INTENTIUS/choudoufu#1026 measured, where the resolution authorised the
   // next run rather than anything anyone had seen.
+  // #2574: a component gate's pending facts carry the environment they were
+  // recorded in, and an approval answers one environment. `--env` picks it;
+  // without it, the newest standing fact decides, and the success line below
+  // names the environment it chose.
+  const ledgerBefore = await readGateLedger(opName);
+  const pendingFor = (all: PendingGateRecord[]): PendingGateRecord[] => {
+    const bound = all.some((p) => p.gate === gate && p.environment !== undefined);
+    return bound && opts.environment !== undefined ? all.filter((p) => p.environment === opts.environment) : all;
+  };
+  const standing = latestPendingGate(pendingFor(ledgerBefore.pending), gate);
+  const environment = standing?.environment;
+
   let planDigest: string | undefined;
   if (opts.plan !== undefined) {
     if (!isPlanDigest(opts.plan)) {
@@ -836,10 +861,12 @@ export async function recordGateApproval(
     }
     planDigest = opts.plan;
   } else {
-    const standing = latestPendingGate((await readGateLedger(opName)).pending, gate);
     if (!standing) {
       console.error(formatError({
-        message: `Gate "${gate}" on "${opName}" has no pending fact, so there is no plan to approve`,
+        message:
+          opts.environment !== undefined && ledgerBefore.pending.some((p) => p.gate === gate && p.environment !== undefined)
+            ? `Gate "${gate}" on "${opName}" has no pending fact in environment "${opts.environment}", so there is no plan to approve`
+            : `Gate "${gate}" on "${opName}" has no pending fact, so there is no plan to approve`,
         hint:
           `Run \`chant run ${opName}\` first — it plans, stops at the gate, and records the plan this ` +
           `approval would be for. To approve a plan you already have the digest for, pass ` +
@@ -858,7 +885,7 @@ export async function recordGateApproval(
   // the way #2300 refuses a plan nobody approved.
   const origin = opts.origin ?? currentGateOrigin();
   const ledger = await readGateLedger(opName);
-  const standingForOrigin = latestPendingGate(ledger.pending, gate);
+  const standingForOrigin = latestPendingGate(pendingFor(ledger.pending), gate);
   const refusal = sameOriginRefusal(standingForOrigin?.origin, origin);
   if (refusal && !opts.allowSameOrigin) {
     console.error(formatError({
@@ -934,6 +961,7 @@ export async function recordGateApproval(
     ...(opts.note ? { note: opts.note } : {}),
     ...(url ? { url } : {}),
     ...(planDigest !== undefined ? { planDigest } : {}),
+    ...(environment !== undefined ? { environment } : {}),
     origin,
     ...(refusal && opts.allowSameOrigin ? { sameOriginOverride: true } : {}),
   });
@@ -949,8 +977,9 @@ export async function recordGateApproval(
   ));
   if (record.planDigest) {
     console.error(formatInfo(
-      `This approves the plan ${record.planDigest}, and only that plan. A run whose fresh plan ` +
-        "differs refuses rather than applying it.",
+      `This approves the plan ${record.planDigest}` +
+        (record.environment !== undefined ? ` in environment "${record.environment}"` : "") +
+        ", and only that plan. A run whose fresh plan differs refuses rather than applying it.",
     ));
   }
   if (approval) {