@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/task/settlement-policy.js

@@ -1,137 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { resolveTaskReadId } from "./board.js";
-import { openTaskStore } from "./task-git-store.js";
-import { taskRepositoryFromStore } from "./task-store-repository.js";
-import { readTaskBoard } from "./commands.js";
-import { advancedTaskUpdatedAt } from "./model.js";
-export function requireHealthySettlementBoard(board) {
-    if (board.diseases.length > 0) {
-        throw new FlowError("INTERNAL_STATE", `authoritative task board is diseased: ${board.diseases.map((disease) => disease.message).join("; ")}`);
-    }
-    return board;
-}
-function settlementDocument(task, contractId, updatedAt) {
-    return {
-        id: task.id,
-        namespace: task.namespace,
-        coordinate: task.coordinate,
-        title: task.title,
-        state: task.state,
-        pri: task.pri,
-        needs: [...task.needs],
-        parent: task.parent,
-        from: [...task.from],
-        supersedes: [...task.supersedes],
-        relatesTo: [...task.relatesTo],
-        notes: task.notes.map((note) => ({ ...note })),
-        createdAt: task.createdAt,
-        updatedAt: advancedTaskUpdatedAt(task, updatedAt),
-        creator: task.creator,
-        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
-        ...(contractId === undefined ? {} : { contractId }),
-        body: task.body,
-    };
-}
-export function contractPointerDocument(task, contractId, updatedAt) {
-    return settlementDocument(task, contractId, updatedAt);
-}
-export function boundTaskDocument(task, contractId, updatedAt) {
-    const document = settlementDocument(task, contractId, updatedAt);
-    document.state = "open";
-    delete document.startedAt;
-    return document;
-}
-export function reopenedTaskDocument(task, updatedAt) {
-    const document = settlementDocument(task, undefined, updatedAt);
-    document.state = "open";
-    delete document.startedAt;
-    return document;
-}
-function validateReadyForBind(board, task) {
-    if (task.state !== "open" && task.state !== "in_progress") {
-        throw new FlowError("INVALID_TARGET", `task ${task.coordinate} is ${task.state}, not open or in_progress for bind`);
-    }
-    if (task.contractId !== undefined) {
-        throw new FlowError("INVALID_TARGET", `task ${task.coordinate} is already bound to contract ${task.contractId}`);
-    }
-}
-/** Read the sole live task prerequisite gate for a task-selected contract. */
-export async function readRemainingTaskNeedsForSettlement(cwd, evidence) {
-    const needIds = [...new Set(evidence?.selected.flatMap((task) => task.needs
-            .filter((need) => need.contractId === undefined)
-            .map((need) => need.taskId)) ?? [])].sort();
-    if (needIds.length === 0)
-        return [];
-    const board = requireHealthySettlementBoard(await readTaskBoard(taskRepositoryFromStore(await openTaskStore(cwd))));
-    return needIds.map((id) => {
-        const task = board.byId.get(id);
-        if (!task)
-            throw new FlowError("INTERNAL_STATE", `task prerequisite ${id} disappeared from the authoritative board`);
-        return { id, satisfied: task.state === "done" || task.state === "drop", state: task.state };
-    });
-}
-export function selectReadyTasksForBind(board, taskIds) {
-    requireHealthySettlementBoard(board);
-    const rootIds = taskIds.map((taskId) => resolveTaskReadId(board, taskId));
-    const duplicates = rootIds.filter((id, index) => rootIds.indexOf(id) !== index);
-    if (duplicates.length > 0) {
-        throw new FlowError("INVALID_TARGET", `task ${[...new Set(duplicates)].sort().join(", ")} selected more than once`);
-    }
-    const admitted = new Set();
-    const tasks = [];
-    for (const rootId of rootIds) {
-        const root = board.byId.get(rootId);
-        if (!admitted.has(root.coordinate)) {
-            admitted.add(root.coordinate);
-            tasks.push(root);
-        }
-        for (const candidate of board.tasks) {
-            if (candidate.parent === null || admitted.has(candidate.coordinate))
-                continue;
-            if (candidate.state === "done" || candidate.state === "drop")
-                continue;
-            if (isDescendantOf(board, candidate, rootId)) {
-                admitted.add(candidate.coordinate);
-                tasks.push(candidate);
-            }
-        }
-    }
-    for (const task of tasks)
-        validateReadyForBind(board, task);
-    return tasks;
-}
-function isDescendantOf(board, task, ancestorId) {
-    let current = task.parent;
-    while (current !== null) {
-        if (current === ancestorId)
-            return true;
-        current = board.byId.get(current)?.parent ?? null;
-    }
-    return false;
-}
-export function tasksForContract(board, contractId) {
-    requireHealthySettlementBoard(board);
-    return board.tasks
-        .filter((task) => task.contractId === contractId)
-        .sort((left, right) => left.coordinate.localeCompare(right.coordinate));
-}
-export function doneTaskReplacements(board, contractId, taskIds, updatedAt) {
-    return taskIds.flatMap((taskId) => {
-        const task = requireSettledTask(board, taskId);
-        if (task.state === "done" && task.contractId === undefined)
-            return [];
-        if (task.contractId !== contractId) {
-            throw new FlowError("INTERNAL_STATE", `task ${task.coordinate} no longer points to contract ${contractId} while settling its immutable bind-base ownership`);
-        }
-        const settled = settlementDocument(task, undefined, updatedAt);
-        settled.state = "done";
-        delete settled.startedAt;
-        return [settled];
-    });
-}
-export function requireSettledTask(board, id) {
-    const task = requireHealthySettlementBoard(board).byId.get(id);
-    if (!task)
-        throw new FlowError("INTERNAL_STATE", `task ${id} disappeared from the board`);
-    return task;
-}

