langmart-gateway-type3 3.0.0

package/dist/core-tools.js

@@ -0,0 +1,694 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreTools = void 0;
+const debug_utils_1 = require("./debug-utils");
+/**
+ * Core Tools for Gateway Type 3 CLI
+ * Provides file system operations, command execution, and web capabilities
+ * Based on Claude Code tool specifications
+ */
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = require("fs/promises");
+const glob_1 = require("glob");
+const chalk_1 = __importDefault(require("chalk"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class CoreTools {
+    constructor() {
+        this.backgroundProcesses = new Map();
+        this.fileReadHistory = new Set();
+    }
+    static getInstance() {
+        if (!CoreTools.instance) {
+            CoreTools.instance = new CoreTools();
+        }
+        return CoreTools.instance;
+    }
+    /**
+     * Get all available tools organized by category
+     */
+    getTools() {
+        return [
+            // Core Tools - File System Operations
+            {
+                name: 'core.read',
+                description: 'Read files from the filesystem',
+                category: 'core',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file_path: {
+                            type: 'string',
+                            description: 'Absolute path to the file to read'
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Line number to start reading from (optional)'
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Number of lines to read (optional, default: 2000)'
+                        }
+                    },
+                    required: ['file_path']
+                }
+            },
+            {
+                name: 'core.write',
+                description: 'Write new files or overwrite existing ones',
+                category: 'core',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file_path: {
+                            type: 'string',
+                            description: 'Absolute path to the file to write (not relative)'
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Full file content to write'
+                        }
+                    },
+                    required: ['file_path', 'content']
+                }
+            },
+            {
+                name: 'core.edit',
+                description: 'Perform exact string replacements in files',
+                category: 'core',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file_path: {
+                            type: 'string',
+                            description: 'Absolute path to the file to edit'
+                        },
+                        old_string: {
+                            type: 'string',
+                            description: 'The exact string to find and replace'
+                        },
+                        new_string: {
+                            type: 'string',
+                            description: 'The string to replace it with (must be different)'
+                        },
+                        replace_all: {
+                            type: 'boolean',
+                            description: 'Replace all occurrences (default: false)'
+                        }
+                    },
+                    required: ['file_path', 'old_string', 'new_string']
+                }
+            },
+            {
+                name: 'core.glob',
+                description: 'Find files using glob patterns (e.g., **/*.ts)',
+                category: 'core',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'
+                        },
+                        path: {
+                            type: 'string',
+                            description: 'Directory to search in (defaults to current working directory)'
+                        }
+                    },
+                    required: ['pattern']
+                }
+            },
+            {
+                name: 'core.grep',
+                description: 'Search file contents using regex patterns',
+                category: 'core',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'Regular expression pattern to search for'
+                        },
+                        path: {
+                            type: 'string',
+                            description: 'File or directory to search in (default: current directory)'
+                        },
+                        output_mode: {
+                            type: 'string',
+                            enum: ['content', 'files_with_matches', 'count'],
+                            description: 'Output mode: "content" shows lines, "files_with_matches" shows paths (default), "count" shows match counts'
+                        },
+                        glob: {
+                            type: 'string',
+                            description: 'Filter files with glob pattern (e.g., "*.js")'
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'File type filter (e.g., "js", "py", "rust")'
+                        },
+                        '-i': {
+                            type: 'boolean',
+                            description: 'Case insensitive search'
+                        },
+                        '-n': {
+                            type: 'boolean',
+                            description: 'Show line numbers (requires output_mode: "content")'
+                        },
+                        '-A': {
+                            type: 'number',
+                            description: 'Lines of context after match (requires output_mode: "content")'
+                        },
+                        '-B': {
+                            type: 'number',
+                            description: 'Lines of context before match (requires output_mode: "content")'
+                        },
+                        '-C': {
+                            type: 'number',
+                            description: 'Lines of context before AND after (requires output_mode: "content")'
+                        },
+                        head_limit: {
+                            type: 'number',
+                            description: 'Limit output to first N results'
+                        },
+                        multiline: {
+                            type: 'boolean',
+                            description: 'Enable multiline matching (default: false)'
+                        }
+                    },
+                    required: ['pattern']
+                }
+            },
+            // Execution Tools
+            {
+                name: 'exec.bash',
+                description: 'Execute bash commands in a persistent shell',
+                category: 'execution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        command: {
+                            type: 'string',
+                            description: 'The bash command to execute'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Clear description of what this command does (5-10 words, recommended)'
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (max 600000 = 10 min, default 120000 = 2 min)'
+                        },
+                        run_in_background: {
+                            type: 'boolean',
+                            description: 'Run command in background and return process ID'
+                        }
+                    },
+                    required: ['command']
+                }
+            },
+            {
+                name: 'exec.bash_output',
+                description: 'Retrieve output from background bash processes',
+                category: 'execution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        bash_id: {
+                            type: 'string',
+                            description: 'Process ID returned from background bash command'
+                        },
+                        filter: {
+                            type: 'string',
+                            description: 'Optional regex to filter output lines (only matching lines returned)'
+                        }
+                    },
+                    required: ['bash_id']
+                }
+            },
+            {
+                name: 'exec.kill_shell',
+                description: 'Terminate background bash processes',
+                category: 'execution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        shell_id: {
+                            type: 'string',
+                            description: 'Process ID of the background process to kill'
+                        }
+                    },
+                    required: ['shell_id']
+                }
+            }
+            // Note: Web tools (web.search, web.fetch, web.scrape) are provided by WebTools module
+        ];
+    }
+    /**
+     * Execute a tool by name
+     */
+    async executeTool(toolName, args) {
+        try {
+            (0, debug_utils_1.debugLog)(chalk_1.default.gray(`[CoreTools] Executing: ${toolName}`));
+            (0, debug_utils_1.debugLog)(chalk_1.default.gray('[CoreTools] Arguments:'), chalk_1.default.gray(JSON.stringify(args, null, 2)));
+            switch (toolName) {
+                // Core Tools
+                case 'core.read':
+                    return await this.toolRead(args);
+                case 'core.write':
+                    return await this.toolWrite(args);
+                case 'core.edit':
+                    return await this.toolEdit(args);
+                case 'core.glob':
+                    return await this.toolGlob(args);
+                case 'core.grep':
+                    return await this.toolGrep(args);
+                // Execution Tools
+                case 'exec.bash':
+                    return await this.toolBash(args);
+                case 'exec.bash_output':
+                    return await this.toolBashOutput(args);
+                case 'exec.kill_shell':
+                    return await this.toolKillShell(args);
+                // Note: Web tools are handled by WebTools module
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown tool: ${toolName}`
+                    };
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`[CoreTools] Error executing ${toolName}:`), error.message);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    // ============= CORE TOOLS IMPLEMENTATION =============
+    /**
+     * Read - Read files with line numbers (cat -n format)
+     * Defaults to 2000 lines, supports offset/limit
+     * Tracks read history for Edit validation
+     */
+    async toolRead(args) {
+        try {
+            const content = await (0, promises_1.readFile)(args.file_path, 'utf-8');
+            const lines = content.split('\n');
+            // Track that this file was read (for Edit validation)
+            this.fileReadHistory.add(args.file_path);
+            // Apply offset and limit (default: 2000 lines from start)
+            const offset = args.offset || 0;
+            const limit = args.limit || 2000;
+            const selectedLines = lines.slice(offset, offset + limit);
+            // Format with line numbers (cat -n format)
+            const numberedLines = selectedLines.map((line, idx) => {
+                const lineNum = offset + idx + 1;
+                // Truncate lines longer than 2000 characters
+                const truncatedLine = line.length > 2000 ? line.substring(0, 2000) + '...' : line;
+                return `${lineNum.toString().padStart(6)}→${truncatedLine}`;
+            }).join('\n');
+            return {
+                success: true,
+                output: numberedLines
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to read file: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Write - Create or overwrite files
+     * MUST have read file first if it exists (checked via read history)
+     * Prefer Edit for existing files
+     */
+    async toolWrite(args) {
+        try {
+            // Check if file exists and hasn't been read
+            try {
+                await (0, promises_1.readFile)(args.file_path, 'utf-8');
+                // File exists - check if it was read
+                if (!this.fileReadHistory.has(args.file_path)) {
+                    return {
+                        success: false,
+                        error: 'File exists but has not been read. Use Read tool first, or use Edit tool for modifications.'
+                    };
+                }
+            }
+            catch {
+                // File doesn't exist - OK to write
+            }
+            await (0, promises_1.writeFile)(args.file_path, args.content, 'utf-8');
+            return {
+                success: true,
+                output: `Successfully wrote ${args.content.length} characters to ${args.file_path}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to write file: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Edit - Exact string replacement
+     * MUST have read file first
+     * Validates uniqueness unless replace_all is true
+     */
+    async toolEdit(args) {
+        try {
+            // Validate file was read first
+            if (!this.fileReadHistory.has(args.file_path)) {
+                return {
+                    success: false,
+                    error: 'File has not been read. Use Read tool first before editing.'
+                };
+            }
+            const content = await (0, promises_1.readFile)(args.file_path, 'utf-8');
+            // Check if old_string exists
+            if (!content.includes(args.old_string)) {
+                return {
+                    success: false,
+                    error: `String not found in file: "${args.old_string.substring(0, 100)}${args.old_string.length > 100 ? '...' : ''}"`
+                };
+            }
+            // Check uniqueness if replace_all is false
+            if (!args.replace_all) {
+                const occurrences = content.split(args.old_string).length - 1;
+                if (occurrences > 1) {
+                    return {
+                        success: false,
+                        error: `String appears ${occurrences} times in file. Either provide a larger unique string or use replace_all: true`
+                    };
+                }
+            }
+            // Perform replacement
+            const newContent = args.replace_all
+                ? content.split(args.old_string).join(args.new_string)
+                : content.replace(args.old_string, args.new_string);
+            await (0, promises_1.writeFile)(args.file_path, newContent, 'utf-8');
+            return {
+                success: true,
+                output: `Successfully ${args.replace_all ? 'replaced all occurrences' : 'replaced string'} in ${args.file_path}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to edit file: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Glob - Find files by pattern
+     * Returns paths sorted by modification time (newest first)
+     */
+    async toolGlob(args) {
+        try {
+            const files = await (0, glob_1.glob)(args.pattern, {
+                cwd: args.path || process.cwd(),
+                nodir: false,
+                absolute: true
+            });
+            // Sort by modification time (newest first) - simplified version
+            // In production, you'd use fs.stat to get actual mtimes
+            const sortedFiles = files.sort().reverse();
+            return {
+                success: true,
+                output: sortedFiles.join('\n') || 'No files matched the pattern'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Glob pattern failed: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Grep - Search file contents using ripgrep
+     * Supports multiple output modes, context lines, filters
+     */
+    async toolGrep(args) {
+        try {
+            const path = args.path || '.';
+            const outputMode = args.output_mode || 'files_with_matches';
+            // Build grep/rg command
+            let command = 'grep';
+            let flags = [];
+            // Output mode flags
+            if (outputMode === 'files_with_matches') {
+                flags.push('-l');
+            }
+            else if (outputMode === 'count') {
+                flags.push('-c');
+            }
+            // Other flags
+            if (args['-i'])
+                flags.push('-i');
+            if (args['-n'])
+                flags.push('-n');
+            if (args['-A'])
+                flags.push(`-A ${args['-A']}`);
+            if (args['-B'])
+                flags.push(`-B ${args['-B']}`);
+            if (args['-C'])
+                flags.push(`-C ${args['-C']}`);
+            // Recursive by default
+            flags.push('-r');
+            // Build full command
+            const fullCommand = `${command} ${flags.join(' ')} "${args.pattern}" ${path}`;
+            const { stdout, stderr } = await execAsync(fullCommand, {
+                timeout: 10000,
+                maxBuffer: 1024 * 1024,
+                cwd: process.cwd()
+            });
+            let output = stdout.trim();
+            // Apply head_limit if specified
+            if (args.head_limit && output) {
+                const lines = output.split('\n');
+                output = lines.slice(0, args.head_limit).join('\n');
+            }
+            return {
+                success: true,
+                output: output || 'No matches found'
+            };
+        }
+        catch (error) {
+            // Grep returns exit code 1 when no matches found
+            if (error.code === 1) {
+                return {
+                    success: true,
+                    output: 'No matches found'
+                };
+            }
+            return {
+                success: false,
+                error: `Grep failed: ${error.message}`
+            };
+        }
+    }
+    // ============= EXECUTION TOOLS IMPLEMENTATION =============
+    /**
+     * Bash - Execute shell commands
+     * Supports background execution with process tracking
+     * Default timeout: 2 minutes, max: 10 minutes
+     */
+    async toolBash(args) {
+        try {
+            const timeout = Math.min(args.timeout || 120000, 600000); // Default 2min, max 10min
+            if (args.run_in_background) {
+                // Run in background
+                const processId = `bg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+                const childProcess = (0, child_process_1.exec)(args.command, {
+                    timeout: timeout,
+                    maxBuffer: 1024 * 1024,
+                    cwd: process.cwd()
+                });
+                this.backgroundProcesses.set(processId, {
+                    process: childProcess,
+                    stdout: '',
+                    stderr: '',
+                    exitCode: null,
+                    startTime: Date.now()
+                });
+                childProcess.stdout?.on('data', (data) => {
+                    const proc = this.backgroundProcesses.get(processId);
+                    if (proc)
+                        proc.stdout += data;
+                });
+                childProcess.stderr?.on('data', (data) => {
+                    const proc = this.backgroundProcesses.get(processId);
+                    if (proc)
+                        proc.stderr += data;
+                });
+                childProcess.on('exit', (code) => {
+                    const proc = this.backgroundProcesses.get(processId);
+                    if (proc)
+                        proc.exitCode = code;
+                });
+                return {
+                    success: true,
+                    output: `Background process started with ID: ${processId}\nUse exec.bash_output to check progress.`
+                };
+            }
+            else {
+                // Run synchronously
+                const { stdout, stderr } = await execAsync(args.command, {
+                    timeout: timeout,
+                    maxBuffer: 1024 * 1024,
+                    cwd: process.cwd()
+                });
+                return {
+                    success: true,
+                    output: (stdout + stderr).trim()
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                exitCode: error.code
+            };
+        }
+    }
+    /**
+     * BashOutput - Monitor background processes
+     * Returns only NEW output since last check
+     */
+    async toolBashOutput(args) {
+        const proc = this.backgroundProcesses.get(args.bash_id);
+        if (!proc) {
+            return {
+                success: false,
+                error: `Process not found: ${args.bash_id}\nUse /bashes command to list running processes.`
+            };
+        }
+        let stdout = proc.stdout;
+        let stderr = proc.stderr;
+        // Apply filter if specified
+        if (args.filter) {
+            const regex = new RegExp(args.filter);
+            stdout = stdout.split('\n').filter(line => regex.test(line)).join('\n');
+            stderr = stderr.split('\n').filter(line => regex.test(line)).join('\n');
+        }
+        const runtime = Math.floor((Date.now() - proc.startTime) / 1000);
+        return {
+            success: true,
+            output: `Process: ${args.bash_id}\nRuntime: ${runtime}s\nExit Code: ${proc.exitCode ?? 'still running'}\n\n=== STDOUT ===\n${stdout || '(empty)'}\n\n=== STDERR ===\n${stderr || '(empty)'}`
+        };
+    }
+    /**
+     * KillShell - Terminate background process
+     */
+    async toolKillShell(args) {
+        const proc = this.backgroundProcesses.get(args.shell_id);
+        if (!proc) {
+            return {
+                success: false,
+                error: `Process not found: ${args.shell_id}`
+            };
+        }
+        proc.process.kill('SIGTERM');
+        this.backgroundProcesses.delete(args.shell_id);
+        return {
+            success: true,
+            output: `Process ${args.shell_id} terminated`
+        };
+    }
+    // ============= UTILITY METHODS =============
+    /**
+     * Format tools for AI system prompt - organized by category
+     */
+    formatToolsForPrompt() {
+        const tools = this.getTools();
+        const coreTools = tools.filter(t => t.category === 'core');
+        const execTools = tools.filter(t => t.category === 'execution');
+        const webTools = tools.filter(t => t.category === 'web');
+        const formatTool = (tool) => {
+            // Extract required and optional parameters from schema
+            const required = tool.inputSchema.required || [];
+            const properties = tool.inputSchema.properties || {};
+            const params = Object.entries(properties).map(([key, value]) => {
+                const isRequired = required.includes(key);
+                const desc = value.description || 'No description';
+                return `      ${key}${isRequired ? ' (required)' : ''}: ${desc}`;
+            }).join('\n');
+            return `  - ${tool.name}: ${tool.description}\n${params}`;
+        };
+        const formatCategory = (title, toolList) => {
+            return `${title}:\n${toolList.map(formatTool).join('\n')}`;
+        };
+        return `\n\nAvailable Tools:\n\n` +
+            formatCategory('Core Tools', coreTools) + '\n\n' +
+            formatCategory('Execution', execTools) + '\n\n' +
+            formatCategory('Web', webTools) +
+            '\n\nTo use a tool, respond with JSON: {"tool": "tool.name", "args": {...}}';
+    }
+    /**
+     * Convert tools to OpenAI tools array format
+     * Used when sending tools parameter in chat completion requests
+     */
+    toOpenAITools() {
+        return this.getTools().map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.inputSchema
+            }
+        }));
+    }
+    /**
+     * Parse tool call from AI response
+     * Supports multiple formats:
+     * 1. JSON: {"tool": "exec.bash", "args": {...}}
+     * 2. Function tags: <function=exec.bash={...}</function>
+     */
+    parseToolCall(response) {
+        try {
+            // Format 1: JSON with "tool" and "args" keys
+            const jsonMatch = response.match(/\{[\s\S]*"tool"[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                // Only match core.* and exec.* tools, not web.* tools
+                if (parsed.tool && parsed.args &&
+                    (parsed.tool.startsWith('core.') || parsed.tool.startsWith('exec.'))) {
+                    return { tool: parsed.tool, args: parsed.args };
+                }
+            }
+            // Format 2: XML-like function tags: <function=tool_name={args}</function>
+            const functionMatch = response.match(/<function=([\w\.]+)=(\{[\s\S]+?\})<\/function>/);
+            if (functionMatch) {
+                const toolName = functionMatch[1];
+                const argsJson = functionMatch[2];
+                const args = JSON.parse(argsJson);
+                // Only match core.* and exec.* tools
+                if (toolName.startsWith('core.') || toolName.startsWith('exec.')) {
+                    return { tool: toolName, args };
+                }
+            }
+        }
+        catch (error) {
+            // Not a tool call
+        }
+        return null;
+    }
+    /**
+     * List background processes
+     */
+    listBackgroundProcesses() {
+        return Array.from(this.backgroundProcesses.keys());
+    }
+}
+exports.CoreTools = CoreTools;
+CoreTools.instance = null;
+//# sourceMappingURL=core-tools.js.map