@astrosheep/keiyaku 2.9.2 → 2.9.4

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

@@ -1,19 +1,13 @@
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { FlowError } from "../../flow-error.js";
-import { parseTaskDocument } from "../task.js";
-function gitResult(cwd, args, input, env) {
-    return spawnSync("git", [...args], {
-        cwd,
-        input,
-        encoding: "utf8",
-        env: { ...process.env, ...env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
-        stdio: ["pipe", "pipe", "pipe"],
-    });
+import { runGitProcess } from "../../git/core.js";
+import { parseTaskDocument } from "./task.js";
+async function gitResult(cwd, args, input, env) {
+    return await runGitProcess(cwd, args, { input, env });
 }
-function git(cwd, args, input, env) {
-    const result = gitResult(cwd, args, input, env);
+async function git(cwd, args, input, env) {
+    const result = await gitResult(cwd, args, input, env);
     if (result.error) {
         throw new FlowError("INTERNAL_STATE", `git ${args[0]} failed: ${result.error.message}`, { cause: result.error });
     }
@@ -29,36 +23,118 @@ function boardPath(root, source) {
     }
     return relative;
 }
-export function inspectCurrentBranch(cwd) {
-    const branch = gitResult(cwd, ["symbolic-ref", "--quiet", "HEAD"]);
+export async function inspectCurrentBranch(cwd) {
+    const branch = await gitResult(cwd, ["symbolic-ref", "--quiet", "HEAD"]);
     if (branch.error) {
         throw new FlowError("INTERNAL_STATE", `cannot inspect HEAD: ${branch.error.message}`, { cause: branch.error });
     }
     if (branch.status !== 0 || branch.stdout.trim() === "") {
         throw new FlowError("DETACHED_HEAD", "cannot publish task board from detached HEAD");
     }
-    return { ref: branch.stdout.trim(), head: git(cwd, ["rev-parse", "HEAD"]).trim() };
+    return { ref: branch.stdout.trim(), head: (await git(cwd, ["rev-parse", "HEAD"])).trim() };
 }
-export function createTaskBoardCommit(input) {
+export async function createTaskBoardCommit(input) {
     const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-task-index-"));
     const indexPath = path.join(temporaryDirectory, "index");
     const env = { GIT_INDEX_FILE: indexPath };
     try {
-        git(input.cwd, ["read-tree", input.parent], undefined, env);
-        git(input.cwd, ["rm", "-r", "--cached", "-f", "--ignore-unmatch", "--", ".keiyaku/tasks"], undefined, env);
+        await git(input.cwd, ["read-tree", input.parent], undefined, env);
         for (const source of input.sources) {
-            const oid = git(input.cwd, ["hash-object", "-w", "--stdin"], source.text).trim();
-            git(input.cwd, ["update-index", "--add", "--cacheinfo", `100644,${oid},${boardPath(input.root, source)}`], undefined, env);
+            const oid = (await git(input.cwd, ["hash-object", "-w", "--stdin"], source.text)).trim();
+            await git(input.cwd, ["update-index", "--add", "--cacheinfo", `100644,${oid},${boardPath(input.root, source)}`], undefined, env);
+        }
+        const tree = (await git(input.cwd, ["write-tree"], undefined, env)).trim();
+        return (await git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject])).trim();
+    }
+    finally {
+        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+function taskMutationPath(write) {
+    return `.keiyaku/tasks/${write.id}.md`;
+}
+/** Build a commit that updates only the listed task paths on top of parent. */
+export async function createTaskMutationCommit(input) {
+    if (input.writes.length === 0) {
+        throw new FlowError("INTERNAL_STATE", "task mutation commit requires at least one write");
+    }
+    const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-task-index-"));
+    const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
+    try {
+        await git(input.cwd, ["read-tree", input.parent], undefined, env);
+        for (const write of input.writes) {
+            const oid = (await git(input.cwd, ["hash-object", "-w", "--stdin"], write.text)).trim();
+            await git(input.cwd, [
+                "update-index",
+                "--add",
+                "--cacheinfo",
+                `100644,${oid},${taskMutationPath(write)}`,
+            ], undefined, env);
         }
-        const tree = git(input.cwd, ["write-tree"], undefined, env).trim();
-        return git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject]).trim();
+        const tree = (await git(input.cwd, ["write-tree"], undefined, env)).trim();
+        const parentTree = (await git(input.cwd, ["rev-parse", `${input.parent}^{tree}`])).trim();
+        if (tree === parentTree)
+            return input.parent;
+        return (await git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject])).trim();
     }
     finally {
         fs.rmSync(temporaryDirectory, { recursive: true, force: true });
     }
 }
-function taskTreeEntries(cwd, commit) {
-    return git(cwd, ["ls-tree", "-r", "-z", commit, "--", ".keiyaku/tasks"])
+/** Stage only the mutated task paths into the real index; leave unrelated entries alone. */
+export async function reconcileTaskMutationIndex(cwd, writes) {
+    for (const write of writes) {
+        const oid = (await git(cwd, ["hash-object", "-w", "--stdin"], write.text)).trim();
+        await git(cwd, [
+            "update-index",
+            "--add",
+            "--cacheinfo",
+            `100644,${oid},${taskMutationPath(write)}`,
+        ]);
+    }
+}
+/**
+ * Atomically publish a pathspec-scoped task micro-commit under the hub branch.
+ * Unrelated staged and unstaged non-task bytes are never read into the commit.
+ */
+export async function publishTaskMutationCommit(input, deps = {}) {
+    let lastError;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const branch = await inspectCurrentBranch(input.cwd);
+        const commit = await createTaskMutationCommit({
+            cwd: input.cwd,
+            gitDir: input.gitDir,
+            parent: branch.head,
+            writes: input.writes,
+            subject: input.subject,
+        });
+        if (commit === branch.head) {
+            await reconcileTaskMutationIndex(input.cwd, input.writes);
+            return commit;
+        }
+        try {
+            await updateBranch({
+                cwd: input.cwd,
+                ref: branch.ref,
+                next: commit,
+                expected: branch.head,
+            }, deps);
+            try {
+                await reconcileTaskMutationIndex(input.cwd, input.writes);
+            }
+            catch {
+                // Branch fact remains authoritative; index may be repaired by a later mutation.
+            }
+            return commit;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
+async function taskTreeEntries(cwd, commit) {
+    return (await git(cwd, ["ls-tree", "-r", "-z", commit, "--", ".keiyaku/tasks"]))
         .split("\0")
         .filter(Boolean)
         .map((record) => {
@@ -70,28 +146,35 @@ function taskTreeEntries(cwd, commit) {
         return { mode, oid, path: record.slice(tab + 1) };
     });
 }
-export function reconcileTaskIndex(cwd, commit) {
-    const existing = git(cwd, ["ls-files", "-z", "--", ".keiyaku/tasks"])
-        .split("\0")
-        .filter(Boolean);
-    for (const file of existing)
-        git(cwd, ["update-index", "--force-remove", "--", file]);
-    for (const entry of taskTreeEntries(cwd, commit)) {
-        git(cwd, ["update-index", "--add", "--cacheinfo", `${entry.mode},${entry.oid},${entry.path}`]);
+/** Reconcile only settlement-owned task paths; never rewrite an unrelated index entry. */
+export async function reconcileTaskPathsetIndex(cwd, commit, paths) {
+    const entries = new Map((await taskTreeEntries(cwd, commit)).map((entry) => [entry.path, entry]));
+    for (const taskPath of paths) {
+        const entry = entries.get(taskPath);
+        if (entry) {
+            await git(cwd, ["update-index", "--add", "--cacheinfo", `${entry.mode},${entry.oid},${entry.path}`]);
+        }
+        else {
+            await git(cwd, ["update-index", "--force-remove", "--", taskPath]);
+        }
     }
 }
-export function refHead(cwd, ref) {
-    return git(cwd, ["rev-parse", ref]).trim();
+/** Task paths tracked by one authoritative commit, independent of the worktree index. */
+export async function trackedTaskPaths(cwd, commit) {
+    return (await taskTreeEntries(cwd, commit)).map((entry) => entry.path).sort();
+}
+export async function refHead(cwd, ref) {
+    return (await git(cwd, ["rev-parse", ref])).trim();
 }
-export function readableRefHead(cwd, ref) {
-    const result = gitResult(cwd, ["rev-parse", ref]);
+export async function readableRefHead(cwd, ref) {
+    const result = await gitResult(cwd, ["rev-parse", ref]);
     if (result.status !== 0)
         return undefined;
     return result.stdout.trim();
 }
-export function taskContractAtCommit(cwd, commit, id) {
+export async function taskContractAtCommit(cwd, commit, id) {
     const sourcePath = `.keiyaku/tasks/${id}.md`;
-    const result = gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
+    const result = await gitResult(cwd, ["show", `${commit}:${sourcePath}`]);
     if (result.status !== 0)
         return undefined;
     return parseTaskDocument({ path: sourcePath, text: result.stdout }).contractId;
@@ -100,17 +183,17 @@ export async function updateBranch(input, deps) {
     if (deps.updateBranch)
         await deps.updateBranch(input);
     else
-        git(input.cwd, ["update-ref", input.ref, input.next, input.expected]);
+        await git(input.cwd, ["update-ref", input.ref, input.next, input.expected]);
 }
 export async function publishForwardTaskBoardCommit(input, deps) {
     let lastError;
     for (let attempt = 0; attempt < 4; attempt += 1) {
-        const parent = refHead(input.cwd, input.ref);
-        const commit = createTaskBoardCommit({ ...input, parent });
+        const parent = await refHead(input.cwd, input.ref);
+        const commit = await createTaskBoardCommit({ ...input, parent });
         try {
             await updateBranch({ cwd: input.cwd, ref: input.ref, next: commit, expected: parent }, deps);
             try {
-                reconcileTaskIndex(input.cwd, commit);
+                await reconcileTaskPathsetIndex(input.cwd, commit, input.paths);
             }
             catch { /* the forward branch fact remains authoritative */ }
             return commit;
@@ -121,32 +204,32 @@ export async function publishForwardTaskBoardCommit(input, deps) {
     }
     throw lastError;
 }
-function treeWithoutTasks(cwd, commit, gitDir) {
+async function treeWithoutTasks(cwd, commit, gitDir) {
     const temporaryDirectory = fs.mkdtempSync(path.join(gitDir, "keiyaku-landing-index-"));
     const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
     try {
-        git(cwd, ["read-tree", commit], undefined, env);
-        git(cwd, ["rm", "-r", "--cached", "-f", "--ignore-unmatch", "--", ".keiyaku/tasks"], undefined, env);
-        return git(cwd, ["write-tree"], undefined, env).trim();
+        await git(cwd, ["read-tree", commit], undefined, env);
+        await git(cwd, ["rm", "-r", "--cached", "-f", "--ignore-unmatch", "--", ".keiyaku/tasks"], undefined, env);
+        return (await git(cwd, ["write-tree"], undefined, env)).trim();
     }
     finally {
         fs.rmSync(temporaryDirectory, { recursive: true, force: true });
     }
 }
-function composeLandingTree(input) {
-    const baseTree = treeWithoutTasks(input.cwd, input.base, input.gitDir);
-    const targetTree = treeWithoutTasks(input.cwd, input.target, input.gitDir);
-    const deliveryTree = treeWithoutTasks(input.cwd, input.delivery, input.gitDir);
+async function composeLandingTree(input) {
+    const baseTree = await treeWithoutTasks(input.cwd, input.base, input.gitDir);
+    const targetTree = await treeWithoutTasks(input.cwd, input.target, input.gitDir);
+    const deliveryTree = await treeWithoutTasks(input.cwd, input.delivery, input.gitDir);
     let mergedTree;
     try {
-        mergedTree = git(input.cwd, [
+        mergedTree = (await git(input.cwd, [
             "merge-tree",
             "--write-tree",
             "--merge-base",
             baseTree,
             targetTree,
             deliveryTree,
-        ]).trim();
+        ])).trim();
     }
     catch (error) {
         throw new FlowError("CLOSE_MERGE_CONFLICT", "claim merge conflict outside task board", { cause: error });
@@ -154,26 +237,35 @@ function composeLandingTree(input) {
     const temporaryDirectory = fs.mkdtempSync(path.join(input.gitDir, "keiyaku-landing-index-"));
     const env = { GIT_INDEX_FILE: path.join(temporaryDirectory, "index") };
     try {
-        git(input.cwd, ["read-tree", mergedTree], undefined, env);
-        git(input.cwd, ["rm", "-r", "--cached", "-f", "--ignore-unmatch", "--", ".keiyaku/tasks"], undefined, env);
+        await git(input.cwd, ["read-tree", mergedTree], undefined, env);
+        // merge-tree deliberately excluded task paths. Restore the target board as
+        // the inherited baseline, then overlay only settlement-authorized writes.
+        for (const entry of await taskTreeEntries(input.cwd, input.target)) {
+            await git(input.cwd, [
+                "update-index",
+                "--add",
+                "--cacheinfo",
+                `${entry.mode},${entry.oid},${entry.path}`,
+            ], undefined, env);
+        }
         for (const source of input.sources) {
-            const oid = git(input.cwd, ["hash-object", "-w", "--stdin"], source.text).trim();
-            git(input.cwd, [
+            const oid = (await git(input.cwd, ["hash-object", "-w", "--stdin"], source.text)).trim();
+            await git(input.cwd, [
                 "update-index",
                 "--add",
                 "--cacheinfo",
                 `100644,${oid},${boardPath(input.root, source)}`,
             ], undefined, env);
         }
-        return git(input.cwd, ["write-tree"], undefined, env).trim();
+        return (await git(input.cwd, ["write-tree"], undefined, env)).trim();
     }
     finally {
         fs.rmSync(temporaryDirectory, { recursive: true, force: true });
     }
 }
-export function createLandingCommit(input) {
-    const tree = composeLandingTree(input);
-    return git(input.cwd, [
+export async function createLandingCommit(input) {
+    const tree = await composeLandingTree(input);
+    return (await git(input.cwd, [
         "commit-tree",
         tree,
         "-p",
@@ -184,13 +276,13 @@ export function createLandingCommit(input) {
         `keiyaku: claim ${input.contractId}`,
         "-m",
         `Merge contract ${input.contractId} into ${input.targetBranch}.`,
-    ]).trim();
+    ])).trim();
 }
-export function containsCommit(cwd, ancestor, descendant) {
-    return gitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+export async function containsCommit(cwd, ancestor, descendant) {
+    return (await gitResult(cwd, ["merge-base", "--is-ancestor", ancestor, descendant])).status === 0;
 }
-export function updateTargetRef(cwd, ref, next, expected) {
-    git(cwd, ["update-ref", ref, next, expected]);
+export async function updateTargetRef(cwd, ref, next, expected) {
+    await git(cwd, ["update-ref", ref, next, expected]);
 }
 export function sameTaskSourceBytes(root, left, right) {
     const snapshot = (sources) => new Map(sources.map((source) => [boardPath(root, source), source.text]));

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

@@ -31,15 +31,12 @@ export function reopenedTaskDocument(task) {
     delete document.startedAt;
     return document;
 }
-export function selectReadyTaskForBind(board, taskId) {
-    requireHealthySettlementBoard(board);
-    const id = resolveTaskReadId(board, taskId);
-    const task = board.byId.get(id);
+function validateReadyForBind(board, task) {
     if (task.state === "in_progress") {
-        throw new FlowError("INVALID_TARGET", `task ${id} is in_progress; stop it before bind`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is in_progress; stop it before bind`);
     }
     if (task.state !== "open") {
-        throw new FlowError("INVALID_TARGET", `task ${id} is ${task.state}, not ready for bind`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is ${task.state}, not ready for bind`);
     }
     const unsatisfied = task.needs
         .filter((need) => {
@@ -48,22 +45,64 @@ export function selectReadyTaskForBind(board, taskId) {
     })
         .sort();
     if (unsatisfied.length > 0) {
-        throw new FlowError("INVALID_TARGET", `task ${id} is blocked by: ${unsatisfied.join(", ")}`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is blocked by: ${unsatisfied.join(", ")}`);
     }
     if (task.contractId !== undefined) {
-        throw new FlowError("INVALID_TARGET", `task ${id} is already bound to contract ${task.contractId}`);
+        throw new FlowError("INVALID_TARGET", `task ${task.id} is already bound to contract ${task.contractId}`);
     }
-    return task;
 }
-export function taskForContract(board, contractId) {
+export function selectReadyTasksForBind(board, taskIds) {
     requireHealthySettlementBoard(board);
-    const matches = board.tasks
+    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.id)) {
+            admitted.add(root.id);
+            tasks.push(root);
+        }
+        for (const candidate of board.tasks) {
+            if (candidate.parent === null || admitted.has(candidate.id))
+                continue;
+            if (candidate.state === "done" || candidate.state === "drop")
+                continue;
+            if (isDescendantOf(board, candidate, rootId)) {
+                admitted.add(candidate.id);
+                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.id.localeCompare(right.id));
-    if (matches.length > 1) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is referenced by multiple tasks: ${matches.map((task) => task.id).join(", ")}`);
-    }
-    return matches[0];
+}
+export function doneTaskReplacements(board, contractId) {
+    return tasksForContract(board, contractId).map((task) => {
+        const settled = settlementDocument(task, undefined);
+        settled.state = "done";
+        delete settled.startedAt;
+        return settled;
+    });
 }
 export function requireSettledTask(board, id) {
     const task = requireHealthySettlementBoard(board).byId.get(id);
@@ -71,12 +110,3 @@ export function requireSettledTask(board, id) {
         throw new FlowError("INTERNAL_STATE", `task ${id} disappeared from the board`);
     return task;
 }
-export function doneTaskReplacement(board, contractId) {
-    const bound = taskForContract(board, contractId);
-    if (!bound)
-        return undefined;
-    const settled = settlementDocument(bound, undefined);
-    settled.state = "done";
-    delete settled.startedAt;
-    return settled;
-}