parallel-codex-tui 0.1.0 → 0.1.4

package/dist/cli-args.js

@@ -1,26 +1,108 @@
 import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { normalizeTuiThemeName, TUI_THEME_NAMES } from "./tui/theme.js";
+import { TaskIdSchema } from "./domain/schemas.js";
+const allowedValueOptions = new Set(["--app-root", "--workspace", "-w", "--task", "-t", "--theme"]);
+const allowedBooleanOptions = new Set(["--doctor", "--help", "-h", "--init", "--probe-agents", "--probe-router", "--themes", "--version", "-v"]);
 export function parseCliArgs(args, cwd) {
-    const appRootFlagIndex = args.findIndex((arg) => arg === "--app-root");
-    const workspaceFlagIndex = args.findIndex((arg) => arg === "--workspace" || arg === "-w");
-    const taskFlagIndex = args.findIndex((arg) => arg === "--task" || arg === "-t");
-    const doctor = args.includes("--doctor");
-    const help = args.includes("--help") || args.includes("-h");
-    const init = args.includes("--init");
-    const version = args.includes("--version") || args.includes("-v");
-    const appRoot = appRootFlagIndex >= 0 && args[appRootFlagIndex + 1]
-        ? resolve(cwd, args[appRootFlagIndex + 1])
-        : cwd;
-    const workspaceRoot = workspaceFlagIndex >= 0 && args[workspaceFlagIndex + 1]
-        ? resolve(cwd, args[workspaceFlagIndex + 1])
-        : cwd;
-    const taskId = taskFlagIndex >= 0 && args[taskFlagIndex + 1] ? args[taskFlagIndex + 1] : null;
+    const optionArgs = argsBeforeTerminator(args);
+    const appRootFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--app-root" || arg.startsWith("--app-root="));
+    const workspaceFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--workspace" || arg.startsWith("--workspace=") || arg === "-w" || arg.startsWith("-w="));
+    const taskFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--task" || arg.startsWith("--task=") || arg === "-t" || arg.startsWith("-t="));
+    const themeFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--theme" || arg.startsWith("--theme="));
+    const doctor = optionArgs.includes("--doctor");
+    const help = optionArgs.includes("--help") || optionArgs.includes("-h");
+    const init = optionArgs.includes("--init");
+    const probeAgents = optionArgs.includes("--probe-agents");
+    const probeRouter = optionArgs.includes("--probe-router");
+    const themes = optionArgs.includes("--themes");
+    const version = optionArgs.includes("--version") || optionArgs.includes("-v");
+    const appRootValue = flagValue(optionArgs, appRootFlagIndex);
+    const appRoot = appRootValue ? resolvePathArg(cwd, appRootValue) : cwd;
+    const explicitWorkspace = flagValue(optionArgs, workspaceFlagIndex);
+    const workspaceRoot = explicitWorkspace ? resolvePathArg(cwd, explicitWorkspace) : cwd;
+    const taskId = flagValue(optionArgs, taskFlagIndex);
+    const theme = cliThemeValue(flagValue(optionArgs, themeFlagIndex));
     return {
         appRoot,
         doctor,
+        explicitWorkspace,
         help,
         init,
+        probeAgents,
+        probeRouter,
         workspaceRoot,
         taskId,
+        theme,
+        themes,
         version
     };
 }
