@intentius/chant 0.124.28 → 0.124.30

package/dist/lifecycle/release-workstation.js

@@ -0,0 +1,180 @@
+/**
+ * Cutting a release from a workstation as from CI (#4027).
+ *
+ * `chant release cut` runs the same steps wherever it runs. What differs
+ * between a laptop and a CI job is read here, from git and the process
+ * environment, so the CLI and its tests resolve it the same way:
+ *
+ * - trunk: the branch `ci.green.branch` names in the declaration at base,
+ *   else the branch `origin/HEAD` points at, else `main`. The commit must be
+ *   reachable from `origin/<branch>` as this clone last fetched it, so a
+ *   commit that is on the local branch only is refused as not pushed. Nothing
+ *   is fetched: a stale `origin/<branch>` can only refuse a commit that was
+ *   pushed since, never admit one that wasn't.
+ * - a clean tree: no tracked change and no untracked file that git does not
+ *   ignore, since the compile reads the directory and a new
+ *   `*.component.ts` would be compiled into the release.
+ * - the actor: `--actor`, else the principal the signers file at base lists
+ *   for the signing key, else the CI's actor, else git's `user.email`, else
+ *   `$USER`.
+ * - the tag: `release/<label>`, or `release/<member>/<label>` in a workspace
+ *   member, an annotated tag on the commit that is created locally and never
+ *   pushed by chant.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+/** A refusal before anything is compiled or written. */
+export class WorkstationCheckError extends Error {
+    constructor(code, message, fix) {
+        super(message);
+        this.code = code;
+        this.fix = fix;
+        this.name = "WorkstationCheckError";
+    }
+}
+function tryGit(cwd, args) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+const isAncestor = (cwd, a, b) => spawnSync("git", ["merge-base", "--is-ancestor", a, b], { cwd, stdio: "ignore" }).status === 0;
+/** The remote a release's commit must be pushed to. */
+export const RELEASE_REMOTE = "origin";
+/** The trunk of the repository at `cwd`: `ci.green.branch` when declared, else what `origin/HEAD` names, else `main`. */
+export function resolveTrunk(cwd, greenBranch) {
+    if (greenBranch)
+        return { remote: RELEASE_REMOTE, branch: greenBranch, from: "ci.green.branch" };
+    const head = tryGit(cwd, ["symbolic-ref", "--quiet", `refs/remotes/${RELEASE_REMOTE}/HEAD`]);
+    const prefix = `refs/remotes/${RELEASE_REMOTE}/`;
+    if (head?.startsWith(prefix))
+        return { remote: RELEASE_REMOTE, branch: head.slice(prefix.length), from: "origin/HEAD" };
+    return { remote: RELEASE_REMOTE, branch: "main", from: "default" };
+}
+/**
+ * Refuse `commit` unless it is reachable from `<remote>/<branch>` as this
+ * clone knows it. A commit on the local branch only is `release-commit-not-pushed`;
+ * any other is `release-commit-not-on-trunk`.
+ */
+export function checkOnTrunk(cwd, commit, trunk) {
+    const remoteRef = `refs/remotes/${trunk.remote}/${trunk.branch}`;
+    const short = commit.slice(0, 12);
+    const named = `${trunk.remote}/${trunk.branch}`;
+    const why = trunk.from === "ci.green.branch" ? " (the branch ci.green names)" : trunk.from === "origin/HEAD" ? ` (the branch ${trunk.remote}/HEAD names)` : "";
+    const remoteTip = tryGit(cwd, ["rev-parse", "--verify", "--quiet", `${remoteRef}^{commit}`]);
+    if (remoteTip && isAncestor(cwd, commit, remoteTip))
+        return;
+    const localTip = tryGit(cwd, ["rev-parse", "--verify", "--quiet", `refs/heads/${trunk.branch}^{commit}`]);
+    if (localTip && isAncestor(cwd, commit, localTip)) {
+        throw new WorkstationCheckError("release-commit-not-pushed", remoteTip
+            ? `commit ${short} is on ${trunk.branch}${why} but not on ${named}, so it has not been pushed`
+            : `commit ${short} is on ${trunk.branch}${why}, and this clone knows no ${named}, so it can't be shown pushed`, `Push it, or fetch if it was pushed elsewhere: git push ${trunk.remote} ${trunk.branch}, or git fetch ${trunk.remote} ${trunk.branch}`);
+    }
+    throw new WorkstationCheckError("release-commit-not-on-trunk", remoteTip
+        ? `commit ${short} is not on ${named}${why}, so a release cut from it would ship what trunk never had`
+        : `commit ${short} is not on ${trunk.branch}${why}, and this clone knows no ${named}`, `Check out a commit of ${named} after fetching it: git fetch ${trunk.remote} ${trunk.branch}`);
+}
+/** Refuse a tree with a tracked change or an untracked file git does not ignore. */
+export function checkCleanTree(cwd, commit) {
+    const status = tryGit(cwd, ["status", "--porcelain", "--untracked-files=normal"]);
+    if (status === null || status === "")
+        return;
+    const lines = status.split("\n");
+    const untracked = lines.filter((l) => l.startsWith("??")).map((l) => l.slice(3));
+    const tracked = lines.length - untracked.length;
+    const parts = [
+        ...(tracked > 0 ? [`${tracked} tracked file(s) with uncommitted changes`] : []),
+        ...(untracked.length > 0 ? [`${untracked.length} untracked file(s) such as ${untracked[0]}`] : []),
+    ];
+    throw new WorkstationCheckError("release-worktree-dirty", `the working tree has ${parts.join(" and ")}, so a compile here would not be commit ${commit.slice(0, 12)}'s`, "Commit, stash or remove them (or add them to .gitignore), or cut from a clean checkout of the commit.");
+}
+/** The public key `keyFile` holds or names, as `<type> <base64>`, or null when it can't be read without a passphrase. */
+export function publicKeyOf(keyFile) {
+    const parse = (text) => {
+        const [type, blob] = text.trim().split(/\s+/);
+        return type && blob && /^(ssh-|ecdsa-|sk-)/.test(type) ? `${type} ${blob}` : null;
+    };
+    try {
+        if (existsSync(keyFile)) {
+            const own = parse(readFileSync(keyFile, "utf-8"));
+            if (own)
+                return own;
+        }
+        if (existsSync(`${keyFile}.pub`)) {
+            const pub = parse(readFileSync(`${keyFile}.pub`, "utf-8"));
+            if (pub)
+                return pub;
+        }
+    }
+    catch {
+        return null;
+    }
+    const derived = spawnSync("ssh-keygen", ["-y", "-P", "", "-f", keyFile], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    return derived.status === 0 ? parse(derived.stdout) : null;
+}
+/** The one principal `signers` lists for `publicKey`, or null for none or several. */
+export function signerPrincipal(publicKey, signers) {
+    const principals = [...new Set(signers.filter((s) => s.key === publicKey).map((s) => s.principal))];
+    return principals.length === 1 ? principals[0] : null;
+}
+/**
+ * Who cut the release, and where the name came from: `--actor`, else the
+ * signer the signers file at base lists for the signing key, else the CI's
+ * actor (`GITHUB_ACTOR`, `GITLAB_USER_LOGIN`), else git's `user.email`, else
+ * `$USER`. Undefined when none is set.
+ */
+export function resolveCutActor(req) {
+    const env = req.env ?? process.env;
+    if (req.explicit)
+        return { actor: req.explicit, source: "flag" };
+    if (req.publicKey && req.signers) {
+        const principal = signerPrincipal(req.publicKey, req.signers);
+        if (principal)
+            return { actor: principal, source: "signer" };
+    }
+    const ci = env.GITHUB_ACTOR || env.GITLAB_USER_LOGIN;
+    if (ci)
+        return { actor: ci, source: "ci" };
+    const email = tryGit(req.cwd, ["config", "--get", "user.email"]);
+    if (email)
+        return { actor: email, source: "git" };
+    if (env.USER)
+        return { actor: env.USER, source: "user" };
+    return undefined;
+}
+/** The tag a labelled release gets: `release/<label>`, or `release/<member>/<label>` for a workspace member. */
+export function releaseTagName(member, label) {
+    return member ? `release/${member}/${label}` : `release/${label}`;
+}
+/**
+ * Whether `tag` can name `commit`: `absent` (the cut creates it), `present`
+ * (it already names the commit), or a {@link WorkstationCheckError} for a
+ * tag that names another commit or is not a valid tag name.
+ */
+export function checkReleaseTag(cwd, tag, commit) {
+    if (spawnSync("git", ["check-ref-format", `refs/tags/${tag}`], { cwd, stdio: "ignore" }).status !== 0) {
+        throw new WorkstationCheckError("release-tag-invalid", `"${tag}" is not a valid git tag name, so the release can't be tagged`, "Pick a label git accepts in a ref name.");
+    }
+    const at = tryGit(cwd, ["rev-parse", "--verify", "--quiet", `refs/tags/${tag}^{commit}`]);
+    if (at === null)
+        return "absent";
+    if (at === commit)
+        return "present";
+    throw new WorkstationCheckError("release-tag-taken", `the tag ${tag} already names commit ${at.slice(0, 12)}, not ${commit.slice(0, 12)}`, "Pick another label, or delete the tag if it was made by mistake: git tag -d " + tag);
+}
+/**
+ * Create `tag` on `commit` as an annotated tag whose message names the
+ * release. Local only. A clone with no git identity tags as chant, as the ci
+ * tags are made.
+ */
+export function createReleaseTag(cwd, tag, commit, release) {
+    const ident = [];
+    if (tryGit(cwd, ["config", "user.name"]) === null)
+        ident.push("-c", "user.name=chant");
+    if (tryGit(cwd, ["config", "user.email"]) === null)
+        ident.push("-c", "user.email=chant@localhost");
+    const message = [`release ${release.label}`, "", `Release-Digest: ${release.releaseDigest}`, ...(release.member ? [`Member: ${release.member}`] : [])].join("\n");
+    execFileSync("git", [...ident, "tag", "-a", "-m", message, tag, commit], { cwd, stdio: ["ignore", "ignore", "pipe"] });
+}

package/dist/lifecycle/retention-policy.d.ts

@@ -0,0 +1,45 @@
+/**
+ * How long chant keeps each kind of stored record (#4036): the retention
+ * policy `chant lifecycle gc` prunes by. It reads no git, so the workspace
+ * declaration's parser imports it for the defaults and the shape.
+ *
+ * Three kinds are pruned:
+ *
+ *   changeSets   `_change-sets/<digest>.json` on `chant/lifecycle` (#4022)
+ *   releases     `_releases/<digest>.json` on `chant/lifecycle` (#4026), with
+ *                the template bytes under `_releases/templates/` that only
+ *                pruned releases name
+ *   runEvents    `<git-common-dir>/chant/run-events/<run>.jsonl`, local only (#4042)
+ *
+ * The ledgers (`cuts.jsonl`, `<env>/releases.jsonl`, `_gates/<op>.jsonl` and
+ * the run ledgers) are append-only and never pruned. See ./retention.ts.
+ */
+/** The retention of one kind: the age in days past which a record can go, and, where it applies, how many of the newest are kept whatever their age. */
+export interface KindRetention {
+    days: number;
+    keep: number;
+}
+/** The retention of every kind, with the defaults filled in. */
+export interface RetentionPolicy {
+    /** A stored change set is kept for `days` after it was stored or last named by a gate fact, whichever is later. `keep` does not apply and is 0. */
+    changeSets: KindRetention;
+    /** A release is promotable for `days` after its newest cut, and the newest `keep` releases of each member stay promotable at any age. */
+    releases: KindRetention;
+    /** A run's event file is kept for `days` after its last write, and the newest `keep` files are kept at any age. */
+    runEvents: KindRetention;
+}
+/** The record kinds a policy names, in the order a report lists them. */
+export declare const RETENTION_KINDS: readonly ["changeSets", "releases", "runEvents"];
+export type RetentionKind = (typeof RETENTION_KINDS)[number];
+/**
+ * The defaults. At chant's own rate (about 25 pull-request gates, 28 main
+ * commits and 5 release cuts a day in September and October 2026) two weeks
+ * keeps every change set an open pull request or a promotion can still need,
+ * and the newest ten releases of a member cover a member that cuts rarely.
+ */
+export declare const DEFAULT_RETENTION: RetentionPolicy;
+/** The declaration's `retention` block as written: any kind or field may be left out. */
+export type RetentionOverride = Partial<Record<RetentionKind, Partial<KindRetention>>>;
+/** The policy an override gives: each field it sets replaces the default. */
+export declare function resolveRetention(override?: RetentionOverride | null): RetentionPolicy;
+//# sourceMappingURL=retention-policy.d.ts.map

package/dist/lifecycle/retention-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention-policy.d.ts","sourceRoot":"","sources":["../../src/lifecycle/retention-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,wJAAwJ;AACxJ,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,mJAAmJ;IACnJ,UAAU,EAAE,aAAa,CAAC;IAC1B,yIAAyI;IACzI,QAAQ,EAAE,aAAa,CAAC;IACxB,mHAAmH;IACnH,SAAS,EAAE,aAAa,CAAC;CAC1B;AAED,yEAAyE;AACzE,eAAO,MAAM,eAAe,YAAI,YAAY,EAAE,UAAU,EAAE,WAAW,CAAU,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAI/B,CAAC;AAEF,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AAEvF,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,IAAI,GAAG,eAAe,CASrF"}

package/dist/lifecycle/retention-policy.js

@@ -0,0 +1,43 @@
+/**
+ * How long chant keeps each kind of stored record (#4036): the retention
+ * policy `chant lifecycle gc` prunes by. It reads no git, so the workspace
+ * declaration's parser imports it for the defaults and the shape.
+ *
+ * Three kinds are pruned:
+ *
+ *   changeSets   `_change-sets/<digest>.json` on `chant/lifecycle` (#4022)
+ *   releases     `_releases/<digest>.json` on `chant/lifecycle` (#4026), with
+ *                the template bytes under `_releases/templates/` that only
+ *                pruned releases name
+ *   runEvents    `<git-common-dir>/chant/run-events/<run>.jsonl`, local only (#4042)
+ *
+ * The ledgers (`cuts.jsonl`, `<env>/releases.jsonl`, `_gates/<op>.jsonl` and
+ * the run ledgers) are append-only and never pruned. See ./retention.ts.
+ */
+/** The record kinds a policy names, in the order a report lists them. */
+export const RETENTION_KINDS = ["changeSets", "releases", "runEvents"];
+/**
+ * The defaults. At chant's own rate (about 25 pull-request gates, 28 main
+ * commits and 5 release cuts a day in September and October 2026) two weeks
+ * keeps every change set an open pull request or a promotion can still need,
+ * and the newest ten releases of a member cover a member that cuts rarely.
+ */
+export const DEFAULT_RETENTION = {
+    changeSets: { days: 14, keep: 0 },
+    releases: { days: 14, keep: 10 },
+    runEvents: { days: 14, keep: 100 },
+};
+/** The policy an override gives: each field it sets replaces the default. */
+export function resolveRetention(override) {
+    const out = structuredClone(DEFAULT_RETENTION);
+    for (const kind of RETENTION_KINDS) {
+        const o = override?.[kind];
+        if (!o)
+            continue;
+        if (typeof o.days === "number")
+            out[kind].days = o.days;
+        if (typeof o.keep === "number" && kind !== "changeSets")
+            out[kind].keep = o.keep;
+    }
+    return out;
+}

package/dist/lifecycle/retention.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Garbage collection of stored change sets, releases and run events by the
+ * retention policy (#4036). `chant lifecycle gc` runs it.
+ *
+ * What it prunes on `chant/lifecycle`, in every member's ledger at once:
+ *
+ *   _change-sets/<digest>.json          a stored change set (#4022)
+ *   _releases/<digest>.json             a release (#4026)
+ *   _releases/templates/<digest>.txt    template bytes no kept release names
+ *
+ * A prune is one new commit on the local branch that removes those files. It
+ * never rewrites or force-pushes history: other clones and tools read the
+ * branch, and every pruned file stays reachable in the commits before the
+ * prune. So a prune bounds the tree a reader walks at the tip, and the
+ * repository's history keeps growing by what is written. `git log -- <path>`
+ * on the branch still finds a pruned file.
+ *
+ * What it never touches: the ledgers. `_releases/cuts.jsonl`,
+ * `<env>/releases.jsonl`, `_gates/<op>.jsonl`, the run ledgers and every other
+ * `.jsonl` on the branch are append-only and are not edited (#4034), and a
+ * whole ledger file is not removed either: the latest deploy record of an
+ * environment, a gate's standing fact and a release's label all live in them,
+ * and they are small next to what they index (one line per fact). Nor does it
+ * touch snapshots, `_plans/`, `_builds/` or checkpoints, which have no policy
+ * yet. A cut line whose release was pruned stays, so its label keeps naming
+ * that digest and can't be given to another release.
+ *
+ * What is never pruned, whatever its age:
+ *
+ * 1. A release an environment runs: the release the latest deploy record of
+ *    each component in each environment names, by its `releaseDigest` or the
+ *    release gate resolution its admission names (`releaseOfDeploy`, #4043),
+ *    and that release's templates. A promotion picks up what the step before
+ *    runs (#4030), so this also keeps every release a promotion can take by
+ *    default.
+ * 2. What a pending gate binds: the change set (`planDigest`) and release
+ *    (`releaseDigest`) of every pending fact that has not expired.
+ * 3. A release still promotable: one whose commit has no `ci/revoked` tag and
+ *    that was cut within `releases.days`, or is among the newest
+ *    `releases.keep` releases of its member.
+ * 4. A change set a gate fact (an approval, an `empty` resolution or a
+ *    pending fact) names together with a release that is kept.
+ *
+ * Anything else is pruned once it is older than its kind's window: a change
+ * set `changeSets.days` after it was stored or last named by a gate fact,
+ * whichever is later. A file that can't be read as a release is kept.
+ *
+ * Run events are local files under `<git-common-dir>/chant/run-events/`
+ * (`../run-event-store.ts`) and are deleted outright.
+ */
+import { type RunEventFile } from "../run-event-store.js";
+import type { RetentionPolicy } from "./retention-policy.js";
+/** What a pruned or kept file on the branch is. */
+export type GcKind = "change-set" | "release" | "template";
+/** Why a file is kept. Closed. */
+export type GcKeepCode = 
+/** The latest deploy record of a component in an environment names the release. */
+"deployed"
+/** A pending fact that has not expired binds it. */
+ | "pending-gate"
+/** The release is among the newest `releases.keep` of its member and not revoked. */
+ | "newest"
+/** It is within its kind's window (and, for a release, not revoked). */
+ | "within-window"
+/** A gate fact names the change set with a release that is kept, or a kept release names the template. */
+ | "kept-release"
+/** The file can't be read as what its directory holds, so nothing can be said about it. */
+ | "unreadable";
+export interface GcKeepReason {
+    code: GcKeepCode;
+    /** The environment, gate or release the reason names, when it names one. */
+    detail?: string;
+}
+export interface GcFile {
+    kind: GcKind;
+    /** The member, its path of names joined with `/`, or null for the flat layout. */
+    member: string | null;
+    /** The full path on the branch. */
+    path: string;
+    digest: string;
+    bytes: number;
+    /** The blob sha at the tip read. */
+    sha: string;
+    /** When it was last written to the branch (the newest commit that added it), or null when history does not say. */
+    storedAt: string | null;
+}
+export interface GcKept extends GcFile {
+    reasons: GcKeepReason[];
+}
+/** Files and bytes in the tip's tree. */
+export interface TreeSize {
+    files: number;
+    bytes: number;
+    changeSets: {
+        files: number;
+        bytes: number;
+    };
+    releases: {
+        files: number;
+        bytes: number;
+    };
+    templates: {
+        files: number;
+        bytes: number;
+    };
+    /** Every `.jsonl` file: append-only, never pruned. */
+    ledgers: {
+        files: number;
+        bytes: number;
+    };
+    other: {
+        files: number;
+        bytes: number;
+    };
+}
+/** What a prune of `chant/lifecycle` would do. */
+export interface LifecycleGcPlan {
+    /** The branch tip read, or null when the checkout has no `chant/lifecycle`. */
+    tip: string | null;
+    remove: GcFile[];
+    keep: GcKept[];
+    before: TreeSize;
+    after: TreeSize;
+}
+export interface GcInput {
+    /** Any directory in the repository. The whole branch is read, every member at once. */
+    cwd: string;
+    policy: RetentionPolicy;
+    now: Date;
+    /** Full shas of commits with a `ci/revoked` tag: their releases are not promotable. */
+    revokedCommits?: ReadonlySet<string>;
+}
+/** Split a branch path into the member prefix (`_members/<a>/_members/<b>/`) and the rest. */
+export declare function splitLedgerPath(path: string): {
+    prefix: string;
+    member: string | null;
+    rest: string;
+};
+/**
+ * The key a digest is matched by: its hex. A plan digest written `sha256:<hex>`
+ * names the same plan as `jcs1-sha256:<hex>` (`samePlanDigest`), and a file
+ * name writes `:` as `_`, so both sides are reduced to the hex.
+ */
+export declare function digestKey(digestOrStem: string): string;
+/**
+ * Decide what a prune of `chant/lifecycle` removes and keeps, by the rules at
+ * the top of this file. Reads the branch at its local tip and writes nothing.
+ */
+export declare function planLifecycleGc(input: GcInput): LifecycleGcPlan;
+/** The commit message of a prune. */
+export declare function pruneMessage(remove: readonly GcFile[]): string;
+/** What {@link runLifecycleGc} did, or would do on a dry run. */
+export interface GcReport {
+    now: string;
+    policy: RetentionPolicy;
+    dryRun: boolean;
+    lifecycle: LifecycleGcPlan & {
+        /** The prune commit, or null on a dry run or when nothing was removed. */
+        commit: string | null;
+        pushed: boolean;
+        pushWarning?: string;
+    };
+    runEvents: {
+        dir: string | null;
+        remove: RunEventFile[];
+        kept: {
+            files: number;
+            bytes: number;
+        };
+        /** How many files were deleted; 0 on a dry run. */
+        deleted: number;
+    };
+}
+/**
+ * Plan and, unless `dryRun`, carry out a prune: one commit on the local
+ * `chant/lifecycle` that removes what the plan lets go, and the run event
+ * files it lets go deleted. The commit is planned against the tip it is
+ * written on: if the branch moved in between, the plan is made again. It is
+ * pushed only when `push` is set.
+ */
+export declare function runLifecycleGc(input: GcInput & {
+    dryRun: boolean;
+    push?: boolean;
+}): Promise<GcReport>;
+//# sourceMappingURL=retention.d.ts.map

package/dist/lifecycle/retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention.d.ts","sourceRoot":"","sources":["../../src/lifecycle/retention.ts"],"names":[],"mappings":"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"}