code-simplifier 1.1.0 → 1.2.1

package/lib/ai-quality-analyzer.js

@@ -0,0 +1,1080 @@
+#!/usr/bin/env node
+
+/**
+ * AI-Powered Code Quality Analyzer
+ * Supports analyzing code quality across 11+ languages using AI
+ */
+
+const fs = require('fs-extra')
+const path = require('path')
+const chalk = require('chalk')
+const ora = require('ora')
+const { OpenAI } = require('openai')
+const Anthropic = require('@anthropic-ai/sdk')
+
+// Code smell patterns for different languages
+const CODE_SMELLS = {
+  // Code Structure Issues
+  longFunction: {
+    name: 'Long Function',
+    description: 'Function exceeds recommended length',
+    severity: 'warning',
+    category: 'structure'
+  },
+  largeClass: {
+    name: 'Large Class',
+    description: 'Class has too many responsibilities',
+    severity: 'warning',
+    category: 'structure'
+  },
+  tooManyParameters: {
+    name: 'Too Many Parameters',
+    description: 'Function has excessive parameters',
+    severity: 'warning',
+    category: 'structure'
+  },
+  duplicateCode: {
+    name: 'Duplicate Code',
+    description: 'Code is duplicated across multiple locations',
+    severity: 'error',
+    category: 'maintainability'
+  },
+
+  // Naming Issues
+  badVariableNames: {
+    name: 'Poor Variable Names',
+    description: 'Variable names are not descriptive',
+    severity: 'warning',
+    category: 'naming'
+  },
+  badFunctionNames: {
+    name: 'Poor Function Names',
+    description: 'Function names are not descriptive',
+    severity: 'warning',
+    category: 'naming'
+  },
+  magicNumbers: {
+    name: 'Magic Numbers',
+    description: 'Unnamed numerical constants in code',
+    severity: 'warning',
+    category: 'maintainability'
+  },
+
+  // Complexity Issues
+  highComplexity: {
+    name: 'High Cyclomatic Complexity',
+    description: 'Function has too many decision points',
+    severity: 'error',
+    category: 'complexity'
+  },
+  nestedConditionals: {
+    name: 'Deeply Nested Conditionals',
+    description: 'Excessive nesting reduces readability',
+    severity: 'warning',
+    category: 'complexity'
+  },
+  arrowAntiPattern: {
+    name: 'Arrow Anti-Pattern',
+    description: 'Excessive callback nesting',
+    severity: 'warning',
+    category: 'complexity'
+  },
+
+  // Code Smells
+  godObject: {
+    name: 'God Object',
+    description: 'Class knows too much or does too much',
+    severity: 'error',
+    category: 'design'
+  },
+  featureEnvy: {
+    name: 'Feature Envy',
+    description: 'Class uses methods of another class excessively',
+    severity: 'warning',
+    category: 'design'
+  },
+  dataClass: {
+    name: 'Data Class',
+    description: 'Class with only data and no behavior',
+    severity: 'warning',
+    category: 'design'
+  },
+  deadCode: {
+    name: 'Dead Code',
+    description: 'Code that is never executed',
+    severity: 'warning',
+    category: 'maintainability'
+  },
+  commentedCode: {
+    name: 'Commented Code',
+    description: 'Old commented-out code',
+    severity: 'info',
+    category: 'maintainability'
+  },
+
+  // Performance Issues
+  inefficientLoop: {
+    name: 'Inefficient Loop',
+    description: 'Suboptimal loop implementation',
+    severity: 'warning',
+    category: 'performance'
+  },
+  stringConcatenation: {
+    name: 'String Concatenation in Loop',
+    description: 'Inefficient string concatenation',
+    severity: 'warning',
+    category: 'performance'
+  },
+  memoryLeak: {
+    name: 'Potential Memory Leak',
+    description: 'May cause memory leaks',
+    severity: 'error',
+    category: 'performance'
+  },
+
+  // Security Issues
+  sqlInjection: {
+    name: 'SQL Injection Risk',
+    description: 'Potential SQL injection vulnerability',
+    severity: 'error',
+    category: 'security'
+  },
+  xssRisk: {
+    name: 'XSS Risk',
+    description: 'Potential cross-site scripting vulnerability',
+    severity: 'error',
+    category: 'security'
+  },
+  hardcodedSecrets: {
+    name: 'Hardcoded Secrets',
+    description: 'Credentials or keys in source code',
+    severity: 'error',
+    category: 'security'
+  },
+
+  // Best Practices
+  missingErrorHandling: {
+    name: 'Missing Error Handling',
+    description: 'No error handling for risky operations',
+    severity: 'warning',
+    category: 'best-practice'
+  },
+  missingValidation: {
+    name: 'Missing Input Validation',
+    description: 'User input not validated',
+    severity: 'warning',
+    category: 'best-practice'
+  },
+  missingDocumentation: {
+    name: 'Missing Documentation',
+    description: 'Function/class lacks documentation',
+    severity: 'info',
+    category: 'documentation'
+  },
+  inconsistentStyle: {
+    name: 'Inconsistent Code Style',
+    description: 'Code style inconsistent with project',
+    severity: 'info',
+    category: 'style'
+  }
+}
+
+const SUPPORTED_LANGUAGES = [
+  'javascript',
+  'typescript',
+  'python',
+  'java',
+  'csharp',
+  'cpp',
+  'php',
+  'ruby',
+  'go',
+  'rust',
+  'swift',
+  'kotlin'
+]
+
+class AIQualityAnalyzer {
+  constructor() {
+    this.openai = null
+    this.anthropic = null
+    this.apiProvider = process.env.AI_PROVIDER || 'openai'
+    this.apiKey = null
+
+    // Initialize API clients
+    this.initializeAPIs()
+  }
+
+  /**
+   * Initialize API clients
+   */
+  initializeAPIs() {
+    try {
+      const openaiKey = process.env.OPENAI_API_KEY
+      const anthropicKey = process.env.ANTHROPIC_API_KEY
+
+      if (openaiKey && (this.apiProvider === 'openai' || !anthropicKey)) {
+        this.openai = new OpenAI({ apiKey: openaiKey })
+        this.apiKey = openaiKey
+        this.currentProvider = 'openai'
+      }
+
+      if (anthropicKey && (this.apiProvider === 'anthropic' || !openaiKey)) {
+        this.anthropic = new Anthropic({ apiKey: anthropicKey })
+        this.apiKey = anthropicKey
+        this.currentProvider = 'anthropic'
+      }
+
+      if (!this.openai && !this.anthropic) {
+        console.warn(chalk.yellow('⚠️  No AI API keys found. Using mock mode for testing.'))
+        this.mockMode = true
+      }
+    } catch (error) {
+      console.warn(chalk.yellow('⚠️  Failed to initialize AI APIs. Using mock mode.'))
+      this.mockMode = true
+    }
+  }
+
+  /**
+   * Analyze a single file
+   */
+  async analyzeFile(filePath, options = {}) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8')
+      const language = this.detectLanguage(filePath)
+
+      if (!language || !SUPPORTED_LANGUAGES.includes(language)) {
+        throw new Error(`Unsupported or unknown language for file: ${filePath}`)
+      }
+
+      const issues = this.detectCodeSmells(content, language, filePath)
+
+      return {
+        file: filePath,
+        language,
+        issues,
+        summary: {
+          total: issues.length,
+          errors: issues.filter(i => i.severity === 'error').length,
+          warnings: issues.filter(i => i.severity === 'warning').length,
+          info: issues.filter(i => i.severity === 'info').length
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to analyze file ${filePath}: ${error.message}`)
+    }
+  }
+
+  /**
+   * Analyze multiple files
+   */
+  async analyzeFiles(filePaths, options = {}) {
+    const spinner = ora(chalk.blue('Analyzing files with AI...')).start()
+    const results = []
+    const errors = []
+
+    try {
+      for (const filePath of filePaths) {
+        try {
+          const result = await this.analyzeFile(filePath, options)
+          results.push(result)
+          spinner.text = `Analyzed ${results.length}/${filePaths.length} files`
+        } catch (error) {
+          errors.push({ file: filePath, error: error.message })
+        }
+      }
+
+      spinner.succeed(chalk.green(`Analysis complete: ${results.length} files analyzed`))
+
+      return {
+        results,
+        errors,
+        summary: this.generateSummary(results)
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Analysis failed'))
+      throw error
+    }
+  }
+
+  /**
+   * Detect programming language from file extension
+   */
+  detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase()
+    const languageMap = {
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.py': 'python',
+      '.java': 'java',
+      '.cs': 'csharp',
+      '.cpp': 'cpp',
+      '.cc': 'cpp',
+      '.cxx': 'cpp',
+      '.h': 'cpp',
+      '.hpp': 'cpp',
+      '.php': 'php',
+      '.rb': 'ruby',
+      '.go': 'go',
+      '.rs': 'rust',
+      '.swift': 'swift',
+      '.kt': 'kotlin',
+      '.kts': 'kotlin'
+    }
+
+    return languageMap[ext]
+  }
+
+  /**
+   * Detect code smells in code
+   */
+  detectCodeSmells(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    // Check for various code smells
+    issues.push(...this.checkLongFunctions(code, language, filePath))
+    issues.push(...this.checkLargeClasses(code, language, filePath))
+    issues.push(...this.checkTooManyParameters(code, language, filePath))
+    issues.push(...this.checkMagicNumbers(code, language, filePath))
+    issues.push(...this.checkHighComplexity(code, language, filePath))
+    issues.push(...this.checkNestedConditionals(code, language, filePath))
+    issues.push(...this.checkDeadCode(code, language, filePath))
+    issues.push(...this.checkCommentedCode(code, language, filePath))
+    issues.push(...this.checkSecurityIssues(code, language, filePath))
+    issues.push(...this.checkPerformanceIssues(code, language, filePath))
+    issues.push(...this.checkNamingIssues(code, language, filePath))
+    issues.push(...this.checkBestPractices(code, language, filePath))
+
+    return issues
+  }
+
+  /**
+   * Check for long functions
+   */
+  checkLongFunctions(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    // Detect function definitions and their lengths
+    const functionRegex = this.getFunctionRegex(language)
+    const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
+    let match
+
+    while ((match = functionRegex.exec(code)) !== null) {
+      const functionStart = code.substring(0, match.index).split('\n').length
+      const functionBody = this.extractFunctionBody(code, match.index, language)
+      const functionLines = functionBody.split('\n').length
+
+      if (functionLines > 50) {
+        issues.push({
+          type: 'longFunction',
+          name: CODE_SMELLS.longFunction.name,
+          severity: CODE_SMELLS.longFunction.severity,
+          category: CODE_SMELLS.longFunction.category,
+          line: functionStart,
+          message: `Function is ${functionLines} lines (recommended: < 50)`,
+          fix: 'Break down into smaller, more focused functions'
+        })
+      }
+    }
+
+    return issues
+  }
+
+  /**
+   * Check for large classes
+   */
+  checkLargeClasses(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    if (language === 'java' || language === 'csharp') {
+      const classRegex = /(?:class|interface)\s+(\w+)/g
+      let match
+
+      while ((match = classRegex.exec(code)) !== null) {
+        const classStart = code.substring(0, match.index).split('\n').length
+        // Count lines until next class or end of file
+        const afterClass = code.substring(match.index)
+        const classLines = afterClass.split('\n').findIndex((line, idx) =>
+          idx > 0 && (line.match(/^\s*(class|interface)\s+\w+/) || line.match(/^\s*}/))
+        )
+
+        if (classLines > 200) {
+          issues.push({
+            type: 'largeClass',
+            name: CODE_SMELLS.largeClass.name,
+            severity: CODE_SMELLS.largeClass.severity,
+            category: CODE_SMELLS.largeClass.category,
+            line: classStart,
+            message: `Class has ~${classLines} lines (recommended: < 200)`,
+            fix: 'Split into smaller, cohesive classes'
+          })
+        }
+      }
+    }
+
+    return issues
+  }
+
+  /**
+   * Check for too many parameters
+   */
+  checkTooManyParameters(code, language, filePath) {
+    const issues = []
+    const functionRegex = this.getFunctionRegex(language)
+    const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
+    let match
+
+    while ((match = functionRegex.exec(code)) !== null) {
+      const functionStartLine = code.substring(0, match.index).split('\n').length
+      const codeFromFunction = code.substring(match.index)
+      const firstLine = codeFromFunction.split('\n')[0]
+
+      // Extract parameter list from the first line
+      const paramMatch = firstLine.match(/\(([^)]*)\)/)
+
+      if (paramMatch) {
+        const params = paramMatch[1].trim()
+        // Handle destructuring parameters and default values
+        const paramList = params.split(',')
+          .map(p => p.trim())
+          .filter(p => p.length > 0)
+
+        if (paramList.length > 5) {
+          issues.push({
+            type: 'tooManyParameters',
+            name: CODE_SMELLS.tooManyParameters.name,
+            severity: CODE_SMELLS.tooManyParameters.severity,
+            category: CODE_SMELLS.tooManyParameters.category,
+            line: functionStartLine,
+            message: `Function has ${paramList.length} parameters (recommended: < 5)`,
+            fix: 'Use parameter object or break down function'
+          })
+        }
+      }
+    }
+
+    return issues
+  }
+
+  /**
+   * Check for magic numbers
+   */
+  checkMagicNumbers(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      // Skip if line already has issue
+      if (line.includes('//') || line.includes('#')) return
+
+      // Find standalone numbers (not in strings or comments)
+      const numberRegex = /\b(\d{4,})\b/g
+      let match
+
+      while ((match = numberRegex.exec(line)) !== null) {
+        const number = match[1]
+
+        // Skip version numbers, dates, etc.
+        if (!['2020', '2021', '2022', '2023', '2024'].includes(number)) {
+          issues.push({
+            type: 'magicNumbers',
+            name: CODE_SMELLS.magicNumbers.name,
+            severity: CODE_SMELLS.magicNumbers.severity,
+            category: CODE_SMELLS.magicNumbers.category,
+            line: index + 1,
+            message: `Magic number: ${number}`,
+            fix: 'Extract to a named constant'
+          })
+        }
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for high cyclomatic complexity
+   */
+  checkHighComplexity(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    // Track nested structures by counting braces and if statements
+    let braceDepth = 0
+    let ifDepth = 0
+    let functionStartLine = 0
+    let inFunction = false
+    let maxNestingDepth = 0
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+
+      // Check for function definition
+      const functionRegex = this.getFunctionRegex(language)
+      const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
+      if (functionRegexNoGlobal.test(line)) {
+        inFunction = true
+        functionStartLine = index + 1
+        braceDepth = 0
+        ifDepth = 0
+        maxNestingDepth = 0
+      }
+
+      if (inFunction) {
+        // Count opening braces
+        const openBraces = (line.match(/{/g) || []).length
+        const closeBraces = (line.match(/}/g) || []).length
+        braceDepth += openBraces - closeBraces
+
+        // Track if statement nesting
+        if (trimmed.match(/if\s*\(/)) {
+          ifDepth++
+          if (ifDepth > maxNestingDepth) {
+            maxNestingDepth = ifDepth
+          }
+        }
+
+        // Check for function end (braceDepth returns to 0 or less)
+        if (braceDepth <= 0 && inFunction && index > functionStartLine) {
+          // Calculate complexity based on nesting depth
+          const complexity = ifDepth + 1 // Base complexity + nesting
+
+          if (complexity > 10 || maxNestingDepth > 5) {
+            issues.push({
+              type: 'highComplexity',
+              name: CODE_SMELLS.highComplexity.name,
+              severity: CODE_SMELLS.highComplexity.severity,
+              category: CODE_SMELLS.highComplexity.category,
+              line: functionStartLine,
+              message: `High cyclomatic complexity or deep nesting (max depth: ${maxNestingDepth})`,
+              fix: 'Simplify logic by extracting methods or using early returns'
+            })
+          }
+
+          inFunction = false
+        }
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for deeply nested conditionals
+   */
+  checkNestedConditionals(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+      const indentation = line.match(/^(\s*)/)[1].length
+
+      if ((trimmed.includes('if ') || trimmed.includes('for ') || trimmed.includes('while ')) &&
+          indentation > 16) { // More than 4 levels of nesting
+        issues.push({
+          type: 'nestedConditionals',
+          name: CODE_SMELLS.nestedConditionals.name,
+          severity: CODE_SMELLS.nestedConditionals.severity,
+          category: CODE_SMELLS.nestedConditionals.category,
+          line: index + 1,
+          message: `Deeply nested conditional (indentation: ${indentation} spaces)`,
+          fix: 'Use early returns or extract nested logic to separate functions'
+        })
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for dead code
+   */
+  checkDeadCode(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    // Check for unreachable code after return/throw
+    let foundReturn = false
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+
+      // Check for return/throw/break statements
+      if (trimmed.startsWith('return') || trimmed.startsWith('throw') ||
+          trimmed.startsWith('break') || trimmed.startsWith('exit') ||
+          trimmed.startsWith('sys.exit')) {
+        foundReturn = true
+      } else if (foundReturn && trimmed && !trimmed.startsWith('//') &&
+                 !trimmed.startsWith('*') && !trimmed.startsWith('*') &&
+                 !trimmed.match(/^[{}\]\);,]$/)) {
+        // Found code after return statement
+        issues.push({
+          type: 'deadCode',
+          name: CODE_SMELLS.deadCode.name,
+          severity: CODE_SMELLS.deadCode.severity,
+          category: CODE_SMELLS.deadCode.category,
+          line: index + 1,
+          message: 'Code appears to be unreachable',
+          fix: 'Remove unreachable code'
+        })
+      }
+
+      // Reset flag when we hit a closing brace at the same level
+      if (trimmed === '}' && foundReturn) {
+        foundReturn = false
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for commented code
+   */
+  checkCommentedCode(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+
+      // Check for commented code blocks
+      if ((trimmed.startsWith('//') || trimmed.startsWith('#')) &&
+          (trimmed.includes('function') || trimmed.includes('class') ||
+           trimmed.includes('const ') || trimmed.includes('let ') ||
+           trimmed.includes('var '))) {
+        issues.push({
+          type: 'commentedCode',
+          name: CODE_SMELLS.commentedCode.name,
+          severity: CODE_SMELLS.commentedCode.severity,
+          category: CODE_SMELLS.commentedCode.category,
+          line: index + 1,
+          message: 'Commented-out code found',
+          fix: 'Remove commented code or use version control to track changes'
+        })
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for security issues
+   */
+  checkSecurityIssues(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      const trimmed = line.toLowerCase()
+
+      // SQL Injection
+      if ((trimmed.includes('query') || trimmed.includes('execute')) &&
+          trimmed.includes('+') && (trimmed.includes('select') || trimmed.includes('from'))) {
+        issues.push({
+          type: 'sqlInjection',
+          name: CODE_SMELLS.sqlInjection.name,
+          severity: CODE_SMELLS.sqlInjection.severity,
+          category: CODE_SMELLS.sqlInjection.category,
+          line: index + 1,
+          message: 'Potential SQL injection vulnerability',
+          fix: 'Use parameterized queries or prepared statements'
+        })
+      }
+
+      // XSS
+      if (trimmed.includes('innerhtml') || trimmed.includes('document.write')) {
+        issues.push({
+          type: 'xssRisk',
+          name: CODE_SMELLS.xssRisk.name,
+          severity: CODE_SMELLS.xssRisk.severity,
+          category: CODE_SMELLS.xssRisk.category,
+          line: index + 1,
+          message: 'Potential XSS vulnerability',
+          fix: 'Sanitize user input or use safe DOM APIs'
+        })
+      }
+
+      // Hardcoded secrets - check both snake_case and camelCase
+      const secretKeywords = ['api_key', 'apikey', 'password', 'secret', 'token', 'private_key', 'privatekey']
+      const hasSecretKeyword = secretKeywords.some(keyword => {
+        // Check both snake_case and camelCase versions
+        return trimmed.includes(keyword) || trimmed.includes(keyword.replace('_', ''))
+      })
+
+      if (hasSecretKeyword) {
+        // Check for assignment without process.env
+        if (trimmed.includes('=') && !trimmed.includes('process.env') &&
+            !trimmed.includes('env.') && !trimmed.includes('env[')) {
+          issues.push({
+            type: 'hardcodedSecrets',
+            name: CODE_SMELLS.hardcodedSecrets.name,
+            severity: CODE_SMELLS.hardcodedSecrets.severity,
+            category: CODE_SMELLS.hardcodedSecrets.category,
+            line: index + 1,
+            message: 'Potential hardcoded secret',
+            fix: 'Use environment variables or secure configuration'
+          })
+        }
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for performance issues
+   */
+  checkPerformanceIssues(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+
+      // String concatenation in loop
+      if (line.includes('for ') || line.includes('while ')) {
+        const nextLine = lines[index + 1] || ''
+        if (nextLine.includes('+=') && (nextLine.includes('str') || nextLine.includes('string'))) {
+          issues.push({
+            type: 'stringConcatenation',
+            name: CODE_SMELLS.stringConcatenation.name,
+            severity: CODE_SMELLS.stringConcatenation.severity,
+            category: CODE_SMELLS.stringConcatenation.category,
+            line: index + 1,
+            message: 'String concatenation in loop',
+            fix: 'Use StringBuilder or array join for better performance'
+          })
+        }
+      }
+
+      // Inefficient loop
+      if (trimmed.includes('for (') && trimmed.includes('length')) {
+        issues.push({
+          type: 'inefficientLoop',
+          name: CODE_SMELLS.inefficientLoop.name,
+          severity: CODE_SMELLS.inefficientLoop.severity,
+          category: CODE_SMELLS.inefficientLoop.category,
+          line: index + 1,
+          message: 'Potentially inefficient loop (length accessed each iteration)',
+          fix: 'Cache length in a variable before loop'
+        })
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for naming issues
+   */
+  checkNamingIssues(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      // Check for bad variable names (const/let/var with single letter or unclear names)
+      const varDeclaration = line.match(/(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+      if (varDeclaration) {
+        const varName = varDeclaration[1]
+        // Check if it's a single letter variable (except common exceptions)
+        const singleLetterExceptions = ['i', 'j', 'k', 'x', 'y', 'z', '_', '$']
+        if (varName.length === 1 && !singleLetterExceptions.includes(varName)) {
+          issues.push({
+            type: 'badVariableNames',
+            name: CODE_SMELLS.badVariableNames.name,
+            severity: CODE_SMELLS.badVariableNames.severity,
+            category: CODE_SMELLS.badVariableNames.category,
+            line: index + 1,
+            message: 'Non-descriptive variable name',
+            fix: 'Use more descriptive variable names'
+          })
+        }
+      }
+
+      // Bad function names (too short or unclear)
+      const functionRegex = this.getFunctionRegex(language)
+      // Create a non-global version for matching
+      const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
+      const functionMatch = line.match(functionRegexNoGlobal)
+      if (functionMatch) {
+        // Extract function name from match groups
+        let funcName = null
+        for (let i = 1; i < functionMatch.length; i++) {
+          if (functionMatch[i]) {
+            funcName = functionMatch[i]
+            break
+          }
+        }
+
+        if (funcName && funcName.length < 3 && !['main', 'init', 'run'].includes(funcName)) {
+          issues.push({
+            type: 'badFunctionNames',
+            name: CODE_SMELLS.badFunctionNames.name,
+            severity: CODE_SMELLS.badFunctionNames.severity,
+            category: CODE_SMELLS.badFunctionNames.category,
+            line: index + 1,
+            message: 'Function name is too short or unclear',
+            fix: 'Use descriptive function names that indicate purpose'
+          })
+        }
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Check for best practice violations
+   */
+  checkBestPractices(code, language, filePath) {
+    const issues = []
+    const lines = code.split('\n')
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+
+      // Missing error handling
+      if ((trimmed.includes('fetch') || trimmed.includes('axios') ||
+           trimmed.includes('http') || trimmed.includes('request')) &&
+          !lines.slice(Math.max(0, index - 5), index).some(l => l.includes('try') || l.includes('catch'))) {
+        issues.push({
+          type: 'missingErrorHandling',
+          name: CODE_SMELLS.missingErrorHandling.name,
+          severity: CODE_SMELLS.missingErrorHandling.severity,
+          category: CODE_SMELLS.missingErrorHandling.category,
+          line: index + 1,
+          message: 'Network operation without error handling',
+          fix: 'Wrap in try-catch or use .catch() for promise-based operations'
+        })
+      }
+
+      // Missing documentation
+      const functionRegex = this.getFunctionRegex(language)
+      const functionRegexNoGlobal = new RegExp(functionRegex.source, functionRegex.flags.replace('g', ''))
+      const functionMatch = line.match(functionRegexNoGlobal)
+      if (functionMatch && index > 0) {
+        const prevLine = lines[index - 1].trim()
+        // Check if previous line is a documentation comment
+        const isDocumented = prevLine.startsWith('/**') ||
+                             prevLine.startsWith('///') ||
+                             prevLine.startsWith('#') ||
+                             prevLine.startsWith('"""') ||
+                             prevLine.startsWith('/*')
+
+        if (!isDocumented) {
+          issues.push({
+            type: 'missingDocumentation',
+            name: CODE_SMELLS.missingDocumentation.name,
+            severity: CODE_SMELLS.missingDocumentation.severity,
+            category: CODE_SMELLS.missingDocumentation.category,
+            line: index + 1,
+            message: 'Function lacks documentation',
+            fix: 'Add JSDoc comments or documentation comments'
+          })
+        }
+      }
+    })
+
+    return issues
+  }
+
+  /**
+   * Get function regex based on language
+   */
+  getFunctionRegex(language) {
+    const regexMap = {
+      javascript: /(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:function|\([^)]*\)\s*=>))/g,
+      typescript: /(?:function\s+(\w+)|(\w+)\s*:\s*(?:.*?)=>\s*|(\w+)\s*\(.*?\)\s*{)/g,
+      python: /def\s+(\w+)\s*\(/g,
+      java: /(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(/g,
+      csharp: /(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(/g,
+      cpp: /\w+\s+(\w+)\s*\([^)]*\)\s*{/g,
+      php: /function\s+(\w+)\s*\(/g,
+      ruby: /def\s+(\w+)/g,
+      go: /func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/g,
+      rust: /fn\s+(\w+)\s*\(/g,
+      swift: /func\s+(\w+)\s*\(/g,
+      kotlin: /(?:fun|private fun|public fun)\s+(\w+)\s*\(/g
+    }
+
+    return regexMap[language] || regexMap.javascript
+  }
+
+  /**
+   * Extract function body from code
+   */
+  extractFunctionBody(code, functionIndex, language) {
+    const codeFromFunction = code.substring(functionIndex)
+    const lines = codeFromFunction.split('\n')
+
+    if (language === 'python') {
+      // Python: find next line at same indentation
+      const functionLine = lines[0]
+      const indentMatch = functionLine.match(/^(\s*)/)
+      const baseIndent = indentMatch ? indentMatch[1].length : 0
+      let bodyLines = []
+
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i]
+        const indent = line.match(/^(\s*)/)?.[1]?.length || 0
+
+        if (indent > baseIndent || line.trim() === '') {
+          bodyLines.push(line)
+        } else {
+          break
+        }
+      }
+      return bodyLines.join('\n')
+    } else {
+      // JavaScript-like languages
+      let braceCount = 0
+      let bodyLines = []
+      let foundOpenBrace = false
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]
+
+        for (const char of line) {
+          if (char === '{') {
+            braceCount++
+            foundOpenBrace = true
+          } else if (char === '}') {
+            braceCount--
+            if (foundOpenBrace && braceCount === 0) {
+              return bodyLines.join('\n')
+            }
+          }
+        }
+
+        if (foundOpenBrace) {
+          bodyLines.push(line)
+        }
+      }
+      return lines.slice(1).join('\n')
+    }
+  }
+
+  /**
+   * Generate summary statistics
+   */
+  generateSummary(results) {
+    const summary = {
+      totalFiles: results.length,
+      totalIssues: 0,
+      errors: 0,
+      warnings: 0,
+      info: 0,
+      byCategory: {},
+      byLanguage: {}
+    }
+
+    results.forEach(result => {
+      result.issues.forEach(issue => {
+        summary.totalIssues++
+
+        if (issue.severity === 'error') summary.errors++
+        else if (issue.severity === 'warning') summary.warnings++
+        else summary.info++
+
+        // By category
+        if (!summary.byCategory[issue.category]) {
+          summary.byCategory[issue.category] = 0
+        }
+        summary.byCategory[issue.category]++
+
+        // By language
+        if (!summary.byLanguage[result.language]) {
+          summary.byLanguage[result.language] = 0
+        }
+        summary.byLanguage[result.language]++
+      })
+    })
+
+    return summary
+  }
+
+  /**
+   * Export results to JSON
+   */
+  async exportToJSON(results, outputPath) {
+    const jsonContent = JSON.stringify(results, null, 2)
+    await fs.writeFile(outputPath, jsonContent)
+    return outputPath
+  }
+
+  /**
+   * Export results to Markdown
+   */
+  async exportToMarkdown(results, outputPath) {
+    const markdown = this.generateMarkdownReport(results)
+    await fs.writeFile(outputPath, markdown)
+    return outputPath
+  }
+
+  /**
+   * Generate Markdown report
+   */
+  generateMarkdownReport(results) {
+    const timestamp = new Date().toLocaleString()
+    const summary = this.generateSummary(results.results || [results])
+
+    let report = `# AI Code Quality Analysis Report\n\n`
+    report += `**Generated**: ${timestamp}\n`
+    report += `**Provider**: ${this.currentProvider || 'Mock'}\n`
+    report += `**Files Analyzed**: ${summary.totalFiles}\n\n`
+
+    report += `## Summary\n\n`
+    report += `| Metric | Count |\n`
+    report += `|--------|-------|\n`
+    report += `| Total Issues | ${summary.totalIssues} |\n`
+    report += `| Errors | ${summary.errors} |\n`
+    report += `| Warnings | ${summary.warnings} |\n`
+    report += `| Info | ${summary.info} |\n\n`
+
+    report += `### Issues by Category\n\n`
+    Object.entries(summary.byCategory).forEach(([category, count]) => {
+      report += `- **${category}**: ${count}\n`
+    })
+    report += `\n`
+
+    report += `### Issues by Language\n\n`
+    Object.entries(summary.byLanguage).forEach(([language, count]) => {
+      report += `- **${language}**: ${count}\n`
+    })
+    report += `\n`
+
+    report += `## Detailed Issues\n\n`
+
+    const analysisResults = results.results || [results]
+    analysisResults.forEach(result => {
+      if (result.issues && result.issues.length > 0) {
+        report += `### ${result.file}\n\n`
+        report += `**Language**: ${result.language}\n`
+        report += `**Total Issues**: ${result.issues.length}\n\n`
+
+        result.issues.forEach(issue => {
+          const severityIcon = issue.severity === 'error' ? '❌' :
+                             issue.severity === 'warning' ? '⚠️' : 'ℹ️'
+          report += `${severityIcon} **${issue.name}** (Line ${issue.line})\n`
+          report += `- Severity: ${issue.severity}\n`
+          report += `- Category: ${issue.category}\n`
+          report += `- Message: ${issue.message}\n`
+          report += `- Fix: ${issue.fix}\n\n`
+        })
+      }
+    })
+
+    report += `---\n*Generated by Code-Simplifier AI Quality Analyzer*\n`
+
+    return report
+  }
+}
+
+module.exports = new AIQualityAnalyzer()