parallel-codex-tui 0.1.3 → 0.1.5

package/dist/core/config.js

@@ -1,7 +1,10 @@
-import { parse, stringify } from "@iarna/toml";
+import { parse } from "@iarna/toml";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
+import { EngineNameSchema } from "../domain/schemas.js";
 import { pathExists, readTextIfExists, writeText } from "./file-store.js";
+import { normalizeTuiThemeColorValue, normalizeTuiThemeName, TUI_THEME_FIELDS, TUI_THEME_NAMES } from "../tui/theme.js";
 const NativeSessionConfigSchema = z.object({
     enabled: z.boolean().default(true),
     resumeArgs: z.array(z.string()).default([]),
@@ -14,27 +17,92 @@ const WorkerModelConfigSchema = z.object({
     args: z.array(z.string()).default([]),
     env: z.record(z.string()).default({})
 });
+const WorkerCapabilitiesConfigSchema = z.object({
+    profile: z.enum(["codex", "claude", "generic"]),
+    writableDirArgs: z.array(z.string()).default([]),
+    freshSessionArgs: z.array(z.string()).default([])
+}).strict().superRefine((value, context) => {
+    if (value.writableDirArgs.length > 0 && !value.writableDirArgs.some((arg) => arg.includes("{dir}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["writableDirArgs"],
+            message: "writableDirArgs must include a {dir} template"
+        });
+    }
+    if (value.freshSessionArgs.length > 0 && !value.freshSessionArgs.some((arg) => arg.includes("{sessionId}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["freshSessionArgs"],
+            message: "freshSessionArgs must include a {sessionId} template"
+        });
+    }
+});
 const InteractiveCommandSchema = z.object({
     command: z.string().min(1),
-    args: z.array(z.string()).default([])
+    args: z.array(z.string()).default([]),
+    forkArgs: z.array(z.string()).default([])
+}).superRefine((value, context) => {
+    if (value.forkArgs.length > 0 && !value.forkArgs.some((arg) => arg.includes("{sessionId}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["forkArgs"],
+            message: "forkArgs must include a {sessionId} template"
+        });
+    }
 });
 const RolePromptConfigSchema = z.object({
     title: z.string().min(1),
     instructions: z.array(z.string()).default([])
 });
+const TuiColorValueSchema = z.string().min(1).refine((value) => normalizeTuiThemeColorValue(value) !== null, {
+    message: "Invalid TUI color value. Use a Chalk color name, #rgb/#rrggbb, rgb(r,g,b), or ansi256(0..255)."
+}).transform((value) => normalizeTuiThemeColorValue(value) ?? value.trim());
+const TuiThemeNameSchema = z.preprocess((value) => typeof value === "string" ? normalizeTuiThemeName(value) ?? value.trim() : value, z.enum(TUI_THEME_NAMES)).default("codex");
+const UiColorOverridesSchema = z.object(Object.fromEntries(TUI_THEME_FIELDS.map((field) => [field, TuiColorValueSchema.optional()]))).strict().default({});
 const CodexRouterConfigSchema = z.object({
     command: z.string().min(1).default("codex"),
-    args: z.array(z.string()).default(["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"]),
-    timeoutMs: z.number().int().positive().default(120000),
-    fallback: z.enum(["simple", "complex"]).default("complex")
+    args: z.array(z.string()).default([
+        "exec",
+        "--ephemeral",
+        "--ignore-rules",
+        "-c",
+        "model_reasoning_effort=low",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "read-only",
+        "--color",
+        "never",
+        "-"
+    ]),
+    timeoutMs: z.number().int().positive().default(30000),
+    firstOutputTimeoutMs: z.number().int().positive().default(15000),
+    idleTimeoutMs: z.number().int().positive().default(15000),
+    maxOutputBytes: z.number().int().min(1024).max(16 * 1024 * 1024).default(1024 * 1024),
+    maxAttempts: z.number().int().min(1).max(3).default(2),
+    retryDelayMs: z.number().int().min(0).max(10000).default(500),
+    followUpTimeoutMs: z.number().int().positive().max(120000).default(20000),
+    fallback: z.enum(["simple", "complex"]).default("simple"),
+    env: z.record(z.string()).default({})
 });
+const OrchestrationConfigSchema = z.object({
+    maxParallelFeatures: z.number().int().min(1).max(8),
+    maxRevisionRounds: z.number().int().min(1).max(10)
+}).strict();
+const UiConfigSchema = z.object({
+    showStatusBar: z.boolean(),
+    autoOpenFailedWorker: z.boolean(),
+    theme: TuiThemeNameSchema,
+    colors: UiColorOverridesSchema
+}).strict();
 const WorkerCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([]),
+    assignable: z.boolean().default(true),
     timeoutMs: z.number().int().positive().optional(),
     idleTimeoutMs: z.number().int().positive().optional(),
     firstOutputTimeoutMs: z.number().int().positive().optional(),
     model: WorkerModelConfigSchema.default({}),
+    capabilities: WorkerCapabilitiesConfigSchema,
     nativeSession: NativeSessionConfigSchema,
     interactive: InteractiveCommandSchema
 });
