langflower 0.0.10 → 0.1.1

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

@@ -1,24 +0,0 @@
-import { bashTool } from './bash/tool.js';
-import { createTool } from './create/tool.js';
-import { deleteTool } from './delete/tool.js';
-import { editTool } from './edit/tool.js';
-import { globTool } from './glob/tool.js';
-import { grepTool } from './grep/tool.js';
-import { readTool } from './read/tool.js';
-import { writeTool } from './write/tool.js';
-/** Composer: builtin order for inventory + invoke dispatch. */
-export const BUILTIN_TOOLS = [
-    readTool,
-    globTool,
-    grepTool,
-    editTool,
-    writeTool,
-    createTool,
-    deleteTool,
-    bashTool,
-];
-export const BUILTIN_TOOL_IDS = BUILTIN_TOOLS.map((tool) => tool.id);
-export const BUILTIN_REGISTRATIONS = BUILTIN_TOOLS.map((tool) => tool.registration);
-const byId = Object.fromEntries(BUILTIN_TOOLS.map((tool) => [tool.id, tool]));
-export const isBuiltinToolId = (toolId) => Object.hasOwn(byId, toolId);
-export const invokeBuiltin = (toolId, ctx, args) => byId[toolId].invoke(ctx, args);

package/vendor/tools/dist/builtins/command-exists.d.ts

@@ -1,5 +0,0 @@
-/**
- * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
- * Result is cached per process.
- */
-export declare const commandExists: (cmd: string) => Promise<boolean>;

package/vendor/tools/dist/builtins/command-exists.js

@@ -1,27 +0,0 @@
-import { spawn } from 'node:child_process';
-const cache = new Map();
-/**
- * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
- * Result is cached per process.
- */
-export const commandExists = async (cmd) => {
-    const cached = cache.get(cmd);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const checkCmd = process.platform === 'win32' ? 'where' : 'which';
-    const exists = await new Promise((resolve) => {
-        const child = spawn(checkCmd, [cmd], {
-            stdio: 'ignore',
-            windowsHide: true,
-        });
-        child.on('error', () => {
-            resolve(false);
-        });
-        child.on('close', (code) => {
-            resolve(code === 0);
-        });
-    });
-    cache.set(cmd, exists);
-    return exists;
-};

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

@@ -1,25 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const createTool: {
-    readonly id: "create";
-    readonly registration: {
-        readonly toolId: "create";
-        readonly name: "create";
-        readonly description: "Create a new file. Fails if the path already exists (use write to overwrite).";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly path: {
-                    readonly type: "string";
-                    readonly description: "Project-relative file path";
-                };
-                readonly content: {
-                    readonly type: "string";
-                    readonly description: "Initial file contents";
-                };
-            };
-            readonly required: readonly ["path", "content"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

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

@@ -1,56 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { resolveProjectPath } from '../../path-sandbox.js';
-import { asString } from '../args.js';
-import { fenceOptions } from '../fence.js';
-const invoke = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    const content = asString(args, 'content');
-    if (userPath === undefined || content === undefined) {
-        throw new Error('create requires string arguments «path» and «content».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    try {
-        await fs.access(absolute);
-        throw new Error(`create failed: «${userPath}» already exists. Use write to overwrite or choose another path.`);
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.startsWith('create failed:')) {
-            throw error;
-        }
-        const code = error !== null && typeof error === 'object' && 'code' in error
-            ? String(error.code)
-            : '';
-        if (code !== 'ENOENT') {
-            throw error;
-        }
-    }
-    await fs.mkdir(path.dirname(absolute), { recursive: true });
-    await fs.writeFile(absolute, content, { encoding: 'utf8', flag: 'wx' });
-    return `Created «${userPath}» (${content.length} chars).`;
-};
-export const createTool = {
-    id: 'create',
-    registration: {
-        toolId: 'create',
-        name: 'create',
-        description: 'Create a new file. Fails if the path already exists (use write to overwrite).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Project-relative file path',
-                },
-                content: {
-                    type: 'string',
-                    description: 'Initial file contents',
-                },
-            },
-            required: ['path', 'content'],
-            additionalProperties: false,
-        },
-    },
-    invoke,
-};

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

