@intentius/chant 0.124.15 → 0.124.16

package/dist/wave-layout.js

@@ -0,0 +1,41 @@
+/**
+ * Wave gate names and the share split of a wide wave (#3766), the parts of
+ * the wave engine (`./wave-engine.ts`) that the Op waves spec module
+ * (`./op/op-waves.ts`) needs. That module is in the gate-decision bundle
+ * (`./gate-decision.ts` re-exports a constant from it), so this imports
+ * nothing and keeps the change-set digest code out of that bundle.
+ */
+/** The default wave gate name pattern: `{gate}` is the base gate name, `{k}` the wave's number. */
+export const WAVE_GATE_NAME_PATTERN = "{gate}-wave-{k}";
+/**
+ * The gate wave `k` waits on under a name pattern (#3821). With the default
+ * pattern this is `waveGateName(gate, k)` from `./gated-waves.ts`; an Op
+ * waves spec's `gateName` names another (such as `"wave-{k}"`) so approvals
+ * already on the ledger under a product's old names keep matching.
+ *
+ * `{gate}` is filled in before `{k}`, as `opWaveGateName` always did, so a
+ * base gate name holding the text `{k}` is filled in too. That is the one
+ * input on which this and `waveGateName` differ, and each entry point keeps
+ * the one it shipped with.
+ */
+export function waveGateNameFrom(pattern, gate, k) {
+    return (pattern ?? WAVE_GATE_NAME_PATTERN).replaceAll("{gate}", gate).replaceAll("{k}", String(k));
+}
+/**
+ * Share `share` (1-based) of `shares` of a wide wave (#3679): the items
+ * sorted by `keyOf`, cut into contiguous slices whose sizes differ by at most
+ * one. The deciding job and every share job cut the same way, so each item
+ * is applied by exactly one share.
+ */
+export function waveShare(items, share, shares, keyOf) {
+    const sorted = [...items].sort((a, b) => {
+        const x = keyOf(a);
+        const y = keyOf(b);
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    const base = Math.floor(sorted.length / shares);
+    const extra = sorted.length % shares;
+    const start = (share - 1) * base + Math.min(share - 1, extra);
+    const size = base + (share <= extra ? 1 : 0);
+    return sorted.slice(start, start + size);
+}

package/dist/wave-runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The slim wave-job runtime (#3896): the four commands a generated Op waves
+ * pipeline runs, and nothing else.
+ *
+ *   chant run wave --spec <file> --wave <k> [--decide | --share <i> | --record-plans]
+ *   chant run resume [--gate <op>/<gate>] [--dry-run]
+ *   chant approve <op> <gate> [...]
+ *   chant workspace points ask|answer|list|... [...]
+ *
+ * `scripts/build-runtime.mjs` bundles this file with esbuild into
+ * `dist/wave-runtime.mjs`: one self-contained ES module whose only imports are
+ * `node:` builtins, with no TypeScript compiler, esbuild, tsx or zod in it. A
+ * product copies that one file into its CI image and runs it with plain node,
+ * or runs it from an installed `@intentius/chant`
+ * (`node node_modules/@intentius/chant/dist/wave-runtime.mjs run wave ...`).
+ *
+ * The handlers are the full CLI's own (`./cli/main.ts` dispatches to the same
+ * functions), parsed by the same `parseArgs`, so flags, output, exit codes and
+ * the ledgers each command writes are the same. What the runtime does not do:
+ * evaluate `chant.config.ts` (which needs a TypeScript loader). None of the
+ * four commands reads the config; the full CLI loads it only to check `--env`
+ * against the declared `environments`, a check the runtime skips.
+ */
+import { type CommandDef } from "./cli/registry.js";
+/** The commands the runtime carries, under the names the full CLI registers them by. */
+export declare const RUNTIME_COMMANDS: CommandDef[];
+/** Parse, dispatch and return the exit code. Exported for tests. */
+export declare function runRuntime(argv: string[]): Promise<number>;
+//# sourceMappingURL=wave-runtime.d.ts.map

package/dist/wave-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-runtime.d.ts","sourceRoot":"","sources":["../src/wave-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAkB,KAAK,UAAU,EAAmB,MAAM,gBAAgB,CAAC;AAYlF,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,EAAE,UAAU,EAKxC,CAAC;AAsBF,oEAAoE;AACpE,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BhE"}

package/dist/wave-runtime.js

@@ -0,0 +1,103 @@
+/**
+ * The slim wave-job runtime (#3896): the four commands a generated Op waves
+ * pipeline runs, and nothing else.
+ *
+ *   chant run wave --spec <file> --wave <k> [--decide | --share <i> | --record-plans]
+ *   chant run resume [--gate <op>/<gate>] [--dry-run]
+ *   chant approve <op> <gate> [...]
+ *   chant workspace points ask|answer|list|... [...]
+ *
+ * `scripts/build-runtime.mjs` bundles this file with esbuild into
+ * `dist/wave-runtime.mjs`: one self-contained ES module whose only imports are
+ * `node:` builtins, with no TypeScript compiler, esbuild, tsx or zod in it. A
+ * product copies that one file into its CI image and runs it with plain node,
+ * or runs it from an installed `@intentius/chant`
+ * (`node node_modules/@intentius/chant/dist/wave-runtime.mjs run wave ...`).
+ *
+ * The handlers are the full CLI's own (`./cli/main.ts` dispatches to the same
+ * functions), parsed by the same `parseArgs`, so flags, output, exit codes and
+ * the ledgers each command writes are the same. What the runtime does not do:
+ * evaluate `chant.config.ts` (which needs a TypeScript loader). None of the
+ * four commands reads the config; the full CLI loads it only to check `--env`
+ * against the declared `environments`, a check the runtime skips.
+ */
+import { parseArgs } from "./cli/parse-args.js";
+import { resolveCommand } from "./cli/registry.js";
+import { formatError } from "./cli/format.js";
+import { flushAndExit } from "./cli/flush.js";
+import { CHANT_VERSION } from "./cli/version.js";
+import { isEntryPoint } from "./cli/is-entry-point.js";
+import { ENV_VAR } from "./env.js";
+import { initRuntime } from "./runtime-adapter.js";
+import { runOpWaveCommand } from "./cli/handlers/run-wave.js";
+import { runResumeCommand } from "./cli/handlers/gate-resume.js";
+import { runApprove } from "./cli/handlers/approve.js";
+import { runWorkspacePoints } from "./workspace/points-cli.js";
+/** The commands the runtime carries, under the names the full CLI registers them by. */
+export const RUNTIME_COMMANDS = [
+    { name: "run wave", handler: runOpWaveCommand },
+    { name: "run resume", handler: runResumeCommand },
+    { name: "approve", handler: runApprove },
+    { name: "workspace points", handler: runWorkspacePoints },
+];
+const HELP = `
+chant runtime ${CHANT_VERSION} - the wave-job commands of chant, in one file
+
+Usage: node wave-runtime.mjs <command> [options]
+
+Commands:
+  run wave --spec <file> --wave <k>   Plan, gate and apply wave k of an Op waves spec
+                                      (--decide, --share <i>, --record-plans, --base <ref>, --json)
+  run resume                          Start the CI jobs that wait at gates whose approval arrived
+                                      (--gate <op>/<gate>, --dry-run, --json)
+  approve <op> <gate>                 Record a gate's resolution on the lifecycle ledger
+                                      (--actor, --plan, --note, --url, --sign, --expire, --resume, ...)
+  workspace points <verb>             Ask, answer and list decision points
+
+Flags, output, exit codes and ledger formats are the full chant CLI's;
+see "chant --help" in @intentius/chant for every flag. This runtime does
+not evaluate chant.config.ts, so --env is not checked against the
+declared environments.
+`;
+/** Parse, dispatch and return the exit code. Exported for tests. */
+export async function runRuntime(argv) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        return 1;
+    }
+    const match = resolveCommand(args, RUNTIME_COMMANDS);
+    if (args.version && (!args.command || match)) {
+        console.log(CHANT_VERSION);
+        return 0;
+    }
+    if (args.help || !args.command) {
+        console.log(HELP);
+        return args.help ? 0 : 1;
+    }
+    if (!match) {
+        const name = args.path && args.path !== "." ? `${args.command} ${args.path}` : args.command;
+        console.error(formatError({
+            message: `"${name}" is not part of chant's wave-job runtime`,
+            hint: "It runs run wave, run resume, approve and workspace points. Every other command needs the full @intentius/chant CLI.",
+        }));
+        return 1;
+    }
+    if (args.env)
+        process.env[ENV_VAR] = args.env;
+    initRuntime();
+    return match.def.handler({ args, plugins: [], serializers: [] });
+}
+if (isEntryPoint(process.argv[1], import.meta.url)) {
+    runRuntime(process.argv.slice(2)).then(flushAndExit, async (err) => {
+        const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+        if (verbose && err instanceof Error && err.stack)
+            console.error(err.stack);
+        else
+            console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        await flushAndExit(1);
+    });
+}