@youdie006/prodex 0.26.1 → 0.27.1

package/README.md

@@ -35,7 +35,7 @@ prodex ask --file src/auth.ts "Review this for security holes"
 
 `prodex ask` is the short form of `prodex pro browser ask`; the full form and every flag work identically. In an interactive terminal, `login` keeps watching the opened window and tells you exactly which manual step is still missing (log in, clear a check, open a chat) until it reports READY. If you skip `login` and the browser is not running, an interactive `ask` recovers on its own: it launches the dedicated browser, waits for your saved session to be READY, and retries the send once (disable with `--no-auto-login`; scripts opt in with `--auto-login`). While ChatGPT thinks, `prodex` prints progress to stderr (connecting, prompt sent, elapsed seconds while generating), so a multi-minute Pro answer never looks frozen.
 
-The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). It is read from the conversation transcript rather than scraped off the page, so markdown tables and fenced code arrive intact, citations keep their links, and a tab that drifts to another conversation mid-wait no longer costs you the answer; the rendered page stays as a fallback. Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and will not send into a tab it cannot read, so leave the dedicated window on a ChatGPT tab; it sends quietly in the background without stealing focus. Prefer no window at all? See [virtual display](#no-window-at-all-virtual-display-recommended). Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (20-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to inline several files. `--file` puts a text file's CONTENTS into the prompt; `--attach` uploads the file itself, which is the only way to hand ChatGPT a pdf, pptx, xlsx or image and let it parse the original (`prodex ask --attach deck.pptx "Review slides 40-60"`). Both are restricted to paths inside the repo, so an agent cannot upload `~/.ssh` by asking nicely. The upload happens before the prompt is submitted and prodex waits for ChatGPT to finish accepting the file - the browser process reads the path, so the file has to live on the machine running the browser. `--tool` turns on a ChatGPT composer tool for that send: `--tool deep-research` (a browsed report - the timeout rises to 30 minutes automatically; prodex presses the start control, waits out the run and returns the full report. The report is read from the conversation transcript rather than the page, because deep research renders inside a widget iframe that leaves the thread looking empty - which also means `prodex pro browser recover --target-url <thread>` fetches a research report that finished after a timeout), `--tool web-search` (current facts with sources), `--tool create-image`. Any other label the menu shows works too, so a tool ChatGPT adds later needs no prodex release. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
+Prefer to drive it yourself instead of remembering flags? `prodex ui` - or just `prodex` in a terminal - asks for the prompt, where the consult should land (the open chat, an existing project, a new one, or no project at all), which composer tools to turn on, and then shows a progress bar while Pro writes; it prints the equivalent command so the flags are learnable from it. The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). It is read from the conversation transcript rather than scraped off the page, so markdown tables and fenced code arrive intact, citations keep their links, and a tab that drifts to another conversation mid-wait no longer costs you the answer; the rendered page stays as a fallback. Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and will not send into a tab it cannot read, so leave the dedicated window on a ChatGPT tab; it sends quietly in the background without stealing focus. Prefer no window at all? See [virtual display](#no-window-at-all-virtual-display-recommended). Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (20-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to inline several files. `--file` puts a text file's CONTENTS into the prompt; `--attach` uploads the file itself, which is the only way to hand ChatGPT a pdf, pptx, xlsx or image and let it parse the original (`prodex ask --attach deck.pptx "Review slides 40-60"`). Both are restricted to paths inside the repo, so an agent cannot upload `~/.ssh` by asking nicely. The upload happens before the prompt is submitted and prodex waits for ChatGPT to finish accepting the file - the browser process reads the path, so the file has to live on the machine running the browser. `--tool` turns on a ChatGPT composer tool for that send: `--tool deep-research` (a browsed report - the timeout rises to 30 minutes automatically; prodex presses the start control, waits out the run and returns the full report. The report is read from the conversation transcript rather than the page, because deep research renders inside a widget iframe that leaves the thread looking empty - which also means `prodex pro browser recover --target-url <thread>` fetches a research report that finished after a timeout), `--tool web-search` (current facts with sources), `--tool create-image`. Any other label the menu shows works too, so a tool ChatGPT adds later needs no prodex release. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
 
 ## Core Shape
 

package/dist/cli-args.js

@@ -20,7 +20,8 @@ export const TOP_LEVEL_COMMANDS = [
     "sessions",
     "pro",
     "release",
-    "mcp"
+    "mcp",
+    "ui"
 ];
 export function isHelpSubcommand(value) {
     return value === "help" || value === "--help" || value === "-h";
@@ -255,7 +256,9 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
     "--stdin",
     "--json",
     "--auto-login",
-    "--no-auto-login"
+    "--no-auto-login",
+    // Send outside any project for once, overriding a pinned default.
+    "--no-project"
 ]);
 export const ASK_PRO_SELECTION_VALUE_FLAGS = ["--project", "--project-new", "--model", "--pro-mode", "--effort"];
 export const ASK_PRO_VALUE_FLAGS = new Set([

package/dist/cli-help.js

@@ -58,6 +58,7 @@ Agent / MCP integration:
   prodex claude prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
   prodex claude config [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
   prodex project prompt [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
+  prodex ui  # interactive: pick project/tools, watch progress (plain prodex in a terminal opens this)
   prodex onboard [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
 
 Maintenance:

package/dist/cli-pro.js

@@ -152,6 +152,7 @@ export async function runProCommand(rest, io, runCliFn) {
             "--confirm-target",
             "--project",
             "--project-new",
+            "--no-project",
             "--model",
             "--pro-mode",
             "--effort",
@@ -797,6 +798,12 @@ export async function runAskProCommand(rest, io) {
     const browserDefaults = await loadBrowserDefaults(targetCwd);
     const explicitProject = readFlag(parsedAskPro.optionArgs, "--project");
     const explicitProjectNew = readFlag(parsedAskPro.optionArgs, "--project-new");
+    // Opt out of a pinned default project for one send. Without this a repo
+    // that pins a project has no route back to the plain chat list.
+    const suppressProject = parsedAskPro.optionArgs.includes("--no-project");
+    if (suppressProject && (explicitProject !== undefined || explicitProjectNew !== undefined)) {
+        throw new Error("ask-pro cannot combine --no-project with --project/--project-new; pick one.");
+    }
     if (explicitProject !== undefined && explicitProjectNew !== undefined) {
         throw new Error("ask-pro cannot combine --project and --project-new; pick an existing project or create one.");
     }
@@ -827,7 +834,7 @@ export async function runAskProCommand(rest, io) {
     // consults stop landing in the general chat list. Only --target-url
     // (pinned tab) and --project-new suppress it.
     const selectionProject = explicitProject ??
-        (normalizedTargetUrl || selectionProjectNew !== undefined ? undefined : browserDefaults?.project);
+        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject ? undefined : browserDefaults?.project);
     const reasoningAxisChosen = explicitProMode !== undefined || explicitEffort !== undefined;
     const selectionProMode = explicitProMode ?? (reasoningAxisChosen ? undefined : browserDefaults?.pro_mode);
     const selectionEffort = explicitEffort ?? (reasoningAxisChosen ? undefined : browserDefaults?.effort);

package/dist/cli.js

@@ -44,6 +44,48 @@ const DOCTOR_REQUIRED_MCP_TOOLS = [
     "repo_write_file_apply",
     "repo_stage_reviewed_paths"
 ];
+/**
+ * Run the interactive picker and hand its choices to the ordinary send path, so
+ * the terminal flow and the documented flags cannot drift apart.
+ */
+async function runInteractiveUi(io) {
+    const { runInteractiveConsult } = await import("./tui-run.js");
+    return runInteractiveConsult({ write: (text) => process.stdout.write(text), input: process.stdin }, {
+        describeContext: async () => {
+            const { loadBrowserDefaults } = await import("./config.js");
+            const { getChatGptBrowserStatus } = await import("./chatgpt-browser.js");
+            const defaults = await loadBrowserDefaults(io.cwd).catch(() => undefined);
+            const status = await getChatGptBrowserStatus({ timeoutMs: 1_500 }).catch(() => undefined);
+            const browser = !status?.reachable
+                ? "not running - prodex pro browser login"
+                : status.blocker
+                    ? status.blocker.code
+                    : status.loggedInLikely
+                        ? "ready"
+                        : "reachable, not logged in";
+            return [
+                { label: "repo", value: io.cwd },
+                { label: "model", value: defaults?.model ?? "whatever the ChatGPT UI has selected" },
+                { label: "project", value: defaults?.project ?? "none pinned" },
+                { label: "browser", value: browser }
+            ];
+        },
+        listProjects: async () => {
+            const { listChatGptSidebarProjects } = await import("./chatgpt-browser.js");
+            const listed = await listChatGptSidebarProjects({});
+            return listed.projects;
+        },
+        runConsult: (args, onProgress) => runCli(args, {
+            ...io,
+            stderr: (line) => {
+                if (line.startsWith("progress:"))
+                    onProgress(line);
+                else
+                    io.stderr(line);
+            }
+        })
+    });
+}
 export async function runCli(args, io = defaultIo()) {
     const [command, ...rest] = args;
     const store = new BridgeStore(io.cwd);
@@ -51,12 +93,21 @@ export async function runCli(args, io = defaultIo()) {
         io.stdout(CLI_VERSION);
         return 0;
     }
+    // A person typing `prodex` used to get the agent-facing command wall and no
+    // way in. On a terminal, walk them through a consult instead; piped or
+    // scripted callers still get the banner and the command list they parse.
+    if (!command && io.isInteractive === true)
+        return runInteractiveUi(io);
     if (!command || command === "help" || command === "--help" || command === "-h") {
         if (shouldColorize())
             io.stdout(renderBanner({ color: true }));
         printHelp(io.stdout);
         return 0;
     }
+    if (command === "ui") {
+        assertOnlyOptions(rest, "ui", []);
+        return runInteractiveUi(io);
+    }
     if (command === "init")
         return runInitCommand(rest, io);
     if (command === "setup")
@@ -322,6 +373,7 @@ repo: ${cwd}
    ${cli} pro browser help${sourceCliOption}
    ${cli} pro browser check${sourceCliOption} --cwd ${quotedCwd}
    ${cli} pro browser smoke${sourceCliOption} --cwd ${quotedCwd}
+   Prefer to drive it yourself? ${cli} ui (or just ${cli} in a terminal) asks where the consult should land, which composer tools to turn on, and shows a progress bar while Pro writes.
    Sharing the browser with other agents? Sends queue behind an in-flight response automatically; pass --busy-wait-ms 0 to fail fast instead.
    Hand ChatGPT a real file - the only way it can open a pdf, pptx, xlsx or image:
    ${cli} ask --cwd ${quotedCwd} --attach deck.pptx "Review slides 40-60"  # uploads the file itself

package/dist/tui-run.js

@@ -0,0 +1,261 @@
+/**
+ * The interactive shell around the pure pickers in `tui.ts`.
+ *
+ * Node's readline in raw mode is enough for a list picker, so the package keeps
+ * carrying no UI dependency. Everything here is I/O; the decisions it collects
+ * are turned into a normal command line by `consultArgsFromChoices`, which is
+ * what keeps the interactive path from drifting away from the documented flags.
+ */
+import readline from "node:readline";
+import { consultArgsFromChoices, moveCursor, renderContextPanel, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+const ESC = "";
+const CLEAR = `${ESC}[2J${ESC}[H`;
+// The alternate screen buffer: the terminal comes back exactly as it was, so a
+// picker does not shove the user's scrollback off the top.
+const ALT_SCREEN_ON = `${ESC}[?1049h`;
+const ALT_SCREEN_OFF = `${ESC}[?1049l`;
+const CLEAR_LINE = `${ESC}[2K\r`;
+const HIDE_CURSOR = `${ESC}[?25l`;
+const SHOW_CURSOR = `${ESC}[?25h`;
+function readKey(io) {
+    return new Promise((resolve) => {
+        const onKey = (_str, key) => {
+            io.input.off("keypress", onKey);
+            resolve(key ?? {});
+        };
+        io.input.on("keypress", onKey);
+    });
+}
+function isCancel(key) {
+    return (key.ctrl === true && key.name === "c") || key.name === "escape" || key.name === "q";
+}
+// Terminals disagree about the Enter key: a carriage return arrives as
+// "return", a line feed as "enter". Accept either, or the picker looks frozen.
+function isConfirm(key) {
+    return key.name === "return" || key.name === "enter";
+}
+async function pick(io, input, header = "") {
+    let cursor = 0;
+    for (;;) {
+        io.write(CLEAR +
+            header +
+            renderSelectList({
+                ...input,
+                cursor,
+                width: terminalWidth(),
+                color: colorEnabled(),
+                footer: "  up/down move   1-9 choose directly   enter confirm   q cancel"
+            }) +
+            "\n");
+        const key = await readKey(io);
+        if (isCancel(key))
+            return undefined;
+        const typed = numericChoice(key, input.options.length);
+        if (typed !== undefined)
+            return typed;
+        if (key.name === "up" || key.name === "k")
+            cursor = moveCursor(cursor, "up", input.options.length);
+        else if (key.name === "down" || key.name === "j")
+            cursor = moveCursor(cursor, "down", input.options.length);
+        else if (isConfirm(key))
+            return cursor;
+    }
+}
+function terminalWidth() {
+    return Math.max(40, Math.min(process.stdout.columns ?? 100, 120));
+}
+function colorEnabled() {
+    return process.stdout.isTTY === true && !process.env.NO_COLOR;
+}
+// Typing the row number is faster than arrowing to it, and matches how the
+// pickers this sits beside are driven.
+function numericChoice(key, length) {
+    const digit = Number(key.name);
+    if (!Number.isInteger(digit) || digit < 1 || digit > Math.min(9, length))
+        return undefined;
+    return digit - 1;
+}
+async function pickMany(io, input, header = "") {
+    let cursor = 0;
+    let selected = [];
+    for (;;) {
+        io.write(CLEAR +
+            header +
+            renderSelectList({
+                ...input,
+                cursor,
+                selected,
+                multi: true,
+                width: terminalWidth(),
+                color: colorEnabled(),
+                footer: "  space toggle   1-9 toggle directly   enter confirm (none is fine)   q cancel"
+            }) +
+            "\n");
+        const key = await readKey(io);
+        if (isCancel(key))
+            return undefined;
+        const typed = numericChoice(key, input.options.length);
+        if (typed !== undefined)
+            selected = toggleSelection(selected, typed);
+        else if (key.name === "up" || key.name === "k")
+            cursor = moveCursor(cursor, "up", input.options.length);
+        else if (key.name === "down" || key.name === "j")
+            cursor = moveCursor(cursor, "down", input.options.length);
+        else if (key.name === "space")
+            selected = toggleSelection(selected, cursor);
+        else if (isConfirm(key))
+            return selected;
+    }
+}
+/** Read one line with the terminal back in cooked mode, so editing works. */
+async function askLine(io, question) {
+    io.input.setRawMode?.(false);
+    const rl = readline.createInterface({ input: io.input, output: process.stdout, terminal: true });
+    const answer = await new Promise((resolve) => rl.question(question, resolve));
+    rl.close();
+    // Closing the line reader detaches the keypress plumbing and pauses the
+    // stream, so the next picker would sit there ignoring every key. Re-arm both.
+    io.input.setRawMode?.(true);
+    readline.emitKeypressEvents(io.input);
+    io.input.resume();
+    return answer.trim();
+}
+const TOOL_CHOICES = [
+    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes" },
+    { id: "web-search", label: "Web search", hint: "current facts, with sources" },
+    { id: "create-image", label: "Create image" }
+];
+/**
+ * Walk the questions a send needs, then run it with a moving progress bar.
+ * Returns the process exit code.
+ */
+export async function runInteractiveConsult(io, deps) {
+    const now = deps.now ?? Date.now;
+    readline.emitKeypressEvents(io.input);
+    io.input.setRawMode?.(true);
+    io.input.resume();
+    io.write(ALT_SCREEN_ON + HIDE_CURSOR);
+    let header = "";
+    try {
+        io.write(CLEAR);
+        // Show what the send will use before asking anything: choosing a project or
+        // a tool without knowing the model, or whether the browser is even up, is
+        // choosing blind - and a browser failure after four questions wastes all four.
+        if (deps.describeContext) {
+            try {
+                const rows = await deps.describeContext();
+                if (rows.length > 0)
+                    header = `${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
+            }
+            catch {
+                // Context is a courtesy; never let it block the consult.
+            }
+        }
+        const prompt = await askLine(io, `${header}Ask ChatGPT Pro\n\n  prompt: `);
+        if (prompt.length === 0) {
+            io.write("Nothing to ask.\n");
+            return 1;
+        }
+        const projectChoice = await pick(io, {
+            title: "Where should this consult land?",
+            step: { index: 1, total: 3 },
+            options: [
+                { label: "The chat that is already open", hint: "keeps the thread's context" },
+                { label: "An existing project" },
+                { label: "A new project" },
+                { label: "No project", hint: "plain chat list, ignores a pinned default" }
+            ]
+        }, header);
+        if (projectChoice === undefined)
+            return cancel(io);
+        const modes = ["current", "existing", "new", "none"];
+        const projectMode = modes[projectChoice];
+        let projectName;
+        if (projectMode === "existing") {
+            const projects = await deps.listProjects();
+            if (projects.length === 0) {
+                io.write("\nNo projects are visible in the ChatGPT sidebar.\n");
+                return 1;
+            }
+            const chosen = await pick(io, {
+                title: "Which project?",
+                options: projects.map((name) => ({ label: name }))
+            }, header);
+            if (chosen === undefined)
+                return cancel(io);
+            projectName = projects[chosen];
+        }
+        else if (projectMode === "new") {
+            projectName = await askLine(io, `${CLEAR}New project\n\n  name: `);
+            if (!projectName)
+                return cancel(io);
+        }
+        const toolChoice = await pickMany(io, {
+            title: "Turn on any composer tools for this send",
+            step: { index: 2, total: 3 },
+            options: TOOL_CHOICES.map((tool) => ({ label: tool.label, ...(tool.hint ? { hint: tool.hint } : {}) }))
+        }, header);
+        if (toolChoice === undefined)
+            return cancel(io);
+        const tools = toolChoice.map((index) => TOOL_CHOICES[index].id);
+        const threadChoice = await pick(io, {
+            title: "Start a fresh thread?",
+            step: { index: 3, total: 3 },
+            options: [
+                { label: "Continue the current thread", hint: "follow-ups keep context" },
+                { label: "Start a new chat", hint: "recommended for an unrelated question" }
+            ]
+        }, header);
+        if (threadChoice === undefined)
+            return cancel(io);
+        const choices = {
+            prompt,
+            projectMode,
+            ...(projectName ? { projectName } : {}),
+            tools,
+            newChat: threadChoice === 1
+        };
+        const args = consultArgsFromChoices(choices);
+        // Leave the alternate screen before the send: the answer, the receipt id
+        // and any blocker belong in the scrollback the user keeps.
+        io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        io.write(`Sending. Equivalent command:\n  prodex ${formatCommand(args)}\n\n`);
+        // Deep research runs about ten minutes; an ordinary Pro answer, minutes.
+        // Fill the bar against that so the wait has a shape.
+        const budgetMs = tools.includes("deep-research") ? 30 * 60_000 : 20 * 60_000;
+        const startedAt = now();
+        let label = "starting";
+        let tick = 0;
+        const timer = setInterval(() => {
+            tick += 1;
+            io.write(CLEAR_LINE +
+                renderProgressBar({ elapsedMs: now() - startedAt, budgetMs, label, tick, width: Math.min(28, terminalWidth() - 52) }));
+        }, 250);
+        try {
+            const code = await deps.runConsult(args, (line) => {
+                label = line.replace(/^progress:\s*/, "").slice(0, 60);
+            });
+            clearInterval(timer);
+            io.write(CLEAR_LINE);
+            return code;
+        }
+        catch (error) {
+            clearInterval(timer);
+            io.write(CLEAR_LINE);
+            throw error;
+        }
+    }
+    finally {
+        io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        io.input.setRawMode?.(false);
+        io.input.pause();
+    }
+}
+function cancel(io) {
+    io.write("\nCancelled.\n");
+    return 130;
+}
+/** Quote only what a shell would need quoted, so the echo can be pasted. */
+export function formatCommand(args) {
+    return args.map((arg) => (/^[A-Za-z0-9._\-/:=]+$/.test(arg) ? arg : JSON.stringify(arg))).join(" ");
+}

package/dist/tui.js

@@ -0,0 +1,138 @@
+/**
+ * The interactive side of prodex.
+ *
+ * Everything an agent needs is already reachable as flags, but a person typing
+ * `prodex` got a wall of commands and no way in. This module is the picker that
+ * asks the same questions the flags answer - where the consult should land,
+ * which composer tools to turn on - and then shows something moving while a
+ * multi-minute Pro answer is written.
+ *
+ * The rendering and the choice-to-argument mapping are pure so they can be
+ * tested without a terminal; only `runInteractiveConsult` touches stdin.
+ */
+/**
+ * Map the picker's answers onto the exact command line a person could have
+ * typed. Keeping this a pure function means the interactive path cannot drift
+ * from the documented flags - and the TUI can print the command it ran.
+ */
+export function consultArgsFromChoices(choices) {
+    const prompt = choices.prompt.trim();
+    if (prompt.length === 0)
+        throw new Error("The prompt is empty - there is nothing to ask.");
+    const args = ["pro", "browser", "ask"];
+    if (choices.newChat)
+        args.push("--new-chat");
+    if (choices.projectMode === "existing" || choices.projectMode === "new") {
+        const name = choices.projectName?.trim();
+        if (!name)
+            throw new Error("Pick a project name, or choose to send without a project.");
+        args.push(choices.projectMode === "existing" ? "--project" : "--project-new", name);
+    }
+    // A pinned default project would otherwise swallow this choice.
+    if (choices.projectMode === "none")
+        args.push("--no-project");
+    for (const attachment of choices.attachments ?? [])
+        args.push("--attach", attachment);
+    for (const tool of choices.tools)
+        args.push("--tool", tool);
+    args.push("--", prompt);
+    return args;
+}
+const ESC = "";
+const DIM = `${ESC}[2m`;
+const BOLD = `${ESC}[1m`;
+const ACCENT = `${ESC}[38;2;190;28;28m`;
+const RESET = `${ESC}[0m`;
+const CURSOR_BAR = "▌";
+function paint(text, code, color) {
+    return color ? `${code}${text}${RESET}` : text;
+}
+/** Cut a line to the terminal rather than letting it wrap into a second row. */
+export function truncateToWidth(text, width) {
+    if (width <= 0 || text.length <= width)
+        return text;
+    return width <= 3 ? text.slice(0, width) : `${text.slice(0, width - 3)}...`;
+}
+export function renderSelectList(input) {
+    const color = input.color ?? true;
+    const width = input.width ?? 100;
+    const selected = new Set(input.selected ?? []);
+    const step = input.step ? paint(`   Step ${input.step.index} of ${input.step.total}`, DIM, color) : "";
+    const lines = [`${paint(input.title, BOLD, color)}${step}`, ""];
+    // Hints line up in their own column; ragged hints read as noise next to the
+    // labels they belong to.
+    const labelWidth = Math.max(...input.options.map((option) => option.label.length), 0);
+    input.options.forEach((option, index) => {
+        const onCursor = index === input.cursor;
+        // A left bar reads as a cursor even once the row is colored, where a ">"
+        // competes with the text. Rows that are not on the cursor keep the same
+        // indent so nothing shifts as it moves.
+        const bar = onCursor ? paint(CURSOR_BAR, ACCENT, color) : " ";
+        // A number per row means a choice can be typed instead of arrowed to.
+        const ordinal = paint(`${index + 1}`, onCursor ? ACCENT : DIM, color);
+        const box = input.multi ? (selected.has(index) ? "[x] " : "[ ] ") : "";
+        const label = onCursor ? paint(option.label, BOLD, color) : option.label;
+        const gap = " ".repeat(Math.max(0, labelWidth - option.label.length));
+        const hint = option.hint ? `${gap}    ${paint(option.hint, DIM, color)}` : "";
+        lines.push(truncateToWidth(` ${bar} ${ordinal} ${box}${label}${hint}`, width + (color ? 64 : 0)));
+    });
+    if (input.footer)
+        lines.push("", paint(input.footer, DIM, color));
+    return lines.join("\n");
+}
+/**
+ * The settings a send is about to use, framed above the questions.
+ *
+ * Picking a project or a tool without seeing which model is pinned, or whether
+ * the browser is even reachable, is choosing blind - and a send that fails on
+ * the browser after four questions wastes all four.
+ */
+export function renderContextPanel(rows, options = {}) {
+    const color = options.color ?? true;
+    const labelWidth = Math.max(...rows.map((row) => row.label.length), 0);
+    const texts = rows.map((row) => ` ${row.label.padEnd(labelWidth)}   ${row.value} `);
+    // Size the frame to its contents, capped by the terminal. A box stretched to
+    // the full width is mostly empty space with a border around it.
+    const inner = Math.min(Math.max(...texts.map((text) => text.length), 0), Math.max(20, (options.width ?? 72) - 2));
+    const body = texts.map((text) => `│${truncateToWidth(text, inner).padEnd(inner)}│`);
+    const top = `╭${"─".repeat(inner)}╮`;
+    const bottom = `╰${"─".repeat(inner)}╯`;
+    return [top, ...body, bottom].map((line) => (color ? paint(line, DIM, color) : line)).join("\n");
+}
+export function moveCursor(cursor, direction, length) {
+    if (length <= 0)
+        return 0;
+    return direction === "up" ? (cursor - 1 + length) % length : (cursor + 1) % length;
+}
+export function toggleSelection(selected, index) {
+    return selected.includes(index) ? selected.filter((entry) => entry !== index) : [...selected, index].sort((a, b) => a - b);
+}
+function formatElapsed(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+}
+const SPINNER = ["|", "/", "-", "\\"];
+/**
+ * A Pro consult can run for many minutes with nothing on screen. The bar fills
+ * against the send's own budget, and says so plainly once the wait outlives it
+ * rather than sitting at 100% pretending to be finished.
+ */
+export function renderProgressBar(input) {
+    const elapsed = formatElapsed(input.elapsedMs);
+    const spinner = SPINNER[Math.abs(input.tick ?? 0) % SPINNER.length];
+    // Saying how to abort belongs on the waiting line itself: a consult can run
+    // for many minutes and the only other thing on screen is the bar.
+    const stop = "ctrl-c to stop";
+    if (!input.budgetMs || input.budgetMs <= 0)
+        return `${spinner} ${input.label}  ${elapsed}  ${stop}`;
+    const width = Math.max(4, input.width ?? 28);
+    const ratio = input.elapsedMs / input.budgetMs;
+    const filled = Math.min(width, Math.round(Math.min(ratio, 1) * width));
+    const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
+    const over = ratio > 1 ? "  over budget" : "";
+    return `${spinner} [${bar}] ${elapsed} / ${formatElapsed(input.budgetMs)}  ${input.label}${over}  ${stop}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.26.1",
+  "version": "0.27.1",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",