@ikarmic/forge-core 5.1.1 → 5.3.0

package/dist/tools/git-diff.js

@@ -0,0 +1,85 @@
+/**
+ * `git_diff`: the current changes, read-only, so Review and Security can see what changed without a
+ * `run_command` approval card. It runs one fixed program with fixed flags; the model chooses only a base
+ * ref, staged or not, and paths. A base that looks like an option is refused: `git diff --output=<file>`
+ * writes a file, and an option passed where a ref belongs is how a model (or a prompt it read) gets there.
+ */
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { resolveOnPath } from '../lsp/client.js';
+import { resolveAndCheckPath } from './shared.js';
+import { shellEnv } from './shell-env.js';
+const run = promisify(execFile);
+/** The most diff text handed to the model; the rest is cut with a note. */
+export const MAX_DIFF_CHARS = 60_000;
+const params = z.object({
+    base: z
+        .string()
+        .optional()
+        .describe('Compare against this ref (a branch, tag, commit or range such as main...HEAD). Default: HEAD, i.e. your uncommitted changes.'),
+    staged: z.boolean().optional().describe('Only the staged changes (git diff --cached).'),
+    paths: z.array(z.string()).optional().describe('Limit the diff to these files or folders inside the project.'),
+});
+/** A ref git will read as a ref, never as an option: no leading dash, only the characters refs and ranges use. */
+export function isSafeGitRef(ref) {
+    return ref.length > 0 && !ref.startsWith('-') && /^[A-Za-z0-9._/~^@{}:-]+$/.test(ref);
+}
+async function git(args, cwd) {
+    const env = shellEnv(process.env);
+    const program = resolveOnPath('git', env, process.platform) ?? 'git';
+    try {
+        // No repository code and no lock on the person's index: core.fsmonitor names a program git would run for
+        // status, and an optional index refresh can collide with the person's own commit (RB-41).
+        const safe = ['-c', 'core.fsmonitor=false', '--no-optional-locks', ...args];
+        const { stdout, stderr } = await run(program, safe, { cwd, env, maxBuffer: 64 * 1024 * 1024, windowsHide: true });
+        return { ok: true, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, stdout: e.stdout ?? '', stderr: e.stderr ?? e.message };
+    }
+}
+function cut(text) {
+    if (text.length <= MAX_DIFF_CHARS)
+        return text;
+    const left = text.length - MAX_DIFF_CHARS;
+    return `${text.slice(0, MAX_DIFF_CHARS)}\n[diff cut: ${left} characters left out. Pass paths to see one file at a time.]`;
+}
+export const gitDiffTool = {
+    name: 'git_diff',
+    description: 'Show the current changes as a unified diff, plus new untracked files. Read-only: it never changes files or the repository. ' +
+        'By default it compares your working tree and staged changes with HEAD; pass base to compare with a branch or commit, staged for staged changes only, paths to narrow it.',
+    parameters: params,
+    execute: async (args, ctx) => {
+        if (args.base !== undefined && !isSafeGitRef(args.base)) {
+            return `git_diff refused the base "${args.base}": a base must be a branch, tag, commit or range, and must not start with "-".`;
+        }
+        const rels = (args.paths ?? []).map((p) => path.relative(ctx.cwd, resolveAndCheckPath(p, ctx)) || '.');
+        const inside = await git(['rev-parse', '--is-inside-work-tree'], ctx.cwd);
+        if (!inside.ok || inside.stdout.trim() !== 'true')
+            return 'This folder is not a git repository, so there is no diff to show.';
+        const diffArgs = ['diff', '--no-ext-diff', '--no-textconv', '--no-color'];
+        // A repository with no commit has no HEAD: its staged files are the change.
+        const hasHead = (await git(['rev-parse', '--verify', '--quiet', 'HEAD'], ctx.cwd)).ok;
+        if (args.staged || (!args.base && !hasHead))
+            diffArgs.push('--cached');
+        else if (!args.base)
+            diffArgs.push('HEAD');
+        if (args.base)
+            diffArgs.push(args.base);
+        diffArgs.push('--', ...rels);
+        const diff = await git(diffArgs, ctx.cwd);
+        if (!diff.ok)
+            return `git diff failed: ${diff.stderr.trim()}`;
+        const status = await git(['status', '--porcelain=v1', '--', ...rels], ctx.cwd);
+        const parts = [diff.stdout.trim() ? diff.stdout : '(no changes in tracked files)'];
+        if (status.ok && status.stdout.trim())
+            parts.push(`git status:\n${status.stdout}`);
+        if (status.ok && /^\?\? /m.test(status.stdout)) {
+            parts.push('Untracked files (marked ??) are new and not shown in the diff above: read them with read_file.');
+        }
+        return cut(parts.join('\n'));
+    },
+};

