@megacode/cli 0.2.0

package/dist/ui/PromptInput.js

@@ -0,0 +1,161 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput, usePaste } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { promptCompletion } from "./autocomplete.js";
+import { KeyList } from "./KeyList.js";
+/**
+ * Multi-line prompt editor with readline-style shortcuts, history and a slash-command menu.
+ * Newline: "\" + enter, or option/alt + enter.
+ */
+export function PromptInput({ value, onChange, onSubmit, onHelp, isActive, history, autocomplete, suggestion, commands, placeholder }) {
+    const [cursor, setCursor] = useState(value.length);
+    const [menuIndex, setMenuIndex] = useState(0);
+    const historyPos = useRef(-1); // -1 = editing a fresh draft
+    const draft = useRef("");
+    // Keep the cursor valid when the value is changed from outside (clear, history, etc.).
+    useEffect(() => setCursor((c) => Math.min(c, value.length)), [value]);
+    const completion = promptCompletion(value, cursor, suggestion, autocomplete && isActive);
+    const menu = /^\/\S*$/.test(value) ? commands.filter((c) => c.name.startsWith(value)) : [];
+    useEffect(() => setMenuIndex(0), [value]);
+    const set = (v, c = v.length) => {
+        onChange(v);
+        setCursor(c);
+    };
+    const insert = (text) => set(value.slice(0, cursor) + text + value.slice(cursor), cursor + text.length);
+    // Line/column helpers for multi-line navigation.
+    const lineStart = value.lastIndexOf("\n", cursor - 1) + 1;
+    const lineEndIdx = value.indexOf("\n", cursor);
+    const lineEnd = lineEndIdx === -1 ? value.length : lineEndIdx;
+    const onFirstLine = lineStart === 0;
+    const onLastLine = lineEndIdx === -1;
+    const browseHistory = (dir) => {
+        if (!history.length)
+            return;
+        if (historyPos.current === -1) {
+            if (dir === 1)
+                return;
+            draft.current = value;
+            historyPos.current = history.length;
+        }
+        const next = historyPos.current + dir;
+        if (next < 0)
+            return;
+        if (next >= history.length) {
+            historyPos.current = -1;
+            return set(draft.current);
+        }
+        historyPos.current = next;
+        set(history[next]);
+    };
+    const moveVertical = (dir) => {
+        const col = cursor - lineStart;
+        if (dir === -1) {
+            const prevStart = value.lastIndexOf("\n", lineStart - 2) + 1;
+            setCursor(Math.min(prevStart + col, lineStart - 1));
+        }
+        else {
+            const nextEndIdx = value.indexOf("\n", lineEnd + 1);
+            const nextEnd = nextEndIdx === -1 ? value.length : nextEndIdx;
+            setCursor(Math.min(lineEnd + 1 + col, nextEnd));
+        }
+    };
+    const wordStart = () => {
+        let i = cursor;
+        while (i > 0 && /\s/.test(value[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(value[i - 1]))
+            i--;
+        return i;
+    };
+    const wordEnd = () => {
+        let i = cursor;
+        while (i < value.length && /\s/.test(value[i]))
+            i++;
+        while (i < value.length && !/\s/.test(value[i]))
+            i++;
+        return i;
+    };
+    const submit = (text) => {
+        historyPos.current = -1;
+        onSubmit(text);
+    };
+    usePaste((text) => insert(text.replace(/\r\n?/g, "\n")), { isActive });
+    useInput((input, key) => {
+        // Handled by the app: interrupt, exit, permission mode.
+        if ((key.ctrl && (input === "c" || input === "d")) || key.escape || (key.shift && key.tab))
+            return;
+        if (key.return) {
+            if (key.meta)
+                return insert("\n");
+            if (value[cursor - 1] === "\\")
+                return set(value.slice(0, cursor - 1) + "\n" + value.slice(cursor), cursor);
+            if (menu.length && value !== menu[menuIndex].name)
+                return submit(menu[menuIndex].name);
+            return submit(value);
+        }
+        if (key.tab) {
+            if (menu.length)
+                set(menu[menuIndex].name + " ");
+            else if (completion)
+                set(value + completion);
+            return;
+        }
+        if (key.upArrow) {
+            if (menu.length)
+                return setMenuIndex((i) => (i - 1 + menu.length) % menu.length);
+            return onFirstLine ? browseHistory(-1) : moveVertical(-1);
+        }
+        if (key.downArrow) {
+            if (menu.length)
+                return setMenuIndex((i) => (i + 1) % menu.length);
+            return onLastLine ? browseHistory(1) : moveVertical(1);
+        }
+        // Some terminals send Option+arrows as readline's Escape+b / Escape+f.
+        if (key.meta && (key.leftArrow || input === "b"))
+            return setCursor(wordStart());
+        if (key.meta && (key.rightArrow || input === "f"))
+            return setCursor(wordEnd());
+        if (key.leftArrow || (key.ctrl && input === "b"))
+            return setCursor(Math.max(0, cursor - 1));
+        if (key.rightArrow || (key.ctrl && input === "f"))
+            return setCursor(Math.min(value.length, cursor + 1));
+        if (key.home || (key.ctrl && input === "a"))
+            return setCursor(lineStart);
+        if (key.end || (key.ctrl && input === "e"))
+            return setCursor(lineEnd);
+        if (key.ctrl && input === "u")
+            return set(value.slice(0, lineStart) + value.slice(cursor), lineStart);
+        if (key.ctrl && input === "k")
+            return set(value.slice(0, cursor) + value.slice(lineEnd), cursor);
+        if ((key.ctrl && input === "w") || (key.meta && key.backspace)) {
+            const start = wordStart();
+            return set(value.slice(0, start) + value.slice(cursor), start);
+        }
+        if (key.backspace) {
+            if (cursor > 0)
+                set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+            return;
+        }
+        if (key.delete)
+            return set(value.slice(0, cursor) + value.slice(cursor + 1), cursor);
+        if (key.ctrl || key.meta || !input)
+            return;
+        if (input === "?" && value === "")
+            return onHelp();
+        // Typed-ahead text can arrive in one chunk together with the enter key.
+        if (input.length > 1 && input.endsWith("\r") && !input.slice(0, -1).includes("\r"))
+            return submit(value.slice(0, cursor) + input.slice(0, -1) + value.slice(cursor));
+        insert(input.replace(/\r\n?/g, "\n"));
+    }, { isActive });
+    // Render with a block cursor.
+    const lines = (value + completion).split("\n");
+    let offset = 0;
+    const rendered = lines.map((line, i) => {
+        const start = offset;
+        offset += line.length + 1;
+        const col = cursor - start;
+        const showCursor = isActive && col >= 0 && col <= line.length;
+        return (_jsxs(Box, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: i === 0 ? "> " : "  " }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsx(Text, { wrap: "wrap", children: showCursor ? (_jsxs(_Fragment, { children: [line.slice(0, col), _jsx(Text, { inverse: true, dimColor: Boolean(completion), children: line[col] ?? " " }), _jsx(Text, { dimColor: Boolean(completion), children: line.slice(col + 1) })] })) : _jsx(Text, { dimColor: start > value.length, children: line || " " }) }) })] }, i));
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, flexDirection: "column", children: value === "" && !completion ? (_jsxs(Box, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: "> " }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsxs(Text, { wrap: "wrap", children: [isActive ? _jsx(Text, { inverse: true, children: placeholder[0] }) : null, _jsx(Text, { dimColor: true, children: isActive ? placeholder.slice(1) : placeholder })] }) })] })) : (rendered) }), completion && _jsx(Text, { dimColor: true, children: "  tab to accept suggestion" }), menu.length > 0 && (_jsx(Box, { paddingX: 2, children: _jsx(KeyList, { rows: menu.map((c) => [c.name, c.description]), selected: menuIndex }) }))] }));
+}

