prab-cli 1.0.0

package/dist/lib/tools/file-tools.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrepTool = exports.GlobTool = exports.EditFileTool = exports.WriteFileTool = exports.ReadFileTool = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const diff_1 = require("diff");
+/**
+ * Read a file with line numbers
+ */
+class ReadFileTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_file';
+        this.description = 'Read the contents of a file with line numbers. Supports pagination for large files.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            file_path: zod_1.z.string().describe('Absolute or relative path to the file to read'),
+            offset: zod_1.z.number().optional().describe('Line number to start reading from (1-indexed)'),
+            limit: zod_1.z.number().optional().describe('Maximum number of lines to read')
+        });
+    }
+    async execute(params) {
+        try {
+            const filePath = path_1.default.resolve(params.file_path);
+            if (!fs_1.default.existsSync(filePath)) {
+                return this.error(`File not found: ${params.file_path}`);
+            }
+            if (fs_1.default.statSync(filePath).isDirectory()) {
+                return this.error(`Path is a directory: ${params.file_path}`);
+            }
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = params.offset ? params.offset - 1 : 0;
+            const endLine = params.limit ? startLine + params.limit : lines.length;
+            const selectedLines = lines.slice(startLine, endLine);
+            // Format with line numbers (1-indexed)
+            const numberedLines = selectedLines.map((line, idx) => {
+                const lineNum = startLine + idx + 1;
+                return `${lineNum.toString().padStart(6)}→${line}`;
+            }).join('\n');
+            const totalLines = lines.length;
+            const showing = `Showing lines ${startLine + 1}-${Math.min(endLine, totalLines)} of ${totalLines}`;
+            return this.success(`${params.file_path}\n${showing}\n\n${numberedLines}`, { totalLines, startLine: startLine + 1, endLine: Math.min(endLine, totalLines) });
+        }
+        catch (error) {
+            return this.error(`Failed to read file: ${error.message}`);
+        }
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+/**
+ * Write content to a file (create or overwrite)
+ */
+class WriteFileTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'write_file';
+        this.description = 'Write content to a file. Creates the file if it doesn\'t exist, overwrites if it does. Creates parent directories as needed.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            file_path: zod_1.z.string().describe('Absolute or relative path to the file to write'),
+            content: zod_1.z.string().describe('Content to write to the file')
+        });
+    }
+    async execute(params) {
+        try {
+            const filePath = path_1.default.resolve(params.file_path);
+            const dir = path_1.default.dirname(filePath);
+            // Create parent directories if needed
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            const fileExists = fs_1.default.existsSync(filePath);
+            fs_1.default.writeFileSync(filePath, params.content, 'utf-8');
+            const action = fileExists ? 'Updated' : 'Created';
+            const lines = params.content.split('\n').length;
+            return this.success(`${action} ${params.file_path} (${lines} lines)`, { action, path: filePath, lines });
+        }
+        catch (error) {
+            return this.error(`Failed to write file: ${error.message}`);
+        }
+    }
+}
+exports.WriteFileTool = WriteFileTool;
+/**
+ * Edit a file by finding and replacing text
+ */
+class EditFileTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'edit_file';
+        this.description = 'Edit a file by finding and replacing text. Shows a diff preview. Supports replace all option.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            file_path: zod_1.z.string().describe('Absolute or relative path to the file to edit'),
+            search: zod_1.z.string().describe('Text to search for (exact match)'),
+            replace: zod_1.z.string().describe('Text to replace with'),
+            replace_all: zod_1.z.boolean().optional().describe('Replace all occurrences (default: false)')
+        });
+    }
+    async execute(params) {
+        try {
+            const filePath = path_1.default.resolve(params.file_path);
+            if (!fs_1.default.existsSync(filePath)) {
+                return this.error(`File not found: ${params.file_path}`);
+            }
+            const originalContent = fs_1.default.readFileSync(filePath, 'utf-8');
+            // Perform replacement
+            let newContent;
+            if (params.replace_all) {
+                newContent = originalContent.split(params.search).join(params.replace);
+            }
+            else {
+                newContent = originalContent.replace(params.search, params.replace);
+            }
+            if (originalContent === newContent) {
+                return this.error(`Search text not found in file: "${params.search}"`);
+            }
+            // Generate diff
+            const diff = (0, diff_1.diffLines)(originalContent, newContent);
+            const diffOutput = diff.map(part => {
+                const prefix = part.added ? '+ ' : part.removed ? '- ' : '  ';
+                return part.value.split('\n').map(line => line ? prefix + line : '').join('\n');
+            }).join('');
+            // Write the changes
+            fs_1.default.writeFileSync(filePath, newContent, 'utf-8');
+            const occurrences = params.replace_all
+                ? originalContent.split(params.search).length - 1
+                : 1;
+            return this.success(`Edited ${params.file_path} (${occurrences} replacement${occurrences > 1 ? 's' : ''})\n\nDiff:\n${diffOutput}`, { occurrences, path: filePath });
+        }
+        catch (error) {
+            return this.error(`Failed to edit file: ${error.message}`);
+        }
+    }
+}
+exports.EditFileTool = EditFileTool;
+/**
+ * Find files matching a glob pattern
+ */
+class GlobTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'glob';
+        this.description = 'Find files matching a glob pattern (e.g., "**/*.ts", "src/**/*.js"). Returns paths sorted by modification time.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            pattern: zod_1.z.string().describe('Glob pattern to match files (e.g., "**/*.ts")'),
+            path: zod_1.z.string().optional().describe('Directory to search in (default: current directory)')
+        });
+    }
+    async execute(params) {
+        try {
+            const cwd = params.path ? path_1.default.resolve(params.path) : process.cwd();
+            const ignore = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/.env', '**/*.lock'];
+            const files = await (0, glob_1.glob)(params.pattern, {
+                cwd,
+                ignore,
+                nodir: true
+            });
+            // Sort by modification time (most recent first)
+            const filesWithStats = files.map(file => {
+                const fullPath = path_1.default.join(cwd, file);
+                const stats = fs_1.default.statSync(fullPath);
+                return { file, mtime: stats.mtime.getTime() };
+            });
+            filesWithStats.sort((a, b) => b.mtime - a.mtime);
+            const sortedFiles = filesWithStats.map(f => f.file);
+            if (sortedFiles.length === 0) {
+                return this.success(`No files found matching pattern: ${params.pattern}`);
+            }
+            const output = sortedFiles.join('\n');
+            return this.success(`Found ${sortedFiles.length} file(s) matching "${params.pattern}":\n${output}`, { count: sortedFiles.length, files: sortedFiles });
+        }
+        catch (error) {
+            return this.error(`Glob search failed: ${error.message}`);
+        }
+    }
+}
+exports.GlobTool = GlobTool;
+/**
+ * Search file contents with regex
+ */
+class GrepTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'grep';
+        this.description = 'Search file contents using regex patterns. Supports multiple output modes and context lines.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            pattern: zod_1.z.string().describe('Regular expression pattern to search for'),
+            path: zod_1.z.string().optional().describe('Directory or file to search in (default: current directory)'),
+            glob_filter: zod_1.z.string().optional().describe('Glob pattern to filter files (e.g., "*.ts")'),
+            output_mode: zod_1.z.enum(['content', 'files', 'count']).optional().describe('Output mode: content (matching lines), files (file paths), count (match counts)'),
+            case_insensitive: zod_1.z.boolean().optional().describe('Case insensitive search (default: false)'),
+            context_lines: zod_1.z.number().optional().describe('Number of context lines to show before and after matches')
+        });
+    }
+    async execute(params) {
+        try {
+            const searchPath = params.path ? path_1.default.resolve(params.path) : process.cwd();
+            const outputMode = params.output_mode || 'files';
+            // Determine files to search
+            let filesToSearch;
+            if (fs_1.default.existsSync(searchPath) && fs_1.default.statSync(searchPath).isFile()) {
+                filesToSearch = [searchPath];
+            }
+            else {
+                const globPattern = params.glob_filter || '**/*';
+                const ignore = ['**/node_modules/**', '**/.git/**', '**/dist/**'];
+                filesToSearch = await (0, glob_1.glob)(globPattern, {
+                    cwd: searchPath,
+                    ignore,
+                    nodir: true,
+                    absolute: true
+                });
+            }
+            // Create regex
+            const flags = params.case_insensitive ? 'gi' : 'g';
+            const regex = new RegExp(params.pattern, flags);
+            const results = [];
+            // Search files
+            for (const file of filesToSearch) {
+                try {
+                    const content = fs_1.default.readFileSync(file, 'utf-8');
+                    const lines = content.split('\n');
+                    const matches = [];
+                    lines.forEach((line, idx) => {
+                        if (regex.test(line)) {
+                            matches.push({ line: idx + 1, content: line });
+                        }
+                        // Reset regex lastIndex for global flag
+                        regex.lastIndex = 0;
+                    });
+                    if (matches.length > 0) {
+                        results.push({ file, matches });
+                    }
+                }
+                catch (e) {
+                    // Skip files that can't be read (binary, permissions, etc.)
+                    continue;
+                }
+            }
+            // Format output based on mode
+            if (outputMode === 'files') {
+                const fileList = results.map(r => r.file).join('\n');
+                return this.success(`Found matches in ${results.length} file(s):\n${fileList}`, { count: results.length, files: results.map(r => r.file) });
+            }
+            else if (outputMode === 'count') {
+                const counts = results.map(r => `${r.file}: ${r.matches.length} matches`).join('\n');
+                const total = results.reduce((sum, r) => sum + r.matches.length, 0);
+                return this.success(`Total matches: ${total}\n${counts}`, { total, breakdown: results.map(r => ({ file: r.file, count: r.matches.length })) });
+            }
+            else {
+                // content mode
+                const contextLines = params.context_lines || 0;
+                let output = '';
+                for (const result of results) {
+                    output += `\n${result.file}:\n`;
+                    for (const match of result.matches) {
+                        output += `  ${match.line}: ${match.content}\n`;
+                    }
+                }
+                return this.success(`Found ${results.reduce((sum, r) => sum + r.matches.length, 0)} match(es) across ${results.length} file(s):${output}`, { matchCount: results.reduce((sum, r) => sum + r.matches.length, 0), fileCount: results.length });
+            }
+        }
+        catch (error) {
+            return this.error(`Grep search failed: ${error.message}`);
+        }
+    }
+}
+exports.GrepTool = GrepTool;

