parallel-codex-tui 0.1.0

package/dist/doctor.js

@@ -0,0 +1,121 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { configPath, loadConfig } from "./core/config.js";
+import { pathExists } from "./core/file-store.js";
+export async function runDoctor(appRoot, workspaceRoot, env = process.env) {
+    const lines = ["parallel-codex-tui doctor"];
+    let ok = true;
+    if (isSupportedNodeVersion(process.versions.node)) {
+        lines.push(`Node.js: ok (${process.versions.node})`);
+    }
+    else {
+        ok = false;
+        lines.push(`Node.js: unsupported (${process.versions.node}; need 22.5+)`);
+    }
+    if (await pathExists(workspaceRoot)) {
+        lines.push(`workspace: ok (${workspaceRoot})`);
+    }
+    else {
+        ok = false;
+        lines.push(`workspace: missing (${workspaceRoot})`);
+    }
+    const localConfigPath = configPath(appRoot);
+    if (!(await pathExists(localConfigPath))) {
+        ok = false;
+        lines.push(`config: missing (${localConfigPath}; run parallel-codex-tui --init)`);
+        return {
+            ok,
+            text: `${lines.join("\n")}\n`
+        };
+    }
+    let config;
+    try {
+        config = await loadConfig(appRoot);
+        lines.push(`config: ok (${localConfigPath})`);
+    }
+    catch (error) {
+        ok = false;
+        lines.push(`config: invalid (${localConfigPath}; ${error.message})`);
+        return {
+            ok,
+            text: `${lines.join("\n")}\n`
+        };
+    }
+    for (const command of configuredCommands(config)) {
+        if (await commandExists(command, env)) {
+            lines.push(`${command}: ok`);
+        }
+        else {
+            ok = false;
+            lines.push(`${command}: missing`);
+        }
+    }
+    return {
+        ok,
+        text: `${lines.join("\n")}\n`
+    };
+}
+function isSupportedNodeVersion(version) {
+    const [majorRaw = "0", minorRaw = "0"] = version.split(".");
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = Number.parseInt(minorRaw, 10);
+    return major > 22 || (major === 22 && minor >= 5);
+}
+function configuredCommands(config) {
+    const engines = new Set();
+    if (config.router.defaultMode === "auto") {
+        engines.add("router-codex");
+        engines.add(config.pairing.main);
+        engines.add(config.pairing.judge);
+        engines.add(config.pairing.actor);
+        engines.add(config.pairing.critic);
+    }
+    else if (config.router.defaultMode === "simple") {
+        engines.add(config.pairing.main);
+    }
+    else {
+        engines.add(config.pairing.judge);
+        engines.add(config.pairing.actor);
+        engines.add(config.pairing.critic);
+    }
+    return Array.from(new Set(Array.from(engines)
+        .map((engine) => commandForEngine(config, engine))
+        .filter((command) => Boolean(command) && command !== "mock")));
+}
+function commandForEngine(config, engine) {
+    if (engine === "router-codex") {
+        return config.router.codex.command;
+    }
+    if (engine === "codex") {
+        return config.workers.codex.command;
+    }
+    if (engine === "claude") {
+        return config.workers.claude.command;
+    }
+    return null;
+}
+async function commandExists(command, env) {
+    if (command.includes("/")) {
+        return canExecute(command);
+    }
+    const pathValue = env.PATH ?? "";
+    const extensions = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const dir of pathValue.split(delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            if (await canExecute(join(dir, `${command}${extension}`))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+async function canExecute(path) {
+    try {
+        await access(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/domain/schemas.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+export const RouteModeSchema = z.enum(["simple", "complex"]);
+export const EngineNameSchema = z.enum(["codex", "claude", "mock"]);
+export const WorkerRoleSchema = z.enum(["main", "judge", "actor", "critic"]);
+export const TaskStateSchema = z.enum([
+    "created",
+    "routed",
+    "judging",
+    "ready_for_pair",
+    "actor_running",
+    "critic_running",
+    "revision_needed",
+    "verifying",
+    "done",
+    "failed",
+    "cancelled"
+]);
+export const WorkerStateSchema = z.enum([
+    "idle",
+    "starting",
+    "running",
+    "waiting",
+    "done",
+    "failed",
+    "cancelled"
+]);
+export const RouteDecisionSchema = z.object({
+    mode: RouteModeSchema,
+    reason: z.string().min(1),
+    suggested_roles: z.array(WorkerRoleSchema).default([]),
+    judge_engine: EngineNameSchema.default("codex"),
+    actor_engine: EngineNameSchema.default("codex"),
+    critic_engine: EngineNameSchema.default("claude")
+});
+export const TaskMetaSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    created_at: z.string().datetime(),
+    cwd: z.string().min(1),
+    mode: RouteModeSchema,
+    status: TaskStateSchema
+});
+export const WorkerStatusSchema = z.object({
+    worker_id: z.string().min(1),
+    role: WorkerRoleSchema,
+    engine: EngineNameSchema,
+    state: WorkerStateSchema,
+    phase: z.string().min(1),
+    last_event_at: z.string().datetime(),
+    summary: z.string(),
+    native_session_id: z.string().min(1).optional()
+});
+export const TurnMetaSchema = z.object({
+    task_id: z.string().min(1),
+    turn_id: z.string().regex(/^\d{4}$/),
+    created_at: z.string().datetime(),
+    request_path: z.string().min(1)
+});
+export const NativeSessionSourceSchema = z.enum(["output-detected", "config", "manual", "claude-project-log", "unknown"]);
+export const NativeSessionSchema = z.object({
+    engine: EngineNameSchema,
+    role: WorkerRoleSchema,
+    worker_id: z.string().min(1),
+    session_id: z.string().min(1),
+    scope: z.literal("task"),
+    cwd: z.string().min(1),
+    created_at: z.string().datetime(),
+    last_used_at: z.string().datetime(),
+    source: NativeSessionSourceSchema
+});
+export const EventRecordSchema = z.object({
+    time: z.string().datetime(),
+    type: z.string().min(1),
+    message: z.string().optional(),
+    worker: z.string().optional(),
+    engine: EngineNameSchema.optional(),
+    task_id: z.string().optional()
+});

package/dist/orchestrator/collaboration-channel.js

@@ -0,0 +1,103 @@
+import { join } from "node:path";
+import { appendJsonLine, ensureDir, writeJson, writeText } from "../core/file-store.js";
+export async function createFeatureChannel(input) {
+    const id = featureIdForTurn(input.turn, input.request);
+    const dir = join(input.task.dir, "features", id);
+    const dialoguePath = join(input.task.dir, "dialogue", "actor-critic.jsonl");
+    const channel = {
+        id,
+        taskId: input.task.id,
+        turnId: input.turn.turnId,
+        dir,
+        specPath: join(dir, "spec.md"),
+        statusPath: join(dir, "status.json"),
+        dialoguePath,
+        actorWorklogPath: join(dir, "actor-worklog.md"),
+        actorRepliesPath: join(dir, "actor-replies.jsonl"),
+        criticFindingsPath: join(dir, "critic-findings.jsonl"),
+        decisionsPath: join(dir, "decisions.md")
+    };
+    await ensureDir(dir);
+    await ensureDir(join(input.task.dir, "dialogue"));
+    await writeText(channel.specPath, buildFeatureSpec(input, channel));
+    await writeText(channel.actorWorklogPath, "");
+    await writeText(channel.actorRepliesPath, "");
+    await writeText(channel.criticFindingsPath, "");
+    await updateFeatureStatus(channel, "created");
+    await appendFeatureDialogue(channel, "feature.created", "actor", "Feature mailbox created for the current turn.");
+    return channel;
+}
+export function featurePromptContext(channel) {
+    return {
+        featureId: channel.id,
+        featureDir: channel.dir,
+        dialoguePath: channel.dialoguePath,
+        actorWorklogPath: channel.actorWorklogPath,
+        actorRepliesPath: channel.actorRepliesPath,
+        criticFindingsPath: channel.criticFindingsPath,
+        decisionsPath: channel.decisionsPath
+    };
+}
+export async function updateFeatureStatus(channel, state) {
+    await writeJson(channel.statusPath, {
+        feature_id: channel.id,
+        task_id: channel.taskId,
+        turn_id: channel.turnId,
+        state,
+        updated_at: new Date().toISOString()
+    });
+}
+export async function appendFeatureDialogue(channel, type, role, message, paths = {}) {
+    await appendJsonLine(channel.dialoguePath, {
+        time: new Date().toISOString(),
+        feature_id: channel.id,
+        turn_id: channel.turnId,
+        type,
+        role,
+        message,
+        paths
+    });
+}
+export async function writeFeatureDecision(channel, summary) {
+    await writeText(channel.decisionsPath, [
+        "# Decisions",
+        "",
+        `Feature: ${channel.id}`,
+        `Turn: ${channel.turnId}`,
+        "",
+        "Supervisor summary:",
+        summary.trim() || "(empty)",
+        ""
+    ].join("\n"));
+}
+function buildFeatureSpec(input, channel) {
+    return [
+        "# Feature Mailbox",
+        "",
+        `Feature: ${channel.id}`,
+        `Task: ${input.task.id}`,
+        `Turn: ${input.turn.turnId}`,
+        `Turn directory: ${input.turn.dir}`,
+        `Judge directory: ${input.judgeDir}`,
+        "",
+        "User request:",
+        input.request.trim(),
+        "",
+        "Protocol:",
+        "- Actor writes implementation notes to actor-worklog.md.",
+        "- Critic writes one JSON object per blocking issue to critic-findings.jsonl.",
+        "- Actor replies to each critic finding in actor-replies.jsonl.",
+        "- Supervisor writes the final decision summary to decisions.md.",
+        ""
+    ].join("\n");
+}
+function featureIdForTurn(turn, request) {
+    const slug = request
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48)
+        .replace(/-+$/g, "");
+    return slug ? `${turn.turnId}-${slug}` : turn.turnId;
+}