+function resolvePathArg(cwd, value) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return resolve(cwd, value);
+}
+export function validateCliArgs(args) {
+    const errors = [];
+    const optionArgs = argsBeforeTerminator(args);
+    for (const arg of optionArgs) {
+        if (!arg.startsWith("-") || arg === "-") {
+            continue;
+        }
+        if (allowedBooleanOptions.has(arg) || allowedValueOptions.has(arg)) {
+            continue;
+        }
+        const equalsIndex = arg.indexOf("=");
+        const optionName = equalsIndex >= 0 ? arg.slice(0, equalsIndex) : arg;
+        if (allowedValueOptions.has(optionName)) {
+            continue;
+        }
+        errors.push(`Unknown option: ${arg}`);
+    }
+    const themeFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--theme" || arg.startsWith("--theme="));
+    const rawThemeValue = flagValue(optionArgs, themeFlagIndex);
+    if (rawThemeValue?.trim() && !normalizeTuiThemeName(rawThemeValue)) {
+        errors.push(`Invalid --theme: ${rawThemeValue.trim()} (expected ${TUI_THEME_NAMES.join(", ")})`);
+    }
+    const taskFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--task" || arg.startsWith("--task=") || arg === "-t" || arg.startsWith("-t="));
+    const rawTaskId = flagValue(optionArgs, taskFlagIndex);
+    if (rawTaskId && !TaskIdSchema.safeParse(rawTaskId).success) {
+        errors.push("Invalid --task: expected task- followed by letters, numbers, dot, underscore, or hyphen");
+    }
+    if (optionArgs.includes("--probe-router") && !optionArgs.includes("--doctor")) {
+        errors.push("--probe-router requires --doctor");
+    }
+    if (optionArgs.includes("--probe-agents") && !optionArgs.includes("--doctor")) {
+        errors.push("--probe-agents requires --doctor");
+    }
+    return errors;
+}
+function argsBeforeTerminator(args) {
+    const terminatorIndex = args.indexOf("--");
+    return terminatorIndex >= 0 ? args.slice(0, terminatorIndex) : args;
+}
+function lastFlagIndex(args, predicate) {
+    for (let index = args.length - 1; index >= 0; index -= 1) {
+        if (predicate(args[index] ?? "")) {
+            return index;
+        }
+    }
+    return -1;
+}
+function flagValue(args, flagIndex) {
+    const flag = flagIndex >= 0 ? args[flagIndex] : null;
+    const inlineMatch = flag?.match(/^-{1,2}[^=]+=(.*)$/);
+    if (inlineMatch) {
+        return inlineMatch[1] || null;
+    }
+    const value = flagIndex >= 0 ? args[flagIndex + 1] : null;
+    return value && !value.startsWith("-") ? value : null;
+}
+function cliThemeValue(value) {
+    return normalizeTuiThemeName(value);
+}

package/dist/cli-help.js

@@ -0,0 +1,20 @@
+import { TUI_THEME_NAMES } from "./tui/theme.js";
+export function buildCliHelpText(themeNames = TUI_THEME_NAMES) {
+    return `Usage: parallel-codex-tui [options]
+
+Options:
+  -w, --workspace <path>  Project workspace for worker sessions and edits
+      --app-root <path>   App root for configuration lookup
+  -t, --task <id>         Open an existing task session
+      --theme <name>      Temporarily use a TUI theme: ${themeNames.join(", ")}
+      --themes            List built-in TUI theme palettes; combine with --theme to filter
+      --init              Write .parallel-codex/config.toml if missing
+      --doctor            Check config, agent commands, and theme palette preview
+      --probe-agents      With --doctor, run fresh + resume probes (uses model quota)
+      --probe-router      With --doctor, run one live Codex Router request
+  -v, --version           Print the current version
+  -h, --help              Print this help message
+
+Options with values also accept --name=value and -x=value forms.`;
+}
+export const helpText = buildCliHelpText();

package/dist/cli-startup-recovery.js