package/build/core/task/source-board.js

@@ -1,104 +0,0 @@
-import { buildTaskBoardFromDocuments } from "./board.js";
-import { parseTaskDocument } from "./document.js";
-import { invalid } from "./validation.js";
-import { taskCoordinateFromSourcePath } from "./coordinate.js";
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function diseaseSort(left, right) {
-    return compareText(left.path, right.path)
-        || compareText(left.code, right.code)
-        || compareText(left.id ?? "", right.id ?? "")
-        || compareText(left.message, right.message);
-}
-function taskDocument(parsed) {
-    return {
-        id: parsed.id,
-        namespace: parsed.namespace ?? null,
-        coordinate: parsed.coordinate ?? parsed.id,
-        title: parsed.title,
-        state: parsed.state,
-        pri: parsed.pri,
-        needs: [...parsed.needs],
-        parent: parsed.parent,
-        from: [...parsed.from],
-        supersedes: [...parsed.supersedes],
-        relatesTo: [...parsed.relatesTo],
-        notes: parsed.notes.map((note) => ({ ...note })),
-        createdAt: parsed.createdAt,
-        ...(parsed.updatedAt === undefined ? {} : { updatedAt: parsed.updatedAt }),
-        creator: parsed.creator,
-        ...(parsed.startedAt === undefined ? {} : { startedAt: parsed.startedAt }),
-        ...(parsed.contractId === undefined ? {} : { contractId: parsed.contractId }),
-        body: parsed.body,
-    };
-}
-export function buildTaskSourceBoard(sources) {
-    const sourceDiseases = [];
-    const authoritative = [];
-    for (const source of [...sources].sort((a, b) => compareText(a.path, b.path))) {
-        let sourceCoordinate;
-        try {
-            const coordinate = taskCoordinateFromSourcePath(source.path);
-            sourceCoordinate = coordinate.coordinate;
-            const parsed = parseTaskDocument(source);
-            if (coordinate.localId !== parsed.id) {
-                invalid(`task source basename must be ${parsed.id}.md`);
-            }
-            for (const [field, relations] of [
-                ["needs", parsed.needs],
-                ["from", parsed.from],
-                ["supersedes", parsed.supersedes],
-                ["relatesTo", parsed.relatesTo],
-            ]) {
-                if (relations.includes(coordinate.coordinate))
-                    invalid(`task field '${field}' must not reference itself`);
-            }
-            if (parsed.parent === coordinate.coordinate)
-                invalid("task field 'parent' must not reference itself");
-            authoritative.push({ ...parsed, namespace: coordinate.namespace, coordinate: coordinate.coordinate });
-        }
-        catch (error) {
-            sourceDiseases.push({
-                code: "invalid_document",
-                path: source.path,
-                message: `task ${sourceCoordinate ?? source.path} invalid document: ${error instanceof Error ? error.message : String(error)}`,
-                ...(sourceCoordinate === undefined ? {} : { id: sourceCoordinate }),
-            });
-        }
-    }
-    const counts = new Map();
-    for (const task of authoritative)
-        counts.set(task.coordinate, (counts.get(task.coordinate) ?? 0) + 1);
-    const candidates = new Map();
-    for (const task of authoritative) {
-        const coordinate = task.coordinate;
-        if (counts.get(coordinate) > 1) {
-            sourceDiseases.push({
-                code: "duplicate_id",
-                path: task.source.path,
-                message: `duplicate authoritative task coordinate ${coordinate}`,
-                id: coordinate,
-            });
-        }
-        else {
-            candidates.set(coordinate, task);
-        }
-    }
-    const domainBoard = buildTaskBoardFromDocuments([...candidates.values()].map(taskDocument));
-    const graphDiseases = domainBoard.diseases.map((disease) => ({
-        ...disease,
-        path: disease.id === undefined ? "" : candidates.get(disease.id)?.source.path ?? "",
-    }));
-    const tasks = domainBoard.tasks.map((task) => ({
-        ...task,
-        path: candidates.get(task.coordinate).source.path,
-    }));
-    return {
-        tasks,
-        diseases: [...sourceDiseases, ...graphDiseases].sort(diseaseSort),
-        byId: new Map(tasks.map((task) => [task.coordinate, task])),
-    };
-}
-/** Compatibility name for source-backed board consumers. */
-export const buildTaskBoard = buildTaskSourceBoard;

