smolcoder 0.4.2 → 0.5.0

package/dist/session.js

@@ -0,0 +1,480 @@
+"use strict";
+// One session = one workspace + one agent + one UI, plus the input loop and
+// slash commands that drive it. Extracted from the CLI entry point so the
+// terminal TUI and the web hub (many sessions side by side, one per browser
+// sidebar entry) run exactly the same loop.
+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 });
+exports.Session = exports.MODE_ORDER = exports.SLASH_COMMANDS = void 0;
+exports.outputBudget = outputBudget;
+exports.makeProvider = makeProvider;
+exports.effortAdvice = effortAdvice;
+exports.reportCompactions = reportCompactions;
+exports.autoPickModel = autoPickModel;
+exports.noBackendsMessage = noBackendsMessage;
+exports.sessionLine = sessionLine;
+exports.fmtTokens = fmtTokens;
+exports.prepareModel = prepareModel;
+const os = __importStar(require("os"));
+const agent_1 = require("./agent");
+const config_1 = require("./config");
+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 util_1 = require("./util");
+exports.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 (web: close this session)" },
+];
+exports.MODE_ORDER = ["ro", "edit", "bypass"];
+// ---- model selection helpers (shared with the headless path) --------------
+/** 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.`);
+    });
+}
+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`;
+}
+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));
+}
+/** Detect backends, pick a model and resolve its context window. Returns null
+ * when no backend answers. `progress` gets a short label for each slow step. */
+async function prepareModel(prefs, cfg, progress) {
+    progress?.("looking for Ollama and LM Studio");
+    const models = await (0, detect_1.detectAll)();
+    if (models.length === 0)
+        return null;
+    const chosen = autoPickModel(models, prefs.model, cfg.lastModel);
+    progress?.(`loading ${chosen.id}`);
+    return (0, detect_1.resolveContextWindow)(chosen, prefs.ctx);
+}
+class Session {
+    ui;
+    workspace;
+    chosen;
+    effort;
+    agent;
+    toolCtx;
+    taskManager;
+    ctxMgr;
+    bus = new events_1.EventBus();
+    shell = (0, shell_1.pickShell)();
+    /** Host hook: fired once when the session has shut down (/exit, ctrl+c). */
+    onExit = null;
+    agentsMd;
+    prefs;
+    help;
+    ended = false;
+    constructor(ui, opts) {
+        this.ui = ui;
+        const { workspace, chosen, prefs, cfg } = opts;
+        this.workspace = workspace;
+        this.chosen = chosen;
+        this.prefs = prefs;
+        this.help = opts.help;
+        const mode0 = prefs.mode ?? cfg.lastMode ?? "edit";
+        this.effort = prefs.effort !== undefined ? prefs.effort : (cfg.effort ?? null);
+        const provider = makeProvider(chosen);
+        provider.setEffort(this.effort);
+        this.taskManager = new tasks_1.TaskManager(workspace);
+        this.toolCtx = {
+            workspace,
+            taskManager: this.taskManager,
+            plan: new plan_1.Plan(),
+            filesTouched: new Set(),
+            commandsRun: [],
+        };
+        this.ctxMgr = new context_1.ContextManager(chosen.contextWindow, provider.maxOutputTokens);
+        this.agentsMd = (0, prompt_1.loadAgentsMd)(workspace);
+        // 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.
+        this.agent = new agent_1.Agent(provider, mode0, this.sysPrompt(mode0), this.toolCtx, this.ctxMgr, this.bus, ui, true, 1000);
+        ui.slashCommands = exports.SLASH_COMMANDS;
+        ui.hintLeft = workspace.replace(os.homedir(), "~");
+        ui.getStatus = () => this.statusLine();
+        ui.onModeCycle = () => {
+            const next = exports.MODE_ORDER[(exports.MODE_ORDER.indexOf(this.agent.mode) + 1) % exports.MODE_ORDER.length];
+            this.agent.setMode(next, this.sysPrompt(next));
+            this.persist();
+        };
+        ui.onCancel = () => this.agent.cancel();
+        ui.onExit = () => void this.shutdown();
+        reportCompactions(this.bus, ui);
+        this.persist();
+    }
+    sysPrompt(mode) {
+        return (0, prompt_1.buildSystemPrompt)({ workspace: this.workspace, mode, shellLabel: this.shell.label, agentsMd: this.agentsMd });
+    }
+    persist() {
+        (0, config_1.saveConfig)({ lastModel: this.chosen.id, lastMode: this.agent.mode, effort: this.effort });
+    }
+    /** The TUI's status row: mode · model · effort · context · plan · tasks. */
+    statusLine() {
+        const agent = this.agent;
+        const tasks = this.taskManager.runningSummary().length;
+        const plan = this.toolCtx.plan;
+        return (`${modeColored(agent.mode)} ${util_1.c.dim("·")} ${this.chosen.id} ${util_1.c.dim(this.chosen.backend)}` +
+            (this.effort || agent.provider.effortLabel()
+                ? ` ${util_1.c.dim("·")} ${util_1.c.yellow(agent.provider.effortLabel() ?? this.effort ?? "")}`
+                : "") +
+            ` ${util_1.c.dim("·")} ${util_1.c.dim(`${fmtTokens(agent.contextTokens())} (${agent.contextPercent()}%)`)}` +
+            (plan.exists
+                ? ` ${util_1.c.dim("·")} ${plan.currentIndex < 0
+                    ? util_1.c.green(`plan ${plan.doneCount}/${plan.steps.length}`)
+                    : util_1.c.cyan(`plan ${plan.doneCount}/${plan.steps.length}`)}`
+                : "") +
+            (tasks ? ` ${util_1.c.dim("·")} ${util_1.c.green(`${tasks} task${tasks > 1 ? "s" : ""}`)}` : ""));
+    }
+    /** Structured status for the web page's status bar. */
+    state() {
+        const plan = this.toolCtx.plan;
+        return {
+            mode: this.agent.mode,
+            model: this.chosen.id,
+            backend: this.chosen.backend,
+            effort: this.agent.provider.effortLabel() ?? this.effort,
+            ctxTokens: this.agent.contextTokens(),
+            ctxPct: this.agent.contextPercent(),
+            plan: plan.exists ? { steps: plan.steps, current: plan.currentIndex } : null,
+            tasks: this.taskManager.runningSummary().length,
+            workspace: this.workspace,
+            commands: exports.SLASH_COMMANDS,
+            urls: this.taskManager.recentUrls(),
+        };
+    }
+    /** The opening lines: backend · model · mode, workspace, AGENTS.md, advice. */
+    announce() {
+        const ui = this.ui;
+        ui.println(sessionLine(this.chosen, this.agent.mode));
+        if (this.chosen.note)
+            ui.warn(`  ${this.chosen.note}`);
+        ui.status(`  workspace ${this.workspace} · shell ${this.shell.label}`);
+        if (this.agentsMd)
+            ui.status(`  AGENTS.md loaded (${this.agentsMd.split("\n").length} lines)`);
+        const advice = effortAdvice(this.chosen, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+    snapshot() {
+        return {
+            messages: this.agent.messages.slice(1),
+            plan: this.toolCtx.plan.steps.map((s) => ({ ...s })),
+            filesTouched: [...this.toolCtx.filesTouched],
+            commandsRun: [...this.toolCtx.commandsRun],
+            originalRequest: this.agent.originalRequest,
+            currentRequest: this.agent.currentRequest,
+            mode: this.agent.mode,
+            effort: this.effort,
+            model: this.chosen.id,
+            backend: this.chosen.backend,
+        };
+    }
+    /** Bring a saved transcript back (the system message is rebuilt for the
+     * current mode/workspace; approvals are deliberately not restored). */
+    restore(s) {
+        this.agent.restoreTranscript(s.messages ?? [], s.originalRequest ?? "", s.currentRequest ?? "");
+        this.toolCtx.plan.steps = (s.plan ?? []).map((p) => ({ text: String(p.text), done: !!p.done }));
+        for (const f of s.filesTouched ?? [])
+            this.toolCtx.filesTouched.add(f);
+        this.toolCtx.commandsRun.push(...(s.commandsRun ?? []));
+    }
+    /** The input loop. Returns after /exit (or after the host asked the UI to
+     * hand back "/exit"). */
+    async run() {
+        const { ui, agent, toolCtx, taskManager } = this;
+        await this.bus.emit("session_start");
+        for (;;) {
+            const input = await ui.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 this.shutdown();
+                        return;
+                    case "help":
+                        ui.println(this.help);
+                        break;
+                    case "models":
+                    case "model":
+                        await this.switchModel();
+                        break;
+                    case "mode":
+                        await this.setMode(arg);
+                        break;
+                    case "effort":
+                        await this.setEffort(arg);
+                        break;
+                    case "plan":
+                        if (toolCtx.plan.exists)
+                            ui.planUpdated(toolCtx.plan);
+                        else
+                            ui.status("· no plan yet — the agent creates one when it starts a multi-step task");
+                        break;
+                    case "tasks":
+                        ui.println(taskManager.list());
+                        break;
+                    case "logs":
+                        ui.println(taskManager.logs(arg ?? "", Number(rest[1]) || 50));
+                        break;
+                    case "stop":
+                        ui.println(taskManager.stop(arg ?? ""));
+                        break;
+                    case "compact":
+                        ui.startSpinner("compacting");
+                        await agent.compactNow();
+                        ui.stopSpinner();
+                        ui.status(`· compacted — ctx now ${agent.contextPercent()}%`);
+                        break;
+                    case "context":
+                        ui.status(`· ctx ${agent.contextPercent()}% of ${this.chosen.contextWindow.toLocaleString()} tokens · ${agent.messages.length} messages`);
+                        break;
+                    case "clear":
+                        agent.resetTranscript();
+                        toolCtx.plan.reset();
+                        ui.status("· conversation cleared");
+                        break;
+                    default:
+                        ui.warn(`Unknown command /${cmd} — try /help`);
+                }
+                ui.refresh();
+                continue;
+            }
+            try {
+                await agent.runTurn(input);
+            }
+            catch (err) {
+                ui.error(`\n${err?.message ?? err}`);
+                if (String(err?.message ?? "").toLowerCase().includes("does not support tools")) {
+                    ui.warn("This model does not support tool calling. Pick a tool-capable model with /models (e.g. qwen3, llama3.1, mistral-nemo).");
+                }
+            }
+        }
+    }
+    /** Idempotent: end-of-session hook, kill background tasks, close the UI,
+     * then tell the host. */
+    async shutdown() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        try {
+            await this.bus.emit("session_end");
+        }
+        catch {
+            /* best effort */
+        }
+        this.taskManager.killAll();
+        this.ui.close();
+        this.onExit?.();
+    }
+    async switchModel() {
+        const { ui, agent } = this;
+        const fresh = await (0, detect_1.detectAll)();
+        if (!fresh.length) {
+            ui.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 === this.chosen.id && m.backend === this.chosen.backend,
+        }));
+        const idx = await ui.select("Select model", options);
+        if (idx === null)
+            return;
+        ui.startSpinner(`loading ${fresh[idx].id}`);
+        const next = await (0, detect_1.resolveContextWindow)(fresh[idx], this.prefs.ctx);
+        ui.stopSpinner();
+        this.chosen = next;
+        const p = makeProvider(next);
+        p.setEffort(this.effort);
+        agent.setProvider(p);
+        this.ctxMgr.setWindow(next.contextWindow, p.maxOutputTokens);
+        this.persist();
+        ui.println(sessionLine(next, agent.mode));
+        if (next.note)
+            ui.warn(`  ${next.note}`);
+        const advice = effortAdvice(next, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+    async setMode(arg) {
+        const { ui, agent } = this;
+        let next = arg === "ro"
+            ? "ro"
+            : arg === "edit" || arg === "write"
+                ? "edit"
+                : arg === "bypass" || arg === "yolo"
+                    ? "bypass"
+                    : undefined;
+        if (!next) {
+            const idx = await ui.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 = exports.MODE_ORDER[idx];
+        }
+        agent.setMode(next, this.sysPrompt(next));
+        this.persist();
+    }
+    async setEffort(arg) {
+        const { ui, agent } = this;
+        const levels = ["default", "off", "low", "medium", "high"];
+        let next;
+        if (arg && levels.includes(arg)) {
+            next = arg === "default" ? null : arg;
+        }
+        else {
+            const idx = await ui.select("Reasoning effort", [
+                {
+                    label: "default",
+                    hint: this.chosen.reasoning?.default
+                        ? `the model's own default (${this.chosen.reasoning.default})`
+                        : "leave it to the model",
+                    current: this.effort === null,
+                },
+                { label: "off", hint: "no thinking — fastest, best for long tool loops", current: this.effort === "off" },
+                { label: "low", hint: "brief reasoning", current: this.effort === "low" },
+                { label: "medium", hint: "", current: this.effort === "medium" },
+                { label: "high", hint: "most thorough — slow on local models", current: this.effort === "high" },
+            ]);
+            if (idx === null)
+                return;
+            next = idx === 0 ? null : levels[idx];
+        }
+        this.effort = next;
+        agent.provider.setEffort(this.effort);
+        this.persist();
+        const label = agent.provider.effortLabel();
+        ui.status(`· effort ${label ?? this.effort ?? "default"}`);
+        const advice = effortAdvice(this.chosen, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+}
+exports.Session = Session;

package/dist/tools/tasks.js

@@ -107,6 +107,21 @@ class TaskManager {
             .filter((t) => t.status === "running")
             .map((t) => `${t.id}: ${t.command}`);
     }
+    /** http://localhost-style URLs printed by running tasks — what a dev server
+     * announces on start — so the web UI can offer them in its browser panel. */
+    recentUrls() {
+        const out = new Set();
+        const re = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\])(?::\d+)?(?:\/[^\s"'<>)\]]*)?/g;
+        for (const t of this.tasks.values()) {
+            if (t.status !== "running")
+                continue;
+            for (const line of t.lines) {
+                for (const m of line.matchAll(re))
+                    out.add(m[0].replace("0.0.0.0", "localhost").replace(/\/$/, ""));
+            }
+        }
+        return [...out].slice(0, 8);
+    }
     killAll() {
         for (const t of this.tasks.values()) {
             if (t.status === "running") {