@megacode/cli 0.2.0

package/dist/ui/ConfigMenu.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { loadSettings } from "../adapters/settings.js";
+import { configDir } from "../adapters/storage.js";
+import { DEFAULT_SETTINGS } from "../core/settings.js";
+import { Dialog } from "./Dialog.js";
+import { tildify } from "./format.js";
+const seconds = (ms) => (ms < 60_000 ? `${ms / 1000}s` : `${ms / 60_000}m`);
+const onOff = [
+    { value: true, label: "on" },
+    { value: false, label: "off" },
+];
+const ENTRIES = [
+    {
+        key: "permissionMode",
+        label: "Permission mode",
+        description: "Ask before writes, edits and shell commands, auto-accept edits only, or bypass all prompts. Applies now and to new sessions (--ask overrides; shift+tab cycles)",
+        choices: [
+            { value: "ask", label: "ask" },
+            { value: "accept-edits", label: "accept edits" },
+            { value: "yolo", label: "bypass" },
+        ],
+    },
+    {
+        key: "maxSteps",
+        label: "Max steps per turn",
+        description: "Model calls the agent may make for one message before it stops",
+        choices: [25, 50, 100, 200].map((n) => ({ value: n, label: String(n) })),
+    },
+    {
+        key: "bashTimeoutMs",
+        label: "Shell command timeout",
+        description: "How long a bash command may run, unless the model asks for a different timeout",
+        choices: [30_000, 120_000, 300_000, 600_000].map((n) => ({ value: n, label: seconds(n) })),
+    },
+    {
+        key: "maxToolOutput",
+        label: "Max tool output",
+        description: "Characters of command and MCP output sent to the model; longer output keeps both ends and is saved to a temp file the model can read",
+        choices: [6_000, 12_000, 30_000, 100_000].map((n) => ({ value: n, label: `${n / 1000}k chars` })),
+    },
+    {
+        key: "projectInstructions",
+        label: "Load AGENTS.md / CLAUDE.md",
+        description: "Add project instruction files from the working directory to the system prompt",
+        choices: onOff,
+    },
+    {
+        key: "worktreeBase",
+        label: "Worktree base",
+        description: "What /worktree and -w branch from: the remote's default branch (origin/HEAD), or the commit you're on",
+        choices: [
+            { value: "fresh", label: "default branch" },
+            { value: "head", label: "current commit" },
+        ],
+    },
+    {
+        key: "promptAutocomplete",
+        label: "Prompt autocomplete",
+        description: "Suggest a next prompt from the current conversation; tab accepts without sending. Uses an extra model request after each turn",
+        choices: onOff,
+    },
+    {
+        key: "saveHistory",
+        label: "Save prompt history",
+        description: "Keep ↑/↓ history across sessions in history.json",
+        choices: onOff,
+    },
+];
+const label = (e, value) => e.choices.find((c) => c.value === value)?.label ?? String(value);
+/** Every setting in one list: ↑/↓ to move, enter/space/←/→ to change, esc to close. Changes save immediately. */
+export function ConfigMenu({ model, mode, onChange, onModel, onClose, }) {
+    const [settings, setSettings] = useState(() => ({ ...loadSettings(), permissionMode: mode }));
+    const [index, setIndex] = useState(0);
+    const rows = ENTRIES.length + 1; // row 0 is the model
+    const cycle = (e, step) => {
+        const i = e.choices.findIndex((c) => c.value === settings[e.key]);
+        // A value hand-edited into settings.json may not be a choice; start from the first one.
+        const next = e.choices[i === -1 ? 0 : (i + step + e.choices.length) % e.choices.length].value;
+        const patch = { [e.key]: next };
+        setSettings((s) => ({ ...s, ...patch }));
+        onChange(patch);
+    };
+    useInput((input, key) => {
+        if (key.escape)
+            return onClose();
+        if (key.upArrow || (key.ctrl && input === "p"))
+            return setIndex((i) => (i - 1 + rows) % rows);
+        if (key.downArrow || (key.ctrl && input === "n"))
+            return setIndex((i) => (i + 1) % rows);
+        const activate = key.return || input === " ";
+        if (index === 0)
+            return activate ? onModel() : undefined;
+        if (activate || key.rightArrow)
+            cycle(ENTRIES[index - 1], 1);
+        else if (key.leftArrow)
+            cycle(ENTRIES[index - 1], -1);
+    });
+    const selected = index === 0 ? null : ENTRIES[index - 1];
+    const description = selected ? selected.description : "Model for new messages (opens the model picker)";
+    return (_jsxs(Dialog, { title: "Settings", subtitle: `saved to ${tildify(configDir())}/settings.json`, footer: "\u2191\u2193 navigate \u00B7 enter/space/\u2190\u2192 change \u00B7 esc close", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { selected: index === 0, label: "Model", value: model }), ENTRIES.map((e, i) => (_jsx(Row, { selected: index === i + 1, label: e.label, value: label(e, settings[e.key]), isDefault: settings[e.key] === DEFAULT_SETTINGS[e.key] }, e.key)))] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: description }) })] }));
+}
+function Row({ selected, label, value, isDefault = true }) {
+    return (_jsxs(Text, { color: selected ? "cyan" : undefined, children: [selected ? "❯ " : "  ", label.padEnd(30), _jsx(Text, { bold: !isDefault, children: value })] }));
+}