package/dist/ui/Questionnaire.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useState } from "react";
+import { Dialog } from "./Dialog.js";
+import { Select } from "./Select.js";
+import { TextField } from "./TextField.js";
+/** Collect all answers before submitting anything to the model. */
+export function Questionnaire({ questions, onSubmit, onCancel }) {
+    const [answers, setAnswers] = useState([]);
+    const [value, setValue] = useState("");
+    const [custom, setCustom] = useState(false);
+    const question = questions[answers.length];
+    function answer(text) {
+        if (!text.trim())
+            return;
+        setAnswers([...answers, text.trim()]);
+        setValue("");
+        setCustom(false);
+    }
+    const footer = "enter continue · esc cancel and interrupt";
+    if (!question)
+        return (_jsxs(Dialog, { title: "Review answers", footer: footer, children: [questions.map((q, i) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [q.question, " \u2192"] }), " ", _jsx(Text, { color: "cyan", children: answers[i] })] }, i))), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: [
+                            { label: "Submit answers", value: "submit" },
+                            { label: "Start over", value: "restart" },
+                            { label: "Cancel", value: "cancel" },
+                        ], onSelect: (choice) => {
+                            if (choice === "submit")
+                                onSubmit(questions.map((q, i) => ({ question: q.question, answer: answers[i] })));
+                            else if (choice === "restart")
+                                setAnswers([]);
+                            else
+                                onCancel();
+                        }, onCancel: onCancel }, "review") })] }));
+    return (_jsxs(Dialog, { title: `Question ${answers.length + 1} of ${questions.length}`, footer: footer, children: [_jsx(Text, { children: question.question }), _jsx(Box, { marginTop: 1, children: question.options && !custom ? (_jsx(Select, { options: [...question.options.map((label) => ({ label, value: label })), { label: "Other — type an answer", value: null }], onSelect: (choice) => (choice === null ? setCustom(true) : answer(choice)), onCancel: onCancel }, answers.length)) : (_jsx(TextField, { value: value, onChange: setValue, onSubmit: answer, onCancel: onCancel, placeholder: "Type your answer\u2026" })) })] }));
+}

