openhorse 0.1.5

package/dist/tools/index.js

@@ -0,0 +1,965 @@
+"use strict";
+/**
+ * openhorse - 工具集
+ *
+ * 定义 Agent 可用的工具（Tool System v2）：
+ *   - read_file: 读取文件内容
+ *   - write_file: 写入文件
+ *   - list_files: 列出目录
+ *   - exec_command: 执行 shell 命令
+ *
+ * 使用 buildTool() 工厂模式。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SANDBOX_OPTIONS = exports.wrapForSandbox = exports.assessCommandSecurity = exports.isPotentiallyDestructive = exports.checkDangerousCommand = exports.isReadOnlyCommand = exports.POTENTIALLY_DESTRUCTIVE_PATTERNS = exports.DANGEROUS_PATTERNS = exports.READ_ONLY_COMMANDS = exports.TOOLS = void 0;
+exports.executeTool = executeTool;
+exports.getToolNames = getToolNames;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const readline_1 = require("readline");
+const tool_1 = require("../framework/tool");
+const memory_1 = require("../memory");
+const semantic_search_1 = require("../memory/semantic-search");
+const session_storage_1 = require("../services/session-storage");
+const web_1 = require("./web");
+const mcp_1 = require("./mcp");
+const todo_1 = require("./todo");
+const plan_1 = require("./plan");
+const bash_security_1 = require("./bash_security");
+// ============================================================================
+// 工具集
+// ============================================================================
+exports.TOOLS = [
+    // Web tools (P0)
+    ...web_1.WEB_TOOLS,
+    // MCP tools (P0)
+    ...mcp_1.MCP_TOOLS,
+    // Todo tools (P1)
+    ...todo_1.TODO_TOOLS,
+    // Plan mode tools (P1)
+    ...plan_1.PLAN_TOOLS,
+    // File tools
+    (0, tool_1.buildTool)({
+        name: 'read_file',
+        description: '读取文件的全部内容。返回文件内容字符串。',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: '文件路径（绝对路径或相对路径）',
+                },
+                maxLines: {
+                    type: 'number',
+                    description: '最大读取行数（可选，默认 500 行）',
+                },
+            },
+            required: ['path'],
+        },
+        execute: async (args) => {
+            // Ensure path is a valid string
+            const path = args.path;
+            if (!path || typeof path !== 'string') {
+                return { success: false, output: '', error: 'read_file requires a path parameter' };
+            }
+            return readFileSync_(path, args.maxLines);
+        },
+        isReadOnly: () => true,
+        userFacingName: (args) => `Read ${args.path}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'write_file',
+        description: '将内容写入文件。如果文件不存在则创建，存在则覆盖。',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: '文件路径（绝对路径或相对路径）',
+                },
+                content: {
+                    type: 'string',
+                    description: '要写入的文件内容',
+                },
+            },
+            required: ['path', 'content'],
+        },
+        execute: async (args) => {
+            // Ensure path and content are valid strings
+            const path = args.path;
+            const content = args.content;
+            if (!path || typeof path !== 'string') {
+                return { success: false, output: '', error: 'write_file requires a path parameter' };
+            }
+            if (!content || typeof content !== 'string') {
+                return { success: false, output: '', error: 'write_file requires a content parameter' };
+            }
+            return writeFileSync_(path, content);
+        },
+        isDestructive: () => true,
+        checkPermissions: (args, context) => {
+            // Destructive operation - ask for confirmation in default mode
+            return { behavior: 'ask', reason: 'Write operation may modify existing files' };
+        },
+        userFacingName: (args) => `Write ${args.path}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'list_files',
+        description: '列出指定目录中的文件和子目录。支持控制递归深度。',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: '目录路径（绝对路径或相对路径）',
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: '最大递归深度（可选，默认 2）',
+                },
+            },
+            required: ['path'],
+        },
+        execute: async (args) => {
+            // Ensure path is a valid string
+            const path = args.path;
+            if (!path || typeof path !== 'string') {
+                return { success: false, output: '', error: 'list_files requires a path parameter' };
+            }
+            return listFiles_(path, args.maxDepth);
+        },
+        isReadOnly: () => true,
+        isConcurrencySafe: () => true,
+        userFacingName: (args) => `List ${args.path}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'exec_command',
+        description: '执行一个 shell 命令。返回 stdout 和 stderr。',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: '要执行的 shell 命令',
+                },
+                cwd: {
+                    type: 'string',
+                    description: '工作目录（可选，默认当前目录）',
+                },
+                timeout: {
+                    type: 'number',
+                    description: '超时时间 ms（可选，默认 30000）',
+                },
+            },
+            required: ['command'],
+        },
+        execute: async (args) => {
+            // Ensure command is a valid string
+            const command = args.command;
+            if (!command || typeof command !== 'string') {
+                return { success: false, output: '', error: 'exec_command requires a command parameter' };
+            }
+            return execCommand_(command, args.cwd, args.timeout);
+        },
+        isDestructive: (args) => {
+            const cmd = args.command || '';
+            return /(rm\s+-rf|mkfs|dd\s)/.test(cmd);
+        },
+        checkPermissions: (args, context) => {
+            const cmd = args.command || '';
+            // Use the bash_security module for comprehensive checks
+            const security = (0, bash_security_1.assessCommandSecurity)(cmd);
+            if (security.level === 'blocked') {
+                return { behavior: 'deny', reason: security.reason || `Command blocked by safety policy: ${cmd.slice(0, 50)}` };
+            }
+            if (security.level === 'safe' && security.isReadOnly) {
+                return { behavior: 'allow' };
+            }
+            if (security.level === 'caution') {
+                return { behavior: 'ask', reason: security.reason || 'Command requires confirmation' };
+            }
+            // Default: ask for confirmation
+            return { behavior: 'ask', reason: 'Command requires confirmation' };
+        },
+        isReadOnly: (args) => {
+            const cmd = args.command || '';
+            return (0, bash_security_1.isReadOnlyCommand)(cmd);
+        },
+        userFacingName: (args) => `Exec ${args.command?.slice(0, 60) || ''}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'edit_file',
+        description: '对文件进行精确字符串替换。old_string 必须在文件中唯一匹配，否则拒绝执行。使用 replace_all 可替换所有匹配。',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: '文件路径（绝对路径或相对路径）',
+                },
+                old_string: {
+                    type: 'string',
+                    description: '要替换的字符串（必须精确匹配）',
+                },
+                new_string: {
+                    type: 'string',
+                    description: '替换后的字符串',
+                },
+                replace_all: {
+                    type: 'boolean',
+                    description: '是否替换所有匹配（可选，默认 false）',
+                },
+            },
+            required: ['path', 'old_string', 'new_string'],
+        },
+        execute: async (args) => {
+            // Ensure required parameters are valid strings
+            const path = args.path;
+            const old_string = args.old_string;
+            const new_string = args.new_string;
+            if (!path || typeof path !== 'string') {
+                return { success: false, output: '', error: 'edit_file requires a path parameter' };
+            }
+            if (!old_string || typeof old_string !== 'string') {
+                return { success: false, output: '', error: 'edit_file requires an old_string parameter' };
+            }
+            if (!new_string || typeof new_string !== 'string') {
+                return { success: false, output: '', error: 'edit_file requires a new_string parameter' };
+            }
+            return editFile_(path, old_string, new_string, args.replace_all);
+        },
+        isDestructive: () => true,
+        checkPermissions: (args, context) => {
+            return { behavior: 'ask', reason: 'Edit operation modifies file contents' };
+        },
+        userFacingName: (args) => `Edit ${args.path}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'glob',
+        description: '使用 glob 模式搜索文件。支持 **（递归）、*（任意字符）、?（单个字符）等通配符。',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'Glob 模式（如 **/*.ts, src/**/*.js）',
+                },
+                path: {
+                    type: 'string',
+                    description: '搜索起始目录（可选，默认当前目录）',
+                },
+            },
+            required: ['pattern'],
+        },
+        execute: async (args) => {
+            // Ensure pattern is a valid string
+            const pattern = args.pattern;
+            if (!pattern || typeof pattern !== 'string') {
+                return { success: false, output: '', error: 'glob requires a pattern parameter' };
+            }
+            return glob_(pattern, args.path);
+        },
+        isReadOnly: () => true,
+        isConcurrencySafe: () => true,
+        userFacingName: (args) => `Glob ${args.pattern}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'grep',
+        description: '在文件中搜索正则表达式模式。返回匹配的文件路径和行内容。',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: '正则表达式模式',
+                },
+                path: {
+                    type: 'string',
+                    description: '搜索路径（可选，默认当前目录）',
+                },
+                glob: {
+                    type: 'string',
+                    description: '文件过滤模式（可选，如 *.ts）',
+                },
+                context: {
+                    type: 'number',
+                    description: '上下文行数（可选，默认 0）',
+                },
+            },
+            required: ['pattern'],
+        },
+        execute: async (args) => {
+            // Ensure pattern is a valid string
+            const pattern = args.pattern;
+            if (!pattern || typeof pattern !== 'string') {
+                return { success: false, output: '', error: 'grep requires a pattern parameter' };
+            }
+            return grep_(pattern, args.path, args.glob, args.context);
+        },
+        isReadOnly: () => true,
+        isConcurrencySafe: () => true,
+        userFacingName: (args) => `Grep ${args.pattern}`,
+    }),
+    // Memory tools
+    (0, tool_1.buildTool)({
+        name: 'memory_save',
+        description: 'Save a memory entry to the persistent memory system. Memories help tailor behavior to user preferences.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Memory name (kebab-case, e.g., "user-role", "feedback-style")',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['user', 'feedback', 'project', 'reference'],
+                    description: 'Memory type',
+                },
+                description: {
+                    type: 'string',
+                    description: 'One-line description for memory index',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Memory content. For feedback/project: use rule + Why + How to apply structure',
+                },
+            },
+            required: ['name', 'type', 'content'],
+        },
+        execute: async (args) => {
+            const name = args.name;
+            const type = args.type;
+            const content = args.content;
+            const description = args.description || content.slice(0, 80);
+            if (!name || typeof name !== 'string') {
+                return { success: false, output: '', error: 'memory_save requires a name parameter' };
+            }
+            if (!type || !['user', 'feedback', 'project', 'reference'].includes(type)) {
+                return { success: false, output: '', error: 'memory_save requires a valid type: user, feedback, project, or reference' };
+            }
+            if (!content || typeof content !== 'string') {
+                return { success: false, output: '', error: 'memory_save requires a content parameter' };
+            }
+            try {
+                const projectPath = process.cwd();
+                const entry = {
+                    name,
+                    type,
+                    description,
+                    content,
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                };
+                if ((0, semantic_search_1.isSemanticEnabled)()) {
+                    // saveAndIndex internally calls saveMemory + vectorStore.upsert
+                    await (0, semantic_search_1.getSemanticSearchService)().saveAndIndex(entry, projectPath);
+                }
+                else {
+                    (0, memory_1.saveMemory)(entry, projectPath);
+                }
+                return { success: true, output: `Saved memory: ${name} (${type})` };
+            }
+            catch (err) {
+                return { success: false, output: '', error: err.message };
+            }
+        },
+        isReadOnly: () => false,
+        userFacingName: (args) => `Memory save ${args.name}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'memory_recall',
+        description: 'Recall memories from the memory system. Returns matching memories or all if no query.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query (optional, returns all if empty)',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['user', 'feedback', 'project', 'reference'],
+                    description: 'Filter by memory type (optional)',
+                },
+            },
+            required: [],
+        },
+        execute: async (args) => {
+            try {
+                const projectPath = process.cwd();
+                const query = args.query || '';
+                const type = args.type;
+                let memories;
+                if (query && (0, semantic_search_1.isSemanticEnabled)()) {
+                    // Semantic path: ask the vector store, then fall back to keywords if it
+                    // returns nothing (e.g. embedding provider unreachable, empty index)
+                    try {
+                        const result = await (0, semantic_search_1.getSemanticSearchService)().search({
+                            query,
+                            projectPath,
+                            type,
+                        });
+                        memories = result.memories.map(m => ({
+                            name: m.name,
+                            type: m.type,
+                            description: m.description,
+                            content: m.content,
+                            createdAt: m.createdAt,
+                            updatedAt: m.createdAt,
+                        }));
+                        if (memories.length === 0) {
+                            memories = (0, memory_1.searchMemories)(query, projectPath);
+                            if (type)
+                                memories = memories.filter(m => m.type === type);
+                        }
+                    }
+                    catch {
+                        memories = (0, memory_1.searchMemories)(query, projectPath);
+                        if (type)
+                            memories = memories.filter(m => m.type === type);
+                    }
+                }
+                else if (type) {
+                    memories = (0, memory_1.loadAllMemories)(projectPath).filter(m => m.type === type);
+                }
+                else if (query) {
+                    memories = (0, memory_1.searchMemories)(query, projectPath);
+                }
+                else {
+                    memories = (0, memory_1.loadAllMemories)(projectPath);
+                }
+                if (memories.length === 0) {
+                    return { success: true, output: 'No memories found' };
+                }
+                const lines = [];
+                for (const mem of memories) {
+                    lines.push(`## ${mem.name} (${mem.type})`);
+                    lines.push(mem.description);
+                    lines.push(mem.content);
+                    lines.push('');
+                }
+                return { success: true, output: lines.join('\n') };
+            }
+            catch (err) {
+                return { success: false, output: '', error: err.message };
+            }
+        },
+        isReadOnly: () => true,
+        userFacingName: (args) => `Memory recall ${args.query || 'all'}`,
+    }),
+    (0, tool_1.buildTool)({
+        name: 'memory_forget',
+        description: 'Delete a memory entry from the memory system.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Memory name to delete',
+                },
+            },
+            required: ['name'],
+        },
+        execute: async (args) => {
+            const name = args.name;
+            if (!name || typeof name !== 'string') {
+                return { success: false, output: '', error: 'memory_forget requires a name parameter' };
+            }
+            try {
+                const projectPath = process.cwd();
+                const existing = (0, memory_1.loadMemory)(name, projectPath);
+                if (!existing) {
+                    return { success: false, output: '', error: `Memory not found: ${name}` };
+                }
+                (0, memory_1.deleteMemory)(name, projectPath);
+                if ((0, semantic_search_1.isSemanticEnabled)()) {
+                    try {
+                        const { getVectorStore } = require('../memory/vector-store');
+                        getVectorStore().delete(name);
+                    }
+                    catch {
+                        // Vector store cleanup is best-effort
+                    }
+                }
+                return { success: true, output: `Deleted memory: ${name}` };
+            }
+            catch (err) {
+                return { success: false, output: '', error: err.message };
+            }
+        },
+        isReadOnly: () => false,
+        userFacingName: (args) => `Memory forget ${args.name}`,
+    }),
+    // History search tool
+    (0, tool_1.buildTool)({
+        name: 'history_search',
+        description: 'Search previous tool operations in current or past sessions. Helps find what was done before.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query (tool name, file path, keyword)',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID to search (optional, defaults to searching recent sessions)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results (optional, default 10)',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (args) => {
+            const query = args.query;
+            if (!query || typeof query !== 'string') {
+                return { success: false, output: '', error: 'history_search requires a query parameter' };
+            }
+            try {
+                const limit = args.limit || 10;
+                const sessionId = args.sessionId;
+                // If sessionId provided, search that session; otherwise search all recent sessions
+                const sessions = sessionId
+                    ? [(0, session_storage_1.loadSessionMeta)(sessionId)].filter(Boolean)
+                    : (0, session_storage_1.listSessions)(5);
+                const results = [];
+                for (const session of sessions) {
+                    if (!session)
+                        continue;
+                    const messages = (0, session_storage_1.readSessionMessages)(session.id);
+                    // Search through messages for tool calls matching query
+                    for (let i = 0; i < messages.length; i++) {
+                        const msg = messages[i];
+                        if (msg.role === 'assistant' && msg.tool_calls) {
+                            for (const tc of msg.tool_calls) {
+                                // Match tool name or arguments content
+                                const matchesQuery = tc.function.name.toLowerCase().includes(query.toLowerCase()) ||
+                                    tc.function.arguments.toLowerCase().includes(query.toLowerCase());
+                                if (matchesQuery) {
+                                    // Find corresponding tool result
+                                    const nextMsg = messages[i + 1];
+                                    const resultPreview = nextMsg?.role === 'tool' && nextMsg.toolCallId === tc.id
+                                        ? nextMsg.content.slice(0, 200)
+                                        : '(no result)';
+                                    results.push({
+                                        sessionId: session.id.slice(0, 8),
+                                        tool: tc.function.name,
+                                        args: tc.function.arguments.slice(0, 100),
+                                        resultPreview,
+                                        timestamp: msg.timestamp,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                // Sort by timestamp (newest first) and limit
+                results.sort((a, b) => b.timestamp - a.timestamp);
+                const limited = results.slice(0, limit);
+                if (limited.length === 0) {
+                    return { success: true, output: 'No matching tool operations found' };
+                }
+                const lines = [];
+                lines.push(`Found ${limited.length} matching operations:`);
+                lines.push('');
+                for (const r of limited) {
+                    lines.push(`Session ${r.sessionId}: ${r.tool}`);
+                    lines.push(`  Args: ${r.args}`);
+                    lines.push(`  Result: ${r.resultPreview.slice(0, 100)}...`);
+                    lines.push('');
+                }
+                return { success: true, output: lines.join('\n') };
+            }
+            catch (err) {
+                return { success: false, output: '', error: err.message };
+            }
+        },
+        isReadOnly: () => true,
+        userFacingName: (args) => `History search ${args.query}`,
+    }),
+];
+// ============================================================================
+// 工具实现
+// ============================================================================
+/** 安全路径解析 — 防止路径遍历攻击 */
+function safePath(input) {
+    const resolved = (0, path_1.resolve)(input);
+    const cwd = process.cwd();
+    if ((0, path_1.relative)(cwd, resolved).startsWith('..')) {
+        return cwd;
+    }
+    return resolved;
+}
+async function readFileSync_(path, maxLines) {
+    try {
+        const resolved = safePath(path);
+        if (!(0, fs_1.existsSync)(resolved)) {
+            return { success: false, output: '', error: `File not found: ${path}` };
+        }
+        if ((0, fs_1.statSync)(resolved).isDirectory()) {
+            return { success: false, output: '', error: `Path is a directory, not a file: ${path}` };
+        }
+        const content = (0, fs_1.readFileSync)(resolved, 'utf-8');
+        const lines = content.split('\n');
+        const limit = maxLines ?? 500;
+        if (lines.length > limit) {
+            return {
+                success: true,
+                output: lines.slice(0, limit).join('\n') + `\n\n[... truncated, ${lines.length - limit} more lines]`,
+            };
+        }
+        return { success: true, output: content };
+    }
+    catch (err) {
+        return { success: false, output: '', error: String(err.message) };
+    }
+}
+async function writeFileSync_(path, content) {
+    try {
+        const resolved = safePath(path);
+        (0, fs_1.writeFileSync)(resolved, content, 'utf-8');
+        return { success: true, output: `Wrote ${content.split('\n').length} lines to ${path}` };
+    }
+    catch (err) {
+        return { success: false, output: '', error: String(err.message) };
+    }
+}
+async function listFiles_(path, maxDepth) {
+    const resolved = safePath(path);
+    if (!(0, fs_1.existsSync)(resolved)) {
+        return { success: false, output: '', error: `Path not found: ${path}` };
+    }
+    if (!(0, fs_1.statSync)(resolved).isDirectory()) {
+        return { success: true, output: path };
+    }
+    const depth = maxDepth ?? 2;
+    const results = [];
+    function walk(dir, currentDepth, prefix) {
+        if (currentDepth > depth)
+            return;
+        try {
+            const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') && entry.name !== '.')
+                    continue;
+                const fullPath = (0, path_1.join)(dir, entry.name);
+                const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    results.push(`${relPath}/`);
+                    walk(fullPath, currentDepth + 1, relPath);
+                }
+                else {
+                    results.push(relPath);
+                }
+            }
+        }
+        catch {
+            // skip unreadable directories
+        }
+    }
+    walk(resolved, 1, '');
+    return { success: true, output: results.join('\n') };
+}
+async function execCommand_(command, cwd, timeout) {
+    return new Promise((resolve) => {
+        const workdir = cwd ? safePath(cwd) : process.cwd();
+        const timeoutMs = timeout ?? 30000;
+        (0, child_process_1.execFile)('sh', ['-c', command], {
+            cwd: workdir,
+            timeout: timeoutMs,
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            const output = stdout.toString().trim();
+            const errOutput = stderr.toString().trim();
+            if (error) {
+                resolve({
+                    success: false,
+                    output: output || errOutput,
+                    error: error.message || `Command exited with code ${error.code}`,
+                });
+            }
+            else {
+                resolve({
+                    success: true,
+                    output: output || '(no output)',
+                    error: errOutput || undefined,
+                });
+            }
+        });
+    });
+}
+async function editFile_(path, old_string, new_string, replace_all) {
+    try {
+        const resolved = safePath(path);
+        if (!(0, fs_1.existsSync)(resolved)) {
+            return { success: false, output: '', error: `File not found: ${path}` };
+        }
+        if ((0, fs_1.statSync)(resolved).isDirectory()) {
+            return { success: false, output: '', error: `Path is a directory, not a file: ${path}` };
+        }
+        const content = (0, fs_1.readFileSync)(resolved, 'utf-8');
+        // Check if old_string exists
+        const count = (content.match(new RegExp(escapeRegExp(old_string), 'g')) || []).length;
+        if (count === 0) {
+            return { success: false, output: '', error: `old_string not found in file: ${old_string.slice(0, 100)}...` };
+        }
+        // If not replace_all, require unique match
+        if (!replace_all && count > 1) {
+            return {
+                success: false,
+                output: '',
+                error: `old_string found ${count} times in file. Use replace_all=true to replace all occurrences, or provide a more specific string that matches exactly once.`,
+            };
+        }
+        // Perform replacement
+        let newContent;
+        if (replace_all) {
+            newContent = content.split(old_string).join(new_string);
+        }
+        else {
+            // Replace first occurrence only
+            const idx = content.indexOf(old_string);
+            newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
+        }
+        (0, fs_1.writeFileSync)(resolved, newContent, 'utf-8');
+        return {
+            success: true,
+            output: `Replaced ${count} occurrence(s) of old_string with new_string in ${path}`,
+        };
+    }
+    catch (err) {
+        return { success: false, output: '', error: String(err.message) };
+    }
+}
+/** Escape special regex characters for literal matching */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// ============================================================================
+// Glob/Grep 工具实现
+// ============================================================================
+/**
+ * Glob 模式匹配 - 简化版实现
+ * 支持: **（递归目录）、*（任意字符）、?（单个字符）
+ */
+async function glob_(pattern, basePath) {
+    try {
+        const base = basePath ? safePath(basePath) : process.cwd();
+        if (!(0, fs_1.existsSync)(base)) {
+            return { success: false, output: '', error: `Path not found: ${basePath}` };
+        }
+        if (!(0, fs_1.statSync)(base).isDirectory()) {
+            return { success: false, output: '', error: `Path is not a directory: ${basePath}` };
+        }
+        const results = [];
+        // Convert glob pattern to regex
+        function globToRegex(pat) {
+            // Use placeholders to avoid interference between replacements
+            let regex = pat;
+            // **/ at start - matches optional path (including empty)
+            regex = regex.replace(/^\*\*\//, '<<STARSTAR_SLASH_START>>');
+            // **/ in middle - matches any number of path segments
+            regex = regex.replace(/\*\*\//g, '<<STARSTAR_SLASH>>');
+            // standalone ** - matches anything
+            regex = regex.replace(/\*\*/g, '<<STARSTAR>>');
+            // escape dots
+            regex = regex.replace(/\./g, '\\.');
+            // * matches anything except /
+            regex = regex.replace(/\*/g, '[^/]*');
+            // ? matches single char except /
+            regex = regex.replace(/\?/g, '[^/]');
+            // Now restore ** placeholders
+            regex = regex.replace(/<<STARSTAR_SLASH_START>>/g, '(.*\\/)?');
+            regex = regex.replace(/<<STARSTAR_SLASH>>/g, '([^/]+\\/)*');
+            regex = regex.replace(/<<STARSTAR>>/g, '.*');
+            return new RegExp(`^${regex}$`);
+        }
+        const regex = globToRegex(pattern);
+        // Recursive walk
+        function walk(dir, prefix) {
+            try {
+                const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        walk((0, path_1.join)(dir, entry.name), relPath);
+                    }
+                    else {
+                        if (regex.test(relPath)) {
+                            results.push(relPath);
+                        }
+                    }
+                }
+            }
+            catch {
+                // skip unreadable directories
+            }
+        }
+        walk(base, '');
+        if (results.length === 0) {
+            return { success: true, output: 'No files found matching pattern' };
+        }
+        return { success: true, output: results.sort().join('\n') };
+    }
+    catch (err) {
+        return { success: false, output: '', error: String(err.message) };
+    }
+}
+/**
+ * Grep 搜索 - 在文件中搜索正则表达式
+ */
+async function grep_(pattern, basePath, globPattern, contextLines) {
+    try {
+        const base = basePath ? safePath(basePath) : process.cwd();
+        if (!(0, fs_1.existsSync)(base)) {
+            return { success: false, output: '', error: `Path not found: ${basePath}` };
+        }
+        const regex = new RegExp(pattern, 'g');
+        const context = contextLines ?? 0;
+        const results = [];
+        const maxResults = 100;
+        // Get list of files to search
+        const files = [];
+        function collectFiles(dir) {
+            try {
+                const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = (0, path_1.join)(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        collectFiles(fullPath);
+                    }
+                    else {
+                        // Check glob filter if provided
+                        if (globPattern) {
+                            const ext = (0, path_1.extname)(entry.name);
+                            if (!matchGlobSimple(entry.name, globPattern))
+                                continue;
+                        }
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // skip unreadable
+            }
+        }
+        function matchGlobSimple(name, pat) {
+            const regex = pat.replace(/\*/g, '.*').replace(/\?/g, '.').replace(/\./g, '\\.');
+            return new RegExp(`^${regex}$`).test(name);
+        }
+        if ((0, fs_1.statSync)(base).isDirectory()) {
+            collectFiles(base);
+        }
+        else {
+            files.push(base);
+        }
+        // Search each file
+        for (const file of files) {
+            if (results.length >= maxResults)
+                break;
+            try {
+                const rl = (0, readline_1.createInterface)({
+                    input: (0, fs_1.createReadStream)(file, { encoding: 'utf-8' }),
+                    crlfDelay: Infinity,
+                });
+                const lines = [];
+                const relPath = (0, path_1.relative)(base, file);
+                rl.on('line', (line) => {
+                    lines.push(line);
+                });
+                await new Promise((resolve) => {
+                    rl.on('close', resolve);
+                });
+                // Search for matches
+                for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+                    if (regex.test(lines[i])) {
+                        // Format: file:line:content
+                        const start = Math.max(0, i - context);
+                        const end = Math.min(lines.length - 1, i + context);
+                        if (context > 0) {
+                            results.push(`${relPath}:${i + 1}:`);
+                            for (let j = start; j <= end; j++) {
+                                const prefix = j === i ? '>' : ' ';
+                                results.push(`  ${prefix}${j + 1}: ${lines[j]}`);
+                            }
+                            results.push('');
+                        }
+                        else {
+                            results.push(`${relPath}:${i + 1}: ${lines[i]}`);
+                        }
+                    }
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+        if (results.length === 0) {
+            return { success: true, output: 'No matches found' };
+        }
+        return { success: true, output: results.slice(0, maxResults).join('\n') };
+    }
+    catch (err) {
+        return { success: false, output: '', error: String(err.message) };
+    }
+}
+// ============================================================================
+// 统一执行入口
+// ============================================================================
+/**
+ * 执行一个工具调用，返回结构化结果字符串
+ */
+async function executeTool(name, args) {
+    const tool = exports.TOOLS.find(t => t.name === name);
+    if (!tool) {
+        return JSON.stringify({
+            success: false,
+            error: `Unknown tool: ${name}. Available tools: ${exports.TOOLS.map(t => t.name).join(', ')}`,
+        });
+    }
+    const context = {
+        cwd: process.cwd(),
+        config: {
+            name: 'openhorse',
+            mode: 'development',
+        },
+    };
+    const result = await tool.execute(args, context);
+    if (!result.success) {
+        return JSON.stringify({
+            success: false,
+            error: result.error,
+            output: result.output,
+        });
+    }
+    return JSON.stringify({
+        success: true,
+        output: result.output,
+    });
+}
+/**
+ * 获取可用工具名称列表
+ */
+function getToolNames() {
+    return exports.TOOLS.map(t => t.name).join(', ');
+}
+// Re-export bash_security module
+var bash_security_2 = require("./bash_security");
+Object.defineProperty(exports, "READ_ONLY_COMMANDS", { enumerable: true, get: function () { return bash_security_2.READ_ONLY_COMMANDS; } });
+Object.defineProperty(exports, "DANGEROUS_PATTERNS", { enumerable: true, get: function () { return bash_security_2.DANGEROUS_PATTERNS; } });
+Object.defineProperty(exports, "POTENTIALLY_DESTRUCTIVE_PATTERNS", { enumerable: true, get: function () { return bash_security_2.POTENTIALLY_DESTRUCTIVE_PATTERNS; } });
+Object.defineProperty(exports, "isReadOnlyCommand", { enumerable: true, get: function () { return bash_security_2.isReadOnlyCommand; } });
+Object.defineProperty(exports, "checkDangerousCommand", { enumerable: true, get: function () { return bash_security_2.checkDangerousCommand; } });
+Object.defineProperty(exports, "isPotentiallyDestructive", { enumerable: true, get: function () { return bash_security_2.isPotentiallyDestructive; } });
+Object.defineProperty(exports, "assessCommandSecurity", { enumerable: true, get: function () { return bash_security_2.assessCommandSecurity; } });
+Object.defineProperty(exports, "wrapForSandbox", { enumerable: true, get: function () { return bash_security_2.wrapForSandbox; } });
+Object.defineProperty(exports, "DEFAULT_SANDBOX_OPTIONS", { enumerable: true, get: function () { return bash_security_2.DEFAULT_SANDBOX_OPTIONS; } });
+//# sourceMappingURL=index.js.map