parallel-codex-tui 0.2.10 → 0.3.0

package/dist/tui/RoleConfigurationView.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { CONFIGURABLE_ROLES } from "../core/role-configuration.js";
+import { compactEndByDisplayWidth, displayWidth } from "./display-width.js";
+import { roleConfigurationScopeHasOverride, roleConfigurationScopeLabel } from "./role-configuration-state.js";
+import { TUI_THEME } from "./theme.js";
+export function RoleConfigurationView({ height = 20, terminalWidth = process.stdout.columns || 120, ...input }) {
+    const viewportHeight = Math.max(1, Math.trunc(height));
+    const width = Math.max(1, terminalWidth - 2);
+    const lines = roleConfigurationDisplayLines(input, width).slice(0, viewportHeight);
+    const blanks = Math.max(0, viewportHeight - lines.length);
+    return (_jsxs(Box, { flexDirection: "column", height: viewportHeight, children: [lines.map((line, index) => (_jsx(RoleConfigurationRow, { line: line, width: width }, `${line.text}-${index}`))), Array.from({ length: blanks }, (_, index) => (_jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(width) }, `role-config-fill-${index}`)))] }));
+}
+export function roleConfigurationDisplayLines(input, width) {
+    const safeWidth = Math.max(1, Math.trunc(width));
+    const lines = [
+        { text: "Role & model control", tone: "heading" },
+        {
+            text: `scope · ${roleConfigurationScopeLabel(input.scope)}`,
+            tone: input.scope === "task" && !input.hasActiveTask ? "warning" : "accent"
+        }
+    ];
+    if (input.loading || !input.snapshot || !input.draft) {
+        lines.push({ text: "loading role configuration...", tone: "muted" });
+        return lines.map((line) => fittedRoleLine(line, safeWidth));
+    }
+    if (input.scope === "task" && !input.hasActiveTask) {
+        lines.push({ text: "No active Task · choose next request or future requests.", tone: "warning" });
+    }
+    else {
+        lines.push({
+            text: roleConfigurationScopeHasOverride(input.snapshot, input.scope)
+                ? "saved override · Enter updates it · X resets inheritance"
+                : "inheriting defaults · Enter saves this matrix",
+            tone: roleConfigurationScopeHasOverride(input.snapshot, input.scope) ? "success" : "muted"
+        });
+    }
+    lines.push({ text: "", tone: "text" });
+    for (const [index, role] of CONFIGURABLE_ROLES.entries()) {
+        const target = input.draft[role];
+        const provider = input.snapshot.providers.find((candidate) => candidate.id === target.engine);
+        const remote = provider?.modelProvider.trim();
+        const model = target.model.trim() || provider?.model.trim() || "default";
+        const prefix = index === input.selectedRoleIndex ? ">" : " ";
+        const roleLabel = `${role[0]?.toUpperCase() ?? ""}${role.slice(1)}`.padEnd(7, " ");
+        lines.push({
+            text: `${prefix} ${roleLabel} ${target.engine} · ${[remote, model].filter(Boolean).join("/")}`,
+            tone: index === input.selectedRoleIndex ? "accent" : "text",
+            selected: index === input.selectedRoleIndex
+        });
+    }
+    lines.push({ text: "", tone: "text" });
+    const active = input.snapshot.activeTurn;
+    if (active) {
+        lines.push({
+            text: `active turn · ${CONFIGURABLE_ROLES.map((role) => `${role}/${active[role].engine}/${active[role].model || "default"}`).join(" · ")}`,
+            tone: "muted"
+        });
+    }
+    if (input.saving) {
+        lines.push({ text: "saving role configuration...", tone: "warning" });
+    }
+    else if (input.error?.trim()) {
+        lines.push({ text: `error · ${input.error.trim()}`, tone: "danger" });
+    }
+    else if (input.notice?.trim()) {
+        lines.push({ text: input.notice.trim(), tone: "success" });
+    }
+    return lines.map((line) => fittedRoleLine(line, safeWidth));
+}
+function RoleConfigurationRow({ line, width }) {
+    const text = compactEndByDisplayWidth(line.text, width);
+    const trailing = Math.max(0, width - displayWidth(text));
+    const theme = roleConfigurationLineTheme(line.tone, line.selected);
+    return (_jsxs(Text, { children: [_jsx(Text, { ...theme, children: text }), trailing > 0 ? _jsx(Text, { backgroundColor: theme.backgroundColor, children: " ".repeat(trailing) }) : null] }));
+}
+export function roleConfigurationLineTheme(tone, selected = false) {
+    return {
+        backgroundColor: selected ? TUI_THEME.rail : TUI_THEME.surface,
+        color: tone === "heading" || tone === "accent"
+            ? TUI_THEME.accent
+            : tone === "success"
+                ? TUI_THEME.success
+                : tone === "warning"
+                    ? TUI_THEME.warning
+                    : tone === "danger"
+                        ? TUI_THEME.danger
+                        : tone === "muted"
+                            ? TUI_THEME.muted
+                            : TUI_THEME.text,
+        ...(tone === "heading" || tone === "danger" || selected ? { bold: true } : {})
+    };
+}
+function fittedRoleLine(line, width) {
+    return { ...line, text: compactEndByDisplayWidth(line.text, width) };
+}

