vigthoria-cli 1.6.2 → 1.6.4

package/src/utils/tools.ts

@@ -1,2086 +0,0 @@
-/**
- * Vigthoria CLI Tools - Agentic Tool System
- * 
- * This module provides Vigthoria Autonomous autonomous tool execution.
- * Tools can be called by the AI to perform actions.
- * 
- * Enhanced with:
- * - Risk-based permission system
- * - Automatic retry logic with exponential backoff
- * - Undo functionality for file operations
- * - Detailed error messages with suggestions
- * 
- * @version 1.1.0
- * @author Vigthoria Labs
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync, spawn } from 'child_process';
-import chalk from 'chalk';
-import { Logger } from './logger.js';
-
-// Risk levels for operations
-export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
-
-export interface ToolResult {
-  success: boolean;
-  output?: string;
-  error?: string;
-  suggestion?: string;  // Actionable suggestion for errors
-  canRetry?: boolean;   // Whether operation can be retried
-  undoable?: boolean;   // Whether operation can be undone
-  metadata?: {          // Additional tool-specific data
-    [key: string]: any;
-  };
-}
-
-export interface ToolCall {
-  tool: string;
-  args: Record<string, string>;
-}
-
-export interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: {
-    name: string;
-    description: string;
-    required: boolean;
-  }[];
-  requiresPermission: boolean;
-  dangerous: boolean;
-  riskLevel: RiskLevel;  // NEW: Risk classification
-  category: 'read' | 'write' | 'execute' | 'search';  // NEW: Tool category
-}
-
-// Undo operation tracking
-interface UndoOperation {
-  id: string;
-  tool: string;
-  timestamp: number;
-  filePath?: string;
-  originalContent?: string | null;  // null means file was created (delete on undo)
-  description: string;
-}
-
-// Error types for better handling
-export enum ToolErrorType {
-  FILE_NOT_FOUND = 'FILE_NOT_FOUND',
-  PERMISSION_DENIED = 'PERMISSION_DENIED',
-  NETWORK_ERROR = 'NETWORK_ERROR',
-  TIMEOUT = 'TIMEOUT',
-  INVALID_ARGS = 'INVALID_ARGS',
-  EXECUTION_FAILED = 'EXECUTION_FAILED',
-  USER_CANCELLED = 'USER_CANCELLED',
-}
-
-export class AgenticTools {
-  private logger: Logger;
-  private cwd: string;
-  private permissionCallback: (action: string, options?: { batchApproval?: boolean }) => Promise<boolean | 'batch'>;
-  private autoApprove: boolean;
-  private undoStack: UndoOperation[] = [];
-  private maxUndoStack: number = 50;
-  private retryConfig = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 10000,
-    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ECONNREFUSED', 'EAI_AGAIN'],
-  };
-  
-  // Session-based tool approvals - remembers which tools user approved for this turn
-  private sessionApprovedTools: Set<string> = new Set();
-
-  constructor(
-    logger: Logger,
-    cwd: string,
-    permissionCallback: (action: string, options?: { batchApproval?: boolean }) => Promise<boolean | 'batch'>,
-    autoApprove: boolean = false
-  ) {
-    this.logger = logger;
-    this.cwd = cwd;
-    this.permissionCallback = permissionCallback;
-    this.autoApprove = autoApprove;
-  }
-
-  /**
-   * Clear session-approved tools (call this at the start of each new AI turn)
-   */
-  clearSessionApprovals(): void {
-    this.sessionApprovedTools.clear();
-  }
-
-  /**
-   * Get currently approved tools for this session
-   */
-  getSessionApprovedTools(): string[] {
-    return Array.from(this.sessionApprovedTools);
-  }
-
-  /**
-   * Get the undo stack for inspection
-   */
-  getUndoStack(): UndoOperation[] {
-    return [...this.undoStack];
-  }
-
-  /**
-   * Undo the last file operation
-   */
-  async undo(): Promise<ToolResult> {
-    const lastOp = this.undoStack.pop();
-    
-    if (!lastOp) {
-      return {
-        success: false,
-        error: 'Nothing to undo',
-        suggestion: 'The undo stack is empty. Only file write/edit operations can be undone.',
-      };
-    }
-
-    if (lastOp.filePath) {
-      try {
-        if (lastOp.originalContent === null) {
-          // File was created, so delete it
-          if (fs.existsSync(lastOp.filePath)) {
-            fs.unlinkSync(lastOp.filePath);
-            return {
-              success: true,
-              output: `✓ Undone: ${lastOp.description}\n  File deleted: ${lastOp.filePath}`,
-              metadata: { remainingUndos: this.undoStack.length },
-            };
-          }
-        } else if (lastOp.originalContent !== undefined) {
-          // Restore original content
-          fs.writeFileSync(lastOp.filePath, lastOp.originalContent, 'utf-8');
-          return {
-            success: true,
-            output: `✓ Undone: ${lastOp.description}\n  File restored: ${lastOp.filePath}`,
-            metadata: { remainingUndos: this.undoStack.length },
-          };
-        }
-      } catch (error) {
-        return {
-          success: false,
-          error: `Failed to undo: ${(error as Error).message}`,
-          suggestion: 'The file may have been moved or permissions changed.',
-        };
-      }
-    }
-
-    return {
-      success: false,
-      error: 'This operation cannot be undone',
-    };
-  }
-
-  /**
-   * List of available tools - Vigthoria's advanced
-   * Enhanced with risk levels and categories
-   */
-  static getToolDefinitions(): ToolDefinition[] {
-    return [
-      {
-        name: 'read_file',
-        description: 'Read the contents of a file',
-        parameters: [
-          { name: 'path', description: 'File path (relative or absolute)', required: true },
-          { name: 'start_line', description: 'Start line (1-indexed)', required: false },
-          { name: 'end_line', description: 'End line (1-indexed)', required: false },
-        ],
-        requiresPermission: false,
-        dangerous: false,
-        riskLevel: 'low',
-        category: 'read',
-      },
-      {
-        name: 'write_file',
-        description: 'Write content to a file (creates if not exists)',
-        parameters: [
-          { name: 'path', description: 'File path', required: true },
-          { name: 'content', description: 'Content to write', required: true },
-        ],
-        requiresPermission: true,
-        dangerous: false,
-        riskLevel: 'medium',
-        category: 'write',
-      },
-      {
-        name: 'edit_file',
-        description: 'Make specific edits to a file by replacing text',
-        parameters: [
-          { name: 'path', description: 'File path', required: true },
-          { name: 'old_text', description: 'Text to replace', required: true },
-          { name: 'new_text', description: 'New text', required: true },
-        ],
-        requiresPermission: true,
-        dangerous: false,
-        riskLevel: 'medium',
-        category: 'write',
-      },
-      {
-        name: 'bash',
-        description: 'Run a shell command',
-        parameters: [
-          { name: 'command', description: 'Shell command to execute', required: true },
-          { name: 'cwd', description: 'Working directory', required: false },
-          { name: 'timeout', description: 'Timeout in seconds', required: false },
-        ],
-        requiresPermission: true,
-        dangerous: true,
-        riskLevel: 'high',
-        category: 'execute',
-      },
-      {
-        name: 'grep',
-        description: 'Search for patterns in files',
-        parameters: [
-          { name: 'pattern', description: 'Search pattern (regex)', required: true },
-          { name: 'path', description: 'File or directory path', required: false },
-          { name: 'include', description: 'File pattern to include (e.g., *.ts)', required: false },
-        ],
-        requiresPermission: false,
-        dangerous: false,
-        riskLevel: 'low',
-        category: 'search',
-      },
-      {
-        name: 'list_dir',
-        description: 'List contents of a directory',
-        parameters: [
-          { name: 'path', description: 'Directory path', required: true },
-          { name: 'recursive', description: 'List recursively', required: false },
-        ],
-        requiresPermission: false,
-        dangerous: false,
-        riskLevel: 'low',
-        category: 'read',
-      },
-      {
-        name: 'glob',
-        description: 'Find files matching a pattern',
-        parameters: [
-          { name: 'pattern', description: 'Glob pattern (e.g., **/*.ts)', required: true },
-        ],
-        requiresPermission: false,
-        dangerous: false,
-        riskLevel: 'low',
-        category: 'search',
-      },
-      {
-        name: 'git',
-        description: 'Run git commands',
-        parameters: [
-          { name: 'args', description: 'Git command arguments', required: true },
-        ],
-        requiresPermission: true,
-        dangerous: false,
-        riskLevel: 'medium',
-        category: 'execute',
-      },
-      {
-        name: 'repo',
-        description: 'Manage projects in Vigthoria Repository - push, pull, list, share, delete, or clone projects',
-        parameters: [
-          { name: 'action', description: 'Action: push, pull, list, status, share, delete, clone', required: true },
-          { name: 'project', description: 'Project name (for push/pull/status/share/delete)', required: false },
-          { name: 'files', description: 'Files to push as JSON object {filename: content} or array [{path, content}]', required: false },
-          { name: 'description', description: 'Project description (for push)', required: false },
-          { name: 'visibility', description: 'Visibility: public or private (for push)', required: false },
-          { name: 'path', description: 'Directory path (for push) or target path (for clone)', required: false },
-          { name: 'username', description: 'Username to share with (for share action)', required: false },
-          { name: 'permission', description: 'Permission level: read, write, admin (for share action)', required: false },
-        ],
-        requiresPermission: true,
-        dangerous: false,
-        riskLevel: 'medium',
-        category: 'execute',
-      },
-      {
-        name: 'fetch_url',
-        description: 'Fetch content from a URL (web page, API endpoint). Works cross-platform on Windows, Mac, and Linux.',
-        parameters: [
-          { name: 'url', description: 'URL to fetch (must be http or https)', required: true },
-          { name: 'method', description: 'HTTP method (GET, POST, etc.)', required: false },
-          { name: 'headers', description: 'JSON string of headers to send', required: false },
-          { name: 'body', description: 'Request body for POST/PUT requests', required: false },
-          { name: 'selector', description: 'CSS selector to extract specific content (for HTML)', required: false },
-        ],
-        requiresPermission: true,
-        dangerous: false,
-        riskLevel: 'low',
-        category: 'read',
-      },
-      {
-        name: 'ssh_exec',
-        description: 'Execute a command on a remote server via SSH (useful for Unix commands from Windows)',
-        parameters: [
-          { name: 'command', description: 'Command to execute on remote server', required: true },
-          { name: 'host', description: 'SSH host (default: vigthoria-server)', required: false },
-          { name: 'timeout', description: 'Timeout in seconds', required: false },
-        ],
-        requiresPermission: true,
-        dangerous: true,
-        riskLevel: 'high',
-        category: 'execute',
-      },
-    ];
-  }
-
-  /**
-   * Execute a tool call with enhanced error handling and retry logic
-   */
-  async execute(call: ToolCall): Promise<ToolResult> {
-    const tool = AgenticTools.getToolDefinitions().find(t => t.name === call.tool);
-    
-    if (!tool) {
-      return this.createErrorResult(
-        ToolErrorType.INVALID_ARGS,
-        `Unknown tool: ${call.tool}`,
-        `Available tools: ${AgenticTools.getToolDefinitions().map(t => t.name).join(', ')}`
-      );
-    }
-
-    // Validate required parameters
-    const validationError = this.validateParameters(call, tool);
-    if (validationError) {
-      return validationError;
-    }
-
-    // Check permission for dangerous/modifying actions
-    if (tool.requiresPermission && !this.autoApprove) {
-      // Check if this tool was already approved for this session/turn
-      if (this.sessionApprovedTools.has(call.tool)) {
-        // Already approved - skip permission prompt
-        this.logger.info(`${call.tool}: Auto-approved (batch)`);
-      } else {
-        const approved = await this.permissionCallback(
-          this.formatPermissionRequest(call, tool),
-          { batchApproval: true }
-        );
-        
-        if (approved === false) {
-          return {
-            success: false,
-            error: 'Permission denied by user',
-            canRetry: true,
-          };
-        }
-        
-        // Only add to session approvals if user chose 'batch' (typed 'a')
-        // 'y' or 'yes' only approves this single request
-        if (approved === 'batch') {
-          this.sessionApprovedTools.add(call.tool);
-        }
-      }
-    }
-
-    // Execute with retry logic for applicable operations
-    return this.executeWithRetry(call, tool);
-  }
-
-  /**
-   * Execute tool with automatic retry for transient failures
-   */
-  private async executeWithRetry(call: ToolCall, tool: ToolDefinition): Promise<ToolResult> {
-    let lastError: ToolResult | null = null;
-    
-    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
-      try {
-        const result = await this.executeTool(call);
-        
-        if (result.success) {
-          return result;
-        }
-
-        // Check if error is retryable
-        const isRetryable = result.canRetry !== false && 
-          this.isRetryableError(result.error || '');
-
-        if (!isRetryable || attempt === this.retryConfig.maxRetries) {
-          return result;
-        }
-
-        lastError = result;
-        
-        // Calculate delay with exponential backoff
-        const delay = Math.min(
-          this.retryConfig.baseDelayMs * Math.pow(2, attempt),
-          this.retryConfig.maxDelayMs
-        );
-        
-        this.logger.warn(`Retrying ${call.tool} in ${delay}ms (attempt ${attempt + 2}/${this.retryConfig.maxRetries + 1})...`);
-        await this.sleep(delay);
-        
-      } catch (error) {
-        lastError = this.createErrorResult(
-          ToolErrorType.EXECUTION_FAILED,
-          (error as Error).message
-        );
-        
-        if (attempt === this.retryConfig.maxRetries) {
-          return lastError;
-        }
-      }
-    }
-
-    return lastError || this.createErrorResult(
-      ToolErrorType.EXECUTION_FAILED,
-      'Unknown error after retries'
-    );
-  }
-
-  /**
-   * Execute the actual tool operation
-   */
-  private async executeTool(call: ToolCall): Promise<ToolResult> {
-    switch (call.tool) {
-      case 'read_file':
-        return this.readFile(call.args);
-      case 'write_file':
-        return this.writeFile(call.args);
-      case 'edit_file':
-        return this.editFile(call.args);
-      case 'bash':
-        return this.bash(call.args);
-      case 'grep':
-        return this.grep(call.args);
-      case 'list_dir':
-        return this.listDir(call.args);
-      case 'glob':
-        return this.glob(call.args);
-      case 'git':
-        return this.git(call.args);
-      case 'repo':
-        return this.repo(call.args);
-      case 'fetch_url':
-        return this.fetchUrl(call.args);
-      case 'ssh_exec':
-        return this.sshExec(call.args);
-      default:
-        return this.createErrorResult(
-          ToolErrorType.INVALID_ARGS,
-          `Tool not implemented: ${call.tool}`
-        );
-    }
-  }
-
-  /**
-   * Check if an error is retryable
-   */
-  private isRetryableError(error: string): boolean {
-    return this.retryConfig.retryableErrors.some(e => error.includes(e));
-  }
-
-  /**
-   * Validate tool parameters
-   */
-  private validateParameters(call: ToolCall, tool: ToolDefinition): ToolResult | null {
-    for (const param of tool.parameters) {
-      if (param.required && !call.args[param.name]) {
-        return this.createErrorResult(
-          ToolErrorType.INVALID_ARGS,
-          `Missing required parameter: ${param.name}`,
-          `The ${call.tool} tool requires the '${param.name}' parameter. ${param.description}`
-        );
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Create a standardized error result
-   */
-  private createErrorResult(
-    type: ToolErrorType,
-    message: string,
-    suggestion?: string
-  ): ToolResult {
-    const suggestions: Record<ToolErrorType, string> = {
-      [ToolErrorType.FILE_NOT_FOUND]: 'Check if the file path is correct. Use list_dir to see available files.',
-      [ToolErrorType.PERMISSION_DENIED]: 'You may need elevated permissions. Try using sudo or check file ownership.',
-      [ToolErrorType.NETWORK_ERROR]: 'Check your internet connection. The operation will retry automatically.',
-      [ToolErrorType.TIMEOUT]: 'The operation took too long. Try with a shorter timeout or simpler command.',
-      [ToolErrorType.INVALID_ARGS]: 'Check the tool documentation for correct parameter usage.',
-      [ToolErrorType.EXECUTION_FAILED]: 'Review the command syntax and try again.',
-      [ToolErrorType.USER_CANCELLED]: 'Operation cancelled. You can retry if needed.',
-    };
-
-    return {
-      success: false,
-      error: message,
-      suggestion: suggestion || suggestions[type],
-      canRetry: type !== ToolErrorType.USER_CANCELLED && type !== ToolErrorType.INVALID_ARGS,
-    };
-  }
-
-  /**
-   * Enhanced permission request with risk visualization
-   */
-  private formatPermissionRequest(call: ToolCall, tool: ToolDefinition): string {
-    const riskColors: Record<RiskLevel, (text: string) => string> = {
-      low: chalk.green,
-      medium: chalk.yellow,
-      high: chalk.red,
-      critical: chalk.bgRed.white,
-    };
-    
-    const riskIcons: Record<RiskLevel, string> = {
-      low: '🟢',
-      medium: '🟡',
-      high: '🔴',
-      critical: '⛔',
-    };
-
-    const riskColor = riskColors[tool.riskLevel];
-    const riskIcon = riskIcons[tool.riskLevel];
-    
-    let msg = `\n${riskIcon} ${riskColor(`${tool.riskLevel.toUpperCase()} RISK`)} - AI wants to use ${chalk.cyan.bold(call.tool)}\n`;
-    msg += chalk.gray('─'.repeat(50)) + '\n';
-    
-    // Tool-specific details
-    if (call.tool === 'bash') {
-      msg += `${chalk.gray('├─')} ${chalk.white('Command:')} ${chalk.yellow(call.args.command)}\n`;
-      if (call.args.cwd) {
-        msg += `${chalk.gray('├─')} ${chalk.white('Directory:')} ${call.args.cwd}\n`;
-      }
-      msg += `${chalk.gray('├─')} ${chalk.white('Timeout:')} ${call.args.timeout || '30'}s\n`;
-    } else if (call.tool === 'write_file') {
-      msg += `${chalk.gray('├─')} ${chalk.white('File:')} ${chalk.cyan(call.args.path)}\n`;
-      const preview = call.args.content.substring(0, 100);
-      msg += `${chalk.gray('├─')} ${chalk.white('Content preview:')} ${chalk.gray(preview)}${call.args.content.length > 100 ? '...' : ''}\n`;
-      msg += `${chalk.gray('├─')} ${chalk.white('Size:')} ${call.args.content.length} bytes\n`;
-    } else if (call.tool === 'edit_file') {
-      msg += `${chalk.gray('├─')} ${chalk.white('File:')} ${chalk.cyan(call.args.path)}\n`;
-      msg += `${chalk.gray('├─')} ${chalk.white('Replace:')} ${chalk.red(call.args.old_text.substring(0, 50))}${call.args.old_text.length > 50 ? '...' : ''}\n`;
-      msg += `${chalk.gray('├─')} ${chalk.white('With:')} ${chalk.green(call.args.new_text.substring(0, 50))}${call.args.new_text.length > 50 ? '...' : ''}\n`;
-    } else if (call.tool === 'git') {
-      msg += `${chalk.gray('├─')} ${chalk.white('Command:')} git ${chalk.yellow(call.args.args)}\n`;
-    }
-    
-    // Safety info
-    msg += chalk.gray('─'.repeat(50)) + '\n';
-    
-    const canUndo = ['write_file', 'edit_file'].includes(call.tool);
-    msg += `${chalk.gray('├─')} ${chalk.white('Undo:')} ${canUndo ? chalk.green('✓ Available (use /undo)') : chalk.gray('✗ Not available')}\n`;
-    msg += `${chalk.gray('└─')} ${chalk.white('Category:')} ${tool.category}\n`;
-    
-    if (tool.dangerous) {
-      msg += `\n${chalk.red.bold('⚠️  WARNING: This is a potentially dangerous action!')}\n`;
-      msg += chalk.red('   The AI is requesting to execute commands on your system.\n');
-    }
-    
-    // Add batch approval hint
-    msg += `\n${chalk.gray('Respond:')} ${chalk.white('[y]es')} ${chalk.gray('/')} ${chalk.white('[n]o')} ${chalk.gray('/')} ${chalk.cyan('[a]pprove all')} ${chalk.cyan(call.tool)} ${chalk.gray('for this turn')}\n`;
-    
-    return msg;
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  // Tool implementations with enhanced error handling and undo support
-
-  /**
-   * Read file with enhanced error handling and suggestions
-   */
-  private readFile(args: Record<string, string>): ToolResult {
-    const filePath = this.resolvePath(args.path);
-    
-    if (!fs.existsSync(filePath)) {
-      // Try to find similar files
-      const dir = path.dirname(filePath);
-      const basename = path.basename(filePath);
-      let suggestions: string[] = [];
-      
-      if (fs.existsSync(dir)) {
-        const files = fs.readdirSync(dir);
-        suggestions = files
-          .filter(f => f.toLowerCase().includes(basename.toLowerCase().slice(0, 3)))
-          .slice(0, 3);
-      }
-      
-      return this.createErrorResult(
-        ToolErrorType.FILE_NOT_FOUND,
-        `File not found: ${args.path}`,
-        suggestions.length > 0 
-          ? `Did you mean one of these? ${suggestions.join(', ')}`
-          : 'Use list_dir to see available files in the directory.'
-      );
-    }
-
-    try {
-      const stats = fs.statSync(filePath);
-      if (stats.size > 1024 * 1024) { // 1MB warning
-        this.logger.warn(`Large file (${(stats.size / 1024 / 1024).toFixed(2)}MB) - consider using start_line/end_line`);
-      }
-      
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const lines = content.split('\n');
-      
-      const startLine = args.start_line ? parseInt(args.start_line) - 1 : 0;
-      const endLine = args.end_line ? parseInt(args.end_line) : lines.length;
-      
-      // Validate line numbers
-      if (startLine < 0 || startLine >= lines.length) {
-        return this.createErrorResult(
-          ToolErrorType.INVALID_ARGS,
-          `Invalid start_line: ${args.start_line}. File has ${lines.length} lines.`
-        );
-      }
-      
-      const selectedLines = lines.slice(startLine, Math.min(endLine, lines.length));
-      
-      return {
-        success: true,
-        output: selectedLines.join('\n'),
-        metadata: {
-          totalLines: lines.length,
-          linesReturned: selectedLines.length,
-          filePath: args.path,
-        },
-      };
-    } catch (error: any) {
-      if (error.code === 'EACCES') {
-        return this.createErrorResult(ToolErrorType.PERMISSION_DENIED, `Permission denied: ${args.path}`);
-      }
-      return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, error.message);
-    }
-  }
-
-  /**
-   * Write file with undo support
-   */
-  private writeFile(args: Record<string, string>): ToolResult {
-    const filePath = this.resolvePath(args.path);
-    const dir = path.dirname(filePath);
-    
-    // Save original content for undo if file exists
-    let originalContent: string | null = null;
-    if (fs.existsSync(filePath)) {
-      originalContent = fs.readFileSync(filePath, 'utf-8');
-    }
-    
-    try {
-      // Create directory if needed
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      
-      fs.writeFileSync(filePath, args.content, 'utf-8');
-      
-      // Store undo operation
-      const undoOp: UndoOperation = {
-        id: `undo-${Date.now()}`,
-        tool: 'write_file',
-        timestamp: Date.now(),
-        filePath: filePath,
-        originalContent: originalContent,
-        description: originalContent 
-          ? `Restore ${args.path} to previous version`
-          : `Delete ${args.path} (was created)`,
-      };
-      this.undoStack.push(undoOp);
-      
-      // Limit undo stack size
-      if (this.undoStack.length > 50) {
-        this.undoStack.shift();
-      }
-      
-      const isNew = originalContent === null;
-      return {
-        success: true,
-        output: `File ${isNew ? 'created' : 'updated'}: ${args.path}`,
-        metadata: {
-          bytes: args.content.length,
-          isNew,
-          canUndo: true,
-        },
-      };
-    } catch (error: any) {
-      if (error.code === 'EACCES') {
-        return this.createErrorResult(ToolErrorType.PERMISSION_DENIED, `Permission denied writing to: ${args.path}`);
-      }
-      if (error.code === 'ENOSPC') {
-        return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, 'No space left on device');
-      }
-      return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, error.message);
-    }
-  }
-
-  /**
-   * Edit file with undo support and helpful error messages
-   */
-  private editFile(args: Record<string, string>): ToolResult {
-    const filePath = this.resolvePath(args.path);
-    
-    if (!fs.existsSync(filePath)) {
-      return this.createErrorResult(
-        ToolErrorType.FILE_NOT_FOUND,
-        `File not found: ${args.path}`,
-        'Use write_file to create a new file, or check the path.'
-      );
-    }
-
-    try {
-      let content = fs.readFileSync(filePath, 'utf-8');
-      const originalContent = content;
-      
-      if (!content.includes(args.old_text)) {
-        // Try to help identify the issue
-        const lines = content.split('\n');
-        const searchTerms = args.old_text.split('\n')[0].trim().slice(0, 30);
-        const possibleMatches = lines
-          .map((line, i) => ({ line: i + 1, content: line }))
-          .filter(l => l.content.includes(searchTerms.slice(0, 10)))
-          .slice(0, 3);
-        
-        let suggestion = 'The exact text was not found. ';
-        if (possibleMatches.length > 0) {
-          suggestion += `Similar content found at lines: ${possibleMatches.map(m => m.line).join(', ')}. `;
-        }
-        suggestion += 'Ensure whitespace and indentation match exactly.';
-        
-        return this.createErrorResult(
-          ToolErrorType.EXECUTION_FAILED,
-          'Old text not found in file',
-          suggestion
-        );
-      }
-      
-      // Check for multiple matches
-      const matchCount = (content.match(new RegExp(args.old_text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
-      if (matchCount > 1) {
-        this.logger.warn(`Found ${matchCount} matches - only replacing first occurrence`);
-      }
-      
-      content = content.replace(args.old_text, args.new_text);
-      fs.writeFileSync(filePath, content, 'utf-8');
-      
-      // Store undo operation
-      const undoOp: UndoOperation = {
-        id: `undo-${Date.now()}`,
-        tool: 'edit_file',
-        timestamp: Date.now(),
-        filePath: filePath,
-        originalContent: originalContent,
-        description: `Restore ${args.path} (reverts edit)`,
-      };
-      this.undoStack.push(undoOp);
-      
-      // Limit undo stack size
-      if (this.undoStack.length > 50) {
-        this.undoStack.shift();
-      }
-      
-      return {
-        success: true,
-        output: `File edited: ${args.path}`,
-        metadata: {
-          matchesFound: matchCount,
-          canUndo: true,
-        },
-      };
-    } catch (error: any) {
-      if (error.code === 'EACCES') {
-        return this.createErrorResult(ToolErrorType.PERMISSION_DENIED, `Permission denied: ${args.path}`);
-      }
-      return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, error.message);
-    }
-  }
-
-  /**
-   * Execute bash command with enhanced error handling
-   * SECURITY: Commands are sandboxed to workspace directory
-   * WINDOWS: Detects Unix-specific commands and suggests alternatives
-   */
-  private bash(args: Record<string, string>): ToolResult {
-    const cwd = args.cwd ? this.resolvePath(args.cwd) : this.cwd;
-    const timeout = args.timeout ? parseInt(args.timeout) * 1000 : 30000;
-    const os = require('os');
-    const platform = os.platform();
-    
-    // Unix-specific commands that don't exist on Windows
-    const unixOnlyCommands = [
-      'head', 'tail', 'grep', 'awk', 'sed', 'wc', 'cut', 'sort', 'uniq',
-      'xargs', 'find', 'chmod', 'chown', 'ln', 'df', 'du', 'ps', 'kill',
-      'top', 'htop', 'which', 'whereis', 'man', 'less', 'more', 'cat',
-    ];
-    
-    // Check if command uses Unix-only tools on Windows
-    if (platform === 'win32') {
-      const cmdParts = args.command.split(/[|&;]/);
-      for (const part of cmdParts) {
-        const firstWord = part.trim().split(/\s+/)[0].toLowerCase();
-        if (unixOnlyCommands.includes(firstWord)) {
-          return this.createErrorResult(
-            ToolErrorType.EXECUTION_FAILED,
-            `Command '${firstWord}' is not available on Windows`,
-            `Use the 'ssh_exec' tool to run Unix commands on the server, ` +
-            `or use 'fetch_url' for web requests. ` +
-            `PowerShell alternatives: dir (ls), type (cat), findstr (grep), select-string (grep)`
-          );
-        }
-      }
-      
-      // Check for pipe to Unix command
-      if (args.command.includes('|')) {
-        const pipedCommands = args.command.split('|').map(c => c.trim().split(/\s+/)[0].toLowerCase());
-        for (const cmd of pipedCommands) {
-          if (unixOnlyCommands.includes(cmd)) {
-            return this.createErrorResult(
-              ToolErrorType.EXECUTION_FAILED,
-              `Piped command '${cmd}' is not available on Windows`,
-              `Windows doesn't have '${cmd}'. Use 'ssh_exec' tool to run this command on the Vigthoria server instead.`
-            );
-          }
-        }
-      }
-    }
-    
-    // SECURITY: Block dangerous commands that could access outside workspace
-    const blockedPatterns = [
-      /\bcat\s+\/etc\//i,                    // Reading system files
-      /\bcat\s+\/var\/(?!log)/i,              // Reading /var/ except logs
-      /\bcat\s+\/root\//i,                    // Reading root home
-      /\bcat\s+\/home\/[^\/]+\/\.[^\/]/i,     // Reading hidden files in home dirs
-      /\bcat\s+~\/\./i,                       // Reading hidden files via ~
-      /\bcd\s+(\/etc|\/var\/www|\/root|\/home)/i,  // CD to sensitive dirs
-      /\brm\s+-rf?\s+\//i,                    // Dangerous rm commands
-      /\b(curl|wget).*\|\s*(bash|sh)\b/i,     // Downloading and executing scripts
-      /\bsudo\b/i,                             // Sudo commands
-      /\bsu\s+-/i,                             // Su to root
-      /\bchmod\s+[0-7]*777/i,                  // World-writable permissions
-      /\/(var\/www|opt)\/[a-z]+-?(database|models|coder|mcp|operator|voice|music)/i, // Vigthoria ecosystem
-      /vigthoria-(models|database|mcp|operator|voice|music)/i, // Vigthoria project names
-    ];
-    
-    for (const pattern of blockedPatterns) {
-      if (pattern.test(args.command)) {
-        this.logger.warn(`Security: Blocked potentially dangerous command: ${args.command.substring(0, 50)}...`);
-        return this.createErrorResult(
-          ToolErrorType.PERMISSION_DENIED,
-          'This command is blocked for security reasons',
-          'Commands must operate within your current project workspace.'
-        );
-      }
-    }
-    
-    // Validate working directory
-    if (!fs.existsSync(cwd)) {
-      return this.createErrorResult(
-        ToolErrorType.FILE_NOT_FOUND,
-        `Working directory not found: ${cwd}`,
-        'Check that the directory exists or use an absolute path.'
-      );
-    }
-    
-    try {
-      const startTime = Date.now();
-      
-      // Build exec options based on platform
-      const execOptions: any = {
-        cwd,
-        timeout,
-        encoding: 'utf-8',
-        maxBuffer: 10 * 1024 * 1024, // 10MB
-        stdio: ['pipe', 'pipe', 'pipe'],
-        // Ensure consistent environment
-        env: {
-          ...process.env,
-          // Prevent locale issues
-          LC_ALL: 'C',
-          LANG: 'C',
-        },
-      };
-      
-      // Set shell based on platform for consistent behavior
-      if (platform === 'win32') {
-        execOptions.shell = true; // Use default cmd.exe on Windows
-      } else {
-        // Use /bin/sh on Unix-like systems (more portable than bash)
-        execOptions.shell = '/bin/sh';
-      }
-      
-      const output = execSync(args.command, execOptions) as string;
-      
-      const duration = Date.now() - startTime;
-      
-      return {
-        success: true,
-        output: output.trim(),
-        metadata: {
-          durationMs: duration,
-          cwd,
-        },
-      };
-    } catch (error: any) {
-      // Command failed but may have output
-      const output = error.stdout || '';
-      const stderr = error.stderr || '';
-      
-      // Provide helpful error messages for common cases
-      if (error.killed) {
-        return this.createErrorResult(
-          ToolErrorType.TIMEOUT,
-          `Command timed out after ${timeout/1000}s`,
-          'Try increasing the timeout or breaking the command into smaller parts.'
-        );
-      }
-      
-      if (stderr.includes('command not found') || stderr.includes('not recognized')) {
-        const cmd = args.command.split(' ')[0];
-        return this.createErrorResult(
-          ToolErrorType.EXECUTION_FAILED,
-          `Command not found: ${cmd}`,
-          'Check that the command is installed and in PATH.'
-        );
-      }
-      
-      if (stderr.includes('Permission denied')) {
-        return this.createErrorResult(
-          ToolErrorType.PERMISSION_DENIED,
-          'Permission denied executing command',
-          'Try using sudo or check file/directory permissions.'
-        );
-      }
-      
-      return {
-        success: false,
-        output,
-        error: stderr || error.message,
-        suggestion: 'Check command syntax and try again.',
-        canRetry: !error.killed,
-      };
-    }
-  }
-
-  private grep(args: Record<string, string>): ToolResult {
-    const searchPath = args.path ? this.resolvePath(args.path) : this.cwd;
-    const include = args.include || '*';
-    const os = require('os');
-    
-    // macOS uses BSD grep which has different options than GNU grep
-    const isMac = os.platform() === 'darwin';
-    
-    let cmd: string;
-    if (isMac) {
-      // BSD grep: use -r for recursive, -n for line numbers
-      // Note: BSD grep doesn't support --color=never, just omit it
-      if (args.include) {
-        cmd = `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-      } else {
-        cmd = `grep -rn "${args.pattern}" "${searchPath}"`;
-      }
-    } else {
-      // GNU grep (Linux)
-      if (args.include) {
-        cmd = `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-      } else {
-        cmd = `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
-      }
-    }
-    
-    try {
-      const output = execSync(cmd, {
-        cwd: this.cwd,
-        encoding: 'utf-8',
-        maxBuffer: 5 * 1024 * 1024,
-        timeout: 30000,
-        env: { ...process.env, GREP_OPTIONS: '' }, // Prevent user's grep options from interfering
-      });
-      
-      return { success: true, output: output.trim() };
-    } catch (error: any) {
-      if (error.status === 1) {
-        // No matches found
-        return { success: true, output: 'No matches found' };
-      }
-      return { success: false, error: error.message };
-    }
-  }
-
-  private listDir(args: Record<string, string>): ToolResult {
-    const dirPath = this.resolvePath(args.path);
-    
-    if (!fs.existsSync(dirPath)) {
-      return { success: false, error: `Directory not found: ${args.path}` };
-    }
-
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    const output = entries.map(e => {
-      const suffix = e.isDirectory() ? '/' : '';
-      return e.name + suffix;
-    }).join('\n');
-    
-    return { success: true, output };
-  }
-
-  private glob(args: Record<string, string>): ToolResult {
-    const { globSync } = require('glob');
-    
-    try {
-      const files = globSync(args.pattern, { cwd: this.cwd });
-      return { success: true, output: files.join('\n') };
-    } catch (error) {
-      return { success: false, error: (error as Error).message };
-    }
-  }
-
-  private git(args: Record<string, string>): ToolResult {
-    try {
-      const output = execSync(`git ${args.args}`, {
-        cwd: this.cwd,
-        encoding: 'utf-8',
-        timeout: 60000,
-      });
-      return { success: true, output: output.trim() };
-    } catch (error: any) {
-      return { success: false, error: error.stderr || error.message };
-    }
-  }
-
-  /**
-   * Vigthoria Repository management tool
-   * Allows AI to push, pull, list, share, and manage projects in the Vigthoria Repository
-   */
-  private async repo(args: Record<string, string>): Promise<ToolResult> {
-    const action = args.action?.toLowerCase();
-    const project = args.project;
-    const visibility = args.visibility || 'public';
-    const targetPath = args.path || this.cwd;
-    const description = args.description || '';
-    
-    try {
-      // Push action uses direct API call to Community server (bypasses interactive CLI)
-      if (action === 'push') {
-        if (!project) {
-          return { 
-            success: false, 
-            error: 'Project name is required for push',
-            suggestion: 'Provide a project name, e.g., repo action=push project=my-project'
-          };
-        }
-
-        // Load auth config
-        const configPath = path.join(process.env.HOME || '/root', '.config', 'vigthoria-cli', 'config.json');
-        if (!fs.existsSync(configPath)) {
-          return { success: false, error: 'Not logged in. Run vigthoria login first.' };
-        }
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        const authToken = config.authToken;
-        const apiBase = config.apiUrl || 'https://coder.vigthoria.io';
-        if (!authToken) {
-          return { success: false, error: 'No auth token found. Run vigthoria login first.' };
-        }
-
-        // Build files array
-        let filesArray: Array<{ path: string; content: string }> = [];
-
-        if (args.files) {
-          // AI passed files directly
-          let filesInput: any;
-          if (typeof args.files === 'string') {
-            try { filesInput = JSON.parse(args.files); } catch { filesInput = args.files; }
-          } else {
-            filesInput = args.files;
-          }
-
-          if (Array.isArray(filesInput)) {
-            // Already in [{path, content}] format
-            filesArray = filesInput.map((f: any) => ({ path: f.path || f.name || 'file', content: String(f.content || '') }));
-          } else if (typeof filesInput === 'object' && filesInput !== null) {
-            // {filename: content} format - convert
-            for (const [filePath, content] of Object.entries(filesInput)) {
-              filesArray.push({ path: filePath, content: String(content) });
-            }
-          }
-        }
-
-        // If no files from AI, read from disk
-        if (filesArray.length === 0 && fs.existsSync(targetPath)) {
-          const readDir = (dir: string, base: string): void => {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-              const fullPath = path.join(dir, entry.name);
-              const relPath = path.relative(base, fullPath);
-              // Skip hidden dirs, node_modules, common non-essential dirs
-              if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '__pycache__') continue;
-              if (entry.isDirectory()) {
-                readDir(fullPath, base);
-              } else if (entry.isFile()) {
-                try {
-                  const content = fs.readFileSync(fullPath, 'utf-8');
-                  filesArray.push({ path: relPath, content });
-                } catch { /* skip binary/unreadable files */ }
-              }
-            }
-          };
-
-          const stat = fs.statSync(targetPath);
-          if (stat.isDirectory()) {
-            readDir(targetPath, targetPath);
-          } else {
-            filesArray.push({ path: path.basename(targetPath), content: fs.readFileSync(targetPath, 'utf-8') });
-          }
-        }
-
-        if (filesArray.length === 0) {
-          return { success: false, error: 'No files to push. Provide files parameter or a valid path.' };
-        }
-
-        // POST to Community API via Coder proxy (fallback to direct Community server)
-        const body = JSON.stringify({
-          projectName: project,
-          description: description || `${project} - pushed via Vigthoria AI`,
-          visibility,
-          files: filesArray,
-          commitMessage: `Push from Vigthoria AI: ${filesArray.length} file(s)`
-        });
-
-        const headers = {
-          'Authorization': `Bearer ${authToken}`,
-          'Content-Type': 'application/json'
-        };
-
-        // Try proxy first, then direct Community server
-        const pushUrls = [
-          `${apiBase}/api/community-repo/push`,
-          'http://localhost:9000/api/repo/push'
-        ];
-
-        let result: any;
-        let lastError = '';
-        for (const pushUrl of pushUrls) {
-          try {
-            const response = await fetch(pushUrl, { method: 'POST', headers, body });
-            result = await response.json() as any;
-            if (response.ok && result.success) break;
-            lastError = result.error || result.message || `Status ${response.status}`;
-            result = null;
-          } catch (e: any) {
-            lastError = e.message;
-            result = null;
-          }
-        }
-
-        if (!result || !result.success) {
-          return { 
-            success: false, 
-            error: lastError || 'Push failed on all endpoints',
-            suggestion: 'Check your authentication and try again. Run vigthoria login to refresh your token.'
-          };
-        }
-
-        return {
-          success: true,
-          output: `Successfully pushed "${project}" to Vigthoria Community!\n` +
-                  `Action: ${result.action || 'created'}\n` +
-                  `Files: ${result.filesWritten || filesArray.length}\n` +
-                  `URL: ${result.url || `https://community.vigthoria.io/showcase/${result.projectId}`}`,
-          metadata: { action: 'push', project, filesWritten: result.filesWritten || filesArray.length, url: result.url }
-        };
-      }
-
-      // All other actions use CLI commands
-      let command: string;
-      
-      switch (action) {
-        case 'pull':
-          if (!project) {
-            return { 
-              success: false, 
-              error: 'Project name is required for pull',
-              suggestion: 'Provide a project name, e.g., repo action=pull project=my-project'
-            };
-          }
-          command = `vigthoria repo pull "${project}"`;
-          break;
-          
-        case 'list':
-          command = 'vigthoria repo list';
-          break;
-          
-        case 'status':
-          if (!project) {
-            return { 
-              success: false, 
-              error: 'Project name is required for status',
-              suggestion: 'Provide a project name, e.g., repo action=status project=my-project'
-            };
-          }
-          command = `vigthoria repo status "${project}"`;
-          break;
-          
-        case 'share':
-          if (!project || !args.username) {
-            return { 
-              success: false, 
-              error: 'Project name and username are required for share',
-              suggestion: 'Provide both, e.g., repo action=share project=my-project username=collaborator permission=read'
-            };
-          }
-          const permission = args.permission || 'read';
-          command = `vigthoria repo share "${project}" "${args.username}" --permission ${permission}`;
-          break;
-          
-        case 'delete':
-          if (!project) {
-            return { 
-              success: false, 
-              error: 'Project name is required for delete',
-              suggestion: 'Provide a project name, e.g., repo action=delete project=my-project'
-            };
-          }
-          command = `vigthoria repo delete "${project}" --force`;
-          break;
-          
-        case 'clone':
-          if (!project) {
-            return { 
-              success: false, 
-              error: 'Project name is required for clone',
-              suggestion: 'Provide a project name, e.g., repo action=clone project=my-project path=/path/to/target'
-            };
-          }
-          command = `vigthoria repo clone "${project}" "${targetPath}"`;
-          break;
-          
-        default:
-          return {
-            success: false,
-            error: `Unknown repo action: ${action}`,
-            suggestion: 'Available actions: push, pull, list, status, share, delete, clone'
-          };
-      }
-      
-      const output = execSync(command, {
-        cwd: this.cwd,
-        encoding: 'utf-8',
-        timeout: 120000,
-        env: { ...process.env, FORCE_COLOR: '0' }
-      });
-      
-      return { 
-        success: true, 
-        output: output.trim(),
-        metadata: { action, project }
-      };
-    } catch (error: any) {
-      return { 
-        success: false, 
-        error: error.stderr || error.message,
-        suggestion: 'Make sure you are logged in with vigthoria login and have the required permissions.'
-      };
-    }
-  }
-
-  /**
-   * Fetch URL content - Cross-platform web fetching
-   * Uses Node.js native fetch (available in Node 18+)
-   */
-  private async fetchUrl(args: Record<string, string>): Promise<ToolResult> {
-    const url = args.url;
-    const method = (args.method || 'GET').toUpperCase();
-    
-    // Validate URL
-    if (!url.startsWith('http://') && !url.startsWith('https://')) {
-      return this.createErrorResult(
-        ToolErrorType.INVALID_ARGS,
-        'URL must start with http:// or https://',
-        'Provide a valid URL, e.g., https://example.com'
-      );
-    }
-    
-    try {
-      const fetchOptions: RequestInit = {
-        method,
-        headers: {
-          'User-Agent': 'Vigthoria-CLI/1.5.7',
-          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-        },
-      };
-      
-      // Parse custom headers if provided
-      if (args.headers) {
-        try {
-          const customHeaders = JSON.parse(args.headers);
-          fetchOptions.headers = { ...fetchOptions.headers, ...customHeaders };
-        } catch {
-          this.logger.warn('Invalid headers JSON, using defaults');
-        }
-      }
-      
-      // Add body for POST/PUT requests
-      if (args.body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-        fetchOptions.body = args.body;
-        (fetchOptions.headers as Record<string, string>)['Content-Type'] = 'application/json';
-      }
-      
-      // Use AbortController for timeout
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 30000);
-      fetchOptions.signal = controller.signal;
-      
-      const response = await fetch(url, fetchOptions);
-      clearTimeout(timeout);
-      
-      if (!response.ok) {
-        return this.createErrorResult(
-          ToolErrorType.NETWORK_ERROR,
-          `HTTP ${response.status}: ${response.statusText}`,
-          `The server returned an error. Status: ${response.status}`
-        );
-      }
-      
-      let content = await response.text();
-      
-      // Extract content based on selector if provided (basic HTML extraction)
-      if (args.selector && content.includes('<')) {
-        const selector = args.selector.toLowerCase().trim();
-        
-        if (selector === 'title') {
-          const match = content.match(/<title[^>]*>([^<]*)<\/title>/i);
-          content = match ? match[1].trim() : 'No title found';
-        } else if (selector === 'meta' || selector.includes('meta[')) {
-          const matches = content.match(/<meta[^>]+>/gi) || [];
-          content = matches.length > 0 ? matches.join('\n') : 'No meta tags found';
-        } else if (selector === 'body' || selector === 'text') {
-          // Extract readable text from body
-          const match = content.match(/<body[^>]*>([\s\S]*)<\/body>/i);
-          if (match) {
-            content = match[1]
-              .replace(/<script[\s\S]*?<\/script>/gi, '')
-              .replace(/<style[\s\S]*?<\/style>/gi, '')
-              .replace(/<nav[\s\S]*?<\/nav>/gi, '')
-              .replace(/<header[\s\S]*?<\/header>/gi, '')
-              .replace(/<footer[\s\S]*?<\/footer>/gi, '')
-              .replace(/<[^>]+>/g, ' ')
-              .replace(/\s+/g, ' ')
-              .trim();
-          }
-        } else if (selector === 'links' || selector === 'a') {
-          // Extract all links
-          const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>([^<]*)<\/a>/gi;
-          const links: string[] = [];
-          let linkMatch;
-          while ((linkMatch = linkRegex.exec(content)) !== null) {
-            const href = linkMatch[1];
-            const text = linkMatch[2].trim();
-            if (text && !href.startsWith('#') && !href.startsWith('javascript:')) {
-              links.push(`${text}: ${href}`);
-            }
-          }
-          content = links.length > 0 ? links.join('\n') : 'No links found';
-        } else if (selector.includes(',')) {
-          // Handle compound selectors like "h1, h2, h3"
-          const tags = selector.split(',').map(s => s.trim());
-          const allMatches: string[] = [];
-          for (const tag of tags) {
-            const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'gi');
-            let match;
-            while ((match = regex.exec(content)) !== null) {
-              const text = match[1].replace(/<[^>]+>/g, '').trim();
-              if (text) allMatches.push(`[${tag}] ${text}`);
-            }
-          }
-          content = allMatches.length > 0 ? allMatches.join('\n') : `No ${selector} tags found`;
-        } else if (/^h[1-6]$/.test(selector)) {
-          // Single heading selector
-          const regex = new RegExp(`<${selector}[^>]*>([\\s\\S]*?)</${selector}>`, 'gi');
-          const matches: string[] = [];
-          let match;
-          while ((match = regex.exec(content)) !== null) {
-            const text = match[1].replace(/<[^>]+>/g, '').trim();
-            if (text) matches.push(text);
-          }
-          content = matches.length > 0 ? matches.join('\n') : `No ${selector} tags found`;
-        } else if (selector === 'nav' || selector === 'nav a') {
-          // Extract navigation links
-          const navMatch = content.match(/<nav[^>]*>([\s\S]*?)<\/nav>/gi);
-          if (navMatch) {
-            const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>([^<]*)<\/a>/gi;
-            const links: string[] = [];
-            for (const nav of navMatch) {
-              let linkMatch;
-              while ((linkMatch = linkRegex.exec(nav)) !== null) {
-                const text = linkMatch[2].trim();
-                if (text) links.push(`${text}: ${linkMatch[1]}`);
-              }
-            }
-            content = links.length > 0 ? links.join('\n') : 'No navigation links found';
-          } else {
-            content = 'No navigation found';
-          }
-        } else if (selector === 'footer') {
-          const match = content.match(/<footer[^>]*>([\s\S]*?)<\/footer>/i);
-          content = match ? match[1].replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim() : 'No footer found';
-        } else if (selector === 'images' || selector === 'img') {
-          const imgRegex = /<img[^>]+src=["']([^"']+)["'][^>]*(?:alt=["']([^"']*)["'])?[^>]*>/gi;
-          const images: string[] = [];
-          let imgMatch;
-          while ((imgMatch = imgRegex.exec(content)) !== null) {
-            const src = imgMatch[1];
-            const alt = imgMatch[2] || 'no alt';
-            images.push(`${alt}: ${src}`);
-          }
-          content = images.length > 0 ? images.join('\n') : 'No images found';
-        } else {
-          // Generic tag extraction
-          const regex = new RegExp(`<${selector}[^>]*>([\\s\\S]*?)</${selector}>`, 'gi');
-          const matches: string[] = [];
-          let match;
-          while ((match = regex.exec(content)) !== null) {
-            matches.push(match[1].replace(/<[^>]+>/g, ' ').trim());
-          }
-          content = matches.length > 0 ? matches.join('\n\n---\n\n') : `No ${selector} elements found`;
-        }
-      }
-      
-      // Truncate if too long
-      if (content.length > 50000) {
-        content = content.substring(0, 50000) + '\n... (truncated, content too long)';
-      }
-      
-      return {
-        success: true,
-        output: content,
-        metadata: {
-          url,
-          status: response.status,
-          contentType: response.headers.get('content-type') || 'unknown',
-          contentLength: content.length,
-        },
-      };
-    } catch (error: any) {
-      if (error.name === 'AbortError') {
-        return this.createErrorResult(
-          ToolErrorType.TIMEOUT,
-          'Request timed out after 30 seconds',
-          'The server took too long to respond. Try again or use a different URL.'
-        );
-      }
-      
-      return this.createErrorResult(
-        ToolErrorType.NETWORK_ERROR,
-        error.message,
-        'Check your internet connection and ensure the URL is correct.'
-      );
-    }
-  }
-
-  /**
-   * Execute command via SSH on remote server
-   * Useful for running Unix commands from Windows
-   */
-  private async sshExec(args: Record<string, string>): Promise<ToolResult> {
-    const command = args.command;
-    const host = args.host || 'vigthoria-server';
-    const timeout = args.timeout ? parseInt(args.timeout) * 1000 : 60000;
-    
-    // Security checks for SSH commands
-    const blockedPatterns = [
-      /\brm\s+-rf?\s+\//i,          // Dangerous rm commands
-      /\bsudo\s+rm/i,                // Sudo rm
-      />\s*\/dev\/sd/i,              // Writing to disk devices
-      /\bdd\s+.*of=\/dev/i,          // dd to devices
-      /\bmkfs/i,                     // Format filesystems
-      /shutdown|reboot|halt|poweroff/i, // System control
-    ];
-    
-    for (const pattern of blockedPatterns) {
-      if (pattern.test(command)) {
-        return this.createErrorResult(
-          ToolErrorType.PERMISSION_DENIED,
-          'This command is blocked for security reasons',
-          'Dangerous system commands cannot be executed via SSH.'
-        );
-      }
-    }
-    
-    try {
-      const os = require('os');
-      const platform = os.platform();
-      
-      let sshCommand: string;
-      let execOptions: any = {
-        encoding: 'utf-8',
-        timeout,
-        maxBuffer: 10 * 1024 * 1024,
-      };
-      
-      if (platform === 'win32') {
-        // On Windows, use the ssh command from OpenSSH
-        sshCommand = `ssh -o BatchMode=yes -o StrictHostKeyChecking=no -o ConnectTimeout=10 ${host} "${command.replace(/"/g, '\\"')}"`;
-        execOptions.shell = true;
-      } else {
-        // On Unix-like systems
-        sshCommand = `ssh -o BatchMode=yes -o StrictHostKeyChecking=no -o ConnectTimeout=10 ${host} '${command.replace(/'/g, "'\\''")}'`;
-        execOptions.shell = '/bin/sh';
-      }
-      
-      const output = execSync(sshCommand, execOptions) as string;
-      
-      return {
-        success: true,
-        output: output.trim(),
-        metadata: { host, command },
-      };
-    } catch (error: any) {
-      // Check for common SSH errors
-      const errorMsg = error.stderr || error.message || '';
-      
-      if (errorMsg.includes('Connection refused') || errorMsg.includes('No route to host')) {
-        return this.createErrorResult(
-          ToolErrorType.NETWORK_ERROR,
-          `Cannot connect to SSH host: ${host}`,
-          'Check that the SSH host is correct and the server is running.'
-        );
-      }
-      
-      if (errorMsg.includes('Permission denied') || errorMsg.includes('authentication')) {
-        return this.createErrorResult(
-          ToolErrorType.PERMISSION_DENIED,
-          'SSH authentication failed',
-          'Make sure you have SSH key authentication set up for this host.'
-        );
-      }
-      
-      if (error.killed) {
-        return this.createErrorResult(
-          ToolErrorType.TIMEOUT,
-          `SSH command timed out after ${timeout/1000}s`,
-          'Try a simpler command or increase the timeout.'
-        );
-      }
-      
-      return {
-        success: false,
-        output: error.stdout || '',
-        error: errorMsg,
-        suggestion: 'Check the command syntax and ensure SSH access is configured.',
-      };
-    }
-  }
-
-  /**
-   * Resolve and SANITIZE path - prevent path traversal outside workspace
-   * SECURITY: All paths MUST stay within the workspace (cwd)
-   */
-  private resolvePath(p: string): string {
-    // Resolve the full path (handles both relative and absolute)
-    let resolvedPath: string;
-    if (path.isAbsolute(p)) {
-      resolvedPath = path.normalize(p);
-    } else {
-      resolvedPath = path.normalize(path.join(this.cwd, p));
-    }
-    
-    // SECURITY CHECK: Ensure path is within workspace
-    const workspaceRoot = path.normalize(this.cwd);
-    if (!resolvedPath.startsWith(workspaceRoot + path.sep) && resolvedPath !== workspaceRoot) {
-      // Path is outside workspace - force it back to workspace
-      this.logger.warn(`Security: Blocked access to path outside workspace: ${p}`);
-      // Return the sanitized relative path within workspace
-      const basename = path.basename(p);
-      return path.join(this.cwd, basename);
-    }
-    
-    return resolvedPath;
-  }
-  
-  /**
-   * Check if a path is within the allowed workspace
-   */
-  private isPathWithinWorkspace(p: string): boolean {
-    const resolvedPath = path.normalize(path.isAbsolute(p) ? p : path.join(this.cwd, p));
-    const workspaceRoot = path.normalize(this.cwd);
-    return resolvedPath.startsWith(workspaceRoot + path.sep) || resolvedPath === workspaceRoot;
-  }
-
-  /**
-   * Parse tool calls from AI response (Vigthoria Agent format)
-   * Enhanced to handle various AI output formats including malformed JSON
-   */
-  static parseToolCalls(text: string): ToolCall[] {
-    const calls: ToolCall[] = [];
-    let match;
-    
-    // Helper to extract balanced JSON from a position (handles nested braces)
-    const extractBalancedJson = (str: string, startIdx: number): string | null => {
-      if (str[startIdx] !== '{') return null;
-      let braceCount = 0;
-      let inString = false;
-      let escapeNext = false;
-      
-      for (let i = startIdx; i < str.length; i++) {
-        const char = str[i];
-        
-        if (escapeNext) {
-          escapeNext = false;
-          continue;
-        }
-        
-        if (char === '\\') {
-          escapeNext = true;
-          continue;
-        }
-        
-        if (char === '"') {
-          inString = !inString;
-          continue;
-        }
-        
-        if (!inString) {
-          if (char === '{') braceCount++;
-          else if (char === '}') {
-            braceCount--;
-            if (braceCount === 0) {
-              return str.substring(startIdx, i + 1);
-            }
-          }
-        }
-      }
-      return null;
-    };
-    
-    // Helper to fix common JSON issues from AI outputs
-    // IMPORTANT: Don't blindly replace quotes - it breaks code content
-    const fixJson = (jsonStr: string): string => {
-      // First, escape newlines and control characters
-      let fixed = jsonStr
-        .replace(/\r/g, '')  // Remove carriage returns
-        .replace(/\t/g, '\\t');  // Escape tabs
-      
-      // Escape literal newlines inside strings (but not \n which is already escaped)
-      // We need to be careful - only escape newlines that are inside quoted strings
-      const parts: string[] = [];
-      let inString = false;
-      let currentPart = '';
-      
-      for (let i = 0; i < fixed.length; i++) {
-        const char = fixed[i];
-        const prevChar = i > 0 ? fixed[i - 1] : '';
-        
-        if (char === '"' && prevChar !== '\\') {
-          inString = !inString;
-          currentPart += char;
-        } else if (char === '\n') {
-          if (inString) {
-            currentPart += '\\n';  // Escape the newline
-          } else {
-            currentPart += char;  // Keep as-is outside strings
-          }
-        } else {
-          currentPart += char;
-        }
-      }
-      fixed = currentPart;
-      
-      // Quote unquoted keys (only outside strings)
-      fixed = fixed.replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
-      
-      // Remove trailing commas
-      fixed = fixed.replace(/,\s*}/g, '}');
-      fixed = fixed.replace(/,\s*]/g, ']');
-      
-      return fixed;
-    };
-
-    // Normalize tool name from various formats
-    const normalizeToolName = (name: string): string => {
-      const normalized = name
-        .replace(/^__/, '')  // Remove leading underscores
-        .replace(/__$/, '')  // Remove trailing underscores
-        .replace(/^execute_/i, '')  // Remove execute_ prefix
-        .replace(/_execute$/i, '')  // Remove _execute suffix
-        .toLowerCase();
-      
-      // Map common variations
-      const toolMap: Record<string, string> = {
-        'bash': 'bash',
-        'shell': 'bash',
-        'run': 'bash',
-        'command': 'bash',
-        'list_dir': 'list_dir',
-        'list_directory': 'list_dir',
-        'ls': 'list_dir',
-        'dir': 'list_dir',
-        'read_file': 'read_file',
-        'readfile': 'read_file',
-        'read': 'read_file',
-        'write_file': 'write_file',
-        'writefile': 'write_file',
-        'write': 'write_file',
-        'edit_file': 'edit_file',
-        'editfile': 'edit_file',
-        'edit': 'edit_file',
-      };
-      
-      return toolMap[normalized] || normalized;
-    };
-    
-    // Match <tool_call>...</tool_call> blocks
-    const toolCallRegex = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
-    while ((match = toolCallRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[1]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          calls.push(parsed);
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // Match ```tool format
-    const codeBlockRegex = /```tool\s*\n([\s\S]*?)\n```/g;
-    while ((match = codeBlockRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[1]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          calls.push(parsed);
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // Match ```json blocks with tool definitions
-    const jsonBlockRegex = /```(?:json)?\s*\n?([\s\S]*?"tool"[\s\S]*?)\n?```/g;
-    while ((match = jsonBlockRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[1]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          // Prevent duplicates
-          if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-            calls.push(parsed);
-          }
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // ROBUST PARSER: Find {"tool": at any position and extract balanced JSON
-    // This handles multi-line content in write_file and nested structures
-    const toolMarkerRegex = /\{"tool"\s*:/g;
-    while ((match = toolMarkerRegex.exec(text)) !== null) {
-      const startIdx = match.index;
-      const jsonStr = extractBalancedJson(text, startIdx);
-      
-      if (jsonStr) {
-        try {
-          const parsed = JSON.parse(jsonStr);
-          if (parsed.tool && parsed.args) {
-            parsed.tool = normalizeToolName(parsed.tool);
-            // Prevent duplicates
-            if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-              calls.push(parsed);
-            }
-          }
-        } catch (e) {
-          // Invalid JSON, try to fix it
-          try {
-            const fixed = fixJson(jsonStr);
-            const parsed = JSON.parse(fixed);
-            if (parsed.tool && parsed.args) {
-              parsed.tool = normalizeToolName(parsed.tool);
-              if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-                calls.push(parsed);
-              }
-            }
-          } catch (e2) {
-            // Still invalid - try more aggressive fixing for write_file
-            if (jsonStr.includes('"write_file"') || jsonStr.includes('"content"')) {
-              try {
-                // More aggressive: escape all control characters
-                const aggressiveFix = jsonStr
-                  .replace(/[\x00-\x1F]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
-                  .replace(/'/g, '"');
-                const parsed = JSON.parse(aggressiveFix);
-                if (parsed.tool && parsed.args) {
-                  parsed.tool = normalizeToolName(parsed.tool);
-                  if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-                    calls.push(parsed);
-                  }
-                }
-              } catch (e3) {
-                // Still invalid, skip
-              }
-            }
-          }
-        }
-      }
-    }
-    
-    // Match inline JSON with "tool" key (various formats - tool before args)
-    const inlineToolRegex = /\{[^{}]*"?tool"?\s*:\s*["']?([^"',}]+)["']?[^{}]*"?args"?\s*:\s*\{([^{}]*)\}[^{}]*\}/gi;
-    while ((match = inlineToolRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[0]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-            calls.push(parsed);
-          }
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // Match inline JSON with "args" BEFORE "tool" (handles reversed order from some AI models)
-    const inlineArgsFirstRegex = /\{[^{}]*"?args"?\s*:\s*\{([^{}]*)\}[^{}]*"?tool"?\s*:\s*["']?([^"',}]+)["']?[^{}]*\}/gi;
-    while ((match = inlineArgsFirstRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[0]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-            calls.push(parsed);
-          }
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // Universal: Try to find any JSON object with both "tool" and "args" keys
-    const universalJsonRegex = /\{[^{}]*(?:"tool"|"args")[^{}]*(?:"tool"|"args")[^{}]*\}/gi;
-    while ((match = universalJsonRegex.exec(text)) !== null) {
-      try {
-        const fixed = fixJson(match[0]);
-        const parsed = JSON.parse(fixed);
-        if (parsed.tool && parsed.args) {
-          parsed.tool = normalizeToolName(parsed.tool);
-          if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-            calls.push(parsed);
-          }
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-      }
-    }
-    
-    // Fallback: Try to parse each line as JSON (for plain JSON output without code blocks)
-    // This handles cases where AI outputs just: {"args": {...}, "tool": "..."}
-    const lines = text.split('\n');
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith('{') && trimmed.includes('"tool"') && trimmed.includes('"args"')) {
-        try {
-          // Try to find balanced braces
-          let braceCount = 0;
-          let startIdx = -1;
-          let endIdx = -1;
-          for (let i = 0; i < trimmed.length; i++) {
-            if (trimmed[i] === '{') {
-              if (startIdx === -1) startIdx = i;
-              braceCount++;
-            } else if (trimmed[i] === '}') {
-              braceCount--;
-              if (braceCount === 0 && startIdx !== -1) {
-                endIdx = i + 1;
-                break;
-              }
-            }
-          }
-          if (startIdx !== -1 && endIdx !== -1) {
-            const jsonStr = trimmed.substring(startIdx, endIdx);
-            const fixed = fixJson(jsonStr);
-            const parsed = JSON.parse(fixed);
-            if (parsed.tool && parsed.args) {
-              parsed.tool = normalizeToolName(parsed.tool);
-              if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
-                calls.push(parsed);
-              }
-            }
-          }
-        } catch (e) {
-          // Invalid JSON, skip
-        }
-      }
-    }
-    
-    // Parse Vigthoria V2 format: {"tool": "__BASH__", ...}
-    const vigV2Regex = /"?tool"?\s*:\s*["']__?([A-Za-z_]+)__?["']/gi;
-    while ((match = vigV2Regex.exec(text)) !== null) {
-      try {
-        const toolName = normalizeToolName(match[1]);
-        // Extract args from nearby context
-        const pathMatch = text.match(/"?(?:arg_)?path"?\s*:\s*["']([^"']+)["']/i);
-        const cmdMatch = text.match(/"?command"?\s*:\s*(?:["']([^"']+)["']|\[\s*["']([^"']+)["']\s*\])/i);
-        const contentMatch = text.match(/"?content"?\s*:\s*["']([^"']+)["']/i);
-        
-        const args: Record<string, string> = {};
-        if (pathMatch) args.path = pathMatch[1];
-        if (cmdMatch) args.command = cmdMatch[1] || cmdMatch[2];
-        if (contentMatch) args.content = contentMatch[1];
-        
-        if (Object.keys(args).length > 0) {
-          // Prevent duplicates
-          if (!calls.some(c => c.tool === toolName && JSON.stringify(c.args) === JSON.stringify(args))) {
-            calls.push({ tool: toolName, args });
-          }
-        }
-      } catch (e) {
-        // Skip
-      }
-    }
-    
-    return calls;
-  }
-
-  /**
-   * Get tools formatted for AI system prompt
-   */
-  static getToolsForPrompt(): string {
-    const tools = AgenticTools.getToolDefinitions();
-    
-    let prompt = `## AGENT MODE - YOU MUST USE TOOLS
-
-⚠️ CRITICAL: You are in Agent Mode. You MUST use tools to interact with files and the system.
-DO NOT guess or hallucinate file contents. DO NOT make up directory structures.
-ALWAYS use read_file before discussing what's in a file.
-ALWAYS use list_dir before discussing what's in a directory.
-
-You have access to these tools:
-
-`;
-    
-    for (const tool of tools) {
-      prompt += `## ${tool.name}
-${tool.description}
-Parameters:
-${tool.parameters.map(p => `  - ${p.name}${p.required ? ' (required)' : ''}: ${p.description}`).join('\n')}
-
-`;
-    }
-    
-    prompt += `
-## How to Use Tools
-
-To use a tool, output a JSON block in a code fence with "tool" language:
-
-\`\`\`tool
-{"tool": "tool_name", "args": {"param1": "value1"}}
-\`\`\`
-
-## MANDATORY TOOL USAGE (DO NOT SKIP!)
-
-**When user asks "what's in this folder/directory":**
-→ FIRST use list_dir, THEN respond based on actual results
-
-**When user asks "can you see/read/show me file X":**
-→ FIRST use read_file, THEN respond based on actual contents
-
-**When user mentions a path like "C:\\some\\path" or "/some/path":**
-→ FIRST use list_dir to check if it exists, THEN respond
-
-**NEVER say things like "Here's an overview of the contents..." without first using tools!**
-**NEVER describe files or code you haven't actually read with read_file!**
-
-### Examples:
-
-1. List directory contents:
-\`\`\`tool
-{"tool": "list_dir", "args": {"path": "."}}
-\`\`\`
-
-2. Read a file:
-\`\`\`tool
-{"tool": "read_file", "args": {"path": "src/index.js"}}
-\`\`\`
-
-3. Fetch a web page (full HTML):
-\`\`\`tool
-{"tool": "fetch_url", "args": {"url": "https://example.com"}}
-\`\`\`
-
-4. Fetch specific content with selectors:
-\`\`\`tool
-{"tool": "fetch_url", "args": {"url": "https://example.com", "selector": "h1, h2, h3"}}
-\`\`\`
-   Available selectors: title, body, text, links, nav, footer, images, h1, h2, h3, h1/h2/h3 (compound)
-
-5. Run command on YOUR configured SSH server (requires user SSH setup, NOT Vigthoria servers):
-\`\`\`tool
-{"tool": "ssh_exec", "args": {"command": "curl -s https://example.com | head -20", "host": "your-server"}}
-\`\`\`
-   Note: ssh_exec is for users who have their own servers configured. It does NOT connect to Vigthoria infrastructure.
-
-6. Write a file:
-\`\`\`tool
-{"tool": "write_file", "args": {"path": "hello.py", "content": "print('Hello World')"}}
-\`\`\`
-
-## CRITICAL RULES:
-
-### ABSOLUTELY NO HALLUCINATION (READ THIS CAREFULLY):
-- ONLY use information from tool results you just received in THIS conversation
-- DO NOT make up names, organizations, or content that wasn't in the fetched data
-- DO NOT read random files from the workspace expecting them to contain relevant data
-- If you fetch a website, your analysis MUST be based ONLY on what you just fetched
-- If the user asks about websites A and B, ONLY discuss A and B - don't invent Site C
-- NEVER create fictional organizations, services, or content
-- If you're unsure about something, say "Based on the fetched content, I can see..." not "This organization does..."
-
-### Strategic Planning (VERY IMPORTANT):
-- PLAN before acting - don't issue many redundant tool calls
-- For web comparisons: Fetch each URL ONCE with no selector to get full HTML, then analyze locally
-- Do NOT fetch the same URL multiple times with different selectors - fetch once and parse the result
-- Think step-by-step: 1) Gather data, 2) Analyze it, 3) Present findings
-- If comparing two things, fetch both ONCE, then write a REAL comparison with specific differences
-- Maximum 2-4 tool calls per step is usually enough - don't spam 10+ calls at once
-- Do NOT use list_dir or read_file when the task is about fetching websites - those are for LOCAL files only
-
-### Cross-Platform Compatibility:
-- On Windows, Unix commands (head, tail, grep, awk, sed, wc) are NOT available
-- Use \`fetch_url\` for web requests instead of curl|grep
-- Use \`ssh_exec\` to run Unix commands on the Vigthoria server if needed
-- Use \`read_file\` instead of cat
-- Use \`list_dir\` instead of ls
-
-### Handling Tool Failures:
-- If a tool fails, REPORT the failure honestly to the user
-- NEVER make up or hallucinate content when a tool fails
-- If you cannot access a URL, say "I was unable to fetch the URL because..."
-- If a command fails, explain what happened and suggest alternatives
-- Do NOT write analysis or comparison reports if you couldn't gather the actual data
-
-### Comparison Tasks:
-- When asked to compare websites/files, you MUST produce actual specific differences
-- Don't just describe each site separately - show what Site A has that Site B is missing
-- Use concrete examples: "Site A has a Team page at /team.html, Site B does not"
-- If you need sub-pages, fetch them in follow-up steps after analyzing the main page
-- BASE YOUR COMPARISON ONLY ON THE DATA YOU FETCHED - not on random files in the workspace
-- Quote actual text from the fetched content to support your claims
-
-### File Access:
-- You can ONLY access files within the current project workspace
-- Use relative paths (e.g., "src/file.js", "app.py", "./config.json")
-- Never try to access system files or directories outside the workspace
-- Do NOT read files unrelated to the user's request (e.g., don't read "comparison.md" when asked to fetch websites)
-- When comparing WEBSITES, use fetch_url - do NOT use read_file or list_dir
-
-### Tool Names:
-- Use ONLY these exact tool names: list_dir, read_file, write_file, edit_file, bash, grep, glob, git, repo, fetch_url, ssh_exec
-- The JSON must be valid with double quotes for all keys and string values
-- After tool execution, you will receive results and can continue with the next step
-- Explain what you're doing before using tools
-`;
-    
-    return prompt;
-  }
-}