error-solution-ai-buddy 0.0.0-stage → 1.0.1

package/cli/error-listener.js

@@ -0,0 +1,409 @@
+/**
+ * Error Listener - Detects and analyzes errors from stderr
+ * 
+ * This module is responsible for:
+ * 1. Detecting if output contains an error (vs. just warnings/info)
+ * 2. Identifying the programming language
+ * 3. Extracting useful context (error type, line number, file)
+ * 4. Providing pattern-based explanations (fallback when AI unavailable)
+ */
+
+/**
+ * Error patterns for each language
+ * 
+ * WHY we use patterns:
+ * 1. Fast detection without AI
+ * 2. Fallback when Ollama is offline
+ * 3. Helps identify language for better AI prompts
+ */
+const ERROR_PATTERNS = {
+  javascript: {
+    // Pattern: matches the error type and extracts it
+    patterns: [
+      /^(\w*Error): (.+)$/m,                           // TypeError: message
+      /^(\w*Exception): (.+)$/m,                       // ReferenceException: message
+      /SyntaxError: (.+)/,                             // Syntax errors
+      /Cannot find module '(.+)'/,                     // Module not found
+      /is not defined/,                                // Undefined variable
+      /is not a function/,                             // Calling non-function
+      /Cannot read propert(?:y|ies) of (undefined|null)/, // Null/undefined access
+      /ENOENT|EACCES|ECONNREFUSED/,                    // System errors
+    ],
+    stackTraceIndicator: /at\s+(?:\S+\s+)?\(?.*:\d+:\d+\)?/,
+    fileLinePattern: /at\s+.*\(?(.*):(\d+):(\d+)\)?/,
+  },
+  
+  java: {
+    patterns: [
+      /^Exception in thread ".*" (\w+(?:\.\w+)*): (.*)$/m,  // Exception in thread "main"
+      /^(\w+(?:\.\w+)*Exception): (.*)$/m,                   // NullPointerException:
+      /^(\w+(?:\.\w+)*Error): (.*)$/m,                       // OutOfMemoryError:
+      /^Caused by: (\w+(?:\.\w+)*): (.*)$/m,                 // Caused by:
+      /cannot find symbol/,                                   // Compile error
+      /error: (.+)/,                                          // Generic error
+      /incompatible types/,                                   // Type mismatch
+    ],
+    stackTraceIndicator: /at\s+[\w.$]+\([\w.]+:\d+\)/,
+    fileLinePattern: /at\s+[\w.$]+\(([\w.]+):(\d+)\)/,
+  },
+  
+  csharp: {
+    patterns: [
+      /^Unhandled exception\. (\w+(?:\.\w+)*): (.*)$/m,     // Unhandled exception.
+      /^(\w+(?:\.\w+)*Exception): (.*)$/m,                   // NullReferenceException:
+      /error CS\d+: (.+)/,                                   // Compiler error
+      /Object reference not set/,                            // NullRef
+      /Index was outside the bounds/,                        // Array bounds
+      /The type or namespace name .* could not be found/,    // Missing type
+    ],
+    stackTraceIndicator: /at\s+[\w.<>]+\(.*\)\s+in\s+.*:line\s+\d+/,
+    fileLinePattern: /in\s+(.*):line\s+(\d+)/,
+  }
+};
+
+/**
+ * Common error explanations (used when AI is unavailable)
+ * 
+ * WHY we have local explanations:
+ * - Works offline
+ * - Instant response (no network latency)
+ * - Fallback if Ollama fails
+ */
+const COMMON_ERRORS = {
+  javascript: {
+    'TypeError': {
+      'Cannot read propert': {
+        what: 'You tried to access a property on something that is undefined or null.',
+        why: 'The variable you\'re accessing doesn\'t exist or hasn\'t been assigned a value yet.',
+        fix: 'Add a null check before accessing properties.',
+        example: `// Instead of: data.users.map(...)
+// Do this:
+if (data && data.users) {
+  data.users.map(...)
+}`
+      },
+      'is not a function': {
+        what: 'You tried to call something as a function, but it\'s not a function.',
+        why: 'The variable might be undefined, or you imported/accessed the wrong thing.',
+        fix: 'Check that you\'re calling the right function and it\'s properly imported.',
+        example: `// Check if it's a function first:
+if (typeof myFunc === 'function') {
+  myFunc();
+}`
+      }
+    },
+    'ReferenceError': {
+      'is not defined': {
+        what: 'You\'re using a variable that doesn\'t exist in the current scope.',
+        why: 'Either the variable was never declared, or it\'s spelled wrong, or it\'s out of scope.',
+        fix: 'Make sure the variable is declared (const, let, var) before using it.',
+        example: `// Wrong:
+console.log(myVar);
+
+// Right:
+const myVar = 'hello';
+console.log(myVar);`
+      }
+    },
+    'SyntaxError': {
+      'default': {
+        what: 'Your code has a syntax mistake that JavaScript cannot understand.',
+        why: 'Missing brackets, quotes, semicolons, or other syntax issues.',
+        fix: 'Check the line number mentioned and look for missing or extra characters.',
+        example: `// Common issues:
+// - Missing closing bracket: { or }
+// - Missing closing parenthesis: ( or )
+// - Missing quotes: " or '
+// - Extra/missing comma in arrays/objects`
+      }
+    },
+    'ENOENT': {
+      'default': {
+        what: 'A file or directory you tried to access doesn\'t exist.',
+        why: 'The path is wrong, or the file was deleted/moved.',
+        fix: 'Check that the file path is correct and the file exists.',
+        example: `// Check if file exists first:
+const fs = require('fs');
+if (fs.existsSync('./myfile.txt')) {
+  // read file
+}`
+      }
+    },
+    'ECONNREFUSED': {
+      'default': {
+        what: 'Your code tried to connect to a server that refused the connection.',
+        why: 'The server might not be running, wrong port, or firewall blocking.',
+        fix: 'Make sure the server is running and the port/host are correct.',
+        example: `// Common checks:
+// 1. Is the database/server running?
+// 2. Is the port correct? (e.g., 3000, 5432)
+// 3. Is it localhost or 127.0.0.1?`
+      }
+    }
+  },
+  
+  java: {
+    'NullPointerException': {
+      'default': {
+        what: 'You tried to use an object that is null (doesn\'t exist).',
+        why: 'A variable wasn\'t initialized, or a method returned null.',
+        fix: 'Add null checks before using objects.',
+        example: `// Instead of: user.getName()
+// Do this:
+if (user != null) {
+    user.getName();
+}
+
+// Or use Optional:
+Optional.ofNullable(user).map(User::getName);`
+      }
+    },
+    'ArrayIndexOutOfBoundsException': {
+      'default': {
+        what: 'You tried to access an array index that doesn\'t exist.',
+        why: 'Arrays are 0-indexed, so an array of size 5 has indices 0-4.',
+        fix: 'Check array length before accessing an index.',
+        example: `// Wrong: accessing index 5 in array of size 5
+int[] arr = new int[5];
+arr[5] = 10; // Error! Valid indices are 0-4
+
+// Right:
+if (index >= 0 && index < arr.length) {
+    arr[index] = 10;
+}`
+      }
+    },
+    'ClassNotFoundException': {
+      'default': {
+        what: 'Java cannot find a class you\'re trying to use.',
+        why: 'The class isn\'t in your classpath, or the name is misspelled.',
+        fix: 'Check your dependencies (pom.xml/build.gradle) and class name.',
+        example: `// Check:
+// 1. Is the dependency in pom.xml?
+// 2. Did you run 'mvn install'?
+// 3. Is the class name spelled correctly?
+// 4. Is the import statement correct?`
+      }
+    },
+    'cannot find symbol': {
+      'default': {
+        what: 'Java compiler cannot find a variable, method, or class you\'re using.',
+        why: 'Typo in name, missing import, or wrong scope.',
+        fix: 'Check spelling and make sure imports are correct.',
+        example: `// Common causes:
+// 1. Typo: myVarible instead of myVariable
+// 2. Missing import statement
+// 3. Variable declared in different scope
+// 4. Method doesn't exist in that class`
+      }
+    }
+  },
+  
+  csharp: {
+    'NullReferenceException': {
+      'default': {
+        what: 'You tried to use an object that is null.',
+        why: 'A variable wasn\'t initialized, or a method returned null.',
+        fix: 'Add null checks or use null-conditional operators.',
+        example: `// Instead of: user.Name
+// Use null-conditional:
+var name = user?.Name;
+
+// Or null check:
+if (user != null)
+{
+    var name = user.Name;
+}`
+      }
+    },
+    'IndexOutOfRangeException': {
+      'default': {
+        what: 'You tried to access an array/list index that doesn\'t exist.',
+        why: 'The index is negative or greater than the collection size.',
+        fix: 'Check collection length before accessing an index.',
+        example: `// Wrong:
+var items = new int[5];
+var x = items[5]; // Error!
+
+// Right:
+if (index >= 0 && index < items.Length)
+{
+    var x = items[index];
+}`
+      }
+    },
+    'CS0103': {
+      'default': {
+        what: 'The name you\'re using doesn\'t exist in the current context.',
+        why: 'Variable not declared, typo, or missing using statement.',
+        fix: 'Check variable spelling and add any missing using statements.',
+        example: `// Did you forget to add:
+using System.Linq;
+using YourNamespace;
+
+// Or declare the variable:
+var myVariable = "value";`
+      }
+    },
+    'CS0246': {
+      'default': {
+        what: 'C# cannot find a type or namespace you\'re trying to use.',
+        why: 'Missing using statement, missing NuGet package, or typo.',
+        fix: 'Add the using statement or install the required NuGet package.',
+        example: `// Add using statement:
+using Newtonsoft.Json;
+
+// Or install package:
+// dotnet add package Newtonsoft.Json`
+      }
+    }
+  }
+};
+
+export class ErrorListener {
+  constructor() {
+    this.patterns = ERROR_PATTERNS;
+    this.explanations = COMMON_ERRORS;
+  }
+
+  /**
+   * Quick check if text looks like an error
+   * 
+   * WHY: We don't want to trigger AI for every output.
+   * Only analyze when there's likely an actual error.
+   */
+  detectError(text) {
+    const errorIndicators = [
+      /error/i,
+      /exception/i,
+      /failed/i,
+      /cannot/i,
+      /unable to/i,
+      /fatal/i,
+      /ENOENT|EACCES|ECONNREFUSED/,
+      /at\s+[\w.]+\(.*:\d+/,  // Stack trace pattern
+    ];
+
+    return errorIndicators.some(pattern => pattern.test(text));
+  }
+
+  /**
+   * Analyze the error and extract useful information
+   */
+  analyzeError(errorText) {
+    const analysis = {
+      isError: false,
+      language: this.detectLanguage(errorText),
+      errorType: null,
+      errorMessage: null,
+      file: null,
+      line: null,
+      column: null,
+      localExplanation: null,
+    };
+
+    if (!analysis.language) {
+      // Try to still detect if it's an error
+      analysis.isError = this.detectError(errorText);
+      analysis.language = 'unknown';
+      return analysis;
+    }
+
+    const langPatterns = this.patterns[analysis.language];
+    
+    // Try to match error patterns
+    for (const pattern of langPatterns.patterns) {
+      const match = errorText.match(pattern);
+      if (match) {
+        analysis.isError = true;
+        analysis.errorType = match[1] || null;
+        analysis.errorMessage = match[2] || match[1] || null;
+        break;
+      }
+    }
+
+    // Extract file and line number
+    if (langPatterns.fileLinePattern) {
+      const fileMatch = errorText.match(langPatterns.fileLinePattern);
+      if (fileMatch) {
+        analysis.file = fileMatch[1];
+        analysis.line = fileMatch[2];
+        analysis.column = fileMatch[3] || null;
+      }
+    }
+
+    // Get local explanation if available
+    analysis.localExplanation = this.getLocalExplanation(analysis, errorText);
+
+    return analysis;
+  }
+
+  /**
+   * Detect programming language from error output
+   */
+  detectLanguage(errorText) {
+    // JavaScript/Node.js indicators
+    if (
+      /(TypeError|ReferenceError|SyntaxError)[:\s]/i.test(errorText) ||
+      /at\s+\S+\s+\(.*\.js:\d+:\d+\)/.test(errorText) ||
+      /at\s+.*\.js:\d+:\d+/.test(errorText) ||
+      /node_modules/.test(errorText) ||
+      /ENOENT|EACCES|ECONNREFUSED/.test(errorText) ||
+      /Cannot find module/.test(errorText)
+    ) {
+      return 'javascript';
+    }
+
+    // Java indicators
+    if (
+      /at\s+[\w.$]+\([\w.]+\.java:\d+\)/.test(errorText) ||
+      /Exception in thread/.test(errorText) ||
+      /\.java:\d+:/.test(errorText) ||
+      /at\s+java\./.test(errorText)
+    ) {
+      return 'java';
+    }
+
+    // C# indicators
+    if (
+      /at\s+[\w.<>]+\(.*\)\s+in\s+.*:line\s+\d+/.test(errorText) ||
+      /error CS\d+/.test(errorText) ||
+      /\.cs\(\d+,\d+\)/.test(errorText) ||
+      /Unhandled exception\. System\./.test(errorText) ||
+      /at\s+System\./.test(errorText)
+    ) {
+      return 'csharp';
+    }
+
+    return null;
+  }
+
+  /**
+   * Get local explanation for an error (used when AI is unavailable)
+   */
+  getLocalExplanation(analysis, errorText) {
+    if (!analysis.language || !this.explanations[analysis.language]) {
+      return null;
+    }
+
+    const langExplanations = this.explanations[analysis.language];
+    
+    // Try to find matching explanation
+    for (const [errorType, subErrors] of Object.entries(langExplanations)) {
+      if (errorText.includes(errorType) || analysis.errorType?.includes(errorType)) {
+        // Check for specific sub-patterns
+        for (const [subPattern, explanation] of Object.entries(subErrors)) {
+          if (subPattern === 'default' || errorText.includes(subPattern)) {
+            return explanation;
+          }
+        }
+        // Return default if exists
+        if (subErrors.default) {
+          return subErrors.default;
+        }
+      }
+    }
+
+    return null;
+  }
+}

package/cli/formatter.js

@@ -0,0 +1,244 @@
+/**
+ * Formatter - Pretty prints error explanations to the terminal
+ * 
+ * This module handles all output formatting to make errors
+ * easy to read at a glance.
+ * 
+ * WHY separate formatting:
+ * 1. Single responsibility (easy to maintain)
+ * 2. Easy to change styling without touching logic
+ * 3. Can support different output formats (terminal, JSON, etc.)
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+
+export class Formatter {
+  constructor(options = {}) {
+    this.useColor = options.useColor !== false;
+    this.useEmoji = options.useEmoji !== false;
+    this.boxStyle = options.boxStyle || 'round';
+  }
+
+  /**
+   * Print AI-generated explanation
+   * 
+   * Expected format from AI:
+   * {
+   *   what: "What the error is",
+   *   why: "Why it happened",
+   *   fix: "How to fix it",
+   *   example: "Code example"
+   * }
+   */
+  printAIExplanation(explanation) {
+    const header = this.useEmoji ? '🤖 Error Buddy Explanation:' : '[Error Buddy]';
+    
+    let content = '';
+    
+    // What is this?
+    if (explanation.what) {
+      content += chalk.cyan.bold(this.useEmoji ? '📘 What is this?' : '[What]') + '\n';
+      content += this.wrapText(explanation.what) + '\n\n';
+    }
+    
+    // Why it happens?
+    if (explanation.why) {
+      content += chalk.yellow.bold(this.useEmoji ? '❓ Why it happens?' : '[Why]') + '\n';
+      content += this.wrapText(explanation.why) + '\n\n';
+    }
+    
+    // How to fix?
+    if (explanation.fix) {
+      content += chalk.green.bold(this.useEmoji ? '✅ How to fix it:' : '[Fix]') + '\n';
+      content += this.wrapText(explanation.fix) + '\n';
+    }
+    
+    // Code example
+    if (explanation.example) {
+      content += '\n' + chalk.magenta.bold(this.useEmoji ? '💡 Example:' : '[Example]') + '\n';
+      content += chalk.gray(this.formatCode(explanation.example));
+    }
+
+    // Print in a box
+    const box = boxen(content.trim(), {
+      title: header,
+      titleAlignment: 'left',
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: this.boxStyle,
+      borderColor: 'cyan',
+    });
+
+    console.log(box);
+  }
+
+  /**
+   * Print pattern-based explanation (when AI is unavailable)
+   */
+  printPatternExplanation(analysis) {
+    if (!analysis.localExplanation) {
+      this.printGenericHelp(analysis);
+      return;
+    }
+
+    const explanation = analysis.localExplanation;
+    const header = this.useEmoji ? '📋 Quick Explanation:' : '[Quick Help]';
+    
+    let content = '';
+    
+    // Language detected
+    if (analysis.language && analysis.language !== 'unknown') {
+      content += chalk.gray(`Language: ${this.formatLanguage(analysis.language)}`) + '\n';
+      if (analysis.errorType) {
+        content += chalk.gray(`Error: ${analysis.errorType}`) + '\n';
+      }
+      content += '\n';
+    }
+
+    // What
+    content += chalk.cyan.bold(this.useEmoji ? '📘 What:' : '[What]') + '\n';
+    content += this.wrapText(explanation.what) + '\n\n';
+
+    // Why
+    content += chalk.yellow.bold(this.useEmoji ? '❓ Why:' : '[Why]') + '\n';
+    content += this.wrapText(explanation.why) + '\n\n';
+
+    // Fix
+    content += chalk.green.bold(this.useEmoji ? '✅ Fix:' : '[Fix]') + '\n';
+    content += this.wrapText(explanation.fix) + '\n';
+
+    // Example
+    if (explanation.example) {
+      content += '\n' + chalk.magenta.bold(this.useEmoji ? '💡 Example:' : '[Example]') + '\n';
+      content += chalk.gray(this.formatCode(explanation.example));
+    }
+
+    // Offline notice
+    content += '\n\n' + chalk.gray.italic('(Offline mode - start Ollama for AI explanations)');
+
+    const box = boxen(content.trim(), {
+      title: header,
+      titleAlignment: 'left',
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: this.boxStyle,
+      borderColor: 'yellow',
+    });
+
+    console.log(box);
+  }
+
+  /**
+   * Print generic help when no pattern matches
+   */
+  printGenericHelp(analysis) {
+    const header = this.useEmoji ? '🔍 Error Detected:' : '[Error]';
+    
+    let content = '';
+    
+    if (analysis.language && analysis.language !== 'unknown') {
+      content += chalk.gray(`Language: ${this.formatLanguage(analysis.language)}`) + '\n';
+    }
+    
+    if (analysis.errorType) {
+      content += chalk.gray(`Type: ${analysis.errorType}`) + '\n';
+    }
+    
+    if (analysis.file) {
+      content += chalk.gray(`File: ${analysis.file}`) + '\n';
+    }
+    
+    if (analysis.line) {
+      content += chalk.gray(`Line: ${analysis.line}`) + '\n';
+    }
+
+    content += '\n';
+    content += chalk.cyan('Start Ollama for detailed AI explanations:') + '\n';
+    content += chalk.white('  1. Install Ollama: https://ollama.ai') + '\n';
+    content += chalk.white('  2. Run: ollama serve') + '\n';
+    content += chalk.white('  3. Try your command again') + '\n';
+
+    const box = boxen(content.trim(), {
+      title: header,
+      titleAlignment: 'left',
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: this.boxStyle,
+      borderColor: 'gray',
+    });
+
+    console.log(box);
+  }
+
+  /**
+   * Format language name nicely
+   */
+  formatLanguage(lang) {
+    const names = {
+      javascript: 'JavaScript/Node.js',
+      java: 'Java',
+      csharp: 'C#/.NET',
+      python: 'Python',
+      unknown: 'Unknown',
+    };
+    return names[lang] || lang;
+  }
+
+  /**
+   * Wrap text to terminal width
+   */
+  wrapText(text, maxWidth = 70) {
+    if (!text) return '';
+    
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = '';
+
+    for (const word of words) {
+      if (currentLine.length + word.length + 1 <= maxWidth) {
+        currentLine += (currentLine ? ' ' : '') + word;
+      } else {
+        if (currentLine) lines.push(currentLine);
+        currentLine = word;
+      }
+    }
+    if (currentLine) lines.push(currentLine);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format code block with indentation
+   */
+  formatCode(code) {
+    if (!code) return '';
+    
+    // Add consistent indentation
+    return code
+      .split('\n')
+      .map(line => '  ' + line)
+      .join('\n');
+  }
+
+  /**
+   * Print a simple status message
+   */
+  printStatus(message, type = 'info') {
+    const icons = {
+      info: this.useEmoji ? 'ℹ️ ' : '[i] ',
+      success: this.useEmoji ? '✅ ' : '[+] ',
+      warning: this.useEmoji ? '⚠️ ' : '[!] ',
+      error: this.useEmoji ? '❌ ' : '[x] ',
+    };
+
+    const colors = {
+      info: chalk.cyan,
+      success: chalk.green,
+      warning: chalk.yellow,
+      error: chalk.red,
+    };
+
+    console.log(colors[type](icons[type] + message));
+  }
+}