@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/tools/grep.js

@@ -0,0 +1,422 @@
+import { createInterface } from "node:readline";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { spawn } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { minimatch } from "minimatch";
+import path from "path";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { ensureTool } from "../../utils/tools-manager.js";
+import { resolveToCwd } from "./path-utils.js";
+import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, formatSize, GREP_MAX_LINE_LENGTH, truncateHead, truncateLine, } from "./truncate.js";
+const grepSchema = Type.Object({
+    pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
+    path: Type.Optional(Type.String({ description: "Directory or file to search (default: current directory)" })),
+    glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" })),
+    ignoreCase: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+    literal: Type.Optional(Type.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })),
+    context: Type.Optional(Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
+});
+const DEFAULT_LIMIT = 100;
+const SKIP_DIRS = new Set([".git", "node_modules"]);
+const defaultGrepOperations = {
+    isDirectory: (p) => statSync(p).isDirectory(),
+    readFile: (p) => readFileSync(p, "utf-8"),
+};
+function toPosixPath(value) {
+    return value.split(path.sep).join("/");
+}
+function shouldIncludeByGlob(filePath, rootPath, glob) {
+    if (!glob)
+        return true;
+    const relative = toPosixPath(path.relative(rootPath, filePath));
+    return minimatch(relative, glob, { dot: true }) || minimatch(path.posix.basename(relative), glob, { dot: true });
+}
+function collectSearchFiles(searchPath, isDirectory, glob) {
+    if (!isDirectory)
+        return [searchPath];
+    const files = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory() && SKIP_DIRS.has(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.isFile() && shouldIncludeByGlob(fullPath, searchPath, glob)) {
+                files.push(fullPath);
+            }
+        }
+    };
+    walk(searchPath);
+    return files;
+}
+function compileSearchPattern(pattern, ignoreCase, literal) {
+    const flags = ignoreCase ? "i" : "";
+    if (literal) {
+        return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+    }
+    return new RegExp(pattern, flags);
+}
+function formatGrepCall(args, theme) {
+    const pattern = str(args?.pattern);
+    const rawPath = str(args?.path);
+    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
+    const glob = str(args?.glob);
+    const limit = args?.limit;
+    const invalidArg = invalidArgText(theme);
+    let text = theme.fg("toolTitle", theme.bold("grep")) +
+        " " +
+        (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) +
+        theme.fg("toolOutput", ` in ${path === null ? invalidArg : path}`);
+    if (glob)
+        text += theme.fg("toolOutput", ` (${glob})`);
+    if (limit !== undefined)
+        text += theme.fg("toolOutput", ` limit ${limit}`);
+    return text;
+}
+function formatGrepResult(result, options, theme, showImages) {
+    const output = getTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 15;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")})`;
+        }
+    }
+    const matchLimit = result.details?.matchLimitReached;
+    const truncation = result.details?.truncation;
+    const linesTruncated = result.details?.linesTruncated;
+    if (matchLimit || truncation?.truncated || linesTruncated) {
+        const warnings = [];
+        if (matchLimit)
+            warnings.push(`${matchLimit} matches limit`);
+        if (truncation?.truncated)
+            warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        if (linesTruncated)
+            warnings.push("some lines truncated");
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export function createGrepToolDefinition(cwd, options) {
+    const customOps = options?.operations;
+    return {
+        name: "grep",
+        label: "grep",
+        description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+        promptSnippet: "Search file contents for patterns (respects .gitignore)",
+        parameters: grepSchema,
+        async execute(_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit, }, signal, _onUpdate, _ctx) {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let settled = false;
+                const settle = (fn) => {
+                    if (!settled) {
+                        settled = true;
+                        fn();
+                    }
+                };
+                (async () => {
+                    try {
+                        const rgPath = await ensureTool("rg", true);
+                        const searchPath = resolveToCwd(searchDir || ".", cwd);
+                        const ops = customOps ?? defaultGrepOperations;
+                        let isDirectory;
+                        try {
+                            isDirectory = await ops.isDirectory(searchPath);
+                        }
+                        catch {
+                            settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+                            return;
+                        }
+                        const contextValue = context && context > 0 ? context : 0;
+                        const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
+                        const formatPath = (filePath) => {
+                            if (isDirectory) {
+                                const relative = path.relative(searchPath, filePath);
+                                if (relative && !relative.startsWith("..")) {
+                                    return relative.replace(/\\/g, "/");
+                                }
+                            }
+                            return path.basename(filePath);
+                        };
+                        const fileCache = new Map();
+                        const getFileLines = async (filePath) => {
+                            let lines = fileCache.get(filePath);
+                            if (!lines) {
+                                try {
+                                    const content = await ops.readFile(filePath);
+                                    lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+                                }
+                                catch {
+                                    lines = [];
+                                }
+                                fileCache.set(filePath, lines);
+                            }
+                            return lines;
+                        };
+                        const formatBlock = async (filePath, lineNumber) => {
+                            const relativePath = formatPath(filePath);
+                            const lines = await getFileLines(filePath);
+                            if (!lines.length)
+                                return [`${relativePath}:${lineNumber}: (unable to read file)`];
+                            const block = [];
+                            const start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber;
+                            const end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
+                            for (let current = start; current <= end; current++) {
+                                const lineText = lines[current - 1] ?? "";
+                                const sanitized = lineText.replace(/\r/g, "");
+                                const isMatchLine = current === lineNumber;
+                                // Truncate long lines so grep output stays compact.
+                                const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                                if (wasTruncated)
+                                    linesTruncated = true;
+                                if (isMatchLine)
+                                    block.push(`${relativePath}:${current}: ${truncatedText}`);
+                                else
+                                    block.push(`${relativePath}-${current}- ${truncatedText}`);
+                            }
+                            return block;
+                        };
+                        let matchCount = 0;
+                        let matchLimitReached = false;
+                        let linesTruncated = false;
+                        const outputLines = [];
+                        const finalizeMatches = () => {
+                            if (matchCount === 0) {
+                                settle(() => resolve({ content: [{ type: "text", text: "No matches found" }], details: undefined }));
+                                return;
+                            }
+                            const rawOutput = outputLines.join("\n");
+                            // Apply byte truncation. There is no line limit here because the match limit already capped rows.
+                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+                            let output = truncation.content;
+                            const details = {};
+                            // Build actionable notices for truncation and match limits.
+                            const notices = [];
+                            if (matchLimitReached) {
+                                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                                details.matchLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (linesTruncated) {
+                                notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
+                                details.linesTruncated = true;
+                            }
+                            if (notices.length > 0)
+                                output += `\n\n[${notices.join(". ")}]`;
+                            settle(() => resolve({
+                                content: [{ type: "text", text: output }],
+                                details: Object.keys(details).length > 0 ? details : undefined,
+                            }));
+                        };
+                        if (!rgPath) {
+                            if (!existsSync(searchPath)) {
+                                settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+                                return;
+                            }
+                            let regex;
+                            try {
+                                regex = compileSearchPattern(pattern, ignoreCase, literal);
+                            }
+                            catch (error) {
+                                settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+                                return;
+                            }
+                            const files = collectSearchFiles(searchPath, isDirectory, glob);
+                            for (const filePath of files) {
+                                if (signal?.aborted) {
+                                    settle(() => reject(new Error("Operation aborted")));
+                                    return;
+                                }
+                                const lines = await getFileLines(filePath);
+                                for (let i = 0; i < lines.length; i++) {
+                                    if (matchCount >= effectiveLimit)
+                                        break;
+                                    regex.lastIndex = 0;
+                                    if (!regex.test(lines[i] ?? ""))
+                                        continue;
+                                    matchCount++;
+                                    if (contextValue === 0) {
+                                        const relativePath = formatPath(filePath);
+                                        const sanitized = (lines[i] ?? "").replace(/\r/g, "");
+                                        const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                                        if (wasTruncated)
+                                            linesTruncated = true;
+                                        outputLines.push(`${relativePath}:${i + 1}: ${truncatedText}`);
+                                    }
+                                    else {
+                                        outputLines.push(...await formatBlock(filePath, i + 1));
+                                    }
+                                }
+                                if (matchCount >= effectiveLimit) {
+                                    matchLimitReached = true;
+                                    break;
+                                }
+                            }
+                            finalizeMatches();
+                            return;
+                        }
+                        const args = ["--json", "--line-number", "--color=never", "--hidden"];
+                        if (ignoreCase)
+                            args.push("--ignore-case");
+                        if (literal)
+                            args.push("--fixed-strings");
+                        if (glob)
+                            args.push("--glob", glob);
+                        args.push(pattern, searchPath);
+                        const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+                        const rl = createInterface({ input: child.stdout });
+                        let stderr = "";
+                        let aborted = false;
+                        let killedDueToLimit = false;
+                        const cleanup = () => {
+                            rl.close();
+                            signal?.removeEventListener("abort", onAbort);
+                        };
+                        const stopChild = (dueToLimit = false) => {
+                            if (!child.killed) {
+                                killedDueToLimit = dueToLimit;
+                                child.kill();
+                            }
+                        };
+                        const onAbort = () => {
+                            aborted = true;
+                            stopChild();
+                        };
+                        signal?.addEventListener("abort", onAbort, { once: true });
+                        child.stderr?.on("data", (chunk) => {
+                            stderr += chunk.toString();
+                        });
+                        // Collect matches during streaming, then format them after rg exits.
+                        const matches = [];
+                        rl.on("line", (line) => {
+                            if (!line.trim() || matchCount >= effectiveLimit)
+                                return;
+                            let event;
+                            try {
+                                event = JSON.parse(line);
+                            }
+                            catch {
+                                return;
+                            }
+                            if (event.type === "match") {
+                                matchCount++;
+                                const filePath = event.data?.path?.text;
+                                const lineNumber = event.data?.line_number;
+                                const lineText = event.data?.lines?.text;
+                                if (filePath && typeof lineNumber === "number")
+                                    matches.push({ filePath, lineNumber, lineText });
+                                if (matchCount >= effectiveLimit) {
+                                    matchLimitReached = true;
+                                    stopChild(true);
+                                }
+                            }
+                        });
+                        child.on("error", (error) => {
+                            cleanup();
+                            settle(() => reject(new Error(`Failed to run ripgrep: ${error.message}`)));
+                        });
+                        child.on("close", async (code) => {
+                            cleanup();
+                            if (aborted) {
+                                settle(() => reject(new Error("Operation aborted")));
+                                return;
+                            }
+                            if (!killedDueToLimit && code !== 0 && code !== 1) {
+                                const errorMsg = stderr.trim() || `ripgrep exited with code ${code}`;
+                                settle(() => reject(new Error(errorMsg)));
+                                return;
+                            }
+                            if (matchCount === 0) {
+                                settle(() => resolve({ content: [{ type: "text", text: "No matches found" }], details: undefined }));
+                                return;
+                            }
+                            // Format matches after streaming finishes so custom readFile() backends can be async.
+                            for (const match of matches) {
+                                if (contextValue === 0 && match.lineText !== undefined) {
+                                    const relativePath = formatPath(match.filePath);
+                                    const sanitized = match.lineText
+                                        .replace(/\r\n/g, "\n")
+                                        .replace(/\r/g, "")
+                                        .replace(/\n$/, "");
+                                    const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                                    if (wasTruncated)
+                                        linesTruncated = true;
+                                    outputLines.push(`${relativePath}:${match.lineNumber}: ${truncatedText}`);
+                                }
+                                else {
+                                    const block = await formatBlock(match.filePath, match.lineNumber);
+                                    outputLines.push(...block);
+                                }
+                            }
+                            const rawOutput = outputLines.join("\n");
+                            // Apply byte truncation. There is no line limit here because the match limit already capped rows.
+                            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+                            let output = truncation.content;
+                            const details = {};
+                            // Build actionable notices for truncation and match limits.
+                            const notices = [];
+                            if (matchLimitReached) {
+                                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                                details.matchLimitReached = effectiveLimit;
+                            }
+                            if (truncation.truncated) {
+                                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+                                details.truncation = truncation;
+                            }
+                            if (linesTruncated) {
+                                notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
+                                details.linesTruncated = true;
+                            }
+                            if (notices.length > 0)
+                                output += `\n\n[${notices.join(". ")}]`;
+                            settle(() => resolve({
+                                content: [{ type: "text", text: output }],
+                                details: Object.keys(details).length > 0 ? details : undefined,
+                            }));
+                        });
+                    }
+                    catch (err) {
+                        settle(() => reject(err));
+                    }
+                })();
+            });
+        },
+        renderCall(args, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatGrepCall(args, theme));
+            return text;
+        },
+        renderResult(result, options, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatGrepResult(result, options, theme, context.showImages));
+            return text;
+        },
+    };
+}
+export function createGrepTool(cwd, options) {
+    return wrapToolDefinition(createGrepToolDefinition(cwd, options));
+}

