parallel-codex-tui 0.1.0 → 0.1.4

package/dist/core/task-state-machine.js

@@ -0,0 +1,17 @@
+const TASK_STATE_TRANSITIONS = {
+    created: new Set(["routed", "failed", "cancelled"]),
+    routed: new Set(["judging", "failed", "cancelled"]),
+    judging: new Set(["ready_for_pair", "failed", "cancelled"]),
+    ready_for_pair: new Set(["actor_running", "done", "failed", "cancelled"]),
+    actor_running: new Set(["critic_running", "verifying", "failed", "cancelled"]),
+    critic_running: new Set(["revision_needed", "integrating", "failed", "cancelled"]),
+    revision_needed: new Set(["actor_running", "failed", "cancelled"]),
+    integrating: new Set(["actor_running", "verifying", "done", "failed", "cancelled"]),
+    verifying: new Set(["revision_needed", "integrating", "failed", "cancelled"]),
+    done: new Set(["routed", "cancelled"]),
+    failed: new Set(["routed", "judging", "ready_for_pair"]),
+    cancelled: new Set(["routed", "judging", "ready_for_pair"])
+};
+export function taskStateTransitionAllowed(from, to) {
+    return from === to || TASK_STATE_TRANSITIONS[from].has(to);
+}

package/dist/core/workspace-commit-recovery.js

