@youdie006/prodex 0.27.0 → 0.27.2

package/dist/cli.js

@@ -51,6 +51,25 @@ const DOCTOR_REQUIRED_MCP_TOOLS = [
 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({});

package/dist/tui-run.js

@@ -7,20 +7,64 @@
  * what keeps the interactive path from drifting away from the documented flags.
  */
 import readline from "node:readline";
-import { consultArgsFromChoices, moveCursor, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+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);
-    });
+/**
+ * Keys are queued by one long-lived listener rather than a listener attached
+ * per read.
+ *
+ * Attaching on demand drops every key pressed while nothing is waiting - during
+ * a redraw, or across the seconds it takes to read the project list out of the
+ * browser. Measured by using it: the first key after the prompt vanished, so
+ * "4" (no project) was swallowed and the next key landed on the wrong row.
+ */
+class KeyQueue {
+    input;
+    pending = [];
+    waiting;
+    constructor(input) {
+        this.input = input;
+        this.input.on("keypress", this.onKey);
+    }
+    onKey = (_str, key) => {
+        const value = key ?? {};
+        if (this.waiting) {
+            const resolve = this.waiting;
+            this.waiting = undefined;
+            resolve(value);
+            return;
+        }
+        this.pending.push(value);
+    };
+    next() {
+        const buffered = this.pending.shift();
+        if (buffered)
+            return Promise.resolve(buffered);
+        return new Promise((resolve) => {
+            this.waiting = resolve;
+        });
+    }
+    /** Drop keys typed before a screen existed to receive them. */
+    drain() {
+        this.pending.length = 0;
+    }
+    dispose() {
+        this.input.off("keypress", this.onKey);
+    }
+}
+let keys;
+function readKey(_io) {
+    if (!keys)
+        throw new Error("The key reader is not running.");
+    return keys.next();
 }
 function isCancel(key) {
     return (key.ctrl === true && key.name === "c") || key.name === "escape" || key.name === "q";
@@ -30,13 +74,25 @@ function isCancel(key) {
 function isConfirm(key) {
     return key.name === "return" || key.name === "enter";
 }
-async function pick(io, input) {
+async function pick(io, input, header = "") {
     let cursor = 0;
     for (;;) {
-        io.write(CLEAR + renderSelectList({ ...input, cursor, footer: "  up/down move, enter choose, q cancel" }) + "\n");
+        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")
@@ -45,23 +101,43 @@ async function pick(io, input) {
             return cursor;
     }
 }
-async function pickMany(io, input) {
+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,
-                footer: "  space toggle, enter confirm (none is fine), q cancel"
+                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;
-        if (key.name === "up" || key.name === "k")
+        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);
@@ -82,6 +158,7 @@ async function askLine(io, question) {
     io.input.setRawMode?.(true);
     readline.emitKeypressEvents(io.input);
     io.input.resume();
+    keys?.drain();
     return answer.trim();
 }
 const TOOL_CHOICES = [
@@ -98,23 +175,36 @@ export async function runInteractiveConsult(io, deps) {
     readline.emitKeypressEvents(io.input);
     io.input.setRawMode?.(true);
     io.input.resume();
-    io.write(HIDE_CURSOR);
+    keys = new KeyQueue(io.input);
+    io.write(ALT_SCREEN_ON + HIDE_CURSOR);
+    let header = "";
     try {
         io.write(CLEAR);
+        // Gather the context WHILE the prompt is being typed. Reading the browser
+        // state takes a second or two, and doing it first left the screen blank for
+        // that long - anything typed into that gap was swallowed, prompt included.
+        const contextPromise = deps.describeContext?.().catch(() => []);
         const prompt = await askLine(io, "Ask ChatGPT Pro\n\n  prompt: ");
+        // The panel still leads every question that follows, which is where it
+        // earns its place: choosing a project and tools without knowing the browser
+        // is down wastes every answer given before the failure.
+        const rows = (await contextPromise) ?? [];
+        if (rows.length > 0)
+            header = `${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
         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"];
@@ -129,7 +219,7 @@ export async function runInteractiveConsult(io, deps) {
             const chosen = await pick(io, {
                 title: "Which project?",
                 options: projects.map((name) => ({ label: name }))
-            });
+            }, header);
             if (chosen === undefined)
                 return cancel(io);
             projectName = projects[chosen];
@@ -141,18 +231,20 @@ export async function runInteractiveConsult(io, deps) {
         }
         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 = {
@@ -163,16 +255,21 @@ export async function runInteractiveConsult(io, deps) {
             newChat: threadChoice === 1
         };
         const args = consultArgsFromChoices(choices);
-        io.write(CLEAR + SHOW_CURSOR);
+        // 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(() => {
-            io.write(CLEAR_LINE + renderProgressBar({ elapsedMs: now() - startedAt, budgetMs, label }));
-        }, 500);
+            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);
@@ -188,7 +285,9 @@ export async function runInteractiveConsult(io, deps) {
         }
     }
     finally {
-        io.write(SHOW_CURSOR);
+        keys?.dispose();
+        keys = undefined;
+        io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
         io.input.setRawMode?.(false);
         io.input.pause();
     }

package/dist/tui.js

@@ -38,22 +38,67 @@ export function consultArgsFromChoices(choices) {
     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 lines = [input.title, ""];
+    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 pointer = index === input.cursor ? ">" : " ";
+        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 hint = option.hint ? `${" ".repeat(labelWidth - option.label.length)}    ${option.hint}` : "";
-        lines.push(`  ${pointer} ${box}${option.label}${hint}`);
+        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("", 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;
@@ -70,6 +115,7 @@ function formatElapsed(ms) {
     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
@@ -77,12 +123,16 @@ function formatElapsed(ms) {
  */
 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 `${input.label}  ${elapsed}`;
+        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 `[${bar}] ${elapsed} / ${formatElapsed(input.budgetMs)}  ${input.label}${over}`;
+    return `${spinner} [${bar}] ${elapsed} / ${formatElapsed(input.budgetMs)}  ${input.label}${over}  ${stop}`;
 }

package/package.json

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