@@ -1,21 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const deleteTool: {
-    readonly id: "delete";
-    readonly registration: {
-        readonly toolId: "delete";
-        readonly name: "delete";
-        readonly description: "Delete a file under the project root.";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly path: {
-                    readonly type: "string";
-                    readonly description: "Project-relative file path";
-                };
-            };
-            readonly required: readonly ["path"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

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

@@ -1,44 +0,0 @@
-import fs from 'node:fs/promises';
-import { formatNotFound, resolveProjectPath } from '../../path-sandbox.js';
-import { asString } from '../args.js';
-import { fenceOptions } from '../fence.js';
-const invoke = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    if (userPath === undefined) {
-        throw new Error('delete requires string argument «path».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    try {
-        await fs.unlink(absolute);
-    }
-    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 `Deleted «${userPath}».`;
-};
-export const deleteTool = {
-    id: 'delete',
-    registration: {
-        toolId: 'delete',
-        name: 'delete',
-        description: 'Delete a file under the project root.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Project-relative file path',
-                },
-            },
-            required: ['path'],
-            additionalProperties: false,
-        },
-    },
-    invoke,
-};

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

@@ -1,29 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const editTool: {
-    readonly id: "edit";
-    readonly registration: {
-        readonly toolId: "edit";
-        readonly name: "edit";
-        readonly description: "Exact string replace in a file. Fails if oldString is missing or not unique.";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly path: {
-                    readonly type: "string";
-                    readonly description: "Project-relative file path";
-                };
-                readonly oldString: {
-                    readonly type: "string";
-                    readonly description: "Exact text to find";
-                };
-                readonly newString: {
-                    readonly type: "string";
-                    readonly description: "Replacement text";
-                };
-            };
-            readonly required: readonly ["path", "oldString", "newString"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly invoke: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-};

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

@@ -1,68 +0,0 @@
-import fs from 'node:fs/promises';
-import { formatNotFound, resolveProjectPath } from '../../path-sandbox.js';
-import { asString } from '../args.js';
-import { fenceOptions } from '../fence.js';
-const invoke = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    const oldString = asString(args, 'oldString');
-    const newString = asString(args, 'newString');
-    if (userPath === undefined ||
-        oldString === undefined ||
-        newString === undefined) {
-        throw new Error('edit requires string arguments «path», «oldString», and «newString».');
-    }
-    if (oldString.length === 0) {
-        throw new Error('edit «oldString» must not be empty.');
-    }
-    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;
-    }
-    const parts = content.split(oldString);
-    if (parts.length === 1) {
-        throw new Error(`edit: oldString not found in «${userPath}». Provide an exact unique match.`);
-    }
-    if (parts.length > 2) {
-        throw new Error(`edit: oldString matched ${parts.length - 1} times in «${userPath}». Provide a longer unique snippet.`);
-    }
-    await fs.writeFile(absolute, parts.join(newString), 'utf8');
-    return `Edited «${userPath}» (1 replacement).`;
-};
-export const editTool = {
-    id: 'edit',
-    registration: {
-        toolId: 'edit',
-        name: 'edit',
-        description: 'Exact string replace in a file. Fails if oldString is missing or not unique.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Project-relative file path',
-                },
-                oldString: {
-                    type: 'string',
-                    description: 'Exact text to find',
-                },
-                newString: {
-                    type: 'string',
-                    description: 'Replacement text',
-                },
-            },
-            required: ['path', 'oldString', 'newString'],
-            additionalProperties: false,
-        },
-    },
-    invoke,
-};

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

@@ -1,4 +0,0 @@
-import { type PathFenceOptions } from '../path-sandbox.js';
-import type { HandlerContext } from './types.js';
-export declare const fenceOptions: (ctx: HandlerContext) => PathFenceOptions;
-export declare const displayPath: (ctx: HandlerContext, absolute: string) => string;

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

@@ -1,6 +0,0 @@
-import { toHarnessDisplayPath, } from '../path-sandbox.js';
-export const fenceOptions = (ctx) => ({
-    denyPaths: ctx.denyPaths,
-    allowedRoots: ctx.allowedRoots,
-});
-export const displayPath = (ctx, absolute) => toHarnessDisplayPath(ctx.projectRoot, absolute, ctx.allowedRoots);

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