package/dist/ui/Select.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+/**
+ * Arrow-key list: ↑/↓ (or ctrl+p/n) to move, enter to pick, 1-9 to pick directly, esc to cancel.
+ * `accent` colors the cursor and selected label; `numberColor` the "1." column.
+ */
+export function Select({ options, onSelect, onCancel, initialIndex = 0, accent = "cyan", numberColor, }) {
+    const [index, setIndex] = useState(initialIndex);
+    useInput((input, key) => {
+        if (key.upArrow || (key.ctrl && input === "p"))
+            setIndex((i) => (i - 1 + options.length) % options.length);
+        else if (key.downArrow || (key.ctrl && input === "n"))
+            setIndex((i) => (i + 1) % options.length);
+        else if (key.return)
+            onSelect(options[index].value);
+        else if (key.escape)
+            onCancel?.();
+        else if (/^[1-9]$/.test(input) && Number(input) <= options.length)
+            onSelect(options[Number(input) - 1].value);
+    });
+    // "❯ 1. " stays in its own column so long labels wrap under the label, not under the number.
+    const marker = `❯ ${options.length}. `.length;
+    return (_jsx(Box, { flexDirection: "column", children: options.map((o, i) => {
+            const selected = i === index;
+            return (_jsxs(Box, { children: [_jsx(Box, { width: marker, flexShrink: 0, children: _jsxs(Text, { children: [_jsx(Text, { color: accent, children: selected ? "❯ " : "  " }), _jsxs(Text, { color: numberColor ?? (selected ? accent : undefined), children: [i + 1, "."] })] }) }), _jsx(Box, { flexShrink: 1, minWidth: 0, children: _jsxs(Text, { color: selected ? accent : undefined, children: [o.label, o.hint ? _jsxs(Text, { dimColor: true, children: [" ", o.hint] }) : null] }) })] }, i));
+        }) }));
+}

package/dist/ui/Spinner.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useAnimation } from "ink";
+const FRAMES = ["·", "✢", "✳", "✶", "✻", "✽", "✻", "✶", "✳", "✢"];
+/** "✻ Thinking… (3s · esc to interrupt)" while a turn runs. */
+export function Spinner({ verb }) {
+    const { frame, time } = useAnimation({ interval: 120 });
+    return (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "cyan", children: [FRAMES[frame % FRAMES.length], " ", verb, "\u2026", " "] }), _jsxs(Text, { dimColor: true, children: ["(", Math.floor(time / 1000), "s \u00B7 esc to interrupt)"] })] }));
+}
+/** Blinking dot in front of a running tool call. */
+export function Blink() {
+    const { frame } = useAnimation({ interval: 500 });
+    return _jsx(Text, { color: "cyan", children: frame % 2 ? " " : "⏺" });
+}
+/** Braille spinner with a message, for dialogs waiting on the network or a browser. */
+export function Waiting({ text }) {
+    const { frame } = useAnimation({ interval: 100 });
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame % 10] }), " ", text] }));
+}

