@astrosheep/keiyaku 2.8.5 → 2.9.1

package/build/core/task-contract.js

@@ -0,0 +1,237 @@
+import { FlowError } from "../flow-error.js";
+import { assertGitObservation, requireGitRepository } from "../git/branches.js";
+import { withLockHeldTaskBoard } from "./task-git-store.js";
+import { prepareTaskDocumentReplacements, taskRepositoryFromLockedBoard } from "./task-store-repository.js";
+import { containsCommit, createLandingCommit, createTaskBoardCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, readableRefHead, reconcileTaskIndex, refHead, sameTaskSourceBytes, taskContractAtCommit, taskWritesFromSources, updateBranch, updateTargetRef, } from "./task/settlement-git.js";
+import { contractPointerDocument, doneTaskReplacement, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTaskForBind, taskForContract, } from "./task/settlement-policy.js";
+import { stableRepoRoot } from "./worktree-path.js";
+async function clearAttemptedPointer(input) {
+    const current = requireSettledTask(await input.repository.read(), input.task.id);
+    if (current.contractId === input.contractId) {
+        await replaceTaskDocument(input.repository, contractPointerDocument(current, undefined));
+    }
+}
+async function replaceTaskDocument(repository, replacement) {
+    return repository.mutate(() => ({
+        replacements: [replacement],
+        select: (resulting) => requireSettledTask(resulting, replacement.id),
+    }));
+}
+export async function settleTaskBoardForBind(input, deps = {}) {
+    await requireGitRepository(input.cwd, "task bind");
+    return withLockHeldTaskBoard(input.cwd, async (transaction) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task bind");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
+        }
+        const hubCwd = transaction.location.root;
+        const repository = taskRepositoryFromLockedBoard(transaction);
+        const branch = inspectCurrentBranch(hubCwd);
+        const board = requireHealthySettlementBoard(await repository.read());
+        const selected = input.taskId === undefined
+            ? undefined
+            : selectReadyTaskForBind(board, input.taskId);
+        if (selected) {
+            await replaceTaskDocument(repository, contractPointerDocument(selected, input.contractId));
+        }
+        const firstCommit = createTaskBoardCommit({
+            cwd: hubCwd,
+            gitDir: transaction.location.gitDir,
+            root: transaction.location.root,
+            parent: branch.head,
+            sources: transaction.sources,
+            subject: selected
+                ? `Bind task ${selected.id} to contract ${input.contractId}`
+                : `Flush task board for contract ${input.contractId}`,
+        });
+        try {
+            await updateBranch({ cwd: hubCwd, ref: branch.ref, next: firstCommit, expected: branch.head }, deps);
+        }
+        catch (error) {
+            if (selected) {
+                await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
+                const concurrentHead = refHead(hubCwd, branch.ref);
+                if (taskContractAtCommit(hubCwd, concurrentHead, selected.id) === input.contractId) {
+                    await publishForwardTaskBoardCommit({
+                        cwd: hubCwd,
+                        ref: branch.ref,
+                        gitDir: transaction.location.gitDir,
+                        root: transaction.location.root,
+                        sources: transaction.sources,
+                        subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
+                    }, deps);
+                }
+            }
+            throw error;
+        }
+        try {
+            reconcileTaskIndex(hubCwd, firstCommit);
+        }
+        catch (indexError) {
+            if (selected) {
+                await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
+                await publishForwardTaskBoardCommit({
+                    cwd: hubCwd,
+                    ref: branch.ref,
+                    gitDir: transaction.location.gitDir,
+                    root: transaction.location.root,
+                    sources: transaction.sources,
+                    subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
+                }, deps);
+            }
+            throw indexError;
+        }
+        try {
+            const ledger = await input.publishLedger(firstCommit);
+            return {
+                boardCommit: firstCommit,
+                ledger,
+                ...(selected ? { task: requireSettledTask(await repository.read(), selected.id) } : {}),
+            };
+        }
+        catch (publishError) {
+            if (!selected)
+                throw publishError;
+            await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
+            await publishForwardTaskBoardCommit({
+                cwd: hubCwd,
+                ref: branch.ref,
+                gitDir: transaction.location.gitDir,
+                root: transaction.location.root,
+                sources: transaction.sources,
+                subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
+            }, deps);
+            throw publishError;
+        }
+    });
+}
+export async function reconcileTaskForfeit(input) {
+    await requireGitRepository(input.cwd, "task forfeit");
+    const hubRoot = await stableRepoRoot(input.cwd);
+    return withLockHeldTaskBoard(hubRoot, async (transaction) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task forfeit");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task forfeit requires Git task storage");
+        }
+        const repository = taskRepositoryFromLockedBoard(transaction);
+        const matched = taskForContract(await repository.read(), input.contractId);
+        const ledger = await input.publishLedger();
+        if (!matched)
+            return { ledger };
+        const task = await replaceTaskDocument(repository, reopenedTaskDocument(matched));
+        return {
+            ledger,
+            task,
+        };
+    });
+}
+/**
+ * Claim owns the sole task-board settlement after target CAS. Contract branch
+ * task trees are fossils: the candidate is the code-only three-way merge plus
+ * one complete snapshot of the common hub board held under its repository lock.
+ */
+export async function settleTaskBoardForLanding(input) {
+    await requireGitRepository(input.cwd, "task landing");
+    const hubRoot = await stableRepoRoot(input.cwd);
+    let lastTargetHead = input.targetHead;
+    let lastPublishError;
+    let acceptedMovement;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const result = await withLockHeldTaskBoard(hubRoot, async (transaction) => {
+            if (transaction.location.mode !== "git") {
+                if (transaction.location.capability === "unavailable") {
+                    assertGitObservation({ capability: "unavailable" }, "task landing");
+                }
+                throw new FlowError("NOT_GIT_REPO", "task landing requires Git task storage");
+            }
+            // Each attempt reads fresh target and board facts while holding the
+            // common task lock. A losing CAS exits before the next attempt.
+            const targetHead = refHead(input.cwd, input.targetRef);
+            lastTargetHead = targetHead;
+            const repository = taskRepositoryFromLockedBoard(transaction);
+            const board = requireHealthySettlementBoard(await repository.read());
+            const replacement = doneTaskReplacement(board, input.contractId);
+            const prepared = replacement
+                ? prepareTaskDocumentReplacements(transaction.sources, [replacement])
+                : { sources: transaction.sources, board };
+            const finalSources = prepared.sources;
+            requireHealthySettlementBoard(prepared.board);
+            let mergeCommit = targetHead;
+            let movement = acceptedMovement?.mergeCommit === targetHead ? acceptedMovement : undefined;
+            if (!containsCommit(input.cwd, input.deliveryHead, targetHead)) {
+                mergeCommit = createLandingCommit({
+                    cwd: input.cwd,
+                    gitDir: transaction.location.gitDir,
+                    root: transaction.location.root,
+                    base: input.baseCommit,
+                    target: targetHead,
+                    delivery: input.deliveryHead,
+                    sources: finalSources,
+                    contractId: input.contractId,
+                    targetBranch: input.targetBranch,
+                });
+                await input.beforeCas?.(mergeCommit, targetHead);
+                try {
+                    updateTargetRef(input.cwd, input.targetRef, mergeCommit, targetHead);
+                    movement = { mergeCommit, oldHead: targetHead };
+                    acceptedMovement = movement;
+                }
+                catch {
+                    const current = readableRefHead(input.cwd, input.targetRef);
+                    if (!current || !containsCommit(input.cwd, input.deliveryHead, current)) {
+                        return { kind: "retry" };
+                    }
+                    mergeCommit = current;
+                    movement = acceptedMovement?.mergeCommit === mergeCommit ? acceptedMovement : undefined;
+                }
+            }
+            const warnings = [];
+            if (!sameTaskSourceBytes(transaction.location.root, transaction.sources, finalSources)) {
+                await transaction.replace(taskWritesFromSources(finalSources));
+            }
+            try {
+                reconcileTaskIndex(transaction.location.root, mergeCommit);
+            }
+            catch (error) {
+                warnings.push(`Accepted landing ${mergeCommit}, but task index reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                await input.publishLedger?.(mergeCommit);
+            }
+            catch (error) {
+                lastPublishError = error;
+                return { kind: "retry" };
+            }
+            const reconcileWarnings = movement
+                ? await input.afterCas?.(mergeCommit, movement.oldHead)
+                : undefined;
+            warnings.push(...(reconcileWarnings ?? []));
+            return {
+                kind: movement ? "accepted" : "idempotent",
+                mergeCommit,
+                ...(movement ? { oldHead: movement.oldHead } : {}),
+                ...(warnings.length > 0 ? { warnings } : {}),
+            };
+        });
+        if (result.kind === "retry")
+            continue;
+        if (result.kind === "idempotent") {
+            return {
+                mergeCommit: result.mergeCommit,
+                ...(result.warnings ? { warnings: result.warnings } : {}),
+            };
+        }
+        return {
+            mergeCommit: result.mergeCommit,
+            oldHead: result.oldHead,
+            ...(result.warnings ? { warnings: result.warnings } : {}),
+        };
+    }
+    if (lastPublishError !== undefined)
+        throw lastPublishError;
+    throw new FlowError("CONCURRENT_MODIFICATION", `target branch kept moving while claiming ${input.contractId}; last observed ${lastTargetHead}`);
+}

package/build/core/task-doctor.js

@@ -0,0 +1,14 @@
+import { rollbackOrphanTaskPointers } from "./task.js";
+import { buildTaskSourceBoard } from "./task/source-board.js";
+export async function inspectTaskDoctor(store, repository, facts) {
+    const orphans = facts.lockHeld ? [] : await rollbackOrphanTaskPointers(repository, facts.contractIds);
+    const sources = await store.read();
+    const board = buildTaskSourceBoard(sources);
+    return {
+        board,
+        sources,
+        orphans,
+        landingDiagnostics: facts.landingDiagnostics ?? [],
+        lockHeld: facts.lockHeld === true,
+    };
+}

package/build/core/task-git-actor.js

@@ -0,0 +1,38 @@
+import { spawnSync } from "node:child_process";
+const ANONYMOUS_TASK_CREATOR = "(anonymous)";
+const TASK_ACTOR_ENV = "KEIYAKU_ACTOR";
+const GIT_ACTOR_KEYS = ["keiyaku.actor", "user.name"];
+function defaultRunGit(cwd, args, env) {
+    return spawnSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function attribution(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function resolveTaskCreator(cwd, deps = {}) {
+    const sourceEnv = deps.env ?? process.env;
+    const environmentActor = attribution(sourceEnv[TASK_ACTOR_ENV]);
+    if (environmentActor)
+        return environmentActor;
+    const gitEnv = { ...sourceEnv, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
+    const runGit = deps.runGit ?? defaultRunGit;
+    for (const key of GIT_ACTOR_KEYS) {
+        try {
+            const result = runGit(cwd, ["config", "--get", key], gitEnv);
+            if (!result.error && result.status === 0) {
+                const configuredActor = attribution(result.stdout);
+                if (configuredActor)
+                    return configuredActor;
+            }
+        }
+        catch {
+            // Creator attribution is advisory and must not prevent task creation.
+        }
+    }
+    return ANONYMOUS_TASK_CREATOR;
+}

package/build/core/task-git-runtime.js

@@ -0,0 +1,37 @@
+import { observeGitRepository } from "../git/branches.js";
+import { listContractIds } from "./ledger.js";
+import { contractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
+import { inspectTaskLock, openTaskStore } from "./task-git-store.js";
+import { taskRepositoryFromStore } from "./task-store-repository.js";
+import { withTaskWorktreePolicy } from "./task-worktree.js";
+import { inspectTaskDoctor } from "./task-doctor.js";
+export async function taskCommandContractId(cwd) {
+    const observation = await observeGitRepository(cwd);
+    if (observation.capability === "unknown")
+        throw observation.error;
+    if (observation.capability !== "available" || observation.coordinate !== "repository")
+        return undefined;
+    return contractBoundByEngineWorktree(cwd);
+}
+export async function openTaskCommandRepository(cwd) {
+    const store = await openTaskStore(cwd);
+    const repository = taskRepositoryFromStore(store);
+    if (store.mode !== "git")
+        return repository;
+    const contractId = await contractBoundByEngineWorktree(cwd);
+    return contractId ? withTaskWorktreePolicy(repository, contractId) : repository;
+}
+export async function taskContractIds(cwd) {
+    return new Set(await listContractIds(await stableRepoRoot(cwd)));
+}
+export async function readTaskDoctor(cwd) {
+    const store = await openTaskStore(cwd);
+    const repository = taskRepositoryFromStore(store);
+    const gitMode = store.mode === "git";
+    const lockHeld = (await inspectTaskLock(cwd)).state === "held";
+    return inspectTaskDoctor(store, repository, {
+        contractIds: gitMode ? await taskContractIds(cwd) : new Set(),
+        landingDiagnostics: [],
+        lockHeld,
+    });
+}