chivgent 0.19.0 → 1.0.1

package/dist/repl.js

@@ -1,25 +1,49 @@
 import { TuiInput } from "./tui/input.js";
+import { EditorController } from "./tui/editor-input.js";
+import { readLiveGitDiff } from "./tui/git-diff.js";
+import { terminalText } from "./tui/text.js";
+import { PatchReviewController } from "./tui/review.js";
+import { InputMenu } from "./tui/menu.js";
 import { createInterface, emitKeypressEvents } from "node:readline";
 import { formatTokens } from "./providers/usage.js";
+import { approvalPreview, commandReviewable } from "./tui/activity.js";
+import { terminalWidth } from "./tui/live.js";
+import { formatDiffPage, mostRecentSuccessfulPatch } from "./tui/diff.js";
 export const REPL_PROMPT = "› ";
 export const BUILT_IN_COMMANDS = [
     "help",
     "session",
     "tools",
+    "diff",
+    "compose",
+    "editor",
+    "review",
+    "gitdiff",
     "clear",
     "exit",
     "quit",
     "login",
+    "provider",
+    "model",
+    "endpoint",
 ];
 const HELP = `Commands:
   /help      Show this help
   /session   Show the current session id, workspace, and size
   /tools     List the tools available to the model
+  /diff [N]  Review the latest successful apply_patch, page N
+  /compose   Write a multi-line prompt (/send to submit, /cancel to discard)
+  /editor    Open the cursor-editable multiline composer (Ctrl+S sends)
+  /review    Browse last applied patch with arrows, q to close
+  /gitdiff [--staged]  Review actual workspace Git changes after explicit approval
   /clear     Start a new transcript in the same session
-  /login     Store an API key for this Provider
-  /exit      Leave chivgent (Ctrl+D also works)
+  /provider  Choose a Provider (↑↓ and Enter in the TUI)
+  /model     Show or change the current model: /model MODEL
+  /endpoint  Set the URL for an OpenAI-compatible Provider
+  /login     Store a key for the current Provider; /login NAME switches first
+  /exit      Leave chivgent (Ctrl+C or Ctrl+D also works)
 
-Anything else is sent to the model. Ctrl+C stops the answer in progress.
+Anything else is sent to the model. Ctrl+C stops a running answer; at the prompt it exits.
 `;
 function helpText(context) {
     const extras = context.extensionCommands ?? [];
@@ -52,16 +76,73 @@ export function handleSlashCommand(line, context) {
         case "/tools":
             context.write(`${context.session.toolNames.map((name) => `  ${name}`).join("\n")}\n`);
             return "handled";
+        case "/diff": {
+            const argument = trimmed.slice("/diff".length).trim();
+            if (argument.length > 0 && !/^[1-9]\d*$/.test(argument)) {
+                context.write("Usage: /diff [positive page number]\n");
+                return "handled";
+            }
+            const patch = mostRecentSuccessfulPatch(context.session.messages);
+            if (patch === undefined) {
+                context.write("No successfully applied patch found in this session.\n");
+                return "handled";
+            }
+            const page = argument.length === 0 ? 1 : Number(argument);
+            context.write(formatDiffPage(patch, page, context.width ?? 80, context.color === true).text);
+            return "handled";
+        }
+        case "/compose":
+            context.write("Use /compose at the interactive prompt to enter multi-line mode.\n");
+            return "handled";
+        case "/editor":
+            context.write("Use /editor in an interactive TUI to open the multiline editor.\n");
+            return "handled";
+        case "/review":
+            context.write("Use /review in an interactive TUI to browse the most recent successful patch.\n");
+            return "handled";
+        case "/gitdiff":
+            context.write("Use /gitdiff [--staged] in an interactive TUI to approve read-only Git diff.\n");
+            return "handled";
         case "/clear":
             context.session.clear();
             context.write("Transcript cleared.\n");
             return "handled";
+        case "/provider":
+            if (context.providers === undefined) {
+                context.write("Provider switching is unavailable in this session.\n");
+                return "handled";
+            }
+            if (trimmed === "/provider") {
+                context.write(context.providers.describe());
+                return "handled";
+            }
+            return { kind: "provider", argument: trimmed.slice("/provider".length).trim() };
+        case "/model":
+            if (context.providers === undefined) {
+                context.write("Model switching is unavailable in this session.\n");
+                return "handled";
+            }
+            if (trimmed === "/model") {
+                context.write(`Current model: ${context.providers.model ?? "not set"}. Use /model MODEL to change it.\n`);
+                return "handled";
+            }
+            return { kind: "model", argument: trimmed.slice("/model".length).trim() };
+        case "/endpoint":
+            if (context.providers === undefined) {
+                context.write("Endpoint configuration is unavailable in this session.\n");
+                return "handled";
+            }
+            if (trimmed === "/endpoint") {
+                context.write("Use /endpoint https://api.example.com/v1 for an OpenAI-compatible Provider.\n");
+                return "handled";
+            }
+            return { kind: "endpoint", argument: trimmed.slice("/endpoint".length).trim() };
         case "/login":
             if (context.signIn === undefined) {
                 context.write("This session cannot store a key; it is attached to a server that already has one.\n");
                 return "handled";
             }
-            return { kind: "login" };
+            return { kind: "login", providerArgument: trimmed.slice("/login".length).trim() };
         case "/exit":
         case "/quit":
             return "exit";
@@ -130,11 +211,7 @@ async function withoutEcho(readline, read) {
     }
 }
 async function runSignIn(readline, readNextLine, write, signIn) {
-    write([
-        `Paste an API key for ${signIn.provider}. It is not echoed.`,
-        `It will be stored in ${signIn.authFile}, readable only by you.`,
-        "API key: ",
-    ].join("\n"));
+    write(`API key for ${signIn.provider} (hidden, saved locally; Enter skips): `);
     // The key is read from the same line source the loop uses. readline's
     // question() competes with the loop's own iterator for input, so the answer
     // would be swallowed or never arrive.
@@ -153,12 +230,13 @@ async function runSignIn(readline, readNextLine, write, signIn) {
         write(`${failure}\n`);
         return;
     }
-    write(`Stored the key for ${signIn.provider}. The key is not checked until your next prompt.\n`);
+    write(signIn.ready()
+        ? `Stored the key for ${signIn.provider}. Ready for your next prompt.\n`
+        : `Stored the key for ${signIn.provider}. ${signIn.unavailableMessage?.() ?? "Finish Provider setup before sending a prompt."}\n`);
 }
 /**
- * Reads prompts until the user leaves. One run at a time: Ctrl+C cancels the
- * answer in progress instead of killing the process, so the transcript and the
- * session log survive an interrupt.
+ * Reads prompts until the user leaves. Ctrl+C cancels a running answer, keeping
+ * its transcript and log; at an idle prompt it closes the REPL.
  */
 export async function runRepl(options) {
     const write = (text) => {
@@ -175,24 +253,123 @@ export async function runRepl(options) {
         output: options.output,
         terminal: true,
         prompt: REPL_PROMPT,
-        ...(options.tui ? {
-            completer: (line) => {
-                const commands = [...BUILT_IN_COMMANDS, ...(options.extensionCommands ?? []).map((command) => command.name)];
-                const matches = line.startsWith("/") && !/\s/.test(line)
-                    ? [...new Set(commands)].map((name) => `/${name}`).filter((name) => name.startsWith(line))
-                    : [];
-                return [matches, line];
-            },
-        } : {}),
     });
+    const menu = tuiInput === undefined ? undefined : new InputMenu(readline, options.output);
+    let dismissedLine;
+    let refreshQueued = false;
+    const menuPriority = ["provider", "model", "editor", "review", "help"];
+    const commands = [...BUILT_IN_COMMANDS, ...(options.extensionCommands ?? []).map((command) => command.name)]
+        .filter((name, index, all) => all.indexOf(name) === index)
+        .sort((a, b) => {
+        const rank = (name) => {
+            const index = menuPriority.indexOf(name);
+            return index < 0 ? menuPriority.length : index;
+        };
+        return rank(a) - rank(b);
+    })
+        .map((name) => ({ value: name, label: `/${name}${name === "provider" ? "  ·  choose a Provider" : name === "model" ? "  ·  change model" : ""}` }));
+    const menuItems = (line) => {
+        if (line === "/provider" || line.startsWith("/provider ")) {
+            const query = line.slice("/provider".length).trim().toLowerCase();
+            return (options.providers?.providerIds() ?? []).filter((id) => id.includes(query))
+                .map((id) => ({ value: `provider ${id}`, label: `${id === options.providers?.provider ? "●" : "○"} ${id}` }));
+        }
+        if (line.startsWith("/") && !/\s/.test(line)) {
+            return commands.filter((item) => item.label.startsWith(line));
+        }
+        return [];
+    };
+    const refreshMenu = () => {
+        if (menu === undefined || inputClosed || signingIn || controller !== undefined)
+            return;
+        const line = readline.line;
+        menu.show(line === dismissedLine ? [] : menuItems(line), true);
+    };
+    const queueRefresh = () => {
+        if (refreshQueued)
+            return;
+        refreshQueued = true;
+        setImmediate(() => { refreshQueued = false; refreshMenu(); });
+    };
+    const replaceDraft = (value) => {
+        menu?.reset();
+        readline.write(null, { ctrl: true, name: "a" });
+        readline.write(null, { ctrl: true, name: "k" });
+        readline.write(value);
+    };
     let controller;
     let promptVisible = false;
+    let inputClosed = false;
+    let signingIn = false;
+    let composing = false;
+    let composeCancelled = false;
+    let interrupted = false;
+    if (tuiInput !== undefined) {
+        tuiInput.setMenuControls(() => {
+            menu?.clear();
+            dismissedLine = undefined;
+        }, (key) => {
+            if (signingIn || controller !== undefined)
+                return false;
+            if (key === "enter" && !menu?.active && readline.line === "/provider" && options.providers !== undefined) {
+                menu?.show(menuItems(readline.line));
+                return true;
+            }
+            if (key === "tab" && !menu?.active) {
+                const first = menuItems(readline.line)[0]?.value;
+                if (first !== undefined) {
+                    replaceDraft(`/${first}${first === "model" || first === "endpoint" ? " " : ""}`);
+                    queueRefresh();
+                    return true;
+                }
+            }
+            if (!menu?.active)
+                return false;
+            if (key === "up" || key === "down") {
+                menu.move(key === "up" ? -1 : 1);
+                return true;
+            }
+            if (key === "escape") {
+                dismissedLine = readline.line;
+                menu.clear();
+                return true;
+            }
+            const chosen = menu.selection;
+            if (chosen === undefined)
+                return false;
+            const replacement = `/${chosen}`;
+            if (key === "tab") {
+                replaceDraft(replacement + (chosen === "model" || chosen === "endpoint" ? " " : ""));
+                queueRefresh();
+                return true;
+            }
+            if (key === "enter") {
+                replaceDraft(replacement);
+                if (chosen === "provider" || chosen === "model" || chosen === "endpoint") {
+                    if (chosen !== "provider")
+                        readline.write(" ");
+                    queueRefresh();
+                }
+                else {
+                    tuiInput.markSubmitted();
+                    readline.write("\r");
+                }
+                return true;
+            }
+            return false;
+        });
+        tuiInput.on("keypress", queueRefresh);
+    }
     const showPrompt = () => {
+        if (inputClosed || options.inlineComposer)
+            return;
         promptVisible = true;
         readline.prompt();
     };
-    readline.on("line", () => { promptVisible = false; });
+    readline.on("line", () => { menu?.reset(); promptVisible = false; });
     readline.on("close", () => {
+        menu?.reset();
+        inputClosed = true;
         controller?.abort();
         if (options.tui && promptVisible) {
             // Ctrl+D closes an empty input line without printing a newline.
@@ -201,16 +378,22 @@ export async function runRepl(options) {
         }
     });
     readline.on("SIGINT", () => {
+        if (composing) {
+            composeCancelled = true;
+            readline.write("\r");
+            return;
+        }
         if (controller === undefined) {
             if (options.tui) {
-                // Use readline's editing operations so wrapped input is also erased.
+                // Erase wrapped drafts before removing the prompt on close.
                 readline.write(null, { ctrl: true, name: "e" });
                 readline.write(null, { ctrl: true, name: "u" });
             }
             else {
-                write("Press Ctrl+D or /exit to leave.\n");
+                options.output.write("\n");
             }
-            showPrompt();
+            interrupted = true;
+            readline.close();
             return;
         }
         controller.abort();
@@ -225,19 +408,283 @@ export async function runRepl(options) {
         const next = await lines.next();
         return next.done === true ? undefined : next.value;
     };
+    // Approval and normal input share the same readline iterator.
+    if (options.shellApproval !== undefined) {
+        options.shellApproval.setHandler(async (command, signal) => {
+            if (signal?.aborted)
+                return false;
+            menu?.clear();
+            options.liveRegion?.pause();
+            tuiInput?.setApprovalMode(true);
+            tuiInput?.setBusy(false);
+            try {
+                const width = terminalWidth({ columns: options.output.columns });
+                write(approvalPreview(command, width));
+                if (!commandReviewable(command, width)) {
+                    write("  Denied: command cannot be fully reviewed at this width. Ask for a shorter command.\n");
+                    return false;
+                }
+                readline.setPrompt("approve> ");
+                readline.prompt();
+                // Ctrl+C must unblock the pending line read, not leave the agent
+                // stuck waiting for a reply to an approval that was cancelled.
+                const unblockOnAbort = () => {
+                    readline.write("\n");
+                };
+                signal?.addEventListener("abort", unblockOnAbort, { once: true });
+                try {
+                    if (signal?.aborted)
+                        return false;
+                    const answer = await readNextLine();
+                    return answer?.trim().toLowerCase() === "y" && signal?.aborted !== true;
+                }
+                finally {
+                    signal?.removeEventListener("abort", unblockOnAbort);
+                }
+            }
+            finally {
+                readline.setPrompt(REPL_PROMPT);
+                tuiInput?.setApprovalMode(false);
+                tuiInput?.setBusy(true);
+                options.liveRegion?.resume();
+            }
+        });
+    }
+    /** Modal composer retains readline editing, Unicode and native history. */
+    const collectMultiline = async () => {
+        const parts = [];
+        let bytes = 0;
+        composing = true;
+        composeCancelled = false;
+        tuiInput?.setComposeMode(true);
+        menu?.clear();
+        dismissedLine = undefined;
+        readline.setPrompt("  │ ");
+        write("\nCompose prompt · Enter adds a line · /send submits · /cancel discards\n");
+        try {
+            for (;;) {
+                readline.prompt();
+                const part = await readNextLine();
+                if (tuiInput?.composeLimitExceeded) {
+                    write("Draft too large (64 KiB paste buffer). Nothing was sent.\n");
+                    return undefined;
+                }
+                if (composeCancelled || part === undefined || part.trim() === "/cancel") {
+                    write("Draft discarded.\n");
+                    return undefined;
+                }
+                if (part.trim() === "/send") {
+                    const message = parts.join("\n");
+                    if (message.trim().length === 0) {
+                        write("Empty draft discarded.\n");
+                        return undefined;
+                    }
+                    write(`Submitted ${parts.length} lines.\n`);
+                    return message;
+                }
+                bytes += Buffer.byteLength(part, "utf8") + 1;
+                if (parts.length >= 200 || bytes > 64 * 1024) {
+                    write("Draft too large (200 lines / 64 KiB). Nothing was sent.\n");
+                    return undefined;
+                }
+                // //send and //cancel are literal lines instead of commands.
+                parts.push(part.startsWith("//send") || part.startsWith("//cancel") ? part.slice(1) : part);
+            }
+        }
+        finally {
+            composing = false;
+            composeCancelled = false;
+            tuiInput?.setComposeMode(false);
+            readline.setPrompt(REPL_PROMPT);
+        }
+    };
+    /** Cursor-editable modal, with exclusive keyboard and paint ownership. */
+    const collectEditor = async (isDefault = false) => {
+        if (tuiInput === undefined) {
+            write("The cursor editor requires --tui. Use /compose here instead.\n");
+            return undefined;
+        }
+        menu?.clear();
+        dismissedLine = undefined;
+        composing = true;
+        let resolveDraft;
+        const pending = new Promise(resolve => { resolveDraft = resolve; });
+        const output = options.output;
+        const recent = options.session.messages
+            .filter((message) => message.role === "user")
+            .map(message => message.content)
+            .filter(message => message.length > 0)
+            .slice(-100);
+        const editor = new EditorController(output, resolveDraft, {
+            submitOnEnter: isDefault,
+            history: recent,
+            slashCommands: commands.map(item => ({ value: item.value, label: item.label })),
+            mouse: isDefault && options.tui === true && output.isTTY === true,
+        });
+        const resized = () => { editor.resized(); };
+        const closed = () => { editor.cancel(); };
+        tuiInput.setRawHandler(chunk => { editor.receive(chunk); });
+        output.on("resize", resized);
+        readline.once("close", closed);
+        options.input.once("end", closed);
+        try {
+            editor.begin();
+            const result = await pending;
+            if (editor.exitRequested.value)
+                readline.close();
+            if (!isDefault)
+                write(result === undefined ? "Draft discarded.\n" : "Draft submitted.\n");
+            return result;
+        }
+        finally {
+            tuiInput.setRawHandler(undefined);
+            output.off("resize", resized);
+            readline.off("close", closed);
+            options.input.off("end", closed);
+            composing = false;
+        }
+    };
+    /** Read-only patch viewer, safe and separate from the model's tool calls. */
+    const inspectPatch = async (override, label) => {
+        const patch = override ?? mostRecentSuccessfulPatch(options.session.messages);
+        if (patch === undefined) {
+            write("No successfully applied patch found in this session.\n");
+            return;
+        }
+        if (tuiInput === undefined) {
+            write("Interactive patch review requires --tui; use /diff instead.\n");
+            return;
+        }
+        menu?.clear();
+        let resolveReview;
+        const pending = new Promise(resolve => { resolveReview = resolve; });
+        const output = options.output;
+        const review = new PatchReviewController(output, patch, resolveReview, process.env.NO_COLOR === undefined && process.env.TERM !== "dumb", label);
+        const resized = () => { review.resized(); };
+        const closed = () => { review.cancel(); };
+        tuiInput.setRawHandler(chunk => { review.receive(chunk); });
+        output.on("resize", resized);
+        readline.once("close", closed);
+        try {
+            review.begin();
+            await pending;
+        }
+        finally {
+            tuiInput.setRawHandler(undefined);
+            output.off("resize", resized);
+            readline.off("close", closed);
+        }
+    };
+    const inspectLiveGitDiff = async (line) => {
+        if (tuiInput === undefined) {
+            write("Live Git review requires interactive --tui.\n");
+            return;
+        }
+        if (line !== "/gitdiff" && line !== "/gitdiff --staged") {
+            write("Usage: /gitdiff [--staged]\n");
+            return;
+        }
+        const mode = line.endsWith("--staged") ? "staged" : "working";
+        // Explicit user confirmation before starting any local Git process.
+        const root = terminalText(options.session.cwd);
+        write(`\nRead-only local Git diff (${mode}) in:\n${root}\nNo network, hooks, external diff or file writes. Approve once? [y/N]\n`);
+        tuiInput.acceptLine();
+        tuiInput.setApprovalMode(true);
+        readline.setPrompt("gitdiff> ");
+        let allowed = false;
+        try {
+            readline.prompt();
+            const answer = await readNextLine();
+            allowed = answer?.trim().toLowerCase() === "y";
+        }
+        finally {
+            tuiInput.setApprovalMode(false);
+            readline.setPrompt(REPL_PROMPT);
+        }
+        if (!allowed) {
+            write("Git diff review denied; no process started.\n");
+            return;
+        }
+        try {
+            const diff = await (options.gitDiffReader ?? readLiveGitDiff)(options.session.cwd, mode);
+            if (diff.trim().length === 0) {
+                write(`No ${mode} tracked Git changes found.\n`);
+                return;
+            }
+            await inspectPatch(diff, `live Git diff (${mode})`);
+        }
+        catch (error) {
+            write(`${error instanceof Error ? error.message : "Git diff unavailable"}\n`);
+        }
+    };
+    const signInAfterProviderSelection = async () => {
+        if (!options.tui || options.signIn === undefined)
+            return;
+        let missingKey;
+        try {
+            missingKey = options.signIn.needsApiKey === undefined
+                ? !options.signIn.ready()
+                : await options.signIn.needsApiKey();
+        }
+        catch (error) {
+            write(`Could not check saved API key: ${error instanceof Error ? error.message : String(error)}\n`);
+            return;
+        }
+        if (!missingKey)
+            return;
+        signingIn = true;
+        try {
+            await runSignIn(readline, readNextLine, write, options.signIn);
+        }
+        finally {
+            signingIn = false;
+        }
+    };
     try {
         for (;;) {
-            const line = await readNextLine();
+            let line = options.inlineComposer && tuiInput !== undefined
+                ? await collectEditor(true)
+                : await readNextLine();
             if (line === undefined) {
-                break;
+                if (inputClosed)
+                    break;
+                continue;
             }
             if (line.trim().length === 0) {
                 showPrompt();
                 continue;
             }
-            const outcome = handleSlashCommand(line, {
+            const fromComposer = line.trim() === "/compose";
+            const fromEditor = line.trim() === "/editor";
+            if (line.trim() === "/review") {
+                await inspectPatch();
+                if (inputClosed)
+                    break;
+                showPrompt();
+                continue;
+            }
+            if (line.trim().startsWith("/gitdiff")) {
+                await inspectLiveGitDiff(line.trim());
+                if (inputClosed)
+                    break;
+                showPrompt();
+                continue;
+            }
+            if (fromComposer || fromEditor) {
+                const draft = fromEditor ? await collectEditor() : await collectMultiline();
+                if (draft === undefined) {
+                    if (inputClosed)
+                        break;
+                    showPrompt();
+                    continue;
+                }
+                line = draft;
+            }
+            const outcome = fromComposer || fromEditor ? "not-a-command" : handleSlashCommand(line, {
                 session: options.session,
                 write,
+                width: terminalWidth({ columns: options.output.columns }),
+                color: options.tui === true && process.env.NO_COLOR === undefined && process.env.TERM !== "dumb",
                 ...(options.sessionFile === undefined
                     ? {}
                     : { sessionFile: options.sessionFile }),
@@ -245,13 +692,46 @@ export async function runRepl(options) {
                     ? {}
                     : { extensionCommands: options.extensionCommands }),
                 ...(options.signIn === undefined ? {} : { signIn: options.signIn }),
+                ...(options.providers === undefined ? {} : { providers: options.providers }),
             });
             if (outcome === "exit") {
                 break;
             }
             if (typeof outcome === "object" && outcome.kind === "login") {
+                if (outcome.providerArgument.length > 0) {
+                    if (options.providers === undefined) {
+                        write("Provider switching is unavailable in this session.\n");
+                        showPrompt();
+                        continue;
+                    }
+                    const selected = await options.providers.select(outcome.providerArgument);
+                    write(selected.message);
+                    if (!selected.ok) {
+                        showPrompt();
+                        continue;
+                    }
+                }
                 if (options.signIn !== undefined) {
-                    await runSignIn(readline, readNextLine, write, options.signIn);
+                    signingIn = true;
+                    try {
+                        await runSignIn(readline, readNextLine, write, options.signIn);
+                    }
+                    finally {
+                        signingIn = false;
+                    }
+                }
+                showPrompt();
+                continue;
+            }
+            if (typeof outcome === "object" && (outcome.kind === "provider" || outcome.kind === "model" || outcome.kind === "endpoint")) {
+                if (options.providers !== undefined) {
+                    const selected = outcome.kind === "provider"
+                        ? await options.providers.select(outcome.argument)
+                        : outcome.kind === "model" ? await options.providers.changeModel(outcome.argument)
+                            : await options.providers.changeEndpoint(outcome.argument);
+                    write(selected.message);
+                    if (selected.ok && outcome.kind === "provider")
+                        await signInAfterProviderSelection();
                 }
                 showPrompt();
                 continue;
@@ -280,7 +760,7 @@ export async function runRepl(options) {
             if (options.signIn !== undefined && !options.signIn.ready()) {
                 // Saying this before the run starts is clearer than letting the Provider
                 // call fail and reporting it as an agent failure.
-                write("No API key yet. Run /login to add one.\n");
+                write(`${options.providers?.unavailableMessage?.() ?? `No API key for ${options.signIn.provider}. Run /login or use /provider to switch.`}\n`);
                 showPrompt();
                 continue;
             }
@@ -306,9 +786,10 @@ export async function runRepl(options) {
         }
     }
     finally {
+        options.shellApproval?.setHandler(undefined);
         readline.close();
         tuiInput?.dispose();
     }
-    return 0;
+    return interrupted ? 130 : 0;
 }
 //# sourceMappingURL=repl.js.map