package/dist/ui/Dialog.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/**
+ * The frame every dialog uses, so spacing is the same everywhere: title line, a blank line,
+ * the body, then dim key hints. `warn` marks dialogs that ask before something happens.
+ */
+export function Dialog({ title, subtitle, footer, tone = "default", children, }) {
+    const color = tone === "warn" ? "yellow" : "cyan";
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, paddingX: 1, marginTop: 1, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: tone === "warn" ? color : undefined, children: title }), subtitle ? _jsxs(Text, { dimColor: true, children: [" \u00B7 ", subtitle] }) : null] }), children ? _jsx(Box, { flexDirection: "column", marginTop: 1, children: children }) : null, footer ? _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: footer }) }) : null] }));
+}

package/dist/ui/DiffLines.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { DIFF_COLORS, gutter, pieces, rowStyle } from "./diff.js";
+/** Diff rows as Claude Code draws them. Changed rows fill their width; long lines wrap under the code. */
+export function DiffLines({ model }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [model.rows.map((row, i) => {
+                if (row.type === "gap")
+                    return (_jsxs(Text, { color: DIFF_COLORS.muted, children: [gutter(row, model), "\u2026"] }, i));
+                const style = rowStyle(row);
+                return (_jsxs(Box, { backgroundColor: style.background, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: style.color, backgroundColor: style.background, children: gutter(row, model) }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsx(Text, { wrap: "wrap", color: style.color, backgroundColor: style.background, children: pieces(row).map((p, j) => (_jsx(Text, { backgroundColor: p.changed ? style.word : style.background, children: p.text }, j))) }) })] }, i));
+            }), model.hidden > 0 && _jsxs(Text, { color: DIFF_COLORS.muted, children: ["\u2026 +", model.hidden, " lines"] })] }));
+}

package/dist/ui/EffortPicker.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EFFORTS } from "../core/provider.js";
+import { Dialog } from "./Dialog.js";
+import { Select } from "./Select.js";
+/** /effort without an argument: pick the reasoning effort for future turns. */
+export function EffortPicker({ current = "default", onSelect, onCancel }) {
+    return (_jsx(Dialog, { title: "Model effort", subtitle: current, footer: "Saved for future turns \u00B7 model support varies \u00B7 esc cancel", children: _jsx(Select, { options: EFFORTS.map((effort) => ({ label: effort, value: effort })), initialIndex: Math.max(0, EFFORTS.indexOf(current)), onSelect: onSelect, onCancel: onCancel }) }));
+}

