@astrosheep/keiyaku 2.8.5 → 2.9.1

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

@@ -0,0 +1,385 @@
+import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { FlowError } from "../flow-error.js";
+import { isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS } from "../git/core.js";
+import { gitCommonRootPath, normalizeGitPath } from "./path-coordinate.js";
+const TASK_ID = /^k-[0-9a-f]{12}$/;
+const SQLITE_BUSY = 5;
+const LOCK_FILE = "task-lock.sqlite";
+const GIT_LOCK_FILE = "keiyaku-task-lock.sqlite";
+export class TaskLockHeldError extends Error {
+    path;
+    code = "TASK_LOCK_HELD";
+    constructor(path, options) {
+        super(`task lock is already held: ${path}`, options);
+        this.path = path;
+        this.name = "TaskLockHeldError";
+    }
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isSqliteBusy(error) {
+    return typeof error === "object"
+        && error !== null
+        && "errcode" in error
+        && error.errcode === SQLITE_BUSY;
+}
+function defaultRunGit(cwd, args, input) {
+    return spawnSync("git", [...args], {
+        cwd,
+        input,
+        encoding: "utf8",
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+function nearestDirectoryBoard(cwd) {
+    const original = path.resolve(cwd);
+    let candidate = original;
+    while (true) {
+        if (lstatIfPresent(path.join(candidate, ".keiyaku")))
+            return candidate;
+        const parent = path.dirname(candidate);
+        if (parent === candidate)
+            return original;
+        candidate = parent;
+    }
+}
+export function taskBoardRootFromGitDir(rawGitDir, platform = process.platform) {
+    return gitCommonRootPath(rawGitDir, platform);
+}
+export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
+    const probe = runGitProbe(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
+    if (probe.error && !isGitExecutableUnavailable(probe.error)) {
+        throw new FlowError("INTERNAL_STATE", `cannot inspect task repository: ${probe.error.message}`, { cause: probe.error });
+    }
+    if (probe.error) {
+        return { mode: "directory", root: nearestDirectoryBoard(cwd), capability: "unavailable" };
+    }
+    if (probe.status !== 0) {
+        if (NOT_GIT_REPOSITORY_PATTERNS.some((pattern) => probe.stderr.includes(pattern))) {
+            return { mode: "directory", root: nearestDirectoryBoard(cwd) };
+        }
+        const detail = probe.stderr.trim() || `exit ${String(probe.status)}`;
+        throw new FlowError("INTERNAL_STATE", `cannot inspect task repository: ${detail}`);
+    }
+    const [insideWorktree, bare] = probe.stdout.trim().split(/\r?\n/);
+    if (bare === "true" || insideWorktree !== "true") {
+        throw new FlowError("NOT_GIT_REPO", "bare repositories are not supported for task storage");
+    }
+    const facts = runGitProbe(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
+    if (facts.error) {
+        throw new FlowError("INTERNAL_STATE", `git rev-parse failed: ${facts.error.message}`, { cause: facts.error });
+    }
+    if (facts.status !== 0) {
+        const detail = facts.stderr.trim() || `exit ${String(facts.status)}`;
+        throw new FlowError("INTERNAL_STATE", `git rev-parse failed: ${detail}`);
+    }
+    const [checkoutRoot, rawGitDir] = facts.stdout.trimEnd().split(/\r?\n/);
+    const gitDir = rawGitDir === undefined ? undefined : normalizeGitPath(rawGitDir);
+    const normalizedCheckoutRoot = checkoutRoot === undefined ? undefined : normalizeGitPath(checkoutRoot);
+    if (!normalizedCheckoutRoot || !gitDir || !path.isAbsolute(normalizedCheckoutRoot) || !path.isAbsolute(gitDir)) {
+        throw new FlowError("INTERNAL_STATE", "git returned incomplete task-board location facts");
+    }
+    return {
+        mode: "git",
+        root: taskBoardRootFromGitDir(gitDir),
+        gitDir,
+    };
+}
+function taskDirectory(board) {
+    return path.join(board.root, ".keiyaku", "tasks");
+}
+function assertKeiyakuDirectory(board) {
+    const keiyakuDirectory = path.join(board.root, ".keiyaku");
+    const stat = lstatIfPresent(keiyakuDirectory);
+    if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {
+        throw new FlowError("INTERNAL_STATE", `.keiyaku is not a regular directory: ${keiyakuDirectory}`);
+    }
+}
+function taskLockPath(board) {
+    return board.mode === "git"
+        ? path.join(board.gitDir, GIT_LOCK_FILE)
+        : path.join(board.root, ".keiyaku", LOCK_FILE);
+}
+function closeQuietly(database) {
+    try {
+        database.close();
+    }
+    catch {
+        // The original operation remains authoritative.
+    }
+}
+function acquireTaskLock(lockPath) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    let database;
+    try {
+        database = new DatabaseSync(lockPath);
+    }
+    catch (error) {
+        throw new FlowError("INTERNAL_STATE", `cannot open task lock: ${errorText(error)}`, { cause: error });
+    }
+    try {
+        database.exec("PRAGMA busy_timeout=0");
+        database.exec("PRAGMA journal_mode=DELETE");
+        database.exec("CREATE TABLE IF NOT EXISTS lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
+        database.exec("BEGIN EXCLUSIVE");
+        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
+        return database;
+    }
+    catch (error) {
+        closeQuietly(database);
+        if (isSqliteBusy(error))
+            throw new TaskLockHeldError(lockPath, { cause: error });
+        throw new FlowError("INTERNAL_STATE", `cannot acquire task lock: ${errorText(error)}`, { cause: error });
+    }
+}
+export async function inspectTaskLock(cwd) {
+    const lockPath = taskLockPath(await locateTaskBoard(cwd));
+    if (!fs.existsSync(lockPath))
+        return { state: "free", path: lockPath };
+    let database;
+    try {
+        database = new DatabaseSync(lockPath, { readOnly: true });
+    }
+    catch (error) {
+        throw new FlowError("INTERNAL_STATE", `cannot inspect task lock: ${errorText(error)}`, { cause: error });
+    }
+    try {
+        database.exec("PRAGMA busy_timeout=0");
+        database.exec("BEGIN DEFERRED");
+        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
+        database.exec("ROLLBACK");
+        return { state: "free", path: lockPath };
+    }
+    catch (error) {
+        if (isSqliteBusy(error))
+            return { state: "held", path: lockPath };
+        throw new FlowError("INTERNAL_STATE", `cannot inspect task lock: ${errorText(error)}`, { cause: error });
+    }
+    finally {
+        closeQuietly(database);
+    }
+}
+export function atomicReplaceTaskFile(filePath, text, _deps) {
+    const directory = path.dirname(filePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporary = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomBytes(12).toString("hex")}.tmp`);
+    let descriptor;
+    try {
+        descriptor = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
+        fs.writeFileSync(descriptor, text, { encoding: "utf8" });
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        fs.renameSync(temporary, filePath);
+        fsyncDirectory(directory);
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                fs.closeSync(descriptor);
+            }
+            catch { /* preserve original failure */ }
+        }
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* absent after rename or already cleaned */ }
+        throw error;
+    }
+}
+function fsyncDirectory(directory) {
+    const descriptor = fs.openSync(directory, fs.constants.O_RDONLY);
+    try {
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function lstatIfPresent(target) {
+    try {
+        return fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function readTaskSources(directory) {
+    const directoryStat = lstatIfPresent(directory);
+    if (!directoryStat)
+        return [];
+    if (directoryStat.isSymbolicLink() || !directoryStat.isDirectory()) {
+        throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
+    }
+    const names = fs.readdirSync(directory)
+        .filter((name) => name.endsWith(".md"))
+        .sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
+    return names.map((name) => {
+        const sourcePath = path.join(directory, name);
+        const sourceStat = fs.lstatSync(sourcePath);
+        if (sourceStat.isSymbolicLink() || !sourceStat.isFile()) {
+            throw new FlowError("INTERNAL_STATE", `task source is not a regular file: ${sourcePath}`);
+        }
+        return {
+            path: sourcePath,
+            text: fs.readFileSync(sourcePath, "utf8"),
+        };
+    });
+}
+function validatePlan(plan) {
+    validateWrites(plan.writes);
+}
+function validateWrites(writes) {
+    if (writes.length === 0) {
+        throw new FlowError("INTERNAL_STATE", "task mutation must contain at least one write");
+    }
+    const targets = new Set();
+    for (const write of writes) {
+        const target = `${write.id}.md`;
+        if (!TASK_ID.test(write.id)) {
+            throw new FlowError("INTERNAL_STATE", `invalid task mutation id: ${write.id}`);
+        }
+        if (targets.has(target))
+            throw new FlowError("INTERNAL_STATE", `duplicate task mutation target: ${target}`);
+        targets.add(target);
+    }
+}
+function mutationTarget(write) {
+    return `${write.id}.md`;
+}
+function capturePreviousFiles(directory, writes) {
+    return writes.map((write) => {
+        const destination = path.join(directory, mutationTarget(write));
+        const stat = lstatIfPresent(destination);
+        if (!stat)
+            return { path: destination };
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new FlowError("INTERNAL_STATE", `task destination is not a regular file: ${destination}`);
+        }
+        return { path: destination, text: fs.readFileSync(destination, "utf8") };
+    });
+}
+function sameSources(left, right) {
+    return left.length === right.length && left.every((source, index) => {
+        const candidate = right[index];
+        return candidate !== undefined && source.path === candidate.path && source.text === candidate.text;
+    });
+}
+function removeTaskFile(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+        fsyncDirectory(path.dirname(filePath));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function restoreFiles(previous, deps) {
+    for (const entry of previous) {
+        if (entry.text === undefined)
+            removeTaskFile(entry.path);
+        else
+            (deps.atomicReplace ?? atomicReplaceTaskFile)(entry.path, entry.text);
+    }
+}
+function writeTaskFile(directory, write, deps) {
+    const destination = path.join(directory, mutationTarget(write));
+    (deps.atomicReplace ?? atomicReplaceTaskFile)(destination, write.text);
+}
+function releaseTaskLock(database, deps) {
+    try {
+        if (deps.releaseLock)
+            deps.releaseLock();
+        else
+            database.exec("COMMIT");
+    }
+    catch {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch { /* close releases the advisory lock */ }
+    }
+    finally {
+        closeQuietly(database);
+    }
+}
+function assertTaskDirectorySafety(directory) {
+    const stat = lstatIfPresent(directory);
+    if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {
+        throw new FlowError("INTERNAL_STATE", `task directory is not a regular directory: ${directory}`);
+    }
+}
+export async function openTaskStore(cwd, deps = {}) {
+    const board = await locateTaskBoard(cwd, deps.runGit);
+    const directory = taskDirectory(board);
+    return {
+        mode: board.mode,
+        read: async () => {
+            assertKeiyakuDirectory(board);
+            return readTaskSources(directory);
+        },
+        async mutate(apply) {
+            return withLockHeldTaskBoard(cwd, async (transaction) => {
+                const plan = await apply(transaction.sources);
+                validatePlan(plan);
+                await transaction.replace(plan.writes);
+                return plan.value;
+            }, deps, board);
+        },
+    };
+}
+export async function withLockHeldTaskBoard(cwd, apply, deps = {}, locatedBoard) {
+    const board = locatedBoard ?? await locateTaskBoard(cwd, deps.runGit);
+    const directory = taskDirectory(board);
+    assertKeiyakuDirectory(board);
+    const database = acquireTaskLock(taskLockPath(board));
+    try {
+        let sources = await readTaskSources(directory);
+        const transaction = {
+            location: board,
+            get sources() {
+                return sources;
+            },
+            async replace(writes) {
+                validateWrites(writes);
+                assertKeiyakuDirectory(board);
+                assertTaskDirectorySafety(directory);
+                const currentSources = await readTaskSources(directory);
+                if (!sameSources(sources, currentSources)) {
+                    throw new FlowError("CONCURRENT_MODIFICATION", "task sources changed while applying the mutation");
+                }
+                assertKeiyakuDirectory(board);
+                assertTaskDirectorySafety(directory);
+                const previous = capturePreviousFiles(directory, writes);
+                let applied = 0;
+                try {
+                    for (const write of writes) {
+                        writeTaskFile(directory, write, deps);
+                        applied += 1;
+                    }
+                }
+                catch (error) {
+                    try {
+                        restoreFiles(previous.slice(0, applied + 1), deps);
+                    }
+                    catch { /* the original replacement failure remains authoritative */ }
+                    throw error;
+                }
+                sources = await readTaskSources(directory);
+            },
+        };
+        return await apply(transaction);
+    }
+    finally {
+        releaseTaskLock(database, deps);
+    }
+}

package/build/core/task-repository.js

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

package/build/core/task-store-repository.js

@@ -0,0 +1,86 @@
+import { requireHealthy } from "./task/board.js";
+import { parseTaskDocument, serializeTaskDocument } from "./task/document.js";
+import { buildTaskSourceBoard } from "./task/source-board.js";
+function taskBoardFromSourceBoard(sourceBoard) {
+    const tasks = sourceBoard.tasks.map((task) => ({
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        pri: task.pri,
+        needs: [...task.needs],
+        parent: task.parent,
+        from: [...task.from],
+        createdAt: task.createdAt,
+        creator: task.creator,
+        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
+        body: task.body,
+        blocks: [...task.blocks],
+        blocked: task.blocked,
+        releasedNeeds: [...task.releasedNeeds],
+    }));
+    return {
+        tasks,
+        diseases: sourceBoard.diseases.map((disease) => ({
+            code: disease.code,
+            message: disease.message,
+            ...(disease.id === undefined ? {} : { id: disease.id }),
+            ...(disease.relatedIds === undefined ? {} : { relatedIds: [...disease.relatedIds] }),
+        })),
+        byId: new Map(tasks.map((task) => [task.id, task])),
+    };
+}
+export function prepareTaskDocumentReplacements(sources, replacements) {
+    const serialized = replacements.map((document) => ({
+        id: document.id,
+        text: serializeTaskDocument(document),
+    }));
+    const replacementIds = new Set(serialized.map((replacement) => replacement.id));
+    const paths = new Map();
+    const retained = sources.filter((source) => {
+        try {
+            const id = parseTaskDocument(source).id;
+            paths.set(id, source.path);
+            return !replacementIds.has(id);
+        }
+        catch {
+            // Malformed sources remain quarantined and visible to the resulting board.
+            return true;
+        }
+    });
+    const replacementSources = serialized.map((replacement) => ({
+        path: paths.get(replacement.id) ?? `${replacement.id}.md`,
+        text: replacement.text,
+    }));
+    const resultingSources = [...retained, ...replacementSources];
+    const board = taskBoardFromSourceBoard(buildTaskSourceBoard(resultingSources));
+    requireHealthy(board);
+    return {
+        sources: resultingSources,
+        writes: serialized,
+        board,
+    };
+}
+function mutationPlan(sources, mutation) {
+    const prepared = prepareTaskDocumentReplacements(sources, mutation.replacements);
+    return {
+        writes: prepared.writes,
+        value: mutation.select(prepared.board),
+    };
+}
+export function taskRepositoryFromStore(store) {
+    return {
+        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(await store.read())),
+        mutate: async (apply) => store.mutate(async (sources) => mutationPlan(sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(sources))))),
+    };
+}
+export function taskRepositoryFromLockedBoard(transaction) {
+    return {
+        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)),
+        mutate: async (apply) => {
+            const plan = mutationPlan(transaction.sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources))));
+            await transaction.replace(plan.writes);
+            return plan.value;
+        },
+    };
+}

package/build/core/task-store.js

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

package/build/core/task-worktree.js

@@ -0,0 +1,51 @@
+import { FlowError } from "../flow-error.js";
+function documentFacts(task) {
+    return JSON.stringify({
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        pri: task.pri,
+        needs: [...task.needs],
+        parent: task.parent,
+        from: [...task.from],
+        createdAt: task.createdAt,
+        creator: task.creator,
+        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
+        body: task.body,
+    });
+}
+function isNeedsAppend(prior, next) {
+    return next.needs.length > prior.needs.length
+        && prior.needs.every((need, index) => next.needs[index] === need)
+        && new Set(next.needs).size === next.needs.length
+        && documentFacts(prior) === documentFacts({ ...next, needs: prior.needs });
+}
+export function validateTaskWorktreeMutation(before, replacements, after, contractId) {
+    const existing = new Map(before.tasks.map((task) => [task.id, task]));
+    const bound = before.tasks.filter((task) => task.contractId === contractId);
+    for (const replacement of replacements) {
+        const prior = existing.get(replacement.id);
+        if (!prior)
+            continue;
+        const next = after.byId.get(replacement.id);
+        if (bound.length === 1 && prior.id === bound[0].id && next && isNeedsAppend(prior, next))
+            continue;
+        throw new FlowError("UNSUPPORTED_POLICY", `task ${replacement.id} is not yours; this checkout is bound to contract ${contractId}`);
+    }
+}
+export function withTaskWorktreePolicy(repository, contractId) {
+    return {
+        read: repository.read.bind(repository),
+        mutate: async (apply) => repository.mutate(async (before) => {
+            const mutation = await apply(before);
+            return {
+                replacements: mutation.replacements,
+                select(after) {
+                    validateTaskWorktreeMutation(before, mutation.replacements, after, contractId);
+                    return mutation.select(after);
+                },
+            };
+        }),
+    };
+}

package/build/core/task.js

@@ -0,0 +1,4 @@
+export { parseTaskDocument, serializeTaskDocument, } from "./task/document.js";
+export { resolveTaskReadId, } from "./task/board.js";
+export { buildTaskBoard } from "./task/source-board.js";
+export { readTaskBoard, createTask, updateTask, startTask, stopTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./task/commands.js";