@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/ref-log.js

@@ -1,119 +0,0 @@
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, parseRevListOutput, wrapGitError } from "../git/core.js";
-const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-const MISSING_REF_SENTINEL = "0".repeat(40);
-/** Resolve a ref log head, or null when the ref is missing. */
-export async function resolveRefLogHead(cwd, ref, options = {}) {
-    const git = createGit(cwd);
-    const peel = options.peel ?? "commit";
-    const target = peel === "commit" ? `${ref}^{commit}` : ref;
-    try {
-        return (await git.raw(["rev-parse", "--verify", target])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-/** Read the raw commit message bytes used by ref-log parsers (`show %B`). */
-export async function readRefLogCommitMessage(cwd, commit) {
-    const git = createGit(cwd);
-    try {
-        return await git.raw(["show", "-s", "--format=%B", commit]);
-    }
-    catch (error) {
-        throw wrapGitError(`show commit message ${commit}`, error, cwd);
-    }
-}
-/**
- * List commits reachable from `head` oldest-first.
- * `errorLabel` is the ref or range name used in wrapGitError text.
- */
-export async function listRefLogCommits(cwd, head, errorLabel = head) {
-    const git = createGit(cwd);
-    try {
-        return parseRevListOutput(await git.raw(["rev-list", "--reverse", head]));
-    }
-    catch (error) {
-        throw wrapGitError(`rev-list ${errorLabel}`, error, cwd);
-    }
-}
-/**
- * Create an empty-tree commit for a ref log entry.
- * Callers own subject/body byte layout so message formats stay domain-local.
- */
-export async function createRefLogCommit(cwd, input) {
-    const git = createGit(cwd);
-    const args = ["commit-tree", EMPTY_TREE_HASH];
-    if (input.parentHead)
-        args.push("-p", input.parentHead);
-    args.push("-m", input.subject, "-m", input.body);
-    try {
-        return (await git.raw(args)).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`commit-tree ${input.errorLabel ?? input.subject}`, error, cwd);
-    }
-}
-/**
- * Compare-and-swap a ref to `newHead`.
- * Returns false on CAS failure; callers own re-resolve / degrade policy.
- */
-export async function casUpdateRefLog(cwd, ref, newHead, expectedOld) {
-    const git = createGit(cwd);
-    const oldValue = expectedOld ?? MISSING_REF_SENTINEL;
-    try {
-        await git.raw(["update-ref", ref, newHead, oldValue]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readRefLogAt(cwd, ref, head, parse) {
-    const commits = await listRefLogCommits(cwd, head, ref);
-    const entries = [];
-    for (const commit of commits) {
-        entries.push(parse(await readRefLogCommitMessage(cwd, commit)));
-    }
-    return entries;
-}
-export async function readRefLog(cwd, ref, parse) {
-    const head = await resolveRefLogHead(cwd, ref);
-    if (!head)
-        return [];
-    return readRefLogAt(cwd, ref, head, parse);
-}
-export async function appendRefLogWithRetry(cwd, ref, subjectFor, parse, build, options = {}) {
-    const maxRetries = options.maxRetries ?? 3;
-    let currentHead = await resolveRefLogHead(cwd, ref);
-    const startedMissing = currentHead === null;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-        const entries = currentHead ? await readRefLogAt(cwd, ref, currentHead, parse) : [];
-        const entry = await build(entries);
-        if (entry === null)
-            return { ok: false, reason: "aborted", currentHead };
-        const newHead = await createRefLogCommit(cwd, {
-            subject: subjectFor(entry),
-            body: JSON.stringify(entry, null, 2),
-            parentHead: currentHead,
-        });
-        const casOk = await casUpdateRefLog(cwd, ref, newHead, currentHead);
-        if (casOk)
-            return { ok: true, head: newHead };
-        // Intentional degrade: re-resolve after CAS loss; missing-ref mid-flight is sticky
-        // when the ref existed at start (do not resurrect).
-        const resolved = await resolveRefLogHead(cwd, ref);
-        if (resolved === null) {
-            if (!startedMissing)
-                return { ok: false, reason: "missing-ref" };
-            currentHead = null;
-        }
-        else {
-            currentHead = resolved;
-        }
-    }
-    if (currentHead === null)
-        return { ok: false, reason: "missing-ref" };
-    return { ok: false, reason: "conflict", currentHead };
-}

package/build/core/renew-session.js

@@ -1,128 +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 { syncDirectory } from "../fs/durability.js";
-import { deleteRecoveryRef } from "../git/refs.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { renderContractView } from "./contract-view.js";
-import { readLedger } from "./ledger.js";
-import { latestBase } from "./status/drift.js";
-import { findRegisteredContractWorktreePath } from "./worktree-path.js";
-const RENEW_SESSION_DIRECTORY = path.join(".keiyaku", "recovery");
-const RENEW_SESSION_FILE = "renew-session.json";
-function isSha(value) {
-    return typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
-}
-function parseSession(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session is malformed");
-    }
-    const value = raw;
-    const keys = Object.keys(value).sort();
-    const expected = ["commission", "newBase", "oldBase", "oldHead", "recoveryRef"];
-    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session has unknown or missing fields");
-    }
-    if (typeof value.commission !== "string" || !value.commission ||
-        !isSha(value.oldBase) || !isSha(value.oldHead) || !isSha(value.newBase) ||
-        typeof value.recoveryRef !== "string" || !value.recoveryRef) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session has invalid coordinates");
-    }
-    return value;
-}
-async function sessionPath(cwd, commission) {
-    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
-    return worktree ? path.join(worktree, RENEW_SESSION_DIRECTORY, RENEW_SESSION_FILE) : undefined;
-}
-export async function readRenewRecoverySession(cwd, commission) {
-    const filePath = await sessionPath(cwd, commission);
-    if (!filePath)
-        return null;
-    try {
-        return parseSession(JSON.parse(await fs.readFile(filePath, "utf8")));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        if (error instanceof FlowError)
-            throw error;
-        throw new FlowError("INTERNAL_STATE", `cannot read renew recovery session for ${commission}`, { cause: error });
-    }
-}
-export async function writeRenewRecoverySession(cwd, session) {
-    const filePath = await sessionPath(cwd, session.commission);
-    if (!filePath) {
-        throw new FlowError("INTERNAL_STATE", `renew --resolve requires ${session.commission}'s registered contract worktree`);
-    }
-    const existing = await readRenewRecoverySession(cwd, session.commission);
-    if (existing) {
-        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is already open for ${session.commission}`, {
-            facts: { kind: "renew_session", commission: session.commission, nextAction: "continue-or-abort" },
-        });
-    }
-    const directory = path.dirname(filePath);
-    await fs.mkdir(directory, { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-    await fs.writeFile(temporary, `${JSON.stringify(session)}\n`, { encoding: "utf8", flag: "wx" });
-    await fs.rename(temporary, filePath);
-    await syncDirectory(directory);
-    return filePath;
-}
-export async function removeRenewRecoverySession(cwd, commission) {
-    const filePath = await sessionPath(cwd, commission);
-    if (!filePath)
-        return;
-    try {
-        await fs.unlink(filePath);
-        await syncDirectory(path.dirname(filePath));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-function publishedRenewForSession(ledger, session) {
-    const tail = ledger.entries.at(-1);
-    if (session.commission !== ledger.contractId ||
-        tail?.kind !== "renew" ||
-        tail.data.oldBase !== session.oldBase ||
-        tail.data.oldHead !== session.oldHead ||
-        tail.data.newBase !== session.newBase ||
-        latestBase(ledger.entries) !== session.newBase)
-        return null;
-    const previous = ledger.entries.at(-2);
-    return {
-        renew: tail,
-        seal: previous?.kind === "seal" && previous.data.sealedBy === "renew" ? previous : null,
-    };
-}
-export async function convergeRenewRecoverySession(cwd, commission) {
-    const session = await readRenewRecoverySession(cwd, commission);
-    if (!session)
-        return { state: "none" };
-    const ledger = await readLedger(cwd, commission);
-    if (!ledger)
-        return { state: "live", session };
-    const published = publishedRenewForSession(ledger, session);
-    if (!published)
-        return { state: "live", session };
-    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
-    if (!worktree) {
-        throw new FlowError("INTERNAL_STATE", `registered contract worktree disappeared for spent renew session ${commission}`);
-    }
-    await fs.writeFile(path.join(worktree, KEIYAKU_FILE), renderContractView({ id: commission, entries: ledger.entries }), "utf8");
-    const recoveryCleanup = await deleteRecoveryRef(cwd, session.recoveryRef, session.oldHead);
-    await removeRenewRecoverySession(cwd, commission);
-    return { state: "spent", session, ledger, ...published, recoveryCleanup };
-}
-export async function assertNoRenewRecoverySession(cwd, commission) {
-    const state = await convergeRenewRecoverySession(cwd, commission);
-    if (state.state === "none")
-        return null;
-    if (state.state === "spent")
-        return state;
-    throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${commission}`, {
-        facts: { kind: "renew_session", commission, nextAction: "continue-or-abort" },
-    });
-}

package/build/core/status/ledger-batch.js

@@ -1 +0,0 @@
-export { readAllLedgerSnapshots as readStatusLedgers, } from "../ledger-batch.js";

package/build/core/status/reconciliation.js

@@ -1,137 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createGit, parseRevListOutput, wrapGitError } from "../../git/core.js";
-import { stableRepoRoot } from "../worktree-path.js";
-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 [];
-    }
-}
-export async function computeClaimReconciliation(cwd, defaultBranch) {
-    if (!defaultBranch)
-        return null;
-    const receiptLines = await readClaimReceipts(cwd);
-    if (receiptLines.length === 0)
-        return null;
-    const git = createGit(cwd);
-    let firstParentHistory;
-    try {
-        firstParentHistory = parseRevListOutput(await git.raw(["rev-list", "--first-parent", defaultBranch.head]));
-    }
-    catch (error) {
-        throw wrapGitError(`rev-list --first-parent ${defaultBranch.head}`, error, cwd);
-    }
-    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.
-    // Intentional degrade: rev-list failure yields empty segments plus non-chain receipt issues.
-    let revList;
-    try {
-        revList = parseRevListOutput(await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]));
-    }
-    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 };
-}