code-simplifier 1.1.0 → 1.2.1

package/lib/ai-knowledge-base.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+
+/**
+ * AI-Powered Knowledge Base
+ * Automatically extracts and manages best practices from code analysis
+ * Provides intelligent Q&A and learning materials
+ */
+
+const fs = require('fs-extra')
+const path = require('path')
+const chalk = require('chalk')
+const { OpenAI } = require('openai')
+const Anthropic = require('@anthropic-ai/sdk')
+
+/**
+ * AI Knowledge Base - Manages best practices, patterns, and learning materials
+ */
+class AIKnowledgeBase {
+  constructor(config = {}) {
+    this.config = {
+      dataDir: config.dataDir || path.join(process.cwd(), 'knowledge-base'),
+      casesFile: config.casesFile || 'cases.json',
+      patternsFile: config.patternsFile || 'patterns.json',
+      minCasesPerWeek: config.minCasesPerWeek || 10,
+      maxIterations: config.maxIterations || 50,
+      openaiApiKey: config.openaiApiKey || process.env.OPENAI_API_KEY,
+      anthropicApiKey: config.anthropicApiKey || process.env.ANTHROPIC_API_KEY,
+      ...config
+    }
+
+    this.cases = []
+    this.patterns = {}
+    this.statistics = {
+      totalCases: 0,
+      weeklyCases: 0,
+      tagAccuracy: 0,
+      lastUpdated: null
+    }
+
+    this.openai = this.config.openaiApiKey ? new OpenAI({ apiKey: this.config.openaiApiKey }) : null
+    this.anthropic = this.config.anthropicApiKey ? new Anthropic({ apiKey: this.config.anthropicApiKey }) : null
+
+    this.knowledgeDir = path.join(this.config.dataDir, 'knowledge')
+    this.examplesDir = path.join(this.config.dataDir, 'examples')
+  }
+
+  /**
+   * Initialize the knowledge base
+   */
+  async initialize() {
+    await fs.ensureDir(this.knowledgeDir)
+    await fs.ensureDir(this.examplesDir)
+    await this.loadKnowledgeBase()
+  }
+
+  /**
+   * Load knowledge base from files
+   */
+  async loadKnowledgeBase() {
+    try {
+      const casesPath = path.join(this.config.dataDir, this.config.casesFile)
+      const patternsPath = path.join(this.config.dataDir, this.config.patternsFile)
+
+      if (await fs.pathExists(casesPath)) {
+        this.cases = await fs.readJson(casesPath)
+      }
+
+      if (await fs.pathExists(patternsPath)) {
+        this.patterns = await fs.readJson(patternsPath)
+      }
+
+      this.updateStatistics()
+    } catch (error) {
+      console.error(chalk.red('Error loading knowledge base:'), error.message)
+      this.cases = []
+      this.patterns = {}
+    }
+  }
+
+  /**
+   * Save knowledge base to files
+   */
+  async saveKnowledgeBase() {
+    try {
+      await fs.ensureDir(this.config.dataDir)
+      const casesPath = path.join(this.config.dataDir, this.config.casesFile)
+      const patternsPath = path.join(this.config.dataDir, this.config.patternsFile)
+
+      await fs.writeJson(casesPath, this.cases, { spaces: 2 })
+      await fs.writeJson(patternsPath, this.patterns, { spaces: 2 })
+
+      this.statistics.lastUpdated = new Date().toISOString()
+    } catch (error) {
+      console.error(chalk.red('Error saving knowledge base:'), error.message)
+      // Don't throw, just log the error
+    }
+  }
+
+  /**
+   * Extract best practices from code analysis results
+   */
+  async extractBestPractices(analysisResult, metadata = {}) {
+    console.log(chalk.blue('Extracting best practices from analysis...'))
+
+    const cases = []
+
+    for (const fileResult of analysisResult.files || []) {
+      const issues = fileResult.issues || []
+
+      for (const issue of issues) {
+        if (issue.severity === 'error' || issue.severity === 'warning') {
+          const bestPractice = await this.generateBestPractice(issue, fileResult, metadata)
+          if (bestPractice) {
+            cases.push(bestPractice)
+          }
+        }
+      }
+    }
+
+    // Smart classification and tagging
+    for (const caseItem of cases) {
+      await this.classifyAndTagCase(caseItem)
+    }
+
+    // Add to knowledge base
+    this.cases.push(...cases)
+
+    // Ensure we meet weekly quota
+    await this.ensureWeeklyQuota()
+
+    // Update statistics
+    this.updateStatistics()
+
+    await this.saveKnowledgeBase()
+
+    return {
+      extracted: cases.length,
+      totalCases: this.cases.length,
+      weeklyCases: this.statistics.weeklyCases
+    }
+  }
+
+  /**
+   * Generate best practice from an issue
+   */
+  async generateBestPractice(issue, fileResult, metadata) {
+    const prompt = `
+      Based on the following code issue, generate a comprehensive best practice case:
+
+      Issue: ${issue.type}
+      Description: ${issue.description}
+      File: ${fileResult.filePath}
+      Language: ${fileResult.language}
+      Severity: ${issue.severity}
+      Location: Line ${issue.line}
+
+      Code Context:
+      ${issue.codeSnippet || 'No code snippet available'}
+
+      Generate a best practice case in JSON format with:
+      1. title: Clear, descriptive title
+      2. problem: Detailed explanation of the problem
+      3. whyItMatters: Why this issue is important
+      4. solution: Step-by-step solution
+      5. codeExample: Working code example
+      6. tags: Relevant tags (3-5 tags)
+      7. category: Main category
+      8. language: Programming language
+      9. difficulty: beginner/intermediate/advanced
+      10. relatedPatterns: Array of related patterns
+      11. preventionTips: Tips to prevent this issue
+
+      Return only valid JSON.
+    `
+
+    try {
+      const response = await this.generateWithAI(prompt)
+      const parsed = JSON.parse(response)
+
+      return {
+        id: this.generateCaseId(),
+        timestamp: new Date().toISOString(),
+        source: 'ai-analysis',
+        sourceFile: fileResult.filePath,
+        ...parsed,
+        metadata: {
+          originalIssue: issue,
+          fileLanguage: fileResult.language,
+          analysisMetadata: metadata
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow('Could not generate AI case, using template:'), error.message)
+      return this.createTemplateCase(issue, fileResult)
+    }
+  }
+
+  /**
+   * Create a template case when AI is not available
+   */
+  createTemplateCase(issue, fileResult) {
+    return {
+      id: this.generateCaseId(),
+      timestamp: new Date().toISOString(),
+      source: 'template',
+      sourceFile: fileResult.filePath,
+      title: `${issue.type}: ${issue.description}`,
+      problem: issue.description,
+      whyItMatters: `This ${issue.severity} issue affects code quality and maintainability.`,
+      solution: this.getDefaultSolution(issue.type),
+      codeExample: issue.codeSnippet || '// Example code needed',
+      tags: this.extractTagsFromIssue(issue),
+      category: this.getCategoryFromIssue(issue),
+      language: fileResult.language || 'unknown',
+      difficulty: 'intermediate',
+      relatedPatterns: [],
+      preventionTips: ['Follow coding standards', 'Regular code reviews', 'Use linters'],
+      metadata: {
+        originalIssue: issue,
+        fileLanguage: fileResult.language
+      }
+    }
+  }
+
+  /**
+   * Classify and tag a case intelligently
+   */
+  async classifyAndTagCase(caseItem) {
+    const prompt = `
+      Analyze this best practice case and provide smart classification:
+
+      Title: ${caseItem.title}
+      Problem: ${caseItem.problem}
+      Solution: ${caseItem.solution}
+
+      Provide enhanced tags (3-5 additional tags) and category refinements.
+      Focus on: design patterns, anti-patterns, best practices, language-specific idioms.
+
+      Return JSON with:
+      {
+        "enhancedTags": ["tag1", "tag2", "tag3"],
+        "confidence": 0.95,
+        "patternTypes": ["pattern1", "pattern2"]
+      }
+    `
+
+    try {
+      const response = await this.generateWithAI(prompt)
+      const parsed = JSON.parse(response)
+
+      caseItem.tags = [...new Set([...caseItem.tags, ...parsed.enhancedTags])]
+      caseItem.patternTypes = parsed.patternTypes
+      caseItem.classificationConfidence = parsed.confidence
+    } catch (error) {
+      console.warn(chalk.yellow('Classification failed, using defaults'))
+      caseItem.classificationConfidence = 0.7
+    }
+  }
+
+  /**
+   * Generate learning materials and examples
+   */
+  async generateLearningMaterials(caseId) {
+    const caseItem = this.cases.find(c => c.id === caseId)
+    if (!caseItem) {
+      throw new Error(`Case ${caseId} not found`)
+    }
+
+    const materials = {
+      caseId,
+      generatedAt: new Date().toISOString(),
+      sections: []
+    }
+
+    // Generate different types of learning materials
+    materials.sections.push({
+      type: 'explanation',
+      title: 'Understanding the Problem',
+      content: await this.generateExplanation(caseItem)
+    })
+
+    materials.sections.push({
+      type: 'example',
+      title: 'Code Example',
+      content: await this.generateDetailedExample(caseItem)
+    })
+
+    materials.sections.push({
+      type: 'exercise',
+      title: 'Practice Exercise',
+      content: await this.generateExercise(caseItem)
+    })
+
+    materials.sections.push({
+      type: 'related',
+      title: 'Related Concepts',
+      content: await this.findRelatedConcepts(caseItem)
+    })
+
+    // Save materials
+    const materialsPath = path.join(this.knowledgeDir, `${caseId}-materials.md`)
+    await fs.writeFile(materialsPath, this.formatMaterialsAsMarkdown(materials))
+
+    return materials
+  }
+
+  /**
+   * Answer questions using natural language
+   */
+  async query(question, options = {}) {
+    console.log(chalk.blue(`Processing query: "${question}"`))
+
+    const prompt = `
+      Knowledge Base Query: ${question}
+
+      Available Cases: ${this.cases.length}
+      Categories: ${Object.keys(this.patterns).join(', ')}
+
+      Search through the knowledge base and provide a comprehensive answer.
+      Include:
+      1. Direct answer to the question
+      2. Relevant cases/examples
+      3. Best practices
+      4. Code snippets when applicable
+      5. Related recommendations
+
+      Format as a helpful, informative response.
+    `
+
+    try {
+      const response = await this.generateWithAI(prompt)
+
+      // Also perform keyword search
+      const keywordResults = this.performKeywordSearch(question)
+
+      return {
+        question,
+        answer: response,
+        relevantCases: keywordResults.cases,
+        confidence: keywordResults.confidence,
+        timestamp: new Date().toISOString()
+      }
+    } catch (error) {
+      console.warn(chalk.yellow('AI query failed, using keyword search'))
+      return this.performKeywordSearch(question)
+    }
+  }
+
+  /**
+   * Perform keyword-based search
+   */
+  performKeywordSearch(query) {
+    const keywords = query.toLowerCase().split(/\s+/)
+    const scoredCases = []
+
+    for (const caseItem of this.cases) {
+      let score = 0
+      const searchableText = [
+        caseItem.title,
+        caseItem.problem,
+        caseItem.solution,
+        ...(caseItem.tags || [])
+      ].join(' ').toLowerCase()
+
+      for (const keyword of keywords) {
+        if (searchableText.includes(keyword)) {
+          score += 1
+        }
+      }
+
+      if (score > 0) {
+        scoredCases.push({
+          ...caseItem,
+          relevanceScore: score / keywords.length
+        })
+      }
+    }
+
+    scoredCases.sort((a, b) => b.relevanceScore - a.relevanceScore)
+
+    return {
+      cases: scoredCases.slice(0, 10),
+      confidence: scoredCases.length > 0 ? Math.min(scoredCases[0].relevanceScore, 1.0) : 0.0
+    }
+  }
+
+  /**
+   * Provide related case recommendations
+   */
+  async getRecommendations(caseId, limit = 5) {
+    const caseItem = this.cases.find(c => c.id === caseId)
+    if (!caseItem) {
+      return []
+    }
+
+    const recommendations = []
+
+    for (const otherCase of this.cases) {
+      if (otherCase.id === caseId) continue
+
+      let similarity = 0
+
+      // Check tag overlap
+      const commonTags = (caseItem.tags || []).filter(tag =>
+        (otherCase.tags || []).includes(tag)
+      )
+      similarity += commonTags.length * 0.3
+
+      // Check category match
+      if (caseItem.category === otherCase.category) {
+        similarity += 0.4
+      }
+
+      // Check language match
+      if (caseItem.language === otherCase.language) {
+        similarity += 0.2
+      }
+
+      // Check pattern type match
+      const commonPatterns = (caseItem.patternTypes || []).filter(pattern =>
+        (otherCase.patternTypes || []).includes(pattern)
+      )
+      similarity += commonPatterns.length * 0.1
+
+      if (similarity > 0) {
+        recommendations.push({
+          ...otherCase,
+          similarityScore: similarity,
+          commonTags,
+          commonPatterns
+        })
+      }
+    }
+
+    recommendations.sort((a, b) => b.similarityScore - a.similarityScore)
+
+    return recommendations.slice(0, limit)
+  }
+
+  /**
+   * Ensure minimum weekly case quota
+   */
+  async ensureWeeklyQuota() {
+    const oneWeekAgo = new Date()
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
+
+    const recentCases = this.cases.filter(c =>
+      new Date(c.timestamp) > oneWeekAgo
+    )
+
+    this.statistics.weeklyCases = recentCases.length
+
+    if (recentCases.length < this.config.minCasesPerWeek) {
+      console.log(chalk.yellow(`Weekly quota not met. Extracting ${this.config.minCasesPerWeek - recentCases.length} more cases...`))
+
+      // This would typically trigger additional analysis or extraction
+      // For now, we'll mark it in statistics
+      this.statistics.quotaStatus = 'needs-attention'
+    } else {
+      this.statistics.quotaStatus = 'met'
+    }
+  }
+
+  /**
+   * Update statistics
+   */
+  updateStatistics() {
+    this.statistics.totalCases = this.cases.length
+
+    const oneWeekAgo = new Date()
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
+
+    const recentCases = this.cases.filter(c =>
+      new Date(c.timestamp) > oneWeekAgo
+    )
+
+    this.statistics.weeklyCases = recentCases.length
+
+    // Calculate tag accuracy (mock implementation)
+    const classifiedCases = this.cases.filter(c => c.classificationConfidence)
+    if (classifiedCases.length > 0) {
+      const avgConfidence = classifiedCases.reduce((sum, c) =>
+        sum + (c.classificationConfidence || 0), 0
+      ) / classifiedCases.length
+      this.statistics.tagAccuracy = avgConfidence * 100
+    }
+  }
+
+  /**
+   * Generate with AI (OpenAI or Anthropic)
+   */
+  async generateWithAI(prompt) {
+    // Try OpenAI first
+    if (this.openai) {
+      try {
+        const response = await this.openai.chat.completions.create({
+          model: 'gpt-4',
+          messages: [{ role: 'user', content: prompt }],
+          temperature: 0.7,
+          max_tokens: 2000
+        })
+        return response.choices[0].message.content
+      } catch (error) {
+        console.warn(chalk.yellow('OpenAI failed, trying Anthropic...'))
+      }
+    }
+
+    // Try Anthropic
+    if (this.anthropic) {
+      try {
+        const response = await this.anthropic.messages.create({
+          model: 'claude-3-5-sonnet-20241022',
+          max_tokens: 2000,
+          messages: [{ role: 'user', content: prompt }]
+        })
+        return response.content[0].text
+      } catch (error) {
+        console.warn(chalk.yellow('Anthropic failed, using mock mode'))
+      }
+    }
+
+    // Mock mode
+    return this.generateMockResponse(prompt)
+  }
+
+  /**
+   * Generate mock response for testing
+   */
+  generateMockResponse(prompt) {
+    if (prompt.includes('best practice case')) {
+      return JSON.stringify({
+        title: 'Code Quality Best Practice',
+        problem: 'This is a mock problem description',
+        whyItMatters: 'Quality matters for maintainability',
+        solution: 'Follow best practices and coding standards',
+        codeExample: '// Example code here',
+        tags: ['best-practice', 'quality'],
+        category: 'best-practices',
+        language: 'javascript',
+        difficulty: 'intermediate',
+        relatedPatterns: ['clean-code'],
+        preventionTips: ['Use linters', 'Code reviews']
+      })
+    }
+
+    if (prompt.includes('enhanced tags')) {
+      return JSON.stringify({
+        enhancedTags: ['refactoring', 'clean-code'],
+        confidence: 0.85,
+        patternTypes: ['extract-method', 'rename-variable']
+      })
+    }
+
+    return 'This is a mock AI response for testing purposes.'
+  }
+
+  /**
+   * Generate explanation for learning materials
+   */
+  async generateExplanation(caseItem) {
+    return `
+## Understanding ${caseItem.title}
+
+### The Problem
+${caseItem.problem}
+
+### Why It Matters
+${caseItem.whyItMatters}
+
+### Impact
+- Affects code maintainability
+- Increases technical debt
+- Makes debugging harder
+- Reduces team productivity
+
+### Best Practices
+${caseItem.preventionTips.map(tip => `- ${tip}`).join('\n')}
+    `.trim()
+  }
+
+  /**
+   * Generate detailed example
+   */
+  async generateDetailedExample(caseItem) {
+    return `
+## Code Example (${caseItem.language})
+
+### Bad Example
+\`\`\`${caseItem.language}
+${caseItem.codeExample}
+\`\`\`
+
+### Good Example
+\`\`\`${caseItem.language}
+// Refactored code following best practices
+// This demonstrates the solution
+    `.trim()
+  }
+
+  /**
+   * Generate practice exercise
+   */
+  async generateExercise(caseItem) {
+    return `
+## Practice Exercise
+
+### Task
+Refactor the following code to address the ${caseItem.title} issue.
+
+### Hints
+- Consider the single responsibility principle
+- Follow naming conventions
+- Keep functions small and focused
+
+### Expected Outcome
+- Improved code quality
+- Better maintainability
+- Clearer intent
+    `.trim()
+  }
+
+  /**
+   * Find related concepts
+   */
+  async findRelatedConcepts(caseItem) {
+    const related = await this.getRecommendations(caseItem.id, 3)
+    return related.map(r => `
+- **${r.title}** (${(r.similarityScore * 100).toFixed(0)}% similar)
+  ${r.problem.substring(0, 100)}...
+    `).join('\n')
+  }
+
+  /**
+   * Format materials as Markdown
+   */
+  formatMaterialsAsMarkdown(materials) {
+    return `# Learning Materials: ${materials.caseId}
+
+Generated: ${materials.generatedAt}
+
+${materials.sections.map(section => `
+## ${section.title}
+
+${section.content}
+`).join('\n')}
+`
+  }
+
+  /**
+   * Generate case ID
+   */
+  generateCaseId() {
+    return `KB-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * Get default solution for issue type
+   */
+  getDefaultSolution(issueType) {
+    const solutions = {
+      'longFunction': 'Extract smaller functions with single responsibilities',
+      'badVariableNames': 'Use descriptive names that explain purpose',
+      'highComplexity': 'Simplify logic and reduce decision points',
+      'duplicateCode': 'Extract to a shared function or constant',
+      'magicNumbers': 'Replace with named constants',
+      'nestedConditionals': 'Use early returns and polymorphism'
+    }
+    return solutions[issueType] || 'Review and improve code structure'
+  }
+
+  /**
+   * Extract tags from issue
+   */
+  extractTagsFromIssue(issue) {
+    const tags = [issue.type, issue.severity]
+    if (issue.category) tags.push(issue.category)
+    return tags
+  }
+
+  /**
+   * Get category from issue
+   */
+  getCategoryFromIssue(issue) {
+    return issue.category || 'general'
+  }
+
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    this.updateStatistics()
+    return this.statistics
+  }
+
+  /**
+   * Export knowledge base
+   */
+  async export(format = 'json') {
+    const exportData = {
+      cases: this.cases,
+      patterns: this.patterns,
+      statistics: this.getStatistics(),
+      exportedAt: new Date().toISOString()
+    }
+
+    if (format === 'json') {
+      return JSON.stringify(exportData, null, 2)
+    }
+
+    if (format === 'markdown') {
+      return this.exportAsMarkdown(exportData)
+    }
+
+    throw new Error(`Unsupported export format: ${format}`)
+  }
+
+  /**
+   * Export as Markdown
+   */
+  exportAsMarkdown(data) {
+    let markdown = `# Knowledge Base Export
+
+Generated: ${data.exportedAt}
+Total Cases: ${data.statistics.totalCases}
+Weekly Cases: ${data.statistics.weeklyCases}
+
+## Cases
+
+`
+
+    for (const caseItem of data.cases) {
+      markdown += `
+### ${caseItem.title}
+
+**Category:** ${caseItem.category}
+**Language:** ${caseItem.language}
+**Difficulty:** ${caseItem.difficulty}
+**Tags:** ${caseItem.tags.join(', ')}
+
+#### Problem
+${caseItem.problem}
+
+#### Solution
+${caseItem.solution}
+
+#### Code Example
+\`\`\`${caseItem.language}
+${caseItem.codeExample}
+\`\`\`
+
+---
+
+`
+    }
+
+    return markdown
+  }
+}
+
+module.exports = AIKnowledgeBase