package/dist/ui/Help.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "ink";
+import { COMMANDS } from "./commands.js";
+import { KeyList } from "./KeyList.js";
+const SHORTCUTS = [
+    ["enter", "send message (queued while running)"],
+    ["ctrl+s", "send queued messages now (interrupts the running turn)"],
+    ["\\ + enter, option+enter", "newline"],
+    ["↑ / ↓", "prompt history"],
+    ["tab", "accept prompt suggestion / complete command"],
+    ["alt+← / alt+→", "move cursor by word"],
+    ["/", "commands"],
+    ["esc", "interrupt · clear input"],
+    ["shift+tab", "cycle permission mode"],
+    ["ctrl+a / ctrl+e", "start / end of line"],
+    ["ctrl+u / ctrl+k / ctrl+w", "delete to start / end / word"],
+    ["ctrl+c", "interrupt · clear · exit (twice)"],
+];
+export function Help() {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, marginTop: 1, gap: 1, children: [_jsx(KeyList, { rows: SHORTCUTS }), _jsx(KeyList, { rows: COMMANDS.map((c) => [c.name, c.description]) })] }));
+}

package/dist/ui/KeyList.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/**
+ * Keys or commands in one column, what they do in the next. Long descriptions wrap inside
+ * their own column, so the left column stays readable at any width.
+ */
+export function KeyList({ rows, selected }) {
+    const width = Math.max(...rows.map(([key]) => key.length)) + 2;
+    return (_jsx(Box, { flexDirection: "column", children: rows.map(([key, text], i) => (_jsxs(Box, { children: [_jsx(Box, { width: width, flexShrink: 0, children: _jsx(Text, { color: "cyan", children: key }) }), _jsx(Box, { flexShrink: 1, minWidth: 0, children: _jsx(Text, { dimColor: i !== selected, color: i === selected ? "cyan" : undefined, children: text }) })] }, key))) }));
+}

