@zq-silk/yui 0.2.0 → 0.4.2

package/dist/workspace/gitChangeSetCapture.js

@@ -0,0 +1,86 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const executeFile = promisify(execFile);
+export async function captureManagedGitChanges(input) {
+    await assertManagedHead(input);
+    const status = await git([
+        "-C", input.path, "status", "--porcelain=v1", "--untracked-files=all"
+    ]);
+    if (status.trim().length > 0) {
+        if (input.requireClean === true) {
+            throw new Error(`Managed workspace must be clean before capture: ${input.identity}.`);
+        }
+        await git(["-C", input.path, "add", "--all"]);
+        await git([
+            "-C", input.path,
+            "-c", "user.name=Yui",
+            "-c", "user.email=yui@local",
+            "commit", "-m", input.commitMessage
+        ]);
+    }
+    const headCommit = await assertManagedHead(input);
+    if (headCommit === input.baseCommit)
+        return null;
+    const changedPaths = (await git([
+        "-C", input.path,
+        "diff", "--name-only", "-z",
+        input.baseCommit,
+        headCommit
+    ])).split("\0").filter(Boolean);
+    return { headCommit, changedPaths };
+}
+async function assertManagedHead(input) {
+    const currentBranch = (await git([
+        "-C", input.path, "symbolic-ref", "--quiet", "--short", "HEAD"
+    ])).trim();
+    if (currentBranch !== input.branch) {
+        throw new Error(`Managed workspace left its managed branch: expected ${input.branch}, found ${currentBranch} (${input.identity}).`);
+    }
+    const headCommit = await gitLine(["-C", input.path, "rev-parse", "HEAD^{commit}"]);
+    if (input.expectedHead !== undefined && headCommit !== input.expectedHead) {
+        throw new Error(`Managed workspace HEAD no longer matches its Candidate snapshot: ${input.identity}.`);
+    }
+    if (!await gitSucceeds([
+        "-C", input.path,
+        "merge-base", "--is-ancestor",
+        input.baseCommit,
+        headCommit
+    ])) {
+        throw new Error(`Managed workspace HEAD does not descend from its recorded base: ${input.identity}.`);
+    }
+    return headCommit;
+}
+async function git(args) {
+    try {
+        const result = await executeFile("git", [...args], {
+            encoding: "utf8",
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: 120_000
+        });
+        return result.stdout;
+    }
+    catch (error) {
+        const stderr = typeof error === "object" && error !== null && "stderr" in error
+            ? String(error.stderr).trim()
+            : "";
+        throw new Error(stderr.length === 0 ? "Git command failed." : `Git command failed: ${stderr}`, {
+            cause: error
+        });
+    }
+}
+async function gitLine(args) {
+    const value = (await git(args)).trim();
+    if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(value)) {
+        throw new Error("Git returned an invalid commit.");
+    }
+    return value;
+}
+async function gitSucceeds(args) {
+    try {
+        await git(args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/workspace/workItemChangeSetManager.js

@@ -0,0 +1,445 @@
+import { isDeepStrictEqual } from "node:util";
+import { createWorkItemChangeSet } from "../integration/changeSet.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
+import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
+import { captureManagedGitChanges } from "./gitChangeSetCapture.js";
+const CAPTURABLE_WORK_ITEM_STATUSES = new Set([
+    "awaiting_acceptance",
+    "completed",
+    "failed",
+    "retired"
+]);
+export class WorkItemChangeSetManager {
+    store;
+    now;
+    constructor(store, now = () => new Date()) {
+        this.store = store;
+        this.now = now;
+    }
+    async capture(taskId, workItemId, options = {}) {
+        const context = requireCapturableContext(this.store, taskId, workItemId, options.taskFinalReviewContract);
+        const entries = capturableEntries(context);
+        if (context.source === "task-main") {
+            const git = new NodeGitWorkspace();
+            for (const { entry, expectedHead } of entries) {
+                if (!await git.isClean(entry.path)) {
+                    throw new Error(`Exact direct Candidate Task main must be clean: ${context.workItemId}/${entry.projectId}.`);
+                }
+                const branch = await git.headRef(entry.path);
+                const headCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
+                if (branch !== entry.branch || headCommit !== expectedHead) {
+                    throw new Error(`Exact direct Candidate Task main no longer matches its frozen snapshot: ${context.workItemId}/${entry.projectId}.`);
+                }
+            }
+        }
+        const captured = [];
+        for (const entry of entries) {
+            const changeSet = await this.#captureProject(context, entry);
+            if (changeSet !== null)
+                captured.push(changeSet);
+        }
+        return captured;
+    }
+    async assertIntegrated(taskId, workItemId) {
+        const item = this.store.getWorkItem(taskId, workItemId);
+        if (item === null)
+            throw new Error(`Work item not found: ${taskId}/${workItemId}.`);
+        const workspace = this.store.getWorkItemWorkspace(item.taskId, item.id);
+        if (workspace === null
+            || workspace.owner.type !== "work-item"
+            || workspace.owner.workItemId !== item.id)
+            return null;
+        const git = new NodeGitWorkspace();
+        const projects = [];
+        for (const entry of writableEntries(workspace)) {
+            if (!await git.isClean(entry.path)) {
+                throw new Error(`WorkItem Project workspace is not clean: ${item.id}/${entry.projectId}.`);
+            }
+            const headCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
+            const latest = latestWorkItemChangeSet(this.store, item.taskId, item.id, entry.projectId);
+            if (headCommit === entry.baseCommit) {
+                if (latest !== undefined) {
+                    throw new Error(`WorkItem Project no longer matches its latest ChangeSet: ${item.id}/${entry.projectId}.`);
+                }
+                projects.push({
+                    projectId: entry.projectId,
+                    baseCommit: entry.baseCommit,
+                    headCommit
+                });
+                continue;
+            }
+            if (latest === undefined
+                || latest.baseCommit !== entry.baseCommit
+                || latest.headCommit !== headCommit
+                || latest.branch !== entry.branch) {
+                throw new Error(`WorkItem Project has uncaptured commits: ${item.id}/${entry.projectId}.`);
+            }
+            const integrated = this.store.listIntegrationAttempts(item.taskId).some((integration) => (integration.status === "committed"
+                && integration.projectId === entry.projectId
+                && integration.changeSetIds.includes(latest.id)));
+            if (!integrated) {
+                throw new Error(`WorkItem ChangeSet is not integrated: ${latest.id}.`);
+            }
+            projects.push({
+                projectId: entry.projectId,
+                baseCommit: entry.baseCommit,
+                headCommit,
+                changeSetId: latest.id
+            });
+        }
+        return {
+            workItemId: item.id,
+            ...(item.assignee === undefined ? {} : { assignee: item.assignee }),
+            workspace,
+            projects
+        };
+    }
+    /**
+     * Fail-closed proof that retiring the aggregate will not hide unrecorded Git
+     * state. It never removes or modifies a worktree.
+     */
+    async assertRetirable(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task === null)
+            throw new Error(`Task not found: ${taskId}.`);
+        if (task.status !== "active" && task.status !== "draft") {
+            throw new Error(`Task cannot be retired from ${task.status}: ${task.id}.`);
+        }
+        const unresolved = this.store.listIntegrationAttempts(task.id).find((attempt) => (attempt.status === "running"
+            || attempt.status === "blocked"
+            || attempt.status === "validating"));
+        if (unresolved !== undefined) {
+            throw new Error(`Task has an unresolved Integration Attempt: ${task.id}/${unresolved.id}.`);
+        }
+        const git = new NodeGitWorkspace();
+        const remoteHeads = new Map();
+        const findPublishedCommit = async (entry, headCommit) => {
+            const project = this.store.getProject(entry.projectId);
+            if (project?.remoteUrl === undefined)
+                return null;
+            let remoteHead = remoteHeads.get(project.id);
+            if (remoteHead === undefined) {
+                remoteHead = (await git.fetchRemoteHeadIntoWorktree({
+                    repositoryPath: entry.path,
+                    remoteUrl: project.remoteUrl,
+                    branch: project.developmentBranch
+                })).commit;
+                remoteHeads.set(project.id, remoteHead);
+            }
+            return git.findCommitWithSameTreeInHistory({
+                repositoryPath: entry.path,
+                sourceCommit: headCommit,
+                historyHead: remoteHead
+            });
+        };
+        const workspaces = [];
+        for (const workspace of this.store.listManagedWorkspaces(task.id)) {
+            const projects = [];
+            for (const entry of workspace.entries) {
+                if (!await git.isClean(entry.path)) {
+                    throw new Error(`Task retirement workspace is not clean: ${task.id}/${entry.projectId}.`);
+                }
+                const headCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
+                if (headCommit !== entry.baseCommit) {
+                    if (workspace.owner.type === "work-item") {
+                        const latest = latestWorkItemChangeSet(this.store, task.id, workspace.owner.workItemId, entry.projectId);
+                        if (latest === undefined
+                            || latest.baseCommit !== entry.baseCommit
+                            || latest.headCommit !== headCommit
+                            || latest.branch !== entry.branch) {
+                            const publishedCommit = await findPublishedCommit(entry, headCommit);
+                            if (publishedCommit === null) {
+                                throw new Error(`Task retirement would hide uncaptured WorkItem commits: `
+                                    + `${workspace.owner.workItemId}/${entry.projectId}.`);
+                            }
+                            projects.push({
+                                projectId: entry.projectId,
+                                baseCommit: entry.baseCommit,
+                                headCommit,
+                                publishedCommit
+                            });
+                            continue;
+                        }
+                        projects.push({
+                            projectId: entry.projectId,
+                            baseCommit: entry.baseCommit,
+                            headCommit,
+                            changeSetId: latest.id
+                        });
+                        continue;
+                    }
+                    const committed = this.store.listIntegrationAttempts(task.id).find((attempt) => (attempt.status === "committed"
+                        && attempt.projectId === entry.projectId
+                        && attempt.candidateCommit === headCommit));
+                    if (committed === undefined) {
+                        const publishedCommit = await findPublishedCommit(entry, headCommit);
+                        if (publishedCommit === null) {
+                            throw new Error(`Task retirement would hide uncaptured Task workspace commits: `
+                                + `${task.id}/${entry.projectId}.`);
+                        }
+                        projects.push({
+                            projectId: entry.projectId,
+                            baseCommit: entry.baseCommit,
+                            headCommit,
+                            publishedCommit
+                        });
+                        continue;
+                    }
+                }
+                projects.push({
+                    projectId: entry.projectId,
+                    baseCommit: entry.baseCommit,
+                    headCommit
+                });
+            }
+            workspaces.push({ ownerKey: managedWorkspaceKey(workspace.owner), workspace, projects });
+        }
+        return {
+            taskId: task.id,
+            taskUpdatedAt: task.updatedAt,
+            workspaces
+        };
+    }
+    async #captureProject(context, project) {
+        const { entry, expectedHead } = project;
+        const result = await captureManagedGitChanges({
+            path: entry.path,
+            branch: entry.branch,
+            baseCommit: entry.baseCommit,
+            commitMessage: `yui: work item ${context.workItemId} (${entry.directory})`,
+            identity: `${context.workItemId}/${entry.projectId}`,
+            ...(context.source === "task-main" ? { requireClean: true, expectedHead } : {})
+        });
+        if (result === null)
+            return null;
+        const existing = findWorkItemChangeSet(this.store, context.taskId, context.workItemId, entry.projectId, entry.baseCommit, result.headCommit);
+        if (existing !== undefined)
+            return existing;
+        return this.store.transaction((tx) => {
+            assertCaptureStillCurrent(tx, context);
+            const concurrent = findWorkItemChangeSet(tx, context.taskId, context.workItemId, entry.projectId, entry.baseCommit, result.headCommit);
+            if (concurrent !== undefined) {
+                if (!sameCapturedResult(concurrent, {
+                    ...concurrent,
+                    projectId: entry.projectId,
+                    branch: entry.branch,
+                    changedPaths: result.changedPaths
+                })) {
+                    throw new Error(`Work item ChangeSet is immutable: ${context.workItemId}/${entry.projectId}.`);
+                }
+                return concurrent;
+            }
+            const changeSet = createWorkItemChangeSet({
+                id: tx.nextChangeSetId(context.taskId),
+                taskId: context.taskId,
+                workItemId: context.workItemId,
+                projectId: entry.projectId,
+                baseCommit: entry.baseCommit,
+                headCommit: result.headCommit,
+                branch: entry.branch,
+                changedPaths: result.changedPaths
+            }, nextCaptureTime(tx, context.taskId, context.workItemId, entry.projectId, this.now()));
+            tx.saveChangeSet(context.taskId, changeSet);
+            return changeSet;
+        });
+    }
+}
+function requireCapturableContext(store, taskId, workItemId, taskFinalReviewContract) {
+    const item = store.getWorkItem(taskId, workItemId);
+    if (item === null)
+        throw new Error(`Work item not found: ${taskId}/${workItemId}.`);
+    if (!CAPTURABLE_WORK_ITEM_STATUSES.has(item.status)) {
+        throw new Error(`Work item must be awaiting acceptance or terminal before capture: ${item.id}.`);
+    }
+    if (item.workspaceDisposition !== undefined) {
+        throw new Error(`Work item workspace is already recorded as ${item.workspaceDisposition}: ${item.id}.`);
+    }
+    const task = store.getTask(item.taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${item.taskId}.`);
+    if (task.status !== "active") {
+        throw new Error(`Task is not active: ${task.id}/${task.status}.`);
+    }
+    const workspace = store.getWorkItemWorkspace(task.id, item.id);
+    if (workspace?.owner.type === "review-round") {
+        throw new Error(`ReviewRound-owned workspace cannot be captured as WorkItem Develop: ${item.id}.`);
+    }
+    const exactWorkItemWorkspace = workspace !== null
+        && workspace.owner.type === "work-item"
+        && workspace.owner.workItemId === item.id;
+    let selectedWorkspace;
+    let source;
+    let taskMainSnapshot;
+    if (exactWorkItemWorkspace) {
+        selectedWorkspace = workspace;
+        source = "work-item";
+    }
+    else {
+        if (taskFinalReviewContract === undefined) {
+            throw new Error(`Work item has no managed workspace: ${item.id}.`);
+        }
+        const candidate = item.candidates.at(-1);
+        if (candidate?.source.type !== "direct"
+            || !sameTaskFinalReviewContract(candidate.taskFinalReviewContract, taskFinalReviewContract)) {
+            throw new Error(`Work item has no matching exact Task-final direct Candidate: ${item.id}.`);
+        }
+        if (candidate.taskMainSnapshot === undefined) {
+            throw new Error(`Exact Task-final direct Candidate has no frozen Task-main snapshot: ${item.id}.`);
+        }
+        if (latestExactDirectAnchorId(store, task.id, taskFinalReviewContract) !== item.id) {
+            throw new Error(`Only the latest exact Task-final direct Candidate may capture Task main: ${item.id}.`);
+        }
+        const taskWorkspace = store.getTaskWorkspace(task.id);
+        if (taskWorkspace === null
+            || taskWorkspace.owner.type !== "task"
+            || taskWorkspace.owner.taskId !== task.id) {
+            throw new Error(`Task has no authoritative main workspace: ${task.id}.`);
+        }
+        selectedWorkspace = taskWorkspace;
+        source = "task-main";
+        taskMainSnapshot = candidate.taskMainSnapshot;
+    }
+    const expectedWriteProjects = [...item.writeProjectIds].sort();
+    const availableWriteProjects = writableEntries(selectedWorkspace)
+        .map(({ projectId }) => projectId);
+    const actualWriteProjects = availableWriteProjects
+        .filter((projectId) => expectedWriteProjects.includes(projectId))
+        .sort();
+    if (!isDeepStrictEqual(actualWriteProjects, expectedWriteProjects)) {
+        throw new Error(`Work item workspace scope is stale: ${item.id}.`);
+    }
+    if (source === "task-main") {
+        const snapshotProjects = taskMainSnapshot.projects
+            .map(({ projectId }) => projectId)
+            .sort();
+        if (!isDeepStrictEqual(snapshotProjects, expectedWriteProjects)) {
+            throw new Error(`Direct Candidate snapshot scope is stale: ${item.id}.`);
+        }
+        for (const snapshot of taskMainSnapshot.projects) {
+            const current = selectedWorkspace.entries.find(({ projectId }) => projectId === snapshot.projectId);
+            if (current === undefined
+                || current.access !== "write"
+                || current.directory !== snapshot.directory
+                || current.branch !== snapshot.branch) {
+                throw new Error(`Direct Candidate Task-main identity is stale: ${item.id}/${snapshot.projectId}.`);
+            }
+        }
+    }
+    return {
+        taskId: task.id,
+        workItemId: item.id,
+        ...(item.assignee === undefined ? {} : { assignee: item.assignee }),
+        expectedRevision: item.revision,
+        source,
+        writeProjectIds: expectedWriteProjects,
+        ...(source === "task-main" ? { taskFinalReviewContract, taskMainSnapshot } : {}),
+        workspace: selectedWorkspace
+    };
+}
+function assertCaptureStillCurrent(store, expected) {
+    const task = store.getTask(expected.taskId);
+    const item = store.getWorkItem(expected.taskId, expected.workItemId);
+    const workspace = expected.source === "task-main"
+        ? store.getTaskWorkspace(expected.taskId)
+        : store.getWorkItemWorkspace(expected.taskId, expected.workItemId);
+    const candidate = item?.candidates.at(-1);
+    if (task?.status !== "active"
+        || item === null
+        || item.revision !== expected.expectedRevision
+        || !CAPTURABLE_WORK_ITEM_STATUSES.has(item.status)
+        || item.workspaceDisposition !== undefined
+        || workspace === null
+        || (expected.source === "task-main"
+            ? !sameTaskMainWorkspaceIdentity(workspace, expected.workspace)
+            : !isDeepStrictEqual(workspace, expected.workspace))
+        || (expected.source === "task-main" && (candidate?.source.type !== "direct"
+            || !isDeepStrictEqual(candidate.taskMainSnapshot, expected.taskMainSnapshot)
+            || !sameTaskFinalReviewContract(candidate.taskFinalReviewContract, expected.taskFinalReviewContract)
+            || latestExactDirectAnchorId(store, expected.taskId, expected.taskFinalReviewContract) !== expected.workItemId))) {
+        throw new Error(`WorkItem changed while its ChangeSets were being captured: ${expected.workItemId}. Retry capture.`);
+    }
+}
+function sameTaskMainWorkspaceIdentity(current, expected) {
+    return current.owner.type === "task"
+        && expected.owner.type === "task"
+        && current.owner.taskId === expected.owner.taskId
+        && current.root === expected.root
+        && current.entries.length === expected.entries.length
+        && current.entries.every((entry, index) => {
+            const frozen = expected.entries[index];
+            return frozen !== undefined
+                && entry.projectId === frozen.projectId
+                && entry.directory === frozen.directory
+                && entry.access === frozen.access
+                && entry.path === frozen.path
+                && entry.branch === frozen.branch;
+        });
+}
+function latestExactDirectAnchorId(store, taskId, contract) {
+    if (contract === undefined)
+        return undefined;
+    return store.listWorkItems(taskId)
+        .filter((item) => {
+        const candidate = item.candidates.at(-1);
+        return candidate?.source.type === "direct"
+            && sameTaskFinalReviewContract(candidate.taskFinalReviewContract, contract);
+    })
+        .sort((left, right) => (left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id)))
+        .at(-1)?.id;
+}
+function capturableEntries(context) {
+    const allowed = new Set(context.writeProjectIds);
+    return writableEntries(context.workspace)
+        .filter(({ projectId }) => allowed.has(projectId))
+        .map((entry) => {
+        if (context.source !== "task-main")
+            return { entry };
+        const snapshot = context.taskMainSnapshot.projects.find(({ projectId }) => projectId === entry.projectId);
+        return {
+            entry: {
+                ...entry,
+                branch: snapshot.branch,
+                baseCommit: snapshot.baseCommit
+            },
+            expectedHead: snapshot.headCommit
+        };
+    });
+}
+function writableEntries(workspace) {
+    return workspace.entries.filter(({ access }) => access === "write");
+}
+function latestWorkItemChangeSet(store, taskId, workItemId, projectId, commits) {
+    return store.listChangeSets(taskId).filter((changeSet) => (changeSet.schemaVersion === 2
+        && changeSet.workItemId === workItemId
+        && changeSet.projectId === projectId
+        && (commits === undefined
+            || (changeSet.baseCommit === commits.baseCommit
+                && changeSet.headCommit === commits.headCommit)))).sort(compareNewestFirst)[0];
+}
+function findWorkItemChangeSet(store, taskId, workItemId, projectId, baseCommit, headCommit) {
+    return latestWorkItemChangeSet(store, taskId, workItemId, projectId, {
+        baseCommit,
+        headCommit
+    });
+}
+function compareNewestFirst(left, right) {
+    return right.createdAt.localeCompare(left.createdAt) || right.id.localeCompare(left.id);
+}
+function nextCaptureTime(store, taskId, workItemId, projectId, candidate) {
+    const latest = latestWorkItemChangeSet(store, taskId, workItemId, projectId);
+    if (latest === undefined)
+        return candidate;
+    const minimum = Date.parse(latest.createdAt) + 1;
+    return candidate.getTime() >= minimum ? candidate : new Date(minimum);
+}
+function sameCapturedResult(left, right) {
+    return left.taskId === right.taskId
+        && left.workItemId === right.workItemId
+        && left.projectId === right.projectId
+        && left.baseCommit === right.baseCommit
+        && left.headCommit === right.headCommit
+        && left.branch === right.branch
+        && left.changedPaths.length === right.changedPaths.length
+        && left.changedPaths.every((path, index) => path === right.changedPaths[index]);
+}