@@ -0,0 +1,70 @@
+export function startupRecoveryMessages(recoveredTasks, activeTaskId, pendingTaskCreations) {
+    return [
+        ...interruptedTaskRecoveryMessages(recoveredTasks, activeTaskId),
+        ...pendingTaskCreationMessages(pendingTaskCreations)
+    ];
+}
+function interruptedTaskRecoveryMessages(recoveredTasks, activeTaskId) {
+    if (recoveredTasks.length === 0) {
+        return [];
+    }
+    const active = activeTaskId
+        ? recoveredTasks.find((recovery) => recovery.taskId === activeTaskId)
+        : null;
+    if (active) {
+        const restoredTurns = restoredTurnCount(active);
+        const archived = archivedTurnDetail(active);
+        if (restoredTurns > 0) {
+            return [{
+                    from: "system",
+                    text: `Recovered ${restoredTurns === 1 ? "follow-up turn" : `${restoredTurns} follow-up turns`} #${compactStartupTaskId(active.taskId)} · request and route kept${archived} · checkpoints kept · Ctrl+R resume`
+                }];
+        }
+        if (active.previousState === "done") {
+            return [{
+                    from: "system",
+                    text: `Recovered incomplete task #${compactStartupTaskId(active.taskId)} · completion evidence missing${archived} · checkpoints kept · Ctrl+R rebuild`
+                }];
+        }
+        const workerLabel = `${active.workersRecovered} ${active.workersRecovered === 1 ? "worker" : "workers"}`;
+        return [{
+                from: "system",
+                text: `Recovered interrupted task #${compactStartupTaskId(active.taskId)} · ${workerLabel} stopped${archived} · checkpoints kept · Ctrl+R resume`
+            }];
+    }
+    const restoredTurns = recoveredTasks.reduce((total, recovery) => total + restoredTurnCount(recovery), 0);
+    const turnDetail = restoredTurns > 0
+        ? ` · ${restoredTurns} ${restoredTurns === 1 ? "turn" : "turns"} restored`
+        : "";
+    return [{
+            from: "system",
+            text: `Recovered ${recoveredTasks.length} interrupted ${recoveredTasks.length === 1 ? "task" : "tasks"}${turnDetail} · checkpoints kept · Ctrl+T inspect`
+        }];
+}
+function pendingTaskCreationMessages(recovery) {
+    if (!recovery || (recovery.abandoned === 0 && recovery.active === 0)) {
+        return [];
+    }
+    const details = [];
+    if (recovery.abandoned > 0) {
+        details.push(`${recovery.abandoned} incomplete task ${recovery.abandoned === 1 ? "creation" : "creations"} archived`);
+    }
+    if (recovery.active > 0) {
+        details.push(`${recovery.active} task ${recovery.active === 1 ? "creation" : "creations"} active in another TUI`);
+    }
+    return [{
+            from: "system",
+            text: `Startup cleanup · ${details.join(" · ")}`
+        }];
+}
+function restoredTurnCount(recovery) {
+    return (recovery.turnsPublished ?? 0) + (recovery.turnsRepaired ?? 0);
+}
+function archivedTurnDetail(recovery) {
+    const count = recovery.turnsAbandoned ?? 0;
+    return count > 0 ? ` · ${count} ${count === 1 ? "fragment" : "fragments"} archived` : "";
+}
+function compactStartupTaskId(taskId) {
+    const parts = taskId.split("-");
+    return parts.length > 2 ? parts.slice(-2).join("-") : taskId;
+}

package/dist/cli-workspace-picker.js

