smolcoder 0.4.0

package/dist/providers/ollama.js

@@ -0,0 +1,264 @@
+"use strict";
+// Ollama adapter — uses the NATIVE /api/chat endpoint, not the OpenAI-compat
+// one, because only the native API lets us set num_ctx per request, pass
+// thinking traces back, and read real timings (prompt/eval durations).
+//
+// Prompt-size savings that matter on a long tool loop with a thinking model:
+// reasoning traces from assistant messages BEFORE the current user turn are
+// not sent back (the qwen3-family templates drop them anyway); only the
+// current turn's traces travel, which is what tool-call loops need.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+exports.toWire = toWire;
+const types_1 = require("./types");
+/** Exported for tests. */
+function toWire(messages) {
+    const keepThinkingFrom = (0, types_1.lastUserIndex)(messages);
+    return messages.map((m, i) => {
+        if (m.role === "assistant" && m.toolCalls?.length) {
+            return {
+                role: "assistant",
+                content: m.content ?? "",
+                ...(m.thinking && i > keepThinkingFrom ? { thinking: m.thinking } : {}),
+                tool_calls: m.toolCalls.map((tc) => ({
+                    function: { name: tc.name, arguments: tc.args },
+                })),
+            };
+        }
+        if (m.role === "tool") {
+            return { role: "tool", content: m.content, tool_name: m.toolName };
+        }
+        return { role: m.role, content: m.content };
+    });
+}
+function toWireTools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+    }));
+}
+/** Keep the model resident between tool calls and while the user reads or
+ * approves. Ollama's own default (5 min) unloads mid-session on any longer
+ * pause, and a reload of a 17 GB model costs 10-20 s plus a cold cache. */
+const KEEP_ALIVE = process.env.SMOLCODER_KEEP_ALIVE || "30m";
+class OllamaProvider {
+    baseUrl;
+    modelId;
+    contextWindow;
+    numCtx;
+    label;
+    maxOutputTokens;
+    effort = null;
+    thinkUnsupported = false;
+    /** null = unknown, tried lazily; false = this model only takes a boolean. */
+    levelsSupported = null;
+    constructor(baseUrl, modelId, contextWindow, 
+    /** Explicit num_ctx to send; undefined = respect the server's configured context. */
+    numCtx, maxOutputTokens = types_1.MAX_OUTPUT_TOKENS) {
+        this.baseUrl = baseUrl;
+        this.modelId = modelId;
+        this.contextWindow = contextWindow;
+        this.numCtx = numCtx;
+        this.label = `ollama · ${modelId}`;
+        this.maxOutputTokens = maxOutputTokens;
+        // Only gpt-oss is documented to take levels; everything else gets a
+        // boolean straight away instead of a wasted probe request.
+        if (!/gpt-oss/i.test(modelId))
+            this.levelsSupported = false;
+    }
+    setEffort(effort) {
+        this.effort = effort;
+        this.thinkUnsupported = false;
+    }
+    effortLabel() {
+        if (this.effort === null || this.effort === "off")
+            return null;
+        if (this.thinkUnsupported)
+            return `${this.effort} (model has no thinking switch)`;
+        if (this.levelsSupported === false)
+            return `${this.effort} → thinking on`;
+        return null;
+    }
+    /** Ollama's think param: boolean for most reasoning models; gpt-oss accepts levels. */
+    thinkParam(effort) {
+        if (effort === null || this.thinkUnsupported)
+            return undefined;
+        if (effort === "off")
+            return false;
+        return this.levelsSupported === false ? true : effort;
+    }
+    async chat(messages, tools, opts = {}) {
+        const effort = opts.effortOverride ?? this.effort;
+        const makeBody = (stream, think) => ({
+            model: this.modelId,
+            messages: toWire(messages),
+            tools: tools.length ? toWireTools(tools) : undefined,
+            stream,
+            keep_alive: KEEP_ALIVE,
+            ...(think !== undefined ? { think } : {}),
+            options: {
+                ...(this.numCtx ? { num_ctx: this.numCtx } : {}),
+                num_predict: opts.maxTokens ?? this.maxOutputTokens,
+            },
+        });
+        let think = this.thinkParam(effort);
+        const started = { streaming: false };
+        try {
+            return await this.request(makeBody(true, think), opts, started);
+        }
+        catch (err) {
+            if (err?.name === "AbortError")
+                throw err;
+            // Never re-request after tokens were already streamed to the UI — that
+            // double-emits. Let agent.ts's chatWithRetry handle mid-stream failures.
+            if (started.streaming)
+                throw err;
+            const msg = String(err?.message ?? "");
+            const paramRejected = /returned 4\d\d/.test(msg) && /think/i.test(msg);
+            // Only treat the think param as unsupported on an actual param rejection;
+            // a transient 5xx/network error must NOT permanently disable reasoning.
+            if (think !== undefined && paramRejected) {
+                if (typeof think === "string") {
+                    // Levels rejected — this model takes a boolean. Same intent: on.
+                    this.levelsSupported = false;
+                    think = true;
+                    try {
+                        return await this.request(makeBody(true, think), opts, started);
+                    }
+                    catch (err2) {
+                        if (err2?.name === "AbortError" || started.streaming)
+                            throw err2;
+                        const msg2 = String(err2?.message ?? "");
+                        if (!(/returned 4\d\d/.test(msg2) && /think/i.test(msg2)))
+                            throw err2;
+                    }
+                }
+                this.thinkUnsupported = true;
+                think = undefined;
+                return await this.request(makeBody(true, undefined), opts, started);
+            }
+            // Older Ollama versions reject stream+tools together; retry non-streaming
+            // once, but only for a pre-stream rejection (not a transient error).
+            if (/returned 4\d\d/.test(msg)) {
+                return await this.request(makeBody(false, think), opts, started);
+            }
+            throw err;
+        }
+    }
+    async request(body, opts, started) {
+        const t0 = Date.now();
+        const res = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            signal: opts.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Ollama returned ${res.status}: ${text.slice(0, 300)}`);
+        }
+        let content = "";
+        let thinking = "";
+        const toolCalls = [];
+        let promptTokens;
+        let completionTokens;
+        let promptTokPerSec;
+        let genTokPerSec;
+        let truncated = false;
+        let firstTokAt = 0;
+        const handleChunk = (chunk) => {
+            if (started)
+                started.streaming = true; // committed — no safe re-request now
+            const msg = chunk.message;
+            if (msg?.thinking) {
+                thinking += msg.thinking;
+                opts.onThinking?.(msg.thinking);
+                if (!firstTokAt)
+                    firstTokAt = Date.now();
+            }
+            if (msg?.content) {
+                content += msg.content;
+                opts.onToken?.(msg.content);
+                if (!firstTokAt)
+                    firstTokAt = Date.now();
+            }
+            if (Array.isArray(msg?.tool_calls)) {
+                if (!firstTokAt)
+                    firstTokAt = Date.now();
+                for (const tc of msg.tool_calls) {
+                    const fn = tc.function ?? {};
+                    toolCalls.push({
+                        id: (0, types_1.nextCallId)(),
+                        name: fn.name ?? "",
+                        ...(0, types_1.parseArgs)(fn.arguments),
+                    });
+                }
+            }
+            if (chunk.done) {
+                if (typeof chunk.prompt_eval_count === "number")
+                    promptTokens = chunk.prompt_eval_count;
+                if (typeof chunk.eval_count === "number")
+                    completionTokens = chunk.eval_count;
+                if (typeof chunk.prompt_eval_duration === "number" && chunk.prompt_eval_duration > 0 && promptTokens) {
+                    promptTokPerSec = promptTokens / (chunk.prompt_eval_duration / 1e9);
+                }
+                if (typeof chunk.eval_duration === "number" && chunk.eval_duration > 0 && completionTokens) {
+                    genTokPerSec = completionTokens / (chunk.eval_duration / 1e9);
+                }
+                if (chunk.done_reason === "length")
+                    truncated = true;
+            }
+        };
+        if (body.stream === false) {
+            handleChunk(await res.json());
+        }
+        else {
+            // NDJSON stream: one JSON object per line.
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let nl;
+                while ((nl = buffer.indexOf("\n")) >= 0) {
+                    const line = buffer.slice(0, nl).trim();
+                    buffer = buffer.slice(nl + 1);
+                    if (!line)
+                        continue;
+                    try {
+                        handleChunk(JSON.parse(line));
+                    }
+                    catch {
+                        /* partial/garbled line — skip */
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                try {
+                    handleChunk(JSON.parse(buffer.trim()));
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        return {
+            content,
+            toolCalls,
+            thinking: thinking || undefined,
+            promptTokens,
+            // Ollama replays this turn's thinking into the next prompt, so the full
+            // eval count is what the next request carries.
+            completionTokens,
+            generatedTokens: completionTokens,
+            promptTokPerSec,
+            genTokPerSec,
+            ttftMs: firstTokAt ? firstTokAt - t0 : undefined,
+            truncated,
+        };
+    }
+}
+exports.OllamaProvider = OllamaProvider;

package/dist/providers/types.js

@@ -0,0 +1,60 @@
+"use strict";
+// One internal message/tool shape; each provider adapts it to its wire format.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_OUTPUT_TOKENS = exports.EFFORT_RANK = void 0;
+exports.nextCallId = nextCallId;
+exports.parseArgs = parseArgs;
+exports.estimateReplayTokens = estimateReplayTokens;
+exports.lastUserIndex = lastUserIndex;
+/** Rank of every reasoning level any backend knows about, used to map a
+ * requested effort onto whatever a specific model actually supports. */
+exports.EFFORT_RANK = {
+    none: 0,
+    off: 0,
+    minimal: 1,
+    low: 2,
+    medium: 3,
+    high: 4,
+    xhigh: 5,
+    on: 3,
+};
+exports.MAX_OUTPUT_TOKENS = 2048;
+let callCounter = 0;
+function nextCallId() {
+    return `call_${++callCounter}`;
+}
+function parseArgs(raw) {
+    if (raw && typeof raw === "object")
+        return { args: raw };
+    if (typeof raw === "string") {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object")
+                return { args: parsed, rawArgs: raw };
+            return { args: {}, rawArgs: raw, parseError: "arguments were not a JSON object" };
+        }
+        catch (e) {
+            return { args: {}, rawArgs: raw, parseError: `invalid JSON: ${e.message}` };
+        }
+    }
+    return { args: {} };
+}
+/** Tokens the visible reply + tool-call JSON will occupy when replayed in the
+ * next prompt (~4 chars/token, corrected by real usage on the next response). */
+function estimateReplayTokens(content, toolCalls) {
+    let chars = (content ?? "").length;
+    for (const tc of toolCalls)
+        chars += tc.name.length + (tc.rawArgs ?? JSON.stringify(tc.args)).length + 12;
+    return Math.ceil(chars / 4);
+}
+/** Index of the most recent plain user message (the current turn's start).
+ * Reasoning traces from assistant messages BEFORE it are dropped from the
+ * wire — that is what the Qwen3-family chat templates do themselves, and it
+ * is the biggest single saving on a long tool loop with a thinking model. */
+function lastUserIndex(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user" && !messages[i].compactNote)
+            return i;
+    }
+    return -1;
+}

package/dist/sandbox.js

@@ -0,0 +1,179 @@
+"use strict";
+// Workspace containment for file tools. Every path a tool touches must resolve
+// inside the workspace root — including through symlinks, which is why we
+// realpath the deepest EXISTING ancestor before comparing.
+//
+// Commands (run_command / task) cannot be contained this way. Edit mode scans
+// the command text instead (commandEscapesWorkspace, below) and asks the user
+// only when something reaches outside; bypass mode never asks.
+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.SandboxError = void 0;
+exports.resolveInWorkspace = resolveInWorkspace;
+exports.relPath = relPath;
+exports.commandEscapesWorkspace = commandEscapesWorkspace;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class SandboxError extends Error {
+}
+exports.SandboxError = SandboxError;
+const isWin = process.platform === "win32";
+function normalizeForCompare(p) {
+    return isWin ? p.toLowerCase() : p;
+}
+function resolveInWorkspace(root, userPath) {
+    if (typeof userPath !== "string" || userPath.trim() === "") {
+        throw new SandboxError("path is required (relative to the workspace, e.g. \"src/app.js\").");
+    }
+    const abs = path.resolve(root, userPath);
+    // realpath the deepest existing ancestor to defeat symlink escapes
+    let existing = abs;
+    while (!fs.existsSync(existing)) {
+        const parent = path.dirname(existing);
+        if (parent === existing)
+            break;
+        existing = parent;
+    }
+    let realExisting;
+    let realRoot;
+    try {
+        realExisting = fs.realpathSync(existing);
+        realRoot = fs.realpathSync(root);
+    }
+    catch {
+        throw new SandboxError(`cannot resolve path "${userPath}".`);
+    }
+    const rel = path.relative(normalizeForCompare(realRoot), normalizeForCompare(realExisting));
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new SandboxError(`"${userPath}" is outside the workspace. Only files inside ${root} can be accessed. Use a relative path like "src/app.js".`);
+    }
+    return abs;
+}
+function relPath(root, abs) {
+    return path.relative(root, abs).split(path.sep).join("/") || ".";
+}
+// ---------------------------------------------------------------------------
+// Command containment (edit mode). A shell command cannot be sandboxed the way
+// a file path can, so this is a best-effort scan of the command text for
+// anything that reaches outside the workspace: absolute paths that resolve
+// elsewhere, `..` climbing past the root, home-directory shortcuts, temp-dir
+// variables, and package-manager global installs. A clean in-tree command
+// (`npm install`, `node script.mjs`, `a && b`) runs without asking; a flagged
+// one goes to the y/n prompt with the reason shown. False positives cost one
+// prompt, false negatives are the accepted limit of a text scan.
+const HOME_TOKENS = /^(~|\$HOME|\$\{HOME\}|%USERPROFILE%|%HOMEPATH%)([\\/]|$)/i;
+const TEMP_TOKENS = /^(\$TMPDIR|\$\{TMPDIR\}|\$TEMP|\$TMP|%TEMP%|%TMP%|\$\{TEMP\}|\$\{TMP\})([\\/]|$)/i;
+const GLOBAL_INSTALL = /\b(npm|pnpm|yarn|bun)\b[^;&|]*\s(-g|--global|global)(\s|$)/;
+/** MSYS roots Git Bash maps to real places; any other one-segment `/word` on
+ * Windows is a command switch (`taskkill /pid`, `dir /s`), not a path. */
+const MSYS_ROOTS = /^\/(tmp|usr|etc|bin|home|mnt|dev|proc|var|opt|root)(\/|$)/i;
+/** Split a command into candidate path tokens: whitespace-separated words with
+ * quotes stripped, the value side of `--flag=value` and `VAR=value`, and the
+ * target of `>`/`<` redirections written without a space. */
+function pathCandidates(command) {
+    const out = [];
+    for (const raw of command.split(/\s+/)) {
+        if (!raw)
+            continue;
+        let tok = raw.replace(/^[<>]+|^[\d]?[<>]+&?/, "").replace(/^["'`]+|["'`,;)]+$/g, "");
+        if (!tok)
+            continue;
+        if (/^[a-z][a-z0-9+.-]*:\/\//i.test(tok))
+            continue; // URLs
+        const eq = tok.indexOf("=");
+        if (eq > 0 && /^[-\w.]+$/.test(tok.slice(0, eq)))
+            tok = tok.slice(eq + 1);
+        if (tok)
+            out.push(tok);
+    }
+    return out;
+}
+/** Git Bash writes C:\x as /c/x; map that back so it compares like a Windows
+ * path. A bare `/f` with nothing after it is left alone — that is a command
+ * switch far more often than the root of drive F:. */
+function fromMsys(tok) {
+    const m = /^\/([a-zA-Z])(\/.*)$/.exec(tok);
+    if (m && isWin)
+        return `${m[1].toUpperCase()}:${m[2].replace(/\//g, "\\")}`;
+    return tok;
+}
+function isAbsoluteLike(tok) {
+    if (/^[a-zA-Z]:[\\/]/.test(tok))
+        return true; // C:\ or C:/
+    if (/^\\\\/.test(tok))
+        return true; // UNC
+    return tok.startsWith("/");
+}
+function insideWorkspace(root, abs) {
+    let realRoot = root;
+    try {
+        realRoot = fs.realpathSync(root);
+    }
+    catch {
+        /* compare against the given root */
+    }
+    const rel = path.relative(normalizeForCompare(realRoot), normalizeForCompare(path.resolve(abs)));
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+/**
+ * Why a command would reach outside the workspace, or null when every path it
+ * mentions stays inside it. Only the reason text is returned; the caller
+ * decides whether that means "ask" or "refuse".
+ */
+function commandEscapesWorkspace(command, root) {
+    if (GLOBAL_INSTALL.test(command))
+        return "installs a package globally, outside the workspace";
+    for (const tok of pathCandidates(command)) {
+        if (HOME_TOKENS.test(tok))
+            return `uses the home directory (${tok})`;
+        if (TEMP_TOKENS.test(tok))
+            return `uses the system temp directory (${tok})`;
+        const t = fromMsys(tok);
+        if (isAbsoluteLike(t)) {
+            // On Windows under Git Bash, a bare POSIX path like /tmp or /usr/bin is
+            // an MSYS path — never inside a Windows workspace.
+            const posixOnWin = isWin && t.startsWith("/");
+            if (posixOnWin && !MSYS_ROOTS.test(t))
+                continue; // a /switch, not a path
+            if (posixOnWin || !insideWorkspace(root, t))
+                return `reaches outside the workspace (${tok})`;
+            continue;
+        }
+        if (/(^|[\\/])\.\.([\\/]|$)/.test(t) && !insideWorkspace(root, path.resolve(root, t))) {
+            return `climbs above the workspace (${tok})`;
+        }
+    }
+    return null;
+}