package/dist/tui/StatusDetailView.js

@@ -25,7 +25,7 @@ export function statusDetailDisplayLines(input, width, height) {
             tone: "muted"
         },
         {
-            text: fitStatusDetailText(rolePairingDetail(input.pairing), safeWidth),
+            text: fitStatusDetailText(rolePairingDetail(input.pairing, input.roleSelection), safeWidth),
             tone: "text"
         }
     ];
@@ -59,15 +59,18 @@ export function statusDetailDisplayLines(input, width, height) {
     }
     return lines.slice(0, maxLines);
 }
-function rolePairingDetail(pairing) {
+function rolePairingDetail(pairing, selection) {
     return [
         "active roles",
-        `main/${pairing.main}`,
-        `judge/${pairing.judge}`,
-        `actor/${pairing.actor}`,
-        `critic/${pairing.critic}`
+        rolePairingEntry("main", selection?.main.engine ?? pairing.main, selection?.main.model),
+        rolePairingEntry("judge", selection?.judge.engine ?? pairing.judge, selection?.judge.model),
+        rolePairingEntry("actor", selection?.actor.engine ?? pairing.actor, selection?.actor.model),
+        rolePairingEntry("critic", selection?.critic.engine ?? pairing.critic, selection?.critic.model)
     ].join(" · ");
 }
+function rolePairingEntry(role, engine, model) {
+    return [role, engine, model?.trim()].filter(Boolean).join("/");
+}
 function taskDetail(input) {
     if (!input.taskId) {
         return "task · none";

package/dist/tui/keyboard.js

@@ -38,6 +38,9 @@ export function isCopyShortcut(input, key) {
 export function isDiagnosticsShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "x") || input === "\u0018";
 }
+export function isRoleConfigurationShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "e") || input === "\u0005";
+}
 export function workerLogJumpKind(input) {
     if (input === "e" || input === "E") {
         return "error";
@@ -80,6 +83,14 @@ export function rawPlainArrowDelta(input) {
     }
     return delta;
 }
+export function rawHorizontalArrowDelta(input) {
+    let delta = 0;
+    for (const match of input.matchAll(/\x1b(?:O([CD])|\[[0-9;?]*([CD]))/g)) {
+        const direction = match[1] ?? match[2];
+        delta += direction === "C" ? 1 : -1;
+    }
+    return delta;
+}
 export function rawChatScrollArrowDelta(input) {
     const delta = rawPlainArrowDelta(input);
     // Alternate-scroll wheels arrive as arrow bursts; one arrow remains a draft-history keypress.

package/dist/tui/role-configuration-state.js

@@ -0,0 +1,74 @@
+import { CONFIGURABLE_ROLES, cloneRoleSelection } from "../core/role-configuration.js";
+const ROLE_CONFIGURATION_SCOPES = ["next", "task", "future"];
+export function roleConfigurationSelectionForScope(snapshot, scope) {
+    if (scope === "future") {
+        return cloneRoleSelection(snapshot.future);
+    }
+    if (scope === "task") {
+        return cloneRoleSelection(snapshot.task ?? snapshot.future);
+    }
+    return cloneRoleSelection(snapshot.next ?? snapshot.future);
+}
+export function roleConfigurationScopeHasOverride(snapshot, scope) {
+    if (!snapshot) {
+        return false;
+    }
+    if (scope === "future") {
+        return !sameRoleSelection(snapshot.future, snapshot.baseline);
+    }
+    return scope === "next" ? snapshot.next !== null : snapshot.task !== null;
+}
+export function nextRoleConfigurationScope(scope, delta, hasTask) {
+    const available = ROLE_CONFIGURATION_SCOPES.filter((candidate) => candidate !== "task" || hasTask);
+    const index = Math.max(0, available.indexOf(scope));
+    return available[((index + delta) % available.length + available.length) % available.length] ?? "next";
+}
+export function moveRoleConfigurationSelection(index, delta) {
+    const length = CONFIGURABLE_ROLES.length;
+    return ((index + delta) % length + length) % length;
+}
+export function selectedConfigurableRole(index) {
+    return CONFIGURABLE_ROLES[Math.max(0, Math.min(CONFIGURABLE_ROLES.length - 1, index))] ?? "main";
+}
+export function cycleRoleProvider(roles, role, providers, delta) {
+    const currentEngine = roles[role].engine;
+    const selectableProviders = providers.filter((provider) => (provider.assignable || provider.id === currentEngine));
+    if (selectableProviders.length === 0) {
+        return cloneRoleSelection(roles);
+    }
+    const currentIndex = selectableProviders.findIndex((provider) => provider.id === currentEngine);
+    const start = currentIndex >= 0 ? currentIndex : 0;
+    const provider = selectableProviders[((start + delta) % selectableProviders.length + selectableProviders.length) % selectableProviders.length] ?? selectableProviders[0];
+    if (!provider) {
+        return cloneRoleSelection(roles);
+    }
+    return {
+        ...cloneRoleSelection(roles),
+        [role]: {
+            engine: provider.id,
+            model: provider.model
+        }
+    };
+}
+export function updateRoleModel(roles, role, model) {
+    return {
+        ...cloneRoleSelection(roles),
+        [role]: {
+            ...roles[role],
+            model
+        }
+    };
+}
+export function sameRoleSelection(left, right) {
+    return CONFIGURABLE_ROLES.every((role) => (left[role].engine === right[role].engine
+        && left[role].model === right[role].model));
+}
+export function roleConfigurationScopeLabel(scope) {
+    if (scope === "next") {
+        return "next request · one shot";
+    }
+    if (scope === "task") {
+        return "current task · retries and follow-ups";
+    }
+    return "future requests · persisted default";
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.2.10";
+export const version = "0.3.0";

package/dist/workers/native-attach.js

@@ -18,7 +18,11 @@ export async function buildNativeForkLaunch(input) {
 async function buildNativeSessionLaunch(input, mode) {
     const workerConfig = workerProvider(input.config, input.worker.engine).config;
     const nativeSession = await readWorkerNativeSession(input.worker, workerConfig.capabilities.profile);
-    const modelConfig = workerConfig.model;
+    const modelConfig = {
+        ...workerConfig.model,
+        name: input.worker.runtimeStatus?.model_name?.trim() || workerConfig.model.name,
+        provider: input.worker.runtimeStatus?.model_provider?.trim() || workerConfig.model.provider
+    };
     const env = modelEnvironment(modelConfig);
     const interactiveArgs = mode === "fork"
         ? workerConfig.interactive.forkArgs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.2.10",
+  "version": "0.3.0",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",