package/dist/lib/tools/git-tools.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitPushTool = exports.GitBranchTool = exports.GitCommitTool = exports.GitLogTool = exports.GitDiffTool = exports.GitAddTool = exports.GitStatusTool = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const simple_git_1 = __importDefault(require("simple-git"));
+const git = (0, simple_git_1.default)();
+/**
+ * Get git status
+ */
+class GitStatusTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_status';
+        this.description = 'Show the working tree status - staged, unstaged, and untracked files.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({});
+    }
+    async execute(params) {
+        try {
+            const status = await git.status();
+            const output = [];
+            output.push(`Branch: ${status.current || '(detached HEAD)'}`);
+            output.push(`Ahead: ${status.ahead}, Behind: ${status.behind}`);
+            if (status.files.length === 0) {
+                output.push('\nWorking tree clean');
+            }
+            else {
+                if (status.staged.length > 0) {
+                    output.push('\nStaged files:');
+                    status.staged.forEach(file => output.push(`  + ${file}`));
+                }
+                if (status.modified.length > 0 || status.deleted.length > 0) {
+                    output.push('\nUnstaged changes:');
+                    status.modified.forEach(file => output.push(`  M ${file}`));
+                    status.deleted.forEach(file => output.push(`  D ${file}`));
+                }
+                if (status.not_added.length > 0) {
+                    output.push('\nUntracked files:');
+                    status.not_added.forEach(file => output.push(`  ? ${file}`));
+                }
+            }
+            return this.success(output.join('\n'), { status });
+        }
+        catch (error) {
+            return this.error(`Git status failed: ${error.message}`);
+        }
+    }
+}
+exports.GitStatusTool = GitStatusTool;
+/**
+ * Stage files for commit (git add)
+ */
+class GitAddTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_add';
+        this.description = 'Stage files for commit. Use "." to stage all changes, or specify specific files.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            files: zod_1.z.array(zod_1.z.string()).describe('Files to stage. Use ["."] to stage all changes.')
+        });
+    }
+    async execute(params) {
+        try {
+            await git.add(params.files);
+            // Get status to show what was staged
+            const status = await git.status();
+            const stagedFiles = status.staged;
+            return this.success(`Staged ${stagedFiles.length} file(s):\n${stagedFiles.map(f => `  + ${f}`).join('\n')}`, { staged: stagedFiles });
+        }
+        catch (error) {
+            return this.error(`Git add failed: ${error.message}`);
+        }
+    }
+}
+exports.GitAddTool = GitAddTool;
+/**
+ * Show git diff
+ */
+class GitDiffTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_diff';
+        this.description = 'Show changes in files. Can show staged or unstaged changes, or changes for specific files.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            files: zod_1.z.array(zod_1.z.string()).optional().describe('Specific files to show diff for'),
+            staged: zod_1.z.boolean().optional().describe('Show staged changes (default: false, shows unstaged)')
+        });
+    }
+    async execute(params) {
+        try {
+            const options = params.staged ? ['--cached'] : [];
+            if (params.files && params.files.length > 0) {
+                options.push('--', ...params.files);
+            }
+            const diff = await git.diff(options);
+            if (!diff || diff.trim().length === 0) {
+                return this.success('No changes to show');
+            }
+            return this.success(diff, { staged: params.staged || false });
+        }
+        catch (error) {
+            return this.error(`Git diff failed: ${error.message}`);
+        }
+    }
+}
+exports.GitDiffTool = GitDiffTool;
+/**
+ * Show git log
+ */
+class GitLogTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_log';
+        this.description = 'Show commit history with messages, authors, and dates.';
+        this.requiresConfirmation = false;
+        this.destructive = false;
+        this.schema = zod_1.z.object({
+            limit: zod_1.z.number().optional().describe('Maximum number of commits to show (default: 10)'),
+            branch: zod_1.z.string().optional().describe('Branch to show log for (default: current branch)')
+        });
+    }
+    async execute(params) {
+        try {
+            const options = {
+                maxCount: params.limit || 10
+            };
+            if (params.branch) {
+                options.file = params.branch;
+            }
+            const log = await git.log(options);
+            const output = log.all.map(commit => {
+                return `${commit.hash.substring(0, 7)} ${commit.date}\n  ${commit.message}`;
+            }).join('\n\n');
+            return this.success(output || 'No commits found', { count: log.all.length, commits: log.all });
+        }
+        catch (error) {
+            return this.error(`Git log failed: ${error.message}`);
+        }
+    }
+}
+exports.GitLogTool = GitLogTool;
+/**
+ * Create a git commit
+ */
+class GitCommitTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_commit';
+        this.description = 'Create a git commit with staged changes. Adds Claude attribution to commit message.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            message: zod_1.z.string().describe('Commit message'),
+            files: zod_1.z.array(zod_1.z.string()).optional().describe('Files to stage before committing (if not already staged)')
+        });
+    }
+    async execute(params) {
+        try {
+            // Stage files if specified
+            if (params.files && params.files.length > 0) {
+                await git.add(params.files);
+            }
+            // Add Claude attribution
+            const fullMessage = `${params.message}\n\n🤖 Generated with CLI AI Tool\n\nCo-Authored-By: AI Assistant <noreply@example.com>`;
+            // Create commit
+            const result = await git.commit(fullMessage);
+            return this.success(`Created commit: ${result.commit}\n${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`, { commit: result.commit, summary: result.summary });
+        }
+        catch (error) {
+            return this.error(`Git commit failed: ${error.message}`);
+        }
+    }
+}
+exports.GitCommitTool = GitCommitTool;
+/**
+ * Manage git branches
+ */
+class GitBranchTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_branch';
+        this.description = 'List, create, switch, or delete git branches.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            action: zod_1.z.enum(['list', 'create', 'switch', 'delete']).describe('Action to perform'),
+            name: zod_1.z.string().optional().describe('Branch name (required for create, switch, delete)')
+        });
+    }
+    async execute(params) {
+        try {
+            switch (params.action) {
+                case 'list': {
+                    const branches = await git.branchLocal();
+                    const output = branches.all.map(branch => {
+                        return branch === branches.current ? `* ${branch}` : `  ${branch}`;
+                    }).join('\n');
+                    return this.success(`Branches:\n${output}`, { current: branches.current, all: branches.all });
+                }
+                case 'create': {
+                    if (!params.name) {
+                        return this.error('Branch name is required for create action');
+                    }
+                    await git.checkoutLocalBranch(params.name);
+                    return this.success(`Created and switched to branch: ${params.name}`);
+                }
+                case 'switch': {
+                    if (!params.name) {
+                        return this.error('Branch name is required for switch action');
+                    }
+                    await git.checkout(params.name);
+                    return this.success(`Switched to branch: ${params.name}`);
+                }
+                case 'delete': {
+                    if (!params.name) {
+                        return this.error('Branch name is required for delete action');
+                    }
+                    await git.deleteLocalBranch(params.name);
+                    return this.success(`Deleted branch: ${params.name}`);
+                }
+                default:
+                    return this.error(`Unknown action: ${params.action}`);
+            }
+        }
+        catch (error) {
+            return this.error(`Git branch operation failed: ${error.message}`);
+        }
+    }
+}
+exports.GitBranchTool = GitBranchTool;
+/**
+ * Push to remote
+ */
+class GitPushTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'git_push';
+        this.description = 'Push commits to remote repository. Use with caution, especially with force flag.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            branch: zod_1.z.string().optional().describe('Branch to push (default: current branch)'),
+            force: zod_1.z.boolean().optional().describe('Force push (use with extreme caution, default: false)'),
+            set_upstream: zod_1.z.boolean().optional().describe('Set upstream tracking (default: false)')
+        });
+    }
+    async execute(params) {
+        try {
+            // Warn about force push to main/master
+            if (params.force && (params.branch === 'main' || params.branch === 'master')) {
+                return this.error('Force push to main/master branch is blocked for safety. ' +
+                    'Please run this manually if absolutely necessary.');
+            }
+            const options = [];
+            if (params.force) {
+                options.push('--force');
+            }
+            if (params.set_upstream) {
+                options.push('--set-upstream');
+            }
+            const remote = 'origin';
+            const branch = params.branch || (await git.branchLocal()).current;
+            await git.push(remote, branch, options);
+            return this.success(`Pushed ${branch} to ${remote}${params.force ? ' (force)' : ''}`, { remote, branch, force: params.force || false });
+        }
+        catch (error) {
+            return this.error(`Git push failed: ${error.message}`);
+        }
+    }
+}
+exports.GitPushTool = GitPushTool;