package/dist/ui/StatusLine.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { tildify } from "./format.js";
+const MODE_LABELS = {
+    "accept-edits": { text: "⏵⏵ accept edits", color: "magenta" },
+    ask: { text: "ask mode", color: "cyan" },
+};
+/** Row under the prompt: permission mode and cwd on the left; model, worktree and tokens on the right. */
+export function StatusLine({ mode, model, loggedIn, exitArmed, usage, worktree, }) {
+    // Give exit confirmation the whole row instead of competing with model/worktree metadata.
+    if (exitArmed) {
+        return (_jsx(Box, { paddingX: 2, children: _jsx(Text, { color: "yellow", children: "Press Ctrl-C again to exit" }) }));
+    }
+    // Bypass is the default, so only the other modes get a label.
+    const modeLabel = MODE_LABELS[mode];
+    const tokens = usage.input + usage.output;
+    // When space runs out the path gives way first, then the details on the right; the mode never does.
+    return (_jsxs(Box, { paddingX: 2, gap: 2, children: [_jsxs(Box, { flexGrow: 1, flexShrink: 100, minWidth: modeLabel ? modeLabel.text.length + 1 : 0, children: [modeLabel && (_jsx(Box, { flexShrink: 0, marginRight: 1, children: _jsx(Text, { color: modeLabel.color, children: modeLabel.text }) })), _jsx(Box, { flexShrink: 1, minWidth: 0, children: _jsx(Text, { dimColor: true, wrap: "truncate-start", children: tildify(process.cwd()) }) })] }), _jsx(Box, { flexShrink: 1, minWidth: 0, children: _jsxs(Text, { dimColor: loggedIn, color: loggedIn ? undefined : "yellow", wrap: "truncate-end", children: [model, loggedIn ? "" : " · not logged in (/login)", worktree ? ` · ⎇ ${worktree}` : "", tokens ? ` · ${tokens < 1000 ? tokens : `${(tokens / 1000).toFixed(1)}k`} tokens` : ""] }) })] }));
+}

package/dist/ui/TextField.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput, usePaste } from "ink";
+/** Single-line input for dialogs. `mask` hides the value (API keys), showing only the last 4 chars. */
+export function TextField({ value, onChange, onSubmit, onCancel, mask, placeholder = "", }) {
+    usePaste((text) => onChange(value + text.replace(/[\r\n]/g, "").trim()));
+    useInput((input, key) => {
+        if (key.return)
+            return onSubmit(value.trim());
+        if (key.escape)
+            return onCancel?.();
+        if (key.backspace || key.delete)
+            return onChange(value.slice(0, -1));
+        if (key.ctrl && input === "u")
+            return onChange("");
+        if (key.ctrl || key.meta || key.upArrow || key.downArrow || key.tab)
+            return;
+        if (input)
+            onChange(value + input.replace(/[\r\n]/g, ""));
+    });
+    const shown = mask && value.length > 4 ? "•".repeat(Math.min(value.length - 4, 40)) + value.slice(-4) : value;
+    return (_jsxs(Text, { children: ["> ", shown || _jsx(Text, { dimColor: true, children: placeholder }), _jsx(Text, { inverse: true, children: " " })] }));
+}

