vibecodingmachine-core 1.0.2 → 2025.11.2-7.1239

package/src/ide-integration/aider-cli-manager.cjs

@@ -1,850 +1,850 @@
-// Aider CLI Manager - handles Aider CLI installation and execution
-const { execSync, spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const ProviderManager = require('./provider-manager.cjs');
-
-// Helper function to get formatted timestamp
-function getTimestamp() {
-  const now = new Date();
-  let hours = now.getHours();
-  const minutes = now.getMinutes().toString().padStart(2, '0');
-  const ampm = hours >= 12 ? 'PM' : 'AM';
-  hours = hours % 12;
-  hours = hours ? hours : 12;
-  const timeZoneString = now.toLocaleTimeString('en-US', { timeZoneName: 'short' });
-  const timezone = timeZoneString.split(' ').pop();
-  return `${hours}:${minutes} ${ampm} ${timezone}`;
-}
-
-class AiderCLIManager {
-  constructor() {
-    this.logger = console;
-    this.runningProcesses = []; // Track all running Aider subprocesses for cleanup
-    this.providerManager = new ProviderManager(); // Track provider rate limits
-  }
-
-  /**
-   * Kill all running Aider processes immediately (force kill all aider processes)
-   */
-  killAllProcesses() {
-    const { execSync } = require('child_process');
-
-    // First, try to kill tracked processes
-    for (const proc of this.runningProcesses) {
-      if (proc && proc.pid) {
-        try {
-          proc.kill('SIGKILL');
-        } catch (err) {
-          // Process already dead
-        }
-      }
-    }
-    this.runningProcesses = [];
-
-    // Then, force kill ALL aider processes (fallback to catch any orphans)
-    try {
-      execSync('pkill -9 -f "\\-m aider"', { stdio: 'ignore' });
-    } catch (err) {
-      // No processes to kill or pkill not available
-    }
-  }
-
-  /**
-   * Kill the current Aider process if it's running (legacy - use killAllProcesses)
-   */
-  killCurrentProcess() {
-    this.killAllProcesses();
-  }
-
-  /**
-   * Check if Aider CLI is installed
-   */
-  isInstalled() {
-    try {
-      // Fast check: try which aider first (instant)
-      try {
-        execSync('which aider', { stdio: 'pipe' });
-        return true;
-      } catch {
-        // Fast check: try common installation paths (file system check, no exec)
-        const os = require('os');
-        const fs = require('fs');
-        const homeDir = os.homedir();
-        const possiblePaths = [
-          `${homeDir}/.local/bin/aider`,
-          '/usr/local/bin/aider',
-          '/opt/homebrew/bin/aider'
-        ];
-        
-        for (const checkPath of possiblePaths) {
-          try {
-            if (fs.existsSync(checkPath)) {
-              return true;
-            }
-          } catch {
-            // Continue checking other paths
-          }
-        }
-        
-        // Last resort: try python3 -m aider (can be slow, but only if other checks fail)
-        // This is the slowest check, so we do it last
-        try {
-          execSync('python3 -m aider --version', { stdio: 'pipe' });
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get Aider CLI version
-   */
-  getVersion() {
-    try {
-      const version = execSync('aider --version', { encoding: 'utf8', stdio: 'pipe' });
-      return version.trim();
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Install Aider CLI
-   */
-  async install() {
-    try {
-      this.logger.log('Installing Aider CLI...');
-      
-      // Try different pip commands in order of preference
-      let pipCommand = null;
-      
-      // First try pip3 (common on macOS)
-      try {
-        execSync('which pip3', { stdio: 'pipe' });
-        pipCommand = 'pip3';
-      } catch {
-        // Try python3 -m pip (also common on macOS)
-        try {
-          execSync('which python3', { stdio: 'pipe' });
-          pipCommand = 'python3 -m pip';
-        } catch {
-          // Try regular pip
-          try {
-            execSync('which pip', { stdio: 'pipe' });
-            pipCommand = 'pip';
-          } catch {
-            throw new Error('No pip command found. Please install Python and pip.');
-          }
-        }
-      }
-      
-      this.logger.log(`Using ${pipCommand} to install Aider CLI...`);
-      execSync(`${pipCommand} install aider-chat`, { stdio: 'inherit', timeout: 120000 });
-      return { success: true };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        needsManualInstall: true,
-        suggestions: [
-          'Install Python: brew install python (if using Homebrew)',
-          'Or download from: https://www.python.org/downloads/',
-          'Then try: pip3 install aider-chat'
-        ]
-      };
-    }
-  }
-
-  /**
-   * Check if Ollama is installed and running
-   */
-  isOllamaInstalled() {
-    try {
-      execSync('which ollama', { stdio: 'pipe' });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Verify Ollama API is accessible
-   */
-  async verifyOllamaAPI() {
-    try {
-      const http = require('http');
-      return new Promise((resolve) => {
-        const req = http.request({
-          hostname: 'localhost',
-          port: 11434,
-          path: '/api/tags',
-          method: 'GET',
-          timeout: 2000
-        }, (res) => {
-          if (res.statusCode === 200) {
-            resolve({ success: true });
-          } else {
-            resolve({ success: false, error: `HTTP ${res.statusCode}` });
-          }
-        });
-
-        req.on('error', () => {
-          resolve({ success: false, error: 'Connection refused' });
-        });
-
-        req.on('timeout', () => {
-          req.destroy();
-          resolve({ success: false, error: 'Timeout' });
-        });
-
-        req.end();
-      });
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Start Ollama service if not running
-   * @returns {Promise<boolean>} True if service is running (or was started), false otherwise
-   */
-  async startOllamaService() {
-    try {
-      // First check if it's already running
-      const apiCheck = await this.verifyOllamaAPI();
-      if (apiCheck.success) {
-        return true; // Already running
-      }
-
-      this.logger.log('Starting Ollama service...');
-
-      // Try to start Ollama service in background
-      const platform = os.platform();
-
-      if (platform === 'darwin') {
-        // On macOS, try to launch Ollama.app first (doesn't require CLI to be in PATH)
-        try {
-          execSync('open -a Ollama', { stdio: 'pipe' });
-          this.logger.log('Launched Ollama.app');
-        } catch (appErr) {
-          // If app doesn't exist, try ollama serve (requires CLI in PATH)
-          if (!this.isOllamaInstalled()) {
-            this.logger.error('Ollama is not installed (neither Ollama.app nor ollama CLI found)');
-            return false;
-          }
-          try {
-            spawn('ollama', ['serve'], {
-              detached: true,
-              stdio: 'ignore'
-            }).unref();
-            this.logger.log('Started ollama serve in background');
-          } catch (err) {
-            this.logger.error('Failed to start Ollama:', err.message);
-            return false;
-          }
-        }
-      } else {
-        // On Linux/Windows, use ollama serve (requires CLI in PATH)
-        if (!this.isOllamaInstalled()) {
-          this.logger.error('Ollama CLI is not installed');
-          return false;
-        }
-        try {
-          spawn('ollama', ['serve'], {
-            detached: true,
-            stdio: 'ignore'
-          }).unref();
-          this.logger.log('Started ollama serve in background');
-        } catch (err) {
-          this.logger.error('Failed to start Ollama:', err.message);
-          return false;
-        }
-      }
-
-      // Wait for service to be ready (max 15 seconds for initial startup)
-      for (let i = 0; i < 30; i++) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        const check = await this.verifyOllamaAPI();
-        if (check.success) {
-          this.logger.log('Ollama service is ready');
-          return true;
-        }
-      }
-
-      // Even if API isn't responding yet, Ollama may still be starting up
-      // Return true so Aider can try (it will handle connection errors)
-      this.logger.warn('Ollama service started but API not responding yet (may still be initializing)');
-      return true;
-    } catch (error) {
-      this.logger.error('Error starting Ollama service:', error.message);
-      return false;
-    }
-  }
-
-  /**
-   * Get Ollama models
-   */
-  async getOllamaModels() {
-    try {
-      const output = execSync('ollama list', { encoding: 'utf8', stdio: 'pipe' });
-      const lines = output.split('\n').slice(1); // Skip header
-      return lines
-        .filter(line => line.trim())
-        .map(line => {
-          const parts = line.trim().split(/\s+/);
-          return parts[0];
-        });
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Configure Aider CLI for Ollama
-   * @param {string} modelName - Model name (e.g., 'llama3.1:8b')
-   */
-  configureForOllama(modelName = 'llama3.1:8b') {
-    // Aider uses environment variables for configuration
-    // No config file needed - just set env vars
-    return {
-      success: true,
-      model: modelName,
-      env: {
-        OPENAI_API_BASE: 'http://localhost:11434/v1',
-        OPENAI_API_KEY: 'ollama'
-      }
-    };
-  }
-
-  /**
-   * Configure Aider CLI for AWS Bedrock
-   * @param {string} bedrockEndpoint - Bedrock endpoint URL (OpenAI-compatible proxy)
-   * @param {string} modelName - Model name
-   */
-  configureForBedrock(bedrockEndpoint, modelName) {
-    return {
-      success: true,
-      model: modelName,
-      env: {
-        OPENAI_API_BASE: bedrockEndpoint,
-        OPENAI_API_KEY: 'bedrock' // Bedrock doesn't need a real key if using a proxy
-      }
-    };
-  }
-
-  /**
-   * Run Aider CLI in background and return process
-   * @param {string} text - The instruction text
-   * @param {string} cwd - Working directory
-   * @param {string} provider - 'ollama' or 'bedrock'
-   * @param {string} modelName - Model name
-   * @param {string} bedrockEndpoint - Bedrock endpoint (if provider is bedrock)
-   * @param {Function} onOutput - Callback for stdout chunks
-   * @param {Function} onError - Callback for stderr chunks
-   * @returns {ChildProcess} The spawned process
-   */
-  runInBackground(text, cwd = process.cwd(), provider = 'ollama', modelName = 'llama3.1:8b', bedrockEndpoint = null, onOutput, onError) {
-    // Build environment variables
-    const env = { ...process.env };
-
-    // CRITICAL: Disable browser opens from litellm/aider (prevents docs from opening in loop)
-    // Use /usr/bin/true as browser command (does nothing, returns success)
-    env.BROWSER = '/usr/bin/true';
-    env.AIDER_NO_BROWSER = '1';
-    env.AIDER_NO_AUTO_COMMITS = '1';  // Prevent auto-commits that might trigger browsers
-
-    // Disable Python webbrowser module completely
-    // This prevents litellm from opening docs when it encounters errors
-    env.PYTHONDONTWRITEBYTECODE = '1';
-    env.PYTHONUNBUFFERED = '1';
-
-    if (provider === 'ollama') {
-      // Aider uses OLLAMA_API_BASE for Ollama models, not OPENAI_API_BASE
-      env.OLLAMA_API_BASE = 'http://localhost:11434';
-      // Also set OPENAI_API_BASE as fallback (some versions might use it)
-      env.OPENAI_API_BASE = 'http://localhost:11434/v1';
-      env.OPENAI_API_KEY = 'ollama';
-    } else if (provider === 'bedrock' && bedrockEndpoint) {
-      env.OPENAI_API_BASE = bedrockEndpoint;
-      env.OPENAI_API_KEY = 'bedrock';
-    }
-
-    // Aider CLI arguments
-    // --yes-always: always auto-apply changes without asking (for autonomous mode)
-    // --auto-commits: enable git commits (allows rollback if changes are bad)
-    // --model: specify the model (must be prefixed with ollama/ for Ollama models)
-    // --edit-format: use diff format to prevent lazy coding / file destruction
-    // --message (-m): send a single message and exit (non-interactive mode)
-    // --no-show-model-warnings: suppress warnings for cleaner output
-    const fullModelName = provider === 'ollama' ? `ollama/${modelName}` : modelName;
-    const args = [
-      '--yes-always',
-      '--auto-commits',  // Changed from --no-git to enable safety commits
-      '--edit-format', 'diff',  // Use diff format to prevent file destruction
-      '--model', fullModelName,
-      '--no-show-model-warnings',
-      '--message', text
-    ];
-
-    // Find aider command (try multiple locations)
-    let aiderCommand = 'aider';
-    let finalArgs = args;
-    
-    try {
-      // First try direct command
-      execSync('which aider', { stdio: 'pipe' });
-      aiderCommand = 'aider';
-      finalArgs = args;
-    } catch {
-      // Try python3 -m aider (most common on macOS)
-      try {
-        execSync('python3 -m aider --version', { stdio: 'pipe' });
-        aiderCommand = 'python3';
-        finalArgs = ['-m', 'aider', ...args];
-      } catch {
-        // Try common installation paths
-        const os = require('os');
-        const homeDir = os.homedir();
-        const possiblePaths = [
-          `${homeDir}/.local/bin/aider`,
-          '/usr/local/bin/aider',
-          '/opt/homebrew/bin/aider'
-        ];
-        
-        let found = false;
-        for (const path of possiblePaths) {
-          const fs = require('fs');
-          if (fs.existsSync(path)) {
-            aiderCommand = path;
-            finalArgs = args;
-            found = true;
-            break;
-          }
-        }
-        
-        if (!found) {
-          // Last resort: try python3 -m aider anyway (might work even if version check fails)
-          aiderCommand = 'python3';
-          finalArgs = ['-m', 'aider', ...args];
-        }
-      }
-    }
-
-    // Add error handler for spawn failures
-    let proc;
-    try {
-      // Suppress verbose logging for cleaner output
-      // this.logger.log(`Spawning: ${aiderCommand} ${finalArgs.join(' ')}`);
-      proc = spawn(aiderCommand, finalArgs, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: env,
-        cwd: cwd
-      });
-
-      // Handle spawn errors (e.g., aider not found)
-      proc.on('error', (spawnError) => {
-        if (onError) {
-          onError(`Failed to spawn Aider CLI: ${spawnError.message}\n`);
-          if (spawnError.code === 'ENOENT') {
-            onError('Aider CLI is not installed or not in PATH. Install with: pip install aider-chat\n');
-          }
-        }
-      });
-
-      if (onOutput) {
-        proc.stdout.on('data', (data) => {
-          onOutput(data.toString());
-        });
-      }
-
-      if (onError) {
-        proc.stderr.on('data', (data) => {
-          onError(data.toString());
-        });
-      }
-    } catch (spawnError) {
-      // If spawn itself fails (shouldn't happen, but handle it)
-      if (onError) {
-        onError(`Failed to start Aider CLI: ${spawnError.message}\n`);
-      }
-      // Return a mock process that will fail immediately
-      const { EventEmitter } = require('events');
-      const mockProc = new EventEmitter();
-      mockProc.pid = null;
-      mockProc.kill = () => {};
-      mockProc.on = () => {};
-      mockProc.stdout = { on: () => {} };
-      mockProc.stderr = { on: () => {} };
-      setTimeout(() => {
-        mockProc.emit('close', 1);
-      }, 0);
-      return mockProc;
-    }
-
-    return proc;
-  }
-
-  /**
-   * Send text to Aider CLI and execute (non-blocking, returns immediately)
-   * @param {string} text - The instruction text to send
-   * @param {string} cwd - Working directory (defaults to current)
-   * @param {string} provider - 'ollama' or 'bedrock'
-   * @param {string} modelName - Model name
-   * @param {string} bedrockEndpoint - Bedrock endpoint (if provider is bedrock)
-   * @param {Array<string>} filesToAdd - Optional array of file paths to add to Aider's context
-   * @param {Function} onOutput - Optional callback for output (filtered)
-   * @param {Function} onError - Optional callback for errors
-   * @returns {Promise<Object>} Result with success, output, and error
-   */
-  async sendText(text, cwd = process.cwd(), provider = 'ollama', modelName = 'llama3.1:8b', bedrockEndpoint = null, filesToAdd = [], onOutput = null, onError = null, timeoutMs = 300000) {
-    if (!this.isInstalled()) {
-      return {
-        success: false,
-        error: 'Aider CLI is not installed. Run install() first.',
-        needsInstall: true
-      };
-    }
-
-    // Start Ollama service if using Ollama provider
-    if (provider === 'ollama') {
-      const ollamaStarted = await this.startOllamaService();
-      if (!ollamaStarted) {
-        return {
-          success: false,
-          error: 'Failed to start Ollama service. Please start it manually with: ollama serve',
-          needsOllama: true
-        };
-      }
-    }
-
-    try {
-      const env = { ...process.env };
-
-      // CRITICAL: Disable browser opens from litellm/aider (prevents docs from opening in loop)
-      // Use /usr/bin/true as browser command (does nothing, returns success)
-      env.BROWSER = '/usr/bin/true';
-      env.AIDER_NO_BROWSER = '1';
-      env.AIDER_NO_AUTO_COMMITS = '1';  // Prevent auto-commits that might trigger browsers
-
-      // Disable Python webbrowser module completely
-      // This prevents litellm from opening docs when it encounters errors
-      env.PYTHONDONTWRITEBYTECODE = '1';
-      env.PYTHONUNBUFFERED = '1';
-
-      if (provider === 'ollama') {
-        // Aider uses OLLAMA_API_BASE for Ollama models, not OPENAI_API_BASE
-        env.OLLAMA_API_BASE = 'http://localhost:11434';
-        // Also set OPENAI_API_BASE as fallback (some versions might use it)
-        env.OPENAI_API_BASE = 'http://localhost:11434/v1';
-        env.OPENAI_API_KEY = 'ollama';
-      } else if (provider === 'bedrock' && bedrockEndpoint) {
-        env.OPENAI_API_BASE = bedrockEndpoint;
-        env.OPENAI_API_KEY = 'bedrock';
-      }
-
-      const fullModelName = provider === 'ollama' ? `ollama/${modelName}` : modelName;
-
-      // For cloud providers with token limits (Groq = 12k), disable repo map entirely
-      const mapTokens = provider === 'groq' ? '0' : '1024';
-
-      const args = [
-        '--yes-always',
-        '--no-auto-commits',  // Disable auto-commits to prevent auto-file-add
-        '--edit-format', 'diff',  // Use diff format to prevent file destruction
-        '--model', fullModelName,
-        '--no-show-model-warnings',
-        '--map-tokens', mapTokens,  // 0 for Groq (no repo map), 1024 for others
-        '--no-suggest-shell-commands',  // Disable shell command suggestions
-        // Add files to context BEFORE --message so Aider can see them
-        ...(filesToAdd && filesToAdd.length > 0 ? filesToAdd : []),
-        '--message', text
-      ];
-
-      // Find aider command (same logic as runInBackground)
-      let aiderCommand = 'aider';
-      let finalArgs = args;
-      
-      try {
-        execSync('which aider', { stdio: 'pipe' });
-        aiderCommand = 'aider';
-        finalArgs = args;
-      } catch {
-        try {
-          execSync('python3 -m aider --version', { stdio: 'pipe' });
-          aiderCommand = 'python3';
-          finalArgs = ['-m', 'aider', ...args];
-        } catch {
-          aiderCommand = 'python3';
-          finalArgs = ['-m', 'aider', ...args]; // Try anyway
-        }
-      }
-
-      // Suppress verbose logging for cleaner output
-      // this.logger.log(`Executing: ${aiderCommand} ${finalArgs.join(' ')}`);
-      // this.logger.log(`Working directory: ${cwd}`);
-      // this.logger.log(`Provider: ${provider}, Model: ${modelName}`);
-
-      return new Promise((resolve) => {
-        const startTime = Date.now();
-        const proc = spawn(aiderCommand, finalArgs, {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: env,
-          cwd: cwd,
-          // Don't create a new process group - stay in parent's group to receive signals
-          detached: false
-        });
-
-        // Store process for cleanup
-        this.runningProcesses.push(proc);
-
-        let stdout = '';
-        let stderr = '';
-        let lastOutputTime = Date.now();
-        let waitingForLLM = false;
-
-        // Loop detection - track repeated output
-        const recentOutputLines = [];
-        const MAX_RECENT_LINES = 50;
-        let loopDetected = false;
-        let rateLimitDetected = false;
-
-        // Status update interval - show progress every 10 seconds if no output
-        const statusInterval = setInterval(() => {
-          const timeSinceOutput = (Date.now() - lastOutputTime) / 1000;
-          if (timeSinceOutput > 10) {
-            const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
-            const chalk = require('chalk');
-            const timestamp = getTimestamp();
-            console.log(chalk.yellow(`[${timestamp}] [AIDER] Still waiting... (${elapsed}s elapsed, ${timeSinceOutput.toFixed(0)}s since last output)`));
-            if (waitingForLLM) {
-              console.log(chalk.yellow(`[${timestamp}] [AIDER] LLM is processing - this may take 1-2 minutes`));
-            }
-          }
-        }, 10000);
-
-        // Hard timeout - kill process if it runs too long
-        let timeoutKilled = false;
-        const hardTimeout = setTimeout(() => {
-          const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
-          const chalk = require('chalk');
-          const timestamp = getTimestamp();
-          console.log(chalk.red(`\n[${timestamp}] ⏰ TIMEOUT: Aider process exceeded ${timeoutMs/1000}s limit (ran for ${elapsed}s)`));
-          console.log(chalk.red(`[${timestamp}] Killing Aider process to prevent hanging...`));
-          timeoutKilled = true;
-          clearInterval(statusInterval);
-          proc.kill('SIGTERM');
-          setTimeout(() => proc.kill('SIGKILL'), 2000); // Force kill after 2s
-        }, timeoutMs);
-
-        proc.stdout.on('data', (data) => {
-          const chunk = data.toString();
-          stdout += chunk;
-          lastOutputTime = Date.now();
-          const timestamp = getTimestamp();
-
-          // Rate limit detection - kill process if rate limited
-          if ((chunk.includes('Rate limit reached') || chunk.includes('rate_limit_exceeded')) && !rateLimitDetected) {
-            rateLimitDetected = true;
-            const chalk = require('chalk');
-            console.log(chalk.yellow(`\n[${timestamp}] ⚠️  RATE LIMIT: API rate limit reached`));
-            console.log(chalk.yellow(`[${timestamp}] Stopping Aider - please try again later or upgrade your plan`));
-
-            // Mark provider as rate limited (parse duration from stderr)
-            // We'll mark it in the close event when we have full stderr
-
-            clearInterval(statusInterval);
-            proc.kill('SIGTERM');
-            setTimeout(() => proc.kill('SIGKILL'), 1000); // Force kill after 1s
-            return;
-          }
-
-          // Loop detection - check for repeated SEARCH/REPLACE blocks
-          if (chunk.includes('<<<<<<< SEARCH') || chunk.includes('>>>>>>> REPLACE')) {
-            const normalizedChunk = chunk.trim().substring(0, 200); // First 200 chars
-            recentOutputLines.push(normalizedChunk);
-
-            // Keep only recent lines
-            if (recentOutputLines.length > MAX_RECENT_LINES) {
-              recentOutputLines.shift();
-            }
-
-            // Check for loops - if we see the same block 3+ times
-            const occurrences = recentOutputLines.filter(line => line === normalizedChunk).length;
-            if (occurrences >= 3 && !loopDetected) {
-              loopDetected = true;
-              const chalk = require('chalk');
-              console.log(chalk.red(`\n[${timestamp}] ⚠️  LOOP DETECTED: Same output repeated ${occurrences} times!`));
-              console.log(chalk.red(`[${timestamp}] Killing Aider process to prevent infinite loop...`));
-              proc.kill('SIGTERM');
-              setTimeout(() => proc.kill('SIGKILL'), 2000); // Force kill after 2s
-              return;
-            }
-          }
-
-          // Detect if we're waiting for LLM response
-          if (chunk.includes('Tokens:') || chunk.toLowerCase().includes('thinking')) {
-            waitingForLLM = true;
-            const chalk = require('chalk');
-            console.log(chalk.cyan(`[${timestamp}] [AIDER] Prompt sent to LLM, waiting for response...`));
-          }
-
-          // Detect when LLM starts responding
-          if (waitingForLLM && (chunk.includes('####') || chunk.includes('```') || chunk.includes('SEARCH/REPLACE'))) {
-            waitingForLLM = false;
-            const chalk = require('chalk');
-            console.log(chalk.green(`[${timestamp}] [AIDER] LLM responding...`));
-          }
-          
-          // Filter and show useful output (Assistant responses, file edits, etc.)
-          // Skip verbose startup messages and warnings
-          const lines = chunk.split('\n');
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed) continue;
-            
-            // Show assistant responses and important messages
-            const shouldShow = trimmed.startsWith('Assistant:') || 
-                trimmed.startsWith('User:') ||
-                trimmed.includes('file listing') ||
-                trimmed.includes('Updated') ||
-                trimmed.includes('Created') ||
-                trimmed.includes('Tokens:') ||
-                (trimmed.startsWith('###') && !trimmed.includes('ONE LINE')) ||
-                // Show meaningful content (not just startup noise)
-                (!trimmed.includes('NotOpenSSLWarning') && 
-                 !trimmed.includes('Warning:') &&
-                 !trimmed.includes('Detected dumb terminal') &&
-                 !trimmed.includes('Aider v') &&
-                 !trimmed.includes('Model:') &&
-                 !trimmed.includes('Git repo:') &&
-                 !trimmed.includes('Repo-map:') &&
-                 !trimmed.includes('─────────────────') &&
-                 trimmed.length > 10); // Only show substantial lines
-            
-            if (shouldShow) {
-              if (onOutput) {
-                onOutput(line + '\n');
-              } else {
-                // Fallback: just write directly if no callback
-                try {
-                  const chalk = require('chalk');
-                  process.stdout.write(chalk.gray(line + '\n'));
-                } catch {
-                  process.stdout.write(line + '\n');
-                }
-              }
-            }
-          }
-        });
-
-        proc.stderr.on('data', (data) => {
-          const chunk = data.toString();
-          stderr += chunk;
-          
-          // Only show actual errors, suppress warnings
-          if (chunk.includes('Error:') || chunk.includes('Failed:') || 
-              (chunk.includes('error') && !chunk.includes('NotOpenSSLWarning') && !chunk.includes('Warning:'))) {
-            if (onError) {
-              onError(chunk.trim());
-            } else {
-              this.logger.error('[Aider Error]', chunk.trim());
-            }
-          }
-        });
-
-        proc.on('close', (code) => {
-          // Remove process from tracking array
-          const index = this.runningProcesses.indexOf(proc);
-          if (index > -1) {
-            this.runningProcesses.splice(index, 1);
-          }
-
-          clearInterval(statusInterval);
-          clearTimeout(hardTimeout);
-          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-          const chalk = require('chalk');
-          const timestamp = getTimestamp();
-
-          if (timeoutKilled) {
-            console.log(chalk.red(`[${timestamp}] [AIDER] Process killed due to timeout after ${elapsed}s`));
-            resolve({
-              success: false,
-              output: stdout,
-              error: 'Timeout: Process exceeded maximum execution time',
-              exitCode: -1,
-              timeout: true
-            });
-          } else if (rateLimitDetected) {
-            console.log(chalk.yellow(`[${timestamp}] [AIDER] Process stopped due to rate limit after ${elapsed}s`));
-
-            // Mark provider as rate limited with duration from error message
-            const errorMessage = stderr + stdout; // Full error with duration
-            this.providerManager.markRateLimited(provider, modelName, errorMessage);
-
-            resolve({
-              success: false,
-              output: stdout,
-              error: 'Rate limit: API rate limit reached - please try again later',
-              errorMessage: errorMessage, // Full error with duration
-              exitCode: -1,
-              rateLimitDetected: true,
-              provider: provider,
-              model: modelName
-            });
-          } else if (loopDetected) {
-            console.log(chalk.red(`[${timestamp}] [AIDER] Process killed due to loop detection after ${elapsed}s`));
-            resolve({
-              success: false,
-              output: stdout,
-              error: 'Loop detected: Same output repeated multiple times',
-              exitCode: -1,
-              loopDetected: true
-            });
-          } else {
-            console.log(chalk.gray(`[${timestamp}] [AIDER] Process closed after ${elapsed}s with code: ${code}`));
-          }
-
-          if (code === 0 && !timeoutKilled && !rateLimitDetected && !loopDetected) {
-            resolve({
-              success: true,
-              output: stdout,
-              stderr: stderr,
-              exitCode: code
-            });
-          } else if (!timeoutKilled && !loopDetected) {
-            resolve({
-              success: false,
-              output: stdout,
-              error: stderr || `Process exited with code ${code}`,
-              exitCode: code
-            });
-          }
-        });
-
-        proc.on('error', (error) => {
-          clearInterval(statusInterval);
-          clearTimeout(hardTimeout);
-          resolve({
-            success: false,
-            error: error.message,
-            exitCode: -1
-          });
-        });
-      });
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-}
-
-module.exports = { AiderCLIManager };
-
+// Aider CLI Manager - handles Aider CLI installation and execution
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const ProviderManager = require('./provider-manager.cjs');
+
+// Helper function to get formatted timestamp
+function getTimestamp() {
+  const now = new Date();
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, '0');
+  const ampm = hours >= 12 ? 'PM' : 'AM';
+  hours = hours % 12;
+  hours = hours ? hours : 12;
+  const timeZoneString = now.toLocaleTimeString('en-US', { timeZoneName: 'short' });
+  const timezone = timeZoneString.split(' ').pop();
+  return `${hours}:${minutes} ${ampm} ${timezone}`;
+}
+
+class AiderCLIManager {
+  constructor() {
+    this.logger = console;
+    this.runningProcesses = []; // Track all running Aider subprocesses for cleanup
+    this.providerManager = new ProviderManager(); // Track provider rate limits
+  }
+
+  /**
+   * Kill all running Aider processes immediately (force kill all aider processes)
+   */
+  killAllProcesses() {
+    const { execSync } = require('child_process');
+
+    // First, try to kill tracked processes
+    for (const proc of this.runningProcesses) {
+      if (proc && proc.pid) {
+        try {
+          proc.kill('SIGKILL');
+        } catch (err) {
+          // Process already dead
+        }
+      }
+    }
+    this.runningProcesses = [];
+
+    // Then, force kill ALL aider processes (fallback to catch any orphans)
+    try {
+      execSync('pkill -9 -f "\\-m aider"', { stdio: 'ignore' });
+    } catch (err) {
+      // No processes to kill or pkill not available
+    }
+  }
+
+  /**
+   * Kill the current Aider process if it's running (legacy - use killAllProcesses)
+   */
+  killCurrentProcess() {
+    this.killAllProcesses();
+  }
+
+  /**
+   * Check if Aider CLI is installed
+   */
+  isInstalled() {
+    try {
+      // Fast check: try which aider first (instant)
+      try {
+        execSync('which aider', { stdio: 'pipe' });
+        return true;
+      } catch {
+        // Fast check: try common installation paths (file system check, no exec)
+        const os = require('os');
+        const fs = require('fs');
+        const homeDir = os.homedir();
+        const possiblePaths = [
+          `${homeDir}/.local/bin/aider`,
+          '/usr/local/bin/aider',
+          '/opt/homebrew/bin/aider'
+        ];
+        
+        for (const checkPath of possiblePaths) {
+          try {
+            if (fs.existsSync(checkPath)) {
+              return true;
+            }
+          } catch {
+            // Continue checking other paths
+          }
+        }
+        
+        // Last resort: try python3 -m aider (can be slow, but only if other checks fail)
+        // This is the slowest check, so we do it last
+        try {
+          execSync('python3 -m aider --version', { stdio: 'pipe' });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get Aider CLI version
+   */
+  getVersion() {
+    try {
+      const version = execSync('aider --version', { encoding: 'utf8', stdio: 'pipe' });
+      return version.trim();
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Install Aider CLI
+   */
+  async install() {
+    try {
+      this.logger.log('Installing Aider CLI...');
+      
+      // Try different pip commands in order of preference
+      let pipCommand = null;
+      
+      // First try pip3 (common on macOS)
+      try {
+        execSync('which pip3', { stdio: 'pipe' });
+        pipCommand = 'pip3';
+      } catch {
+        // Try python3 -m pip (also common on macOS)
+        try {
+          execSync('which python3', { stdio: 'pipe' });
+          pipCommand = 'python3 -m pip';
+        } catch {
+          // Try regular pip
+          try {
+            execSync('which pip', { stdio: 'pipe' });
+            pipCommand = 'pip';
+          } catch {
+            throw new Error('No pip command found. Please install Python and pip.');
+          }
+        }
+      }
+      
+      this.logger.log(`Using ${pipCommand} to install Aider CLI...`);
+      execSync(`${pipCommand} install aider-chat`, { stdio: 'inherit', timeout: 120000 });
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        needsManualInstall: true,
+        suggestions: [
+          'Install Python: brew install python (if using Homebrew)',
+          'Or download from: https://www.python.org/downloads/',
+          'Then try: pip3 install aider-chat'
+        ]
+      };
+    }
+  }
+
+  /**
+   * Check if Ollama is installed and running
+   */
+  isOllamaInstalled() {
+    try {
+      execSync('which ollama', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify Ollama API is accessible
+   */
+  async verifyOllamaAPI() {
+    try {
+      const http = require('http');
+      return new Promise((resolve) => {
+        const req = http.request({
+          hostname: 'localhost',
+          port: 11434,
+          path: '/api/tags',
+          method: 'GET',
+          timeout: 2000
+        }, (res) => {
+          if (res.statusCode === 200) {
+            resolve({ success: true });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}` });
+          }
+        });
+
+        req.on('error', () => {
+          resolve({ success: false, error: 'Connection refused' });
+        });
+
+        req.on('timeout', () => {
+          req.destroy();
+          resolve({ success: false, error: 'Timeout' });
+        });
+
+        req.end();
+      });
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Start Ollama service if not running
+   * @returns {Promise<boolean>} True if service is running (or was started), false otherwise
+   */
+  async startOllamaService() {
+    try {
+      // First check if it's already running
+      const apiCheck = await this.verifyOllamaAPI();
+      if (apiCheck.success) {
+        return true; // Already running
+      }
+
+      this.logger.log('Starting Ollama service...');
+
+      // Try to start Ollama service in background
+      const platform = os.platform();
+
+      if (platform === 'darwin') {
+        // On macOS, try to launch Ollama.app first (doesn't require CLI to be in PATH)
+        try {
+          execSync('open -a Ollama', { stdio: 'pipe' });
+          this.logger.log('Launched Ollama.app');
+        } catch (appErr) {
+          // If app doesn't exist, try ollama serve (requires CLI in PATH)
+          if (!this.isOllamaInstalled()) {
+            this.logger.error('Ollama is not installed (neither Ollama.app nor ollama CLI found)');
+            return false;
+          }
+          try {
+            spawn('ollama', ['serve'], {
+              detached: true,
+              stdio: 'ignore'
+            }).unref();
+            this.logger.log('Started ollama serve in background');
+          } catch (err) {
+            this.logger.error('Failed to start Ollama:', err.message);
+            return false;
+          }
+        }
+      } else {
+        // On Linux/Windows, use ollama serve (requires CLI in PATH)
+        if (!this.isOllamaInstalled()) {
+          this.logger.error('Ollama CLI is not installed');
+          return false;
+        }
+        try {
+          spawn('ollama', ['serve'], {
+            detached: true,
+            stdio: 'ignore'
+          }).unref();
+          this.logger.log('Started ollama serve in background');
+        } catch (err) {
+          this.logger.error('Failed to start Ollama:', err.message);
+          return false;
+        }
+      }
+
+      // Wait for service to be ready (max 15 seconds for initial startup)
+      for (let i = 0; i < 30; i++) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const check = await this.verifyOllamaAPI();
+        if (check.success) {
+          this.logger.log('Ollama service is ready');
+          return true;
+        }
+      }
+
+      // Even if API isn't responding yet, Ollama may still be starting up
+      // Return true so Aider can try (it will handle connection errors)
+      this.logger.warn('Ollama service started but API not responding yet (may still be initializing)');
+      return true;
+    } catch (error) {
+      this.logger.error('Error starting Ollama service:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get Ollama models
+   */
+  async getOllamaModels() {
+    try {
+      const output = execSync('ollama list', { encoding: 'utf8', stdio: 'pipe' });
+      const lines = output.split('\n').slice(1); // Skip header
+      return lines
+        .filter(line => line.trim())
+        .map(line => {
+          const parts = line.trim().split(/\s+/);
+          return parts[0];
+        });
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Configure Aider CLI for Ollama
+   * @param {string} modelName - Model name (e.g., 'llama3.1:8b')
+   */
+  configureForOllama(modelName = 'llama3.1:8b') {
+    // Aider uses environment variables for configuration
+    // No config file needed - just set env vars
+    return {
+      success: true,
+      model: modelName,
+      env: {
+        OPENAI_API_BASE: 'http://localhost:11434/v1',
+        OPENAI_API_KEY: 'ollama'
+      }
+    };
+  }
+
+  /**
+   * Configure Aider CLI for AWS Bedrock
+   * @param {string} bedrockEndpoint - Bedrock endpoint URL (OpenAI-compatible proxy)
+   * @param {string} modelName - Model name
+   */
+  configureForBedrock(bedrockEndpoint, modelName) {
+    return {
+      success: true,
+      model: modelName,
+      env: {
+        OPENAI_API_BASE: bedrockEndpoint,
+        OPENAI_API_KEY: 'bedrock' // Bedrock doesn't need a real key if using a proxy
+      }
+    };
+  }
+
+  /**
+   * Run Aider CLI in background and return process
+   * @param {string} text - The instruction text
+   * @param {string} cwd - Working directory
+   * @param {string} provider - 'ollama' or 'bedrock'
+   * @param {string} modelName - Model name
+   * @param {string} bedrockEndpoint - Bedrock endpoint (if provider is bedrock)
+   * @param {Function} onOutput - Callback for stdout chunks
+   * @param {Function} onError - Callback for stderr chunks
+   * @returns {ChildProcess} The spawned process
+   */
+  runInBackground(text, cwd = process.cwd(), provider = 'ollama', modelName = 'llama3.1:8b', bedrockEndpoint = null, onOutput, onError) {
+    // Build environment variables
+    const env = { ...process.env };
+
+    // CRITICAL: Disable browser opens from litellm/aider (prevents docs from opening in loop)
+    // Use /usr/bin/true as browser command (does nothing, returns success)
+    env.BROWSER = '/usr/bin/true';
+    env.AIDER_NO_BROWSER = '1';
+    env.AIDER_NO_AUTO_COMMITS = '1';  // Prevent auto-commits that might trigger browsers
+
+    // Disable Python webbrowser module completely
+    // This prevents litellm from opening docs when it encounters errors
+    env.PYTHONDONTWRITEBYTECODE = '1';
+    env.PYTHONUNBUFFERED = '1';
+
+    if (provider === 'ollama') {
+      // Aider uses OLLAMA_API_BASE for Ollama models, not OPENAI_API_BASE
+      env.OLLAMA_API_BASE = 'http://localhost:11434';
+      // Also set OPENAI_API_BASE as fallback (some versions might use it)
+      env.OPENAI_API_BASE = 'http://localhost:11434/v1';
+      env.OPENAI_API_KEY = 'ollama';
+    } else if (provider === 'bedrock' && bedrockEndpoint) {
+      env.OPENAI_API_BASE = bedrockEndpoint;
+      env.OPENAI_API_KEY = 'bedrock';
+    }
+
+    // Aider CLI arguments
+    // --yes-always: always auto-apply changes without asking (for autonomous mode)
+    // --auto-commits: enable git commits (allows rollback if changes are bad)
+    // --model: specify the model (must be prefixed with ollama/ for Ollama models)
+    // --edit-format: use diff format to prevent lazy coding / file destruction
+    // --message (-m): send a single message and exit (non-interactive mode)
+    // --no-show-model-warnings: suppress warnings for cleaner output
+    const fullModelName = provider === 'ollama' ? `ollama/${modelName}` : modelName;
+    const args = [
+      '--yes-always',
+      '--auto-commits',  // Changed from --no-git to enable safety commits
+      '--edit-format', 'diff',  // Use diff format to prevent file destruction
+      '--model', fullModelName,
+      '--no-show-model-warnings',
+      '--message', text
+    ];
+
+    // Find aider command (try multiple locations)
+    let aiderCommand = 'aider';
+    let finalArgs = args;
+    
+    try {
+      // First try direct command
+      execSync('which aider', { stdio: 'pipe' });
+      aiderCommand = 'aider';
+      finalArgs = args;
+    } catch {
+      // Try python3 -m aider (most common on macOS)
+      try {
+        execSync('python3 -m aider --version', { stdio: 'pipe' });
+        aiderCommand = 'python3';
+        finalArgs = ['-m', 'aider', ...args];
+      } catch {
+        // Try common installation paths
+        const os = require('os');
+        const homeDir = os.homedir();
+        const possiblePaths = [
+          `${homeDir}/.local/bin/aider`,
+          '/usr/local/bin/aider',
+          '/opt/homebrew/bin/aider'
+        ];
+        
+        let found = false;
+        for (const path of possiblePaths) {
+          const fs = require('fs');
+          if (fs.existsSync(path)) {
+            aiderCommand = path;
+            finalArgs = args;
+            found = true;
+            break;
+          }
+        }
+        
+        if (!found) {
+          // Last resort: try python3 -m aider anyway (might work even if version check fails)
+          aiderCommand = 'python3';
+          finalArgs = ['-m', 'aider', ...args];
+        }
+      }
+    }
+
+    // Add error handler for spawn failures
+    let proc;
+    try {
+      // Suppress verbose logging for cleaner output
+      // this.logger.log(`Spawning: ${aiderCommand} ${finalArgs.join(' ')}`);
+      proc = spawn(aiderCommand, finalArgs, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: env,
+        cwd: cwd
+      });
+
+      // Handle spawn errors (e.g., aider not found)
+      proc.on('error', (spawnError) => {
+        if (onError) {
+          onError(`Failed to spawn Aider CLI: ${spawnError.message}\n`);
+          if (spawnError.code === 'ENOENT') {
+            onError('Aider CLI is not installed or not in PATH. Install with: pip install aider-chat\n');
+          }
+        }
+      });
+
+      if (onOutput) {
+        proc.stdout.on('data', (data) => {
+          onOutput(data.toString());
+        });
+      }
+
+      if (onError) {
+        proc.stderr.on('data', (data) => {
+          onError(data.toString());
+        });
+      }
+    } catch (spawnError) {
+      // If spawn itself fails (shouldn't happen, but handle it)
+      if (onError) {
+        onError(`Failed to start Aider CLI: ${spawnError.message}\n`);
+      }
+      // Return a mock process that will fail immediately
+      const { EventEmitter } = require('events');
+      const mockProc = new EventEmitter();
+      mockProc.pid = null;
+      mockProc.kill = () => {};
+      mockProc.on = () => {};
+      mockProc.stdout = { on: () => {} };
+      mockProc.stderr = { on: () => {} };
+      setTimeout(() => {
+        mockProc.emit('close', 1);
+      }, 0);
+      return mockProc;
+    }
+
+    return proc;
+  }
+
+  /**
+   * Send text to Aider CLI and execute (non-blocking, returns immediately)
+   * @param {string} text - The instruction text to send
+   * @param {string} cwd - Working directory (defaults to current)
+   * @param {string} provider - 'ollama' or 'bedrock'
+   * @param {string} modelName - Model name
+   * @param {string} bedrockEndpoint - Bedrock endpoint (if provider is bedrock)
+   * @param {Array<string>} filesToAdd - Optional array of file paths to add to Aider's context
+   * @param {Function} onOutput - Optional callback for output (filtered)
+   * @param {Function} onError - Optional callback for errors
+   * @returns {Promise<Object>} Result with success, output, and error
+   */
+  async sendText(text, cwd = process.cwd(), provider = 'ollama', modelName = 'llama3.1:8b', bedrockEndpoint = null, filesToAdd = [], onOutput = null, onError = null, timeoutMs = 300000) {
+    if (!this.isInstalled()) {
+      return {
+        success: false,
+        error: 'Aider CLI is not installed. Run install() first.',
+        needsInstall: true
+      };
+    }
+
+    // Start Ollama service if using Ollama provider
+    if (provider === 'ollama') {
+      const ollamaStarted = await this.startOllamaService();
+      if (!ollamaStarted) {
+        return {
+          success: false,
+          error: 'Failed to start Ollama service. Please start it manually with: ollama serve',
+          needsOllama: true
+        };
+      }
+    }
+
+    try {
+      const env = { ...process.env };
+
+      // CRITICAL: Disable browser opens from litellm/aider (prevents docs from opening in loop)
+      // Use /usr/bin/true as browser command (does nothing, returns success)
+      env.BROWSER = '/usr/bin/true';
+      env.AIDER_NO_BROWSER = '1';
+      env.AIDER_NO_AUTO_COMMITS = '1';  // Prevent auto-commits that might trigger browsers
+
+      // Disable Python webbrowser module completely
+      // This prevents litellm from opening docs when it encounters errors
+      env.PYTHONDONTWRITEBYTECODE = '1';
+      env.PYTHONUNBUFFERED = '1';
+
+      if (provider === 'ollama') {
+        // Aider uses OLLAMA_API_BASE for Ollama models, not OPENAI_API_BASE
+        env.OLLAMA_API_BASE = 'http://localhost:11434';
+        // Also set OPENAI_API_BASE as fallback (some versions might use it)
+        env.OPENAI_API_BASE = 'http://localhost:11434/v1';
+        env.OPENAI_API_KEY = 'ollama';
+      } else if (provider === 'bedrock' && bedrockEndpoint) {
+        env.OPENAI_API_BASE = bedrockEndpoint;
+        env.OPENAI_API_KEY = 'bedrock';
+      }
+
+      const fullModelName = provider === 'ollama' ? `ollama/${modelName}` : modelName;
+
+      // For cloud providers with token limits (Groq = 12k), disable repo map entirely
+      const mapTokens = provider === 'groq' ? '0' : '1024';
+
+      const args = [
+        '--yes-always',
+        '--no-auto-commits',  // Disable auto-commits to prevent auto-file-add
+        '--edit-format', 'diff',  // Use diff format to prevent file destruction
+        '--model', fullModelName,
+        '--no-show-model-warnings',
+        '--map-tokens', mapTokens,  // 0 for Groq (no repo map), 1024 for others
+        '--no-suggest-shell-commands',  // Disable shell command suggestions
+        // Add files to context BEFORE --message so Aider can see them
+        ...(filesToAdd && filesToAdd.length > 0 ? filesToAdd : []),
+        '--message', text
+      ];
+
+      // Find aider command (same logic as runInBackground)
+      let aiderCommand = 'aider';
+      let finalArgs = args;
+      
+      try {
+        execSync('which aider', { stdio: 'pipe' });
+        aiderCommand = 'aider';
+        finalArgs = args;
+      } catch {
+        try {
+          execSync('python3 -m aider --version', { stdio: 'pipe' });
+          aiderCommand = 'python3';
+          finalArgs = ['-m', 'aider', ...args];
+        } catch {
+          aiderCommand = 'python3';
+          finalArgs = ['-m', 'aider', ...args]; // Try anyway
+        }
+      }
+
+      // Suppress verbose logging for cleaner output
+      // this.logger.log(`Executing: ${aiderCommand} ${finalArgs.join(' ')}`);
+      // this.logger.log(`Working directory: ${cwd}`);
+      // this.logger.log(`Provider: ${provider}, Model: ${modelName}`);
+
+      return new Promise((resolve) => {
+        const startTime = Date.now();
+        const proc = spawn(aiderCommand, finalArgs, {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: env,
+          cwd: cwd,
+          // Don't create a new process group - stay in parent's group to receive signals
+          detached: false
+        });
+
+        // Store process for cleanup
+        this.runningProcesses.push(proc);
+
+        let stdout = '';
+        let stderr = '';
+        let lastOutputTime = Date.now();
+        let waitingForLLM = false;
+
+        // Loop detection - track repeated output
+        const recentOutputLines = [];
+        const MAX_RECENT_LINES = 50;
+        let loopDetected = false;
+        let rateLimitDetected = false;
+
+        // Status update interval - show progress every 10 seconds if no output
+        const statusInterval = setInterval(() => {
+          const timeSinceOutput = (Date.now() - lastOutputTime) / 1000;
+          if (timeSinceOutput > 10) {
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+            const chalk = require('chalk');
+            const timestamp = getTimestamp();
+            console.log(chalk.yellow(`[${timestamp}] [AIDER] Still waiting... (${elapsed}s elapsed, ${timeSinceOutput.toFixed(0)}s since last output)`));
+            if (waitingForLLM) {
+              console.log(chalk.yellow(`[${timestamp}] [AIDER] LLM is processing - this may take 1-2 minutes`));
+            }
+          }
+        }, 10000);
+
+        // Hard timeout - kill process if it runs too long
+        let timeoutKilled = false;
+        const hardTimeout = setTimeout(() => {
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+          const chalk = require('chalk');
+          const timestamp = getTimestamp();
+          console.log(chalk.red(`\n[${timestamp}] ⏰ TIMEOUT: Aider process exceeded ${timeoutMs/1000}s limit (ran for ${elapsed}s)`));
+          console.log(chalk.red(`[${timestamp}] Killing Aider process to prevent hanging...`));
+          timeoutKilled = true;
+          clearInterval(statusInterval);
+          proc.kill('SIGTERM');
+          setTimeout(() => proc.kill('SIGKILL'), 2000); // Force kill after 2s
+        }, timeoutMs);
+
+        proc.stdout.on('data', (data) => {
+          const chunk = data.toString();
+          stdout += chunk;
+          lastOutputTime = Date.now();
+          const timestamp = getTimestamp();
+
+          // Rate limit detection - kill process if rate limited
+          if ((chunk.includes('Rate limit reached') || chunk.includes('rate_limit_exceeded')) && !rateLimitDetected) {
+            rateLimitDetected = true;
+            const chalk = require('chalk');
+            console.log(chalk.yellow(`\n[${timestamp}] ⚠️  RATE LIMIT: API rate limit reached`));
+            console.log(chalk.yellow(`[${timestamp}] Stopping Aider - please try again later or upgrade your plan`));
+
+            // Mark provider as rate limited (parse duration from stderr)
+            // We'll mark it in the close event when we have full stderr
+
+            clearInterval(statusInterval);
+            proc.kill('SIGTERM');
+            setTimeout(() => proc.kill('SIGKILL'), 1000); // Force kill after 1s
+            return;
+          }
+
+          // Loop detection - check for repeated SEARCH/REPLACE blocks
+          if (chunk.includes('<<<<<<< SEARCH') || chunk.includes('>>>>>>> REPLACE')) {
+            const normalizedChunk = chunk.trim().substring(0, 200); // First 200 chars
+            recentOutputLines.push(normalizedChunk);
+
+            // Keep only recent lines
+            if (recentOutputLines.length > MAX_RECENT_LINES) {
+              recentOutputLines.shift();
+            }
+
+            // Check for loops - if we see the same block 3+ times
+            const occurrences = recentOutputLines.filter(line => line === normalizedChunk).length;
+            if (occurrences >= 3 && !loopDetected) {
+              loopDetected = true;
+              const chalk = require('chalk');
+              console.log(chalk.red(`\n[${timestamp}] ⚠️  LOOP DETECTED: Same output repeated ${occurrences} times!`));
+              console.log(chalk.red(`[${timestamp}] Killing Aider process to prevent infinite loop...`));
+              proc.kill('SIGTERM');
+              setTimeout(() => proc.kill('SIGKILL'), 2000); // Force kill after 2s
+              return;
+            }
+          }
+
+          // Detect if we're waiting for LLM response
+          if (chunk.includes('Tokens:') || chunk.toLowerCase().includes('thinking')) {
+            waitingForLLM = true;
+            const chalk = require('chalk');
+            console.log(chalk.cyan(`[${timestamp}] [AIDER] Prompt sent to LLM, waiting for response...`));
+          }
+
+          // Detect when LLM starts responding
+          if (waitingForLLM && (chunk.includes('####') || chunk.includes('```') || chunk.includes('SEARCH/REPLACE'))) {
+            waitingForLLM = false;
+            const chalk = require('chalk');
+            console.log(chalk.green(`[${timestamp}] [AIDER] LLM responding...`));
+          }
+          
+          // Filter and show useful output (Assistant responses, file edits, etc.)
+          // Skip verbose startup messages and warnings
+          const lines = chunk.split('\n');
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            
+            // Show assistant responses and important messages
+            const shouldShow = trimmed.startsWith('Assistant:') || 
+                trimmed.startsWith('User:') ||
+                trimmed.includes('file listing') ||
+                trimmed.includes('Updated') ||
+                trimmed.includes('Created') ||
+                trimmed.includes('Tokens:') ||
+                (trimmed.startsWith('###') && !trimmed.includes('ONE LINE')) ||
+                // Show meaningful content (not just startup noise)
+                (!trimmed.includes('NotOpenSSLWarning') && 
+                 !trimmed.includes('Warning:') &&
+                 !trimmed.includes('Detected dumb terminal') &&
+                 !trimmed.includes('Aider v') &&
+                 !trimmed.includes('Model:') &&
+                 !trimmed.includes('Git repo:') &&
+                 !trimmed.includes('Repo-map:') &&
+                 !trimmed.includes('─────────────────') &&
+                 trimmed.length > 10); // Only show substantial lines
+            
+            if (shouldShow) {
+              if (onOutput) {
+                onOutput(line + '\n');
+              } else {
+                // Fallback: just write directly if no callback
+                try {
+                  const chalk = require('chalk');
+                  process.stdout.write(chalk.gray(line + '\n'));
+                } catch {
+                  process.stdout.write(line + '\n');
+                }
+              }
+            }
+          }
+        });
+
+        proc.stderr.on('data', (data) => {
+          const chunk = data.toString();
+          stderr += chunk;
+          
+          // Only show actual errors, suppress warnings
+          if (chunk.includes('Error:') || chunk.includes('Failed:') || 
+              (chunk.includes('error') && !chunk.includes('NotOpenSSLWarning') && !chunk.includes('Warning:'))) {
+            if (onError) {
+              onError(chunk.trim());
+            } else {
+              this.logger.error('[Aider Error]', chunk.trim());
+            }
+          }
+        });
+
+        proc.on('close', (code) => {
+          // Remove process from tracking array
+          const index = this.runningProcesses.indexOf(proc);
+          if (index > -1) {
+            this.runningProcesses.splice(index, 1);
+          }
+
+          clearInterval(statusInterval);
+          clearTimeout(hardTimeout);
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          const chalk = require('chalk');
+          const timestamp = getTimestamp();
+
+          if (timeoutKilled) {
+            console.log(chalk.red(`[${timestamp}] [AIDER] Process killed due to timeout after ${elapsed}s`));
+            resolve({
+              success: false,
+              output: stdout,
+              error: 'Timeout: Process exceeded maximum execution time',
+              exitCode: -1,
+              timeout: true
+            });
+          } else if (rateLimitDetected) {
+            console.log(chalk.yellow(`[${timestamp}] [AIDER] Process stopped due to rate limit after ${elapsed}s`));
+
+            // Mark provider as rate limited with duration from error message
+            const errorMessage = stderr + stdout; // Full error with duration
+            this.providerManager.markRateLimited(provider, modelName, errorMessage);
+
+            resolve({
+              success: false,
+              output: stdout,
+              error: 'Rate limit: API rate limit reached - please try again later',
+              errorMessage: errorMessage, // Full error with duration
+              exitCode: -1,
+              rateLimitDetected: true,
+              provider: provider,
+              model: modelName
+            });
+          } else if (loopDetected) {
+            console.log(chalk.red(`[${timestamp}] [AIDER] Process killed due to loop detection after ${elapsed}s`));
+            resolve({
+              success: false,
+              output: stdout,
+              error: 'Loop detected: Same output repeated multiple times',
+              exitCode: -1,
+              loopDetected: true
+            });
+          } else {
+            console.log(chalk.gray(`[${timestamp}] [AIDER] Process closed after ${elapsed}s with code: ${code}`));
+          }
+
+          if (code === 0 && !timeoutKilled && !rateLimitDetected && !loopDetected) {
+            resolve({
+              success: true,
+              output: stdout,
+              stderr: stderr,
+              exitCode: code
+            });
+          } else if (!timeoutKilled && !loopDetected) {
+            resolve({
+              success: false,
+              output: stdout,
+              error: stderr || `Process exited with code ${code}`,
+              exitCode: code
+            });
+          }
+        });
+
+        proc.on('error', (error) => {
+          clearInterval(statusInterval);
+          clearTimeout(hardTimeout);
+          resolve({
+            success: false,
+            error: error.message,
+            exitCode: -1
+          });
+        });
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = { AiderCLIManager };
+