@youdie006/prodex 0.26.1 → 0.27.0

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,29 @@ 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 }, {
+        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 +74,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 +354,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,203 @@
+/**
+ * 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, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+const ESC = "";
+const CLEAR = `${ESC}[2J${ESC}[H`;
+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) {
+    let cursor = 0;
+    for (;;) {
+        io.write(CLEAR + renderSelectList({ ...input, cursor, footer: "  up/down move, enter choose, q cancel" }) + "\n");
+        const key = await readKey(io);
+        if (isCancel(key))
+            return undefined;
+        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;
+    }
+}
+async function pickMany(io, input) {
+    let cursor = 0;
+    let selected = [];
+    for (;;) {
+        io.write(CLEAR +
+            renderSelectList({
+                ...input,
+                cursor,
+                selected,
+                multi: true,
+                footer: "  space toggle, 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")
+            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(HIDE_CURSOR);
+    try {
+        io.write(CLEAR);
+        const prompt = await askLine(io, "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?",
+            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" }
+            ]
+        });
+        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 }))
+            });
+            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",
+            options: TOOL_CHOICES.map((tool) => ({ label: tool.label, ...(tool.hint ? { hint: tool.hint } : {}) }))
+        });
+        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?",
+            options: [
+                { label: "Continue the current thread", hint: "follow-ups keep context" },
+                { label: "Start a new chat", hint: "recommended for an unrelated question" }
+            ]
+        });
+        if (threadChoice === undefined)
+            return cancel(io);
+        const choices = {
+            prompt,
+            projectMode,
+            ...(projectName ? { projectName } : {}),
+            tools,
+            newChat: threadChoice === 1
+        };
+        const args = consultArgsFromChoices(choices);
+        io.write(CLEAR + 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";
+        const timer = setInterval(() => {
+            io.write(CLEAR_LINE + renderProgressBar({ elapsedMs: now() - startedAt, budgetMs, label }));
+        }, 500);
+        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(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,88 @@
+/**
+ * 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;
+}
+export function renderSelectList(input) {
+    const selected = new Set(input.selected ?? []);
+    const lines = [input.title, ""];
+    // 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 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}`);
+    });
+    if (input.footer)
+        lines.push("", input.footer);
+    return lines.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`;
+}
+/**
+ * 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);
+    if (!input.budgetMs || input.budgetMs <= 0)
+        return `${input.label}  ${elapsed}`;
+    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}`;
+}

package/package.json

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