@@ -0,0 +1,118 @@
+import { readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { sessionsRoot } from "./paths.js";
+const TASK_DIRECTORY_PATTERN = /^task-/;
+const TURN_DIRECTORY_PATTERN = /^turn-(\d{4,})$/;
+const WAVE_DIRECTORY_PATTERN = /^wave-(\d{4,})$/;
+const COMMIT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
+const COMMIT_PROTOCOL = "atomic-claim-v1";
+export async function reconcileWorkspaceCommitIntents(projectRoot, dataDir) {
+    const recovery = { cleaned: 0, preserved: 0 };
+    const taskEntries = await directoryEntries(sessionsRoot(projectRoot, dataDir));
+    for (const taskEntry of taskEntries) {
+        if (!taskEntry.isDirectory() || !TASK_DIRECTORY_PATTERN.test(taskEntry.name)) {
+            continue;
+        }
+        const workspacesDir = join(sessionsRoot(projectRoot, dataDir), taskEntry.name, "workspaces");
+        for (const turnEntry of await directoryEntries(workspacesDir)) {
+            const turnMatch = turnEntry.isDirectory() ? TURN_DIRECTORY_PATTERN.exec(turnEntry.name) : null;
+            if (!turnMatch) {
+                continue;
+            }
+            for (const waveEntry of await directoryEntries(join(workspacesDir, turnEntry.name))) {
+                const waveMatch = waveEntry.isDirectory() ? WAVE_DIRECTORY_PATTERN.exec(waveEntry.name) : null;
+                if (!waveMatch) {
+                    continue;
+                }
+                const waveDir = join(workspacesDir, turnEntry.name, waveEntry.name);
+                const pendingPath = join(waveDir, "integration.pending.json");
+                const pendingRecord = await readJsonRecord(pendingPath);
+                if (pendingRecord === undefined) {
+                    continue;
+                }
+                const pending = parseCommitEvidence(pendingRecord, "committing");
+                const integrated = parseCommitEvidence(await readJsonRecord(join(waveDir, "integration.json")), "integrated");
+                const directoryTurnId = turnMatch[1];
+                const directoryWave = Number(waveMatch[1]);
+                if (!pending
+                    || !integrated
+                    || pending.turnId !== directoryTurnId
+                    || pending.wave !== directoryWave
+                    || !sameCommit(pending, integrated)) {
+                    recovery.preserved += 1;
+                    continue;
+                }
+                try {
+                    await rm(pendingPath, { force: true });
+                    recovery.cleaned += 1;
+                }
+                catch {
+                    recovery.preserved += 1;
+                }
+            }
+        }
+    }
+    return recovery;
+}
+async function directoryEntries(path) {
+    try {
+        return await readdir(path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+async function readJsonRecord(path) {
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : null;
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? undefined : null;
+    }
+}
+function parseCommitEvidence(record, state) {
+    const featureIds = stringArray(record?.feature_ids);
+    const changedPaths = stringArray(record?.changed_paths);
+    const commitId = record?.commit_id;
+    const commitProtocol = record?.commit_protocol;
+    if (record?.version !== 1
+        || record.state !== state
+        || typeof record.turn_id !== "string"
+        || !Number.isInteger(record.wave)
+        || record.wave < 1
+        || !featureIds
+        || !changedPaths
+        || (commitId !== undefined && (typeof commitId !== "string" || !COMMIT_ID_PATTERN.test(commitId)))
+        || (commitProtocol !== undefined && commitProtocol !== COMMIT_PROTOCOL)) {
+        return null;
+    }
+    return {
+        version: 1,
+        state,
+        turnId: record.turn_id,
+        wave: record.wave,
+        featureIds,
+        ...(typeof commitId === "string" ? { commitId } : {}),
+        ...(commitProtocol === COMMIT_PROTOCOL ? { commitProtocol } : {}),
+        changedPaths
+    };
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? value
+        : null;
+}
+function sameCommit(pending, integrated) {
+    return pending.turnId === integrated.turnId
+        && pending.wave === integrated.wave
+        && sameStrings(pending.featureIds, integrated.featureIds)
+        && sameStrings(pending.changedPaths, integrated.changedPaths)
+        && (pending.commitId === undefined || pending.commitId === integrated.commitId)
+        && (pending.commitProtocol === undefined || pending.commitProtocol === integrated.commitProtocol);
+}
+function sameStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/core/workspace.js

@@ -0,0 +1,126 @@
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { ensureDir, pathExists, pathIsDirectory, readJson, readTextIfExists, writeJson, writeText } from "./file-store.js";
+import { runWithLeaseFinalization } from "./lease-finalization.js";
+import { acquireProcessMutationTurn } from "./process-mutation-turn.js";
+const lastWorkspaceFile = "last-workspace";
+const workspacesFile = "workspaces.json";
+const maxRememberedWorkspaces = 20;
+const workspaceRegistryIntentPrefix = ".workspace-registry-claim-";
+const WorkspaceRegistrySchema = z.object({
+    version: z.literal(1).default(1),
+    workspaces: z
+        .array(z.object({
+        path: z.string().min(1),
+        last_used_at: z.string().min(1)
+    }))
+        .default([])
+});
+export async function resolveWorkspaceSelection(input) {
+    if (input.explicitWorkspace?.trim()) {
+        return resolveWorkspacePath(input.cwd, input.explicitWorkspace);
+    }
+    const [latest] = await listWorkspaceChoices(input.appRoot);
+    return latest ? latest.path : input.cwd;
+}
+export async function prepareWorkspace(appRoot, workspaceRoot) {
+    const resolved = resolveWorkspacePath(process.cwd(), workspaceRoot);
+    if ((await pathExists(resolved)) && !(await pathIsDirectory(resolved))) {
+        throw new Error(`Workspace path exists but is not a directory: ${resolved}`);
+    }
+    await ensureDir(resolved);
+    await ensureDir(join(resolved, ".parallel-codex"));
+    await rememberWorkspace(appRoot, resolved);
+    return resolved;
+}
+export async function hasSavedWorkspace(appRoot) {
+    return (await listWorkspaceChoices(appRoot)).length > 0;
+}
+export async function listWorkspaceChoices(appRoot) {
+    const entries = await readWorkspaceEntries(appRoot);
+    const legacy = (await readTextIfExists(lastWorkspacePath(appRoot))).trim();
+    if (legacy) {
+        entries.push({ path: legacy, last_used_at: "" });
+    }
+    const seen = new Set();
+    const unique = entries
+        .map((entry, index) => ({
+        path: resolveStoredWorkspacePath(appRoot, entry.path),
+        lastUsedAt: entry.last_used_at || null,
+        order: index
+    }))
+        .filter((entry) => {
+        if (seen.has(entry.path)) {
+            return false;
+        }
+        seen.add(entry.path);
+        return true;
+    })
+        .sort((left, right) => {
+        const byDate = (right.lastUsedAt ?? "").localeCompare(left.lastUsedAt ?? "");
+        return byDate === 0 ? left.order - right.order : byDate;
+    });
+    const choices = await Promise.all(unique.map(async (entry) => {
+        const exists = await pathExists(entry.path);
+        const isDirectory = exists && (await pathIsDirectory(entry.path));
+        return {
+            path: entry.path,
+            exists: isDirectory,
+            lastUsedAt: entry.lastUsedAt,
+            selectable: !exists || isDirectory
+        };
+    }));
+    return choices
+        .filter((choice) => choice.selectable)
+        .map(({ selectable: _selectable, ...choice }) => choice);
+}
+async function rememberWorkspace(appRoot, workspaceRoot) {
+    const resolved = resolveWorkspacePath(process.cwd(), workspaceRoot);
+    const mutationTurn = await acquireProcessMutationTurn(join(appRoot, ".parallel-codex"), {
+        intentPrefix: workspaceRegistryIntentPrefix,
+        timeoutMessage: "Timed out waiting to update the workspace registry."
+    });
+    await runWithLeaseFinalization("Workspace registry update", mutationTurn, async () => {
+        const current = await readWorkspaceEntries(appRoot);
+        const next = {
+            version: 1,
+            workspaces: [
+                { path: resolved, last_used_at: new Date().toISOString() },
+                ...current.filter((entry) => resolveStoredWorkspacePath(appRoot, entry.path) !== resolved)
+            ].slice(0, maxRememberedWorkspaces)
+        };
+        await writeJson(workspacesPath(appRoot), WorkspaceRegistrySchema.parse(next));
+        await writeText(lastWorkspacePath(appRoot), `${resolved}\n`);
+    });
+}
+async function readWorkspaceEntries(appRoot) {
+    const file = workspacesPath(appRoot);
+    if (!(await pathExists(file))) {
+        return [];
+    }
+    try {
+        return (await readJson(file, WorkspaceRegistrySchema)).workspaces;
+    }
+    catch {
+        return [];
+    }
+}
+function lastWorkspacePath(appRoot) {
+    return join(appRoot, ".parallel-codex", lastWorkspaceFile);
+}
+function workspacesPath(appRoot) {
+    return join(appRoot, ".parallel-codex", workspacesFile);
+}
+export function resolveWorkspacePath(cwd, value) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return resolve(cwd, value);
+}
+function resolveStoredWorkspacePath(appRoot, value) {
+    return resolveWorkspacePath(appRoot, value);
+}