package/dist/ui/LoginDialog.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { useRef, useState } from "react";
+import { countModels, saveChatGPTLogin, verifyAndSaveKey } from "../adapters/accounts.js";
+import { loginAnthropicCLI } from "../adapters/auth/anthropic.js";
+import { loginChatGPT } from "../adapters/auth/chatgpt.js";
+import { loginOpenRouter } from "../adapters/auth/openrouter.js";
+import { savedCredentials, savedProviders } from "../adapters/auth/store.js";
+import { configDir } from "../adapters/storage.js";
+import { envKeyName, PROVIDER_INFO, providerInfo } from "../adapters/providers/catalog.js";
+import { authStatus, isConfigured } from "../adapters/providers/credentials.js";
+import { Dialog } from "./Dialog.js";
+import { tildify } from "./format.js";
+import { firstStep, friendlyError, stepAfterFailure, stepBack } from "./loginFlow.js";
+import { Select } from "./Select.js";
+import { Waiting } from "./Spinner.js";
+import { TextField } from "./TextField.js";
+const METHOD_LABELS = {
+    chatgpt: ["Sign in with ChatGPT", "use your Plus / Pro / Business plan"],
+    "openrouter-oauth": ["Sign in with OpenRouter", "in your browser; creates a key for megacode"],
+    "ant-cli": ["Sign in with the Anthropic CLI", "runs `ant auth login` in your browser"],
+    key: ["Paste an API key", ""],
+    url: ["Connect to a server", ""],
+};
+/**
+ * /login: provider → sign-in method → browser OAuth, API key or endpoint → verify by listing models → save.
+ */
+export function LoginDialog({ initialProvider, welcome, onDone, onCancel, }) {
+    const [provider, setProvider] = useState(initialProvider);
+    const [step, setStep] = useState(initialProvider ? firstStep(providerInfo(initialProvider)) : "pick");
+    const [method, setMethod] = useState();
+    const [baseURL, setBaseURL] = useState(initialProvider ? defaultURL(initialProvider) : "");
+    const [apiKey, setApiKey] = useState("");
+    const [error, setError] = useState("");
+    const [browserUrl, setBrowserUrl] = useState("");
+    const [output, setOutput] = useState([]);
+    const abort = useRef(null);
+    const info = provider ? providerInfo(provider) : undefined;
+    function pick(name) {
+        setProvider(name);
+        setBaseURL(defaultURL(name));
+        setApiKey("");
+        setError("");
+        setStep(firstStep(providerInfo(name)));
+    }
+    function back() {
+        setError("");
+        if (step === "browser")
+            abort.current?.abort();
+        const previous = stepBack(step, info, !!initialProvider);
+        if (previous === "close")
+            onCancel();
+        else
+            setStep(previous);
+    }
+    function chooseMethod(m) {
+        setMethod(m);
+        setError("");
+        if (m === "key")
+            return setStep("key");
+        if (m === "url")
+            return setStep("url");
+        browserLogin(m);
+    }
+    async function browserLogin(m) {
+        const name = provider;
+        const ctrl = (abort.current = new AbortController());
+        setBrowserUrl("");
+        setOutput([]);
+        setStep("browser");
+        try {
+            if (m === "chatgpt") {
+                saveChatGPTLogin(await loginChatGPT(setBrowserUrl, ctrl.signal));
+                return await finish(name, "", m);
+            }
+            if (m === "openrouter-oauth")
+                return await verify(await loginOpenRouter(setBrowserUrl, ctrl.signal), m);
+            if (m === "ant-cli") {
+                await loginAnthropicCLI((line) => setOutput((o) => [...o.slice(-4), line]), ctrl.signal);
+                return await finish(name, "", m);
+            }
+        }
+        catch (e) {
+            if (ctrl.signal.aborted)
+                return;
+            setError(e.message);
+            setStep("method");
+        }
+    }
+    // `via` and `url` are passed along rather than read from state: they're often set in the same
+    // handler that calls these, and the state wouldn't show them yet.
+    /** Save an API key / endpoint after checking it works. */
+    async function verify(key, via = method, url = baseURL) {
+        const name = provider;
+        setStep("verifying");
+        setError("");
+        try {
+            await verifyAndSaveKey(name, { apiKey: key, baseURL: url });
+        }
+        catch (e) {
+            return fail(e, key, via, url);
+        }
+        await finish(name, key, via);
+    }
+    /** Credentials are in place: count the models and hand back to the app. */
+    async function finish(name, key, via) {
+        setStep("verifying");
+        try {
+            onDone(name, await countModels(name));
+        }
+        catch (e) {
+            fail(e, key, via);
+        }
+    }
+    function fail(e, key, via, url = baseURL) {
+        const p = providerInfo(provider);
+        setError(friendlyError(e, p, url));
+        setStep(stepAfterFailure(p, via, key));
+    }
+    useInput((_, key) => key.escape && back(), { isActive: step === "browser" });
+    const envKey = info && envKeyName(info);
+    const envNote = envKey && _jsxs(Text, { color: "yellow", children: ["$", envKey, " is set and takes precedence over anything saved here."] });
+    const errorLine = error && _jsx(Text, { color: "red", children: error });
+    const keys = "enter continue · esc back";
+    if (step === "pick" || !info)
+        return (_jsxs(Dialog, { title: welcome ? "Welcome to megacode" : "Log in to a provider", footer: `Saved to ${tildify(configDir())}/auth.json, readable only by you · esc close`, children: [welcome && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Connect a model provider to get started. You can add more later with /login." }) })), _jsx(Select, { options: PROVIDER_INFO.map((p) => ({
+                        label: p.label,
+                        value: p.name,
+                        hint: p.local ? defaultURL(p.name) : isConfigured(p.name) ? `✔ ${authStatus(p.name)}` : undefined,
+                    })), onSelect: pick, onCancel: onCancel })] }));
+    if (step === "method")
+        return (_jsxs(Dialog, { title: `Log in to ${info.label}`, subtitle: "how do you want to sign in?", footer: "enter select \u00B7 esc back", children: [errorLine, envNote, _jsx(Box, { marginTop: error || envNote ? 1 : 0, children: _jsx(Select, { options: info.methods.map((m) => ({ label: METHOD_LABELS[m][0], value: m, hint: METHOD_LABELS[m][1] || undefined })), onSelect: chooseMethod, onCancel: back }) })] }));
+    if (step === "browser")
+        return (_jsxs(Dialog, { title: method ? METHOD_LABELS[method][0] : "Sign in", footer: "esc cancel", children: [_jsx(Text, { dimColor: true, children: method === "ant-cli" ? "Running `ant auth login`. Finish signing in in your browser." : "Finish signing in in your browser. If it didn't open, visit:" }), browserUrl && _jsx(Text, { color: "cyan", children: browserUrl }), output.map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))), _jsx(Box, { marginTop: 1, children: _jsx(Waiting, { text: "Waiting for sign-in\u2026" }) })] }));
+    if (step === "url")
+        return (_jsxs(Dialog, { title: `Log in to ${info.label}`, subtitle: "endpoint URL", footer: keys, children: [_jsx(Text, { dimColor: true, children: info.local ? `Make sure the server is running. Default: ${info.baseURL}` : "Base URL of the OpenAI-compatible API, e.g. https://host/v1" }), errorLine, _jsx(Box, { marginTop: 1, children: _jsx(TextField, { value: baseURL, onChange: setBaseURL, placeholder: info.baseURL ?? "https://…/v1", onSubmit: (v) => {
+                            const url = v || info.baseURL || "";
+                            if (!url)
+                                return setError("An endpoint URL is required.");
+                            setBaseURL(url);
+                            if (info.local)
+                                verify("", method, url);
+                            else
+                                setStep("key");
+                        }, onCancel: back }) })] }));
+    if (step === "key")
+        return (_jsxs(Dialog, { title: `Log in to ${info.label}`, subtitle: "API key", footer: keys, children: [info.keyUrl && _jsxs(Text, { dimColor: true, children: ["Create one at ", info.keyUrl] }), info.keyOptional && _jsx(Text, { dimColor: true, children: "Leave empty if the endpoint doesn't need a key." }), envNote, errorLine, _jsx(Box, { marginTop: info.keyUrl || info.keyOptional || envNote || error ? 1 : 0, children: _jsx(TextField, { value: apiKey, onChange: setApiKey, mask: true, placeholder: "paste your key and press enter", onSubmit: (v) => (v || info.keyOptional ? verify(v) : setError("Paste a key, or esc to go back.")), onCancel: back }) })] }));
+    return (_jsx(Dialog, { title: `Log in to ${info.label}`, children: _jsx(Waiting, { text: `Connecting to ${info.label}…` }) }));
+}
+/** /logout: pick which saved credentials to remove. */
+export function LogoutDialog({ onSelect, onCancel }) {
+    return (_jsx(Dialog, { title: "Remove saved credentials", footer: "enter remove \u00B7 esc cancel", children: _jsx(Select, { options: savedProviders().map((n) => ({ label: providerInfo(n).label, value: n, hint: authStatus(n) })), onSelect: onSelect, onCancel: onCancel }) }));
+}
+const defaultURL = (name) => savedCredentials(name)?.baseURL ?? providerInfo(name).baseURL ?? "";

