langflower 0.0.6 → 0.0.8

package/vendor/tools/dist/builtins/grep/tool.js

@@ -4,23 +4,15 @@ import { formatNotFound, resolveFenceRoot, resolveProjectPath, } from '../../pat
 import { applyPostProcess } from '../apply-post-process.js';
 import { asBoolean, asString } from '../args.js';
 import { displayPath, fenceOptions } from '../fence.js';
-import { walkFiles } from '../walk-files.js';
-const MAX_GREP_MATCHES = 100;
+import { runGrepCascade } from './search.js';
 const invoke = async (ctx, args) => {
     const pattern = asString(args, 'pattern');
     if (pattern === undefined) {
         throw new Error('grep requires string argument «pattern».');
     }
-    let regex;
-    try {
-        regex = new RegExp(pattern, asBoolean(args, 'caseInsensitive', false) ? 'i' : '');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid regex «${pattern}»: ${message}. Escape special characters or simplify the pattern.`);
-    }
     const searchPath = asString(args, 'path') ?? '.';
     const respectGitignore = asBoolean(args, 'respectGitignore', true);
+    const caseInsensitive = asBoolean(args, 'caseInsensitive', false);
     const absolute = resolveProjectPath(ctx.projectRoot, searchPath, fenceOptions(ctx));
     const stat = await fs.stat(absolute).catch(() => null);
     if (stat === null) {
@@ -28,39 +20,15 @@ const invoke = async (ctx, args) => {
     }
     const fenceRoot = resolveFenceRoot(ctx.projectRoot, absolute, ctx.allowedRoots) ??
         path.resolve(ctx.projectRoot);
-    const files = stat.isFile()
-        ? [displayPath(ctx, absolute)]
-        : (await walkFiles(fenceRoot, absolute, respectGitignore)).map((file) => displayPath(ctx, path.join(fenceRoot, file)));
-    const hits = [];
-    for (const file of files) {
-        if (hits.length >= MAX_GREP_MATCHES) {
-            break;
-        }
-        const fileAbs = resolveProjectPath(ctx.projectRoot, file, fenceOptions(ctx));
-        let text;
-        try {
-            text = await fs.readFile(fileAbs, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = text.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i += 1) {
-            const line = lines[i] ?? '';
-            if (regex.test(line)) {
-                hits.push(`${file}:${i + 1}:${line}`);
-                if (hits.length >= MAX_GREP_MATCHES) {
-                    break;
-                }
-            }
-        }
-    }
-    const body = hits.length === 0
-        ? '(no matches)'
-        : hits.join('\n') +
-            (hits.length >= MAX_GREP_MATCHES
-                ? `\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
-                : '');
+    const { body } = await runGrepCascade({
+        pattern,
+        caseInsensitive,
+        respectGitignore,
+        searchAbsolute: absolute,
+        fenceRoot,
+        displayPath: (fileAbs) => displayPath(ctx, fileAbs),
+        ...(ctx.signal !== undefined ? { signal: ctx.signal } : {}),
+    });
     return applyPostProcess(args, body);
 };
 export const grepTool = {
@@ -68,13 +36,13 @@ export const grepTool = {
     registration: {
         toolId: 'grep',
         name: 'grep',
-        description: 'Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.',
+        description: 'Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.',
         inputSchema: {
             type: 'object',
             properties: {
                 pattern: {
                     type: 'string',
-                    description: 'JavaScript RegExp source',
+                    description: 'Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)',
                 },
                 path: {
                     type: 'string',

package/vendor/tools/dist/builtins/spawn-capture.d.ts

@@ -0,0 +1,15 @@
+export type SpawnCaptureResult = {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+};
+export type SpawnCaptureOptions = {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+    readonly maxStdout?: number;
+};
+/**
+ * Async spawn with arg array (no shell). Honors AbortSignal via Node's
+ * spawn `signal` (kills the child). Caps captured stdout.
+ */
+export declare const spawnCapture: (command: string, args: readonly string[], options?: SpawnCaptureOptions) => Promise<SpawnCaptureResult>;

package/vendor/tools/dist/builtins/spawn-capture.js

@@ -0,0 +1,42 @@
+import { spawn } from 'node:child_process';
+/**
+ * Async spawn with arg array (no shell). Honors AbortSignal via Node's
+ * spawn `signal` (kills the child). Caps captured stdout.
+ */
+export const spawnCapture = (command, args, options = {}) => {
+    const maxStdout = options.maxStdout ?? 2_000_000;
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            reject(new Error('aborted'));
+            return;
+        }
+        const child = spawn(command, [...args], {
+            cwd: options.cwd,
+            windowsHide: true,
+            shell: false,
+            ...(options.signal !== undefined ? { signal: options.signal } : {}),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            if (stdout.length < maxStdout) {
+                stdout += String(chunk);
+                if (stdout.length > maxStdout) {
+                    stdout = stdout.slice(0, maxStdout);
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+            if (stderr.length > 64_000) {
+                stderr = stderr.slice(0, 64_000);
+            }
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve({ stdout, stderr, code });
+        });
+    });
+};

package/vendor/tools/dist/builtins/types.d.ts

@@ -6,6 +6,8 @@ export type HandlerContext = {
     /** Absolute (or project-relative) roots trusted outside the project. */
     readonly allowedRoots: readonly string[];
     readonly bashEnabled: boolean;
+    /** Per-invoke abort (tool timeout / run cancel). */
+    readonly signal?: AbortSignal;
 };
 export type BuiltinTool<Id extends string = string> = {
     readonly id: Id;

package/vendor/tools/dist/builtins/walk-files.d.ts

@@ -1,2 +1,16 @@
+/** Always skip these directory names (ts-scan-style), even with --no-ignore. */
+export declare const WALK_EXCLUDE_DIR_NAMES: readonly ["node_modules", "dist", "build", ".git"];
 export declare const globToRegExp: (pattern: string) => RegExp;
-export declare const walkFiles: (root: string, dir: string, respectGitignore: boolean) => Promise<readonly string[]>;
+export type WalkFilesOptions = {
+    readonly respectGitignore?: boolean;
+    readonly signal?: AbortSignal;
+    /** Stop collecting after this many files (default unlimited). */
+    readonly maxFiles?: number;
+    /** Yield to the event loop every N directory entries (default 32). */
+    readonly yieldEvery?: number;
+};
+/**
+ * Async recursive file walk. Third arg may be `respectGitignore` boolean
+ * (legacy) or {@link WalkFilesOptions}.
+ */
+export declare const walkFiles: (root: string, dir: string, options?: boolean | WalkFilesOptions) => Promise<readonly string[]>;

package/vendor/tools/dist/builtins/walk-files.js

@@ -1,6 +1,13 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadGitIgnoreMatcher } from '../gitignore.js';
+/** Always skip these directory names (ts-scan-style), even with --no-ignore. */
+export const WALK_EXCLUDE_DIR_NAMES = [
+    'node_modules',
+    'dist',
+    'build',
+    '.git',
+];
 export const globToRegExp = (pattern) => {
     const escaped = pattern
         .replace(/\\/g, '/')
@@ -11,12 +18,42 @@ export const globToRegExp = (pattern) => {
         .replace(/::DOUBLESTAR::/g, '.*');
     return new RegExp(`^${escaped}$`);
 };
-export const walkFiles = async (root, dir, respectGitignore) => {
+const normalizeOptions = (options) => typeof options === 'boolean' ? { respectGitignore: options } : options;
+const yieldEventLoop = () => new Promise((resolve) => {
+    setImmediate(resolve);
+});
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw new Error('aborted');
+    }
+};
+/**
+ * Async recursive file walk. Third arg may be `respectGitignore` boolean
+ * (legacy) or {@link WalkFilesOptions}.
+ */
+export const walkFiles = async (root, dir, options = true) => {
+    const opts = normalizeOptions(options);
+    const respectGitignore = opts.respectGitignore !== false;
+    const yieldEvery = opts.yieldEvery ?? 32;
     const matcher = respectGitignore
         ? await loadGitIgnoreMatcher(root)
         : { ignores: () => false };
     const out = [];
+    const visitedDirs = new Set();
+    let steps = 0;
     const visit = async (absoluteDir) => {
+        throwIfAborted(opts.signal);
+        let realDir;
+        try {
+            realDir = await fs.realpath(absoluteDir);
+        }
+        catch {
+            return;
+        }
+        if (visitedDirs.has(realDir)) {
+            return;
+        }
+        visitedDirs.add(realDir);
         let entries;
         try {
             entries = await fs.readdir(absoluteDir, { withFileTypes: true });
@@ -25,6 +62,16 @@ export const walkFiles = async (root, dir, respectGitignore) => {
             return;
         }
         for (const entry of entries) {
+            throwIfAborted(opts.signal);
+            steps += 1;
+            if (steps % yieldEvery === 0) {
+                await yieldEventLoop();
+                throwIfAborted(opts.signal);
+            }
+            if (entry.isDirectory() &&
+                WALK_EXCLUDE_DIR_NAMES.includes(entry.name)) {
+                continue;
+            }
             const absolute = path.join(absoluteDir, entry.name);
             const relative = path
                 .relative(root, absolute)
@@ -33,11 +80,18 @@ export const walkFiles = async (root, dir, respectGitignore) => {
             if (matcher.ignores(relative, entry.isDirectory())) {
                 continue;
             }
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
             if (entry.isDirectory()) {
                 await visit(absolute);
             }
             else if (entry.isFile()) {
                 out.push(relative);
+                if (opts.maxFiles !== undefined &&
+                    out.length >= opts.maxFiles) {
+                    return;
+                }
             }
         }
     };

package/vendor/tools/dist/create-project-harness.js

@@ -48,7 +48,10 @@ export const createProjectHarness = (options) => {
                 return deniedToolResult(toolId, detail);
             }
             try {
-                const text = await invokeBuiltin(toolId, ctx, call.args);
+                const invokeCtx = call.signal === undefined
+                    ? ctx
+                    : { ...ctx, signal: call.signal };
+                const text = await invokeBuiltin(toolId, invokeCtx, call.args);
                 return { ok: true, text };
             }
             catch (error) {

package/vendor/tools/dist/domain/domain-tool-configs.d.ts

@@ -15,6 +15,8 @@ export type ToolHandlerContext = {
     readonly webFetch?: (request: WebFetchRequest) => Promise<WebFetchResult>;
     readonly denyPaths?: readonly string[];
     readonly allowedHosts?: readonly string[];
+    /** Per-invoke abort (tool timeout / run cancel) for builtins. */
+    readonly signal?: AbortSignal;
 };
 export type ToolHandler = (args: Readonly<Record<string, unknown>>, ctx: ToolHandlerContext) => Promise<string>;
 export type DomainToolConfig = {

package/vendor/tools/dist/harness-types.d.ts

@@ -12,6 +12,8 @@ export type ToolInvokeResult = {
 export type ToolInvokeCall = {
     readonly toolId: string;
     readonly args: Readonly<Record<string, unknown>>;
+    /** Per-invoke abort (tool timeout / run cancel). */
+    readonly signal?: AbortSignal;
 };
 export type BuiltinToolRegistration = {
     readonly toolId: string;