smolcoder 0.4.0

package/dist/plan.js

@@ -0,0 +1,91 @@
+"use strict";
+// The agent's plan: a harness-held checklist. This is deliberately NOT a file
+// and NOT model-formatted text — the harness owns the state, so rendering it
+// to the user costs zero tokens, and compaction can never destroy it. For a
+// small model it works as a compass: every `done` result re-states what comes
+// next, and after compaction the whole checklist is re-injected verbatim.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plan = void 0;
+class Plan {
+    steps = [];
+    get exists() {
+        return this.steps.length > 0;
+    }
+    get doneCount() {
+        return this.steps.filter((s) => s.done).length;
+    }
+    /** Index of the current (first undone) step, or -1 when all done/empty. */
+    get currentIndex() {
+        return this.steps.findIndex((s) => !s.done);
+    }
+    reset() {
+        this.steps = [];
+    }
+    /** Replace the plan. Steps arrive as one newline-separated string — the most
+     * reliable shape for small models (no arrays to mangle). */
+    set(stepsText) {
+        const lines = stepsText
+            .split("\n")
+            .map((l) => l.replace(/^\s*(?:[-*]|\d+[.)])?\s*(?:\[.\]\s*)?/, "").trim())
+            .filter(Boolean)
+            .slice(0, 20);
+        if (lines.length === 0) {
+            return 'Error: steps is required — one step per line. Example: {"action": "set", "steps": "create index.html\\ncreate game.js\\ntest the page"}';
+        }
+        this.steps = lines.map((text) => ({ text, done: false }));
+        return `Plan set (${this.steps.length} steps). Current: 1. ${this.steps[0].text}`;
+    }
+    /** Mark a step done. No index = the current step. Returns a compact
+     * "what's next" line — cheap tokens that keep the model on course. */
+    markDone(stepNumber) {
+        if (!this.exists)
+            return 'Error: no plan yet. Create one first with {"action": "set", "steps": "..."}';
+        let idx;
+        if (stepNumber === undefined || stepNumber === null) {
+            idx = this.currentIndex;
+            if (idx < 0)
+                return "All steps are already done.";
+        }
+        else {
+            idx = Math.floor(stepNumber) - 1;
+            if (idx < 0 || idx >= this.steps.length) {
+                return `Error: step ${stepNumber} does not exist. The plan has ${this.steps.length} steps.`;
+            }
+        }
+        this.steps[idx].done = true;
+        const next = this.currentIndex;
+        return next < 0
+            ? `Done: ${idx + 1}. All ${this.steps.length} steps complete.`
+            : `Done: ${idx + 1}. Next: ${next + 1}. ${this.steps[next].text}`;
+    }
+    add(text) {
+        if (typeof text !== "string" || !text.trim()) {
+            return 'Error: text is required. Example: {"action": "add", "text": "fix the collision bug"}';
+        }
+        if (this.steps.length >= 20)
+            return "Error: the plan already has 20 steps — finish some first.";
+        this.steps.push({ text: text.trim(), done: false });
+        return `Added step ${this.steps.length}: ${text.trim()}`;
+    }
+    /** Compact model-facing checklist (used by action "show" and after compaction). */
+    modelView() {
+        if (!this.exists)
+            return "No plan set.";
+        return this.steps
+            .map((s, i) => `${i + 1}.[${s.done ? "x" : i === this.currentIndex ? ">" : " "}] ${s.text}`)
+            .join("\n");
+    }
+    /** One-line summary for the compaction state note. */
+    compactLine() {
+        if (!this.exists)
+            return null;
+        return `Plan (${this.doneCount}/${this.steps.length} done):\n${this.modelView()}`;
+    }
+    pendingSummary() {
+        return this.steps
+            .filter((s) => !s.done)
+            .map((s) => s.text)
+            .join("; ");
+    }
+}
+exports.Plan = Plan;

package/dist/prompt.js

