smolcoder 0.4.0

package/dist/index.js

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+"use strict";
+// smolcoder — a tiny, zero-config CLI coding agent for local models.
+//
+// Interactive: an opencode-style inline TUI. No upfront questions — the last
+// (or first) detected model is picked automatically; switch with /models,
+// cycle modes with shift+tab, set reasoning effort with /effort.
+// Headless: smol -p "prompt" for people and automations.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const agent_1 = require("./agent");
+const context_1 = require("./context");
+const detect_1 = require("./detect");
+const events_1 = require("./events");
+const plan_1 = require("./plan");
+const prompt_1 = require("./prompt");
+const lmstudio_1 = require("./providers/lmstudio");
+const ollama_1 = require("./providers/ollama");
+const index_1 = require("./tools/index");
+const shell_1 = require("./tools/shell");
+const tasks_1 = require("./tools/tasks");
+const tui_1 = require("./tui/tui");
+const ui_1 = require("./ui");
+const webui_1 = require("./web/webui");
+const util_1 = require("./util");
+const VERSION = require("../package.json").version;
+const CONFIG_PATH = path.join(os.homedir(), ".smolcoder.json");
+function parseArgs(argv) {
+    const args = { workspace: process.cwd() };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--help" || a === "-h")
+            args.help = true;
+        else if (a === "--version" || a === "-v")
+            args.version = true;
+        else if (a === "--mode" || a === "-m") {
+            const v = argv[++i];
+            if (v === "ro" || v === "read-only" || v === "readonly")
+                args.mode = "ro";
+            else if (v === "edit" || v === "e" || v === "write" || v === "w")
+                args.mode = "edit";
+            else if (v === "bypass" || v === "bypass-permissions" || v === "b" || v === "yolo" || v === "y")
+                args.mode = "bypass";
+            else {
+                console.error(`Unknown mode "${v}". Use ro, edit, or bypass.`);
+                process.exit(1);
+            }
+        }
+        else if (a === "--bypass" || a === "--bypass-permissions" || a === "--yolo")
+            args.mode = "bypass";
+        else if (a === "--model")
+            args.model = argv[++i];
+        else if (a === "--ctx")
+            args.ctx = Number(argv[++i]) || undefined;
+        else if (a === "--effort") {
+            const v = argv[++i];
+            if (v === "off" || v === "low" || v === "medium" || v === "high")
+                args.effort = v;
+            else if (v === "default")
+                args.effort = null;
+            else {
+                console.error(`Unknown effort "${v}". Use off, low, medium, high, or default.`);
+                process.exit(1);
+            }
+        }
+        else if (a === "--print" || a === "-p")
+            args.print = argv[++i];
+        else if (a === "--web") {
+            args.web = true;
+            if (argv[i + 1] && /^\d+$/.test(argv[i + 1]))
+                args.webPort = Number(argv[++i]);
+        }
+        else if (!a.startsWith("-"))
+            args.workspace = path.resolve(a);
+        else {
+            console.error(`Unknown option "${a}". Try smol --help.`);
+            process.exit(1);
+        }
+    }
+    return args;
+}
+const HELP = `
+${util_1.c.bold("smolcoder")} v${VERSION} — a tiny, zero-config coding agent for local models.
+
+Detects Ollama and LM Studio automatically. No configuration.
+
+${util_1.c.bold("Usage:")}
+  smol [workspace] [options]
+
+${util_1.c.bold("Options:")}
+  -m, --mode <ro|edit|bypass>  ro: read files only. edit: read/write files and run
+                               commands inside the workspace; anything reaching
+                               outside it asks y/n. bypass: no approvals at all.
+  --model <name>               pick a model by (partial) name
+  --ctx <tokens>               force a context window (Ollama: sends num_ctx)
+  --effort <level>             reasoning effort: off, low, medium, high, default
+  --web [port]                 serve the session as a local web UI (default port 7433)
+  -p, --print "<prompt>"       headless: run a single prompt and exit
+  -h, --help                   this help
+  -v, --version                version
+
+${util_1.c.bold("Keys:")}
+  shift+tab   cycle mode (read-only → edit → bypass permissions)
+  /           slash commands (autocomplete menu)
+  esc         cancel a running turn · clear the input
+  ctrl+c ×2   quit
+
+${util_1.c.bold("Slash commands:")}
+  /models     switch model         /tasks        background tasks
+  /mode       set mode             /logs <id>    task output
+  /effort     reasoning effort     /stop <id>    kill a task
+  /context    context usage        /clear        reset conversation
+  /compact    compact now          /exit         quit
+`;
+function loadConfig() {
+    try {
+        const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+        // Never let bypass be inherited implicitly from a past session — a single
+        // shift+tab into it would otherwise silently persist unattended, unchecked
+        // command execution into every later run, including headless -p in CI.
+        // Requires an explicit flag (-m bypass / --bypass) each time. Old configs
+        // saved "write"/"yolo" under the previous mode names.
+        if (cfg.lastMode === "write")
+            cfg.lastMode = "edit";
+        if (cfg.lastMode === "yolo" || cfg.lastMode === "bypass")
+            cfg.lastMode = "edit";
+        return cfg;
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(cfg) {
+    try {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+/** Output budget scales with the window: big windows can afford whole-file
+ * writes (a single write_file's JSON must fit in the output), tiny windows
+ * must stay conservative. */
+function outputBudget(window) {
+    return Math.max(1024, Math.min(16384, Math.floor(window / 4)));
+}
+function makeProvider(m) {
+    const maxOut = outputBudget(m.contextWindow);
+    return m.backend === "ollama"
+        ? new ollama_1.OllamaProvider(m.baseUrl, m.id, m.contextWindow, m.numCtx, maxOut)
+        : new lmstudio_1.LmStudioProvider(m.baseUrl, m.id, m.contextWindow, maxOut, m.reasoning);
+}
+/** One-line advice when the effective reasoning setting will be slow: LM
+ * Studio applies the model's own default level when none is chosen, and for
+ * current qwen builds that default is the maximum. */
+function effortAdvice(m, effort) {
+    if (m.backend !== "lmstudio" || !m.reasoning?.default)
+        return null;
+    const d = m.reasoning.default;
+    if (effort === null && /^(high|xhigh)$/.test(d)) {
+        return `this model thinks at "${d}" by default on LM Studio — expect long pauses before each tool call. /effort off (or --effort off) is many times faster; /effort low or medium keeps some reasoning.`;
+    }
+    return null;
+}
+/** Tell the user what context management just did (both UIs; headless logs
+ * it to stderr so a long run's log shows when and how hard compaction hit). */
+function reportCompactions(bus, ui) {
+    bus.on("post_compact", (report) => {
+        const delta = `${report?.before} → ${report?.after} tokens est.`;
+        if (report?.action === "evicted")
+            ui.status(`· freed context by dropping old tool output (${delta})`);
+        else if (report?.action === "compacted")
+            ui.status(`· compacted the conversation into hand-over notes (${delta})`);
+        else if (report?.action === "floor")
+            ui.warn(`· context is at its floor: system prompt + tools + the working tail no longer fit comfortably (${delta}). Consider a bigger context window.`);
+    });
+}
+/** Node fires 'exit' on normal termination but NOT on a killing signal, so
+ * background tasks (dev servers) survive a closed terminal (SIGHUP) or `kill`
+ * (SIGTERM) unless we handle those explicitly. Runs synchronous cleanup then
+ * re-exits so the 'exit' path is still reached. */
+function installSignalCleanup(cleanup) {
+    let done = false;
+    const run = (code) => {
+        if (done)
+            return;
+        done = true;
+        try {
+            cleanup();
+        }
+        catch {
+            /* best effort */
+        }
+        process.exit(code);
+    };
+    process.on("SIGTERM", () => run(143));
+    process.on("SIGHUP", () => run(129));
+    process.on("SIGINT", () => run(130));
+}
+function autoPickModel(models, wanted, remembered) {
+    if (wanted) {
+        const hit = models.find((m) => m.id === wanted) ??
+            models.find((m) => m.id.toLowerCase().includes(wanted.toLowerCase()));
+        if (hit)
+            return hit;
+    }
+    return (models.find((m) => m.id === remembered) ??
+        models.find((m) => m.backend === "ollama") ??
+        models.find((m) => m.loaded) ??
+        models[0]);
+}
+function noBackendsMessage() {
+    return (util_1.c.red("No local model backend found.") +
+        `\n\nsmolcoder looks for:\n` +
+        `  · ${util_1.c.bold("Ollama")} at http://127.0.0.1:11434 ${util_1.c.dim("(or $OLLAMA_HOST)")} — install: https://ollama.com, then: ollama pull qwen3\n` +
+        `  · ${util_1.c.bold("LM Studio")} at http://127.0.0.1:1234 — start its local server (Developer tab → Start Server)\n\n` +
+        `Start one of them and run smol again. No configuration needed.`);
+}
+function sessionLine(m, mode) {
+    return `${util_1.c.green("●")} ${m.backend} · ${util_1.c.bold(m.id)} · ctx ${m.contextWindow.toLocaleString()} · ${index_1.MODE_LABELS[mode]} mode`;
+}
+const MODE_ORDER = ["ro", "edit", "bypass"];
+const LOGO_ROWS = [
+    "████████╗ ██╗ ███╗   ██╗ ██╗   ██╗",
+    "╚══██╔══╝ ██║ ████╗  ██║ ╚██╗ ██╔╝",
+    "   ██║    ██║ ██╔██╗ ██║  ╚████╔╝ ",
+    "   ██║    ██║ ██║╚██╗██║   ╚██╔╝  ",
+    "   ██║    ██║ ██║ ╚████║    ██║   ",
+    "   ╚═╝    ╚═╝ ╚═╝  ╚═══╝    ╚═╝   ",
+];
+function printLogo() {
+    const cols = process.stdout.columns || 80;
+    if (cols >= 46) {
+        console.log();
+        LOGO_ROWS.forEach((row, i) => {
+            const tail = i === LOGO_ROWS.length - 1 ? "  " + util_1.c.dim(util_1.c.bold("coder") + " v" + VERSION) : "";
+            console.log(" " + util_1.c.cyan(row) + tail);
+        });
+        console.log();
+    }
+    else {
+        console.log(`${util_1.c.bold("tiny")}${util_1.c.dim(util_1.c.bold("coder"))} ${util_1.c.dim("v" + VERSION)}`);
+    }
+}
+function fmtTokens(n) {
+    return n < 1000 ? String(n) : (n / 1000).toFixed(1) + "k";
+}
+function modeColored(mode) {
+    const label = index_1.MODE_LABELS[mode];
+    if (mode === "bypass")
+        return util_1.c.red(util_1.c.bold(label));
+    if (mode === "ro")
+        return util_1.c.magenta(util_1.c.bold(label));
+    return util_1.c.cyan(util_1.c.bold(label));
+}
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    if (args.version) {
+        console.log(VERSION);
+        return;
+    }
+    if (!fs.existsSync(args.workspace) || !fs.statSync(args.workspace).isDirectory()) {
+        console.error(`Workspace folder does not exist: ${args.workspace}`);
+        process.exit(1);
+    }
+    if (args.print !== undefined) {
+        await runHeadless(args);
+    }
+    else {
+        await runInteractive(args);
+    }
+}
+// ---- headless (-p) ---------------------------------------------------------
+async function runHeadless(args) {
+    const ui = new ui_1.UI();
+    const bus = new events_1.EventBus();
+    const models = await (0, detect_1.detectAll)();
+    if (models.length === 0) {
+        ui.println(noBackendsMessage());
+        ui.close();
+        process.exit(1);
+    }
+    const cfg = loadConfig();
+    let chosen = autoPickModel(models, args.model, cfg.lastModel);
+    chosen = await (0, detect_1.resolveContextWindow)(chosen, args.ctx);
+    const mode = args.mode ?? cfg.lastMode ?? "edit";
+    const shell = (0, shell_1.pickShell)();
+    const provider = makeProvider(chosen);
+    provider.setEffort(args.effort !== undefined ? args.effort : (cfg.effort ?? null));
+    const taskManager = new tasks_1.TaskManager(args.workspace);
+    const toolCtx = {
+        workspace: args.workspace,
+        taskManager,
+        plan: new plan_1.Plan(),
+        filesTouched: new Set(),
+        commandsRun: [],
+    };
+    const ctxMgr = new context_1.ContextManager(chosen.contextWindow, provider.maxOutputTokens);
+    const agentsMd = (0, prompt_1.loadAgentsMd)(args.workspace);
+    if (agentsMd)
+        ui.status(`· AGENTS.md loaded (${agentsMd.split("\n").length} lines)`);
+    const systemPrompt = (0, prompt_1.buildSystemPrompt)({ workspace: args.workspace, mode, shellLabel: shell.label, agentsMd });
+    const agent = new agent_1.Agent(provider, mode, systemPrompt, toolCtx, ctxMgr, bus, ui, false, 1000);
+    reportCompactions(bus, ui);
+    process.on("exit", () => taskManager.killAll());
+    installSignalCleanup(() => taskManager.killAll());
+    ui.println(sessionLine(chosen, mode));
+    if (chosen.note)
+        ui.warn(`  ${chosen.note}`);
+    const effortSetting = args.effort !== undefined ? args.effort : (cfg.effort ?? null);
+    ui.status(`  effort ${provider.effortLabel() ?? effortSetting ?? "default"}`);
+    const advice = effortAdvice(chosen, effortSetting);
+    if (advice)
+        ui.warn(`  ${advice}`);
+    try {
+        await agent.runTurn(args.print);
+    }
+    catch (err) {
+        ui.error(`\n${err?.message ?? err}`);
+        process.exitCode = 1;
+    }
+    const st = agent.lastTurnStats;
+    if (st) {
+        // Machine-readable summary for scripts/benchmarks comparing backends.
+        process.stderr.write(`[stats] ${JSON.stringify({
+            backend: chosen.backend,
+            model: chosen.id,
+            durationMs: st.durationMs,
+            modelCalls: st.modelCalls,
+            toolCalls: st.toolCalls,
+            generatedTokens: st.generatedTokens,
+            thinkingTokensEst: Math.round(st.thinkingChars / 4),
+            genTokPerSec: st.genSeconds > 0 ? Math.round(st.generatedTokens / st.genSeconds) : null,
+            promptTokensLast: st.promptTokensLast,
+            contextWindow: chosen.contextWindow,
+            planDone: toolCtx.plan.exists ? `${toolCtx.plan.doneCount}/${toolCtx.plan.steps.length}` : null,
+        })}\n`);
+    }
+    taskManager.killAll();
+    ui.close();
+}
+// ---- interactive TUI -------------------------------------------------------
+const SLASH_COMMANDS = [
+    { name: "models", desc: "Switch model" },
+    { name: "mode", desc: "Set mode (ro / edit / bypass)" },
+    { name: "effort", desc: "Set reasoning effort" },
+    { name: "plan", desc: "Show the agent's plan" },
+    { name: "context", desc: "Show context usage" },
+    { name: "compact", desc: "Compact the conversation now" },
+    { name: "tasks", desc: "List background tasks" },
+    { name: "logs", desc: "Show task output — /logs t1" },
+    { name: "stop", desc: "Stop a background task — /stop t1" },
+    { name: "clear", desc: "Reset the conversation" },
+    { name: "help", desc: "Show help" },
+    { name: "exit", desc: "Quit smolcoder" },
+];
+async function runInteractive(args) {
+    const isWeb = !!args.web;
+    if (!isWeb && (!process.stdout.isTTY || !process.stdin.isTTY)) {
+        console.error('Interactive mode needs a terminal. For headless use, run: smol -p "your prompt" — or serve a browser UI with --web');
+        process.exit(1);
+    }
+    if (isWeb)
+        console.log(`${util_1.c.bold("tiny")}${util_1.c.dim(util_1.c.bold("coder"))} ${util_1.c.dim("v" + VERSION + " · web")}`);
+    else
+        printLogo();
+    process.stdout.write(util_1.c.dim("· looking for Ollama and LM Studio…"));
+    const models = await (0, detect_1.detectAll)();
+    process.stdout.write("\r\x1b[2K");
+    if (models.length === 0) {
+        console.log(noBackendsMessage());
+        process.exit(1);
+    }
+    const cfg = loadConfig();
+    let chosen = autoPickModel(models, args.model, cfg.lastModel);
+    process.stdout.write(util_1.c.dim(`· loading ${chosen.id}…`));
+    chosen = await (0, detect_1.resolveContextWindow)(chosen, args.ctx);
+    process.stdout.write("\r\x1b[2K");
+    const mode0 = args.mode ?? cfg.lastMode ?? "edit";
+    let effort = args.effort !== undefined ? args.effort : (cfg.effort ?? null);
+    const shell = (0, shell_1.pickShell)();
+    const bus = new events_1.EventBus();
+    const provider = makeProvider(chosen);
+    provider.setEffort(effort);
+    const taskManager = new tasks_1.TaskManager(args.workspace);
+    const toolCtx = {
+        workspace: args.workspace,
+        taskManager,
+        plan: new plan_1.Plan(),
+        filesTouched: new Set(),
+        commandsRun: [],
+    };
+    const ctxMgr = new context_1.ContextManager(chosen.contextWindow, provider.maxOutputTokens);
+    const agentsMd = (0, prompt_1.loadAgentsMd)(args.workspace);
+    const sysPrompt = (m) => (0, prompt_1.buildSystemPrompt)({ workspace: args.workspace, mode: m, shellLabel: shell.label, agentsMd });
+    // The step cap is a runaway-loop backstop, not a work limit — esc/ctrl+c is
+    // the user's real kill switch, so set it far above any legitimate task.
+    const tui = isWeb ? new webui_1.WebUI(args.webPort ?? 7433) : new tui_1.Tui();
+    const agent = new agent_1.Agent(provider, mode0, sysPrompt(mode0), toolCtx, ctxMgr, bus, tui, true, 1000);
+    const persist = () => saveConfig({ lastModel: chosen.id, lastMode: agent.mode, effort });
+    tui.slashCommands = SLASH_COMMANDS;
+    tui.hintLeft = args.workspace.replace(os.homedir(), "~");
+    tui.getStatus = () => {
+        const tasks = taskManager.runningSummary().length;
+        return (`${modeColored(agent.mode)} ${util_1.c.dim("·")} ${chosen.id} ${util_1.c.dim(chosen.backend)}` +
+            (effort || agent.provider.effortLabel()
+                ? ` ${util_1.c.dim("·")} ${util_1.c.yellow(agent.provider.effortLabel() ?? effort ?? "")}`
+                : "") +
+            ` ${util_1.c.dim("·")} ${util_1.c.dim(`${fmtTokens(agent.contextTokens())} (${agent.contextPercent()}%)`)}` +
+            (toolCtx.plan.exists
+                ? ` ${util_1.c.dim("·")} ${toolCtx.plan.currentIndex < 0
+                    ? util_1.c.green(`plan ${toolCtx.plan.doneCount}/${toolCtx.plan.steps.length}`)
+                    : util_1.c.cyan(`plan ${toolCtx.plan.doneCount}/${toolCtx.plan.steps.length}`)}`
+                : "") +
+            (tasks ? ` ${util_1.c.dim("·")} ${util_1.c.green(`${tasks} task${tasks > 1 ? "s" : ""}`)}` : ""));
+    };
+    tui.onModeCycle = () => {
+        const next = MODE_ORDER[(MODE_ORDER.indexOf(agent.mode) + 1) % MODE_ORDER.length];
+        agent.setMode(next, sysPrompt(next));
+        persist();
+    };
+    tui.onCancel = () => agent.cancel();
+    const shutdown = async () => {
+        await bus.emit("session_end");
+        taskManager.killAll();
+        tui.close();
+        process.exit(0);
+    };
+    tui.onExit = () => void shutdown();
+    process.on("exit", () => taskManager.killAll());
+    installSignalCleanup(() => {
+        taskManager.killAll();
+        try {
+            tui.close(); // restore the raw-mode terminal on signal death
+        }
+        catch {
+            /* best effort */
+        }
+    });
+    reportCompactions(bus, tui);
+    if (tui instanceof webui_1.WebUI) {
+        tui.getState = () => ({
+            mode: agent.mode,
+            model: chosen.id,
+            backend: chosen.backend,
+            effort: agent.provider.effortLabel() ?? effort,
+            ctxTokens: agent.contextTokens(),
+            ctxPct: agent.contextPercent(),
+            plan: toolCtx.plan.exists
+                ? { steps: toolCtx.plan.steps, current: toolCtx.plan.currentIndex }
+                : null,
+            tasks: taskManager.runningSummary().length,
+            workspace: args.workspace,
+            commands: SLASH_COMMANDS,
+        });
+    }
+    tui.start();
+    tui.println(sessionLine(chosen, agent.mode));
+    if (chosen.note)
+        tui.warn(`  ${chosen.note}`);
+    tui.status(`  workspace ${args.workspace} · shell ${shell.label}`);
+    if (agentsMd)
+        tui.status(`  AGENTS.md loaded (${agentsMd.split("\n").length} lines)`);
+    {
+        const advice = effortAdvice(chosen, effort);
+        if (advice)
+            tui.warn(`  ${advice}`);
+    }
+    if (!isWeb)
+        tui.println("");
+    persist();
+    await bus.emit("session_start");
+    const switchModel = async (filter) => {
+        const fresh = await (0, detect_1.detectAll)();
+        if (!fresh.length) {
+            tui.error("No backends reachable right now.");
+            return;
+        }
+        const options = fresh.map((m) => ({
+            label: m.id,
+            hint: m.backend === "ollama"
+                ? "ollama"
+                : `lm studio${m.loaded ? ` · ctx ${m.contextWindow.toLocaleString()}` : " · not loaded"}`,
+            current: m.id === chosen.id && m.backend === chosen.backend,
+        }));
+        const idx = await tui.select("Select model", options);
+        if (idx === null)
+            return;
+        tui.startSpinner(`loading ${fresh[idx].id}`);
+        const next = await (0, detect_1.resolveContextWindow)(fresh[idx], args.ctx);
+        tui.stopSpinner();
+        chosen = next;
+        const p = makeProvider(next);
+        p.setEffort(effort);
+        agent.setProvider(p);
+        ctxMgr.setWindow(next.contextWindow, p.maxOutputTokens);
+        persist();
+        tui.println(sessionLine(next, agent.mode));
+        if (next.note)
+            tui.warn(`  ${next.note}`);
+        {
+            const advice = effortAdvice(next, effort);
+            if (advice)
+                tui.warn(`  ${advice}`);
+        }
+        void filter;
+    };
+    const setMode = async (arg) => {
+        let next = arg === "ro"
+            ? "ro"
+            : arg === "edit" || arg === "write"
+                ? "edit"
+                : arg === "bypass" || arg === "yolo"
+                    ? "bypass"
+                    : undefined;
+        if (!next) {
+            const idx = await tui.select("Select mode", [
+                { label: "read-only", hint: "read and search files only", current: agent.mode === "ro" },
+                {
+                    label: "edit",
+                    hint: "edit files; run commands inside the workspace, ask y/n for anything outside it",
+                    current: agent.mode === "edit",
+                },
+                {
+                    label: "bypass permissions",
+                    hint: "full access, never asks for approval",
+                    current: agent.mode === "bypass",
+                },
+            ]);
+            if (idx === null)
+                return;
+            next = MODE_ORDER[idx];
+        }
+        agent.setMode(next, sysPrompt(next));
+        persist();
+    };
+    const setEffort = async (arg) => {
+        const levels = ["default", "off", "low", "medium", "high"];
+        let next;
+        if (arg && levels.includes(arg)) {
+            next = arg === "default" ? null : arg;
+        }
+        else {
+            const idx = await tui.select("Reasoning effort", [
+                {
+                    label: "default",
+                    hint: chosen.reasoning?.default ? `the model's own default (${chosen.reasoning.default})` : "leave it to the model",
+                    current: effort === null,
+                },
+                { label: "off", hint: "no thinking — fastest, best for long tool loops", current: effort === "off" },
+                { label: "low", hint: "brief reasoning", current: effort === "low" },
+                { label: "medium", hint: "", current: effort === "medium" },
+                { label: "high", hint: "most thorough — slow on local models", current: effort === "high" },
+            ]);
+            if (idx === null)
+                return;
+            next = idx === 0 ? null : levels[idx];
+        }
+        effort = next;
+        agent.provider.setEffort(effort);
+        persist();
+        const label = agent.provider.effortLabel();
+        tui.status(`· effort ${label ?? effort ?? "default"}`);
+        const advice = effortAdvice(chosen, effort);
+        if (advice)
+            tui.warn(`  ${advice}`);
+    };
+    for (;;) {
+        const input = await tui.readInput();
+        if (input.startsWith("/")) {
+            const [cmd, ...rest] = input.slice(1).split(/\s+/);
+            const arg = rest[0];
+            switch (cmd) {
+                case "exit":
+                case "quit":
+                case "q":
+                    await shutdown();
+                    return;
+                case "help":
+                    tui.println(HELP);
+                    break;
+                case "models":
+                case "model":
+                    await switchModel(arg);
+                    break;
+                case "mode":
+                    await setMode(arg);
+                    break;
+                case "effort":
+                    await setEffort(arg);
+                    break;
+                case "plan":
+                    if (toolCtx.plan.exists)
+                        tui.planUpdated(toolCtx.plan);
+                    else
+                        tui.status("· no plan yet — the agent creates one when it starts a multi-step task");
+                    break;
+                case "tasks":
+                    tui.println(taskManager.list());
+                    break;
+                case "logs":
+                    tui.println(taskManager.logs(arg ?? "", Number(rest[1]) || 50));
+                    break;
+                case "stop":
+                    tui.println(taskManager.stop(arg ?? ""));
+                    break;
+                case "compact":
+                    tui.startSpinner("compacting");
+                    await agent.compactNow();
+                    tui.stopSpinner();
+                    tui.status(`· compacted — ctx now ${agent.contextPercent()}%`);
+                    break;
+                case "context":
+                    tui.status(`· ctx ${agent.contextPercent()}% of ${chosen.contextWindow.toLocaleString()} tokens · ${agent.messages.length} messages`);
+                    break;
+                case "clear":
+                    agent.resetTranscript();
+                    toolCtx.plan.reset();
+                    tui.status("· conversation cleared");
+                    break;
+                default:
+                    tui.warn(`Unknown command /${cmd} — try /help`);
+            }
+            continue;
+        }
+        try {
+            await agent.runTurn(input);
+        }
+        catch (err) {
+            tui.error(`\n${err?.message ?? err}`);
+            if (String(err?.message ?? "").toLowerCase().includes("does not support tools")) {
+                tui.warn("This model does not support tool calling. Pick a tool-capable model with /models (e.g. qwen3, llama3.1, mistral-nemo).");
+            }
+        }
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});