@ikarmic/forge-core 5.2.0 → 5.3.0

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>;

package/dist/tools/search-worker.js

@@ -0,0 +1,77 @@
+/**
+ * search_files' matching, run in a worker thread with a time limit. JavaScript cannot interrupt a running regex, so a
+ * pattern that backtracks badly on the main thread froze the process (in VS Code, the extension host): in a worker it
+ * is terminated after `timeoutMs`. The worker source is a plain string, not a function's text, so a bundler cannot
+ * rename or wrap anything in it; the same string runs in-process when a worker cannot start.
+ */
+import { readFileSync } from 'node:fs';
+import { Worker } from 'node:worker_threads';
+export const DEFAULT_SEARCH_TIMEOUT_MS = 20_000;
+/** Body of `function (job, readFile)`: read each file, skip binaries, match line by line, keep context. */
+const MATCH_BODY = String.raw `
+  var regex = new RegExp(job.source, job.flags);
+  var matches = [];
+  var truncated = false;
+  var filesScanned = 0;
+  function truncateByLines(text, maxLines) {
+    var lines = text.split(/\r?\n/);
+    if (lines.length <= maxLines) return text;
+    var dropped = lines.length - maxLines;
+    return lines.slice(0, maxLines).join('\n') + '\n\n... (' + dropped + ' more line' + (dropped === 1 ? '' : 's') + ' truncated; re-read with a smaller offset to see more)';
+  }
+  for (var f = 0; f < job.files.length; f++) {
+    if (matches.length >= job.maxResults) { truncated = true; break; }
+    var file = job.files[f];
+    filesScanned++;
+    var buf;
+    try { buf = readFile(file.abs); } catch (e) { continue; }
+    if (buf.includes(0)) continue;
+    var lines = buf.toString('utf8').split(/\r?\n/);
+    for (var i = 0; i < lines.length; i++) {
+      if (matches.length >= job.maxResults) { truncated = true; break; }
+      regex.lastIndex = 0;
+      if (regex.test(lines[i])) {
+        var start = Math.max(0, i - job.contextLines);
+        var end = Math.min(lines.length - 1, i + job.contextLines);
+        var block = [];
+        for (var j = start; j <= end; j++) block.push((j === i ? '>' : ' ') + ' ' + String(j + 1).padStart(6) + '\t' + lines[j]);
+        matches.push({ path: file.rel, line: i + 1, text: truncateByLines(block.join('\n'), 10) });
+      }
+    }
+  }
+  return { matches: matches, truncated: truncated, filesScanned: filesScanned };
+`;
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+const fs = require('node:fs');
+const match = new Function('job', 'readFile', ${JSON.stringify(MATCH_BODY)});
+parentPort.postMessage(match(workerData, (p) => fs.readFileSync(p)));
+`;
+function matchInProcess(job) {
+    return new Function('job', 'readFile', MATCH_BODY)(job, (p) => readFileSync(p));
+}
+/** Match `job` in a worker; throws when it runs longer than `timeoutMs`. Falls back to in-process if no worker starts. */
+export function matchInWorker(job, opts) {
+    let worker;
+    try {
+        worker = (opts.startWorker ?? ((source, data) => new Worker(source, { eval: true, workerData: data })))(WORKER_SOURCE, job);
+    }
+    catch {
+        return Promise.resolve(matchInProcess(job));
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            void worker.terminate();
+            reject(new Error(`The search pattern took longer than ${Math.round(opts.timeoutMs / 1000)} s and was stopped. Simplify it (avoid repeated groups that can match the same text in several ways) or search fewer files.`));
+        }, opts.timeoutMs);
+        worker.once('message', (result) => {
+            clearTimeout(timer);
+            void worker.terminate();
+            resolve(result);
+        });
+        worker.once('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}

package/dist/tools/sub-agent.d.ts

@@ -77,7 +77,7 @@ export declare function childAgentConfig(setup: {
     model: ModelConfig;
     maxIterations: number;
     systemPrompt?: string;
-}, ctx: Pick<ToolContext, 'autoApproveTools' | 'permissionRules' | 'toolSandbox' | 'askBudget'>, cwd: string, auto: boolean): AgentConfig;
+}, ctx: Pick<ToolContext, 'autoApproveTools' | 'permissionRules' | 'toolSandbox' | 'askBudget' | 'commandSandbox'>, cwd: string, auto: boolean): AgentConfig;
 /** What a child runs without asking: what the parent does, else the read-only tools. Destructive tools still never run unasked. */
 export declare function childAutoApprove(ctx: Pick<ToolContext, 'autoApproveTools'>): string[];
 /** The configured sub-agent model, else the parent's, else a last-resort default. */

package/dist/tools/sub-agent.js

@@ -328,6 +328,7 @@ export function childAgentConfig(setup, ctx, cwd, auto) {
         autoApproveTools: childAutoApprove(ctx),
         ...(ctx.permissionRules ? { permissionRules: ctx.permissionRules } : {}),
         ...(ctx.toolSandbox ? { toolSandbox: ctx.toolSandbox } : {}),
+        ...(ctx.commandSandbox ? { commandSandbox: ctx.commandSandbox } : {}),
         // The same budget object, not a copy: a child that started its own four
         // would be a way around the limit the parent is under (RB-14).
         ...(ctx.askBudget ? { askBudget: ctx.askBudget } : {}),

package/dist/types.d.ts

@@ -107,6 +107,10 @@ export interface ToolContext {
      * the default `child_process` runner.
      */
     commandRunner?: CommandRunner;
+    /** How long `search_files` may match before its worker is stopped. Default 20 s. */
+    searchTimeoutMs?: number;
+    /** Run `run_command` inside the OS sandbox (`AgentConfig.commandSandbox`); handed to sub-agents. */
+    commandSandbox?: CommandSandbox;
     /** The model sub-agents use instead of the parent's (`AgentConfig.subAgentModel`). */
     subAgentModel?: ModelConfig;
     /** Folder `AGENTS.md` paths already shown in this run; `read_file` adds each folder's file once. */
@@ -176,6 +180,13 @@ export type ModelRouter = (ctx: {
     /** Tool names the model called on the previous step (empty on the first). */
     lastToolNames: string[];
 }) => ModelConfig | undefined;
+/** What `run_command`'s OS sandbox allows besides writing to the workspace and the temp folder. */
+export interface CommandSandbox {
+    /** Let commands reach the network. */
+    network: boolean;
+    /** More folders commands may write to (a package manager's cache, say). */
+    extraWritable?: string[];
+}
 /**
  * Executes one shell command on behalf of `run_command`. Return `null` to decline
  * (e.g. no terminal available); the default `child_process` runner then handles it.
@@ -250,6 +261,11 @@ export interface ChildProgressEvent {
     /** Any event the child emitted. */
     event: AgentEvent;
 }
+/**
+ * How a tool call was let through: the person approved it, a permission rule allowed it, it is on the
+ * auto-approve list, memory writes are allowed, the command is on the "Always allow" list, or the run is Autonomous.
+ */
+export type ApprovalSource = 'person' | 'rule' | 'list' | 'memory' | 'always' | 'autonomous';
 /** Streamed agent event: surfaced to the UI via the AgentRunOptions.onEvent callback. */
 export type AgentEvent = {
     type: 'text_delta';
@@ -263,11 +279,14 @@ export type AgentEvent = {
 } | {
     type: 'reasoning_done';
     text: string;
-} | {
+}
+/** `approval` says how the call was let through; absent for bookkeeping tools that never ask (the todo list). */
+ | {
     type: 'tool_call';
     name: string;
     id: string;
     args: unknown;
+    approval?: ApprovalSource;
 } | {
     type: 'tool_result';
     name: string;
@@ -343,6 +362,22 @@ export type AgentEvent = {
 } | {
     type: 'continuation'; /** 1-based count of continuations so far in this run. */
     count: number;
+}
+/**
+ * The step now running failed (a provider error worth retrying, or an empty reply) and is being asked again after
+ * `delayMs`. Everything it streamed is discarded: a UI drops the step's partial text.
+ */
+/** The model ended a turn with `open` items of its own todo list still open and was reminded once (RB-44). */
+ | {
+    type: 'todo_nudge';
+    open: number;
+} | {
+    type: 'retry';
+    kind: 'provider_error' | 'empty_reply' | 'offline';
+    attempt: number;
+    maxRetries: number;
+    delayMs: number;
+    reason: string;
 } | {
     type: 'phase';
     /** Architect/editor mode: which phase the following events belong to. */
@@ -742,6 +777,23 @@ export interface AgentConfig {
      * Each continuation is a normal iteration (counts toward every cap).
      */
     maxContinuations?: number;
+    /**
+     * Retrying a step whose model call failed with something a retry can fix (429, 5xx, overload, dropped
+     * connection). Default 5 retries, back-off from 2 s (doubling, capped at 30 s) unless the provider sends
+     * retry-after. An empty or reasoning-only reply is asked for again twice, separately.
+     */
+    providerRetry?: {
+        maxRetries?: number;
+        baseDelayMs?: number;
+        /**
+         * With no network at all (DNS or route gone) the run waits instead of spending retries: it probes every
+         * `offlinePollMs` (default 3 s) for up to `maxOfflineMs` in total (default 15 min), then reports the error.
+         */
+        offlinePollMs?: number;
+        maxOfflineMs?: number;
+        /** True when the network is reachable; default dials a few public addresses over TCP. */
+        networkProbe?: () => Promise<boolean>;
+    };
     /**
      * Pick the model for each step (cheap for exploration, strong for planning…).
      * Return `undefined` to keep the current model. Cost is priced per routed model.
@@ -749,6 +801,11 @@ export interface AgentConfig {
     modelRouter?: ModelRouter;
     /** Replace how `run_command` executes. See {@link CommandRunner}. */
     commandRunner?: CommandRunner;
+    /**
+     * Confine `run_command` with the OS sandbox: bubblewrap on Linux, sandbox-exec on macOS. A command is refused when
+     * the tool is missing; Windows has no equivalent, so there commands run as before. Absent = off.
+     */
+    commandSandbox?: CommandSandbox;
     /**
      * Answers `ask_user`. When absent, or when `auto` is on, the model is not offered the tool.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikarmic/forge-core",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Agent engine for IKarmic AI Forge. Model loop, tools, MCP, sandbox, memory, compaction, plan mode, skills, hooks.",
   "type": "module",
   "main": "./dist/index.js",