package/dist/lib/tools/shell-tools.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BashTool = void 0;
+const zod_1 = require("zod");
+const base_1 = require("./base");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Execute bash commands
+ */
+class BashTool extends base_1.Tool {
+    constructor() {
+        super(...arguments);
+        this.name = 'bash';
+        this.description = 'Execute bash/shell commands with timeout. Use for running terminal commands, scripts, or system operations.';
+        this.requiresConfirmation = true;
+        this.destructive = true;
+        this.schema = zod_1.z.object({
+            command: zod_1.z.string().describe('The shell command to execute'),
+            description: zod_1.z.string().optional().describe('Brief description of what this command does'),
+            timeout: zod_1.z.number().optional().describe('Timeout in milliseconds (default: 120000ms, max: 600000ms)')
+        });
+        // Dangerous commands that always require explicit confirmation
+        this.dangerousPatterns = [
+            /rm\s+-rf\s+\//,
+            /mkfs/,
+            /dd\s+if=/,
+            />\s*\/dev\/sd/,
+            /chmod\s+-R\s+777/,
+            /chown\s+-R/,
+            /:(){ :|:& };:/ // Fork bomb
+        ];
+    }
+    isDangerous(command) {
+        return this.dangerousPatterns.some(pattern => pattern.test(command));
+    }
+    async execute(params) {
+        try {
+            // Safety check for dangerous commands
+            if (this.isDangerous(params.command)) {
+                return this.error(`Dangerous command detected and blocked: "${params.command}". ` +
+                    `This command could cause system damage. Please run it manually if you're certain.`);
+            }
+            const timeout = params.timeout && params.timeout <= 600000
+                ? params.timeout
+                : 120000; // Default 2 minutes
+            // Execute command
+            const { stdout, stderr } = await execPromise(params.command, {
+                timeout,
+                maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+                cwd: process.cwd()
+            });
+            const output = stdout + (stderr ? `\n[stderr]\n${stderr}` : '');
+            return this.success(`Command executed: ${params.command}\n\nOutput:\n${output || '(no output)'}`, {
+                command: params.command,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                hasError: stderr.length > 0
+            });
+        }
+        catch (error) {
+            // Handle timeout
+            if (error.killed && error.signal === 'SIGTERM') {
+                return this.error(`Command timed out after ${params.timeout || 120000}ms: ${params.command}`);
+            }
+            // Handle command failure
+            const errorOutput = error.stdout || error.stderr || error.message;
+            return this.error(`Command failed: ${params.command}\nExit code: ${error.code || 'unknown'}\nOutput:\n${errorOutput}`);
+        }
+    }
+}
+exports.BashTool = BashTool;