@burtson-labs/agent-core 1.6.16 → 1.6.18

package/dist/tools/core-tools.js

@@ -51,9 +51,10 @@ function validatePostWrite(absolutePath, content) {
             // run it — there's no perf reason to skip. We tolerate the
             // common BOM + trim leading whitespace because some hosts
             // prepend a UTF-8 BOM to written files.
-            const trimmed = content.replace(/^/, '').trimStart();
-            if (trimmed.length === 0)
-                return null; // empty file is valid JSON-zero
+            const trimmed = content.replace(/^\uFEFF/, '').trimStart();
+            if (trimmed.length === 0) {
+                return null;
+            } // empty file is valid JSON-zero
             try {
                 JSON.parse(content);
                 return null;
@@ -68,17 +69,21 @@ function validatePostWrite(absolutePath, content) {
     }
 }
 function isAbsolutePath(p) {
-    if (p.startsWith('/') || p.startsWith('~'))
+    if (p.startsWith('/') || p.startsWith('~')) {
+        return true;
+    }
+    if (/^[A-Za-z]:[\\/]/.test(p)) {
         return true;
-    if (/^[A-Za-z]:[\\/]/.test(p))
-        return true; // C:\foo or C:/foo
-    if (p.startsWith('\\\\'))
-        return true; // UNC \\server\share
+    } // C:\foo or C:/foo
+    if (p.startsWith('\\\\')) {
+        return true;
+    } // UNC \\server\share
     return false;
 }
 function truncate(text, max, label) {
-    if (text.length <= max)
+    if (text.length <= max) {
         return text;
+    }
     return `${text.slice(0, max)}\n\n[${label}: truncated — ${text.length - max} chars omitted]`;
 }
 function stableContentHash(text) {
@@ -126,8 +131,9 @@ const readFileTool = {
     ],
     async execute(params, ctx) {
         const relPath = params.path?.trim();
-        if (!relPath)
+        if (!relPath) {
             return { output: 'Error: path parameter is required', isError: true };
+        }
         // Extension check first so we don't burn bytes decoding a binary blob.
         const lastDot = relPath.lastIndexOf('.');
         const ext = lastDot >= 0 ? relPath.slice(lastDot).toLowerCase() : '';
@@ -136,7 +142,7 @@ const readFileTool = {
         }
         // A path starting with "~" is home-relative — let the host's tool context
         // expand it rather than prepending the workspace root (which would produce
-        // nonsense like /Users/mark/~/Desktop/file.md).
+        // nonsense like /Users/name/~/Desktop/file.md).
         const absPath = isAbsolutePath(relPath)
             ? relPath
             : `${ctx.workspaceRoot}/${relPath}`;
@@ -175,7 +181,7 @@ const readFileTool = {
             // models (4B-class) routinely copy-paste those prefix bytes
             // into apply_edit `find` strings, where they never match the
             // real file content and the edit silently no-ops. Observed
-            // 2026-05-01 on a portfolio sandbox with gemma4:e4b: model
+            // 2026-05-01 on a React/TS sandbox with gemma4:e4b: model
             // emitted `Find: " 10 │ <link href=..."` and the loop
             // terminated with no edit landed. The header note + the
             // explicit reminder in apply_edit's `find` parameter
@@ -232,10 +238,12 @@ const writeFileTool = {
     async execute(params, ctx) {
         const relPath = params.path?.trim();
         const content = params.content;
-        if (!relPath)
+        if (!relPath) {
             return { output: 'Error: path parameter is required', isError: true };
-        if (content === undefined || content === null)
+        }
+        if (content === undefined || content === null) {
             return { output: 'Error: content parameter is required', isError: true };
+        }
         // Same rule as read_file: a "~" path is home-relative, not workspace-
         // relative. Leave the "~" for the host context (CliToolExecutionContext
         // expands it via os.homedir) rather than creating a literal "~" dir.
@@ -330,8 +338,9 @@ const deleteFileTool = {
     ],
     async execute(params, ctx) {
         const relPath = params.path?.trim();
-        if (!relPath)
+        if (!relPath) {
             return { output: 'Error: path parameter is required', isError: true };
+        }
         const absPath = isAbsolutePath(relPath)
             ? relPath
             : `${ctx.workspaceRoot}/${relPath}`;
@@ -408,16 +417,21 @@ const applyEditTool = {
         // the data we needed.
         const find = params.find ?? params.old_text ?? params.old_string;
         const replace = params.replace ?? params.new_text ?? params.new_string;
-        if (!relPath)
+        if (!relPath) {
             return { output: 'Error: path parameter is required', isError: true };
-        if (find === undefined || find === null)
+        }
+        if (find === undefined || find === null) {
             return { output: 'Error: find parameter is required (also accepts old_text, old_string)', isError: true };
-        if (replace === undefined || replace === null)
+        }
+        if (replace === undefined || replace === null) {
             return { output: 'Error: replace parameter is required (also accepts new_text, new_string)', isError: true };
-        if (find === '')
+        }
+        if (find === '') {
             return { output: 'Error: find parameter must not be empty — use write_file to create a new file', isError: true };
-        if (find === replace)
+        }
+        if (find === replace) {
             return { output: 'Error: find and replace are identical — no edit to apply', isError: true };
+        }
         // Scratchpad-placeholder detector. Small models occasionally dump their
         // own internal reasoning into `replace` as a bracketed "token" where
         // code should go, e.g.
@@ -545,13 +559,15 @@ const applyEditTool = {
             let scanIdx = 0;
             while (true) {
                 const idx = before.indexOf(find, scanIdx);
-                if (idx === -1)
+                if (idx === -1) {
                     break;
+                }
                 const lineNum = before.slice(0, idx).split('\n').length;
                 matchPositions.push({ lineNum, charIdx: idx });
                 scanIdx = idx + find.length;
-                if (matchPositions.length >= 32)
+                if (matchPositions.length >= 32) {
                     break;
+                }
             }
             if (Number.isFinite(nearLine) && matchPositions.length > 0) {
                 // Pick the candidate whose start line is closest to near_line.
@@ -607,21 +623,27 @@ const applyEditTool = {
         // match could have a different indent) and on edits where the model
         // already supplied absolute indent on the first line.
         const finalReplace = (() => {
-            if (replaceAll)
+            if (replaceAll) {
                 return replace;
-            if (find.includes('\n'))
+            }
+            if (find.includes('\n')) {
                 return replace;
-            if (!replace.includes('\n'))
+            }
+            if (!replace.includes('\n')) {
                 return replace;
-            if (/^\s/.test(replace))
+            }
+            if (/^\s/.test(replace)) {
                 return replace;
+            }
             const matchIndex = before.indexOf(find);
-            if (matchIndex === -1)
+            if (matchIndex === -1) {
                 return replace;
+            }
             const lineStart = before.lastIndexOf('\n', matchIndex - 1) + 1;
             const indent = before.slice(lineStart, matchIndex);
-            if (indent.length === 0 || !/^[ \t]+$/.test(indent))
+            if (indent.length === 0 || !/^[ \t]+$/.test(indent)) {
                 return replace;
+            }
             const lines = replace.split('\n');
             return lines
                 .map((line, i) => (i === 0 || line.length === 0 ? line : indent + line))
@@ -647,10 +669,12 @@ const applyEditTool = {
                 spliceReplace = finalReplace
                     .split('\n')
                     .map((line) => {
-                    if (line.length === 0)
+                    if (line.length === 0) {
                         return line;
-                    if (delta > 0)
+                    }
+                    if (delta > 0) {
                         return ' '.repeat(delta) + line;
+                    }
                     const leading = (line.match(/^[ \t]*/) ?? [''])[0].length;
                     return line.slice(Math.min(-delta, leading));
                 })
@@ -762,10 +786,12 @@ const replaceRangeTool = {
     async execute(params, ctx) {
         const relPath = params.path?.trim();
         const content = params.content ?? params.replace ?? params.new_text;
-        if (!relPath)
+        if (!relPath) {
             return { output: 'Error: path parameter is required', isError: true };
-        if (content === undefined || content === null)
+        }
+        if (content === undefined || content === null) {
             return { output: 'Error: content parameter is required', isError: true };
+        }
         const parsedStart = parseInt(params.start_line ?? params.start ?? params.from_line ?? '', 10);
         const parsedEnd = params.end_line !== undefined && params.end_line !== null && params.end_line !== ''
             ? parseInt(params.end_line, 10)
@@ -813,7 +839,7 @@ const replaceRangeTool = {
         // into a replace_range(43-50) call, hashes diverge (because they
         // cover different bytes), edit rejected, model re-reads, picks
         // up a still-wrong hash from the wider read, retries — repeat
-        // indefinitely. Captured 2026-05-26 Portfolio session: 3-5
+        // indefinitely. Captured 2026-05-26 real CLI session: 3-5
         // iterations spinning on a single 8-line replacement.
         //
         // The hash was always weaker safety than the read-tracking guard
@@ -921,8 +947,9 @@ const applyPatchTool = {
     ],
     async execute(params, ctx) {
         const raw = (params.patch ?? params.input ?? '').trim();
-        if (!raw)
+        if (!raw) {
             return { output: 'Error: patch parameter is required', isError: true };
+        }
         // Auto-detect format. Unified-diff patches start with one of the
         // standard headers (`---`, `+++`, `diff `, `@@`); the Codex format
         // starts with `*** Begin Patch`. When neither pattern matches we
@@ -959,29 +986,33 @@ const applyPatchTool = {
             const addMatch = /^\*\*\* Add File:\s+(.+?)\s*$/.exec(line);
             const deleteMatch = /^\*\*\* Delete File:\s+(.+?)\s*$/.exec(line);
             if (updateMatch) {
-                if (current)
+                if (current) {
                     actions.push(current);
+                }
                 current = { kind: 'update', path: updateMatch[1], hunks: [] };
                 currentHunk = null;
                 continue;
             }
             if (addMatch) {
-                if (current)
+                if (current) {
                     actions.push(current);
+                }
                 current = { kind: 'add', path: addMatch[1], lines: [] };
                 currentHunk = null;
                 continue;
             }
             if (deleteMatch) {
-                if (current)
+                if (current) {
                     actions.push(current);
+                }
                 actions.push({ kind: 'delete', path: deleteMatch[1] });
                 current = null;
                 currentHunk = null;
                 continue;
             }
-            if (!current)
+            if (!current) {
                 continue;
+            }
             if (current.kind === 'add') {
                 // Add file: every line should start with `+ ` (or be empty).
                 if (line.startsWith('+')) {
@@ -1019,8 +1050,9 @@ const applyPatchTool = {
                 continue;
             }
         }
-        if (current)
+        if (current) {
             actions.push(current);
+        }
         if (actions.length === 0) {
             return { output: 'apply_patch rejected: envelope contained no action blocks. Use `*** Update File:`, `*** Add File:`, or `*** Delete File:` headers.', isError: true };
         }
@@ -1249,8 +1281,9 @@ exports.applyPatchTool = applyPatchTool;
  */
 function maybeParseJsonArrayArgs(argsString) {
     const trimmed = argsString.trim();
-    if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
         return null;
+    }
     try {
         const parsed = JSON.parse(trimmed);
         if (Array.isArray(parsed) && parsed.every((v) => typeof v === 'string')) {
@@ -1264,11 +1297,13 @@ function maybeParseJsonArrayArgs(argsString) {
 }
 function introducedNewErrors(before, after) {
     const afterText = after ?? '';
-    if (!afterText.trim())
+    if (!afterText.trim()) {
         return false;
+    }
     const beforeText = before ?? '';
-    if (!beforeText.trim())
-        return true; // before was clean, after isn't — definitely introduced.
+    if (!beforeText.trim()) {
+        return true;
+    } // before was clean, after isn't — definitely introduced.
     // Strip position-bearing tokens that change with file content shifts
     // even when the underlying error is unchanged. Without this, renaming
     // "foo" → "foo-renamed" in a file that already had a JSON parse error
@@ -1290,8 +1325,9 @@ function introducedNewErrors(before, after) {
     const beforeSet = normalize(beforeText);
     const afterSet = normalize(afterText);
     for (const line of afterSet) {
-        if (!beforeSet.has(line))
+        if (!beforeSet.has(line)) {
             return true;
+        }
     }
     return false;
 }
@@ -1393,14 +1429,17 @@ async function executeUnifiedDiffPatch(patchText, pathOverride, ctx) {
  */
 function findIndentationHint(source, find) {
     const firstLine = find.split('\n', 1)[0].trim();
-    if (firstLine.length < 4)
+    if (firstLine.length < 4) {
         return '';
+    }
     const candidateLine = source.split('\n').find(line => line.trim() === firstLine);
-    if (!candidateLine || candidateLine === firstLine)
+    if (!candidateLine || candidateLine === firstLine) {
         return '';
+    }
     const indent = candidateLine.match(/^\s*/)?.[0] ?? '';
-    if (!indent)
+    if (!indent) {
         return '';
+    }
     return `Hint: the target line exists in the file but begins with "${indent.replace(/\t/g, '\\t')}" whitespace — your \`find\` is missing that indent. `;
 }
 /**
@@ -1408,9 +1447,9 @@ function findIndentationHint(source, find) {
  * snippet of what the file ACTUALLY contains around the closest fuzzy
  * match. Saves the model a re-read round-trip and prevents the failure
  * mode where it retries the same wrong `find` 3+ times before giving up
- * (observed Portfolio turn m9xj: assumed `<title>Vite + React</title>`
- * still existed when the file already had `<title>mark-portfolio</title>`
- * from a prior edit — three iterations wasted before re-reading).
+ * (observed when the model assumed `<title>Vite + React</title>` still
+ * existed when the file already had `<title>my-app</title>` from a prior
+ * edit — three iterations wasted before re-reading).
  *
  * Strategy: tokenize the first non-empty line of `find`, score every line
  * in the source by token-overlap, return ±3 lines of context around the
@@ -1420,22 +1459,27 @@ function findIndentationHint(source, find) {
  */
 function nearestMatchSnippet(source, find) {
     const findFirstLine = find.split('\n').find(l => l.trim().length > 0)?.trim();
-    if (!findFirstLine || findFirstLine.length < 8)
+    if (!findFirstLine || findFirstLine.length < 8) {
         return '';
+    }
     const findTokens = new Set(findFirstLine.split(/[^\w]+/).filter(t => t.length >= 3));
-    if (findTokens.size < 2)
+    if (findTokens.size < 2) {
         return '';
+    }
     const lines = source.split('\n');
     let bestLine = -1;
     let bestScore = 0;
     for (let i = 0; i < lines.length; i++) {
         const lineTokens = lines[i].split(/[^\w]+/).filter(t => t.length >= 3);
-        if (lineTokens.length === 0)
+        if (lineTokens.length === 0) {
             continue;
+        }
         let hits = 0;
-        for (const t of lineTokens)
-            if (findTokens.has(t))
+        for (const t of lineTokens) {
+            if (findTokens.has(t)) {
                 hits++;
+            }
+        }
         // Normalize by max so a long line with a couple matches doesn't beat
         // a short line where everything matches. Tie-broken by earlier line.
         const score = hits / Math.max(findTokens.size, lineTokens.length);
@@ -1446,8 +1490,9 @@ function nearestMatchSnippet(source, find) {
     }
     // 0.4 token-overlap threshold is the empirical "this is probably the
     // line you meant" cutoff. Lower than that and the snippet is noise.
-    if (bestLine < 0 || bestScore < 0.4)
+    if (bestLine < 0 || bestScore < 0.4) {
         return '';
+    }
     const start = Math.max(0, bestLine - 3);
     const end = Math.min(lines.length, bestLine + 4);
     const widest = String(end).length;
@@ -1471,15 +1516,17 @@ const listFilesTool = {
     ],
     async execute(params, ctx) {
         const pattern = params.pattern?.trim();
-        if (!pattern)
+        if (!pattern) {
             return { output: 'Error: pattern parameter is required', isError: true };
+        }
         const cwd = params.cwd
             ? (isAbsolutePath(params.cwd) ? params.cwd : `${ctx.workspaceRoot}/${params.cwd}`)
             : ctx.workspaceRoot;
         try {
             const files = await ctx.listFiles(pattern, cwd);
-            if (!files.length)
+            if (!files.length) {
                 return { output: `No files matched pattern "${pattern}"` };
+            }
             const list = files.slice(0, 200).join('\n');
             const suffix = files.length > 200 ? `\n\n[list_files: showing first 200 of ${files.length} files]` : '';
             return { output: `${files.length} file(s) matched "${pattern}":\n\n${list}${suffix}` };
@@ -1503,8 +1550,9 @@ const lsTool = {
     ],
     async execute(params, ctx) {
         const raw = params.path?.trim();
-        if (!raw)
+        if (!raw) {
             return { output: 'Error: path parameter is required', isError: true };
+        }
         // Resolve relative paths against the workspace root. Hosts handle
         // ~ expansion themselves.
         const resolved = isAbsolutePath(raw)
@@ -1519,15 +1567,17 @@ const lsTool = {
             // only the files directly in Desktop, never the folder itself.
             if (ctx.listDirectoryEntries) {
                 const names = await ctx.listDirectoryEntries(resolved);
-                if (!names.length)
+                if (!names.length) {
                     return { output: `(empty or not found: ${raw})` };
+                }
                 return { output: `${names.length} entr${names.length === 1 ? 'y' : 'ies'} in ${raw}:\n${names.join('\n')}` };
             }
             // Fallback path for hosts that predate listDirectoryEntries —
             // files-only, but better than nothing.
             const files = await ctx.listFiles('*', resolved);
-            if (!files.length)
+            if (!files.length) {
                 return { output: `(empty or not found: ${raw})` };
+            }
             const prefix = resolved.endsWith('/') ? resolved : resolved + '/';
             const names = files.map(f => f.startsWith(prefix) ? f.slice(prefix.length) : f).sort();
             return { output: `${names.length} entr${names.length === 1 ? 'y' : 'ies'} in ${raw} (files only — host does not support directory listing):\n${names.join('\n')}` };
@@ -1572,17 +1622,20 @@ function repoTokenize(s) {
 function repoMatchScore(name, query) {
     const lowerName = name.toLowerCase();
     const lowerQuery = query.toLowerCase();
-    if (lowerName === lowerQuery)
+    if (lowerName === lowerQuery) {
         return 1000;
+    }
     const queryTokens = repoTokenize(query);
     const nameTokens = repoTokenize(name);
-    if (queryTokens.length === 0)
+    if (queryTokens.length === 0) {
         return 0;
+    }
     // Every query token must appear as a substring of some name token.
     let matched = 0;
     for (const qt of queryTokens) {
-        if (nameTokens.some((nt) => nt.includes(qt)))
+        if (nameTokens.some((nt) => nt.includes(qt))) {
             matched++;
+        }
     }
     if (matched === queryTokens.length) {
         // All tokens accounted for. Bonus when the token sets are equal
@@ -1592,8 +1645,9 @@ function repoMatchScore(name, query) {
     }
     // Fall back to plain substring on the joined string so partial
     // queries still surface candidates.
-    if (lowerName.includes(lowerQuery))
+    if (lowerName.includes(lowerQuery)) {
         return 100;
+    }
     return 0;
 }
 const findDirectoryTool = {
@@ -1604,8 +1658,9 @@ const findDirectoryTool = {
     ],
     async execute(params, ctx) {
         const query = params.name?.trim();
-        if (!query)
+        if (!query) {
             return { output: 'Error: name parameter is required', isError: true };
+        }
         if (!ctx.listDirectoryEntries) {
             return { output: 'Error: this host does not support directory enumeration. Fall back to `run_command find ~ -maxdepth 4 -type d -iname "*<name>*"`.', isError: true };
         }
@@ -1633,15 +1688,17 @@ const findDirectoryTool = {
             try {
                 const entries = await ctx.listDirectoryEntries(parent);
                 for (const entry of entries) {
-                    if (!entry.endsWith('/'))
+                    if (!entry.endsWith('/')) {
                         continue;
+                    }
                     const name = entry.slice(0, -1);
                     const lower = name.toLowerCase();
                     // Dedup by lowercased basename — tilde paths and the workspace
                     // parent often resolve to overlapping directories; reporting the
                     // same hit twice is noise.
-                    if (seen.has(lower))
+                    if (seen.has(lower)) {
                         continue;
+                    }
                     const score = repoMatchScore(name, query);
                     if (score > 0) {
                         seen.add(lower);
@@ -1669,25 +1726,31 @@ const findDirectoryTool = {
         const lines = [];
         if (exact.length) {
             lines.push(`Exact match${exact.length === 1 ? '' : 'es'} for "${query}":`);
-            for (const h of exact)
+            for (const h of exact) {
                 lines.push(h.path);
+            }
         }
         if (tokenMatch.length) {
-            if (lines.length)
+            if (lines.length) {
                 lines.push('');
+            }
             lines.push(`Token match${tokenMatch.length === 1 ? '' : 'es'} for "${query}":`);
-            for (const h of tokenMatch)
+            for (const h of tokenMatch) {
                 lines.push(h.path);
+            }
         }
         if (substring.length) {
-            if (lines.length)
+            if (lines.length) {
                 lines.push('');
+            }
             lines.push(`Substring match${substring.length === 1 ? '' : 'es'} for "${query}":`);
-            for (const h of substring)
+            for (const h of substring) {
                 lines.push(h.path);
+            }
         }
-        if (omitted > 0)
+        if (omitted > 0) {
             lines.push(`\n[find_directory: showing first ${MAX} of ${hits.length} matches — narrow the query to see the rest]`);
+        }
         return { output: lines.join('\n') };
     }
 };
@@ -1703,15 +1766,17 @@ const searchCodeTool = {
     ],
     async execute(params, ctx) {
         const pattern = params.pattern?.trim();
-        if (!pattern)
+        if (!pattern) {
             return { output: 'Error: pattern parameter is required', isError: true };
+        }
         const cwd = params.cwd
             ? (isAbsolutePath(params.cwd) ? params.cwd : `${ctx.workspaceRoot}/${params.cwd}`)
             : ctx.workspaceRoot;
         try {
             const results = await ctx.searchCode(pattern, cwd, params.file_glob);
-            if (!results.trim())
+            if (!results.trim()) {
                 return { output: `No matches found for "${pattern}"` };
+            }
             return { output: truncate(results, MAX_SEARCH_CHARS, 'search_code') };
         }
         catch (err) {
@@ -1953,8 +2018,9 @@ function shellTokenize(input) {
     let inDouble = false;
     let hasToken = false;
     const push = () => {
-        if (hasToken || current.length > 0)
+        if (hasToken || current.length > 0) {
             out.push(current);
+        }
         current = '';
         hasToken = false;
     };
@@ -2000,15 +2066,17 @@ function shellTokenize(input) {
             continue;
         }
         if (/\s/.test(ch)) {
-            if (current.length > 0 || hasToken)
+            if (current.length > 0 || hasToken) {
                 push();
+            }
             continue;
         }
         current += ch;
         hasToken = true;
     }
-    if (current.length > 0 || hasToken)
+    if (current.length > 0 || hasToken) {
         push();
+    }
     return out;
 }
 const runCommandTool = {
@@ -2021,8 +2089,9 @@ const runCommandTool = {
     ],
     async execute(params, ctx) {
         const rawCmd = params.cmd?.trim();
-        if (!rawCmd)
+        if (!rawCmd) {
             return { output: 'Error: cmd parameter is required', isError: true };
+        }
         // Some models squish the entire command line into `cmd` ("npx create
         // @angular/cli mqtt-app") instead of splitting it across `cmd` /
         // `args` per the schema. Normalize before the allow-list check —
@@ -2118,8 +2187,9 @@ const watchCommandTool = {
     ],
     async execute(params, ctx) {
         const rawCmd = params.cmd?.trim();
-        if (!rawCmd)
+        if (!rawCmd) {
             return { output: 'Error: cmd parameter is required', isError: true };
+        }
         // Mirror the run_command normalization — accept both
         // cmd="npm" args="run dev" AND cmd="npm run dev" args="" shapes.
         let cmd = rawCmd;