package/dist/ui/McpMenu.js

@@ -0,0 +1,138 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useEffect, useReducer, useState } from "react";
+import { describeServer, draftToConfig, MCP_FILE, parseExtra, transportOf, } from "../adapters/mcp/config.js";
+import { mcp } from "../adapters/mcp/manager.js";
+import { configDir } from "../adapters/storage.js";
+import { previousAddStep, serverNameError, targetError } from "./mcpWizard.js";
+import { tildify } from "./format.js";
+import { Dialog } from "./Dialog.js";
+import { Select } from "./Select.js";
+import { TextField } from "./TextField.js";
+const MAX_TOOLS_SHOWN = 15;
+function statusText(s) {
+    switch (s.state) {
+        case "connected":
+            return `✔ connected · ${s.tools.length} tool${s.tools.length === 1 ? "" : "s"}`;
+        case "connecting":
+            return "… connecting";
+        case "failed":
+            return `✗ ${s.error}`;
+        case "disabled":
+            return "○ disabled";
+    }
+}
+const statusColor = (s) => ({ connected: "green", connecting: "yellow", failed: "red", disabled: "gray" })[s.state];
+/** List, add, inspect, reconnect, enable/disable and remove MCP servers. Changes save to ~/.megacode/mcp.json. */
+export function McpMenu({ onClose }) {
+    const [, rerender] = useReducer((n) => n + 1, 0);
+    useEffect(() => mcp.subscribe(rerender), []);
+    const [screen, setScreen] = useState({ type: "list" });
+    const [input, setInput] = useState("");
+    const [error, setError] = useState("");
+    const servers = mcp.servers();
+    const file = `${tildify(configDir())}/${MCP_FILE}`;
+    const go = (s) => {
+        setScreen(s);
+        setInput("");
+        setError("");
+    };
+    let body;
+    let help = "↑↓ navigate · enter select · esc back";
+    if (screen.type === "list") {
+        help = "↑↓ navigate · enter select · esc close";
+        body = (_jsxs(_Fragment, { children: [servers.length === 0 && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "No MCP servers yet. Add one to give megacode more tools." }) })), _jsx(Select, { options: [
+                        ...servers.map((s) => ({ label: s.name, value: s.name, hint: statusText(s.status) })),
+                        { label: "Add server…", value: "" },
+                    ], onSelect: (name) => (name ? go({ type: "server", name }) : go({ type: "add", step: "name", draft: { name: "", type: "stdio", target: "", extras: {} } })), onCancel: onClose })] }));
+    }
+    else if (screen.type === "server") {
+        const server = servers.find((s) => s.name === screen.name);
+        if (!server) {
+            body = _jsx(Text, { dimColor: true, children: "Server removed." });
+        }
+        else {
+            const { config, status } = server;
+            const extras = "url" in config ? Object.keys(config.headers ?? {}) : Object.keys(config.env ?? {});
+            const tools = status.state === "connected" ? status.tools : [];
+            body = (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: server.name }), " ", _jsxs(Text, { dimColor: true, children: ["(", transportOf(config), ")"] }), " ", _jsx(Text, { color: statusColor(status), children: statusText(status) })] }), _jsx(Text, { dimColor: true, children: describeServer(config) }), extras.length > 0 && _jsxs(Text, { dimColor: true, children: ["url" in config ? "headers" : "env", ": ", extras.join(", ")] }), tools.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [tools.slice(0, MAX_TOOLS_SHOWN).map((t) => (_jsxs(Text, { children: ["  ", t.tool, _jsxs(Text, { dimColor: true, children: [" ", t.description.split("\n")[0].slice(0, 70)] })] }, t.name))), tools.length > MAX_TOOLS_SHOWN && _jsx(Text, { dimColor: true, children: `  … and ${tools.length - MAX_TOOLS_SHOWN} more` })] })), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
+                                ...(config.disabled
+                                    ? [{ label: "Enable", value: "enable" }]
+                                    : [
+                                        { label: "Reconnect", value: "reconnect" },
+                                        { label: "Disable", value: "disable" },
+                                    ]),
+                                { label: "Remove", value: "remove" },
+                                { label: "Back", value: "back" },
+                            ], onSelect: (action) => {
+                                if (action === "reconnect")
+                                    mcp.connect(server.name);
+                                else if (action === "enable")
+                                    mcp.setEnabled(server.name, true);
+                                else if (action === "disable")
+                                    mcp.setEnabled(server.name, false);
+                                else if (action === "remove")
+                                    go({ type: "remove", name: server.name });
+                                else
+                                    go({ type: "list" });
+                            }, onCancel: () => go({ type: "list" }) }, `${server.name}-${status.state}`) })] }));
+        }
+    }
+    else if (screen.type === "remove") {
+        body = (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Remove ", screen.name, " from ", file, "?"] }), _jsx(Select, { options: [
+                        { label: "No, keep it", value: false },
+                        { label: "Yes, remove", value: true },
+                    ], onSelect: async (yes) => {
+                        if (!yes)
+                            return go({ type: "server", name: screen.name });
+                        await mcp.remove(screen.name);
+                        go({ type: "list" });
+                    }, onCancel: () => go({ type: "server", name: screen.name }) })] }));
+    }
+    else {
+        const { step, draft } = screen;
+        const isUrl = draft.type !== "stdio";
+        const back = () => {
+            const previous = previousAddStep(step);
+            go(previous ? { type: "add", step: previous, draft } : { type: "list" });
+        };
+        help = "enter continue · esc back";
+        const field = (prompt, placeholder, submit) => (_jsxs(_Fragment, { children: [_jsx(Text, { children: prompt }), _jsx(TextField, { value: input, onChange: (v) => {
+                        setInput(v);
+                        setError("");
+                    }, onSubmit: submit, onCancel: back, placeholder: placeholder })] }));
+        if (step === "name")
+            body = field("Server name (used in tool names, e.g. mcp__github__create_issue):", "e.g. github", (v) => {
+                const problem = serverNameError(v, servers.map((s) => s.name));
+                if (problem)
+                    return setError(problem);
+                go({ type: "add", step: "type", draft: { ...draft, name: v } });
+            });
+        else if (step === "type")
+            body = (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["How does megacode reach ", draft.name, "?"] }), _jsx(Select, { options: [
+                            { label: "stdio", value: "stdio", hint: "run a local command (npx, uvx, docker, a binary…)" },
+                            { label: "http", value: "http", hint: "remote server, streamable HTTP" },
+                            { label: "sse", value: "sse", hint: "remote server, legacy SSE" },
+                        ], onSelect: (type) => go({ type: "add", step: "target", draft: { ...draft, type, extras: {} } }), onCancel: back })] }));
+        else if (step === "target")
+            body = field(isUrl ? "Server URL:" : "Command to start the server:", isUrl ? "https://example.com/mcp" : "npx -y @modelcontextprotocol/server-filesystem ~/projects", (v) => {
+                const problem = targetError(draft.type, v);
+                if (problem)
+                    return setError(problem);
+                go({ type: "add", step: "extras", draft: { ...draft, target: v } });
+            });
+        else
+            body = (_jsxs(_Fragment, { children: [Object.entries(draft.extras).map(([k]) => (_jsxs(Text, { dimColor: true, children: ["  ", isUrl ? `${k}: ••••` : `${k}=••••`] }, k))), field(isUrl ? "Add a header (Name: value), or press enter to finish:" : "Add an environment variable (KEY=value), or press enter to finish:", isUrl ? "Authorization: Bearer …" : "GITHUB_TOKEN=…", (v) => {
+                        if (!v) {
+                            mcp.add(draft.name, draftToConfig(draft));
+                            return go({ type: "server", name: draft.name });
+                        }
+                        const extra = parseExtra(draft.type, v);
+                        if (!extra)
+                            return setError(isUrl ? "Use the form Name: value" : "Use the form KEY=value");
+                        const [key, value] = extra;
+                        go({ type: "add", step: "extras", draft: { ...draft, extras: { ...draft.extras, [key]: value } } });
+                    })] }));
+    }
+    return (_jsxs(Dialog, { title: "MCP servers", subtitle: file, footer: help, children: [body, error && _jsx(Text, { color: "red", children: error })] }));
+}

