@oxecli/oxe 1.0.0

package/dist/tools.js

@@ -0,0 +1,856 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { structuredPatch } from "diff";
+import { max_diff_source_chars, max_diff_lines, max_diff_context_lines, max_diff_line_chars, max_read_line_chars, max_read_file_bytes, max_read_lines, max_output_chars, max_bash_timeout_seconds, max_grep_file_bytes, strict_max_properties, ignoredDirs, } from "./config.js";
+import { toolLoadSkill } from "./skills.js";
+// ---------------------------------------------------------------------------
+// Natural sort + diff helpers
+// ---------------------------------------------------------------------------
+export function naturalSortKey(s) {
+    return s.replace(/\d+/g, (m) => m.padStart(12, "0")).toLowerCase();
+}
+function isGlob(s) {
+    return /[*?[]/.test(s);
+}
+function truncateDiffLine(line) {
+    const ending = line.endsWith("\n") ? "\n" : "";
+    const body = ending ? line.slice(0, -1) : line;
+    if (body.length > max_diff_line_chars) {
+        return body.slice(0, max_diff_line_chars) + " …(line truncated)" + ending;
+    }
+    return line;
+}
+function displayDiff(pathName, oldContent, newContent) {
+    if (oldContent.length + newContent.length > max_diff_source_chars) {
+        console.log(`\x1b[2m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
+            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m`);
+        return;
+    }
+    const patch = structuredPatch(pathName, pathName, oldContent, newContent, "", "", { context: max_diff_context_lines });
+    const contentLines = [];
+    for (const hunk of patch.hunks) {
+        for (const l of hunk.lines) {
+            if (l.startsWith("+"))
+                contentLines.push({ line: l, kind: "+" });
+            else if (l.startsWith("-"))
+                contentLines.push({ line: l, kind: "-" });
+            else
+                contentLines.push({ line: l, kind: " " });
+        }
+    }
+    const added = contentLines.filter((c) => c.kind === "+").length;
+    const removed = contentLines.filter((c) => c.kind === "-").length;
+    if (!added && !removed)
+        return;
+    console.log(`\x1b[2m${pathName}\x1b[0m`);
+    console.log(`\x1b[31m-${removed}\x1b[0m \x1b[32m+${added}\x1b[0m`);
+    const shown = [];
+    let run = [];
+    let lastKind = null;
+    const flush = () => {
+        if (!run.length)
+            return;
+        const kind = run[0].kind;
+        const limit = kind === " " ? max_diff_context_lines : max_diff_lines;
+        const hidden = run.length - limit;
+        for (const r of run.slice(0, limit))
+            shown.push(truncateDiffLine(r.line));
+        if (hidden > 0) {
+            shown.push(`… (${hidden} ${hidden === 1 ? "line" : "lines"} of diff hidden) …`);
+        }
+        run = [];
+    };
+    for (const c of contentLines) {
+        if (c.kind !== lastKind) {
+            flush();
+            lastKind = c.kind;
+        }
+        run.push(c);
+    }
+    flush();
+    const diffText = shown.join("\n");
+    const colored = diffText
+        .split("\n")
+        .map((l) => l.startsWith("+") ? `\x1b[32m${l}\x1b[0m` : l.startsWith("-") ? `\x1b[31m${l}\x1b[0m` : l)
+        .join("\n");
+    process.stdout.write(colored + "\n");
+}
+export function truncateToolOutput(output, maxChars = max_output_chars) {
+    if (output.length > maxChars) {
+        return (output.slice(0, maxChars) +
+            `\n\n[... Output truncated! Total characters: ${output.length} ...]`);
+    }
+    return output;
+}
+function capLine(line) {
+    line = line.replace(/[\r\n]+$/, "");
+    if (line.length > max_read_line_chars) {
+        return line.slice(0, max_read_line_chars) + " …(line truncated)";
+    }
+    return line;
+}
+// ---------------------------------------------------------------------------
+// read_file
+// ---------------------------------------------------------------------------
+const lineIndexCache = new Map();
+const lineIndexCacheMaxFiles = 32;
+const lineIndexCacheMaxTotalOffsets = 1_000_000;
+const indexScanChunk = 1 << 20;
+function buildLineIndex(p) {
+    const offsets = [0];
+    let nNewlines = 0;
+    let base = 0;
+    const buf = Buffer.alloc(indexScanChunk);
+    let fd = null;
+    try {
+        fd = fs.openSync(p, "r");
+        while (true) {
+            const bytesRead = fs.readSync(fd, buf, 0, buf.length, base);
+            if (bytesRead <= 0)
+                break;
+            const chunk = buf.subarray(0, bytesRead);
+            for (let i = 0; i < chunk.length; i++)
+                if (chunk[i] === 0x0a)
+                    nNewlines++;
+            let start = 0;
+            while (true) {
+                const idx = chunk.indexOf(0x0a, start);
+                if (idx === -1)
+                    break;
+                offsets.push(base + idx + 1);
+                start = idx + 1;
+            }
+            base += bytesRead;
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+    }
+    if (base === 0)
+        return [[0], 0];
+    const endsWithNl = offsets[offsets.length - 1] === base;
+    const total = endsWithNl ? nNewlines : nNewlines + 1;
+    return [offsets, total];
+}
+function lineIndex(p) {
+    let st;
+    try {
+        st = fs.statSync(p);
+    }
+    catch {
+        return null;
+    }
+    const key = `${path.resolve(p).toLowerCase()}:${st.size}:${st.mtimeMs}`;
+    const cached = lineIndexCache.get(p);
+    if (cached && cached.key === key)
+        return [cached.offsets, cached.total];
+    const built = buildLineIndex(p);
+    if (!built)
+        return null;
+    const [offsets, total] = built;
+    if (offsets.length <= lineIndexCacheMaxTotalOffsets) {
+        while (lineIndexCache.size >= lineIndexCacheMaxFiles ||
+            [...lineIndexCache.values()].reduce((s, e) => s + e.offsets.length, 0) >
+                lineIndexCacheMaxTotalOffsets) {
+            lineIndexCache.delete(lineIndexCache.keys().next().value);
+        }
+        lineIndexCache.set(p, { key, offsets, total });
+    }
+    return [offsets, total];
+}
+function readSpan(p, offsets, startIdx, endIdx) {
+    const startOff = offsets[startIdx];
+    const endOff = endIdx + 1 < offsets.length ? offsets[endIdx + 1] : undefined;
+    let data;
+    try {
+        if (endOff === undefined) {
+            data = fs.readFileSync(p);
+        }
+        else {
+            const fd = fs.openSync(p, "r");
+            const buf = Buffer.alloc(endOff - startOff);
+            fs.readSync(fd, buf, 0, buf.length, startOff);
+            fs.closeSync(fd);
+            data = buf;
+        }
+    }
+    catch {
+        return [];
+    }
+    const text = data.toString("utf-8");
+    let pieces = text.split("\n");
+    if (pieces.length && pieces[pieces.length - 1] === "")
+        pieces.pop();
+    return pieces.map(capLine);
+}
+function streamReadRange(p, start, end) {
+    const numbered = [];
+    let i = 0;
+    try {
+        const lines = fs.readFileSync(p, "utf-8").split("\n");
+        for (let n = 0; n < lines.length; n++) {
+            i = n + 1;
+            if (start <= i && i <= end) {
+                numbered.push(`${String(i).padStart(6, " ")}\t${capLine(lines[n])}`);
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return [i, numbered];
+}
+export function toolReadFile(pathName, startLine = 1, endLine) {
+    const p = pathName;
+    if (!fs.existsSync(p))
+        return `Error: file not found: ${pathName}`;
+    if (!fs.statSync(p).isFile())
+        return `Error: not a file: ${pathName}`;
+    let size;
+    try {
+        size = fs.statSync(p).size;
+    }
+    catch (err) {
+        return `Error: ${err}`;
+    }
+    if (size > max_read_file_bytes) {
+        return (`Error: file too large (${size.toLocaleString()} bytes > ${max_read_file_bytes.toLocaleString()} cap). ` +
+            `Use grep or bash to inspect it instead of reading it whole.`);
+    }
+    if (size === 0)
+        return "(empty file)";
+    const start = Math.max(1, startLine);
+    if (endLine != null && endLine < start) {
+        return `Error: end_line ${endLine} is before start_line ${start}`;
+    }
+    let end = null;
+    let total = 0;
+    let numbered = [];
+    let capped = false;
+    const idx = lineIndex(p);
+    if (idx) {
+        const [offsets, t] = idx;
+        total = t;
+        if (start > total)
+            return `Error: start_line ${start} exceeds file length (${total} lines)`;
+        end = endLine == null ? total : Math.min(total, endLine);
+        capped = end - start + 1 > max_read_lines;
+        if (capped)
+            end = start + max_read_lines - 1;
+        numbered = [];
+        const span = readSpan(p, offsets, start - 1, end - 1);
+        for (let i = 0; i < span.length; i++) {
+            numbered.push(`${String(start + i).padStart(6, " ")}\t${span[i]}`);
+        }
+    }
+    else {
+        const collectEnd = Math.min(Math.max(1, endLine != null ? endLine : start + max_read_lines - 1), start + max_read_lines - 1);
+        [total, numbered] = streamReadRange(p, start, collectEnd);
+        if (start > total)
+            return `Error: start_line ${start} exceeds file length (${total} lines)`;
+        end = endLine == null ? total : Math.min(total, endLine);
+        capped = end - start + 1 > max_read_lines;
+        if (capped) {
+            end = start + max_read_lines - 1;
+            numbered = numbered.slice(0, max_read_lines);
+        }
+    }
+    if (end === null)
+        end = total;
+    const header = `${pathName}: lines ${start}-${end} of ${total} total`;
+    const notes = [];
+    if (capped) {
+        notes.push(`capped at ${max_read_lines} lines; pass start_line=${end + 1} to continue`);
+    }
+    const footer = notes.length ? `\n[${notes.join("; ")}]` : "";
+    return `${header}\n${numbered.join("\n")}${footer}`;
+}
+// ---------------------------------------------------------------------------
+// write_file
+// ---------------------------------------------------------------------------
+export function toolWriteFile(pathName, content) {
+    const p = pathName;
+    if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+        return `Error: ${pathName} is a directory`;
+    }
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        if (fs.existsSync(p)) {
+            const head = fs.readFileSync(p).subarray(0, 8192);
+            if (head.includes(0))
+                return `Error: refusing to overwrite binary file: ${pathName}`;
+            const oldContent = fs.readFileSync(p, "utf-8");
+            displayDiff(pathName, oldContent, content);
+        }
+        else {
+            displayDiff(pathName, "", content);
+        }
+        fs.writeFileSync(p, content, "utf-8");
+    }
+    catch (err) {
+        return `Error: ${err}`;
+    }
+    return `Wrote ${content.length} characters to ${pathName}`;
+}
+// ---------------------------------------------------------------------------
+// edit_file
+// ---------------------------------------------------------------------------
+function detectNewline(text) {
+    const crlf = (text.match(/\r\n/g) || []).length;
+    const lf = (text.match(/\n/g) || []).length - crlf;
+    const loneCr = (text.match(/\r/g) || []).length - crlf;
+    if (crlf && crlf >= lf && crlf >= loneCr)
+        return "\r\n";
+    if (loneCr && loneCr >= lf)
+        return "\r";
+    return "\n";
+}
+function withNewlines(text, nl) {
+    if (nl === "\r")
+        return text.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
+    if (nl === "\n")
+        return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\r\n");
+}
+function findWsBlocks(text, needle) {
+    const needleLines = withNewlines(needle, "\n").split("\n").map((l) => l.trim());
+    while (needleLines.length && needleLines[needleLines.length - 1] === "")
+        needleLines.pop();
+    if (!needleLines.length)
+        return [];
+    const textLines = text.split("\n");
+    const n = needleLines.length;
+    const blocks = [];
+    let i = 0;
+    while (i <= textLines.length - n) {
+        let match = true;
+        for (let j = 0; j < n; j++) {
+            if (textLines[i + j].trim() !== needleLines[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            blocks.push(textLines.slice(i, i + n).join("\n"));
+            i += n;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return blocks;
+}
+export function toolEditFile(pathName, oldString, newString, replaceAll = false) {
+    const p = pathName;
+    if (!fs.existsSync(p))
+        return `Error: file not found: ${pathName}`;
+    if (!fs.statSync(p).isFile())
+        return `Error: not a file: ${pathName}`;
+    if (oldString === newString)
+        return "Error: old_string and new_string are identical";
+    let data;
+    try {
+        data = fs.readFileSync(p);
+    }
+    catch (err) {
+        return `Error: ${err}`;
+    }
+    if (data.includes(0))
+        return `Error: refusing to edit binary file: ${pathName}`;
+    const text = data.toString("utf-8");
+    const newline = detectNewline(text);
+    let match;
+    let normalized = false;
+    if (text.includes(oldString)) {
+        match = oldString;
+    }
+    else {
+        const norm = withNewlines(oldString, newline);
+        if (text.includes(norm)) {
+            match = norm;
+            normalized = true;
+        }
+        else {
+            const blocks = findWsBlocks(text, oldString);
+            if (!blocks.length) {
+                return ("Error: old_string not found in file " +
+                    "(line endings and per-line leading/trailing whitespace are normalized for matching)");
+            }
+            match = blocks[0];
+            normalized = true;
+        }
+    }
+    const count = text.split(match).length - 1;
+    if (count > 1 && !replaceAll) {
+        return (`Error: old_string matches ${count} locations; pass replace_all=true or make old_string more specific`);
+    }
+    const insert = withNewlines(newString, newline);
+    const newContent = replaceAll
+        ? text.split(match).join(insert)
+        : text.replace(match, insert);
+    displayDiff(pathName, text, newContent);
+    try {
+        fs.writeFileSync(p, newContent, "utf-8");
+    }
+    catch (err) {
+        return `Error: ${err}`;
+    }
+    return (`Edited ${pathName} (${count} occurrence${count !== 1 ? "s" : ""} replaced` +
+        `${normalized ? "; line endings and per-line whitespace normalized" : ""})`);
+}
+// ---------------------------------------------------------------------------
+// bash
+// ---------------------------------------------------------------------------
+function terminateProcessTree(proc) {
+    try {
+        if (isWindowsTool()) {
+            execFile("taskkill", ["/F", "/T", "/PID", String(proc.pid)], { timeout: 10000 });
+        }
+        else {
+            try {
+                process.kill(-proc.pid, "SIGKILL");
+            }
+            catch {
+                proc.kill();
+            }
+        }
+    }
+    catch {
+        try {
+            proc.kill();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function isWindowsTool() {
+    return process.platform === "win32";
+}
+export function toolBash(command, timeout = 60, cwd) {
+    try {
+        let t = typeof timeout === "number" ? timeout : parseInt(String(timeout), 10);
+        if (Number.isNaN(t))
+            t = 60;
+        t = t > 0 ? Math.min(t, max_bash_timeout_seconds) : 60;
+        return new Promise((resolve) => {
+            let child;
+            try {
+                if (isWindowsTool()) {
+                    child = spawn(command, {
+                        shell: true,
+                        cwd: cwd || undefined,
+                        windowsHide: false,
+                    });
+                }
+                else {
+                    child = spawn(command, {
+                        shell: true,
+                        cwd: cwd || undefined,
+                        detached: true,
+                    });
+                }
+            }
+            catch (err) {
+                resolve(`Error: ${err}`);
+                return;
+            }
+            let stdout = "";
+            let stderr = "";
+            let finished = false;
+            const timer = setTimeout(() => {
+                if (finished)
+                    return;
+                terminateProcessTree({ pid: child.pid, kill: () => child.kill("SIGKILL") });
+                const output = (stdout + stderr).trim();
+                let msg = `Error: command timed out after ${t}s`;
+                if (output)
+                    msg += `\n${output}`;
+                finished = true;
+                resolve(msg);
+            }, t * 1000);
+            child.stdout?.on("data", (d) => (stdout += d.toString("utf-8")));
+            child.stderr?.on("data", (d) => (stderr += d.toString("utf-8")));
+            child.on("error", (err) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                resolve(`Error: ${err}`);
+            });
+            child.on("close", (code) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                const output = (stdout + stderr).trim() || "(no output)";
+                resolve(`exit code: ${code}\n${output}`);
+            });
+        });
+    }
+    catch (err) {
+        return Promise.resolve(`Error: ${err}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// glob / grep
+// ---------------------------------------------------------------------------
+function pathUnderIgnoredDir(base, f) {
+    const rel = path.relative(base, f);
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+        return false;
+    const parts = rel.split(/[\\/]/);
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (ignoredDirs.has(parts[i]))
+            return true;
+    }
+    return false;
+}
+function matchParts(parts, relParts) {
+    if (!parts.length)
+        return relParts.length === 0;
+    if (parts[0] === "**") {
+        for (let k = 0; k <= relParts.length; k++) {
+            if (matchParts(parts.slice(1), relParts.slice(k)))
+                return true;
+        }
+        return false;
+    }
+    return (relParts.length > 0 &&
+        globMatch(relParts[0], parts[0]) &&
+        matchParts(parts.slice(1), relParts.slice(1)));
+}
+// minimal glob matcher (supports * ? [..])
+function globMatch(name, pattern) {
+    const regex = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${regex}$`).test(name);
+}
+function walkFiles(root, current, rel, parts, out) {
+    let entries;
+    try {
+        entries = fs.readdirSync(current, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const name = entry.name;
+        try {
+            if (entry.isDirectory()) {
+                if (ignoredDirs.has(name))
+                    continue;
+                rel.push(name);
+                walkFiles(root, path.join(current, name), rel, parts, out);
+                rel.pop();
+            }
+            else if (entry.isFile()) {
+                if (matchParts(parts, rel.concat(name))) {
+                    out.push([path.join(root, ...rel, name), fs.statSync(path.join(root, ...rel, name)).size]);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+}
+function rglobPruned(base, pattern) {
+    const norm = pattern.replace(/\\/g, "/");
+    const parts = norm.split("/").filter((p) => p !== "" && p !== ".");
+    const hasDotDot = parts.includes("..");
+    if (hasDotDot) {
+        const out = [];
+        const walk = (dir) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                const full = path.join(dir, e.name);
+                if (e.isDirectory()) {
+                    if (!ignoredDirs.has(e.name))
+                        walk(full);
+                }
+                else if (e.isFile()) {
+                    out.push([full, fs.statSync(full).size]);
+                }
+            }
+        };
+        if (fs.statSync(base).isFile()) {
+            out.push([base, fs.statSync(base).size]);
+        }
+        else {
+            walk(base);
+        }
+        return out;
+    }
+    if (fs.statSync(base).isFile()) {
+        return globMatch(path.basename(base), parts[parts.length - 1] ?? "*")
+            ? [[base, fs.statSync(base).size]]
+            : [];
+    }
+    if (!parts.length)
+        return [];
+    const out = [];
+    walkFiles(base, base, [], ["**", ...parts], out);
+    return out;
+}
+export function toolGlob(pattern, pathName = ".", limit = 200) {
+    const base = pathName;
+    if (!fs.existsSync(base))
+        return `Error: path not found: ${pathName}`;
+    limit = Math.max(1, limit);
+    let matches;
+    try {
+        matches = rglobPruned(base, pattern);
+    }
+    catch {
+        return `Error: path not found: ${pathName}`;
+    }
+    matches.sort((a, b) => naturalSortKey(a[0]).localeCompare(naturalSortKey(b[0])));
+    if (!matches.length)
+        return "No files matched";
+    const total = matches.length;
+    let result = matches.slice(0, limit).map(([p]) => p).join("\n");
+    if (total > limit) {
+        result += `\n\n[... ${total - limit} more matches not shown ...]`;
+    }
+    return result;
+}
+export function toolGrep(pattern, pathName = ".", glob = "*", limit = 200) {
+    const base = pathName;
+    if (!fs.existsSync(base))
+        return `Error: path not found: ${pathName}`;
+    let regex;
+    try {
+        regex = new RegExp(pattern);
+    }
+    catch (err) {
+        return `Error: invalid regex pattern: ${err}`;
+    }
+    glob = glob || "*";
+    let targets;
+    if (fs.statSync(base).isFile()) {
+        targets =
+            glob === "*" || glob === "**" || globMatch(path.basename(base), glob)
+                ? [[base, fs.statSync(base).size]]
+                : [];
+    }
+    else {
+        targets = rglobPruned(base, glob);
+    }
+    const hits = [];
+    let skippedLarge = 0;
+    for (const [fpath, fsize] of targets) {
+        try {
+            if (fsize > max_grep_file_bytes) {
+                skippedLarge++;
+                continue;
+            }
+            const head = fs.readFileSync(fpath).subarray(0, 8192);
+            if (head.includes(0))
+                continue;
+            const lines = fs.readFileSync(fpath, "utf-8").split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = capLine(lines[i]);
+                if (regex.test(line)) {
+                    hits.push(`${fpath}:${i + 1}:${line}`);
+                    if (hits.length >= limit)
+                        break;
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (hits.length >= limit)
+            break;
+    }
+    let result = hits.length ? hits.join("\n") : "No matches found";
+    if (skippedLarge) {
+        result += `\n[... ${skippedLarge} file(s) skipped (> ${Math.floor(max_grep_file_bytes / (1024 * 1024))} MB) ...]`;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Tool registry
+// ---------------------------------------------------------------------------
+export const TOOL_IMPLEMENTATIONS = {
+    read_file: toolReadFile,
+    write_file: toolWriteFile,
+    edit_file: toolEditFile,
+    bash: toolBash,
+    glob: toolGlob,
+    grep: toolGrep,
+    load_skill: toolLoadSkill,
+};
+export const RESPONSES_TOOLS = [
+    {
+        type: "function",
+        name: "read_file",
+        description: "Read a text file from disk, returned with 1-indexed line numbers. " +
+            "Use start_line/end_line to page through large files; the response " +
+            "header reports the file's total line count.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                start_line: { type: "integer", description: "First line to read, 1-indexed (default 1)" },
+                end_line: {
+                    type: "integer",
+                    description: `Last line to read, inclusive (default: end of file, capped at ${max_read_lines} lines from start_line)`,
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        type: "function",
+        name: "write_file",
+        description: "Create a new file or overwrite an existing one with the given content. " +
+            "Always read a file first if you need to preserve parts of it.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                content: { type: "string", description: "Full contents to write" },
+            },
+            required: ["path", "content"],
+        },
+    },
+    {
+        type: "function",
+        name: "edit_file",
+        description: "Replace an exact occurrence of old_string with new_string in a file. " +
+            "old_string must match the file's current text verbatim, including whitespace. " +
+            "By default it must be unique in the file; set replace_all to replace every " +
+            "occurrence. Prefer this over write_file for small changes.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                old_string: { type: "string", description: "Exact text to find" },
+                new_string: { type: "string", description: "Text to replace it with" },
+                replace_all: {
+                    type: "boolean",
+                    description: "Replace every occurrence instead of requiring a unique match (default false)",
+                },
+            },
+            required: ["path", "old_string", "new_string"],
+        },
+    },
+    {
+        type: "function",
+        name: "bash",
+        description: "Run a shell command and return its exit code, stdout, and stderr. " +
+            "Use for running tests, installing packages, git, and anything not covered " +
+            "by the other tools. Avoid interactive commands.",
+        parameters: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The command to run" },
+                timeout: {
+                    type: "integer",
+                    description: `Timeout in seconds (default 60, max ${max_bash_timeout_seconds})`,
+                },
+                cwd: {
+                    type: "string",
+                    description: "Working directory to run the command in (default: current directory)",
+                },
+            },
+            required: ["command"],
+        },
+    },
+    {
+        type: "function",
+        name: "glob",
+        description: "Find files by name pattern (e.g. '*.py') under a directory, recursively.",
+        parameters: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Glob pattern, e.g. '*.py'" },
+                path: { type: "string", description: "Directory to search from (default '.')" },
+                limit: { type: "integer", description: "Max number of matches to return (default 200)" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        type: "function",
+        name: "grep",
+        description: "Search file contents for a regex pattern, recursively. Returns matching " +
+            "'path:line:text' entries.",
+        parameters: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Regular expression to search for" },
+                path: { type: "string", description: "Directory to search from (default '.')" },
+                glob: {
+                    type: "string",
+                    description: "Only search files matching this glob (default '*')",
+                },
+                limit: { type: "integer", description: "Max number of matches to return (default 200)" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        type: "function",
+        name: "load_skill",
+        description: "Load the full contents of an available skill's SKILL.md into context. " +
+            "Call this when a user task needs specialized domain knowledge matching " +
+            "an available skill.",
+        parameters: {
+            type: "object",
+            properties: {
+                skill_name: {
+                    type: "string",
+                    description: "Name of the skill to load (e.g. 'react-native').",
+                },
+            },
+            required: ["skill_name"],
+        },
+    },
+];
+export function buildTools() {
+    const strictTools = [];
+    for (const tool of RESPONSES_TOOLS) {
+        const params = tool["parameters"];
+        if (!params || typeof params !== "object" || params["type"] !== "object") {
+            strictTools.push(tool);
+            continue;
+        }
+        const properties = params["properties"] || {};
+        if (Object.keys(properties).length <= strict_max_properties) {
+            const required = Object.keys(properties).sort();
+            strictTools.push({
+                ...tool,
+                parameters: {
+                    type: "object",
+                    properties,
+                    required,
+                    additionalProperties: false,
+                },
+                strict: true,
+            });
+        }
+        else {
+            strictTools.push(tool);
+        }
+    }
+    return strictTools;
+}