@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/derived-replay.js

@@ -1,340 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { runGitProcess } from "../git/core.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { inventoryIgnorePatternsForWorktree } from "./repository-ledger/inventory.js";
-import { isJsonObject } from "./outcome-base.js";
-import { carrierRetirementInputIdentity, deliveryRefInputIdentity, narrowIgnoreInputIdentity, renewDeliveryInputIdentity, sameInputIdentity, taskBoardInputIdentity, targetWorktreeInputIdentity, worktreeInputIdentity, } from "./repository-ledger/identity.js";
-import { resolveAcceptedLifecycleTransaction, } from "./repository-ledger/accepted-tail.js";
-import { readTaskBoardGeneration, reconcileTaskForfeit, replayClaimTasks, replayCommittedTaskBind, } from "./task/index.js";
-function terminalEntry(model) {
-    return [...model.history].reverse().find(({ entry }) => (entry.kind === "claim" || entry.kind === "forfeit"));
-}
-function receipt(model, surface, status, facts) {
-    return {
-        surface,
-        status,
-        authoritativeHead: model.contractHead,
-        ...(facts ? { facts } : {}),
-    };
-}
-function currentTransaction(repository, model) {
-    const node = repository.topology.nodes.find((candidate) => (candidate.type === "transaction"
-        && candidate.contract === model.contract
-        && candidate.finalEntryObjectId === model.contractHead));
-    if (!node || node.type !== "transaction") {
-        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no accepted transaction for ${model.contractHead}`);
-    }
-    const accepted = resolveAcceptedLifecycleTransaction({
-        read: repository,
-        transactionObjectId: node.objectId,
-        expectedContract: model.contract,
-    });
-    if (accepted.status !== "accepted") {
-        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} transaction ${node.objectId} is not replayable (${accepted.reason})`);
-    }
-    return accepted;
-}
-function obligation(transactionObjectId, surface, expected) {
-    return {
-        transactionObjectId,
-        surface,
-        expected,
-        idempotencyKey: `${transactionObjectId}:${surface}`,
-    };
-}
-/**
- * Purely derive every required surface for the accepted transaction that
- * advanced this folded contract head. No journal, carrier bytes, or filesystem
- * observation participates in this calculation.
- */
-export function deriveReplayObligations(input) {
-    const { repository, lifecycle: model, target, expectedCarrierIdentity } = input;
-    const transaction = input.transaction ?? currentTransaction(repository, model);
-    const base = { contractId: model.contract, contractHead: model.contractHead };
-    const terminal = terminalEntry(model);
-    const required = [];
-    const taskIds = model.resources.tasks.map(({ taskId }) => taskId);
-    if (taskIds.length > 0) {
-        required.push(obligation(transaction.transactionObjectId, "task-board", taskBoardInputIdentity({
-            ...base, taskIds, phase: model.phase,
-        })));
-    }
-    if (terminal) {
-        required.push(obligation(transaction.transactionObjectId, "carrier-retirement", carrierRetirementInputIdentity({
-            ...base,
-            target: target.status === "available" ? target.path : `${target.workspace}:${target.reason}`,
-        })), obligation(transaction.transactionObjectId, "worktree", worktreeInputIdentity({
-            ...base,
-            deliveryHead: model.pins.delivery,
-        })), obligation(transaction.transactionObjectId, "delivery-ref", deliveryRefInputIdentity({
-            ...base, deliveryRef: model.resources.deliveryRef,
-        })));
-        if (terminal.entry.kind === "claim" && terminal.entry.data && typeof terminal.entry.data.target === "string") {
-            required.push(obligation(transaction.transactionObjectId, "target-worktree", targetWorktreeInputIdentity({
-                ...base,
-                target: terminal.entry.data.target,
-                targetHead: terminal.entry.data.targetHead,
-                mergeCommit: terminal.entry.data.mergeCommit,
-            })));
-        }
-        if (target.status === "available") {
-            required.push(obligation(transaction.transactionObjectId, "narrow-ignore", narrowIgnoreInputIdentity({
-                ...base,
-                inventory: JSON.stringify(inventoryIgnorePatternsForWorktree(repository, model)),
-                occupancy: `${target.workspace}:${target.root}`,
-            })));
-        }
-        return required;
-    }
-    const deliveryHead = model.pins.delivery;
-    if (deliveryHead !== null) {
-        required.push(obligation(transaction.transactionObjectId, "worktree", worktreeInputIdentity({ ...base, deliveryHead })));
-    }
-    const patterns = inventoryIgnorePatternsForWorktree(repository, model);
-    required.push(obligation(transaction.transactionObjectId, "narrow-ignore", narrowIgnoreInputIdentity({
-        ...base,
-        inventory: JSON.stringify(patterns),
-        occupancy: `${target.workspace}:${target.status === "available" ? target.root : target.reason}`,
-    })), obligation(transaction.transactionObjectId, "carrier", expectedCarrierIdentity));
-    if (transaction.verb === "renew") {
-        const renew = transaction.entries.find((entry) => entry.kind === "renew");
-        if (renew?.kind === "renew") {
-            required.push(obligation(transaction.transactionObjectId, "renew-delivery", renewDeliveryInputIdentity({
-                ...base,
-                oldHead: renew.data.oldHead,
-                newHead: renew.data.newHead,
-            })));
-        }
-    }
-    return required;
-}
-async function gitExit(cwd, args) {
-    const result = await runGitProcess(cwd, args);
-    if (result.error || (result.status !== 0 && result.status !== 1)) {
-        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || `git ${args.join(" ")} exited ${String(result.status)}`, {
-            cause: result.error,
-        });
-    }
-    return result.status;
-}
-/** Materialize exact per-worktree ignore bytes admitted by typed inventory. */
-export async function materializeInventoryIgnore(targetRoot, patterns) {
-    const ignorePath = path.join(targetRoot, ".gitignore");
-    const expected = patterns.length === 0 ? "" : `${patterns.join("\n")}\n`;
-    const tracked = await gitExit(targetRoot, ["ls-files", "--error-unmatch", "--", ".gitignore"]) === 0;
-    if (tracked) {
-        if (patterns.length === 0)
-            return "already-present";
-        const ignored = await gitExit(targetRoot, ["check-ignore", "-q", "--", KEIYAKU_FILE]) === 0;
-        if (!ignored)
-            throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "tracked .gitignore does not ignore the generated contract view");
-        return "already-present";
-    }
-    let existing = null;
-    try {
-        existing = await fs.readFile(ignorePath, "utf8");
-    }
-    catch (error) {
-        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
-            throw error;
-    }
-    if (patterns.length === 0) {
-        if (existing === null)
-            return "already-present";
-        if (existing !== `${[".gitignore", KEIYAKU_FILE].join("\n")}\n`)
-            return "already-present";
-        await fs.unlink(ignorePath);
-        return "created";
-    }
-    if (existing === expected)
-        return "already-present";
-    if (existing !== null)
-        throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "untracked .gitignore is not a proven generated rendering");
-    const temporary = `${ignorePath}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        await fs.writeFile(temporary, expected, { encoding: "utf8", flag: "wx" });
-        await fs.rename(temporary, ignorePath);
-    }
-    catch (error) {
-        await fs.unlink(temporary).catch(() => undefined);
-        throw error;
-    }
-    return "created";
-}
-async function replayTaskBoard(cwd, model, adapters) {
-    const taskIds = model.resources.tasks.map(({ taskId }) => taskId);
-    const terminal = terminalEntry(model);
-    if (terminal?.entry.kind === "claim") {
-        const replay = taskIds.length === 0
-            ? { commit: terminal.entry.data.mergeCommit, taskCount: 0, worktree: "ref-only" }
-            : await replayClaimTasks({
-                cwd,
-                contractId: model.contract,
-                targetRef: terminal.entry.data.target,
-                taskIds,
-                updatedAt: terminal.entry.at,
-            });
-        return {
-            status: taskIds.length === 0 ? "already-present" : replay.worktree === "ref-only" ? "ref-only" : "created",
-            facts: { taskCount: replay.taskCount, commit: replay.commit, worktree: replay.worktree },
-        };
-    }
-    if (terminal?.entry.kind === "forfeit") {
-        if (taskIds.length === 0)
-            return { status: "already-present", facts: { taskCount: 0 } };
-        const generation = await readTaskBoardGeneration(cwd);
-        await reconcileTaskForfeit({
-            cwd,
-            contractId: model.contract,
-            expectedGeneration: generation,
-            publishLedger: async () => undefined,
-        });
-        return { status: "created", facts: { taskCount: taskIds.length } };
-    }
-    if (taskIds.length === 0)
-        return { status: "already-present", facts: { taskCount: 0 } };
-    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
-    if (!bind || bind.kind !== "bind")
-        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no typed bind`);
-    const status = await replayCommittedTaskBind(cwd, bind.data.base, taskIds);
-    return { status, facts: { taskCount: taskIds.length } };
-}
-function recordSurface(journal, replay, run) {
-    return journal.run({
-        effect: `${replay.surface}-projection`,
-        idempotencyKey: replay.idempotencyKey,
-        run: async () => structuredClone(await run()),
-    });
-}
-/** Sole phase-driven owner for replaying projections from an accepted folded head. */
-export async function replayCommittedDerivedState(input) {
-    const { lifecycle: model, journal } = input;
-    const terminal = terminalEntry(model);
-    const transaction = input.transaction ?? currentTransaction(input.repository, model);
-    const expectedCarrierIdentity = input.adapters.expectedCarrierIdentity(model);
-    if (expectedCarrierIdentity.contractId !== model.contract
-        || expectedCarrierIdentity.contractHead !== model.contractHead) {
-        throw new FlowError("INTERNAL_STATE", "carrier identity semantics did not derive the folded contract coordinate");
-    }
-    const obligations = new Map(deriveReplayObligations({
-        ...input,
-        transaction,
-        expectedCarrierIdentity,
-    }).map((item) => [item.surface, item]));
-    let projectedTarget = input.target;
-    const receipts = [];
-    const run = async (surface, operation, current) => {
-        const replay = obligations.get(surface);
-        if (!replay)
-            return;
-        const row = await recordSurface(journal, replay, async () => {
-            const actual = await input.adapters.inspectSurface({ obligation: replay });
-            if (sameInputIdentity(actual, replay.expected)) {
-                return current?.() ?? receipt(model, surface, "already-present", { inputIdentity: replay.expected });
-            }
-            return operation();
-        });
-        if (row.status === "succeeded")
-            receipts.push(row.receipt);
-    };
-    await run("task-board", async () => {
-        const replay = await replayTaskBoard(input.cwd, model, input.adapters);
-        return receipt(model, "task-board", replay.status, replay.facts);
-    });
-    if (terminal?.entry.kind === "claim") {
-        const claim = terminal.entry;
-        await run("target-worktree", async () => {
-            const taskRow = journal.all().find((row) => row.effect === "task-board-projection" && row.status === "succeeded");
-            const taskFacts = taskRow?.status === "succeeded" ? taskRow.receipt?.facts : undefined;
-            const commit = isJsonObject(taskFacts) && typeof taskFacts.commit === "string"
-                ? taskFacts.commit
-                : claim.data.mergeCommit;
-            const warnings = await input.adapters.replayClaimTarget({
-                target: claim.data.target,
-                targetHead: claim.data.targetHead,
-                mergeCommit: commit,
-            });
-            return receipt(model, "target-worktree", warnings.length === 0 ? "created" : "mismatch", {
-                target: claim.data.target,
-                targetHead: claim.data.targetHead,
-                mergeCommit: commit,
-                warnings: [...warnings],
-            });
-        });
-    }
-    if (terminal) {
-        let carrierRetired = false;
-        await run("carrier-retirement", async () => {
-            const status = await input.adapters.retireContractView({ lifecycle: model, target: input.target });
-            return receipt(model, "carrier-retirement", status);
-        });
-        carrierRetired = journal.all().some((row) => (row.effect === "carrier-retirement-projection" && row.status === "succeeded"));
-        await run("narrow-ignore", async () => {
-            if (!carrierRetired) {
-                throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "cannot retire narrow ignore before carrier retirement");
-            }
-            if (input.target.status !== "available") {
-                return receipt(model, "narrow-ignore", "already-present", { patterns: [] });
-            }
-            const patterns = inventoryIgnorePatternsForWorktree(input.repository, model);
-            return receipt(model, "narrow-ignore", await materializeInventoryIgnore(input.target.root, patterns), { patterns });
-        });
-        await run("worktree", async () => {
-            const cleanup = await input.adapters.cleanupWorkspace(input.cwd, model);
-            return receipt(model, "worktree", cleanup.absent.includes("worktree") ? "already-present" : "retired", {
-                absent: cleanup.absent,
-                ...(cleanup.removedWorktreePath ? { removedWorktreePath: cleanup.removedWorktreePath } : {}),
-                ...(cleanup.worktreeRemoveFailure ? { worktreeRemoveFailure: cleanup.worktreeRemoveFailure } : {}),
-            });
-        }, () => receipt(model, "worktree", "already-present", { absent: ["worktree"] }));
-        await run("delivery-ref", async () => {
-            const observation = await input.adapters.observeDeliveryRef(input.cwd, model.contract);
-            return observation.status === "aligned"
-                ? receipt(model, "delivery-ref", "already-present", observation)
-                : receipt(model, "delivery-ref", "mismatch", observation);
-        }, () => receipt(model, "delivery-ref", "already-present", {
-            status: "aligned",
-            ref: model.resources.deliveryRef,
-            expected: "absent",
-            observed: "absent",
-        }));
-        return receipts;
-    }
-    await run("worktree", async () => {
-        const replay = await input.adapters.reconcileActiveWorktree();
-        projectedTarget = replay.target;
-        return receipt(model, "worktree", replay.status);
-    });
-    if (obligations.has("renew-delivery")) {
-        await run("renew-delivery", async () => {
-            if (transaction.verb !== "renew")
-                throw new FlowError("INTERNAL_STATE", "renew delivery obligation lacks an accepted renew transaction");
-            const renew = transaction.entries.find((entry) => entry.kind === "renew");
-            if (!renew || renew.kind !== "renew")
-                throw new FlowError("INTERNAL_STATE", "accepted renew transaction lacks a renew entry");
-            if (projectedTarget.status !== "available")
-                throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projectedTarget.reason);
-            return receipt(model, "renew-delivery", await input.adapters.reconcileRenewDelivery({ lifecycle: model, target: projectedTarget, transaction }), { oldHead: renew.data.oldHead, newHead: renew.data.newHead });
-        });
-    }
-    await run("narrow-ignore", async () => {
-        if (projectedTarget.status !== "available")
-            throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projectedTarget.reason);
-        const patterns = inventoryIgnorePatternsForWorktree(input.repository, model);
-        return receipt(model, "narrow-ignore", await materializeInventoryIgnore(projectedTarget.root, patterns), {
-            patterns,
-        });
-    });
-    await run("carrier", async () => {
-        const incomplete = journal.all().find((row) => row.status !== "succeeded");
-        if (incomplete) {
-            throw new FlowError("CARRIER_MATERIALIZATION_FAILED", `cannot advance carrier checkpoint while ${incomplete.effect} is ${incomplete.status}`);
-        }
-        const status = await input.adapters.materializeContractView({ lifecycle: model, target: projectedTarget });
-        return receipt(model, "carrier", status, { path: projectedTarget.status === "available" ? path.join(projectedTarget.root, KEIYAKU_FILE) : null });
-    });
-    return receipts;
-}