smolcoder 0.4.0

package/dist/tools/check.js

@@ -0,0 +1,193 @@
+"use strict";
+// Post-write syntax check — a harness hook that fires after every write_file /
+// edit_file. A local model that writes a 300-line game.js with one stray
+// brace gets a blank page and no idea why; catching the parse error in the
+// tool result (with the line number) turns that into a one-step fix. Only
+// parsers we can trust are used: node's own for JS (and inline <script> in
+// HTML), JSON.parse, python's compiler when python is on PATH. Nothing runs
+// the code.
+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.syntaxCheck = syntaxCheck;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CHECK_TIMEOUT_MS = 8000;
+const MAX_CHECK_BYTES = 2 * 1024 * 1024;
+let pythonExe; // undefined = not probed yet
+function findPython() {
+    if (pythonExe !== undefined)
+        return pythonExe;
+    pythonExe = null;
+    for (const exe of process.platform === "win32" ? ["python", "py"] : ["python3", "python"]) {
+        const r = (0, child_process_1.spawnSync)(exe, ["-c", "print(1)"], { encoding: "utf8", timeout: 5000, windowsHide: true });
+        if (r.status === 0 && r.stdout.trim() === "1") {
+            pythonExe = exe;
+            break;
+        }
+    }
+    return pythonExe;
+}
+function parseNodeError(stderr, tmpFile) {
+    const lines = stderr.split(/\r?\n/);
+    let line = null;
+    const loc = lines.find((l) => l.includes(tmpFile));
+    if (loc) {
+        const m = /:(\d+)\s*$/.exec(loc.trim());
+        if (m)
+            line = Number(m[1]);
+    }
+    const err = lines.find((l) => /^\w*Error: /.test(l));
+    if (!err)
+        return null;
+    return { line, message: err.replace(/^SyntaxError: /, "") };
+}
+/** Run `node --check` on a snippet, as a classic script first (non-strict,
+ * matches a browser <script>), then as a module if it needs import/export. */
+function checkJs(source, forceModule = false) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "smolcoder-check-"));
+    try {
+        const tryAs = (ext) => {
+            const tmp = path.join(dir, `snippet${ext}`);
+            fs.writeFileSync(tmp, source, "utf8");
+            const r = (0, child_process_1.spawnSync)(process.execPath, ["--check", tmp], {
+                encoding: "utf8",
+                timeout: CHECK_TIMEOUT_MS,
+                windowsHide: true,
+            });
+            if (r.status === 0)
+                return null;
+            if (r.error)
+                return null; // could not run the check — stay silent
+            return parseNodeError(r.stderr ?? "", tmp) ?? { line: null, message: "syntax error" };
+        };
+        if (forceModule)
+            return tryAs(".mjs");
+        const classic = tryAs(".cjs");
+        if (!classic)
+            return null;
+        if (/import|export|module|await/i.test(classic.message))
+            return tryAs(".mjs");
+        return classic;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function checkHtml(source) {
+    // Inline scripts only (no src=), skipping non-JS types (importmap, JSON, templates).
+    const re = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+    let m;
+    while ((m = re.exec(source))) {
+        const attrs = m[1] ?? "";
+        if (/\bsrc\s*=/i.test(attrs))
+            continue;
+        const type = /\btype\s*=\s*["']?([^"'\s>]+)/i.exec(attrs)?.[1]?.toLowerCase();
+        if (type && !["module", "text/javascript", "application/javascript"].includes(type))
+            continue;
+        const body = m[2];
+        if (!body.trim())
+            continue;
+        const err = checkJs(body, type === "module");
+        if (err) {
+            const startLine = source.slice(0, m.index + m[0].indexOf(body)).split("\n").length;
+            const at = err.line ? ` at line ${startLine + err.line - 1}` : "";
+            return `an inline <script> has a JavaScript syntax error${at}: ${err.message}`;
+        }
+    }
+    return null;
+}
+function checkPython(abs) {
+    const py = findPython();
+    if (!py)
+        return null;
+    const r = (0, child_process_1.spawnSync)(py, ["-m", "py_compile", abs], {
+        encoding: "utf8",
+        timeout: CHECK_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    if (r.status === 0 || r.error)
+        return null;
+    const text = (r.stderr || r.stdout || "").trim().split(/\r?\n/);
+    const line = text.map((l) => /line (\d+)/.exec(l)?.[1]).find(Boolean);
+    const last = text[text.length - 1] ?? "syntax error";
+    return `Python syntax error${line ? ` at line ${line}` : ""}: ${last.replace(/^.*?Error: ?/, "")}`;
+}
+/**
+ * Check a just-written file. Returns a short warning sentence, or null when
+ * the file parses (or when we have no parser for it). Never throws.
+ */
+function syntaxCheck(absPath, relPath) {
+    try {
+        const ext = path.extname(absPath).toLowerCase();
+        if (![".js", ".mjs", ".cjs", ".json", ".html", ".htm", ".py"].includes(ext))
+            return null;
+        const stat = fs.statSync(absPath);
+        if (stat.size > MAX_CHECK_BYTES)
+            return null;
+        if (ext === ".py")
+            return checkPython(absPath);
+        const source = fs.readFileSync(absPath, "utf8");
+        if (ext === ".json") {
+            try {
+                JSON.parse(source);
+                return null;
+            }
+            catch (e) {
+                return `${relPath} is not valid JSON: ${e.message}`;
+            }
+        }
+        if (ext === ".html" || ext === ".htm") {
+            const msg = checkHtml(source);
+            return msg ? `${relPath}: ${msg}` : null;
+        }
+        const err = checkJs(source, ext === ".mjs");
+        if (!err)
+            return null;
+        return `${relPath} has a JavaScript syntax error${err.line ? ` at line ${err.line}` : ""}: ${err.message}`;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/fs-tools.js

@@ -0,0 +1,417 @@
+"use strict";
+// The five file tools: read_file, write_file, edit_file, list_files, search.
+// Design rules for small models: flat string params, generous coaching in every
+// error message (an error IS a prompt — write it like one), and hard output
+// caps so a single result can't flood a small context window.
+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.readFile = readFile;
+exports.writeFile = writeFile;
+exports.editFile = editFile;
+exports.listFiles = listFiles;
+exports.searchFiles = searchFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sandbox_1 = require("../sandbox");
+Object.defineProperty(exports, "SandboxError", { enumerable: true, get: function () { return sandbox_1.SandboxError; } });
+const util_1 = require("../util");
+const READ_LINE_LIMIT = 250;
+// Must stay under TOOL_RESULT_CAP (10000) so the registry's outer truncateMiddle
+// never silently middle-cuts a read chunk while the trailer claims lines X-Y
+// were shown contiguously.
+const READ_CHAR_LIMIT = 9000;
+const LIST_ENTRY_LIMIT = 200;
+const SEARCH_MATCH_LIMIT = 50;
+const SEARCH_FILE_SIZE_LIMIT = 512 * 1024;
+const IGNORED_DIRS = new Set([
+    "node_modules", ".git", "dist", "out", "build", ".next", ".nuxt", ".cache",
+    "coverage", "__pycache__", ".venv", "venv", ".idea", ".vscode", "target",
+    ".svelte-kit", ".turbo", "vendor",
+]);
+const BINARY_EXTS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp", ".pdf", ".zip",
+    ".gz", ".tar", ".7z", ".rar", ".exe", ".dll", ".so", ".dylib", ".bin",
+    ".woff", ".woff2", ".ttf", ".otf", ".eot", ".mp3", ".mp4", ".mov", ".avi",
+    ".wasm", ".db", ".sqlite", ".jar", ".class", ".pyc",
+]);
+function isProbablyBinary(filePath) {
+    if (BINARY_EXTS.has(path.extname(filePath).toLowerCase()))
+        return true;
+    try {
+        const fd = fs.openSync(filePath, "r");
+        const buf = Buffer.alloc(1024);
+        const n = fs.readSync(fd, buf, 0, 1024, 0);
+        fs.closeSync(fd);
+        for (let i = 0; i < n; i++)
+            if (buf[i] === 0)
+                return true;
+    }
+    catch {
+        return true;
+    }
+    return false;
+}
+function readFile(root, args) {
+    const abs = (0, sandbox_1.resolveInWorkspace)(root, args.path);
+    if (!fs.existsSync(abs)) {
+        const dir = path.dirname(abs);
+        let hint = "";
+        if (fs.existsSync(dir)) {
+            const near = fs.readdirSync(dir).slice(0, 15).join(", ");
+            if (near)
+                hint = ` Files that do exist in ${(0, sandbox_1.relPath)(root, dir)}: ${near}`;
+        }
+        return `Error: file "${args.path}" does not exist.${hint}`;
+    }
+    const stat = fs.statSync(abs);
+    if (stat.isDirectory()) {
+        return `Error: "${args.path}" is a folder, not a file. Use list_files with {"path": "${args.path}"} to see what is inside it.`;
+    }
+    if (isProbablyBinary(abs)) {
+        return `Error: "${args.path}" looks like a binary file (${stat.size} bytes) and cannot be read as text.`;
+    }
+    const content = fs.readFileSync(abs, "utf8");
+    const lines = content.split(/\r?\n/);
+    const total = lines.length;
+    const offset = Math.max(1, Number(args.offset) || 1);
+    if (offset > total) {
+        return `The file "${args.path}" has only ${total} line${total === 1 ? "" : "s"}; you have already read all of it.`;
+    }
+    const limit = Math.min(Math.max(1, Number(args.limit) || READ_LINE_LIMIT), 1000);
+    const slice = lines.slice(offset - 1, offset - 1 + limit);
+    let body = slice.join("\n");
+    let end = offset - 1 + slice.length;
+    let charCut = false;
+    if (body.length > READ_CHAR_LIMIT) {
+        const kept = body.slice(0, READ_CHAR_LIMIT).split("\n");
+        if (kept.length > 1) {
+            // Cut on a line boundary so the trailer never claims a partially-shown
+            // line was read.
+            kept.pop();
+            body = kept.join("\n");
+            end = offset - 1 + kept.length;
+            charCut = true;
+        }
+        else {
+            // A single line longer than the limit: there is no line boundary to
+            // advance to, so a line-based "continue" would loop forever. Serve the
+            // head and say so, without a continuation offset.
+            body = body.slice(0, READ_CHAR_LIMIT);
+            return (body +
+                `\n\n[line ${offset} of ${total} is very long; showing its first ${READ_CHAR_LIMIT} characters only.]`);
+        }
+    }
+    if (offset === 1 && end >= total && !charCut)
+        return body;
+    return (body +
+        `\n\n[showing lines ${offset}-${end} of ${total}. Call read_file with {"path": "${args.path}", "offset": ${end + 1}} to continue.]`);
+}
+function writeFile(root, args) {
+    const abs = (0, sandbox_1.resolveInWorkspace)(root, args.path);
+    if (typeof args.content !== "string") {
+        return 'Error: content is required and must be a string. Example: {"path": "notes.txt", "content": "hello"}';
+    }
+    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+        return `Error: "${args.path}" is an existing folder; cannot write a file there.`;
+    }
+    const existed = fs.existsSync(abs);
+    const prevLines = existed ? fs.readFileSync(abs, "utf8").split("\n").length : 0;
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, args.content, "utf8");
+    const newLines = args.content.split("\n").length;
+    return existed
+        ? `Overwrote ${args.path} (was ${prevLines} lines, now ${newLines} lines).`
+        : `Created ${args.path} (${newLines} lines).`;
+}
+// ---------------------------------------------------------------------------
+// edit_file: exact match first, then a line-trimmed (whitespace-forgiving)
+// fallback, then a "closest match" coaching error. Small models paraphrase
+// whitespace constantly; forgiving matching is the difference between a usable
+// and unusable local edit tool.
+// ---------------------------------------------------------------------------
+function findTrimmedMatch(fileLines, oldLines) {
+    const targets = oldLines.map((l) => l.trim());
+    const matches = [];
+    outer: for (let i = 0; i + targets.length <= fileLines.length; i++) {
+        for (let j = 0; j < targets.length; j++) {
+            if (fileLines[i + j].trim() !== targets[j])
+                continue outer;
+        }
+        matches.push(i);
+    }
+    return matches;
+}
+function closestSnippet(fileLines, oldText) {
+    const firstLine = oldText.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+    if (!firstLine)
+        return "";
+    const norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
+    const target = norm(firstLine);
+    let bestIdx = -1;
+    let bestScore = 0;
+    for (let i = 0; i < fileLines.length; i++) {
+        const line = norm(fileLines[i]);
+        if (!line)
+            continue;
+        let score = 0;
+        if (line === target)
+            score = 1000;
+        else if (line.includes(target) || target.includes(line))
+            score = 500;
+        else {
+            const words = target.split(" ").filter((w) => w.length > 2);
+            for (const w of words)
+                if (line.includes(w))
+                    score += w.length;
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestIdx = i;
+        }
+    }
+    if (bestIdx < 0 || bestScore < 6)
+        return "";
+    const start = Math.max(0, bestIdx - 2);
+    const end = Math.min(fileLines.length, bestIdx + 3);
+    return fileLines.slice(start, end).join("\n");
+}
+function editFile(root, args) {
+    const abs = (0, sandbox_1.resolveInWorkspace)(root, args.path);
+    if (!fs.existsSync(abs)) {
+        return `Error: file "${args.path}" does not exist. Use write_file to create a new file.`;
+    }
+    const oldText = args.old_text;
+    const newText = args.new_text ?? "";
+    if (typeof oldText !== "string" || oldText.length === 0) {
+        return 'Error: old_text is required — copy the exact text from the file that you want to replace. To create a new file use write_file instead.';
+    }
+    if (typeof newText !== "string") {
+        return "Error: new_text must be a string (use an empty string to delete the old text).";
+    }
+    const rawContent = fs.readFileSync(abs, "utf8");
+    // Normalize to LF for all matching, re-serialize with the file's dominant EOL.
+    // Otherwise a model that sends "\n"-separated old_text can never exact-match a
+    // CRLF file, and the fallback rebuild leaves the file with mixed line endings.
+    const crlf = rawContent.includes("\r\n");
+    const content = crlf ? rawContent.replace(/\r\n/g, "\n") : rawContent;
+    const oldNorm = oldText.replace(/\r\n/g, "\n");
+    const newNorm = newText.replace(/\r\n/g, "\n");
+    const serialize = (s) => (crlf ? s.replace(/\n/g, "\r\n") : s);
+    // Tier 1: exact match.
+    const occurrences = content.split(oldNorm).length - 1;
+    if (occurrences === 1) {
+        fs.writeFileSync(abs, serialize(content.replace(oldNorm, newNorm)), "utf8");
+        return `Edited ${args.path}: replaced 1 occurrence.`;
+    }
+    if (occurrences > 1) {
+        return `Error: old_text appears ${occurrences} times in ${args.path}. Include a few more surrounding lines in old_text so it matches exactly one place.`;
+    }
+    // Tier 2: line-trimmed match (forgives leading/trailing whitespace per line).
+    const fileLines = content.split("\n");
+    const oldLines = oldNorm.split("\n");
+    const matches = findTrimmedMatch(fileLines, oldLines);
+    if (matches.length === 1) {
+        const start = matches[0];
+        const replaced = [
+            ...fileLines.slice(0, start),
+            ...newNorm.split("\n"),
+            ...fileLines.slice(start + oldLines.length),
+        ].join("\n");
+        fs.writeFileSync(abs, serialize(replaced), "utf8");
+        return `Edited ${args.path}: replaced 1 occurrence (whitespace differences in old_text were ignored).`;
+    }
+    if (matches.length > 1) {
+        return `Error: old_text matches ${matches.length} places in ${args.path} (ignoring whitespace). Include more surrounding lines to make it unique.`;
+    }
+    // Tier 3: coach with the closest real snippet.
+    const snippet = closestSnippet(fileLines, oldText);
+    if (snippet) {
+        return (`Error: old_text was not found in ${args.path}. The closest matching part of the file is below — copy it EXACTLY (including spaces) as old_text and try again:\n---\n${(0, util_1.truncateEnd)(snippet, 1500)}\n---`);
+    }
+    return `Error: old_text was not found in ${args.path}. Call read_file on it first and copy the exact text you want to change.`;
+}
+function listFiles(root, args) {
+    const startRel = typeof args.path === "string" && args.path.trim() ? args.path : ".";
+    const start = (0, sandbox_1.resolveInWorkspace)(root, startRel);
+    if (!fs.existsSync(start))
+        return `Error: folder "${startRel}" does not exist.`;
+    if (!fs.statSync(start).isDirectory()) {
+        return `Error: "${startRel}" is a file, not a folder. Use read_file to read it.`;
+    }
+    const entries = [];
+    let truncated = false;
+    const walk = (dir, depth) => {
+        if (truncated || depth > 6)
+            return;
+        let names;
+        try {
+            names = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        names.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of names) {
+            if (truncated)
+                return;
+            if (e.name.startsWith(".") && e.isDirectory())
+                continue;
+            if (IGNORED_DIRS.has(e.name))
+                continue;
+            if (e.isSymbolicLink())
+                continue; // never follow links out of the workspace
+            const abs = path.join(dir, e.name);
+            const rel = (0, sandbox_1.relPath)(root, abs);
+            if (e.isDirectory()) {
+                entries.push(rel + "/");
+                if (entries.length >= LIST_ENTRY_LIMIT) {
+                    truncated = true;
+                    return;
+                }
+                walk(abs, depth + 1);
+            }
+            else {
+                entries.push(rel);
+                if (entries.length >= LIST_ENTRY_LIMIT) {
+                    truncated = true;
+                    return;
+                }
+            }
+        }
+    };
+    walk(start, 0);
+    if (entries.length === 0)
+        return `The folder "${startRel}" is empty.`;
+    let out = entries.join("\n");
+    if (truncated) {
+        out += `\n\n[listing capped at ${LIST_ENTRY_LIMIT} entries. Call list_files with {"path": "<subfolder>"} to explore deeper.]`;
+    }
+    return out;
+}
+function searchFiles(root, args) {
+    const pattern = args.pattern;
+    if (typeof pattern !== "string" || !pattern) {
+        return 'Error: pattern is required. Example: {"pattern": "function main"}';
+    }
+    const startRel = typeof args.path === "string" && args.path.trim() ? args.path : ".";
+    const start = (0, sandbox_1.resolveInWorkspace)(root, startRel);
+    if (!fs.existsSync(start))
+        return `Error: folder "${startRel}" does not exist.`;
+    let re;
+    try {
+        re = new RegExp(pattern, "i");
+    }
+    catch {
+        re = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+    }
+    const matches = [];
+    let filesScanned = 0;
+    let done = false;
+    const walk = (dir, depth) => {
+        if (done || depth > 8)
+            return;
+        let names;
+        try {
+            names = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of names) {
+            if (done)
+                return;
+            if (e.name.startsWith(".") && e.isDirectory())
+                continue;
+            if (IGNORED_DIRS.has(e.name))
+                continue;
+            // A symlink's Dirent.isDirectory() is false, so a file symlink would
+            // otherwise fall straight into readFileSync and leak its target's
+            // contents (e.g. creds -> ~/.ssh/id_rsa) into model context. Skip all.
+            if (e.isSymbolicLink())
+                continue;
+            const abs = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(abs, depth + 1);
+                continue;
+            }
+            if (filesScanned++ > 5000) {
+                done = true;
+                return;
+            }
+            let stat;
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.size > SEARCH_FILE_SIZE_LIMIT || isProbablyBinary(abs))
+                continue;
+            let text;
+            try {
+                text = fs.readFileSync(abs, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+                if (re.test(lines[i])) {
+                    matches.push(`${(0, sandbox_1.relPath)(root, abs)}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+                    if (matches.length >= SEARCH_MATCH_LIMIT) {
+                        done = true;
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    const startIsFile = fs.statSync(start).isFile();
+    if (startIsFile) {
+        walk(path.dirname(start), 8); // degenerate case; just scan that dir shallowly
+    }
+    else {
+        walk(start, 0);
+    }
+    if (matches.length === 0) {
+        return `No matches for "${pattern}" in ${startRel}. (Searched ${filesScanned} files. Tip: try a shorter or simpler pattern.)`;
+    }
+    let out = matches.join("\n");
+    if (matches.length >= SEARCH_MATCH_LIMIT) {
+        out += `\n\n[stopped at ${SEARCH_MATCH_LIMIT} matches — narrow the pattern or search a subfolder with {"path": "..."}]`;
+    }
+    return out;
+}