package/dist/ui/Transcript.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { DIFF_COLORS } from "./diff.js";
+import { DiffLines } from "./DiffLines.js";
+import { callParts, previewOutput, previewPrompt, renderMarkdown, tildify } from "./format.js";
+/** Claude Code's colors for a finished call and for secondary text. */
+const DONE = "#4eba65";
+const MUTED = DIFF_COLORS.muted;
+import { Blink } from "./Spinner.js";
+export function ItemView({ item, model }) {
+    switch (item.kind) {
+        case "banner":
+            return (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", alignSelf: "flex-start", children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "\u273B" }), " Welcome to ", _jsx(Text, { bold: true, children: "megacode" })] }), _jsx(Text, { dimColor: true, children: "/help for commands \u00B7 ? for shortcuts" }), _jsxs(Text, { dimColor: true, children: ["model: ", model, "\n", "cwd: ", tildify(process.cwd())] })] }));
+        case "user":
+            return (_jsxs(Box, { marginTop: 1, children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: "> " }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, flexBasis: 0, minWidth: 0, children: _jsx(Text, { wrap: "wrap", children: previewPrompt(item.text) }) })] }));
+        case "assistant":
+            return _jsx(AssistantText, { text: item.text, first: item.first });
+        case "tool":
+            return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(TranscriptRow, { prefix: _jsx(Text, { color: item.isError ? "red" : DONE, children: "\u23FA " }), width: 2, children: _jsx(CallHeader, { call: item.call }) }), _jsx(TranscriptRow, { prefix: _jsx(Text, { color: MUTED, children: "  ⎿  " }), width: 5, children: item.diff ? (_jsx(Text, { children: item.output })) : (_jsx(Text, { dimColor: !item.isError, color: item.isError ? "red" : undefined, children: previewOutput(item.output) || "(no output)" })) }), item.diff && (_jsx(Box, { marginLeft: 5, marginRight: 7, flexDirection: "column", children: _jsx(DiffLines, { model: item.diff }) }))] }));
+        case "notice":
+            return (_jsx(Box, { marginTop: 1, children: _jsx(TranscriptRow, { prefix: _jsx(Text, { dimColor: true, children: "  ⎿  " }), width: 5, children: _jsx(Text, { color: item.level === "error" ? "red" : item.level === "warn" ? "yellow" : undefined, dimColor: item.level === "info" && !item.bright, children: item.text }) }) }));
+    }
+}
+/** Assistant Markdown; `first` marks the start of a reply (also used for the live, still-streaming text). */
+export function AssistantText({ text, first }) {
+    return (_jsx(Box, { marginTop: first ? 1 : 0, children: _jsx(TranscriptRow, { prefix: _jsx(Text, { children: first ? "⏺ " : "  " }), width: 2, children: _jsx(Text, { children: renderMarkdown(text) }) }) }));
+}
+/** "Update(src/a.ts)" with only the tool name in bold. */
+function CallHeader({ call }) {
+    const { name, arg } = callParts(call);
+    return (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: name }), "(", arg, ")"] }));
+}
+/** The tool call in progress. While it waits for approval, just its header with a gray dot. */
+export function RunningTool({ call, waiting = false }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [waiting ? _jsx(Text, { color: MUTED, children: "\u23FA" }) : _jsx(Blink, {}), " ", _jsx(CallHeader, { call: call })] }), !waiting && _jsx(Text, { color: MUTED, children: "  ⎿  Running…" })] }));
+}
+/** Keep prefixes out of the text's wrapping width, including on continuation lines. */
+function TranscriptRow({ prefix, width, children }) {
+    return (_jsxs(Box, { width: "100%", children: [_jsx(Box, { width: width, flexShrink: 0, children: prefix }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, flexBasis: 0, minWidth: 0, children: children })] }));
+}

package/dist/ui/WorktreeMenu.js