package/dist/tools/index.d.ts

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,7 +32,7 @@ type AnyToolDefinition = ToolDefinition<any, any>;
  * intentional: the model sees this order in its tool list.
  */
 export declare const BUILTIN_TOOLS: readonly AnyToolDefinition[];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export type { ToolContext, ToolDefinition, ToolPolicy, ToolSandbox } from '../types.js';
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';

package/dist/tools/index.js

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,6 +32,8 @@ export const BUILTIN_TOOLS = [
     findSymbolTool,
     listSymbolsTool,
     findReferencesTool,
+    gitDiffTool,
+    dependencyAuditTool,
     writeFileTool,
     editFileTool,
     applyPatchTool,
@@ -45,7 +49,7 @@ export const BUILTIN_TOOLS = [
     todoReadTool,
     askUserTool,
 ];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';
 export { ToolResultCache, buildCacheKey, cachedExecute } from './result-cache.js';

package/dist/tools/list-files.d.ts

@@ -2,30 +2,12 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    /** Maximum entries to return. Defaults to 500. */
     max_entries: z.ZodOptional<z.ZodNumber>;
-    /** Include dotfiles. Default false. */
     include_hidden: z.ZodOptional<z.ZodBoolean>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
-    /** Recurse into subdirectories. Default false. */
     recursive: z.ZodOptional<z.ZodBoolean>;
-    /** Max recursion depth when recursive=true. Default 4. */
     max_depth: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ListEntry {
     path: string;
     type: 'file' | 'directory' | 'other';

package/dist/tools/list-symbols.d.ts

@@ -3,11 +3,7 @@ import type { SymbolKind } from '../code-index/types.js';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
+}, z.core.$strip>;
 export interface SymbolOutlineEntry {
     name: string;
     kind: SymbolKind;

package/dist/tools/memory.d.ts

@@ -2,21 +2,13 @@ import { z } from 'zod';
 import { type MemoryType } from '../memory/memory-store.js';
 import type { ToolDefinition } from '../types.js';
 declare const readParams: z.ZodObject<{
-    /**
-     * Which memory to read: 'project' (default), 'global', or 'both'. 'both'
-     * returns the merged view with project overriding global on heading
-     * collisions: the same view the system-prompt injector sees.
-     */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global", "both"]>>;
-    /** Optional heading to filter by. Returns just that section's body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+        both: "both";
+    }>>;
     section: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryReadResult {
     scope: 'project' | 'global' | 'both';
     content: string;
@@ -31,30 +23,21 @@ export declare const memoryReadTool: ToolDefinition<z.infer<typeof readParams>,
 /** Longest body `memory_write` accepts. Memory holds short facts, not documents. */
 export declare const MAX_BODY_CHARS = 1200;
 declare const writeParams: z.ZodObject<{
-    /** Where to write: 'project' (default) or 'global'. */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
-    /** Section heading. If the heading already exists (ignoring case and spacing), replaces its body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-    /** Section body. Markdown allowed. */
     body: z.ZodString;
-    type: z.ZodOptional<z.ZodEnum<["convention", "decision", "correction", "reference"]>>;
-    refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    type: z.ZodOptional<z.ZodEnum<{
+        convention: "convention";
+        decision: "decision";
+        correction: "correction";
+        reference: "reference";
+    }>>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     pin: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryWriteResult {
     scope: 'project' | 'global';
     path: string;
@@ -69,15 +52,12 @@ export interface MemoryWriteResult {
 }
 export declare const memoryWriteTool: ToolDefinition<z.infer<typeof writeParams>, MemoryWriteResult>;
 declare const forgetParams: z.ZodObject<{
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryForgetResult {
     scope: 'project' | 'global';
     heading: string;

package/dist/tools/notebook.d.ts

@@ -39,26 +39,20 @@ export declare function outputText(output: unknown): string;
 export declare function renderNotebook(nb: Notebook): string;
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    mode: z.ZodOptional<z.ZodEnum<["replace", "insert", "delete"]>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        delete: "delete";
+        insert: "insert";
+    }>>;
     cell_index: z.ZodOptional<z.ZodNumber>;
     cell_id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
-    cell_type: z.ZodOptional<z.ZodEnum<["code", "markdown", "raw"]>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}>;
+    cell_type: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        raw: "raw";
+        markdown: "markdown";
+    }>>;
+}, z.core.$strip>;
 export interface EditNotebookResult {
     path: string;
     mode: 'replace' | 'insert' | 'delete';

package/dist/tools/read-file.d.ts

@@ -2,19 +2,9 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    /** 1-based line number to start reading from. Omit to start at the beginning. */
     offset: z.ZodOptional<z.ZodNumber>;
-    /** Maximum number of lines to return. Defaults to 2000. */
     max_lines: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ReadFileResult {
     path: string;
     totalLines: number;

package/dist/tools/read-image.d.ts

@@ -26,19 +26,8 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    /**
-     * Maximum bytes to read. The tool errors if the file exceeds this
-     * limit; the default is 5 MB which covers most screenshots and
-     * diagrams without flooding the model context.
-     */
     max_bytes: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    max_bytes?: number | undefined;
-}, {
-    path: string;
-    max_bytes?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ReadImageResult {
     path: string;
     mime: string;

package/dist/tools/read-only.d.ts

@@ -3,6 +3,6 @@
  * anything. Asking before each of them is noise, so they are approved without a prompt by default;
  * edits, commands, web access and sub-agents still ask.
  */
-export declare const READ_ONLY_TOOLS: readonly ["read_file", "list_files", "search_files", "find_symbol", "list_symbols", "find_references", "codebase_search", "memory_read", "sub_agent_wait"];
+export declare const READ_ONLY_TOOLS: readonly ["read_file", "list_files", "search_files", "find_symbol", "list_symbols", "find_references", "git_diff", "codebase_search", "memory_read", "sub_agent_wait"];
 /** The tools that run without a prompt: the user's list, or the read-only tools when none is set. */
 export declare function resolveAutoApprove(configured?: readonly string[]): string[];

package/dist/tools/read-only.js

@@ -10,6 +10,8 @@ export const READ_ONLY_TOOLS = [
     'find_symbol',
     'list_symbols',
     'find_references',
+    // Runs one fixed git command; refuses option-shaped refs.
+    'git_diff',
     'codebase_search',
     'memory_read',
     // Only observes the sub-agents the person already let start.

package/dist/tools/run-command.d.ts

@@ -2,25 +2,9 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     command: z.ZodString;
-    /**
-     * Optional explicit timeout in ms. Default 60_000 (1 minute). Set to 0 to
-     * disable (not recommended).
-     */
     timeout_ms: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Optional working directory override. Must be inside the project root
-     * unless the configured ToolContext permits otherwise.
-     */
     cwd: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-    timeout_ms?: number | undefined;
-    cwd?: string | undefined;
-}, {
-    command: string;
-    timeout_ms?: number | undefined;
-    cwd?: string | undefined;
-}>;
+}, z.core.$strip>;
 export interface RunCommandResult {
     command: string;
     exitCode: number | null;

package/dist/tools/run-command.js

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
 import { z } from 'zod';
+import { sandboxCommand } from './command-sandbox.js';
 import { checkPolicyViolation } from './policy.js';
 import { resolveAndCheckPath } from './shared.js';
 import { shellEnv } from './shell-env.js';
@@ -64,10 +66,18 @@ export const runCommandTool = {
         if (violation)
             throw new Error(`[sandbox] ${violation}`);
         const timeoutMs = args.timeout_ms ?? DEFAULT_TIMEOUT_MS;
+        // The OS sandbox wraps the command line; the result still reports the command the model asked for.
+        let commandLine = args.command;
+        if (ctx.commandSandbox) {
+            const boxed = sandboxCommand(args.command, { cwd, sandbox: ctx.commandSandbox, platform: process.platform, tmpDir: tmpdir() });
+            if (boxed.kind === 'refused')
+                throw new Error(`[sandbox] ${boxed.reason}`);
+            commandLine = boxed.command;
+        }
         if (ctx.commandRunner) {
             const started = Date.now();
             const out = await ctx.commandRunner({
-                command: args.command,
+                command: commandLine,
                 cwd,
                 timeoutMs,
                 ...(ctx.abortSignal ? { signal: ctx.abortSignal } : {}),
@@ -91,7 +101,7 @@ export const runCommandTool = {
         }
         return new Promise((resolve, reject) => {
             const started = Date.now();
-            const child = spawn(args.command, {
+            const child = spawn(commandLine, {
                 shell: true,
                 cwd,
                 // Windows: never run a same-named program the repository ships in its root (see shell-env.ts).

package/dist/tools/search-files.d.ts

@@ -4,26 +4,10 @@ declare const params: z.ZodObject<{
     pattern: z.ZodString;
     path: z.ZodOptional<z.ZodString>;
     include: z.ZodOptional<z.ZodString>;
-    /** Maximum matches to return. Default 200. */
     max_results: z.ZodOptional<z.ZodNumber>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
-    /** Show a few lines of context around each match. */
     context_lines: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    pattern: string;
-    path?: string | undefined;
-    include?: string | undefined;
-    max_results?: number | undefined;
-    include_ignored?: boolean | undefined;
-    context_lines?: number | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-    include?: string | undefined;
-    max_results?: number | undefined;
-    include_ignored?: boolean | undefined;
-    context_lines?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface SearchMatch {
     path: string;
     line: number;

package/dist/tools/search-files.js

@@ -1,9 +1,9 @@
-import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod';
 import { globToRegex } from './policy.js';
 import { IgnoreRules } from './ignore-rules.js';
-import { resolveAndCheckPath, truncateByLines, DEFAULT_IGNORED_DIRS } from './shared.js';
+import { DEFAULT_SEARCH_TIMEOUT_MS, matchInWorker } from './search-worker.js';
+import { resolveAndCheckPath, DEFAULT_IGNORED_DIRS } from './shared.js';
 const params = z.object({
     pattern: z.string().describe('Regex pattern to search for in file contents.'),
     path: z
@@ -33,15 +33,10 @@ export const searchFilesTool = {
         const includeRe = args.include ? globToRegex(args.include) : null;
         const maxResults = args.max_results ?? 200;
         const contextLines = args.context_lines ?? 1;
-        const matches = [];
-        let truncated = false;
-        let filesScanned = 0;
+        // The walk (I/O and ignore rules) stays here; reading and matching run in a worker with a time limit (RB-22).
+        const files = [];
         const rules = args.include_ignored ? null : IgnoreRules.forRoot(ctx.cwd);
         async function walk(dir) {
-            if (matches.length >= maxResults) {
-                truncated = true;
-                return;
-            }
             const { readdir } = await import('node:fs/promises');
             let entries;
             try {
@@ -54,10 +49,6 @@ export const searchFilesTool = {
                 throw err;
             }
             for (const entry of entries) {
-                if (matches.length >= maxResults) {
-                    truncated = true;
-                    return;
-                }
                 if (entry.name.startsWith('.'))
                     continue;
                 if (DEFAULT_IGNORED_DIRS.has(entry.name))
@@ -72,40 +63,7 @@ export const searchFilesTool = {
                     const rel = path.relative(root, abs).split(path.sep).join('/');
                     if (includeRe && !includeRe.test(rel))
                         continue;
-                    await searchFile(abs, rel);
-                }
-            }
-        }
-        async function searchFile(abs, rel) {
-            filesScanned++;
-            let buf;
-            try {
-                buf = await readFile(abs);
-            }
-            catch {
-                return;
-            }
-            // Skip binary files.
-            if (buf.includes(0))
-                return;
-            const text = buf.toString('utf8');
-            const lines = text.split(/\r?\n/);
-            for (let i = 0; i < lines.length; i++) {
-                if (matches.length >= maxResults) {
-                    truncated = true;
-                    return;
-                }
-                const line = lines[i];
-                regex.lastIndex = 0;
-                if (regex.test(line)) {
-                    const start = Math.max(0, i - contextLines);
-                    const end = Math.min(lines.length - 1, i + contextLines);
-                    const block = [];
-                    for (let j = start; j <= end; j++) {
-                        const marker = j === i ? '>' : ' ';
-                        block.push(`${marker} ${String(j + 1).padStart(6)}\t${lines[j]}`);
-                    }
-                    matches.push({ path: rel, line: i + 1, text: truncateByLines(block.join('\n'), 10) });
+                    files.push({ abs, rel });
                 }
             }
         }
@@ -113,12 +71,13 @@ export const searchFilesTool = {
         if (!stat)
             throw new Error(`Path not found: ${root}`);
         if (stat.isFile()) {
-            await searchFile(root, path.basename(root));
+            files.push({ abs: root, rel: path.basename(root) });
         }
         else {
             await walk(root);
         }
-        return { pattern: args.pattern, matches, truncated, filesScanned };
+        const result = await matchInWorker({ files, source: regex.source, flags: regex.flags, maxResults, contextLines }, { timeoutMs: ctx.searchTimeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS });
+        return { pattern: args.pattern, ...result };
     },
 };
 /**

package/dist/tools/search-worker.d.ts

@@ -0,0 +1,23 @@
+import { Worker } from 'node:worker_threads';
+import type { SearchMatch } from './search-files.js';
+export interface MatchJob {
+    files: Array<{
+        abs: string;
+        rel: string;
+    }>;
+    source: string;
+    flags: string;
+    maxResults: number;
+    contextLines: number;
+}
+export interface MatchResult {
+    matches: SearchMatch[];
+    truncated: boolean;
+    filesScanned: number;
+}
+export declare const DEFAULT_SEARCH_TIMEOUT_MS = 20000;
+/** Match `job` in a worker; throws when it runs longer than `timeoutMs`. Falls back to in-process if no worker starts. */
+export declare function matchInWorker(job: MatchJob, opts: {
+    timeoutMs: number;
+    startWorker?: (source: string, data: MatchJob) => Worker;
+}): Promise<MatchResult>;