package/dist/core/tools/index.d.ts

@@ -0,0 +1,70 @@
+export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.js";
+export { createEditTool, createEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, } from "./edit.js";
+export { withFileMutationQueue } from "./file-mutation-queue.js";
+export { createFindTool, createFindToolDefinition, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, } from "./find.js";
+export { createGrepTool, createGrepToolDefinition, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, } from "./grep.js";
+export { createLsTool, createLsToolDefinition, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, } from "./ls.js";
+export { createReadTool, createReadToolDefinition, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, } from "./read.js";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
+export { createWriteTool, createWriteToolDefinition, type WriteOperations, type WriteToolInput, type WriteToolOptions, } from "./write.js";
+import type { AgentTool } from "../agent/types.js";
+import type { ToolDefinition } from "../extensions/types.js";
+import { type BashToolOptions } from "./bash.js";
+import { type EditToolOptions } from "./edit.js";
+import { type FindToolOptions } from "./find.js";
+import { type GrepToolOptions } from "./grep.js";
+import { type LsToolOptions } from "./ls.js";
+import { type ReadToolOptions } from "./read.js";
+import { type WriteToolOptions } from "./write.js";
+export type Tool = AgentTool<any>;
+export type ToolDef = ToolDefinition<any, any>;
+/**
+ * Default tools exposed to LLM via function calls.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, git, npm, etc.) are passed to the system shell.
+ */
+export type ToolName = "cli" | "bash" | "read" | "edit" | "write" | "grep" | "find" | "ls";
+export declare const allToolNames: Set<ToolName>;
+/**
+ * Default tools exposed via function calls.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, etc.) are passed to the system shell.
+ */
+export declare const DEFAULT_LLM_TOOLS: ToolName[];
+export interface ToolsOptions {
+    read?: ReadToolOptions;
+    cli?: BashToolOptions;
+    /** @deprecated Use cli. */
+    bash?: BashToolOptions;
+    write?: WriteToolOptions;
+    edit?: EditToolOptions;
+    grep?: GrepToolOptions;
+    find?: FindToolOptions;
+    ls?: LsToolOptions;
+}
+export declare function createToolDefinition(toolName: ToolName, cwd: string, options?: ToolsOptions): ToolDef;
+export declare function createTool(toolName: ToolName, cwd: string, options?: ToolsOptions): Tool;
+/**
+ * Default coding tools exposed via function calls.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, git, npm, etc.) are passed to the system shell.
+ */
+export declare function createCodingToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[];
+/**
+ * Read-only tools for analysis mode.
+ * Only cli is exposed; read is handled internally; grep/find/ls are passed to shell.
+ */
+export declare function createReadOnlyToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[];
+export declare function createAllToolDefinitions(cwd: string, options?: ToolsOptions): Record<ToolName, ToolDef>;
+/**
+ * Default coding tools exposed to LLM.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, git, npm, etc.) are passed to the system shell.
+ */
+export declare function createCodingTools(cwd: string, options?: ToolsOptions): Tool[];
+/**
+ * Read-only tools for analysis mode.
+ * Only cli is exposed; read is handled internally; grep/find/ls are passed to shell.
+ */
+export declare function createReadOnlyTools(cwd: string, options?: ToolsOptions): Tool[];
+export declare function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool>;

