@intentius/chant 0.124.28 → 0.124.30

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,6 +57,7 @@ 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";
@@ -56,6 +66,8 @@ import { summaryLedgerPrefix, writeGatedRunSummary } from "../../op/gate-summary
 import { approveCommand, gateIsSealed } from "../../op/gate.js";
 import { getHeadCommit } from "../../lifecycle/git.js";
 import { remainingFanOut } from "../../components/fan-out.js";
+import { readDeployedOutputs } from "../../components/wave-plan.js";
+import { deployContext } from "../../components/driver.js";
 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";
@@ -233,7 +245,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 = {};
@@ -259,9 +276,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.
@@ -291,6 +326,29 @@ export async function runComponentsFanOut(ctx) {
         }
     }
     const registry = await fanOutRegistry(projectPath, config);
+    const env = args.env ?? "local";
+    // A completed component's recorded outputs win over a `--seed-outputs`
+    // entry for the same name, as a fresh apply's outputs merge over a seed in
+    // the driver: the record holds what this fan-out itself applied. A seed
+    // neither gives is read from the deployed estate (#4104), through its
+    // capability's `outputs`, as pr-plan reads a dependency outside the change.
+    // One that cannot be read leaves its dependents' references unresolved.
+    const componentOutputs = { ...seededOutputs, ...priorOutputs };
+    const seeds = (progress ? remainingFanOut(derived.plan, derived.components, progress) : derived.plan).seeds;
+    let deployedSeeds;
+    try {
+        deployedSeeds = await readDeployedOutputs(seeds, new Map(derived.components.map((c) => [c.name, c])), registry, (name) => deployContext({ env }, name), componentOutputs);
+    }
+    catch (err) {
+        console.error(formatError({
+            message: `could not read the deployed outputs of ${seeds.filter((s) => !(s in componentOutputs)).join(", ")}: ${err instanceof Error ? err.message : String(err)}`,
+            hint: "Nothing ran. --seed-outputs <file> gives a component's outputs instead of reading them.",
+        }));
+        return 1;
+    }
+    for (const [name, keys] of Object.entries(deployedSeeds)) {
+        console.error(formatInfo(`${name}: outputs read from the deployed estate (${keys.length > 0 ? keys.join(", ") : "none yet"})`));
+    }
     // #3061: the commit this run deploys, for the workloads' vcs.ref.head.revision.
     const revision = await getHeadCommit().catch(() => undefined);
     // The record is rewritten as each component settles, not only once the run
@@ -298,6 +356,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;
@@ -310,6 +369,7 @@ 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 } : {}),
         };
@@ -322,12 +382,9 @@ export async function runComponentsFanOut(ctx) {
     let result;
     try {
         result = await runFanOut(derived.plan, derived.components, registry, {
-            env: args.env ?? "local",
+            env,
             releaseIdentity: () => (revision ? { revision } : {}),
-            // A completed component's recorded outputs win over a `--seed-outputs`
-            // entry for the same name, as a fresh apply's outputs merge over a seed in
-            // the driver: the record holds what this fan-out itself applied.
-            componentOutputs: { ...seededOutputs, ...priorOutputs },
+            componentOutputs,
             ...(gate ? { gate } : {}),
             ...(waveGate ? { waveGate } : {}),
             ...(waveGate
@@ -355,6 +412,8 @@ export async function runComponentsFanOut(ctx) {
                     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;
                         }

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

@@ -33,7 +33,15 @@
  * 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.
+ * 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
@@ -44,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] [--events-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] [--events-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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AA4CH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,qDAAqD;AACrD,eAAO,MAAM,aAAa,cAAc,CAAC;AAoPzC,8IAA8I;AAC9I,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxE;AAuDD,oKAAoK;AACpK,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE"}
+{"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;AA6RzC,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"}