@megacode/cli 0.2.0

package/dist/ui/diff.js

@@ -0,0 +1,130 @@
+import { relative } from "node:path";
+import chalk from "chalk";
+import { diffWordsWithSpace, structuredPatch } from "diff";
+// A file change as Claude Code shows it: one line-number column, removed lines red on a red band and
+// added lines green on a green band (the changed words brighter), plain context around them.
+// New files are listed whole.
+export const DIFF_COLORS = {
+    removedNumber: "#dc5a5a",
+    removed: "#3d0100",
+    removedWord: "#5c0200",
+    addedNumber: "#50c850",
+    added: "#022800",
+    addedWord: "#044700",
+    muted: "#999999",
+};
+const MAX_COMPARE = 1_000_000; // characters; larger files aren't diffed
+/** Marks the words that changed between a replaced line and its replacement, unless they're mostly different. */
+function markChangedWords(removed, added) {
+    const parts = diffWordsWithSpace(removed.text, added.text);
+    const same = parts.filter((p) => !p.added && !p.removed).reduce((n, p) => n + p.value.length, 0);
+    if (same < Math.max(removed.text.length, added.text.length) / 2)
+        return;
+    for (const [row, side] of [[removed, "removed"], [added, "added"]]) {
+        row.marks = [];
+        let at = 0;
+        for (const p of parts) {
+            if (p[side === "added" ? "removed" : "added"])
+                continue; // the other side's text
+            if (p[side])
+                row.marks.push([at, at + p.value.length]);
+            at += p.value.length;
+        }
+    }
+}
+/** The rows to show for a change, at most `maxRows`. Null when the files are too large to compare. */
+export function buildDiff(change, maxRows = 60) {
+    if (change.before.length + change.after.length > MAX_COMPARE)
+        return null;
+    const file = relative(process.cwd(), change.file) || change.file;
+    const bounded = (rows, rest) => ({
+        file,
+        rows: rows.slice(0, maxRows),
+        hidden: Math.max(0, rows.length - maxRows),
+        ...rest,
+    });
+    if (change.created) {
+        const lines = change.after === "" ? [] : change.after.replace(/\n$/, "").split("\n");
+        const rows = lines.map((text, i) => ({ type: "line", number: i + 1, text }));
+        return bounded(rows, { created: true, numberWidth: String(lines.length).length, added: lines.length, removed: 0 });
+    }
+    const patch = structuredPatch(file, file, change.before, change.after, undefined, undefined, { context: 3, timeout: 200 });
+    if (!patch)
+        return null;
+    const rows = [];
+    let [added, removed, widest] = [0, 0, 0];
+    for (const [h, hunk] of patch.hunks.entries()) {
+        if (h > 0)
+            rows.push({ type: "gap" });
+        let [oldNo, newNo] = [hunk.oldStart, hunk.newStart];
+        const lines = hunk.lines.filter((l) => !l.startsWith("\\")); // ""
+        for (let i = 0; i < lines.length;) {
+            if (lines[i][0] === " ") {
+                rows.push({ type: "context", number: newNo++, text: lines[i++].slice(1) });
+                oldNo++;
+                continue;
+            }
+            // A block of removals then additions; same-sized blocks are line-for-line replacements.
+            const minus = [];
+            const plus = [];
+            for (; lines[i]?.[0] === "-"; i++)
+                minus.push({ type: "remove", number: oldNo++, text: lines[i].slice(1) });
+            for (; lines[i]?.[0] === "+"; i++)
+                plus.push({ type: "add", number: newNo++, text: lines[i].slice(1) });
+            if (minus.length === plus.length)
+                minus.forEach((m, k) => markChangedWords(m, plus[k]));
+            rows.push(...minus, ...plus);
+            [removed, added] = [removed + minus.length, added + plus.length];
+        }
+        widest = Math.max(widest, oldNo - 1, newNo - 1);
+    }
+    return bounded(rows, { created: false, numberWidth: String(widest).length, added, removed });
+}
+/** The gutter for a row: a space, the line number, a space, and the sign (none for new files). */
+export function gutter(row, model) {
+    if (row.type === "gap")
+        return " ".repeat(model.numberWidth + (model.created ? 2 : 3));
+    const sign = model.created ? "" : row.type === "add" ? "+" : row.type === "remove" ? "-" : " ";
+    return ` ${String(row.number).padStart(model.numberWidth)} ${sign}`;
+}
+/** Text color (line number, sign and code), band and changed-word background for each kind of row. */
+export function rowStyle(row) {
+    if (row.type === "add")
+        return { color: DIFF_COLORS.addedNumber, background: DIFF_COLORS.added, word: DIFF_COLORS.addedWord };
+    if (row.type === "remove")
+        return { color: DIFF_COLORS.removedNumber, background: DIFF_COLORS.removed, word: DIFF_COLORS.removedWord };
+    return {};
+}
+/** A row's text in pieces, each marked if it's a changed word. */
+export function pieces(row) {
+    const out = [];
+    let at = 0;
+    for (const [start, end] of row.marks ?? []) {
+        if (start > at)
+            out.push({ text: row.text.slice(at, start), changed: false });
+        out.push({ text: row.text.slice(start, end), changed: true });
+        at = end;
+    }
+    if (at < row.text.length || !out.length)
+        out.push({ text: row.text.slice(at), changed: false });
+    return out;
+}
+/** The diff as ANSI text `width` columns wide, for plain (non-TUI) output. */
+export function diffToAnsi(model, width = process.stdout.columns || 80) {
+    const lines = model.rows.map((row) => {
+        const head = gutter(row, model);
+        if (row.type === "gap")
+            return chalk.hex(DIFF_COLORS.muted)(head + "…");
+        const style = rowStyle(row);
+        const paint = (background, text) => {
+            const colored = style.color ? chalk.hex(style.color)(text) : text;
+            return background ? chalk.bgHex(background)(colored) : colored;
+        };
+        const body = pieces(row).map((p) => paint(p.changed ? style.word : style.background, p.text)).join("");
+        const padding = style.background ? paint(style.background, " ".repeat(Math.max(0, width - head.length - row.text.length))) : "";
+        return paint(style.background, head) + body + padding;
+    });
+    if (model.hidden)
+        lines.push(chalk.hex(DIFF_COLORS.muted)(`… +${model.hidden} lines`));
+    return lines.join("\n");
+}

