@intentius/chant 0.124.27 → 0.124.29

package/dist/cli/handlers/fan-out.js

@@ -34,6 +34,15 @@
  * the plan before the gate is decided, and the digest is carried rather than
  * recomputed, so the approval still stands.
  *
+ * The approval and the progress are bound to different things (#4081). The
+ * approval is bound to the plan digest, the derivation: who runs, in what
+ * order, off which edges. The progress is bound to each component's input
+ * digest (../../components/fan-out-inputs.ts): a component the earlier
+ * attempt applied stays `already-applied` only while what it would apply is
+ * the same, and one whose template, step inputs or upstream moved runs again
+ * with a line saying so. The fix after a failure keeps the approval, and a
+ * different change of the same shape does not inherit the progress.
+ *
  * `--wave-gate <name>` (#3049) swaps the one gate for one per wave: the same
  * repeated command stops at each wave's gate in turn, each planned after the
  * wave before it applied, and `chant approve fan-out <name>-wave-<n>` answers
@@ -48,9 +57,11 @@ import { changedFilesBetween, lexiconChangedUnits } from "../../components/chang
 import { deriveFanOut, fanOutRegistry } from "../../components/fan-out-support.js";
 import { EarlierWaveNotAppliedError, runFanOut } from "../../components/fan-out-run.js";
 import { readFanOutAttempt, writeFanOutAttempt } from "../../components/fan-out-record.js";
+import { componentInputDigests, progressThatCarries } from "../../components/fan-out-inputs.js";
 import { describeChangedWave, withWaveRecord } from "../../gated-waves.js";
 import { renderFanOutHuman, renderFanOutJson, renderFanOutPlan } from "../../components/fan-out-output.js";
 import { ndjsonProgressSink } from "../../components/run-progress.js";
+import { openCliRunEvents, refusesBothStreams } from "../run-events.js";
 import { summaryLedgerPrefix, writeGatedRunSummary } from "../../op/gate-summary.js";
 import { approveCommand, gateIsSealed } from "../../op/gate.js";
 import { getHeadCommit } from "../../lifecycle/git.js";
@@ -59,7 +70,7 @@ import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli.js";
 import { formatError, formatInfo, formatWarning } from "../format.js";
 import { FAN_OUT_GATE_OP } from "../../op/gate-name.js";
 import { resolveBuildRoot } from "./lifecycle.js";
-import { GATED_EXIT_CODE, recordAutoReleasesForRun } from "./run.js";
+import { GATED_EXIT_CODE, autoReleaseRun, recordAutoReleasesForRun } from "./run.js";
 /**
  * The stack-level change signal, from whichever end the invocation supplied.
  *
@@ -156,10 +167,12 @@ export async function resolveChangedUnits(ctx, config, opts = {}) {
  * chant components fan-out --base <ref> | --from-affected <file>
  *   [--head <ref>] [--include-dependents] [--env <env>] [--gate <name>]
  *   [--dry-run] [--json] [--resume <file>] [--seed-outputs <file>]
- *   [--dump-outputs <file>] [--progress-json]
+ *   [--dump-outputs <file>] [--progress-json | --events-json]
  */
 export async function runComponentsFanOut(ctx) {
     const { args } = ctx;
+    if (refusesBothStreams(args))
+        return 1;
     const projectPath = resolve(".");
     const { config } = await loadChantConfig(projectPath).catch(() => ({ config: {} }));
     const paramsResolution = resolveCliBuildParams(config.buildParams, {
@@ -230,7 +243,12 @@ export async function runComponentsFanOut(ctx) {
     // real run happens inside `runFanOut`, before the gate is decided, so an
     // approval survives the resume rather than being re-asked for.
     const resumePath = args.resume ? resolve(args.resume) : undefined;
+    // What each component would apply now (#4081). The record keeps it for
+    // every component that applies, and a later attempt carries progress only
+    // where it is unchanged.
+    const inputsNow = resumePath ? componentInputDigests(derived.components, { projectRoot: projectPath, env: args.env ?? "local" }) : {};
     let priorCompleted = [];
+    let priorInputs = {};
     let priorOutputs = {};
     let priorWaves = [];
     let priorCarried = {};
@@ -256,9 +274,27 @@ export async function runComponentsFanOut(ctx) {
             // as progress would block their subtrees again on the very run that
             // exists to retry them — the operator repeated the command precisely
             // because the thing that failed is now expected to work.
-            priorCompleted = attempt.completed;
-            priorOutputs = Object.fromEntries(Object.entries(attempt.outputs).filter(([name]) => attempt.completed.includes(name)));
-            progress = { completed: attempt.completed };
+            //
+            // And only the part of `completed` whose input is the same now (#4081).
+            // The plan digest identifies the derivation, which a different change
+            // of the same shape shares; the input digest says what was applied.
+            const split = progressThatCarries(attempt, inputsNow);
+            if (split.unrecorded && split.changed.length > 0) {
+                console.error(formatWarning({
+                    message: `--resume: "${args.resume}" does not record what each component applied, so none of its progress carries`,
+                    hint: "It was written before chant recorded component inputs. Everything selected will run.",
+                }));
+            }
+            else {
+                for (const name of split.changed) {
+                    console.error(formatInfo(`${name}: changed since the earlier attempt, so it runs again`));
+                }
+            }
+            const carried = new Set(split.carried);
+            priorCompleted = split.carried;
+            priorInputs = Object.fromEntries(split.carried.map((name) => [name, inputsNow[name]]));
+            priorOutputs = Object.fromEntries(Object.entries(attempt.outputs).filter(([name]) => carried.has(name)));
+            progress = { completed: split.carried };
             priorWaves = attempt.waves ?? [];
             // What steps kept per member (#3459), such as a choudoufu root's wave
             // resume file. Each step decides whether what it kept still applies.
@@ -295,6 +331,7 @@ export async function runComponentsFanOut(ctx) {
     // runner, ctrl-c) then still knows that the first two applied, and the
     // repeated command picks up from there instead of redoing them.
     const completedSoFar = new Set(priorCompleted);
+    const inputsSoFar = { ...priorInputs };
     const failedSoFar = [];
     const outputsSoFar = { ...priorOutputs };
     let wavesSoFar = priorWaves;
@@ -307,11 +344,16 @@ export async function runComponentsFanOut(ctx) {
             completed: [...completedSoFar].sort(),
             failed: [...failedSoFar].sort(),
             outputs: outputsSoFar,
+            inputs: Object.fromEntries(Object.entries(inputsSoFar).sort(([a], [b]) => a.localeCompare(b))),
             ...(wavesSoFar.length > 0 ? { waves: wavesSoFar } : {}),
             ...(Object.keys(carriedSoFar).length > 0 ? { carried: carriedSoFar } : {}),
         };
         writeFanOutAttempt(resumePath, attempt);
     };
+    // The run id the release records carry, chosen before the run so that
+    // `--events-json` (#4041) names the run by it too.
+    const release = autoReleaseRun(`fan-out-${Date.now()}`);
+    const events = await openCliRunEvents(args, { kind: "component", name: `fan-out ${derived.plan.order.join(",")}`, runId: release.runId, cwd: projectPath });
     let result;
     try {
         result = await runFanOut(derived.plan, derived.components, registry, {
@@ -342,11 +384,14 @@ export async function runComponentsFanOut(ctx) {
                 }
                 : {}),
             ...(args.progressJson ? { onProgress: ndjsonProgressSink() } : {}),
+            ...(events ? { onRunEvent: events.emit } : {}),
             ...(resumePath
                 ? {
                     onComponentSettled: (settled, outputs) => {
                         if (settled.status === "ok") {
                             completedSoFar.add(settled.component);
+                            if (inputsNow[settled.component] !== undefined)
+                                inputsSoFar[settled.component] = inputsNow[settled.component];
                             if (outputs)
                                 outputsSoFar[settled.component] = outputs;
                         }
@@ -360,6 +405,7 @@ export async function runComponentsFanOut(ctx) {
         });
     }
     catch (err) {
+        events?.settle("failed", err instanceof Error ? err.message : String(err));
         // `--wave <n>` reached before an earlier wave applied: nothing ran.
         if (err instanceof EarlierWaveNotAppliedError) {
             console.error(formatError({ message: err.message }));
@@ -367,6 +413,8 @@ export async function runComponentsFanOut(ctx) {
         }
         throw err;
     }
+    // The fan-out settles the stream; this only ends one it left open.
+    events?.settle(result.status === "fail" ? "failed" : result.status);
     if (args.dumpOutputs) {
         const dumpPath = resolve(args.dumpOutputs);
         mkdirSync(dirname(dumpPath), { recursive: true });
@@ -395,7 +443,7 @@ export async function runComponentsFanOut(ctx) {
     // A gated-wave run can stop at a later wave's gate after earlier waves
     // applied, and those applies are recorded like any other.
     if (result.status !== "gated" || result.completed.length > 0) {
-        await recordAutoReleasesForRun(result.results, args.env ?? "local", `fan-out-${Date.now()}`, resolveAutoReleaseDisabled(config, args.noReleaseRecord));
+        await recordAutoReleasesForRun(result.results, args.env ?? "local", release.runId, resolveAutoReleaseDisabled(config, args.noReleaseRecord), release.runOrigin);
     }
     // A failed root outranks a gate in the status, but a gated-wave run that
     // stopped at a wave's gate still prints how to approve it.

package/dist/cli/handlers/lifecycle-gc.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `chant lifecycle gc [--yes] [--push] [--json] [--verbose]` (#4036): prune
+ * stored change sets, releases and their templates from `chant/lifecycle`, and
+ * run event files from this host, by the retention policy.
+ *
+ * Without `--yes` it is a dry run: it prints what it would remove and changes
+ * nothing. With `--yes` it writes one commit to the local `chant/lifecycle`
+ * that removes those files, and deletes the run event files. It pushes only
+ * with `--push`. History is never rewritten, so a pruned file stays in the
+ * branch's earlier commits. The rules are in ../../lifecycle/retention.ts.
+ *
+ * The policy is the defaults, overridden by the `retention` block of the
+ * workspace declaration at base when the checkout is a workspace. The prune
+ * covers the whole branch, every member, from wherever in the repository it
+ * runs.
+ */
+import type { CommandContext } from "../registry.js";
+export declare function runLifecycleGc(ctx: CommandContext): Promise<number>;
+//# sourceMappingURL=lifecycle-gc.d.ts.map

package/dist/cli/handlers/lifecycle-gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-gc.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/lifecycle-gc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAuClD,wBAAsB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqFzE"}

package/dist/cli/handlers/lifecycle-gc.js

@@ -0,0 +1,143 @@
+/**
+ * `chant lifecycle gc [--yes] [--push] [--json] [--verbose]` (#4036): prune
+ * stored change sets, releases and their templates from `chant/lifecycle`, and
+ * run event files from this host, by the retention policy.
+ *
+ * Without `--yes` it is a dry run: it prints what it would remove and changes
+ * nothing. With `--yes` it writes one commit to the local `chant/lifecycle`
+ * that removes those files, and deletes the run event files. It pushes only
+ * with `--push`. History is never rewritten, so a pruned file stays in the
+ * branch's earlier commits. The rules are in ../../lifecycle/retention.ts.
+ *
+ * The policy is the defaults, overridden by the `retention` block of the
+ * workspace declaration at base when the checkout is a workspace. The prune
+ * covers the whole branch, every member, from wherever in the repository it
+ * runs.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { formatError, formatSuccess, formatWarning } from "../format.js";
+const USAGE = "chant lifecycle gc [--yes] [--push] [--json] [--verbose]";
+function tryGit(cwd, args) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether a workspace declaration sits in `cwd` or a directory above it, up to the repository's top. */
+function inWorkspace(cwd, top) {
+    for (let dir = cwd;; dir = dirname(dir)) {
+        if (existsSync(join(dir, "chant.workspace.json")) || existsSync(join(dir, "chant.workspace.jsonc")))
+            return true;
+        if (dir === top || dirname(dir) === dir)
+            return false;
+    }
+}
+/** Every commit with a `ci/revoked/<sha>` tag, counted as `chant release cut` counts it. */
+async function revokedCommits(cwd, top, green, workspace) {
+    if (workspace) {
+        const { readCiTags } = await import("../../workspace/ci-green.js");
+        const base = green
+            ? (tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${green.branch}^{commit}`]) ??
+                tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/heads/${green.branch}^{commit}`]) ??
+                tryGit(top, ["rev-parse", "HEAD"]))
+            : null;
+        return new Set(readCiTags(top, green, base).revoked.keys());
+    }
+    // With no declaration every tag counts, as readCiTags counts them without `ci.green`.
+    const out = tryGit(cwd, ["for-each-ref", "--format=%(refname:lstrip=4)", "refs/tags/ci/revoked/"]) ?? "";
+    return new Set(out.split("\n").filter((s) => /^[0-9a-f]{40,64}$/.test(s)));
+}
+const kb = (bytes) => (bytes >= 1024 * 1024 ? `${(bytes / 1024 / 1024).toFixed(1)} MB` : `${(bytes / 1024).toFixed(1)} KB`);
+export async function runLifecycleGc(ctx) {
+    const { args } = ctx;
+    if (args.extraPositional) {
+        console.error(formatError({ message: `lifecycle gc takes no argument, and was given "${args.extraPositional}"`, hint: USAGE }));
+        return 1;
+    }
+    const cwd = resolve(".");
+    const top = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
+    if (!top) {
+        console.error(formatError({ message: "lifecycle gc prunes the chant/lifecycle branch, and this directory is not in a git repository", hint: USAGE }));
+        return 1;
+    }
+    const dryRun = args.yes !== true;
+    const { resolveRetention } = await import("../../lifecycle/retention-policy.js");
+    let policy = resolveRetention(null);
+    let green = null;
+    const workspace = inWorkspace(cwd, top);
+    if (workspace) {
+        const { scopeSource } = await import("../../workspace/write-scope.js");
+        const source = scopeSource(cwd);
+        if (!source.declaration) {
+            console.error(formatError({ message: `the workspace declaration can't be read, so its retention policy is unknown and nothing is pruned: ${source.failure?.message ?? "no declaration"}` }));
+            return 1;
+        }
+        policy = resolveRetention(source.declaration.retention);
+        green = source.declaration.ci?.green ?? null;
+    }
+    // Read the remote's facts first: a prune planned on a stale branch could
+    // remove what a newer gate binds, and a forked branch must not be pushed over.
+    const { fetchLifecycleStatus } = await import("../../lifecycle/git.js");
+    const fetched = await fetchLifecycleStatus({ cwd });
+    if (fetched.status === "diverged" || fetched.status === "unreachable") {
+        const why = fetched.status === "diverged" ? `the local chant/lifecycle and ${fetched.remote}'s have forked` : `${fetched.remote} did not answer: ${fetched.stderr}`;
+        if (!dryRun) {
+            console.error(formatError({ message: `nothing was pruned: ${why}`, hint: "Bring chant/lifecycle up to date with its remote, then run again." }));
+            return 1;
+        }
+        if (!args.json)
+            console.error(formatWarning({ message: `planned on the local branch only: ${why}` }));
+    }
+    const { runLifecycleGc: run } = await import("../../lifecycle/retention.js");
+    const report = await run({
+        cwd,
+        policy,
+        now: new Date(),
+        revokedCommits: await revokedCommits(cwd, top, green, workspace),
+        dryRun,
+        push: args.push === true,
+    });
+    if (args.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return 0;
+    }
+    const lc = report.lifecycle;
+    const count = (list, kind) => list.filter((f) => f.kind === kind).length;
+    const bytes = lc.remove.reduce((n, f) => n + f.bytes, 0);
+    const verb = dryRun ? "would remove" : "removed";
+    if (!lc.tip) {
+        console.error("No chant/lifecycle branch: nothing stored to prune.");
+    }
+    else {
+        console.log(`chant/lifecycle at ${lc.tip.slice(0, 12)}: ${verb} ${count(lc.remove, "change-set")} change set(s), ${count(lc.remove, "release")} release(s) and ${count(lc.remove, "template")} template(s), ${kb(bytes)}; ` +
+            `keeps ${count(lc.keep, "change-set")}, ${count(lc.keep, "release")} and ${count(lc.keep, "template")}`);
+        console.log(`  tree at the tip: ${lc.before.files} file(s), ${kb(lc.before.bytes)} before; ${lc.after.files} file(s), ${kb(lc.after.bytes)} after. The ledgers (${kb(lc.before.ledgers.bytes)}) are never pruned, and history keeps every removed file.`);
+        if (args.verbose)
+            for (const f of lc.remove)
+                console.log(`  - ${f.path}`);
+    }
+    const ev = report.runEvents;
+    if (ev.dir) {
+        console.log(`  run events in ${ev.dir}: ${verb} ${ev.remove.length} file(s), ${kb(ev.remove.reduce((n, f) => n + f.bytes, 0))}; keeps ${ev.kept.files}`);
+        if (args.verbose)
+            for (const f of ev.remove)
+                console.log(`  - ${f.file}`);
+    }
+    if (dryRun) {
+        console.error("Dry run: nothing was removed. Run again with --yes to prune.");
+    }
+    else if (lc.commit) {
+        console.error(formatSuccess(`Pruned in commit ${lc.commit.slice(0, 12)} on chant/lifecycle`));
+        if (lc.pushed)
+            console.error("  pushed");
+        else if (lc.pushWarning)
+            console.error(formatWarning({ message: lc.pushWarning }));
+        else
+            console.error("  not pushed: run with --push, or push chant/lifecycle yourself");
+    }
+    return 0;
+}

package/dist/cli/handlers/pr.d.ts

@@ -29,6 +29,20 @@
  *
  * Every run writes `pr-plan.json` or `pr-apply.json` (`pr-report.schema.json`),
  * `change-set.json` and `pr-note.md` under `--output` (default `.chant/pr`). *
+ * `--events-json` (#4041, #4007) streams the stage's run events to stdout,
+ * one `run-event.schema.json` line each: the planning as a `plan` phase with
+ * a step per component, the gate's decision as a `gate` phase, and on
+ * pr-apply the apply's waves and components as `chant run --components`
+ * streams them. A component the apply does not start settles too, `blocked`
+ * behind a failed dependency or `already-applied` on a resumed apply.
+ * With or without it, pr-apply prints a line on stderr as each wave starts
+ * and as each component settles, so a job log shows the waves in order.
+ *
+ * `--report-url <s3 or file URL>` (#4007) copies `pr-<stage>.json`,
+ * `change-set.json` and, with `--events-json`, the events to
+ * `<url>/<pr>/<commit>/`, the events again as each wave and component
+ * settles (`../../pr-report-url.ts`).
+ *
  * `--member <name>` (#3465) runs a workspace member's loop: the member's
  * generated pipeline passes it from the member's directory. The gate is
  * recorded under `pr-<n>-<member>`, and the note and the statuses carry the
@@ -38,8 +52,8 @@
 import type { CommandContext } from "../registry.js";
 /** Where the reports land unless `--output` says. */
 export declare const PR_REPORT_DIR = ".chant/pr";
-/** chant components pr-plan --base <ref> --pr <n> [--env <env>] [--gate <name>] [--forge <kind>] [--output <dir>] [--json] */
+/** chant components pr-plan --base <ref> --pr <n> [--env <env>] [--gate <name>] [--forge <kind>] [--output <dir>] [--json] [--events-json] [--report-url <url>] */
 export declare function runComponentsPrPlan(ctx: CommandContext): Promise<number>;
-/** chant components pr-apply --base <ref> [--pr <n>] [--env <env>] [--gate <name>] [--forge <kind>] [--require-review] [--output <dir>] [--json] */
+/** chant components pr-apply --base <ref> [--pr <n>] [--env <env>] [--gate <name>] [--forge <kind>] [--require-review] [--output <dir>] [--json] [--events-json] [--report-url <url>] */
 export declare function runComponentsPrApply(ctx: CommandContext): Promise<number>;
 //# sourceMappingURL=pr.d.ts.map

package/dist/cli/handlers/pr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAyCH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qDAAqD;AACrD,eAAO,MAAM,aAAa,cAAc,CAAC;AA0MzC,8HAA8H;AAC9H,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA0C9E;AAED,oJAAoJ;AACpJ,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkL/E"}
+{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/pr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AA8CH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qDAAqD;AACrD,eAAO,MAAM,aAAa,cAAc,CAAC;AAwRzC,mKAAmK;AACnK,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxE;AAwDD,yLAAyL;AACzL,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE"}