@@ -0,0 +1,330 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { basename } from "node:path";
+import { Box, Text, render, useInput } from "ink";
+import { resolveWorkspacePath } from "./core/workspace.js";
+import { compactEndByDisplayWidth, compactTailByDisplayWidth, displayWidth } from "./tui/display-width.js";
+import { TUI_THEME } from "./tui/theme.js";
+const WORKSPACE_SHORTCUT_DELAY_MS = 500;
+export class WorkspaceSelectionCancelledError extends Error {
+    constructor() {
+        super("Workspace selection cancelled.");
+        this.name = "WorkspaceSelectionCancelledError";
+    }
+}
+export async function promptForWorkspaceTui(input) {
+    let resolveSelection = () => undefined;
+    let rejectSelection = () => undefined;
+    const selection = new Promise((resolve, reject) => {
+        resolveSelection = resolve;
+        rejectSelection = reject;
+    });
+    const cancelSelection = () => rejectSelection(new WorkspaceSelectionCancelledError());
+    let instance = null;
+    process.on("SIGINT", cancelSelection);
+    try {
+        instance = render(_jsx(WorkspacePicker, { cwd: input.cwd, choices: input.choices, invalidExplicitWorkspace: input.invalidExplicitWorkspace, terminalHeight: input.stdout.rows ?? 24, terminalWidth: input.stdout.columns ?? 80, onCancel: cancelSelection, onSelect: resolveSelection }), {
+            stdin: input.stdin,
+            stdout: input.stdout,
+            stderr: input.stdout,
+            exitOnCtrlC: false,
+            patchConsole: false
+        });
+        void instance.waitUntilExit().catch((error) => {
+            rejectSelection(error instanceof Error ? error : new Error(String(error)));
+        });
+        return await selection;
+    }
+    finally {
+        process.off("SIGINT", cancelSelection);
+        instance?.clear();
+        instance?.unmount();
+    }
+}
+export function WorkspacePicker({ cwd, choices, invalidExplicitWorkspace, terminalHeight, terminalWidth, onCancel, onSelect }) {
+    const options = useMemo(() => workspacePickerOptions(choices, invalidExplicitWorkspace), [choices, invalidExplicitWorkspace]);
+    const defaultWorkspace = invalidExplicitWorkspace?.reason === "missing"
+        ? invalidExplicitWorkspace.path
+        : null;
+    const [mode, setMode] = useState(options.some((option) => option.kind === "workspace") ? "list" : "path");
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [pathValue, setPathValue] = useState("");
+    const [openingPath, setOpeningPath] = useState(null);
+    const pathValueRef = useRef("");
+    const settledRef = useRef(false);
+    const shortcutBufferRef = useRef("");
+    const shortcutTimerRef = useRef(null);
+    const width = Math.max(1, terminalWidth - 1);
+    const visibleRows = Math.max(1, Math.min(9, terminalHeight - (invalidExplicitWorkspace ? 7 : 6)));
+    const visible = workspacePickerWindow(options, selectedIndex, visibleRows);
+    const contentRows = 1
+        + (invalidExplicitWorkspace ? 1 : 0)
+        + 1
+        + (mode === "list" ? visible.items.length + 1 : 2);
+    const trailingRows = Math.max(0, terminalHeight - contentRows);
+    useEffect(() => () => {
+        if (shortcutTimerRef.current) {
+            clearTimeout(shortcutTimerRef.current);
+        }
+    }, []);
+    function clearShortcutBuffer() {
+        shortcutBufferRef.current = "";
+        if (shortcutTimerRef.current) {
+            clearTimeout(shortcutTimerRef.current);
+            shortcutTimerRef.current = null;
+        }
+    }
+    function finish(value) {
+        if (settledRef.current) {
+            return;
+        }
+        settledRef.current = true;
+        clearShortcutBuffer();
+        setOpeningPath(value);
+        onSelect(value);
+    }
+    function replacePathValue(value) {
+        pathValueRef.current = value;
+        setPathValue(value);
+    }
+    function submitPath(value) {
+        const requested = value.trim() || defaultWorkspace || cwd;
+        finish(resolveWorkspacePath(cwd, requested));
+    }
+    function openOption(option) {
+        clearShortcutBuffer();
+        if (!option || option.kind === "new" || !option.path) {
+            replacePathValue("");
+            setMode("path");
+            return;
+        }
+        finish(option.path);
+    }
+    function selectNumericShortcut(digits) {
+        const candidate = `${shortcutBufferRef.current}${digits}`;
+        const exactIndex = options.findIndex((option) => option.shortcut === candidate);
+        const hasLonger = options.some((option) => (option.shortcut.length > candidate.length && option.shortcut.startsWith(candidate)));
+        if (exactIndex < 0 && !hasLonger) {
+            clearShortcutBuffer();
+            return;
+        }
+        shortcutBufferRef.current = candidate;
+        if (exactIndex >= 0) {
+            setSelectedIndex(exactIndex);
+        }
+        if (exactIndex >= 0 && !hasLonger) {
+            openOption(options[exactIndex]);
+            return;
+        }
+        if (shortcutTimerRef.current) {
+            clearTimeout(shortcutTimerRef.current);
+        }
+        shortcutTimerRef.current = setTimeout(() => {
+            const pending = shortcutBufferRef.current;
+            clearShortcutBuffer();
+            openOption(options.find((option) => option.shortcut === pending));
+        }, WORKSPACE_SHORTCUT_DELAY_MS);
+    }
+    useInput((input, key) => {
+        if (settledRef.current) {
+            return;
+        }
+        const inputHasReturn = /[\r\n]/.test(input);
+        const printableInput = input.replace(/[\u0000-\u001f\u007f]/g, "");
+        if (key.ctrl && input.toLowerCase() === "c") {
+            if (!settledRef.current) {
+                settledRef.current = true;
+                onCancel();
+            }
+            return;
+        }
+        if (mode === "path") {
+            clearShortcutBuffer();
+            if (key.escape) {
+                if (options.some((option) => option.kind === "workspace")) {
+                    setMode("list");
+                }
+                else {
+                    onCancel();
+                }
+                return;
+            }
+            if (key.return) {
+                submitPath(pathValueRef.current);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                replacePathValue(Array.from(pathValueRef.current).slice(0, -1).join(""));
+                return;
+            }
+            if (key.ctrl && input.toLowerCase() === "u") {
+                replacePathValue("");
+                return;
+            }
+            if (!key.ctrl && !key.meta) {
+                const nextValue = `${pathValueRef.current}${printableInput}`;
+                if (inputHasReturn) {
+                    submitPath(nextValue);
+                }
+                else if (printableInput) {
+                    replacePathValue(nextValue);
+                }
+            }
+            return;
+        }
+        if (key.escape) {
+            clearShortcutBuffer();
+            onCancel();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            clearShortcutBuffer();
+            setSelectedIndex((current) => (current - 1 + options.length) % options.length);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            clearShortcutBuffer();
+            setSelectedIndex((current) => (current + 1) % options.length);
+            return;
+        }
+        if (key.return) {
+            const pending = shortcutBufferRef.current;
+            if (pending) {
+                clearShortcutBuffer();
+                openOption(options.find((option) => option.shortcut === pending));
+                return;
+            }
+            openOption(options[selectedIndex]);
+            return;
+        }
+        const newPath = printableInput.match(/^n(?:ew)?\s+(.+)$/i)?.[1]?.trim();
+        if (newPath) {
+            submitPath(newPath);
+            return;
+        }
+        if (/^n(?:ew)?$/i.test(printableInput)) {
+            clearShortcutBuffer();
+            replacePathValue("");
+            setMode("path");
+            return;
+        }
+        if (/^\d+$/.test(printableInput)) {
+            selectNumericShortcut(printableInput);
+            return;
+        }
+        if (printableInput) {
+            clearShortcutBuffer();
+            if (inputHasReturn) {
+                submitPath(printableInput);
+            }
+            else {
+                replacePathValue(printableInput);
+                setMode("path");
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(WorkspacePickerHeader, { width: width }), invalidExplicitWorkspace ? (_jsx(WorkspacePickerNotice, { invalid: invalidExplicitWorkspace, width: width })) : null, _jsx(WorkspacePickerTitle, { count: choices.length, mode: mode, openingPath: openingPath, width: width }), mode === "list" ? (_jsxs(_Fragment, { children: [visible.items.map(({ option, index }) => (_jsx(WorkspacePickerOptionRow, { option: option, selected: index === selectedIndex, width: width }, `${option.kind}-${option.path ?? "new"}`))), _jsx(WorkspacePickerFooter, { text: openingPath
+                            ? workspacePickerOpeningStatus(openingPath)
+                            : workspacePickerListStatus(selectedIndex, options.length), width: width })] })) : (_jsxs(_Fragment, { children: [_jsx(WorkspacePickerPathRow, { defaultWorkspace: defaultWorkspace ?? cwd, locked: Boolean(openingPath), value: pathValue, width: width }), _jsx(WorkspacePickerFooter, { text: openingPath
+                            ? workspacePickerOpeningStatus(openingPath)
+                            : choices.length > 0 ? `${choices.length} recent` : "new workspace", width: width })] })), Array.from({ length: trailingRows }, (_, index) => (_jsx(FilledText, { text: "", width: width, backgroundColor: TUI_THEME.surface, color: TUI_THEME.text }, `workspace-fill-${index}`)))] }));
+}
+function WorkspacePickerHeader({ width }) {
+    const fullBrand = " parallel-codex-tui";
+    const fullSection = " · workspace";
+    const brand = width >= displayWidth(`${fullBrand}${fullSection}`)
+        ? fullBrand
+        : width >= 9 ? " pct" : compactEndByDisplayWidth("pct", width);
+    const section = width >= displayWidth(`${brand}${fullSection}`)
+        ? fullSection
+        : width >= displayWidth(`${brand} · ws`) ? " · ws" : "";
+    const fill = Math.max(0, width - displayWidth(brand) - displayWidth(section));
+    return (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: TUI_THEME.chrome, color: TUI_THEME.accent, bold: true, children: brand }), _jsx(Text, { backgroundColor: TUI_THEME.chrome, color: TUI_THEME.muted, children: section }), _jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " ".repeat(fill) })] }));
+}
+function WorkspacePickerNotice({ invalid, width }) {
+    const label = invalid.reason === "missing" ? "Workspace does not exist" : "Workspace is not a directory";
+    const text = compactEndByDisplayWidth(` ${label}: ${invalid.path}`, width);
+    return _jsx(FilledText, { text: text, width: width, backgroundColor: TUI_THEME.dangerSurface, color: TUI_THEME.danger });
+}
+function WorkspacePickerTitle({ count, mode, openingPath, width }) {
+    const rawLabel = openingPath ? " Opening project" : mode === "list" ? " Open project" : " Workspace path";
+    const rawMeta = !openingPath && mode === "list" && count > 0 ? `  ${count} recent` : "";
+    const label = compactEndByDisplayWidth(rawLabel, width);
+    const meta = displayWidth(label) + displayWidth(rawMeta) <= width ? rawMeta : "";
+    const fill = Math.max(0, width - displayWidth(label) - displayWidth(meta));
+    return (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: TUI_THEME.surface, color: TUI_THEME.text, bold: true, children: label }), _jsx(Text, { backgroundColor: TUI_THEME.surface, color: TUI_THEME.muted, children: meta }), _jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(fill) })] }));
+}
+function WorkspacePickerOptionRow({ option, selected, width }) {
+    const backgroundColor = selected ? TUI_THEME.rail : TUI_THEME.surface;
+    const rawName = option.kind === "new" ? "New project" : basename(option.path ?? "") || option.path || "workspace";
+    if (width < 12) {
+        return (_jsx(FilledText, { text: `${selected ? ">" : " "} ${rawName}`, width: width, backgroundColor: backgroundColor, color: selected ? TUI_THEME.accent : TUI_THEME.text }));
+    }
+    const indicator = selected ? " > " : "   ";
+    const shortcut = `${option.shortcut.padStart(2)} `;
+    const status = option.kind === "workspace" && !option.exists && width >= 20 ? " new" : "";
+    const fixedWidth = displayWidth(indicator) + displayWidth(shortcut) + displayWidth(status);
+    const showPath = option.kind === "workspace" && width >= 46;
+    const nameBudget = Math.max(4, Math.min(24, width - fixedWidth - (showPath ? 14 : 0)));
+    const name = compactEndByDisplayWidth(rawName, nameBudget);
+    const pathBudget = Math.max(0, width - fixedWidth - displayWidth(name) - (showPath ? 2 : 0));
+    const path = showPath ? compactTailByDisplayWidth(option.path ?? "", pathBudget) : "";
+    const gap = path ? "  " : "";
+    const used = displayWidth(indicator) + displayWidth(shortcut) + displayWidth(name) + displayWidth(gap) + displayWidth(path) + displayWidth(status);
+    const fill = Math.max(0, width - used);
+    return (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: backgroundColor, color: selected ? TUI_THEME.accent : TUI_THEME.muted, bold: selected, children: indicator }), _jsx(Text, { backgroundColor: backgroundColor, color: TUI_THEME.muted, children: shortcut }), _jsx(Text, { backgroundColor: backgroundColor, color: TUI_THEME.text, bold: selected, children: name }), gap ? _jsx(Text, { backgroundColor: backgroundColor, children: gap }) : null, path ? _jsx(Text, { backgroundColor: backgroundColor, color: TUI_THEME.muted, children: path }) : null, status ? _jsx(Text, { backgroundColor: backgroundColor, color: TUI_THEME.warning, children: status }) : null, fill > 0 ? _jsx(Text, { backgroundColor: backgroundColor, children: " ".repeat(fill) }) : null] }));
+}
+function WorkspacePickerPathRow({ defaultWorkspace, locked, value, width }) {
+    if (width < 4) {
+        return _jsx(FilledText, { text: locked ? "·" : "|", width: width, backgroundColor: TUI_THEME.rail, color: locked ? TUI_THEME.muted : TUI_THEME.accent });
+    }
+    const prefix = locked ? "   " : " > ";
+    const cursor = locked ? "" : "|";
+    const valueWidth = Math.max(1, width - displayWidth(prefix) - displayWidth(cursor));
+    const visibleValue = value
+        ? compactTailByDisplayWidth(value, valueWidth)
+        : compactTailByDisplayWidth(defaultWorkspace, valueWidth);
+    const valueColor = value ? TUI_THEME.text : TUI_THEME.muted;
+    const used = displayWidth(prefix) + displayWidth(visibleValue) + displayWidth(cursor);
+    const fill = Math.max(0, width - used);
+    return (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: locked ? TUI_THEME.muted : TUI_THEME.accent, bold: !locked, children: prefix }), _jsx(Text, { backgroundColor: TUI_THEME.rail, color: valueColor, children: visibleValue }), cursor ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: cursor }) : null, fill > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.rail, children: " ".repeat(fill) }) : null] }));
+}
+function WorkspacePickerFooter({ text, width }) {
+    return _jsx(FilledText, { text: ` ${text}`, width: width, backgroundColor: TUI_THEME.chrome, color: TUI_THEME.muted });
+}
+function FilledText({ backgroundColor, color, text, width }) {
+    const visible = compactEndByDisplayWidth(text, width);
+    const fill = Math.max(0, width - displayWidth(visible));
+    return (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: backgroundColor, color: color, children: visible }), fill > 0 ? _jsx(Text, { backgroundColor: backgroundColor, children: " ".repeat(fill) }) : null] }));
+}
+function workspacePickerOptions(choices, invalidExplicitWorkspace) {
+    const explicit = invalidExplicitWorkspace?.reason === "missing" ? invalidExplicitWorkspace.path : null;
+    const options = [];
+    if (explicit && !choices.some((choice) => choice.path === explicit)) {
+        options.push({ kind: "workspace", shortcut: "+", path: explicit, exists: false });
+    }
+    options.push(...choices.map((choice, index) => ({
+        kind: "workspace",
+        shortcut: String(index + 1),
+        path: choice.path,
+        exists: choice.exists
+    })));
+    options.push({ kind: "new", shortcut: "n", path: null, exists: false });
+    return options;
+}
+function workspacePickerWindow(options, selectedIndex, limit) {
+    const maxStart = Math.max(0, options.length - limit);
+    const start = Math.min(maxStart, Math.max(0, selectedIndex - Math.floor(limit / 2)));
+    const end = Math.min(options.length, start + limit);
+    return {
+        start,
+        end,
+        items: options.slice(start, end).map((option, offset) => ({ option, index: start + offset }))
+    };
+}
+function workspacePickerListStatus(selectedIndex, total) {
+    return `${Math.min(total, selectedIndex + 1)} / ${total}`;
+}
+function workspacePickerOpeningStatus(path) {
+    return `opening ${basename(path) || path}`;
+}

