@oxecli/oxe 1.0.51 → 1.0.53

package/dist/tools.js

@@ -6,14 +6,22 @@ import { max_diff_source_chars, max_diff_lines, max_diff_context_lines, max_diff
 import { toolLoadSkill } from "./skills.js";
 export { toolLoadSkill };
 // ---------------------------------------------------------------------------
+// Path sanitization helper
+// ---------------------------------------------------------------------------
+function sanitizePath(p) {
+    if (!p)
+        return "";
+    return String(p).trim().replace(/^["']|["']$/g, "");
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// ---------------------------------------------------------------------------
 // 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;
@@ -24,8 +32,8 @@ function truncateDiffLine(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`);
+        process.stdout.write(`\x1b[2m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
+            `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m\n`);
         return;
     }
     const patch = structuredPatch(pathName, pathName, oldContent, newContent, "", "", { context: max_diff_context_lines });
@@ -44,8 +52,7 @@ function displayDiff(pathName, oldContent, newContent) {
     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`);
+    process.stdout.write(`\x1b[90m┌─\x1b[0m \x1b[1m${pathName}\x1b[0m \x1b[32m+${added}\x1b[0m \x1b[31m-${removed}\x1b[0m\n`);
     const shown = [];
     let run = [];
     let lastKind = null;
@@ -70,17 +77,23 @@ function displayDiff(pathName, oldContent, newContent) {
         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");
+    for (const l of shown) {
+        if (l.startsWith("+")) {
+            process.stdout.write(`\x1b[90m│\x1b[0m \x1b[32m${l}\x1b[0m\n`);
+        }
+        else if (l.startsWith("-")) {
+            process.stdout.write(`\x1b[90m│\x1b[0m \x1b[31m${l}\x1b[0m\n`);
+        }
+        else {
+            process.stdout.write(`\x1b[90m│\x1b[0m \x1b[2m${l}\x1b[0m\n`);
+        }
+    }
+    process.stdout.write(`\x1b[90m└────────────────────────────────────────\x1b[0m\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} ...]`);
+            `\n\n[... Output truncated! Total characters: ${output.length.toLocaleString()} ...]`);
     }
     return output;
 }
@@ -129,11 +142,14 @@ function buildLineIndex(p) {
         return null;
     }
     finally {
-        if (fd !== null)
+        if (fd !== null) {
             try {
                 fs.closeSync(fd);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
+        }
     }
     if (base === 0)
         return [[0], 0];
@@ -210,7 +226,9 @@ function streamReadRange(p, start, end) {
     return [i, numbered];
 }
 export function toolReadFile(pathName, startLine = 1, endLine) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (!fs.existsSync(p))
         return `Error: file not found: ${pathName}`;
     if (!fs.statSync(p).isFile())
@@ -224,13 +242,30 @@ export function toolReadFile(pathName, startLine = 1, endLine) {
     }
     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.`);
+            "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}`;
+    try {
+        const head = fs.readFileSync(p, { flag: "r" }).subarray(0, 8192);
+        if (head.includes(0))
+            return `Error: refusing to read binary file: ${pathName}`;
+    }
+    catch {
+        /* ignore */
+    }
+    const sVal = typeof startLine === "number"
+        ? startLine
+        : parseInt(String(startLine || 1), 10) || 1;
+    const start = Math.max(1, sVal);
+    let eVal = null;
+    if (endLine != null) {
+        const parsed = typeof endLine === "number" ? endLine : parseInt(String(endLine), 10);
+        if (!Number.isNaN(parsed))
+            eVal = parsed;
+    }
+    if (eVal != null && eVal < start) {
+        return `Error: end_line ${eVal} is before start_line ${start}`;
     }
     let end = null;
     let total = 0;
@@ -240,9 +275,10 @@ export function toolReadFile(pathName, startLine = 1, endLine) {
     if (idx) {
         const [offsets, t] = idx;
         total = t;
-        if (start > total)
+        if (start > total) {
             return `Error: start_line ${start} exceeds file length (${total} lines)`;
-        end = endLine == null ? total : Math.min(total, endLine);
+        }
+        end = eVal == null ? total : Math.min(total, eVal);
         capped = end - start + 1 > max_read_lines;
         if (capped)
             end = start + max_read_lines - 1;
@@ -253,11 +289,12 @@ export function toolReadFile(pathName, startLine = 1, endLine) {
         }
     }
     else {
-        const collectEnd = Math.min(Math.max(1, endLine != null ? endLine : start + max_read_lines - 1), start + max_read_lines - 1);
+        const collectEnd = Math.min(Math.max(1, eVal != null ? eVal : start + max_read_lines - 1), start + max_read_lines - 1);
         [total, numbered] = streamReadRange(p, start, collectEnd);
-        if (start > total)
+        if (start > total) {
             return `Error: start_line ${start} exceeds file length (${total} lines)`;
-        end = endLine == null ? total : Math.min(total, endLine);
+        }
+        end = eVal == null ? total : Math.min(total, eVal);
         capped = end - start + 1 > max_read_lines;
         if (capped) {
             end = start + max_read_lines - 1;
@@ -278,7 +315,9 @@ export function toolReadFile(pathName, startLine = 1, endLine) {
 // write_file
 // ---------------------------------------------------------------------------
 export function toolWriteFile(pathName, content) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
         return `Error: ${pathName} is a directory`;
     }
@@ -286,8 +325,9 @@ export function toolWriteFile(pathName, content) {
         fs.mkdirSync(path.dirname(p), { recursive: true });
         if (fs.existsSync(p)) {
             const head = fs.readFileSync(p).subarray(0, 8192);
-            if (head.includes(0))
+            if (head.includes(0)) {
                 return `Error: refusing to overwrite binary file: ${pathName}`;
+            }
             const oldContent = fs.readFileSync(p, "utf-8");
             displayDiff(pathName, oldContent, content);
         }
@@ -299,7 +339,7 @@ export function toolWriteFile(pathName, content) {
     catch (err) {
         return `Error: ${err}`;
     }
-    return `Wrote ${content.length} characters to ${pathName}`;
+    return `Wrote ${content.length.toLocaleString()} characters to ${pathName}`;
 }
 // ---------------------------------------------------------------------------
 // edit_file
@@ -322,9 +362,12 @@ function withNewlines(text, nl) {
     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] === "")
+    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");
@@ -350,7 +393,9 @@ function findWsBlocks(text, needle) {
     return blocks;
 }
 export function toolEditFile(pathName, oldString, newString, replaceAll = false) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (!fs.existsSync(p))
         return `Error: file not found: ${pathName}`;
     if (!fs.statSync(p).isFile())
@@ -391,7 +436,7 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
     }
     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`);
+        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
@@ -412,7 +457,7 @@ export function toolEditFile(pathName, oldString, newString, replaceAll = false)
 // ---------------------------------------------------------------------------
 function terminateProcessTree(proc) {
     try {
-        if (isWindowsTool()) {
+        if (process.platform === "win32") {
             execFile("taskkill", ["/F", "/T", "/PID", String(proc.pid)], { timeout: 10000 });
         }
         else {
@@ -420,42 +465,43 @@ function terminateProcessTree(proc) {
                 process.kill(-proc.pid, "SIGKILL");
             }
             catch {
-                proc.kill();
+                proc.kill("SIGKILL");
             }
         }
     }
     catch {
         try {
-            proc.kill();
+            proc.kill("SIGKILL");
         }
         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;
+        const workingDir = cwd ? sanitizePath(cwd) : undefined;
+        if (workingDir && !fs.existsSync(workingDir)) {
+            return Promise.resolve(`Error: working directory not found: ${cwd}`);
+        }
         return new Promise((resolve) => {
             let child;
             try {
-                if (isWindowsTool()) {
+                if (process.platform === "win32") {
                     child = spawn(command, {
                         shell: true,
-                        cwd: cwd || undefined,
-                        windowsHide: false,
+                        cwd: workingDir,
+                        windowsHide: true,
                     });
                 }
                 else {
                     child = spawn(command, {
                         shell: true,
-                        cwd: cwd || undefined,
+                        cwd: workingDir,
                         detached: true,
                     });
                 }
@@ -470,7 +516,10 @@ export function toolBash(command, timeout = 60, cwd) {
             const timer = setTimeout(() => {
                 if (finished)
                     return;
-                terminateProcessTree({ pid: child.pid, kill: () => child.kill("SIGKILL") });
+                terminateProcessTree({
+                    pid: child.pid,
+                    kill: (sig) => child.kill(sig),
+                });
                 const output = (stdout + stderr).trim();
                 let msg = `Error: command timed out after ${t}s`;
                 if (output)
@@ -504,17 +553,6 @@ export function toolBash(command, timeout = 60, cwd) {
 // ---------------------------------------------------------------------------
 // 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;
@@ -529,13 +567,12 @@ function matchParts(parts, relParts) {
         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);
+    return new RegExp(`^${regex}$`, "i").test(name);
 }
 function walkFiles(root, current, rel, parts, out) {
     let entries;
@@ -557,7 +594,10 @@ function walkFiles(root, current, rel, parts, out) {
             }
             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]);
+                    out.push([
+                        path.join(root, ...rel, name),
+                        fs.statSync(path.join(root, ...rel, name)).size,
+                    ]);
                 }
             }
         }
@@ -611,10 +651,10 @@ function rglobPruned(base, pattern) {
     return out;
 }
 export function toolGlob(pattern, pathName = ".", limit = 200) {
-    const base = pathName;
+    const base = sanitizePath(pathName) || ".";
     if (!fs.existsSync(base))
         return `Error: path not found: ${pathName}`;
-    limit = Math.max(1, limit);
+    const lim = typeof limit === "number" ? limit : parseInt(String(limit), 10) || 200;
     let matches;
     try {
         matches = rglobPruned(base, pattern);
@@ -626,24 +666,25 @@ export function toolGlob(pattern, pathName = ".", limit = 200) {
     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 ...]`;
+    let result = matches.slice(0, lim).map(([p]) => p).join("\n");
+    if (total > lim) {
+        result += `\n\n[... ${total - lim} more matches not shown ...]`;
     }
     return result;
 }
 export function toolGrep(pattern, pathName = ".", glob = "*", limit = 200) {
-    const base = pathName;
+    const base = sanitizePath(pathName) || ".";
     if (!fs.existsSync(base))
         return `Error: path not found: ${pathName}`;
     let regex;
     try {
-        regex = new RegExp(pattern);
+        regex = new RegExp(pattern, "i");
     }
-    catch (err) {
-        return `Error: invalid regex pattern: ${err}`;
+    catch {
+        regex = new RegExp(escapeRegExp(pattern), "i");
     }
     glob = glob || "*";
+    const lim = typeof limit === "number" ? limit : parseInt(String(limit), 10) || 200;
     let targets;
     if (fs.statSync(base).isFile()) {
         targets =
@@ -670,7 +711,7 @@ export function toolGrep(pattern, pathName = ".", glob = "*", limit = 200) {
                 const line = capLine(lines[i]);
                 if (regex.test(line)) {
                     hits.push(`${fpath}:${i + 1}:${line}`);
-                    if (hits.length >= limit)
+                    if (hits.length >= lim)
                         break;
                 }
             }
@@ -678,7 +719,7 @@ export function toolGrep(pattern, pathName = ".", glob = "*", limit = 200) {
         catch {
             continue;
         }
-        if (hits.length >= limit)
+        if (hits.length >= lim)
             break;
     }
     let result = hits.length ? hits.join("\n") : "No matches found";
@@ -710,7 +751,10 @@ export const RESPONSES_TOOLS = [
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the file" },
-                start_line: { type: "integer", description: "First line to read, 1-indexed (default 1)" },
+                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)`,
@@ -784,8 +828,14 @@ export const RESPONSES_TOOLS = [
             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)" },
+                path: {
+                    type: "string",
+                    description: "Directory to search from (default '.')",
+                },
+                limit: {
+                    type: "integer",
+                    description: "Max number of matches to return (default 200)",
+                },
             },
             required: ["pattern"],
         },
@@ -798,13 +848,22 @@ export const RESPONSES_TOOLS = [
         parameters: {
             type: "object",
             properties: {
-                pattern: { type: "string", description: "Regular expression to search for" },
-                path: { type: "string", description: "Directory to search from (default '.')" },
+                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)" },
+                limit: {
+                    type: "integer",
+                    description: "Max number of matches to return (default 200)",
+                },
             },
             required: ["pattern"],
         },