@@ -1,33 +0,0 @@
-import type { HandlerContext } from '../types.js';
-export declare const globTool: {
-    readonly id: "glob";
-    readonly registration: {
-        readonly toolId: "glob";
-        readonly name: "glob";
-        readonly description: "List files matching a glob under the project root (gitignore-aware by default). Optional postProcess.";
-        readonly inputSchema: {
-            readonly type: "object";
-            readonly properties: {
-                readonly pattern: {
-                    readonly type: "string";
-                    readonly description: "Glob pattern, e.g. **/*.ts";
-                };
-                readonly cwd: {
-                    readonly type: "string";
-                    readonly description: "Optional subdirectory relative to project root";
-                };
-                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/glob/tool.js

@@ -1,77 +0,0 @@
-import path from 'node:path';
-import { 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 { globToRegExp, walkFiles } from '../walk-files.js';
-const MAX_GLOB_MATCHES = 200;
-const invoke = async (ctx, args) => {
-    const pattern = asString(args, 'pattern');
-    if (pattern === undefined) {
-        throw new Error('glob requires string argument «pattern».');
-    }
-    const cwdArg = asString(args, 'cwd') ?? '.';
-    const respectGitignore = asBoolean(args, 'respectGitignore', true);
-    const searchRoot = resolveProjectPath(ctx.projectRoot, cwdArg, fenceOptions(ctx));
-    const fenceRoot = resolveFenceRoot(ctx.projectRoot, searchRoot, ctx.allowedRoots) ??
-        path.resolve(ctx.projectRoot);
-    const files = await walkFiles(fenceRoot, searchRoot, respectGitignore);
-    const regex = globToRegExp(pattern.replace(/\\/g, '/'));
-    const searchRel = path
-        .relative(fenceRoot, searchRoot)
-        .split(path.sep)
-        .join('/');
-    const cwdPrefix = searchRel === '' ? '' : `${searchRel.replace(/\/$/, '')}/`;
-    const matches = files
-        .filter((file) => {
-        const relativeToCwd = cwdPrefix
-            ? file.startsWith(cwdPrefix)
-                ? file.slice(cwdPrefix.length)
-                : null
-            : file;
-        return relativeToCwd !== null && regex.test(relativeToCwd);
-    })
-        .map((file) => displayPath(ctx, path.join(fenceRoot, file)))
-        .slice(0, MAX_GLOB_MATCHES + 1);
-    const truncated = matches.length > MAX_GLOB_MATCHES;
-    const listed = matches.slice(0, MAX_GLOB_MATCHES);
-    const body = listed.length === 0
-        ? '(no matches)'
-        : listed.join('\n') +
-            (truncated
-                ? `\n…[truncated at ${MAX_GLOB_MATCHES}; narrow the pattern]`
-                : '');
-    return applyPostProcess(args, body);
-};
-export const globTool = {
-    id: 'glob',
-    registration: {
-        toolId: 'glob',
-        name: 'glob',
-        description: 'List files matching a glob under the project root (gitignore-aware by default). Optional postProcess.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: 'Glob pattern, e.g. **/*.ts',
-                },
-                cwd: {
-                    type: 'string',
-                    description: 'Optional subdirectory relative to project root',
-                },
-                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/grep/search.d.ts

@@ -1,43 +0,0 @@
-import { type SpawnCaptureOptions, type SpawnCaptureResult } from '../spawn-capture.js';
-export declare const MAX_GREP_MATCHES = 100;
-type GrepHit = {
-    readonly file: string;
-    readonly line: number;
-    readonly text: string;
-};
-export type GrepSearchInput = {
-    readonly pattern: string;
-    readonly caseInsensitive: boolean;
-    readonly respectGitignore: boolean;
-    /** Absolute search file or directory (already fenced). */
-    readonly searchAbsolute: string;
-    /** Fence root for relative display paths. */
-    readonly fenceRoot: string;
-    readonly displayPath: (absolute: string) => string;
-    readonly signal?: AbortSignal;
-};
-export type GrepSearchDeps = {
-    readonly commandExists?: (cmd: string) => Promise<boolean>;
-    readonly spawnCapture?: (command: string, args: readonly string[], options?: SpawnCaptureOptions) => Promise<SpawnCaptureResult>;
-};
-type GrepSearchOutcome = {
-    readonly ok: true;
-    readonly hits: readonly GrepHit[];
-    readonly truncated: boolean;
-    readonly backend: 'rg' | 'grep' | 'node';
-} | {
-    readonly ok: false;
-    readonly reason: 'unavailable' | 'error';
-    readonly message: string;
-};
-export declare const searchWithNodeWalk: (input: GrepSearchInput) => Promise<GrepSearchOutcome>;
-/**
- * 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 declare const runGrepCascade: (input: GrepSearchInput, deps?: GrepSearchDeps) => Promise<{
-    readonly body: string;
-    readonly backend: "rg" | "grep" | "node";
-}>;
-export {};