@@ -45,16 +113,17 @@ const AppConfigSchema = z.object({
         defaultMode: z.enum(["auto", "simple", "complex"]),
         codex: CodexRouterConfigSchema.default({})
     }),
+    orchestration: OrchestrationConfigSchema,
     workers: z.object({
         codex: WorkerCommandSchema,
         claude: WorkerCommandSchema,
         mock: WorkerCommandSchema
-    }),
+    }).catchall(WorkerCommandSchema),
     pairing: z.object({
-        main: z.enum(["codex", "claude", "mock"]),
-        judge: z.enum(["codex", "claude", "mock"]),
-        actor: z.enum(["codex", "claude", "mock"]),
-        critic: z.enum(["codex", "claude", "mock"])
+        main: EngineNameSchema,
+        judge: EngineNameSchema,
+        actor: EngineNameSchema,
+        critic: EngineNameSchema
     }),
     roles: z.object({
         main: RolePromptConfigSchema,
@@ -62,10 +131,17 @@ const AppConfigSchema = z.object({
         actor: RolePromptConfigSchema,
         critic: RolePromptConfigSchema
     }),
-    ui: z.object({
-        showStatusBar: z.boolean(),
-        autoOpenFailedWorker: z.boolean()
-    })
+    ui: UiConfigSchema
+}).superRefine((config, context) => {
+    for (const [role, workerId] of Object.entries(config.pairing)) {
+        if (!config.workers[workerId]) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["pairing", role],
+                message: `Unknown Worker profile: ${workerId}`
+            });
+        }
+    }
 });
 export function defaultConfig(projectRoot) {
     return {
@@ -75,15 +151,39 @@ export function defaultConfig(projectRoot) {
             defaultMode: "auto",
             codex: {
                 command: "codex",
-                args: ["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"],
-                timeoutMs: 120000,
-                fallback: "complex"
+                args: [
+                    "exec",
+                    "--ephemeral",
+                    "--ignore-rules",
+                    "-c",
+                    "model_reasoning_effort=low",
+                    "--skip-git-repo-check",
+                    "--sandbox",
+                    "read-only",
+                    "--color",
+                    "never",
+                    "-"
+                ],
+                timeoutMs: 30000,
+                firstOutputTimeoutMs: 15000,
+                idleTimeoutMs: 15000,
+                maxOutputBytes: 1024 * 1024,
+                maxAttempts: 2,
+                retryDelayMs: 500,
+                followUpTimeoutMs: 20000,
+                fallback: "simple",
+                env: {}
             }
         },
+        orchestration: {
+            maxParallelFeatures: 3,
+            maxRevisionRounds: 3
+        },
         workers: {
             codex: {
                 command: "codex",
                 args: ["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"],
+                assignable: true,
                 timeoutMs: 45 * 60 * 1000,
                 idleTimeoutMs: 5 * 60 * 1000,
                 firstOutputTimeoutMs: 2 * 60 * 1000,
@@ -93,6 +193,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "codex",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["exec", "resume", "{sessionId}", "--skip-git-repo-check", "-"],
@@ -101,12 +206,14 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "codex",
-                    args: ["resume", "{sessionId}"]
+                    args: ["resume", "{sessionId}"],
+                    forkArgs: ["fork", "{sessionId}"]
                 }
             },
             claude: {
                 command: "claude",
                 args: ["--print", "--permission-mode", "acceptEdits", "--output-format", "text"],
+                assignable: true,
                 timeoutMs: 45 * 60 * 1000,
                 idleTimeoutMs: 5 * 60 * 1000,
                 firstOutputTimeoutMs: 2 * 60 * 1000,
@@ -116,6 +223,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "claude",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: ["--session-id", "{sessionId}"]
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["--print", "--resume", "{sessionId}", "--permission-mode", "acceptEdits", "--output-format", "text"],
@@ -124,18 +236,25 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "claude",
-                    args: ["--resume", "{sessionId}"]
+                    args: ["--resume", "{sessionId}"],
+                    forkArgs: ["--resume", "{sessionId}", "--fork-session"]
                 }
             },
             mock: {
                 command: "mock",
                 args: [],
+                assignable: false,
                 model: {
                     name: "",
                     provider: "",
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "generic",
+                    writableDirArgs: [],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["resume", "{sessionId}", "-"],
@@ -144,7 +263,8 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "mock",
-                    args: ["resume", "{sessionId}"]
+                    args: ["resume", "{sessionId}"],
+                    forkArgs: []
                 }
             }
         },
