@metabob/minibob 0.1.2

package/src/understanding/analyzer.ts

@@ -0,0 +1,354 @@
+/**
+ * ApplicationAnalyzer - LLM-powered semantic understanding
+ *
+ * Combines CodeExplorer's static analysis with LLM reasoning
+ * to understand application architecture, patterns, and issues.
+ */
+
+import type { ActivityExecutor } from '../activity'
+import type { CodeExplorer } from './explorer'
+import type {
+  AnalyzeOptions,
+  Analysis,
+  Diagnosis,
+  Pattern
+} from './types'
+import type { Impulse } from '../types'
+
+export class ApplicationAnalyzer {
+  constructor(
+    private executor: ActivityExecutor,
+    private explorer: CodeExplorer
+  ) {}
+
+  /**
+   * Safe wrapper for Bun.file() with better error handling
+   */
+  private safeReadFile(path: string): ReturnType<typeof Bun.file> {
+    if (!path || typeof path !== 'string') {
+      throw new Error(`Invalid file path: expected string, got ${typeof path}`)
+    }
+    try {
+      return Bun.file(path)
+    } catch (error) {
+      throw new Error(`Failed to create file handle for '${path}': ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Analyze application architecture and structure
+   */
+  async analyze(options: AnalyzeOptions): Promise<Analysis> {
+    // 1. Fast static exploration
+    console.log('Exploring codebase structure...')
+    const structure = await this.explorer.explore(options.rootPath)
+
+    // 2. Create impulses from exploration
+    const impulses = this.createImpulsesFromStructure(structure, options.focus)
+
+    // 3. Load and execute analysis activity
+    console.log('Performing semantic analysis with LLM...')
+    const template = await this.loadTemplate('explore-codebase')
+
+    const result = await this.executor.execute({
+      template,
+      variables: {
+        structure: JSON.stringify(structure, null, 2),
+        focus: options.focus || 'architecture',
+        depth: options.depth || 'medium'
+      }
+    })
+
+    // 4. Parse structured output from task results
+    return this.parseAnalysisResult(result)
+  }
+
+  /**
+   * Diagnose specific problem in application
+   */
+  async diagnose(problem: string, context?: string[]): Promise<Diagnosis> {
+    // 1. Gather relevant context files
+    const relevantFiles = context || await this.findRelevantFiles(problem)
+
+    if (relevantFiles.length === 0) {
+      return {
+        symptoms: [problem],
+        rootCause: 'Unable to find relevant files for analysis',
+        affectedFiles: [],
+        recommendedFix: 'Please provide specific file paths or more context',
+        validationSteps: [],
+        confidence: 'low'
+      }
+    }
+
+    // 2. Create impulses for relevant files
+    const impulses: Impulse[] = relevantFiles.slice(0, 5).map(path => ({
+      id: `file_${path.replace(/[^a-zA-Z0-9]/g, '_')}`,
+      pointer: { type: 'file', path },
+      budget: 2000,
+      priority: 'high' as const,
+      loaded: false,
+      content: null
+    }))
+
+    // 3. Execute diagnosis activity
+    console.log(`Diagnosing problem across ${impulses.length} files...`)
+    const template = await this.loadTemplate('diagnose-problem')
+
+    const result = await this.executor.execute({
+      template,
+      variables: {
+        problem,
+        files: relevantFiles.join(', ')
+      }
+    })
+
+    // 4. Parse diagnosis result
+    return this.parseDiagnosis(result)
+  }
+
+  /**
+   * Detect patterns in codebase
+   */
+  async detectPatterns(rootPath: string): Promise<Pattern[]> {
+    const structure = await this.explorer.explore(rootPath)
+    const patterns: Pattern[] = []
+
+    // Detect common architecture patterns
+    if (structure.dependencies.frameworks.includes('React')) {
+      patterns.push({
+        type: 'architecture',
+        name: 'React SPA',
+        description: 'React-based single-page application',
+        instances: [{ file: 'package.json' }]
+      })
+    }
+
+    if (structure.dependencies.frameworks.includes('Hono') ||
+        structure.dependencies.frameworks.includes('Express')) {
+      patterns.push({
+        type: 'architecture',
+        name: 'HTTP Server',
+        description: 'HTTP server application',
+        instances: [{ file: 'package.json' }]
+      })
+    }
+
+    // Detect entry point patterns
+    if (structure.entryPoints.includes('index.ts') && structure.entryPoints.includes('server.ts')) {
+      patterns.push({
+        type: 'architecture',
+        name: 'Client-Server Split',
+        description: 'Separate client and server entry points',
+        instances: [
+          { file: 'index.ts', context: 'Client entry' },
+          { file: 'server.ts', context: 'Server entry' }
+        ]
+      })
+    }
+
+    return patterns
+  }
+
+  /**
+   * Create impulses from codebase structure
+   */
+  private createImpulsesFromStructure(
+    structure: any,
+    focus?: string
+  ): Impulse[] {
+    const impulses: Impulse[] = []
+
+    // Add entry point impulses (high priority)
+    for (const entryPoint of structure.entryPoints.slice(0, 3)) {
+      impulses.push({
+        id: `entrypoint_${entryPoint.replace(/[^a-zA-Z0-9]/g, '_')}`,
+        pointer: { type: 'file', path: entryPoint, limit: 100 },
+        budget: 1500,
+        priority: 'high' as const,
+        loaded: false,
+        content: null
+      })
+    }
+
+    // Add package.json for dependency info (medium priority)
+    impulses.push({
+      id: 'dependencies',
+      pointer: { type: 'file', path: 'package.json' },
+      budget: 500,
+      priority: 'medium' as const,
+      loaded: false,
+      content: null
+    })
+
+    // Focus-specific impulses
+    if (focus === 'components' && structure.filesByType['tsx']) {
+      // Add React component files
+      impulses.push({
+        id: 'react_components',
+        pointer: { type: 'memo', content: `Component files: ${structure.filesByType['tsx']} .tsx files found` },
+        budget: 300,
+        priority: 'medium' as const,
+        loaded: false,
+        content: null
+      })
+    }
+
+    return impulses
+  }
+
+  /**
+   * Find files relevant to problem description
+   */
+  private async findRelevantFiles(problem: string): Promise<string[]> {
+    const keywords = this.extractKeywords(problem)
+    const structure = await this.explorer.explore(process.cwd())
+
+    // Build list of all files
+    const allFiles: string[] = []
+    const collectFiles = (node: any) => {
+      if (node.type === 'file') {
+        allFiles.push(node.path)
+      }
+      if (node.children) {
+        for (const child of node.children) {
+          collectFiles(child)
+        }
+      }
+    }
+    collectFiles(structure.directoryStructure)
+
+    // Filter by keywords
+    const relevant = allFiles.filter(file =>
+      keywords.some(kw => file.toLowerCase().includes(kw.toLowerCase()))
+    )
+
+    return relevant.slice(0, 10)
+  }
+
+  /**
+   * Extract keywords from problem description
+   */
+  private extractKeywords(text: string): string[] {
+    // Remove common words and extract meaningful terms
+    const stopWords = new Set(['the', 'is', 'at', 'which', 'on', 'a', 'an', 'and', 'or', 'but', 'in', 'with', 'to', 'for'])
+    const words = text.toLowerCase()
+      .replace(/[^a-z0-9\s]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 2 && !stopWords.has(w))
+
+    return Array.from(new Set(words))
+  }
+
+  /**
+   * Load activity template
+   */
+  private async loadTemplate(templateId: string): Promise<any> {
+    // Try loading from local templates in multiple locations
+    const possiblePaths = [
+      `templates/understanding/${templateId}.json`,
+      `./templates/understanding/${templateId}.json`,
+      `${process.cwd()}/templates/understanding/${templateId}.json`,
+      // Also try from minibob directory if we're running elsewhere
+      `${__dirname}/../../templates/understanding/${templateId}.json`,
+    ]
+
+    for (const templatePath of possiblePaths) {
+      try {
+        const content = await this.safeReadFile(templatePath).text()
+        const template = JSON.parse(content)
+        console.log(`Loaded template from: ${templatePath}`)
+        return template
+      } catch (error) {
+        // Try next path
+      }
+    }
+
+    // Template not found in any location
+    throw new Error(`Template not found: ${templateId}. Tried paths: ${possiblePaths.join(', ')}`)
+  }
+
+  /**
+   * Parse analysis result from LLM output
+   */
+  private parseAnalysisResult(result: any): Analysis {
+    // Extract analysis from task results
+    const output = result.taskResults?.[0]?.output || result.output || ''
+
+    // Try to parse as JSON
+    try {
+      // Look for JSON in output
+      const jsonMatch = output.match(/\{[\s\S]*\}/)
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0])
+      }
+    } catch (error) {
+      // Fallback to text parsing
+    }
+
+    // Fallback: create structured response from text
+    return {
+      architecture: {
+        pattern: 'Unknown',
+        description: output.substring(0, 500),
+        layers: []
+      },
+      components: {
+        summary: 'See full output for details',
+        keyModules: []
+      },
+      dataFlow: {
+        description: 'Analysis in progress',
+        flows: []
+      },
+      entryPoints: {
+        main: []
+      },
+      dependencies: {
+        external: [],
+        internal: []
+      },
+      techStack: {
+        runtime: 'Unknown',
+        framework: [],
+        language: [],
+        tools: []
+      }
+    }
+  }
+
+  /**
+   * Parse diagnosis result from LLM output
+   */
+  private parseDiagnosis(result: any): Diagnosis {
+    const output = result.taskResults?.[0]?.output || result.output || ''
+
+    // Try to parse as JSON
+    try {
+      const jsonMatch = output.match(/\{[\s\S]*\}/)
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0])
+        return {
+          symptoms: parsed.symptoms || [output.substring(0, 200)],
+          rootCause: parsed.rootCause || 'See full analysis',
+          affectedFiles: parsed.affectedFiles || [],
+          recommendedFix: parsed.recommendedFix || 'Review analysis output',
+          validationSteps: parsed.validationSteps || [],
+          confidence: parsed.confidence || 'medium'
+        }
+      }
+    } catch (error) {
+      // Fallback
+    }
+
+    // Fallback: extract from text
+    return {
+      symptoms: [output.substring(0, 200)],
+      rootCause: 'See full analysis in output',
+      affectedFiles: [],
+      recommendedFix: output,
+      validationSteps: ['Review LLM analysis', 'Validate proposed changes'],
+      confidence: 'medium'
+    }
+  }
+}