langflower 0.0.10 → 0.1.1

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

@@ -1,315 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { commandExists } from '../command-exists.js';
-import { spawnCapture, } from '../spawn-capture.js';
-import { WALK_EXCLUDE_DIR_NAMES, walkFiles } from '../walk-files.js';
-export const MAX_GREP_MATCHES = 100;
-const MAX_GREP_FILES_SCANNED = 5_000;
-const MAX_GREP_FILE_BYTES = 1_048_576;
-const MAX_GREP_LINE_CHARS = 8_000;
-const SEARCH_EXCLUDE_GLOBS = [
-    '!**/node_modules/**',
-    '!**/dist/**',
-    '!**/build/**',
-    '!**/.git/**',
-];
-const throwIfAborted = (signal) => {
-    if (signal?.aborted) {
-        throw new Error('aborted');
-    }
-};
-const formatHits = (hits, truncated) => {
-    if (hits.length === 0) {
-        return '(no matches)';
-    }
-    const body = hits
-        .map((hit) => `${hit.file}:${hit.line}:${hit.text}`)
-        .join('\n');
-    return truncated
-        ? `${body}\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
-        : body;
-};
-const formatGrepBody = (hits, truncated) => formatHits(hits, truncated);
-const parseLineHits = (stdout, displayPath, fenceRoot, maxHits) => {
-    const hits = [];
-    const lines = stdout.split(/\r?\n/);
-    for (const raw of lines) {
-        if (raw.length === 0) {
-            continue;
-        }
-        const match = /^(.+?):(\d+):(.*)$/.exec(raw);
-        if (match === null) {
-            continue;
-        }
-        const fileAbs = path.isAbsolute(match[1] ?? '')
-            ? (match[1] ?? '')
-            : path.join(fenceRoot, match[1] ?? '');
-        const line = Number(match[2]);
-        const text = match[3] ?? '';
-        if (!Number.isFinite(line)) {
-            continue;
-        }
-        hits.push({
-            file: displayPath(fileAbs),
-            line,
-            text: text.length > MAX_GREP_LINE_CHARS
-                ? `${text.slice(0, MAX_GREP_LINE_CHARS)}…`
-                : text,
-        });
-        if (hits.length >= maxHits) {
-            return { hits, truncated: true };
-        }
-    }
-    return { hits, truncated: false };
-};
-const isBinaryAbortError = (error) => error instanceof Error &&
-    (error.name === 'AbortError' || error.message === 'aborted');
-const searchWithRipgrep = async (input, deps = {}) => {
-    const exists = deps.commandExists ?? commandExists;
-    const run = deps.spawnCapture ?? spawnCapture;
-    if (!(await exists('rg'))) {
-        return {
-            ok: false,
-            reason: 'unavailable',
-            message: 'ripgrep (rg) is not available on this system',
-        };
-    }
-    throwIfAborted(input.signal);
-    const args = [
-        '-n',
-        '--color',
-        'never',
-        '--max-filesize',
-        `${MAX_GREP_FILE_BYTES}`,
-        ...(input.respectGitignore ? [] : ['--no-ignore']),
-        ...SEARCH_EXCLUDE_GLOBS.flatMap((glob) => ['--glob', glob]),
-        ...(input.caseInsensitive ? ['-i'] : []),
-        '-e',
-        input.pattern,
-        input.searchAbsolute,
-    ];
-    try {
-        const result = await run('rg', args, {
-            cwd: input.fenceRoot,
-            ...(input.signal !== undefined ? { signal: input.signal } : {}),
-        });
-        // rg: 0 = matches, 1 = no matches, 2 = error
-        if (result.code !== null && result.code >= 2) {
-            const detail = result.stderr.trim();
-            return {
-                ok: false,
-                reason: 'error',
-                message: detail.length > 0
-                    ? `ripgrep failed: ${detail}`
-                    : 'ripgrep failed',
-            };
-        }
-        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
-        return {
-            ok: true,
-            hits: parsed.hits,
-            truncated: parsed.truncated,
-            backend: 'rg',
-        };
-    }
-    catch (error) {
-        if (isBinaryAbortError(error)) {
-            throw new Error('aborted');
-        }
-        return {
-            ok: false,
-            reason: 'unavailable',
-            message: error instanceof Error
-                ? error.message
-                : 'Error executing ripgrep',
-        };
-    }
-};
-const searchWithGrep = async (input, deps = {}) => {
-    const exists = deps.commandExists ?? commandExists;
-    const run = deps.spawnCapture ?? spawnCapture;
-    if (!(await exists('grep'))) {
-        return {
-            ok: false,
-            reason: 'unavailable',
-            message: 'grep is not available on this system',
-        };
-    }
-    throwIfAborted(input.signal);
-    const args = [
-        '-r',
-        '-n',
-        '-E',
-        '-I',
-        ...(input.caseInsensitive ? ['-i'] : []),
-        ...WALK_EXCLUDE_DIR_NAMES.flatMap((name) => ['--exclude-dir', name]),
-        '-e',
-        input.pattern,
-        input.searchAbsolute,
-    ];
-    try {
-        const result = await run('grep', args, {
-            cwd: input.fenceRoot,
-            ...(input.signal !== undefined ? { signal: input.signal } : {}),
-        });
-        // grep: 0 = matches, 1 = no matches, ≥2 = error
-        if (result.code !== null && result.code >= 2) {
-            const detail = result.stderr.trim();
-            return {
-                ok: false,
-                reason: 'error',
-                message: detail.length > 0
-                    ? `grep failed: ${detail}`
-                    : 'grep failed',
-            };
-        }
-        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
-        return {
-            ok: true,
-            hits: parsed.hits,
-            truncated: parsed.truncated,
-            backend: 'grep',
-        };
-    }
-    catch (error) {
-        if (isBinaryAbortError(error)) {
-            throw new Error('aborted');
-        }
-        return {
-            ok: false,
-            reason: 'unavailable',
-            message: error instanceof Error ? error.message : 'Error executing grep',
-        };
-    }
-};
-const looksBinary = (buf) => {
-    const sample = buf.subarray(0, Math.min(buf.length, 8_192));
-    return sample.includes(0);
-};
-const yieldEventLoop = () => new Promise((resolve) => {
-    setImmediate(resolve);
-});
-export const searchWithNodeWalk = async (input) => {
-    throwIfAborted(input.signal);
-    let regex;
-    try {
-        regex = new RegExp(input.pattern, input.caseInsensitive ? 'i' : '');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            reason: 'error',
-            message: `Invalid regex «${input.pattern}»: ${message}. Escape special characters or simplify the pattern.`,
-        };
-    }
-    const stat = await fs.stat(input.searchAbsolute).catch(() => null);
-    if (stat === null) {
-        return {
-            ok: false,
-            reason: 'error',
-            message: `Path not found: ${input.searchAbsolute}`,
-        };
-    }
-    const files = stat.isFile()
-        ? [input.searchAbsolute]
-        : (await walkFiles(input.fenceRoot, input.searchAbsolute, {
-            respectGitignore: input.respectGitignore,
-            ...(input.signal !== undefined
-                ? { signal: input.signal }
-                : {}),
-            maxFiles: MAX_GREP_FILES_SCANNED,
-        })).map((relative) => path.join(input.fenceRoot, relative));
-    const hits = [];
-    let matchCapHit = false;
-    let scanned = 0;
-    for (const fileAbs of files) {
-        throwIfAborted(input.signal);
-        scanned += 1;
-        if (scanned % 16 === 0) {
-            await yieldEventLoop();
-            throwIfAborted(input.signal);
-        }
-        if (hits.length >= MAX_GREP_MATCHES) {
-            matchCapHit = true;
-            break;
-        }
-        let buf;
-        try {
-            const handle = await fs.open(fileAbs, 'r');
-            try {
-                const st = await handle.stat();
-                if (st.size > MAX_GREP_FILE_BYTES) {
-                    continue;
-                }
-                buf = Buffer.alloc(Number(st.size));
-                await handle.read(buf, 0, buf.length, 0);
-            }
-            finally {
-                await handle.close();
-            }
-        }
-        catch {
-            continue;
-        }
-        if (looksBinary(buf)) {
-            continue;
-        }
-        const text = buf.toString('utf8');
-        const lines = text.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i += 1) {
-            let line = lines[i] ?? '';
-            if (line.length > MAX_GREP_LINE_CHARS) {
-                line = line.slice(0, MAX_GREP_LINE_CHARS);
-            }
-            if (regex.test(line)) {
-                hits.push({
-                    file: input.displayPath(fileAbs),
-                    line: i + 1,
-                    text: line,
-                });
-                if (hits.length >= MAX_GREP_MATCHES) {
-                    matchCapHit = true;
-                    break;
-                }
-            }
-        }
-    }
-    const fileCapHit = !stat.isFile() && files.length >= MAX_GREP_FILES_SCANNED;
-    return {
-        ok: true,
-        hits,
-        truncated: matchCapHit || fileCapHit,
-        backend: 'node',
-    };
-};
-/**
- * ts-scan-style cascade: rg → grep → bounded Node walk.
- * Soft-falls through when a CLI binary is missing or fails to spawn;
- * Node tier surfaces invalid JS RegExp errors.
- */
-export const runGrepCascade = async (input, deps = {}) => {
-    throwIfAborted(input.signal);
-    const rg = await searchWithRipgrep(input, deps);
-    if (rg.ok) {
-        return {
-            body: formatGrepBody(rg.hits, rg.truncated),
-            backend: rg.backend,
-        };
-    }
-    const grep = await searchWithGrep(input, deps);
-    if (grep.ok) {
-        return {
-            body: formatGrepBody(grep.hits, grep.truncated),
-            backend: grep.backend,
-        };
-    }
-    const node = await searchWithNodeWalk(input);
-    if (!node.ok) {
-        throw new Error(node.message);
-    }
-    return {
-        body: formatGrepBody(node.hits, node.truncated),
-        backend: node.backend,
-    };
-};

package/vendor/tools/dist/builtins/grep/tool.d.ts

@@ -1,36 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const grepTool: {
-    readonly id: "grep";
-    readonly registration: {
-        readonly toolId: "grep";
-        readonly name: "grep";
-        readonly description: "Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly pattern: {
-                    readonly type: "string";
-                    readonly description: "Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)";
-                };
-                readonly path: {
-                    readonly type: "string";
-                    readonly description: "Optional subdirectory or file to search";
-                };
-                readonly caseInsensitive: {
-                    readonly type: "boolean";
-                };
-                readonly respectGitignore: {
-                    readonly type: "boolean";
-                    readonly description: "Default true";
-                };
-                readonly postProcess: {
-                    readonly type: "string";
-                    readonly description: "Optional source of (res: string) => string";
-                };
-            };
-            readonly required: readonly ["pattern"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

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

@@ -1,66 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { formatNotFound, resolveFenceRoot, resolveProjectPath, } from '../../path-sandbox.js';
-import { applyPostProcess } from '../apply-post-process.js';
-import { asBoolean, asString } from '../args.js';
-import { displayPath, fenceOptions } from '../fence.js';
-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».');
-    }
-    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) {
-        throw new Error(await formatNotFound(absolute, searchPath));
-    }
-    const fenceRoot = resolveFenceRoot(ctx.projectRoot, absolute, ctx.allowedRoots) ??
-        path.resolve(ctx.projectRoot);
-    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 = {
-    id: 'grep',
-    registration: {
-        toolId: 'grep',
-        name: 'grep',
-        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: 'Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)',
-                },
-                path: {
-                    type: 'string',
-                    description: 'Optional subdirectory or file to search',
-                },
-                caseInsensitive: { type: 'boolean' },
-                respectGitignore: {
-                    type: 'boolean',
-                    description: 'Default true',
-                },
-                postProcess: {
-                    type: 'string',
-                    description: 'Optional source of (res: string) => string',
-                },
-            },
-            required: ['pattern'],
-            additionalProperties: false,
-        },
-    },
-    invoke,
-};

package/vendor/tools/dist/builtins/read/tool.d.ts

@@ -1,41 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const readTool: {
-    readonly id: "read";
-    readonly registration: {
-        readonly toolId: "read";
-        readonly name: "read";
-        readonly description: "Read a file under the project root. Optional startLine/endLine (1-based) or offset/limit (byte-ish line slices). Optional postProcess: source of (res: string) => string.";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly path: {
-                    readonly type: "string";
-                    readonly description: "Project-relative file path";
-                };
-                readonly startLine: {
-                    readonly type: "number";
-                    readonly description: "1-based start line";
-                };
-                readonly endLine: {
-                    readonly type: "number";
-                    readonly description: "1-based end line (inclusive)";
-                };
-                readonly offset: {
-                    readonly type: "number";
-                    readonly description: "0-based line offset";
-                };
-                readonly limit: {
-                    readonly type: "number";
-                    readonly description: "Max lines to return";
-                };
-                readonly postProcess: {
-                    readonly type: "string";
-                    readonly description: "Optional source of (res: string) => string applied after a successful read";
-                };
-            };
-            readonly required: readonly ["path"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

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

@@ -1,96 +0,0 @@
-import fs from 'node:fs/promises';
-import { formatNotFound, resolveProjectPath } from '../../path-sandbox.js';
-import { applyPostProcess } from '../apply-post-process.js';
-import { asNumber, asString } from '../args.js';
-import { fenceOptions } from '../fence.js';
-const MAX_READ_CHARS = 200_000;
-const sliceLines = (content, args) => {
-    const lines = content.split(/\r?\n/);
-    const startLine = asNumber(args, 'startLine');
-    const endLine = asNumber(args, 'endLine');
-    const offset = asNumber(args, 'offset');
-    const limit = asNumber(args, 'limit');
-    let start = 0;
-    let end = lines.length;
-    if (startLine !== undefined) {
-        start = Math.max(0, Math.floor(startLine) - 1);
-    }
-    else if (offset !== undefined) {
-        start = Math.max(0, Math.floor(offset));
-    }
-    if (endLine !== undefined) {
-        end = Math.min(lines.length, Math.floor(endLine));
-    }
-    else if (limit !== undefined) {
-        end = Math.min(lines.length, start + Math.max(0, Math.floor(limit)));
-    }
-    const sliced = lines.slice(start, end).join('\n');
-    const truncated = sliced.length > MAX_READ_CHARS
-        ? `${sliced.slice(0, MAX_READ_CHARS)}\n…[truncated at ${MAX_READ_CHARS} chars]`
-        : sliced;
-    if (end < lines.length || start > 0) {
-        return `${truncated}\n\n[lines ${start + 1}-${Math.min(end, lines.length)} of ${lines.length}; continue with startLine=${end + 1}]`;
-    }
-    return truncated;
-};
-const invoke = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    if (userPath === undefined) {
-        throw new Error('read requires string argument «path».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    let content;
-    try {
-        content = await fs.readFile(absolute, 'utf8');
-    }
-    catch (error) {
-        const code = error !== null && typeof error === 'object' && 'code' in error
-            ? String(error.code)
-            : '';
-        if (code === 'ENOENT') {
-            throw new Error(await formatNotFound(absolute, userPath));
-        }
-        throw error;
-    }
-    return applyPostProcess(args, sliceLines(content, args));
-};
-export const readTool = {
-    id: 'read',
-    registration: {
-        toolId: 'read',
-        name: 'read',
-        description: 'Read a file under the project root. Optional startLine/endLine (1-based) or offset/limit (byte-ish line slices). Optional postProcess: source of (res: string) => string.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Project-relative file path',
-                },
-                startLine: {
-                    type: 'number',
-                    description: '1-based start line',
-                },
-                endLine: {
-                    type: 'number',
-                    description: '1-based end line (inclusive)',
-                },
-                offset: {
-                    type: 'number',
-                    description: '0-based line offset',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Max lines to return',
-                },
-                postProcess: {
-                    type: 'string',
-                    description: 'Optional source of (res: string) => string applied after a successful read',
-                },
-            },
-            required: ['path'],
-            additionalProperties: false,
-        },
-    },
-    invoke,
-};

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

@@ -1,15 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import type { BuiltinToolRegistration } from '../harness-types.js';
-export type { BuiltinToolRegistration };
-export type HandlerContext = {
-    readonly projectRoot: string;
-    readonly denyPaths: readonly string[];
-    /** 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;
-    readonly registration: BuiltinToolRegistration;
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

package/vendor/tools/dist/builtins/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,16 +0,0 @@
-/** 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 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[]>;