package/dist/ui/format.js

@@ -0,0 +1,138 @@
+import os from "node:os";
+import { stripVTControlCharacters, styleText } from "node:util";
+import chalk from "chalk";
+import { buildDiff, diffToAnsi } from "./diff.js";
+const TOOL_LABELS = {
+    ask_questions: "Ask",
+    view_image: "View",
+    read_file: "Read",
+    write_file: "Write",
+    edit_file: "Update",
+    bash: "Bash",
+    list_files: "List",
+    grep: "Search",
+};
+/** A tool call's name and its main argument: "Bash" + "npm test", "Read" + "src/cli.ts". */
+export function callParts(c) {
+    const mcp = c.name.match(/^mcp__(.+?)__(.+)$/);
+    const firstString = Object.values(c.input ?? {}).find((v) => typeof v === "string");
+    const arg = String((mcp ? firstString : (c.input.command ?? c.input.path ?? c.input.pattern)) ?? "").split("\n")[0];
+    return { name: mcp ? `${mcp[1]} · ${mcp[2]} (MCP)` : (TOOL_LABELS[c.name] ?? c.name), arg: arg.length > 80 ? arg.slice(0, 80) + "…" : arg };
+}
+/** "Bash(npm test)", "Read(src/cli.ts)" */
+export function formatCall(c) {
+    const { name, arg } = callParts(c);
+    return `${name}(${arg})`;
+}
+/** The text shown for an approval request in plain output: a diff for file changes, else the tool's own description. */
+export function approvalBody(req) {
+    if (!req.change)
+        return req.body ?? "";
+    const model = buildDiff(req.change);
+    return model ? diffToAnsi(model) : "Diff preview unavailable (file too large).";
+}
+/** Shortens paths under the home directory to ~/… for display. */
+export const tildify = (p) => p.replace(os.homedir(), "~");
+/** Display-only prompt preview; queued/sent prompts and history retain the full text. */
+export function previewPrompt(text) {
+    const chars = Array.from(text.replace(/\r\n|[\r\n]/g, " ⏎ ").replace(/\t/g, " "));
+    return chars.length > 200 ? chars.slice(0, 199).join("") + "…" : chars.join("");
+}
+export const plural = (n, word) => `${n.toLocaleString("en-US")} ${word}${n === 1 ? "" : "s"}`;
+/** First few lines of tool output for the transcript. */
+export function previewOutput(output, lines = 3) {
+    const all = output.trimEnd().split("\n");
+    const head = all.slice(0, lines).join("\n");
+    return all.length > lines ? `${head}\n${styleText("dim", `… +${plural(all.length - lines, "line")}`)}` : head;
+}
+const count = (n, word) => `${chalk.bold(n.toLocaleString("en-US"))} ${word}${n === 1 ? "" : "s"}`;
+/** Claude Code's summary of an applied change: "Added 2 lines, removed 1 line", "Wrote 14 lines to a.ts". */
+export function describeChange(change, model = buildDiff(change, 0)) {
+    if (!model)
+        return "Changed (too large to compare)";
+    if (model.created)
+        return `Wrote ${count(model.added, "line")} to ${chalk.bold(model.file)}`;
+    const parts = [model.added && `added ${count(model.added, "line")}`, model.removed && `removed ${count(model.removed, "line")}`].filter(Boolean);
+    const text = parts.join(", ");
+    return text ? text[0].toUpperCase() + text.slice(1) : "No changes";
+}
+/** "Read 3 lines", or "Read 200 of 1,234 lines" for a partial read. */
+function describeRead(output) {
+    if (output.startsWith("[EOF:"))
+        return output;
+    const shown = output.match(/^\d+\t/gm)?.length ?? 0;
+    const total = output.match(/\[(\d+) lines total; continue/)?.[1];
+    return total ? `Read ${shown.toLocaleString("en-US")} of ${plural(Number(total), "line")}` : `Read ${plural(shown, "line")}`;
+}
+/**
+ * What the transcript shows for a finished tool call. The model gets the full output; people get
+ * a summary where the raw text would only repeat what the diff or the call already says.
+ */
+export function displayOutput(call, result, model) {
+    if (result.isError)
+        return result.output;
+    if (result.change)
+        return describeChange(result.change, model);
+    if (call.name === "read_file")
+        return describeRead(result.output);
+    return result.output;
+}
+/**
+ * Tiny Markdown → ANSI renderer: headings, bold, italics, inline code, fenced code, lists, quotes.
+ * Good enough for model output in a terminal; not a full CommonMark implementation.
+ */
+export function renderMarkdown(md) {
+    const out = [];
+    let fence;
+    for (const line of md.split("\n")) {
+        const next = fenceAfter(fence, line);
+        if (fence !== undefined || next !== undefined) {
+            // Code is indented; control characters are dropped so a reply can't restyle the terminal.
+            if (fence !== undefined && next !== undefined)
+                out.push(`  ${stripVTControlCharacters(line)}`);
+            fence = next;
+            continue;
+        }
+        let m;
+        if ((m = line.match(/^(#{1,6})\s+(.*)$/)))
+            out.push(styleText("bold", inline(m[2])));
+        else if ((m = line.match(/^(\s*)[-*+]\s+(.*)$/)))
+            out.push(`${m[1]}• ${inline(m[2])}`);
+        else if ((m = line.match(/^>\s?(.*)$/)))
+            out.push(styleText(["dim", "italic"], `│ ${inline(m[1])}`));
+        else if (/^\s*([-*_])\1{2,}\s*$/.test(line))
+            out.push(styleText("dim", "─".repeat(40)));
+        else
+            out.push(inline(line));
+    }
+    return out.join("\n");
+}
+/** The fence open after `line`: a line of ``` or ~~~ opens one; the same marker, at least as long, closes it. */
+function fenceAfter(open, line) {
+    const m = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+    if (!m)
+        return open;
+    if (open === undefined)
+        return m[1];
+    return m[1][0] === open[0] && m[1].length >= open.length && !m[2].trim() ? undefined : open;
+}
+function inline(s) {
+    return s
+        .replace(/`([^`]+)`/g, (_, c) => styleText("cyan", c))
+        .replace(/\*\*([^*]+)\*\*/g, (_, t) => styleText("bold", t))
+        .replace(/(^|[^*\w])\*([^*\s][^*]*)\*(?!\w)/g, (_, p, t) => p + styleText("italic", t));
+}
+/** Index just past the last paragraph break outside a code fence, or -1. Used to flush streamed text. */
+export function lastSafeBreak(text) {
+    let fence;
+    let last = -1;
+    let offset = 0;
+    for (const line of text.split("\n")) {
+        fence = fenceAfter(fence, line);
+        const end = offset + line.length;
+        if (!fence && text[end] === "\n" && text[end + 1] === "\n")
+            last = end + 2;
+        offset = end + 1;
+    }
+    return last;
+}

package/dist/ui/history.js

@@ -0,0 +1,9 @@
+import { loadSettings } from "../adapters/settings.js";
+import { readJson, writeJson } from "../adapters/storage.js";
+// Prompt history shared across sessions, newest last.
+const MAX = 200;
+export const loadHistory = () => (loadSettings().saveHistory ? readJson("history.json", []) : []);
+export const saveHistory = (entries) => {
+    if (loadSettings().saveHistory)
+        writeJson("history.json", entries.slice(-MAX));
+};

package/dist/ui/hooks/useAgentSession.js

@@ -0,0 +1,34 @@
+import { useRef, useState, useSyncExternalStore } from "react";
+import { AgentSession } from "../session.js";
+import { useStreamedText } from "./useStreamedText.js";
+/**
+ * React binding for an AgentSession. The host callbacks may change on every render;
+ * the session always calls the latest ones.
+ */
+export function useAgentSession(agent, host) {
+    const latest = useRef(host);
+    latest.current = host;
+    const stream = useStreamedText((text, first) => latest.current.push({ kind: "assistant", text, first }));
+    const streamRef = useRef(stream);
+    streamRef.current = stream;
+    const [session] = useState(() => new AgentSession(agent, {
+        push: (...items) => latest.current.push(...items),
+        notice: (text, level) => latest.current.notice(text, level),
+        canSend: (text) => latest.current.canSend(text),
+        mode: () => latest.current.mode(),
+        onAllowEdits: () => latest.current.onAllowEdits(),
+        restoreInput: (text) => latest.current.restoreInput(text),
+        onText: (delta) => streamRef.current.append(delta),
+        onStepEnd: () => streamRef.current.end(),
+    }));
+    const state = useSyncExternalStore(session.subscribe, () => session.state);
+    return {
+        ...state,
+        streaming: { text: stream.streaming, first: stream.first },
+        submit: session.submit,
+        interrupt: session.interrupt,
+        flushQueue: session.flushQueue,
+        answerApproval: session.answerApproval,
+        abort: session.abort,
+    };
+}

package/dist/ui/hooks/usePromptSuggestion.js

@@ -0,0 +1,23 @@
+import { useEffect, useState } from "react";
+/**
+ * Asks the model for a next-prompt suggestion after each completed turn. Any change
+ * (new turn, /clear, model switch) drops the current suggestion and cancels a pending one.
+ */
+export function usePromptSuggestion(agent, { enabled, running, completedTurn, epoch, model }) {
+    const [suggestion, setSuggestion] = useState("");
+    useEffect(() => {
+        setSuggestion("");
+        if (!enabled || running || !completedTurn || !agent.messages.length)
+            return;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => {
+            void agent.suggestPrompt(ctrl.signal).then((text) => {
+                if (!ctrl.signal.aborted)
+                    setSuggestion(text);
+            }).catch(() => { }); // Optional suggestions must never disrupt the main conversation.
+        }, 300);
+        const timeout = setTimeout(() => ctrl.abort(), 15_000);
+        return () => { clearTimeout(timer); clearTimeout(timeout); ctrl.abort(); };
+    }, [agent, enabled, running, completedTurn, epoch, model]);
+    return suggestion;
+}

package/dist/ui/hooks/useStreamedText.js

@@ -0,0 +1,38 @@
+import { useRef, useState } from "react";
+import { lastSafeBreak } from "../format.js";
+/**
+ * Buffers streamed assistant text. Finished paragraphs go to `commit` (into <Static>) so the
+ * live area stays short; `streaming` is the unfinished rest.
+ */
+export function useStreamedText(commit) {
+    const [streaming, setStreaming] = useState("");
+    const buffer = useRef("");
+    const first = useRef(true); // the next committed chunk starts a new reply
+    const timer = useRef(null);
+    const flush = (all) => {
+        timer.current = null;
+        const text = buffer.current;
+        const cut = all ? text.length : lastSafeBreak(text);
+        if (cut > 0 && text.slice(0, cut).trim()) {
+            commit(text.slice(0, cut).trim(), first.current);
+            first.current = false;
+        }
+        buffer.current = cut > 0 ? text.slice(cut) : text;
+        setStreaming(buffer.current);
+    };
+    return {
+        streaming,
+        first: first.current,
+        append(delta) {
+            buffer.current += delta;
+            timer.current ??= setTimeout(() => flush(false), 40);
+        },
+        /** Commit everything; the next text starts a new reply. */
+        end() {
+            if (timer.current)
+                clearTimeout(timer.current);
+            flush(true);
+            first.current = true;
+        },
+    };
+}

package/dist/ui/hooks/useWorktree.js

@@ -0,0 +1,30 @@
+import { useState } from "react";
+import { openWorktree, removeWorktree } from "../../adapters/git/worktree.js";
+/** The git worktree the session works in, if any. Actions return a message to show and throw on git errors. */
+export function useWorktree(agent, initial, home) {
+    const [worktree, setWorktree] = useState(initial);
+    const moveTo = (dir) => {
+        process.chdir(dir);
+        agent.reloadSystemPrompt(); // the system prompt includes the working directory
+    };
+    return {
+        worktree,
+        /** Switches to the named worktree, creating it if needed; no name creates one with a random name. */
+        async enter(name) {
+            const wt = await openWorktree(name);
+            moveTo(wt.path);
+            setWorktree(wt);
+            return `${wt.created ? "Created" : "Switched to"} worktree ${wt.name} on branch ${wt.branch} · ${wt.path}`;
+        },
+        /** Returns to `home`, optionally removing the worktree and its branch. */
+        async leave(remove) {
+            const wt = worktree;
+            moveTo(home);
+            setWorktree(null);
+            if (!remove)
+                return `Kept worktree ${wt.name} at ${wt.path} (branch ${wt.branch}). Return with megacode -w ${wt.name}.`;
+            await removeWorktree(wt);
+            return `Removed worktree ${wt.name} and branch ${wt.branch}.`;
+        },
+    };
+}

package/dist/ui/loginFlow.js

@@ -0,0 +1,37 @@
+/** A provider's first step: choose a method when there are several, else go straight to its only one. */
+export function firstStep(info) {
+    if (info.methods.length > 1)
+        return "method";
+    return info.methods[0] === "url" ? "url" : "key";
+}
+/**
+ * Where esc leads from `step`; "close" ends the dialog. A dialog opened for one provider
+ * (e.g. `/login openai`) has no provider list to go back to.
+ */
+export function stepBack(step, info, openedForProvider) {
+    if (step === "pick" || !info)
+        return "close";
+    if (step === "key" && info.keyOptional)
+        return "url";
+    if (step === "browser" || (step === "key" && info.methods.length > 1))
+        return "method";
+    return openedForProvider ? "close" : "pick";
+}
+/** After credentials fail, the step where the likely cause can be fixed. */
+export function stepAfterFailure(info, method, key) {
+    if (info.local || (info.keyOptional && !key))
+        return "url"; // the endpoint is the likely problem
+    if (method && method !== "key")
+        return "method"; // a browser sign-in: try again or pick another way
+    return "key";
+}
+/** An error from verifying credentials, in words that say what to do. */
+export function friendlyError(e, info, baseURL) {
+    if (e.status === 401 || e.status === 403 || /api key|unauthori[sz]ed|invalid.*key/i.test(e.message))
+        return "Those credentials were rejected. Check them and try again.";
+    if (/ECONNREFUSED|fetch failed|Connection error|Timed out/i.test(e.message)) {
+        const hint = info?.local ? `Is ${info.label.replace(" (local)", "")} running at ${baseURL}?` : "Check the URL and your network.";
+        return `Couldn't connect. ${hint}`;
+    }
+    return e.message.split("\n")[0];
+}

package/dist/ui/mcpWizard.js

@@ -0,0 +1,18 @@
+import { isHttpUrl, SERVER_NAME, splitCommand } from "../adapters/mcp/config.js";
+// Steps and checks for the /mcp "Add server" wizard, kept apart from rendering so they can be tested.
+export const ADD_STEPS = ["name", "type", "target", "extras"];
+/** The step before `step`, or null to leave the wizard. */
+export const previousAddStep = (step) => ADD_STEPS[ADD_STEPS.indexOf(step) - 1] ?? null;
+export function serverNameError(name, existing) {
+    if (!SERVER_NAME.test(name))
+        return "Use letters, digits, - and _ (max 32).";
+    if (existing.includes(name))
+        return `A server named ${name} already exists.`;
+    return null;
+}
+/** `target` is a URL for http/sse servers and a command line for stdio ones. */
+export function targetError(type, target) {
+    if (type === "stdio")
+        return splitCommand(target).length ? null : "Enter a command.";
+    return isHttpUrl(target) ? null : "Enter an http:// or https:// URL.";
+}

package/dist/ui/plain.js

@@ -0,0 +1,60 @@
+import { createInterface } from "node:readline/promises";
+import { styleText } from "node:util";
+import { providerInfo } from "../adapters/providers/catalog.js";
+import { needsLogin, providerOf } from "../adapters/providers/credentials.js";
+import { autoApproved } from "../core/settings.js";
+import { approvalBody, displayOutput, formatCall, previewOutput } from "./format.js";
+/** Non-interactive mode for one-shot prompts and pipes: prints the transcript as plain text. */
+export async function runPlain(agent, prompt, mode) {
+    if (needsLogin(agent.model)) {
+        const info = providerInfo(providerOf(agent.model));
+        const env = info.env[0] ? ` or set $${info.env[0]}` : "";
+        console.error(`Not logged in to ${info.label}. Run megacode and use /login${env}.`);
+        return 1;
+    }
+    const controller = new AbortController();
+    process.on("SIGINT", () => controller.abort());
+    const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+    const approve = async (req) => {
+        if (autoApproved(mode, req.tool))
+            return true;
+        if (!rl)
+            return false;
+        console.log(`${styleText("yellow", req.title)}\n${approvalBody(req)}`);
+        try {
+            const answer = await rl.question(styleText("yellow", "Allow? [y/N] "), { signal: controller.signal });
+            return answer.trim().toLowerCase() === "y";
+        }
+        catch {
+            // Ctrl+C at the prompt: readline takes it (so SIGINT never fires) and rejects. Stop the whole run.
+            controller.abort();
+            return false;
+        }
+    };
+    let midLine = false;
+    try {
+        await agent.send(prompt, controller.signal, {
+            approve,
+            onText(d) {
+                process.stdout.write(d);
+                midLine = !d.endsWith("\n");
+            },
+            onStepEnd() {
+                if (midLine)
+                    process.stdout.write("\n");
+                midLine = false;
+            },
+            onToolStart: (call) => console.log(styleText("cyan", `⏺ ${formatCall(call)}`)),
+            onToolEnd: (call, r) => console.log(styleText(r.isError ? "red" : "dim", `  ⎿  ${previewOutput(displayOutput(call, r)).replace(/\n/g, "\n     ")}`)),
+            onNotice: (text, level) => console.log(styleText(level === "error" ? "red" : "yellow", text)),
+        });
+        return 0;
+    }
+    catch (e) {
+        console.error(styleText("red", controller.signal.aborted ? "Interrupted." : `Error: ${e.message}`));
+        return 1;
+    }
+    finally {
+        rl?.close();
+    }
+}