parallel-codex-tui 0.1.0

package/dist/core/paths.js

@@ -0,0 +1,17 @@
+import { join } from "node:path";
+function pad(value) {
+    return String(value).padStart(2, "0");
+}
+export function formatTaskTimestamp(date) {
+    return ([
+        date.getUTCFullYear(),
+        pad(date.getUTCMonth() + 1),
+        pad(date.getUTCDate())
+    ].join("") + `-${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`);
+}
+export function sessionsRoot(projectRoot, dataDir) {
+    return join(projectRoot, dataDir, "sessions");
+}
+export function taskDir(projectRoot, dataDir, taskId) {
+    return join(sessionsRoot(projectRoot, dataDir), taskId);
+}

package/dist/core/router.js

@@ -0,0 +1,151 @@
+import { spawn } from "node:child_process";
+import { RouteDecisionSchema } from "../domain/schemas.js";
+export async function routeRequestWithCodex(request, config, runner = runCodexRouterProcess, cwd = config.projectRoot) {
+    if (config.router.defaultMode === "simple") {
+        return simpleRoute("Forced simple mode from config.", config);
+    }
+    if (config.router.defaultMode === "complex") {
+        return complexRoute("Forced complex mode from config.", config);
+    }
+    try {
+        const output = await runner(buildCodexRouterPrompt(request, config), config, cwd);
+        const route = parseCodexRoute(output, config);
+        return RouteDecisionSchema.parse(route);
+    }
+    catch (error) {
+        const fallback = fallbackRoute(config);
+        return {
+            ...fallback,
+            reason: `Codex router failed: ${error instanceof Error ? error.message : String(error)}. ${fallback.reason}`
+        };
+    }
+}
+export async function runCodexRouterProcess(prompt, config, cwd = config.projectRoot) {
+    const { command, args, timeoutMs } = config.router.codex;
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timeout;
+        const finish = (error, output = stdout) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(output);
+            }
+        };
+        if (timeoutMs > 0) {
+            timeout = setTimeout(() => {
+                child.kill("SIGTERM");
+                finish(new Error(`Codex router timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+        }
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            finish(error);
+        });
+        child.on("close", (code, signal) => {
+            if (code === 0) {
+                finish(null);
+                return;
+            }
+            const detail = (stderr || stdout).trim();
+            finish(new Error(`Codex router exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${detail ? `: ${detail}` : ""}`));
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+function buildCodexRouterPrompt(request, config) {
+    return [
+        "You are a routing classifier for parallel-codex-tui.",
+        "Return only one JSON object. No markdown. No commentary.",
+        "",
+        "Choose mode:",
+        '- "simple": short chat, explanation, status question, no code or project action.',
+        '- "complex": implementation, modification, optimization, debugging, testing, strategy, scoring, experiments, or project work.',
+        "",
+        "JSON schema:",
+        JSON.stringify({
+            mode: "simple|complex",
+            reason: "short explanation",
+            suggested_roles: ["judge", "actor", "critic"],
+            judge_engine: config.pairing.judge,
+            actor_engine: config.pairing.actor,
+            critic_engine: config.pairing.critic
+        }),
+        "",
+        "User request:",
+        request
+    ].join("\n");
+}
+function parseCodexRoute(output, config) {
+    const jsonText = extractJsonObject(output);
+    const parsed = JSON.parse(jsonText);
+    return {
+        mode: parsed.mode === "complex" ? "complex" : "simple",
+        reason: parsed.reason || "Codex router decision.",
+        suggested_roles: parsed.mode === "complex" ? ["judge", "actor", "critic"] : [],
+        judge_engine: parsed.judge_engine ?? config.pairing.judge,
+        actor_engine: parsed.actor_engine ?? config.pairing.actor,
+        critic_engine: parsed.critic_engine ?? config.pairing.critic
+    };
+}
+function extractJsonObject(output) {
+    const trimmed = output.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return trimmed;
+    }
+    const match = trimmed.match(/\{[\s\S]*\}/);
+    if (!match) {
+        throw new Error("No JSON object in Codex router output");
+    }
+    return match[0];
+}
+function fallbackRoute(config) {
+    if (config.router.codex.fallback === "simple") {
+        return simpleRoute("Codex router fallback forced simple.", config);
+    }
+    if (config.router.codex.fallback === "complex") {
+        return complexRoute("Codex router fallback forced complex.", config);
+    }
+    return complexRoute("Codex router fallback forced complex.", config);
+}
+function simpleRoute(reason, config) {
+    return {
+        mode: "simple",
+        reason,
+        suggested_roles: [],
+        judge_engine: config.pairing.judge,
+        actor_engine: config.pairing.actor,
+        critic_engine: config.pairing.critic
+    };
+}
+function complexRoute(reason, config) {
+    return {
+        mode: "complex",
+        reason,
+        suggested_roles: ["judge", "actor", "critic"],
+        judge_engine: config.pairing.judge,
+        actor_engine: config.pairing.actor,
+        critic_engine: config.pairing.critic
+    };
+}

package/dist/core/session-index.js

@@ -0,0 +1,180 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { NativeSessionSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
+import { ensureDir, pathExists, readJson } from "./file-store.js";
+export class SessionIndex {
+    db;
+    projectRoot;
+    dataDir;
+    constructor(db, projectRoot, dataDir) {
+        this.db = db;
+        this.projectRoot = projectRoot;
+        this.dataDir = dataDir;
+    }
+    static async open(projectRoot, dataDir) {
+        await ensureDir(join(projectRoot, dataDir));
+        const index = new SessionIndex(new DatabaseSync(join(projectRoot, dataDir, "session-index.sqlite")), projectRoot, dataDir);
+        index.initialize();
+        return index;
+    }
+    initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        cwd TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS turns (
+        task_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        request_path TEXT NOT NULL,
+        PRIMARY KEY (task_id, turn_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS workers (
+        task_id TEXT NOT NULL,
+        worker_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        engine TEXT NOT NULL,
+        state TEXT NOT NULL,
+        phase TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        status_path TEXT NOT NULL,
+        output_log_path TEXT NOT NULL,
+        dir TEXT NOT NULL,
+        native_session_id TEXT,
+        PRIMARY KEY (task_id, worker_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS native_sessions (
+        task_id TEXT NOT NULL,
+        worker_id TEXT NOT NULL,
+        engine TEXT NOT NULL,
+        role TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        cwd TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        last_used_at TEXT NOT NULL,
+        source TEXT NOT NULL,
+        PRIMARY KEY (task_id, worker_id)
+      );
+    `);
+    }
+    async upsertTask(task) {
+        this.db
+            .prepare(`INSERT INTO tasks (id, title, created_at, cwd, mode, status)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           title=excluded.title,
+           created_at=excluded.created_at,
+           cwd=excluded.cwd,
+           mode=excluded.mode,
+           status=excluded.status`)
+            .run(task.id, task.title, task.created_at, task.cwd, task.mode, task.status);
+    }
+    async upsertTurn(taskId, turn) {
+        this.db
+            .prepare(`INSERT INTO turns (task_id, turn_id, created_at, request_path)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(task_id, turn_id) DO UPDATE SET
+           created_at=excluded.created_at,
+           request_path=excluded.request_path`)
+            .run(taskId, turn.turn_id, turn.created_at, turn.request_path);
+    }
+    async upsertWorker(taskId, status, paths) {
+        this.db
+            .prepare(`INSERT INTO workers (
+          task_id, worker_id, role, engine, state, phase, summary, status_path, output_log_path, dir, native_session_id
+        )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(task_id, worker_id) DO UPDATE SET
+           role=excluded.role,
+           engine=excluded.engine,
+           state=excluded.state,
+           phase=excluded.phase,
+           summary=excluded.summary,
+           status_path=excluded.status_path,
+           output_log_path=excluded.output_log_path,
+           dir=excluded.dir,
+           native_session_id=excluded.native_session_id`)
+            .run(taskId, status.worker_id, status.role, status.engine, status.state, status.phase, status.summary, paths.statusPath, paths.outputLogPath, paths.dir, status.native_session_id ?? null);
+    }
+    async upsertNativeSession(taskId, record) {
+        this.db
+            .prepare(`INSERT INTO native_sessions (
+          task_id, worker_id, engine, role, session_id, cwd, created_at, last_used_at, source
+        )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(task_id, worker_id) DO UPDATE SET
+           engine=excluded.engine,
+           role=excluded.role,
+           session_id=excluded.session_id,
+           cwd=excluded.cwd,
+           created_at=excluded.created_at,
+           last_used_at=excluded.last_used_at,
+           source=excluded.source`)
+            .run(taskId, record.worker_id, record.engine, record.role, record.session_id, record.cwd, record.created_at, record.last_used_at, record.source);
+    }
+    async countRows(table) {
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get();
+        return row.count;
+    }
+    async rebuildFromFiles() {
+        this.db.exec("DELETE FROM native_sessions; DELETE FROM workers; DELETE FROM turns; DELETE FROM tasks;");
+        const sessions = join(this.projectRoot, this.dataDir, "sessions");
+        if (!(await pathExists(sessions))) {
+            return;
+        }
+        const taskEntries = await readdir(sessions, { withFileTypes: true });
+        for (const taskEntry of taskEntries) {
+            if (!taskEntry.isDirectory() || !taskEntry.name.startsWith("task-")) {
+                continue;
+            }
+            await this.rebuildTask(join(sessions, taskEntry.name), taskEntry.name);
+        }
+    }
+    close() {
+        this.db.close();
+    }
+    async rebuildTask(taskDir, taskId) {
+        const metaPath = join(taskDir, "meta.json");
+        if (await pathExists(metaPath)) {
+            await this.upsertTask(await readJson(metaPath, TaskMetaSchema));
+        }
+        const turnsDir = join(taskDir, "turns");
+        if (await pathExists(turnsDir)) {
+            const turnEntries = await readdir(turnsDir, { withFileTypes: true });
+            for (const turnEntry of turnEntries) {
+                const turnPath = join(turnsDir, turnEntry.name, "turn.json");
+                if (turnEntry.isDirectory() && (await pathExists(turnPath))) {
+                    await this.upsertTurn(taskId, await readJson(turnPath, TurnMetaSchema));
+                }
+            }
+        }
+        const entries = await readdir(taskDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === "turns") {
+                continue;
+            }
+            const workerDir = join(taskDir, entry.name);
+            const statusPath = join(workerDir, "status.json");
+            if (await pathExists(statusPath)) {
+                await this.upsertWorker(taskId, await readJson(statusPath, WorkerStatusSchema), {
+                    dir: workerDir,
+                    statusPath,
+                    outputLogPath: join(workerDir, "output.log")
+                });
+            }
+            const nativePath = join(workerDir, "native-session.json");
+            if (await pathExists(nativePath)) {
+                await this.upsertNativeSession(taskId, await readJson(nativePath, NativeSessionSchema));
+            }
+        }
+    }
+}

package/dist/core/session-manager.js

@@ -0,0 +1,264 @@
+import { readdir } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, removeIfExists, writeJson, writeText } from "./file-store.js";
+import { formatTaskTimestamp, taskDir } from "./paths.js";
+import { sessionsRoot } from "./paths.js";
+import { NativeSessionSchema, RouteDecisionSchema, TaskMetaSchema, TurnMetaSchema } from "../domain/schemas.js";
+export class SessionManager {
+    projectRoot;
+    dataDir;
+    now;
+    randomId;
+    index;
+    constructor(options) {
+        this.projectRoot = options.projectRoot;
+        this.dataDir = options.dataDir;
+        this.now = options.now ?? (() => new Date());
+        this.randomId = options.randomId ?? (() => Math.random().toString(16).slice(2, 6));
+        this.index = options.index;
+    }
+    async createTask(input) {
+        const createdAt = this.now();
+        const id = `task-${formatTaskTimestamp(createdAt)}-${this.randomId()}`;
+        const dir = taskDir(this.projectRoot, this.dataDir, id);
+        const meta = {
+            id,
+            title: titleFromRequest(input.request),
+            created_at: createdAt.toISOString(),
+            cwd: input.cwd,
+            mode: input.route.mode,
+            status: "created"
+        };
+        await ensureDir(dir);
+        await writeJson(join(dir, "meta.json"), TaskMetaSchema.parse(meta));
+        await writeText(join(dir, "user-request.md"), `${input.request.trim()}\n`);
+        await this.index?.upsertTask(meta);
+        await writeJson(join(dir, "route.json"), RouteDecisionSchema.parse(input.route));
+        await this.writeTurn({ id, dir }, "0001", input.request, input.route, createdAt);
+        await this.appendEvent({ id, dir }, "task.created", "Task session created");
+        return {
+            id,
+            dir,
+            metaPath: join(dir, "meta.json"),
+            routePath: join(dir, "route.json"),
+            eventsPath: join(dir, "events.jsonl")
+        };
+    }
+    mainSessionDir() {
+        return join(this.projectRoot, this.dataDir, "sessions", "main");
+    }
+    taskFromId(taskId) {
+        const dir = taskDir(this.projectRoot, this.dataDir, taskId);
+        return {
+            id: taskId,
+            dir,
+            metaPath: join(dir, "meta.json"),
+            routePath: join(dir, "route.json"),
+            eventsPath: join(dir, "events.jsonl")
+        };
+    }
+    async latestTask() {
+        const root = sessionsRoot(this.projectRoot, this.dataDir);
+        if (!(await pathExists(root))) {
+            return null;
+        }
+        const entries = await readdir(root, { withFileTypes: true });
+        const tasks = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("task-")) {
+                continue;
+            }
+            const metaPath = join(root, entry.name, "meta.json");
+            if (await pathExists(metaPath)) {
+                const meta = await readJson(metaPath, TaskMetaSchema);
+                if (meta.mode === "complex") {
+                    tasks.push(meta);
+                }
+            }
+        }
+        const latest = tasks.sort((left, right) => left.created_at.localeCompare(right.created_at)).at(-1);
+        if (!latest) {
+            return null;
+        }
+        const dir = taskDir(this.projectRoot, this.dataDir, latest.id);
+        return {
+            id: latest.id,
+            dir,
+            metaPath: join(dir, "meta.json"),
+            routePath: join(dir, "route.json"),
+            eventsPath: join(dir, "events.jsonl")
+        };
+    }
+    async appendTurn(task, input) {
+        await this.indexTaskFromFiles(task);
+        await this.backfillInitialTurn(task, input.route);
+        const turnId = await this.nextTurnId(task);
+        const turn = await this.writeTurn(task, turnId, input.request, input.route, this.now());
+        await this.appendEvent(task, "turn.created", `Turn ${turnId} created`);
+        return turn;
+    }
+    async latestTurn(task) {
+        const root = join(task.dir, "turns");
+        if (!(await pathExists(root))) {
+            return null;
+        }
+        const entries = await readdir(root, { withFileTypes: true });
+        const turnId = entries
+            .filter((entry) => entry.isDirectory() && /^\d{4}$/.test(entry.name))
+            .map((entry) => entry.name)
+            .sort()
+            .at(-1);
+        if (!turnId) {
+            return null;
+        }
+        return this.turnFiles(task, turnId);
+    }
+    async readMeta(task) {
+        return readJson(task.metaPath, TaskMetaSchema);
+    }
+    async updateTaskStatus(task, status) {
+        const meta = await this.readMeta(task);
+        await writeJson(task.metaPath, TaskMetaSchema.parse({ ...meta, status }));
+        await this.index?.upsertTask({ ...meta, status });
+        await this.appendEvent(task, `task.${status}`, `Task moved to ${status}`);
+    }
+    async initializeWorker(task, input) {
+        const dir = join(task.dir, input.workerId);
+        const promptPath = join(dir, "prompt.md");
+        const outputLogPath = join(dir, "output.log");
+        const statusPath = join(dir, "status.json");
+        const status = {
+            worker_id: input.workerId,
+            role: input.role,
+            engine: input.engine,
+            state: "idle",
+            phase: "initialized",
+            last_event_at: this.now().toISOString(),
+            summary: "Worker initialized"
+        };
+        await ensureDir(dir);
+        await this.clearWorkerArtifacts(dir, input.role);
+        await writeText(promptPath, input.prompt);
+        await writeText(outputLogPath, "");
+        await writeJson(statusPath, status);
+        await this.index?.upsertWorker(task.id, status, {
+            dir,
+            statusPath,
+            outputLogPath
+        });
+        return {
+            workerId: input.workerId,
+            dir,
+            promptPath,
+            outputLogPath,
+            statusPath
+        };
+    }
+    async readNativeSession(worker) {
+        const path = join(worker.dir, "native-session.json");
+        if (!(await pathExists(path))) {
+            return null;
+        }
+        return readJson(path, NativeSessionSchema);
+    }
+    async writeNativeSession(worker, record) {
+        await writeJson(join(worker.dir, "native-session.json"), NativeSessionSchema.parse(record));
+        await this.index?.upsertNativeSession(this.taskIdFromWorkerDir(worker.dir), record);
+    }
+    async retireNativeSession(worker, reason) {
+        const nativeSessionPath = join(worker.dir, "native-session.json");
+        if (!(await pathExists(nativeSessionPath))) {
+            return;
+        }
+        const record = await readJson(nativeSessionPath, NativeSessionSchema);
+        await writeJson(join(worker.dir, "native-session.retired.json"), {
+            ...record,
+            retired_at: this.now().toISOString(),
+            retired_reason: reason
+        });
+        await removeIfExists(nativeSessionPath);
+    }
+    async appendEvent(task, type, message) {
+        const event = {
+            time: this.now().toISOString(),
+            type,
+            message,
+            task_id: task.id
+        };
+        await appendJsonLine(join(task.dir, "events.jsonl"), event);
+    }
+    async nextTurnId(task) {
+        const latest = await this.latestTurn(task);
+        if (!latest) {
+            return (await pathExists(join(task.dir, "user-request.md"))) ? "0002" : "0001";
+        }
+        return String(Number(latest.turnId) + 1).padStart(4, "0");
+    }
+    async indexTaskFromFiles(task) {
+        if (!this.index || !(await pathExists(task.metaPath))) {
+            return;
+        }
+        await this.index.upsertTask(await readJson(task.metaPath, TaskMetaSchema));
+    }
+    async backfillInitialTurn(task, fallbackRoute) {
+        const firstTurn = this.turnFiles(task, "0001");
+        if (await pathExists(firstTurn.metaPath)) {
+            return;
+        }
+        const userRequestPath = join(task.dir, "user-request.md");
+        if (!(await pathExists(userRequestPath))) {
+            return;
+        }
+        const request = (await readTextIfExists(userRequestPath)).trim();
+        if (!request) {
+            return;
+        }
+        const route = (await pathExists(task.routePath))
+            ? await readJson(task.routePath, RouteDecisionSchema)
+            : fallbackRoute;
+        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
+        await this.writeTurn(task, "0001", request, route, meta ? new Date(meta.created_at) : this.now());
+    }
+    async writeTurn(task, turnId, request, route, createdAt) {
+        const files = this.turnFiles(task, turnId);
+        const turnMeta = {
+            task_id: task.id,
+            turn_id: turnId,
+            created_at: createdAt.toISOString(),
+            request_path: `turns/${turnId}/user.md`
+        };
+        await ensureDir(files.dir);
+        await writeText(files.userPath, `${request.trim()}\n`);
+        await writeJson(files.routePath, RouteDecisionSchema.parse(route));
+        await writeJson(files.metaPath, TurnMetaSchema.parse(turnMeta));
+        await this.index?.upsertTurn(task.id, turnMeta);
+        return files;
+    }
+    turnFiles(task, turnId) {
+        const dir = join(task.dir, "turns", turnId);
+        return {
+            turnId,
+            dir,
+            metaPath: join(dir, "turn.json"),
+            userPath: join(dir, "user.md"),
+            routePath: join(dir, "route.json")
+        };
+    }
+    taskIdFromWorkerDir(workerDir) {
+        return basename(dirname(workerDir));
+    }
+    async clearWorkerArtifacts(dir, role) {
+        const files = role === "actor"
+            ? ["worklog.md", "patch.diff"]
+            : role === "critic"
+                ? ["review.md"]
+                : [];
+        for (const file of files) {
+            await writeText(join(dir, file), "");
+        }
+    }
+}
+function titleFromRequest(request) {
+    const firstLine = request.trim().split("\n")[0] ?? "Untitled task";
+    return firstLine.length > 80 ? `${firstLine.slice(0, 77)}...` : firstLine;
+}