@@ -174,7 +294,9 @@ export function defaultConfig(projectRoot) {
         },
         ui: {
             showStatusBar: true,
-            autoOpenFailedWorker: true
+            autoOpenFailedWorker: true,
+            theme: "codex",
+            colors: {}
         }
     };
 }
@@ -198,71 +320,18 @@ export async function loadConfig(projectRoot) {
             ...(parsed.router ?? {}),
             codex: {
                 ...base.router.codex,
-                ...(parsed.router?.codex ?? {})
-            }
-        },
-        workers: {
-            codex: {
-                ...base.workers.codex,
-                ...(parsed.workers?.codex ?? {}),
-                model: {
-                    ...base.workers.codex.model,
-                    ...(parsed.workers?.codex?.model ?? {}),
-                    env: {
-                        ...base.workers.codex.model.env,
-                        ...(parsed.workers?.codex?.model?.env ?? {})
-                    }
-                },
-                nativeSession: {
-                    ...base.workers.codex.nativeSession,
-                    ...(parsed.workers?.codex?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.codex.interactive,
-                    ...(parsed.workers?.codex?.interactive ?? {})
-                }
-            },
-            claude: {
-                ...base.workers.claude,
-                ...(parsed.workers?.claude ?? {}),
-                model: {
-                    ...base.workers.claude.model,
-                    ...(parsed.workers?.claude?.model ?? {}),
-                    env: {
-                        ...base.workers.claude.model.env,
-                        ...(parsed.workers?.claude?.model?.env ?? {})
-                    }
-                },
-                nativeSession: {
-                    ...base.workers.claude.nativeSession,
-                    ...(parsed.workers?.claude?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.claude.interactive,
-                    ...(parsed.workers?.claude?.interactive ?? {})
-                }
-            },
-            mock: {
-                ...base.workers.mock,
-                ...(parsed.workers?.mock ?? {}),
-                model: {
-                    ...base.workers.mock.model,
-                    ...(parsed.workers?.mock?.model ?? {}),
-                    env: {
-                        ...base.workers.mock.model.env,
-                        ...(parsed.workers?.mock?.model?.env ?? {})
-                    }
-                },
-                nativeSession: {
-                    ...base.workers.mock.nativeSession,
-                    ...(parsed.workers?.mock?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.mock.interactive,
-                    ...(parsed.workers?.mock?.interactive ?? {})
+                ...(parsed.router?.codex ?? {}),
+                env: {
+                    ...base.router.codex.env,
+                    ...(parsed.router?.codex?.env ?? {})
                 }
             }
         },
+        orchestration: {
+            ...base.orchestration,
+            ...(parsed.orchestration ?? {})
+        },
+        workers: resolveWorkerConfigs(base.workers, parsed.workers ?? {}),
         pairing: {
             ...base.pairing,
             ...(parsed.pairing ?? {})
@@ -287,39 +356,163 @@ export async function loadConfig(projectRoot) {
         },
         ui: {
             ...base.ui,
-            ...(parsed.ui ?? {})
+            ...(parsed.ui ?? {}),
+            colors: {
+                ...base.ui.colors,
+                ...(parsed.ui?.colors ?? {})
+            }
         }
     };
     return AppConfigSchema.parse(merged);
 }
+function resolveWorkerConfigs(builtins, configured) {
+    const resolved = new Map();
+    const resolving = new Set();
+    const ids = [...new Set([...Object.keys(builtins), ...Object.keys(configured)])];
+    const resolve = (id) => {
+        const cached = resolved.get(id);
+        if (cached) {
+            return cached;
+        }
+        if (!EngineNameSchema.safeParse(id).success) {
+            throw new Error(`Invalid Worker profile id: ${id}`);
+        }
+        if (resolving.has(id)) {
+            throw new Error(`Circular Worker profile inheritance: ${[...resolving, id].join(" -> ")}`);
+        }
+        resolving.add(id);
+        try {
+            const override = configured[id] ?? {};
+            const builtin = builtins[id];
+            if (builtin && override.extends) {
+                throw new Error(`Built-in Worker profile ${id} cannot declare extends`);
+            }
+            let parent = builtin;
+            if (!parent) {
+                const parentId = override.extends?.trim();
+                if (!parentId || parentId === "generic") {
+                    parent = genericWorkerConfig(id, override.command);
+                }
+                else {
+                    if (!builtins[parentId] && !configured[parentId]) {
+                        throw new Error(`Unknown Worker profile inherited by ${id}: ${parentId}`);
+                    }
+                    parent = resolve(parentId);
+                }
+            }
+            const worker = mergeWorkerConfig(parent, override);
+            resolved.set(id, worker);
+            return worker;
+        }
+        finally {
+            resolving.delete(id);
+        }
+    };
+    for (const id of ids) {
+        resolve(id);
+    }
+    return Object.fromEntries(resolved);
+}
+function genericWorkerConfig(id, command = id) {
+    return {
+        command,
+        args: [],
+        assignable: true,
+        timeoutMs: 45 * 60 * 1000,
+        idleTimeoutMs: 5 * 60 * 1000,
+        firstOutputTimeoutMs: 2 * 60 * 1000,
+        model: {
+            name: "",
+            provider: "",
+            args: [],
+            env: {}
+        },
+        capabilities: {
+            profile: "generic",
+            writableDirArgs: [],
+            freshSessionArgs: []
+        },
+        nativeSession: {
+            enabled: false,
+            resumeArgs: [],
+            detectSessionId: false,
+            fallback: "fail"
+        },
+        interactive: {
+            command,
+            args: [],
+            forkArgs: []
+        }
+    };
+}
+function mergeWorkerConfig(base, override) {
+    const { extends: _extends, ...values } = override;
+    return {
+        ...base,
+        ...values,
+        model: {
+            ...base.model,
+            ...(override.model ?? {}),
+            env: {
+                ...base.model.env,
+                ...(override.model?.env ?? {})
+            }
+        },
+        capabilities: {
+            ...base.capabilities,
+            ...(override.capabilities ?? {})
+        },
+        nativeSession: {
+            ...base.nativeSession,
+            ...(override.nativeSession ?? {})
+        },
+        interactive: {
+            ...base.interactive,
+            ...(override.interactive ?? {})
+        }
+    };
+}
+export function withUiThemeOverride(config, theme) {
+    if (!theme) {
+        return config;
+    }
+    return {
+        ...config,
+        ui: {
+            ...config.ui,
+            theme
+        }
+    };
+}
 function assertObjectSections(parsed) {
     const sections = [
         ["router", parsed.router],
         ["router.codex", parsed.router?.codex],
+        ["router.codex.env", parsed.router?.codex?.env],
+        ["orchestration", parsed.orchestration],
         ["workers", parsed.workers],
-        ["workers.codex", parsed.workers?.codex],
-        ["workers.codex.model", parsed.workers?.codex?.model],
-        ["workers.codex.model.env", parsed.workers?.codex?.model?.env],
-        ["workers.codex.nativeSession", parsed.workers?.codex?.nativeSession],
-        ["workers.codex.interactive", parsed.workers?.codex?.interactive],
-        ["workers.claude", parsed.workers?.claude],
-        ["workers.claude.model", parsed.workers?.claude?.model],
-        ["workers.claude.model.env", parsed.workers?.claude?.model?.env],
-        ["workers.claude.nativeSession", parsed.workers?.claude?.nativeSession],
-        ["workers.claude.interactive", parsed.workers?.claude?.interactive],
-        ["workers.mock", parsed.workers?.mock],
-        ["workers.mock.model", parsed.workers?.mock?.model],
-        ["workers.mock.model.env", parsed.workers?.mock?.model?.env],
-        ["workers.mock.nativeSession", parsed.workers?.mock?.nativeSession],
-        ["workers.mock.interactive", parsed.workers?.mock?.interactive],
         ["pairing", parsed.pairing],
         ["roles", parsed.roles],
         ["roles.main", parsed.roles?.main],
         ["roles.judge", parsed.roles?.judge],
         ["roles.actor", parsed.roles?.actor],
         ["roles.critic", parsed.roles?.critic],
-        ["ui", parsed.ui]
+        ["ui", parsed.ui],
+        ["ui.colors", parsed.ui?.colors]
     ];
+    if (isPlainObject(parsed.workers)) {
+        for (const [id, value] of Object.entries(parsed.workers)) {
+            sections.push([`workers.${id}`, value]);
+            if (!isPlainObject(value)) {
+                continue;
+            }
+            const worker = value;
+            sections.push([`workers.${id}.model`, worker.model], [`workers.${id}.capabilities`, worker.capabilities], [`workers.${id}.nativeSession`, worker.nativeSession], [`workers.${id}.interactive`, worker.interactive]);
+            if (isPlainObject(worker.model)) {
+                sections.push([`workers.${id}.model.env`, worker.model.env]);
+            }
+        }
+    }
     for (const [path, value] of sections) {
         if (value !== undefined && !isPlainObject(value)) {
             throw new Error(`Invalid config section [${path}]: expected a table`);
@@ -330,13 +523,8 @@ function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 export async function writeDefaultConfig(projectRoot) {
-    const config = defaultConfig(projectRoot);
-    const tomlText = stringify({
-        router: config.router,
-        workers: config.workers,
-        pairing: config.pairing,
-        roles: config.roles,
-        ui: config.ui
-    });
-    await writeText(configPath(projectRoot), tomlText);
+    await writeText(configPath(projectRoot), await readExampleConfig());
+}
+async function readExampleConfig() {
+    return readFile(new URL("../../.parallel-codex/config.example.toml", import.meta.url), "utf8");
 }