package/dist/cli-workspace-transition.js

@@ -0,0 +1,33 @@
+export function commitWorkspaceTransition(input) {
+    try {
+        input.render(input.next);
+    }
+    catch (renderError) {
+        try {
+            input.close(input.next);
+        }
+        catch (cleanupError) {
+            deferCloseSafely(input, input.next, cleanupError);
+            throw new Error(`${errorMessage(renderError)}; prepared workspace cleanup failed: ${errorMessage(cleanupError)}`, { cause: new AggregateError([renderError, cleanupError]) });
+        }
+        throw renderError;
+    }
+    try {
+        input.close(input.previous);
+    }
+    catch (cleanupError) {
+        deferCloseSafely(input, input.previous, cleanupError);
+    }
+    return input.next;
+}
+function deferCloseSafely(input, state, error) {
+    try {
+        input.deferClose(state, error);
+    }
+    catch {
+        // The rendered workspace is already committed; do not turn cleanup bookkeeping into a failed switch.
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/cli-workspace.js

@@ -0,0 +1,40 @@
+import { pathExists, pathIsDirectory } from "./core/file-store.js";
+import { listWorkspaceChoices, resolveWorkspacePath, resolveWorkspaceSelection } from "./core/workspace.js";
+import { promptForWorkspaceTui } from "./cli-workspace-picker.js";
+export async function selectWorkspaceForCli(input) {
+    if (input.explicitWorkspace?.trim()) {
+        const explicit = resolveWorkspacePath(input.cwd, input.explicitWorkspace);
+        const stdin = input.stdin ?? process.stdin;
+        const stdout = input.stdout ?? process.stdout;
+        const explicitExists = await pathExists(explicit);
+        const explicitIsDirectory = explicitExists && (await pathIsDirectory(explicit));
+        if (!explicitIsDirectory && input.interactive !== false && shouldPromptForWorkspace(stdin, stdout)) {
+            return promptForWorkspaceTui({
+                cwd: input.cwd,
+                choices: await listWorkspaceChoices(input.appRoot),
+                invalidExplicitWorkspace: {
+                    path: explicit,
+                    reason: explicitExists ? "file" : "missing"
+                },
+                stdin,
+                stdout
+            });
+        }
+        return resolveWorkspaceSelection(input);
+    }
+    const stdin = input.stdin ?? process.stdin;
+    const stdout = input.stdout ?? process.stdout;
+    const choices = await listWorkspaceChoices(input.appRoot);
+    if (input.interactive === false || !shouldPromptForWorkspace(stdin, stdout)) {
+        return resolveWorkspaceSelection(input);
+    }
+    return promptForWorkspaceTui({
+        cwd: input.cwd,
+        choices,
+        stdin,
+        stdout
+    });
+}
+function shouldPromptForWorkspace(stdin, stdout) {
+    return Boolean(stdin.isTTY && stdout.isTTY);
+}