smolcoder-plus 1.0.0

package/dist/tools/web-search.js

@@ -0,0 +1,155 @@
+"use strict";
+// web_search tool: Brave Search API integration for the agent.
+// Port of scripts/search.js (loadDotEnv + fetchWithTimeout + searchBrave + formatting)
+// into TypeScript so every new project gets internet search without copying files.
+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.DEFAULT_MAX_RESULTS = void 0;
+exports.truncate = truncate;
+exports.formatWebSearchResults = formatWebSearchResults;
+exports.searchBrave = searchBrave;
+exports.webSearch = webSearch;
+const MAX_OUTPUT_CHARS = 3000;
+exports.DEFAULT_MAX_RESULTS = 5;
+const FETCH_TIMEOUT_MS = 10000;
+/** Load KEY=VALUE pairs from a .env file in the current working directory or any parent
+ * directory into process.env, without any npm dependency. Real, already-exported env vars always
+ * win — this only fills in values that aren't set yet (matches scripts/search.js). */
+async function loadDotEnv() {
+    try {
+        const { readFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
+        const { join, dirname } = await Promise.resolve().then(() => __importStar(require("node:path")));
+        let currentDir = process.cwd();
+        let envLoaded = false;
+        while (currentDir !== dirname(currentDir) && !envLoaded) {
+            const envPath = join(currentDir, ".env");
+            try {
+                if (readFileSync(envPath, "utf8")) {
+                    const content = readFileSync(envPath, "utf8");
+                    for (const rawLine of content.split("\n")) {
+                        const line = rawLine.trim();
+                        if (!line || line.startsWith("#"))
+                            continue;
+                        const eq = line.indexOf("=");
+                        if (eq === -1)
+                            continue;
+                        const key = line.slice(0, eq).trim();
+                        let value = line.slice(eq + 1).trim();
+                        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                            value = value.slice(1, -1);
+                        }
+                        if (!(key in process.env))
+                            process.env[key] = value;
+                    }
+                    envLoaded = true;
+                }
+            }
+            catch {
+                // File not found or unreadable, move up
+            }
+            currentDir = dirname(currentDir);
+        }
+    }
+    catch {
+        // General failure — fine, just rely on real env vars.
+    }
+}
+/** fetch with a hard timeout; returns null on any failure. */
+async function fetchWithTimeout(url, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Truncate at the end (with a short tail note) — used for search output. */
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    // Calculate how much to cut so that the note is exactly part of the total length
+    const note = "\n... (truncated)";
+    const cutOff = max - note.length;
+    return text.slice(0, cutOff) + note;
+}
+/** Format raw Brave results into numbered titles, snippets and URLs. */
+function formatWebSearchResults(results) {
+    if (results.length === 0) {
+        return "No results found. (backend: Brave Search)";
+    }
+    const lines = results.map((r, i) => {
+        const title = (r.title || "(no title)").trim();
+        const snippet = (r.snippet || "").trim().replace(/\s+/g, " ");
+        const url = (r.url || "").trim();
+        return `${i + 1}. ${title}\n   ${snippet}\n   ${url}`;
+    });
+    return `Search results (backend: Brave Search)\n\n${lines.join("\n\n")}`;
+}
+/** Call the Brave Search API and return up to maxResults items. */
+async function searchBrave(query, maxResults) {
+    const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`;
+    const res = await fetchWithTimeout(url, {
+        headers: {
+            Accept: "application/json",
+            "X-Subscription-Token": process.env.BRAVE_API_KEY,
+        },
+    });
+    if (!res)
+        throw new Error("Network request failed.");
+    if (!res.ok)
+        throw new Error(`Brave API error: ${res.status} ${res.statusText}`);
+    const data = (await res.json());
+    const items = (data.web && data.web.results) || [];
+    return items.slice(0, maxResults).map((r) => ({
+        title: r.title,
+        snippet: r.description,
+        url: r.url,
+    }));
+}
+/** Main entry point used by the tool registry. Returns a formatted string. */
+function webSearch(query, maxResults) {
+    const limit = Math.max(1, Math.min(8, maxResults ?? exports.DEFAULT_MAX_RESULTS));
+    return loadDotEnv()
+        .then(() => {
+        if (!process.env.BRAVE_API_KEY) {
+            return "Error: Missing BRAVE_API_KEY environment variable.";
+        }
+        return searchBrave(query, limit)
+            .then((results) => truncate(formatWebSearchResults(results), MAX_OUTPUT_CHARS))
+            .catch((e) => `Error: ${e.message}`);
+    });
+}

package/dist/tui/editor.js

@@ -0,0 +1,134 @@
+"use strict";
+// Line editor state: a buffer + cursor index, with logical-line navigation
+// for multi-line input, and a wrap-aware layout used by the renderer.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineEditor = void 0;
+exports.layoutBuffer = layoutBuffer;
+class LineEditor {
+    buffer = "";
+    cursor = 0;
+    insert(text) {
+        this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
+        this.cursor += text.length;
+    }
+    backspace() {
+        if (this.cursor === 0)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        this.cursor--;
+    }
+    del() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+    }
+    left() {
+        if (this.cursor > 0)
+            this.cursor--;
+    }
+    right() {
+        if (this.cursor < this.buffer.length)
+            this.cursor++;
+    }
+    lineStartIdx() {
+        return this.buffer.lastIndexOf("\n", this.cursor - 1) + 1;
+    }
+    lineEndIdx() {
+        const nl = this.buffer.indexOf("\n", this.cursor);
+        return nl < 0 ? this.buffer.length : nl;
+    }
+    home() {
+        this.cursor = this.lineStartIdx();
+    }
+    end() {
+        this.cursor = this.lineEndIdx();
+    }
+    /** Line the cursor is on (0-based) and column within it. */
+    lineCol() {
+        const before = this.buffer.slice(0, this.cursor);
+        const line = (before.match(/\n/g) ?? []).length;
+        const col = this.cursor - this.lineStartIdx();
+        return { line, col };
+    }
+    lineCount() {
+        return (this.buffer.match(/\n/g) ?? []).length + 1;
+    }
+    /** Move cursor up one logical line; returns false if already on the first. */
+    upLine() {
+        const { line, col } = this.lineCol();
+        if (line === 0)
+            return false;
+        const lines = this.buffer.split("\n");
+        let idx = 0;
+        for (let i = 0; i < line - 1; i++)
+            idx += lines[i].length + 1;
+        this.cursor = idx + Math.min(col, lines[line - 1].length);
+        return true;
+    }
+    downLine() {
+        const { line, col } = this.lineCol();
+        const lines = this.buffer.split("\n");
+        if (line >= lines.length - 1)
+            return false;
+        let idx = 0;
+        for (let i = 0; i <= line; i++)
+            idx += lines[i].length + 1;
+        this.cursor = idx + Math.min(col, lines[line + 1].length);
+        return true;
+    }
+    killToLineStart() {
+        const start = this.lineStartIdx();
+        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        this.cursor = start;
+    }
+    deleteWordBack() {
+        if (this.cursor === 0)
+            return;
+        let i = this.cursor;
+        while (i > 0 && /\s/.test(this.buffer[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(this.buffer[i - 1]))
+            i--;
+        this.buffer = this.buffer.slice(0, i) + this.buffer.slice(this.cursor);
+        this.cursor = i;
+    }
+    clear() {
+        this.buffer = "";
+        this.cursor = 0;
+    }
+    set(text) {
+        this.buffer = text;
+        this.cursor = text.length;
+    }
+}
+exports.LineEditor = LineEditor;
+/** Wrap the buffer into display rows of at most `width` chars, tracking where
+ * the cursor lands. Explicit newlines always break a row. */
+function layoutBuffer(buffer, cursor, width) {
+    const rows = [];
+    let row = "";
+    let curRow = 0;
+    let curCol = 0;
+    for (let i = 0; i <= buffer.length; i++) {
+        if (i === cursor) {
+            curRow = rows.length;
+            curCol = row.length;
+        }
+        if (i === buffer.length)
+            break;
+        const ch = buffer[i];
+        if (ch === "\n") {
+            rows.push(row);
+            row = "";
+        }
+        else {
+            row += ch;
+            if (row.length >= width) {
+                rows.push(row);
+                row = "";
+            }
+        }
+    }
+    rows.push(row);
+    return { rows, curRow, curCol };
+}

package/dist/tui/keys.js

@@ -0,0 +1,145 @@
+"use strict";
+// Hand-rolled terminal key decoder (zero deps). Parses VT escape sequences
+// from raw-mode stdin, including bracketed paste so pasted newlines insert
+// instead of submitting.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyDecoder = void 0;
+const CSI_MAP = {
+    A: "up",
+    B: "down",
+    C: "right",
+    D: "left",
+    H: "home",
+    F: "end",
+    Z: "shifttab",
+    "1~": "home",
+    "3~": "delete",
+    "4~": "end",
+    "7~": "home",
+    "8~": "end",
+};
+function normalizePaste(s) {
+    return s
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        // strip control chars except newline and tab
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+class KeyDecoder {
+    pasteBuf = null;
+    decode(s) {
+        const out = [];
+        let i = 0;
+        while (i < s.length) {
+            // inside a bracketed paste: consume until the end marker
+            if (this.pasteBuf !== null) {
+                const end = s.indexOf("\x1b[201~", i);
+                if (end < 0) {
+                    this.pasteBuf += s.slice(i);
+                    return out;
+                }
+                this.pasteBuf += s.slice(i, end);
+                out.push({ type: "text", text: normalizePaste(this.pasteBuf) });
+                this.pasteBuf = null;
+                i = end + 6;
+                continue;
+            }
+            const ch = s[i];
+            if (ch === "\x1b") {
+                if (s.startsWith("\x1b[200~", i)) {
+                    this.pasteBuf = "";
+                    i += 6;
+                    continue;
+                }
+                if (s[i + 1] === "[") {
+                    let j = i + 2;
+                    while (j < s.length && !(s[j] >= "@" && s[j] <= "~"))
+                        j++;
+                    if (j >= s.length)
+                        break; // incomplete sequence — drop
+                    const seq = s.slice(i + 2, j + 1);
+                    const mapped = CSI_MAP[seq];
+                    if (mapped)
+                        out.push({ type: mapped });
+                    i = j + 1;
+                    continue;
+                }
+                if (s[i + 1] === "O" && i + 2 < s.length) {
+                    const mapped = CSI_MAP[s[i + 2]];
+                    if (mapped)
+                        out.push({ type: mapped });
+                    i += 3;
+                    continue;
+                }
+                out.push({ type: "esc" });
+                i++;
+                continue;
+            }
+            const code = ch.charCodeAt(0);
+            if (ch === "\r" || ch === "\n") {
+                out.push({ type: "enter" });
+                i++;
+                continue;
+            }
+            if (ch === "\t") {
+                out.push({ type: "tab" });
+                i++;
+                continue;
+            }
+            if (code === 127 || code === 8) {
+                out.push({ type: "backspace" });
+                i++;
+                continue;
+            }
+            if (code === 3) {
+                out.push({ type: "ctrlc" });
+                i++;
+                continue;
+            }
+            if (code === 4) {
+                out.push({ type: "ctrld" });
+                i++;
+                continue;
+            }
+            if (code === 21) {
+                out.push({ type: "ctrlu" });
+                i++;
+                continue;
+            }
+            if (code === 23) {
+                out.push({ type: "ctrlw" });
+                i++;
+                continue;
+            }
+            if (code === 1) {
+                out.push({ type: "ctrla" });
+                i++;
+                continue;
+            }
+            if (code === 5) {
+                out.push({ type: "ctrle" });
+                i++;
+                continue;
+            }
+            if (code < 32) {
+                i++;
+                continue;
+            } // other control chars: ignore
+            // printable run (single keystroke or unbracketed paste)
+            let j = i;
+            let run = "";
+            while (j < s.length) {
+                const cj = s[j];
+                const cc = cj.charCodeAt(0);
+                if (cj === "\x1b" || cj === "\r" || cj === "\n" || cj === "\t" || cc < 32 || cc === 127)
+                    break;
+                run += cj;
+                j++;
+            }
+            out.push(run.length === 1 ? { type: "char", text: run } : { type: "text", text: run });
+            i = j;
+        }
+        return out;
+    }
+}
+exports.KeyDecoder = KeyDecoder;