package/build/core/task/source-model.js

@@ -1 +0,0 @@
-export {};

package/build/core/task/task-bind-preparation.js

@@ -1,243 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { readCommitCoordinate } from "../../git/commits.js";
-import { runGitProcess } from "../../git/core.js";
-import { assertGitObservation, requireGitRepository } from "../../git/branches.js";
-import { inspectCurrentBranch, createTaskBoardCommit, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskSourcesAtCommit, taskWritesFromSources, } from "./settlement-git.js";
-import { taskCoordinateFromSourcePath } from "./coordinate.js";
-import { advancedTaskUpdatedAt } from "./model.js";
-import { requireHealthySettlementBoard, selectReadyTasksForBind } from "./settlement-policy.js";
-import { buildTaskSourceBoard } from "./source-board.js";
-import { prepareTaskDocumentReplacements, taskBoardFromSourceBoard } from "./task-store-repository.js";
-import { withLockHeldTaskBoard, } from "./task-git-store.js";
-function linkedTaskDocument(task, contractId, at) {
-    return {
-        id: task.id,
-        namespace: task.namespace,
-        coordinate: task.coordinate,
-        title: task.title,
-        state: "open",
-        pri: task.pri,
-        needs: [...task.needs],
-        parent: task.parent,
-        from: [...task.from],
-        supersedes: [...task.supersedes],
-        relatesTo: [...task.relatesTo],
-        notes: task.notes.map((note) => ({ ...note })),
-        createdAt: task.createdAt,
-        updatedAt: advancedTaskUpdatedAt(task, at),
-        creator: task.creator,
-        contractId,
-        body: task.body,
-    };
-}
-function selectedEvidence(board, selected) {
-    return selected.map((task) => ({
-        taskId: task.coordinate,
-        needs: task.needs.map((taskId) => {
-            const need = board.byId.get(taskId);
-            if (!need)
-                throw new FlowError("INTERNAL_STATE", `selected task ${task.coordinate} has missing need ${taskId}`);
-            return { taskId, state: need.state, ...(need.contractId === undefined ? {} : { contractId: need.contractId }) };
-        }),
-    }));
-}
-async function prepareLockedTaskBind(transaction, input, deps) {
-    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 board = requireHealthySettlementBoard(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)));
-    const selected = selectReadyTasksForBind(board, input.taskIds);
-    if (selected.length === 0) {
-        throw new FlowError("INVALID_TARGET", "task bind requires at least one selected task");
-    }
-    const attempt = await input.prepare(selected);
-    const evidence = selectedEvidence(board, selected);
-    const linked = prepareTaskDocumentReplacements(transaction.sources, selected.map((task) => linkedTaskDocument(task, attempt.contractId, attempt.at)));
-    const linkedIds = new Set(selected.map((task) => task.coordinate));
-    const linkedSources = linked.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
-    const originalSources = transaction.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
-    if (linkedSources.length !== selected.length) {
-        throw new FlowError("INTERNAL_STATE", "task bind preparation did not resolve the exact selected task pathset");
-    }
-    if (originalSources.length !== selected.length) {
-        throw new FlowError("INTERNAL_STATE", "task bind preparation did not retain the exact original task pathset");
-    }
-    const branch = await inspectCurrentBranch(transaction.location.root);
-    const newHead = await (deps.createTaskBoardCommit ?? createTaskBoardCommit)({
-        cwd: transaction.location.root,
-        gitDir: transaction.location.gitDir,
-        root: transaction.location.root,
-        parent: branch.head,
-        sources: linkedSources,
-        subject: selected.length === 1
-            ? `Bind task ${selected[0].coordinate} to contract ${attempt.contractId}`
-            : `Bind ${selected.length} tasks to contract ${attempt.contractId}`,
-    });
-    const taskBoard = { ref: branch.ref, expectedHead: branch.head, head: newHead };
-    return {
-        boardRef: taskBoard.ref,
-        expectedHead: taskBoard.expectedHead,
-        newHead,
-        entryBase: newHead,
-        taskIds: selected.map((task) => task.coordinate),
-        selected: evidence,
-        taskBoard,
-        replay: {
-            paths: selected.map((task) => `.keiyaku/tasks/${task.coordinate}.md`).sort(),
-            linkedSources,
-            originalSources,
-        },
-    };
-}
-/** Hold the repository task lock across build and the caller-owned ref transaction. */
-export async function withPreparedTaskBind(input, deps = {}) {
-    await requireGitRepository(input.cwd, "task bind");
-    return await withLockHeldTaskBoard(input.cwd, async (transaction) => {
-        const preparation = await prepareLockedTaskBind(transaction, input, deps);
-        const result = await input.transact(preparation, transaction);
-        return { preparation, result };
-    }, { signal: input.signal });
-}
-/** Task-lock admission from bind's already-observed repository and board coordinates. */
-export async function withPreparedTaskBindSnapshot(input, deps = {}) {
-    return await withLockHeldTaskBoard(input.location.root, async (transaction) => {
-        const prepared = await prepareLockedTaskBindFromSnapshot(transaction, input, deps);
-        return { preparation: prepared, result: await input.transact(prepared, transaction) };
-    }, { signal: input.signal }, input.location);
-}
-async function prepareLockedTaskBindFromSnapshot(transaction, input, deps) {
-    if (transaction.location.mode !== "git")
-        throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
-    const observedBoard = await input.observeBoard();
-    const board = requireHealthySettlementBoard(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)));
-    const selected = selectReadyTasksForBind(board, input.taskIds);
-    if (selected.length === 0)
-        throw new FlowError("INVALID_TARGET", "task bind requires at least one selected task");
-    const attempt = await input.prepare(selected);
-    const evidence = selectedEvidence(board, selected);
-    const linked = prepareTaskDocumentReplacements(transaction.sources, selected.map((task) => linkedTaskDocument(task, attempt.contractId, attempt.at)));
-    const linkedIds = new Set(selected.map((task) => task.coordinate));
-    const linkedSources = linked.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
-    const originalSources = transaction.sources.filter((source) => linkedIds.has(taskCoordinateFromSourcePath(source.path).coordinate));
-    const newHead = await (deps.createTaskBoardCommit ?? createTaskBoardCommit)({
-        cwd: transaction.location.root,
-        gitDir: transaction.location.gitDir,
-        root: transaction.location.root,
-        parent: observedBoard.head,
-        sources: linkedSources,
-        subject: selected.length === 1
-            ? `Bind task ${selected[0].coordinate} to contract ${attempt.contractId}`
-            : `Bind ${selected.length} tasks to contract ${attempt.contractId}`,
-    });
-    return {
-        boardRef: observedBoard.ref,
-        expectedHead: observedBoard.head,
-        newHead,
-        entryBase: newHead,
-        taskIds: selected.map((task) => task.coordinate),
-        selected: evidence,
-        taskBoard: { ref: observedBoard.ref, expectedHead: observedBoard.head, head: newHead },
-        replay: {
-            paths: selected.map((task) => `.keiyaku/tasks/${task.coordinate}.md`).sort(),
-            linkedSources,
-            originalSources,
-        },
-    };
-}
-/** Complete the prepared task projection while its authority transaction still owns the task lock. */
-export async function replayPreparedTaskBindLocked(transaction, prepared) {
-    if (transaction.location.mode !== "git")
-        throw new FlowError("NOT_GIT_REPO", "task bind replay requires Git task storage");
-    const currentHead = await refHead(transaction.location.root, prepared.boardRef);
-    const sources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, currentHead, prepared.replay.paths);
-    if (!sources)
-        throw new FlowError("INTERNAL_STATE", "committed task bind paths are missing from board authority");
-    await transaction.replace(taskWritesFromSources(sources));
-    await reconcileTaskPathsetIndex(transaction.location.root, currentHead, prepared.replay.paths);
-}
-export async function replayPreparedTaskBind(cwd, prepared) {
-    await withLockHeldTaskBoard(cwd, async (transaction) => {
-        await replayPreparedTaskBindLocked(transaction, prepared);
-    });
-}
-async function projectionMatchesCommit(cwd, commit, paths) {
-    const cached = await runGitProcess(cwd, ["diff", "--quiet", "--cached", commit, "--", ...paths]);
-    if (cached.error || (cached.status !== 0 && cached.status !== 1))
-        return false;
-    if (cached.status !== 0)
-        return false;
-    const worktree = await runGitProcess(cwd, ["diff", "--quiet", "--", ...paths]);
-    return !worktree.error && worktree.status === 0;
-}
-/** Rebuild the selected task working-tree projection from the authoritative bind base. */
-export async function replayCommittedTaskBind(cwd, commit, taskIds) {
-    const paths = taskIds.map((taskId) => `.keiyaku/tasks/${taskId}.md`).sort();
-    if (await projectionMatchesCommit(cwd, commit, paths))
-        return "already-present";
-    return await withLockHeldTaskBoard(cwd, async (transaction) => {
-        if (transaction.location.mode !== "git")
-            throw new FlowError("NOT_GIT_REPO", "task bind replay requires Git task storage");
-        const sources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, commit, paths);
-        if (!sources)
-            throw new FlowError("INTERNAL_STATE", "committed task bind paths are missing from board authority");
-        const current = new Map(transaction.sources.map((source) => [source.path, source.text]));
-        const alreadyPresent = sources.every((source) => current.get(source.path) === source.text);
-        if (!alreadyPresent)
-            await transaction.replace(taskWritesFromSources(sources));
-        await reconcileTaskPathsetIndex(transaction.location.root, commit, paths);
-        return alreadyPresent ? "already-present" : "created";
-    });
-}
-/** Reopen task projections from the authoritative parent of a task-selected bind base. */
-export async function replayCommittedTaskBindForfeit(cwd, commit, boardRef, taskIds) {
-    return await withLockHeldTaskBoard(cwd, async (transaction) => {
-        if (transaction.location.mode !== "git")
-            throw new FlowError("NOT_GIT_REPO", "task forfeit replay requires Git task storage");
-        const coordinate = await readCommitCoordinate(transaction.location.root, commit);
-        if (coordinate.status !== "ok") {
-            throw new FlowError("INTERNAL_STATE", `committed task bind base ${commit} has no readable parent`, { cause: coordinate.status === "failed" ? coordinate.error : undefined });
-        }
-        const parent = coordinate.coordinate.parents[0];
-        if (!parent) {
-            throw new FlowError("INTERNAL_STATE", `committed task bind base ${commit} has no readable parent`);
-        }
-        const paths = taskIds.map((taskId) => `.keiyaku/tasks/${taskId}.md`).sort();
-        const originalSources = await taskSourcesAtCommit(transaction.location.root, transaction.location.root, parent, paths);
-        if (!originalSources)
-            throw new FlowError("INTERNAL_STATE", "committed task bind parent is missing selected task paths");
-        const current = new Map(transaction.sources.map((source) => [source.path, source.text]));
-        const alreadyPresent = originalSources.every((source) => current.get(source.path) === source.text);
-        if (alreadyPresent)
-            return "already-present";
-        await transaction.replace(taskWritesFromSources(originalSources));
-        await publishForwardTaskBoardCommit({
-            cwd: transaction.location.root,
-            ref: boardRef,
-            gitDir: transaction.location.gitDir,
-            root: transaction.location.root,
-            sources: originalSources,
-            paths,
-            subject: `Reopen ${taskIds.length === 1 ? `task ${taskIds[0]}` : `${taskIds.length} tasks`} after bind failure`,
-        }, {});
-        return "created";
-    });
-}
-export async function replayPreparedTaskBindForfeit(cwd, prepared) {
-    await withLockHeldTaskBoard(cwd, async (transaction) => {
-        if (transaction.location.mode !== "git")
-            throw new FlowError("NOT_GIT_REPO", "task forfeit replay requires Git task storage");
-        await transaction.replace(taskWritesFromSources(prepared.replay.originalSources));
-        await publishForwardTaskBoardCommit({
-            cwd: transaction.location.root,
-            ref: prepared.boardRef,
-            gitDir: transaction.location.gitDir,
-            root: transaction.location.root,
-            sources: prepared.replay.originalSources,
-            paths: prepared.replay.paths,
-            subject: `Reopen ${prepared.taskIds.length === 1 ? `task ${prepared.taskIds[0]}` : `${prepared.taskIds.length} tasks`} after bind failure`,
-        }, {});
-    });
-}