smolcoder-plus 1.0.0

package/dist/network.js

@@ -0,0 +1,193 @@
+"use strict";
+// The "models on other machines" flows, driven from the model picker in both
+// UIs: search the network, type an address, and manage what was added. Nobody
+// edits a file or runs a command — hosts are saved for them.
+//
+// A machine found by a search is never used until the user picks it: smolcoder
+// sends source code to the server it talks to and runs the tool calls that
+// come back, so choosing a host is choosing to trust it.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundHelp = notFoundHelp;
+exports.findModelsOnNetwork = findModelsOnNetwork;
+exports.manageHosts = manageHosts;
+const config_1 = require("./config");
+const detect_1 = require("./detect");
+const hosts_1 = require("./hosts");
+const netscan_1 = require("./netscan");
+const util_1 = require("./util");
+const BACKEND_NAMES = { ollama: "Ollama", lmstudio: "LM Studio" };
+function describeServers(servers) {
+    return servers.map((s) => `${BACKEND_NAMES[s.backend]} · ${(0, util_1.plural)(s.models, "model")}`).join(" + ");
+}
+/** Why a search or an address can come up empty. Both servers only listen to
+ * their own machine until told otherwise, which is the usual reason. */
+function notFoundHelp(platform = process.platform) {
+    return ("A model server only answers other machines once it is told to. On the machine that runs the models:\n" +
+        "  · Ollama: turn on \"Expose Ollama to the network\" in its settings (Linux or headless: set OLLAMA_HOST=0.0.0.0 and restart it).\n" +
+        "  · LM Studio: Developer tab → Local Server → turn on \"Serve on Local Network\".\n" +
+        "  · Windows: allow the server through the firewall for Private networks when it asks.\n" +
+        (platform === "darwin"
+            ? "On this Mac: System Settings → Privacy & Security → Local Network must allow your terminal app, or nothing on the network is visible.\n"
+            : "") +
+        "Machines on a VPN or another network are not searched — use \"Enter an address\" for those.");
+}
+function save(hosts) {
+    return (0, config_1.updateConfig)({ hosts }).hosts ?? [];
+}
+async function confirmOutsideNetwork(ui, hostname, url) {
+    if (url.startsWith("https://") || (0, hosts_1.isPrivateHost)(hostname))
+        return true;
+    ui.warn(`${hostname} is outside your own network and the connection is plain http: your code and prompts would travel unencrypted.`);
+    return (await ui.select(`Add ${hostname} anyway?`, [{ label: "Cancel" }, { label: "Add it anyway" }])) === 1;
+}
+/** "Enter an address": returns true when a host was added. */
+async function enterAddress(ui, replace) {
+    const typed = await ui.prompt("Address of the machine", "192.168.1.50, gpu-box.local or https://…");
+    if (!typed)
+        return false;
+    let parsed;
+    try {
+        parsed = (0, hosts_1.parseAddress)(typed);
+    }
+    catch (err) {
+        ui.warn(String(err?.message ?? err));
+        return false;
+    }
+    ui.startSpinner(`checking ${parsed.hostname}`);
+    const found = (await Promise.all(parsed.urls.map((u) => (0, detect_1.identifyServer)(u, 4000)))).filter((s) => !!s);
+    ui.stopSpinner();
+    if (!found.length) {
+        ui.warn(`Nothing answered at ${parsed.hostname} as Ollama or LM Studio.`);
+        ui.status(notFoundHelp());
+        return false;
+    }
+    if (!(await confirmOutsideNetwork(ui, parsed.hostname, found[0].baseUrl)))
+        return false;
+    let hosts = (0, config_1.loadConfig)().hosts ?? [];
+    if (replace)
+        hosts = (0, hosts_1.removeHost)(hosts, replace.address);
+    save((0, hosts_1.addHost)(hosts, { address: parsed.address, ...(replace?.name ? { name: replace.name } : {}) }));
+    ui.status(`· added ${replace?.name ?? parsed.hostname} — ${describeServers(found.map((s) => ({ backend: s.backend, models: s.models.length })))}`);
+    return true;
+}
+function savedAddressesOf(found, hosts) {
+    const mine = [found.ip, found.name, ...found.servers.map((s) => s.url)].filter(Boolean).map((s) => String(s).toLowerCase());
+    return hosts.some((h) => mine.includes(h.address.toLowerCase()));
+}
+/** "Search my network": returns true when at least one host was added. */
+async function searchNetwork(ui, subnets, replace) {
+    const range = subnets.map((s) => s.cidr).join(" and ");
+    let lastTenth = -1;
+    ui.startSpinner(`searching ${range}`);
+    const found = await (0, netscan_1.scanSubnets)(subnets, {
+        onProgress: (done, total) => {
+            const tenth = Math.floor((done / total) * 10);
+            if (tenth === lastTenth || tenth >= 10)
+                return;
+            lastTenth = tenth;
+            ui.startSpinner(`searching ${range} · ${tenth * 10}%`);
+        },
+    });
+    ui.stopSpinner();
+    if (!found.length) {
+        ui.warn(`No Ollama or LM Studio found on ${range}.`);
+        ui.status(notFoundHelp());
+        return false;
+    }
+    let added = false;
+    for (;;) {
+        const hosts = (0, config_1.loadConfig)().hosts ?? [];
+        const options = found.map((f) => {
+            const known = savedAddressesOf(f, hosts);
+            return {
+                label: f.name ? `${f.name} (${f.ip})` : f.ip,
+                hint: describeServers(f.servers) + (known ? " · already added" : ""),
+                current: known,
+            };
+        });
+        if (added)
+            options.push({ label: "Done" });
+        const pick = await ui.select(added ? "Add another machine?" : "Found on your network — pick one to use", options);
+        if (pick === null || pick >= found.length)
+            return added;
+        const f = found[pick];
+        if (savedAddressesOf(f, hosts)) {
+            ui.status(`· ${f.name ?? f.ip} is already added`);
+            continue;
+        }
+        // The name survives the router handing out a new IP; fall back to the IP.
+        const base = replace ? (0, hosts_1.removeHost)(hosts, replace.address) : hosts;
+        save((0, hosts_1.addHost)(base, { address: f.name ?? f.ip, ...(replace?.name ? { name: replace.name } : {}) }));
+        ui.status(`· added ${replace?.name ?? f.name ?? f.ip} — ${describeServers(f.servers)}`);
+        added = true;
+        if (replace || found.every((x) => savedAddressesOf(x, (0, config_1.loadConfig)().hosts ?? [])))
+            return true;
+    }
+}
+/** The entry point behind "Find models on my network…". Returns true when the
+ * host list changed, so the caller can look for models again. `replace`
+ * swaps a stale entry for whatever is picked, keeping its name. */
+async function findModelsOnNetwork(ui, replace) {
+    const subnets = (0, netscan_1.localSubnets)();
+    const options = [
+        ...(subnets.length
+            ? [{ label: "Search my network", hint: `${subnets.map((s) => s.cidr).join(", ")} — looks for Ollama and LM Studio` }]
+            : []),
+        { label: "Enter an address", hint: "IP, name or URL — also for VPNs and other networks" },
+    ];
+    if (!subnets.length)
+        ui.status("· this computer is not on a home or office network I can search — you can still enter an address");
+    const pick = await ui.select("Find models on another machine", options);
+    if (pick === null)
+        return false;
+    return options[pick].label === "Search my network" ? searchNetwork(ui, subnets, replace) : enterAddress(ui, replace);
+}
+/** "Network hosts…": see what each added machine serves, rename or remove
+ * it, or look for it again when its address changed. Returns true when the
+ * list changed. */
+async function manageHosts(ui) {
+    let changed = false;
+    for (;;) {
+        const hosts = (0, config_1.loadConfig)().hosts ?? [];
+        if (!hosts.length) {
+            if (!changed)
+                ui.status("· no network hosts added yet");
+            return changed;
+        }
+        ui.startSpinner("checking hosts");
+        const statuses = await (0, detect_1.probeHosts)(hosts);
+        ui.stopSpinner();
+        const pick = await ui.select("Network hosts", statuses.map((s) => ({
+            label: (0, hosts_1.hostLabel)(s.host),
+            hint: (s.host.name ? `${s.host.address} · ` : "") +
+                (s.servers.length ? describeServers(s.servers.map((x) => ({ backend: x.backend, models: x.models.length }))) : "not reachable right now"),
+        })));
+        if (pick === null)
+            return changed;
+        const { host, servers } = statuses[pick];
+        const actions = [
+            { label: "Rename", run: "rename" },
+            { label: "Remove", run: "remove" },
+        ];
+        if (!servers.length)
+            actions.push({ label: "Look for it again", hint: "its address may have changed", run: "refind" });
+        const act = await ui.select((0, hosts_1.hostLabel)(host), actions.map(({ label, hint }) => ({ label, hint })));
+        if (act === null)
+            continue;
+        if (actions[act].run === "rename") {
+            const name = await ui.prompt(`New name for ${(0, hosts_1.hostLabel)(host)}`, (0, hosts_1.hostLabel)(host));
+            if (name) {
+                save((0, hosts_1.renameHost)(hosts, host.address, name));
+                changed = true;
+            }
+        }
+        else if (actions[act].run === "remove") {
+            save((0, hosts_1.removeHost)(hosts, host.address));
+            ui.status(`· removed ${(0, hosts_1.hostLabel)(host)}`);
+            changed = true;
+        }
+        else if (await findModelsOnNetwork(ui, host)) {
+            changed = true;
+        }
+    }
+}