@@ -0,0 +1,83 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { baseRef, describeChanges, listWorktrees, WORKTREE_NAME, worktreeChanges } from "../adapters/git/worktree.js";
+import { Dialog } from "./Dialog.js";
+import { tildify } from "./format.js";
+import { Select } from "./Select.js";
+import { Waiting } from "./Spinner.js";
+import { TextField } from "./TextField.js";
+/** Runs `load` once on mount; undefined until it resolves. */
+function useLoaded(load) {
+    const [value, setValue] = useState();
+    useEffect(() => {
+        let live = true;
+        load().then((v) => live && setValue(v));
+        return () => void (live = false);
+    }, []);
+    return value;
+}
+async function loadMenu(current) {
+    const [worktrees, base, currentChanges] = await Promise.all([
+        listWorktrees().then((list) => Promise.all(list.map(async (wt) => ({ wt, changes: describeChanges(await worktreeChanges(wt)) })))),
+        baseRef(),
+        current ? worktreeChanges(current).then(describeChanges) : "",
+    ]);
+    return { worktrees, base, currentChanges };
+}
+/** Create a worktree, switch to an existing one, or go back to the main checkout. */
+export function WorktreeMenu({ current, onCreate, onOpen, onLeave, onCancel, }) {
+    const [naming, setNaming] = useState(false);
+    const [name, setName] = useState("");
+    const [error, setError] = useState("");
+    const data = useLoaded(() => loadMenu(current));
+    if (!data)
+        return _jsx(Frame, { current: current, children: _jsx(Waiting, { text: "Reading worktrees\u2026" }) });
+    const { worktrees, base, currentChanges } = data;
+    const options = [
+        { label: "New worktree", value: { type: "new" }, hint: `(branches from ${base})` },
+        ...worktrees.map(({ wt, changes }) => ({
+            label: wt.path === current?.path ? `${wt.name} (current)` : `Switch to ${wt.name}`,
+            value: { type: "open", wt },
+            hint: `${wt.branch} · ${changes}`,
+        })),
+    ];
+    if (current)
+        options.push({ label: "Return to main checkout, keep worktree", value: { type: "leave", remove: false } }, {
+            label: "Return to main checkout, remove worktree",
+            value: { type: "leave", remove: true },
+            hint: currentChanges === "no changes" ? "" : `(discards ${currentChanges})`,
+        });
+    function select(a) {
+        if (a.type === "new")
+            return setNaming(true);
+        if (a.type === "leave")
+            return onLeave(a.remove);
+        if (a.wt.path === current?.path)
+            return onCancel();
+        onOpen(a.wt);
+    }
+    function submitName(v) {
+        if (v && !WORKTREE_NAME.test(v))
+            return setError("Use letters, digits, - and _ (max 64), starting with a letter or digit.");
+        onCreate(v || undefined);
+    }
+    return (_jsx(Frame, { current: current, help: naming ? "enter create · esc back" : "↑↓ navigate · enter select · esc cancel", children: naming ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Name for the new worktree (branch worktree-", name || "<name>", "):"] }), _jsx(TextField, { value: name, onChange: (v) => {
+                        setName(v);
+                        setError("");
+                    }, onSubmit: submitName, onCancel: () => setNaming(false), placeholder: "leave empty for a random name" }), error && _jsx(Text, { color: "red", children: error })] })) : (_jsx(Select, { options: options, onSelect: select, onCancel: onCancel })) }));
+}
+function Frame({ current, help, children }) {
+    return (_jsx(Dialog, { title: "Worktrees", subtitle: current ? `in ${current.name} (${current.branch})` : "in the main checkout", footer: help, children: children }));
+}
+/** Shown when exiting while in a worktree: keep it for later, or remove it and its branch. */
+export function ExitWorktreeDialog({ worktree, onSelect, onCancel, }) {
+    // undefined while git runs; null if git couldn't tell.
+    const changes = useLoaded(() => worktreeChanges(worktree));
+    const summary = changes === undefined ? "" : describeChanges(changes);
+    const clean = changes?.files === 0 && changes.commits === 0;
+    return (_jsxs(Dialog, { title: `Exiting worktree ${worktree.name}`, tone: "warn", footer: "esc to stay", children: [_jsxs(Text, { dimColor: true, children: [tildify(worktree.path), " \u00B7 branch ", worktree.branch, summary && ` · ${summary}`] }), _jsx(Box, { marginTop: 1, children: changes === undefined ? (_jsx(Waiting, { text: "Checking for changes\u2026" })) : (_jsx(Select, { initialIndex: clean ? 1 : 0, options: [
+                        { label: "Keep worktree", value: false, hint: `(return with megacode -w ${worktree.name})` },
+                        { label: "Remove worktree and branch", value: true, hint: clean ? "" : `(discards ${summary})` },
+                    ], onSelect: onSelect, onCancel: onCancel })) })] }));
+}

package/dist/ui/autocomplete.js

@@ -0,0 +1,6 @@
+/** Suggestions are display-only until explicitly accepted. */
+export function promptCompletion(value, cursor, suggestion, enabled) {
+    if (!enabled || cursor !== value.length || value.trimStart().startsWith("/"))
+        return "";
+    return suggestion.startsWith(value) ? suggestion.slice(value.length) : "";
+}

package/dist/ui/commands.js