@@ -0,0 +1,85 @@
+"use strict";
+// The whole system prompt. Two short paragraphs, ~120 tokens. Everything else
+// the model needs lives in the tool schemas and in coaching error messages.
+// If the workspace has an AGENTS.md, its contents ride along directly after
+// the prompt (size-capped) — and because they are part of message[0], they
+// survive compaction the same way the system prompt does.
+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.loadAgentsMd = loadAgentsMd;
+exports.buildSystemPrompt = buildSystemPrompt;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AGENTS_MD_CAP_CHARS = 8000; // ~2k tokens — small-context friendly
+/** Read the workspace's AGENTS.md memory file, if any. */
+function loadAgentsMd(workspace) {
+    try {
+        const p = path.join(workspace, "AGENTS.md");
+        if (!fs.existsSync(p))
+            return null;
+        let text = fs.readFileSync(p, "utf8").trim();
+        if (!text)
+            return null;
+        if (text.length > AGENTS_MD_CAP_CHARS) {
+            text =
+                text.slice(0, AGENTS_MD_CAP_CHARS) +
+                    "\n[AGENTS.md was truncated here to save context]";
+        }
+        return text;
+    }
+    catch {
+        return null;
+    }
+}
+function buildSystemPrompt(opts) {
+    const os = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+    const modeLine = opts.mode === "ro"
+        ? "You are in read-only mode: you can read and search files but not change anything."
+        : opts.mode === "edit"
+            ? "You can read, write and edit files freely and run commands (install packages, run tests, scripts) without asking, as long as everything stays inside the workspace. A command that touches paths outside it (absolute paths, /tmp, ~, ..) asks the user for approval first — so keep scratch files inside the workspace, e.g. in a .scratch/ folder."
+            : "You have full access to files and commands; nothing asks the user for approval.";
+    return (`You are smolcoder, a coding agent working in the workspace ${opts.workspace} on ${os}. ` +
+        `Commands run in ${opts.shellLabel} with the workspace as the working directory. ` +
+        `File paths are relative to the workspace; you cannot access files outside it. ${modeLine}\n\n` +
+        `Work step by step: look at the relevant files before changing them, make one tool call at a time, ` +
+        `keep changes small and focused, and verify your work when you can. ` +
+        `For any task with more than one step, FIRST call the plan tool ({"action": "set"}) with your step list. ` +
+        `The moment a step is finished, call plan {"action": "done"} BEFORE starting the next one — the plan is your map of the task and is kept for you even when older context is dropped. ` +
+        `If a tool returns an error, read it carefully — it tells you how to fix the call. ` +
+        `When the task is done, stop and summarize briefly what you did.` +
+        (opts.agentsMd
+            ? `\n\nWorkspace instructions from AGENTS.md — follow these:\n${opts.agentsMd}`
+            : ""));
+}

package/dist/providers/lmstudio.js