package/dist/ui/ModelPicker.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput, usePaste } from "ink";
+import { useEffect, useMemo, useState } from "react";
+import { PROVIDER_INFO } from "../adapters/providers/catalog.js";
+import { isConfigured } from "../adapters/providers/credentials.js";
+import { listModels } from "../adapters/providers/registry.js";
+import { Dialog } from "./Dialog.js";
+const WINDOW = 12;
+/** Searchable list of every model from every configured provider, fetched live. */
+export function ModelPicker({ current, initialQuery = "", onSelect, onLogin, onCancel, }) {
+    const [query, setQuery] = useState(initialQuery);
+    const [lists, setLists] = useState({});
+    const [index, setIndex] = useState(0);
+    const [touched, setTouched] = useState(false); // user moved the cursor; stop auto-selecting current
+    useEffect(() => {
+        for (const p of PROVIDER_INFO) {
+            if (!isConfigured(p.name))
+                continue;
+            setLists((l) => ({ ...l, [p.name]: { status: "loading" } }));
+            listModels(p.name).then((models) => setLists((l) => ({ ...l, [p.name]: { status: "ok", models } })), (e) => setLists((l) => ({ ...l, [p.name]: { status: "error", error: e.message.split("\n")[0] } })));
+        }
+    }, []);
+    const rows = useMemo(() => {
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const matches = (s) => terms.every((t) => s.toLowerCase().includes(t));
+        const out = [];
+        const seen = new Set();
+        for (const p of PROVIDER_INFO) {
+            const state = lists[p.name];
+            if (!isConfigured(p.name)) {
+                if (!p.local && !p.keyOptional && matches(`${p.name} ${p.label} login`))
+                    out.push({ provider: p.name, label: "Log in to see models…", action: { type: "login", provider: p.name }, dim: true });
+                continue;
+            }
+            if (!state || state.status === "loading") {
+                if (matches(p.name))
+                    out.push({ provider: p.name, label: "loading…", action: { type: "none" }, dim: true });
+            }
+            else if (state.status === "error") {
+                // Local servers that aren't running just don't show up.
+                if (!p.local && matches(p.name))
+                    out.push({
+                        provider: p.name,
+                        label: `couldn't list models: ${state.error}`,
+                        action: { type: "login", provider: p.name },
+                        dim: true,
+                    });
+            }
+            else {
+                for (const m of state.models) {
+                    const spec = `${p.name}:${m}`;
+                    seen.add(spec);
+                    if (matches(spec))
+                        out.push({ provider: p.name, label: m, action: { type: "model", spec } });
+                }
+            }
+        }
+        // Anything typed as provider:model can be used even if the provider doesn't list it.
+        const typed = query.trim();
+        if (/^[a-z]+:\S+$/.test(typed) && !seen.has(typed))
+            out.unshift({ provider: typed.split(":")[0], label: `use "${typed.slice(typed.indexOf(":") + 1)}"`, action: { type: "model", spec: typed } });
+        return out;
+    }, [lists, query]);
+    // Start on the current model until the user moves; clamp when the list shrinks.
+    useEffect(() => {
+        if (!touched) {
+            const i = rows.findIndex((r) => r.action.type === "model" && r.action.spec === current);
+            setIndex(Math.max(0, i));
+        }
+        else
+            setIndex((i) => Math.min(i, Math.max(0, rows.length - 1)));
+    }, [rows]);
+    const move = (d) => {
+        setTouched(true);
+        setIndex((i) => Math.max(0, Math.min(rows.length - 1, i + d)));
+    };
+    usePaste((text) => setQuery((q) => q + text.trim()));
+    useInput((input, key) => {
+        if (key.escape)
+            return onCancel();
+        if (key.upArrow)
+            return move(-1);
+        if (key.downArrow)
+            return move(1);
+        if (key.pageUp)
+            return move(-WINDOW);
+        if (key.pageDown)
+            return move(WINDOW);
+        if (key.return) {
+            const row = rows[index];
+            if (row?.action.type === "model")
+                onSelect(row.action.spec);
+            else if (row?.action.type === "login")
+                onLogin(row.action.provider);
+            return;
+        }
+        if (key.backspace || key.delete)
+            return setQuery((q) => q.slice(0, -1));
+        if (key.ctrl && input === "u")
+            return setQuery("");
+        if (key.ctrl || key.meta || key.tab || key.leftArrow || key.rightArrow)
+            return;
+        if (input) {
+            setTouched(true);
+            setIndex(0);
+            setQuery((q) => q + input);
+        }
+    });
+    const start = Math.max(0, Math.min(index - Math.floor(WINDOW / 2), rows.length - WINDOW));
+    const visible = rows.slice(start, start + WINDOW);
+    const loading = Object.values(lists).some((l) => l.status === "loading");
+    return (_jsxs(Dialog, { title: "Select model", subtitle: `${rows.filter((r) => r.action.type === "model").length} models${loading ? " · loading…" : ""}`, footer: "\u2191\u2193 navigate \u00B7 enter select \u00B7 esc cancel \u00B7 /login to add a provider", children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "\u2315 " }), query || _jsx(Text, { dimColor: true, children: "type to filter, or provider:model for anything unlisted" }), query ? _jsx(Text, { inverse: true, children: " " }) : null] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [start > 0 && _jsx(Text, { dimColor: true, children: `  ↑ ${start} more` }), visible.map((r, i) => {
+                        const selected = start + i === index;
+                        const isCurrent = r.action.type === "model" && r.action.spec === current;
+                        return (_jsxs(Text, { color: selected ? "cyan" : undefined, dimColor: !selected && r.dim, children: [selected ? "❯ " : "  ", _jsx(Text, { dimColor: !selected, children: r.provider.padEnd(11) }), r.label, isCurrent ? _jsx(Text, { color: "green", children: " \u2714" }) : null] }, `${r.provider}:${r.label}`));
+                    }), rows.length === 0 && _jsx(Text, { dimColor: true, children: "  No matches." }), start + WINDOW < rows.length && _jsx(Text, { dimColor: true, children: `  ↓ ${rows.length - start - WINDOW} more` })] })] }));
+}