@@ -0,0 +1,117 @@
+import { savedProviders } from "../adapters/auth/store.js";
+import { runSkillsCommand } from "../adapters/skills.js";
+import { mainRoot } from "../adapters/git/worktree.js";
+import { PROVIDERS, providerInfo } from "../adapters/providers/catalog.js";
+import { providerOf } from "../adapters/providers/credentials.js";
+import { providerUsage } from "../adapters/providers/usage.js";
+import { EFFORTS } from "../core/provider.js";
+export const COMMANDS = [
+    {
+        name: "/skills",
+        description: "List skills or install <local-directory|owner/repo|GitHub-URL> [--global]",
+        run(ctx, arg) {
+            if (ctx.running)
+                return ctx.notice("Can't manage skills while a turn is running (esc to interrupt).", "warn");
+            // Preserve spaces in a source path; the only supported option is a trailing --global.
+            const match = /^install\s+(.+?)(\s+--global)?$/.exec(arg);
+            const source = match?.[1].replace(/^([\"'])(.*)\1$/, "$2");
+            const args = match ? ["install", source, ...(match[2] ? ["--global"] : [])] : arg ? [arg] : [];
+            const cwd = process.cwd();
+            if (match)
+                ctx.notice("Installing skills…");
+            runSkillsCommand(args, { cwd }).then(ctx.print, (error) => ctx.notice(error instanceof Error ? error.message : String(error), "error"));
+        },
+    },
+    {
+        name: "/model",
+        description: "Switch model (or /model provider:model)",
+        run: (ctx, arg) => (arg ? ctx.selectModel(arg) : ctx.open({ type: "model" })),
+    },
+    {
+        name: "/effort",
+        description: "Change model effort (default, low, medium, high)",
+        run(ctx, arg) {
+            if (!arg)
+                return ctx.open({ type: "effort" });
+            if (!EFFORTS.includes(arg))
+                return ctx.notice(`Unknown effort "${arg}". Available: ${EFFORTS.join(", ")}`, "warn");
+            ctx.selectEffort(arg);
+        },
+    },
+    {
+        name: "/login",
+        description: "Connect a provider (API key or local server)",
+        run(ctx, arg) {
+            if (arg && !PROVIDERS.includes(arg))
+                return ctx.notice(`Unknown provider "${arg}". Available: ${PROVIDERS.join(", ")}`, "warn");
+            ctx.open({ type: "login", provider: arg || undefined });
+        },
+    },
+    {
+        name: "/logout",
+        description: "Remove saved credentials",
+        run(ctx, arg) {
+            if (arg)
+                return ctx.logout(arg);
+            if (!savedProviders().length)
+                return ctx.notice("No saved credentials. (Keys from environment variables aren't stored by megacode.)");
+            ctx.open({ type: "logout" });
+        },
+    },
+    {
+        name: "/config",
+        description: "View and change settings",
+        aliases: ["/settings"],
+        run: (ctx) => ctx.open({ type: "config" }),
+    },
+    {
+        name: "/mcp",
+        description: "Manage MCP servers (add, remove, reconnect, see tools)",
+        run: (ctx) => ctx.open({ type: "mcp" }),
+    },
+    {
+        name: "/worktree",
+        description: "Create or switch git worktrees (or /worktree name)",
+        run(ctx, arg) {
+            if (arg)
+                return ctx.enterWorktree(arg);
+            mainRoot().then(() => ctx.open({ type: "worktree" }), (e) => ctx.notice(e.message, "warn"));
+        },
+    },
+    {
+        name: "/clear",
+        description: "Clear conversation history and screen",
+        run(ctx) {
+            if (ctx.running)
+                return ctx.notice("Can't clear while a turn is running (esc to interrupt).", "warn");
+            ctx.clear();
+        },
+    },
+    {
+        name: "/usage",
+        description: "Fetch current provider's account usage and limits",
+        run(ctx) {
+            const provider = providerOf(ctx.model);
+            const { label } = providerInfo(provider);
+            ctx.notice(`Fetching ${label} usage…`);
+            providerUsage(provider).then(ctx.print, (error) => ctx.notice(`${label}: ${error instanceof Error ? error.message : "Unable to fetch usage."}`, "error"));
+        },
+    },
+    { name: "/help", description: "Show commands and keyboard shortcuts", run: (ctx) => ctx.showHelp() },
+    { name: "/exit", description: "Exit megacode", aliases: ["/quit"], run: (ctx) => ctx.quit() },
+];
+const parse = (input) => {
+    const [name = "", ...args] = input.trim().split(/\s+/);
+    return { name, arg: args.join(" ") };
+};
+const byName = (name) => COMMANDS.find((c) => c.name === name || c.aliases?.includes(name));
+/** Whether the text is a known slash command (with or without arguments). */
+export const isCommand = (text) => !!byName(parse(text).name);
+/** Runs a slash command line such as "/model openai:gpt-5". */
+export function runCommand(input, ctx) {
+    const { name, arg } = parse(input);
+    const command = byName(name);
+    if (!command)
+        return ctx.notice(`Unknown command ${name}. Type / to see commands.`, "warn");
+    command.run(ctx, arg);
+}