package/dist/plan.js

@@ -0,0 +1,102 @@
+"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. Accept the semicolon lists local models often return
+     * when asked for a newline-separated string. Keep explicit multiline steps
+     * intact, including punctuation or code within a step. */
+    set(stepsText) {
+        const lines = stepsText
+            .split(stepsText.includes("\n") ? "\n" : /;\s*/)
+            .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()}`;
+    }
+    checkpoint(text) {
+        const idx = this.currentIndex;
+        if (idx < 0)
+            return 'Error: create a plan with an unfinished step before recording a checkpoint.';
+        if (!text.trim() || text.length > 1000)
+            return 'Error: checkpoint text must be 1–1000 characters. Keep exact APIs, the unresolved error and the next small edit.';
+        this.steps[idx].note = text.trim();
+        return `Checkpoint saved for step ${idx + 1}: ${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}` +
+            (s.note && i === this.currentIndex ? `\nWorking checkpoint (agent notes; verify against files): ${s.note}` : ""))
+            .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,84 @@
+"use strict";
+// The core system prompt. Short instructions; tool details live in schemas.
+// 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"
+            ? "Read, edit and run commands inside the workspace. Commands reaching outside it need approval; keep scratch files in .scratch/."
+            : "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` +
+        `For multi-step work, first set a short plan of runnable increments; mark each step done as you finish it. The plan survives compaction. Use plan checkpoint to retain exact APIs, errors and your next edit during an investigation. Establish a working entry point early and run the build after wiring modules. ` +
+        `Read relevant files before editing. Search narrowly and read small line ranges. Inspect a local module's actual exports before importing it. Make one tool call at a time; use small modules and write large files in parts. ` +
+        `Read errors and change your approach when a call fails. Put test programs in files rather than long inline shell commands. Verify changes with the relevant test or command; a failed check is not success. ` +
+        `Continue until the request is finished or explain the blocker. Summarize the result and verification briefly.` +
+        (opts.agentsMd
+            ? `\n\nWorkspace instructions from AGENTS.md — follow these:\n${opts.agentsMd}`
+            : ""));
+}