@@ -0,0 +1,326 @@
+"use strict";
+// LM Studio adapter — standard OpenAI-compatible /v1/chat/completions with SSE
+// streaming. The context window is whatever LM Studio loaded the model with;
+// we detect it and budget within it (we cannot change it per request).
+//
+// Reasoning is the part that decides whether LM Studio feels fast or slow.
+// LM Studio's API accepts reasoning_effort none|minimal|low|medium|high|xhigh,
+// but each MODEL only supports a subset (read from /api/v1/models). A value
+// the model does not support is silently replaced by the model's DEFAULT —
+// which for current qwen3.x builds is "xhigh", the maximum. That is how a
+// harness asking for "high" ends up with 8,000-token thinking bursts per tool
+// call. So: "off" is sent as "none" (measured: fully disables thinking), and
+// every other level is snapped to the nearest level the model really has.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmStudioProvider = void 0;
+exports.mapEffort = mapEffort;
+const types_1 = require("./types");
+function toWire(messages) {
+    return messages.map((m) => {
+        if (m.role === "assistant" && m.toolCalls?.length) {
+            return {
+                role: "assistant",
+                content: m.content || null,
+                tool_calls: m.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+                })),
+            };
+        }
+        if (m.role === "tool") {
+            return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+        }
+        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 },
+    }));
+}
+/** Exported for tests. Map a smolcoder effort onto LM Studio's wire value,
+ * respecting what the model supports. Returns undefined for "leave it to the
+ * backend". */
+function mapEffort(effort, info) {
+    if (effort === null)
+        return undefined;
+    if (effort === "off")
+        return "none";
+    const wireLevels = ["low", "medium", "high", "xhigh"];
+    if (!info || info.allowed.length === 0)
+        return effort;
+    // Model-supported levels that the API also accepts (the model list uses
+    // "off"/"on" too; those are not valid wire values).
+    const candidates = wireLevels.filter((l) => info.allowed.includes(l));
+    if (candidates.length === 0)
+        return effort;
+    if (candidates.includes(effort))
+        return effort;
+    const want = types_1.EFFORT_RANK[effort];
+    let best = candidates[0];
+    let bestDist = Infinity;
+    for (const cnd of candidates) {
+        const d = Math.abs(types_1.EFFORT_RANK[cnd] - want);
+        // Ties go to the LOWER level: on a local model the cheaper step wins.
+        if (d < bestDist || (d === bestDist && types_1.EFFORT_RANK[cnd] < types_1.EFFORT_RANK[best])) {
+            best = cnd;
+            bestDist = d;
+        }
+    }
+    return best;
+}
+class LmStudioProvider {
+    baseUrl;
+    modelId;
+    contextWindow;
+    reasoning;
+    label;
+    maxOutputTokens;
+    effort = null;
+    effortUnsupported = false;
+    constructor(baseUrl, modelId, contextWindow, maxOutputTokens = types_1.MAX_OUTPUT_TOKENS, reasoning) {
+        this.baseUrl = baseUrl;
+        this.modelId = modelId;
+        this.contextWindow = contextWindow;
+        this.reasoning = reasoning;
+        this.label = `lmstudio · ${modelId}`;
+        this.maxOutputTokens = maxOutputTokens;
+    }
+    setEffort(effort) {
+        this.effort = effort;
+        this.effortUnsupported = false;
+    }
+    effortLabel() {
+        if (this.effortUnsupported)
+            return this.effort ? `${this.effort} (ignored by this server)` : null;
+        if (this.effort === null) {
+            return this.reasoning?.default ? `default → ${this.reasoning.default}` : null;
+        }
+        const wire = mapEffort(this.effort, this.reasoning);
+        if (wire && wire !== this.effort && wire !== "none")
+            return `${this.effort} → ${wire}`;
+        return null;
+    }
+    async chat(messages, tools, opts = {}) {
+        const effort = opts.effortOverride ?? this.effort;
+        let wireMessages = messages;
+        const base = {
+            model: this.modelId,
+            messages: toWire(wireMessages),
+            tools: tools.length ? toWireTools(tools) : undefined,
+            max_tokens: opts.maxTokens ?? this.maxOutputTokens,
+        };
+        const wireEffort = mapEffort(effort, this.reasoning);
+        if (wireEffort && !this.effortUnsupported) {
+            base.reasoning_effort = wireEffort;
+        }
+        else if (effort === "off" && /qwen/i.test(this.modelId)) {
+            // Older LM Studio builds without reasoning_effort: fall back to the
+            // qwen per-turn /no_think soft switch (older qwen3 models honor it).
+            wireMessages = messages.map((m) => ({ ...m }));
+            for (let i = wireMessages.length - 1; i >= 0; i--) {
+                if (wireMessages[i].role === "user") {
+                    wireMessages[i].content = wireMessages[i].content + " /no_think";
+                    break;
+                }
+            }
+            base.messages = toWire(wireMessages);
+        }
+        const started = { streaming: false };
+        try {
+            return await this.chain(base, opts, started);
+        }
+        catch (err) {
+            if (err?.name === "AbortError")
+                throw err;
+            if (started.streaming)
+                throw err; // tokens already shown — don't re-emit
+            const msg = String(err?.message ?? "");
+            // Only latch effortUnsupported on an actual param rejection (4xx naming
+            // it), never on a transient 5xx / dropped socket.
+            if (base.reasoning_effort && /returned 4\d\d/.test(msg) && /reasoning|effort/i.test(msg)) {
+                this.effortUnsupported = true;
+                delete base.reasoning_effort;
+                return await this.chain(base, opts, started);
+            }
+            throw err;
+        }
+    }
+    async chain(base, opts, started) {
+        try {
+            return await this.request({ ...base, stream: true, stream_options: { include_usage: true } }, opts, started);
+        }
+        catch (err) {
+            if (err?.name === "AbortError")
+                throw err;
+            if (started.streaming)
+                throw err;
+            const msg = String(err?.message ?? "");
+            // Only degrade the request shape on a pre-stream HTTP rejection; a
+            // transient error must propagate to chatWithRetry for backoff.
+            if (!/returned 4\d\d/.test(msg))
+                throw err;
+            // A reasoning_effort rejection must reach chat()'s handler, not be
+            // masked by the stream-shape fallback ladder.
+            if (/reasoning|effort/i.test(msg))
+                throw err;
+            try {
+                return await this.request({ ...base, stream: true }, opts, started);
+            }
+            catch (err2) {
+                if (err2?.name === "AbortError" || started.streaming)
+                    throw err2;
+                if (!/returned 4\d\d/.test(String(err2?.message ?? "")))
+                    throw err2;
+                return await this.request({ ...base, stream: false }, opts, started);
+            }
+        }
+    }
+    async request(body, opts, started) {
+        const t0 = Date.now();
+        const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            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(`LM Studio returned ${res.status}: ${text.slice(0, 300)}`);
+        }
+        if (body.stream === false) {
+            const data = await res.json();
+            const msg = data.choices?.[0]?.message ?? {};
+            const toolCalls = (msg.tool_calls ?? []).map((tc) => ({
+                id: tc.id || (0, types_1.nextCallId)(),
+                name: tc.function?.name ?? "",
+                ...(0, types_1.parseArgs)(tc.function?.arguments),
+            }));
+            if (started)
+                started.streaming = true;
+            if (msg.content)
+                opts.onToken?.(msg.content);
+            const content = msg.content ?? "";
+            const total = Date.now() - t0;
+            return {
+                content,
+                toolCalls,
+                promptTokens: data.usage?.prompt_tokens,
+                completionTokens: (0, types_1.estimateReplayTokens)(content, toolCalls),
+                generatedTokens: data.usage?.completion_tokens,
+                genTokPerSec: data.usage?.completion_tokens ? data.usage.completion_tokens / (total / 1000) : undefined,
+                truncated: data.choices?.[0]?.finish_reason === "length",
+            };
+        }
+        // SSE stream.
+        let content = "";
+        let thinking = "";
+        const partials = new Map();
+        let promptTokens;
+        let completionTokens;
+        let truncated = false;
+        let firstTokAt = 0;
+        let lastTokAt = 0;
+        const handleLine = (rawLine) => {
+            const line = rawLine.trim();
+            if (!line.startsWith("data:"))
+                return;
+            const payload = line.slice(5).trim();
+            if (payload === "[DONE]")
+                return;
+            let chunk;
+            try {
+                chunk = JSON.parse(payload);
+            }
+            catch {
+                return;
+            }
+            if (started)
+                started.streaming = true; // committed — no safe re-request now
+            if (chunk.usage) {
+                promptTokens = chunk.usage.prompt_tokens ?? promptTokens;
+                completionTokens = chunk.usage.completion_tokens ?? completionTokens;
+            }
+            if (chunk.choices?.[0]?.finish_reason === "length")
+                truncated = true;
+            const delta = chunk.choices?.[0]?.delta;
+            if (!delta)
+                return;
+            const reasoning = delta.reasoning_content ?? delta.reasoning;
+            let sawToken = false;
+            if (typeof reasoning === "string" && reasoning) {
+                thinking += reasoning;
+                opts.onThinking?.(reasoning);
+                sawToken = true;
+            }
+            if (delta.content) {
+                content += delta.content;
+                opts.onToken?.(delta.content);
+                sawToken = true;
+            }
+            if (Array.isArray(delta.tool_calls)) {
+                sawToken = true;
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    const p = partials.get(idx) ?? { id: "", name: "", args: "" };
+                    if (tc.id)
+                        p.id = tc.id;
+                    if (tc.function?.name)
+                        p.name += tc.function.name;
+                    if (tc.function?.arguments)
+                        p.args += tc.function.arguments;
+                    partials.set(idx, p);
+                }
+            }
+            if (sawToken) {
+                const now = Date.now();
+                if (!firstTokAt)
+                    firstTokAt = now;
+                lastTokAt = now;
+            }
+        };
+        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);
+                buffer = buffer.slice(nl + 1);
+                handleLine(line);
+            }
+        }
+        // Flush a final line with no trailing newline (may carry usage /
+        // finish_reason:"length" — losing it silently drops the anchor / truncation).
+        if (buffer.trim())
+            handleLine(buffer);
+        const toolCalls = [...partials.entries()]
+            .sort((a, b) => a[0] - b[0])
+            .map(([, p]) => ({
+            id: p.id || (0, types_1.nextCallId)(),
+            name: p.name,
+            ...(0, types_1.parseArgs)(p.args),
+        }));
+        const genMs = lastTokAt > firstTokAt ? lastTokAt - firstTokAt : 0;
+        return {
+            content,
+            toolCalls,
+            thinking: thinking || undefined,
+            promptTokens,
+            // LM Studio does not replay reasoning into the next prompt, so only the
+            // visible reply and tool-call JSON count toward the next request.
+            completionTokens: (0, types_1.estimateReplayTokens)(content, toolCalls),
+            generatedTokens: completionTokens,
+            genTokPerSec: completionTokens && genMs > 0 ? completionTokens / (genMs / 1000) : undefined,
+            ttftMs: firstTokAt ? firstTokAt - t0 : undefined,
+            truncated,
+        };
+    }
+}
+exports.LmStudioProvider = LmStudioProvider;