@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/status.js

@@ -1,539 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { assertSettingsKnobUsable, loadKeiyakuSettings, } from "../config/settings.js";
-import { FlowError } from "../flow-error.js";
-import { SETTINGS_FILE } from "../keiyaku.js";
-import { isGitRepo } from "../git/branches.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
-import { fullBranchRefSchema } from "./entry.js";
-import { listContractIds, readLedger } from "./ledger.js";
-import { readProjectionStatusBoard } from "./projection-status.js";
-import { deriveQueueReadModel, queueMembership, } from "./queue_v2.js";
-import { findOpenArc, getMaxArc, receiptsAfterFence } from "./seal.js";
-import { stableRepoRoot } from "./worktree-path.js";
-/** Prefix bare branch names and validate the full ref. Sole status/bind normalizer. */
-export function normalizeTargetRef(raw) {
-    const ref = raw.startsWith("refs/heads/") ? raw : `refs/heads/${raw}`;
-    if (!fullBranchRefSchema.safeParse(ref).success) {
-        throw new FlowError("INVALID_TARGET", `invalid target ref '${raw}' — pass a branch name or refs/heads/<name>`);
-    }
-    return ref;
-}
-function transitionFromEntry(current, entry) {
-    if (current === "claimed" || current === "forfeited" || current === "corrupt") {
-        return "corrupt";
-    }
-    switch (entry.kind) {
-        case "bind":
-            return "corrupt";
-        case "bootstrap":
-            // Placement legality is owned exclusively by deriveContractState.
-            return "corrupt";
-        case "arc":
-            return current === "bound" || current === "active" ? "active" : "corrupt";
-        case "seal":
-            return current === "active" ? "active" : "corrupt";
-        case "amend":
-            return current === "petitioned" ? "active" : current;
-        case "renew":
-            return current;
-        case "verdict":
-            if (current !== "petitioned")
-                return "corrupt";
-            return entry.data.result === "rejected" ? "active" : "petitioned";
-        case "petition":
-            return current === "bound" || current === "active" ? "petitioned" : "corrupt";
-        case "claim":
-            return current === "petitioned" ? "claimed" : "corrupt";
-        case "forfeit":
-            return "forfeited";
-    }
-    return "corrupt";
-}
-export function deriveContractState(entries) {
-    if (entries.length === 0 || entries[0]?.kind !== "bind") {
-        return { state: "corrupt", at: 0, reason: "ledger must start with bind" };
-    }
-    const bind = entries[0];
-    let state = "bound";
-    for (let index = 1; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (entry.kind === "bootstrap") {
-            if (index !== 1 || state !== "bound") {
-                return { state: "corrupt", at: index + 1, reason: "bootstrap must immediately follow bind" };
-            }
-            if (!bind.data.bootstrap) {
-                return { state: "corrupt", at: index + 1, reason: "bootstrap without bind plan" };
-            }
-            // Legal bootstrap is a durable fact and leaves the derived state bound.
-            continue;
-        }
-        const next = transitionFromEntry(state, entry);
-        if (next === "corrupt") {
-            return { state: "corrupt", at: index + 1, reason: `invalid ${entry.kind} after ${state}` };
-        }
-        state = next;
-    }
-    return { state };
-}
-export function deriveBootstrapDiagnostics(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind?.data.bootstrap)
-        return [];
-    if (entries.some((entry) => entry.kind === "bootstrap"))
-        return [];
-    return [{ kind: "plan-without-result" }];
-}
-export function isTerminalState(state) {
-    return state.state === "claimed" || state.state === "forfeited";
-}
-function hasCurrentPetitionVerdict(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "verdict")
-            return true;
-        if (entry.kind === "petition")
-            return false;
-    }
-    return false;
-}
-function isQueueHeadStall(input) {
-    return (input.queuePosition === 1 &&
-        input.queueLength > 1 &&
-        input.state.state === "petitioned" &&
-        !hasCurrentPetitionVerdict(input.entries));
-}
-export function latestBase(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "renew")
-            return entry.data.newBase;
-    }
-    return entries.find((entry) => entry.kind === "bind")?.data.base;
-}
-/** Commission settlement target from the bind entry. Schema guarantees refs/heads/<name>. */
-export function commissionTarget(entries) {
-    const bind = findBindEntry(entries);
-    if (!bind)
-        return undefined;
-    const ref = bind.data.target;
-    return {
-        ref,
-        branch: ref.slice("refs/heads/".length),
-    };
-}
-async function resolveCommit(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${ref}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-export async function readSettingsDiseases(cwd) {
-    const loaded = await loadKeiyakuSettings(cwd);
-    return loaded.diseases;
-}
-export async function readDefaultBranchOverride(cwd) {
-    const loaded = await loadKeiyakuSettings(cwd);
-    return loaded.knobs?.defaultBranch;
-}
-async function resolveDefaultBranchFromSettings(cwd, loaded, rejectDiseasedOverride) {
-    if (rejectDiseasedOverride)
-        assertSettingsKnobUsable(loaded, "defaultBranch");
-    const override = loaded.knobs?.defaultBranch;
-    if (override) {
-        const head = await resolveCommit(cwd, override);
-        if (!head)
-            throw new FlowError("INVALID_SETTINGS", `${SETTINGS_FILE} defaultBranch '${override}' does not resolve`);
-        return { branch: override, head };
-    }
-    const git = createGit(cwd);
-    for (const branch of ["main", "master"]) {
-        const head = await resolveCommit(cwd, branch);
-        if (head)
-            return { branch, head };
-    }
-    try {
-        const originHead = (await git.raw(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"])).trim();
-        if (originHead) {
-            const head = await resolveCommit(cwd, originHead);
-            if (head)
-                return { branch: originHead, head };
-        }
-    }
-    catch {
-        // Fall through to local branch heuristics.
-    }
-    return null;
-}
-export async function resolveDefaultBranch(cwd) {
-    return resolveDefaultBranchFromSettings(cwd, await loadKeiyakuSettings(cwd), true);
-}
-export async function evaluateBaseDrift(cwd, base, defaultBranch) {
-    if (!defaultBranch)
-        return { state: "unknown", label: "n/a (no default branch)" };
-    if (base === defaultBranch.head) {
-        return { state: "green", defaultBranch: defaultBranch.branch, defaultHead: defaultBranch.head };
-    }
-    const git = createGit(cwd);
-    try {
-        await git.raw(["merge-base", "--is-ancestor", base, defaultBranch.head]);
-        const behindBy = Number.parseInt((await git.raw(["rev-list", "--count", `${base}..${defaultBranch.head}`])).trim(), 10);
-        return {
-            state: "drift",
-            defaultBranch: defaultBranch.branch,
-            defaultHead: defaultBranch.head,
-            behindBy: Number.isFinite(behindBy) ? behindBy : 0,
-        };
-    }
-    catch {
-        return { state: "orphaned", defaultBranch: defaultBranch.branch, defaultHead: defaultBranch.head };
-    }
-}
-function findBindEntry(entries) {
-    return entries.find((entry) => entry.kind === "bind");
-}
-function contractSlugFromId(id) {
-    const dot = id.indexOf(".");
-    if (dot > 0)
-        return id.slice(0, dot);
-    return id;
-}
-function deriveCurrentArc(entries, bindObjective) {
-    const arcObjectives = new Map();
-    let currentArc = null;
-    for (const entry of entries) {
-        if (entry.kind === "arc") {
-            arcObjectives.set(entry.data.arc, entry.data.objective);
-            currentArc = {
-                number: entry.data.arc,
-                objective: entry.data.objective,
-                state: "open",
-            };
-            continue;
-        }
-        if (entry.kind === "seal") {
-            currentArc = {
-                number: entry.data.arc,
-                objective: arcObjectives.get(entry.data.arc) ?? bindObjective ?? "",
-                state: "closed",
-            };
-        }
-    }
-    if (currentArc)
-        return currentArc;
-    return {
-        number: 0,
-        objective: bindObjective ?? "",
-        state: "closed",
-    };
-}
-function deriveNextStep(input) {
-    if (input.state.state === "corrupt") {
-        return { kind: "inspect-log", detail: "inspect log" };
-    }
-    const pendingAfter = input.after.filter((item) => !item.terminal).map((item) => contractSlugFromId(item.id));
-    if (pendingAfter.length > 0) {
-        return { kind: "wait-after", detail: `finish after ${pendingAfter.join(",")}` };
-    }
-    if (input.state.state === "petitioned") {
-        return { kind: "await-claim", detail: "await claim" };
-    }
-    if (input.baseDrift.state === "drift" || input.baseDrift.state === "orphaned") {
-        return { kind: "renew", detail: "renew" };
-    }
-    if (input.currentArc.state === "open") {
-        return { kind: "arc", detail: "arc" };
-    }
-    if (input.state.state === "active" && input.currentArc.number > 0) {
-        return { kind: "petition", detail: "petition" };
-    }
-    return { kind: "arc", detail: "arc" };
-}
-function deriveLastActiveAge(entries, now) {
-    const last = entries.at(-1);
-    if (!last)
-        return {};
-    const atMs = Date.parse(last.at);
-    if (!Number.isFinite(atMs)) {
-        return { lastActivityAt: last.at };
-    }
-    return {
-        lastActivityAt: last.at,
-        lastActiveMs: Math.max(0, now - atMs),
-    };
-}
-function isClaimReceipt(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const receipt = value;
-    return receipt.kind === "receipt" && [receipt.oldHead, receipt.newHead, receipt.contract].every((field) => typeof field === "string" && field.length > 0);
-}
-function isClaimReceiptBaseline(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const baseline = value;
-    if (baseline.kind !== "baseline" || typeof baseline.head !== "string" || typeof baseline.by !== "string" || baseline.by.length === 0) {
-        return false;
-    }
-    if (typeof baseline.establishedAt !== "string" || !baseline.establishedAt.endsWith("Z"))
-        return false;
-    const at = Date.parse(baseline.establishedAt);
-    return Number.isFinite(at) && new Date(at).toISOString() === baseline.establishedAt;
-}
-async function readClaimReceipts(cwd) {
-    const receiptsPath = path.join(await stableRepoRoot(cwd), ".keiyaku", "claim-receipts.jsonl");
-    try {
-        const content = fs.readFileSync(receiptsPath, "utf8");
-        return content
-            .split("\n")
-            .map((line, index) => ({ line, index: index + 1 }))
-            .filter(({ line }) => line.trim().length > 0)
-            .map(({ line, index }) => {
-            try {
-                const parsed = JSON.parse(line);
-                return isClaimReceipt(parsed) || isClaimReceiptBaseline(parsed)
-                    ? { line: index, record: parsed }
-                    : { line: index, issue: { line: index, reason: "malformed" } };
-            }
-            catch {
-                return { line: index, issue: { line: index, reason: "malformed" } };
-            }
-        });
-    }
-    catch {
-        return [];
-    }
-}
-async function computeClaimReconciliation(cwd, defaultBranch) {
-    if (!defaultBranch)
-        return null;
-    const receiptLines = await readClaimReceipts(cwd);
-    if (receiptLines.length === 0)
-        return null;
-    const git = createGit(cwd);
-    const firstParentHistory = (await git.raw(["rev-list", "--first-parent", defaultBranch.head])).trim().split("\n").filter(Boolean);
-    const firstParentSet = new Set(firstParentHistory);
-    let baselineIndex = -1;
-    for (let index = receiptLines.length - 1; index >= 0; index -= 1) {
-        const record = receiptLines[index].record;
-        if (record?.kind === "baseline" && firstParentSet.has(record.head)) {
-            baselineIndex = index;
-            break;
-        }
-    }
-    if (baselineIndex < 0)
-        return null;
-    const baseline = receiptLines[baselineIndex].record;
-    const issues = receiptLines.slice(baselineIndex + 1).flatMap((line) => {
-        if (line.issue)
-            return [line.issue];
-        return line.record?.kind === "baseline" ? [{ line: line.line, reason: "non-chain" }] : [];
-    });
-    // Only records after the latest valid baseline belong to this fence window.
-    let revList;
-    try {
-        const output = await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]);
-        revList = output.trim().split("\n").filter((h) => h.length > 0);
-    }
-    catch {
-        return {
-            defaultBranch: defaultBranch.branch,
-            head: defaultBranch.head,
-            unclaimedSegments: [],
-            receiptIssues: [...issues, ...receiptLines.slice(baselineIndex + 1).filter((line) => line.record?.kind === "receipt").map((line) => ({ line: line.line, reason: "non-chain" }))],
-        };
-    }
-    const firstParent = new Map();
-    let parent = baseline.head;
-    for (const commit of revList) {
-        firstParent.set(commit, parent);
-        parent = commit;
-    }
-    const indexByCommit = new Map(revList.map((commit, index) => [commit, index]));
-    const claimedHeads = new Set();
-    let previousReceiptIndex = -1;
-    for (const line of receiptLines.slice(baselineIndex + 1)) {
-        if (line.record?.kind !== "receipt")
-            continue;
-        const index = indexByCommit.get(line.record.newHead);
-        if (index === undefined || index <= previousReceiptIndex || firstParent.get(line.record.newHead) !== line.record.oldHead) {
-            issues.push({ line: line.line, reason: "non-chain" });
-            continue;
-        }
-        previousReceiptIndex = index;
-        claimedHeads.add(line.record.newHead);
-    }
-    // Walk default-branch first-parent edges and group only movement not covered
-    // by a valid receipt. These are facts, not a judgment about their source.
-    const segments = [];
-    let segmentStart = null;
-    let segmentCount = 0;
-    for (const commit of revList) {
-        if (claimedHeads.has(commit)) {
-            if (segmentStart !== null) {
-                segments.push({ oldHead: segmentStart, newHead: firstParent.get(commit), commitCount: segmentCount });
-                segmentStart = null;
-                segmentCount = 0;
-            }
-        }
-        else {
-            if (segmentStart === null) {
-                segmentStart = firstParent.get(commit);
-            }
-            segmentCount++;
-        }
-    }
-    // Trailing unclaimed segment up to HEAD
-    if (segmentStart !== null) {
-        segments.push({ oldHead: segmentStart, newHead: defaultBranch.head, commitCount: segmentCount });
-    }
-    return { defaultBranch: defaultBranch.branch, head: defaultBranch.head, unclaimedSegments: segments, receiptIssues: issues };
-}
-export async function readKanshiBoard(cwd, now, opts) {
-    const targetFilter = opts?.target ?? null;
-    const loadedSettings = await loadKeiyakuSettings(cwd);
-    if (!(await isGitRepo(cwd))) {
-        return {
-            contracts: [],
-            projections: null,
-            queueLength: 0,
-            diseases: loadedSettings.diseases,
-            claimReconciliation: null,
-            targetFilter,
-        };
-    }
-    // Status is a pure reader: use the same resolver, but retain its ability to
-    // open when the defaultBranch knob itself is diseased.
-    let defaultBranch = null;
-    try {
-        defaultBranch = await resolveDefaultBranchFromSettings(cwd, loadedSettings, false);
-    }
-    catch {
-        defaultBranch = null;
-    }
-    const contractIds = await listContractIds(cwd);
-    const terminalById = new Map();
-    const ledgers = [];
-    const readableLedgers = [];
-    for (const id of contractIds) {
-        try {
-            const ledger = await readLedger(cwd, id);
-            if (ledger) {
-                ledgers.push(ledger);
-                readableLedgers.push(ledger);
-                terminalById.set(id, isTerminalState(deriveContractState(ledger.entries)));
-            }
-        }
-        catch (error) {
-            ledgers.push({ id, error: error instanceof Error ? error : new Error(String(error)) });
-        }
-    }
-    const queueModel = deriveQueueReadModel(readableLedgers);
-    const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
-    const contracts = [];
-    // Readable-ledger commission targets retained for post-assembly filter only.
-    const derivedTargetById = new Map();
-    for (const item of ledgers) {
-        if ("error" in item) {
-            // Unreadable ledgers have no derivable target and stay under every filter.
-            derivedTargetById.set(item.id, undefined);
-            contracts.push({
-                id: item.id,
-                slug: contractSlugFromId(item.id),
-                state: { state: "corrupt", at: 0, reason: item.error.message },
-                queueHeadStalled: false,
-                arcs: 0,
-                currentArc: { number: 0, objective: "", state: "closed" },
-                nextStep: { kind: "inspect-log", detail: "inspect log" },
-                baseDrift: { state: "unknown", label: "n/a (corrupt ledger)" },
-                after: [],
-                corruptReason: item.error.message,
-                bootstrapDiagnostics: [],
-                queueDiagnostics: [],
-            });
-            continue;
-        }
-        const bind = findBindEntry(item.entries);
-        derivedTargetById.set(item.contractId, commissionTarget(item.entries)?.ref);
-        const base = latestBase(item.entries);
-        const state = deriveContractState(item.entries);
-        if (isTerminalState(state))
-            continue;
-        const after = (bind?.data.after ?? []).map((id) => ({ id, terminal: terminalById.get(id) ?? false }));
-        const currentArc = deriveCurrentArc(item.entries, bind?.data.objective);
-        const baseDrift = base
-            ? await evaluateBaseDrift(cwd, base, defaultBranch)
-            : { state: "unknown", label: "n/a (no default branch)" };
-        const nextStep = deriveNextStep({
-            id: item.contractId,
-            state,
-            currentArc,
-            baseDrift,
-            after,
-        });
-        if (nextStep.kind === "renew" && baseDrift.state === "drift") {
-            const openArc = findOpenArc(item.entries);
-            let receiptCount = 0;
-            if (openArc) {
-                try {
-                    receiptCount = (await receiptsAfterFence(cwd, item.entries, `keiyaku/${item.contractId}`)).length;
-                }
-                catch {
-                    // A ledger-only here contract may not have a delivery ref yet.
-                }
-            }
-            const sealForecast = openArc ? `seals a${openArc.data.arc} (${receiptCount} receipts), ` : "";
-            nextStep.hint = `run: keiyaku @${item.contractId} renew — ${sealForecast}follows ${baseDrift.defaultBranch} ▲${baseDrift.behindBy}`;
-        }
-        const membership = queueMembership(queueModel, item.contractId);
-        const queuePosition = membership?.position ?? null;
-        const targetQueueLength = membership?.queueLength ?? 0;
-        contracts.push({
-            id: item.contractId,
-            slug: contractSlugFromId(item.contractId),
-            state,
-            queuePosition,
-            queueHeadStalled: isQueueHeadStall({
-                entries: item.entries,
-                queuePosition,
-                queueLength: targetQueueLength,
-                state,
-            }),
-            arcs: getMaxArc(item.entries),
-            currentArc,
-            nextStep,
-            ...deriveLastActiveAge(item.entries, now),
-            place: bind?.data.place ?? null,
-            base,
-            baseDrift,
-            after,
-            bootstrapDiagnostics: deriveBootstrapDiagnostics(item.entries),
-            queueDiagnostics: membership ? [...membership.diagnostics] : [],
-        });
-    }
-    const filteredContracts = targetFilter === null
-        ? contracts
-        : contracts.filter((contract) => {
-            const derived = derivedTargetById.get(contract.id);
-            return derived === undefined || derived === targetFilter;
-        });
-    const queueLength = targetFilter === null
-        ? boardQueueLength
-        : (queueModel.targetQueues.find((queue) => queue.target === targetFilter)?.ordered.length ?? 0);
-    const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
-    return {
-        contracts: filteredContracts,
-        projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
-        queueLength,
-        defaultBranch: defaultBranch?.branch,
-        defaultHead: defaultBranch?.head,
-        diseases: loadedSettings.diseases,
-        claimReconciliation,
-        targetFilter,
-    };
-}