package/dist/core/tools/index.js

@@ -0,0 +1,129 @@
+export { createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.js";
+export { createEditTool, createEditToolDefinition, } from "./edit.js";
+export { withFileMutationQueue } from "./file-mutation-queue.js";
+export { createFindTool, createFindToolDefinition, } from "./find.js";
+export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
+export { createLsTool, createLsToolDefinition, } from "./ls.js";
+export { createReadTool, createReadToolDefinition, } from "./read.js";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
+export { createWriteTool, createWriteToolDefinition, } from "./write.js";
+import { createBashTool, createBashToolDefinition } from "./bash.js";
+import { createEditTool, createEditToolDefinition } from "./edit.js";
+import { createFindTool, createFindToolDefinition } from "./find.js";
+import { createGrepTool, createGrepToolDefinition } from "./grep.js";
+import { createLsTool, createLsToolDefinition } from "./ls.js";
+import { createReadTool, createReadToolDefinition } from "./read.js";
+import { createWriteTool, createWriteToolDefinition } from "./write.js";
+export const allToolNames = new Set(["read", "cli", "bash", "edit", "write", "grep", "find", "ls"]);
+/**
+ * Default tools exposed via function calls.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, etc.) are passed to the system shell.
+ */
+export const DEFAULT_LLM_TOOLS = ["cli"];
+export function createToolDefinition(toolName, cwd, options) {
+    switch (toolName) {
+        case "read":
+            return createReadToolDefinition(cwd, options?.read);
+        case "cli":
+        case "bash":
+            return createBashToolDefinition(cwd, options?.cli ?? options?.bash);
+        case "edit":
+            return createEditToolDefinition(cwd, options?.edit);
+        case "write":
+            return createWriteToolDefinition(cwd, options?.write);
+        case "grep":
+            return createGrepToolDefinition(cwd, options?.grep);
+        case "find":
+            return createFindToolDefinition(cwd, options?.find);
+        case "ls":
+            return createLsToolDefinition(cwd, options?.ls);
+        default:
+            throw new Error(`Unknown tool name: ${toolName}`);
+    }
+}
+export function createTool(toolName, cwd, options) {
+    switch (toolName) {
+        case "read":
+            return createReadTool(cwd, options?.read);
+        case "cli":
+        case "bash":
+            return createBashTool(cwd, options?.cli ?? options?.bash);
+        case "edit":
+            return createEditTool(cwd, options?.edit);
+        case "write":
+            return createWriteTool(cwd, options?.write);
+        case "grep":
+            return createGrepTool(cwd, options?.grep);
+        case "find":
+            return createFindTool(cwd, options?.find);
+        case "ls":
+            return createLsTool(cwd, options?.ls);
+        default:
+            throw new Error(`Unknown tool name: ${toolName}`);
+    }
+}
+/**
+ * Default coding tools exposed via function calls.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, git, npm, etc.) are passed to the system shell.
+ */
+export function createCodingToolDefinitions(cwd, options) {
+    return [
+        createBashToolDefinition(cwd, options?.cli ?? options?.bash),
+    ];
+}
+/**
+ * Read-only tools for analysis mode.
+ * Only cli is exposed; read is handled internally; grep/find/ls are passed to shell.
+ */
+export function createReadOnlyToolDefinitions(cwd, options) {
+    return [
+        createBashToolDefinition(cwd, options?.cli ?? options?.bash),
+    ];
+}
+export function createAllToolDefinitions(cwd, options) {
+    const cliDefinition = createBashToolDefinition(cwd, options?.cli ?? options?.bash);
+    return {
+        read: createReadToolDefinition(cwd, options?.read),
+        cli: cliDefinition,
+        bash: cliDefinition,
+        edit: createEditToolDefinition(cwd, options?.edit),
+        write: createWriteToolDefinition(cwd, options?.write),
+        grep: createGrepToolDefinition(cwd, options?.grep),
+        find: createFindToolDefinition(cwd, options?.find),
+        ls: createLsToolDefinition(cwd, options?.ls),
+    };
+}
+/**
+ * Default coding tools exposed to LLM.
+ * Only cli is exposed; read/write/edit are handled internally by the cli tool.
+ * Other commands (grep, find, ls, git, npm, etc.) are passed to the system shell.
+ */
+export function createCodingTools(cwd, options) {
+    return [
+        createBashTool(cwd, options?.cli ?? options?.bash),
+    ];
+}
+/**
+ * Read-only tools for analysis mode.
+ * Only cli is exposed; read is handled internally; grep/find/ls are passed to shell.
+ */
+export function createReadOnlyTools(cwd, options) {
+    return [
+        createBashTool(cwd, options?.cli ?? options?.bash),
+    ];
+}
+export function createAllTools(cwd, options) {
+    const cliTool = createBashTool(cwd, options?.cli ?? options?.bash);
+    return {
+        read: createReadTool(cwd, options?.read),
+        cli: cliTool,
+        bash: cliTool,
+        edit: createEditTool(cwd, options?.edit),
+        write: createWriteTool(cwd, options?.write),
+        grep: createGrepTool(cwd, options?.grep),
+        find: createFindTool(cwd, options?.find),
+        ls: createLsTool(cwd, options?.ls),
+    };
+}

package/dist/core/tools/line-anchors.d.ts

@@ -0,0 +1,33 @@
+export interface LineAnchor {
+    line: number;
+    hash: string;
+}
+export interface RangeAnchor {
+    start: LineAnchor;
+    end: LineAnchor;
+}
+export interface LineRecord {
+    lineNumber: number;
+    text: string;
+    startIndex: number;
+    contentEndIndex: number;
+    replacementEndIndex: number;
+    hash: string;
+}
+export interface ResolvedLineRange {
+    range: string;
+    startLine: number;
+    endLine: number;
+    startIndex: number;
+    endIndex: number;
+    existingText: string;
+    usedRelocation: boolean;
+}
+export declare function hashLine(line: string): string;
+export declare function formatLineAnchor(lineNumber: number, line: string): string;
+export declare function formatRange(start: LineAnchor, end?: LineAnchor): string;
+export declare function looksLikeRange(value: string): boolean;
+export declare function parseRange(range: string): RangeAnchor;
+export declare function buildLineRecords(content: string): LineRecord[];
+export declare function annotateTextWithLineAnchors(text: string, startLine?: number): string;
+export declare function resolveRange(content: string, range: string, path: string): ResolvedLineRange;