@wundr.io/cli 1.0.1 → 1.0.2-dev.20260530180455.e1307186

package/src/commands/ai.ts

@@ -1,24 +1,55 @@
-import { Command } from 'commander';
-import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { PluginManager } from '../plugins/plugin-manager';
+import inquirer from 'inquirer';
+
 import { AIService } from '../ai/ai-service';
-import { logger } from '../utils/logger';
 import { errorHandler } from '../utils/error-handler';
-import { ChatSession } from '../types';
+import { logger } from '../utils/logger';
+
+import type { PluginManager } from '../plugins/plugin-manager';
+import type { ChatSession } from '../types';
+import type { ConfigManager } from '../utils/config-manager';
+import type { Command } from 'commander';
+
+/** Review result for a single file */
+interface FileReviewResult {
+  file: string;
+  issues: Array<{ severity: string; description: string }>;
+  suggestions: string[];
+  score: number;
+}
+
+/** Refactoring plan from AI analysis */
+interface RefactoringPlan {
+  description: string;
+  changes: Array<{ description: string; code?: string }>;
+}
+
+/** Optimization plan from AI analysis */
+interface OptimizationPlan {
+  description: string;
+  changes: Array<{ description: string; code?: string }>;
+  optimizedCode: string;
+}
+
+/** Benchmark result metrics */
+interface BenchmarkResult {
+  time: number;
+  memory: number;
+}
 
 /**
  * AI commands for AI-powered development features
  */
 export class AICommands {
   private aiService: AIService;
+  private pluginManager: PluginManager;
 
   constructor(
     private program: Command,
     private configManager: ConfigManager,
-    private _pluginManager: PluginManager
+    pluginManager: PluginManager
   ) {
+    this.pluginManager = pluginManager;
     this.aiService = new AIService(configManager);
     this.registerCommands();
   }
@@ -261,12 +292,7 @@ export class AICommands {
 
       const filesToReview =
         files.length > 0 ? files : await this.getChangedFiles();
-      const reviewResults: Array<{
-        file: string;
-        issues: any;
-        suggestions: any;
-        score: any;
-      }> = [];
+      const reviewResults: FileReviewResult[] = [];
 
       for (const file of filesToReview) {
         logger.debug(`Reviewing ${file}...`);
@@ -378,7 +404,7 @@ export class AICommands {
       );
 
       const code = await this.readFile(target);
-      const _docs = await this.callAI('docs', {
+      const docs = await this.callAI('docs', {
         code,
         target,
         type: options.type,
@@ -391,7 +417,7 @@ export class AICommands {
         options.type,
         options.format
       );
-      await this.saveGeneratedDocs(_docs, outputPath);
+      await this.saveGeneratedDocs(docs, outputPath);
 
       logger.success(`Documentation generated: ${outputPath}`);
     } catch (error) {
@@ -526,13 +552,13 @@ export class AICommands {
       logger.info(`Optimizing ${chalk.cyan(target)}...`);
 
       const code = await this.readFile(target);
-      let beforeBenchmark = null;
+      let beforeBenchmark: BenchmarkResult | undefined;
 
       if (options.benchmarks) {
         beforeBenchmark = await this.runBenchmark(target);
       }
 
-      const _optimization = await this.callAI('optimize', {
+      const optimization: OptimizationPlan = await this.callAI('optimize', {
         code,
         target,
         focus: options.focus,
@@ -548,9 +574,9 @@ export class AICommands {
       ]);
 
       if (apply) {
-        await this.applyOptimization(target, _optimization);
+        await this.applyOptimization(target, optimization);
 
-        if (options.benchmarks) {
+        if (options.benchmarks && beforeBenchmark) {
           const afterBenchmark = await this.runBenchmark(target);
           this.displayBenchmarkComparison(beforeBenchmark, afterBenchmark);
         }
@@ -783,29 +809,153 @@ export class AICommands {
   private async callAI(operation: string, params: any): Promise<any> {
     // Check if AI service is ready
     if (!this.aiService.isReady()) {
-      throw new Error('AI service not configured. Run `wundr ai setup` first.');
+      throw new Error(
+        'AI service not configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run `wundr ai setup`.'
+      );
     }
 
     logger.debug(`Calling AI for operation: ${operation}`);
 
-    // For now, return mock responses - these would be replaced with actual AI calls
+    const sessionId = `ai-cmd-${operation}-${Date.now()}`;
+
     switch (operation) {
-      case 'generate':
-        return `// Generated ${params.type} code\nfunction ${params.type}() {\n  // Implementation here\n}`;
-      case 'review':
-        return { issues: [], suggestions: [], score: 95 };
-      case 'refactor':
-        return { description: 'Refactoring plan', changes: [] };
-      case 'docs':
-        return `# ${params.target} Documentation\n\nGenerated documentation...`;
-      case 'test':
-        return `// Generated tests\ndescribe('${params.target}', () => {\n  // Tests here\n});`;
-      case 'analyze':
-        return { complexity: 'low', maintainability: 'high', suggestions: [] };
-      case 'optimize':
-        return { description: 'Optimization plan', changes: [] };
+      case 'generate': {
+        const prompt = [
+          `Generate ${params.type} code.`,
+          params.prompt ? `Requirements: ${params.prompt}` : '',
+          params.template ? `Use template style: ${params.template}` : '',
+          params.context ? `Context:\n${params.context}` : '',
+          'Return only the code, no explanation.',
+        ]
+          .filter(Boolean)
+          .join('\n');
+        return this.aiService.sendMessage(sessionId, prompt);
+      }
+
+      case 'review': {
+        const prompt = [
+          `Review the following ${params.file} code for issues.`,
+          `Focus: ${params.focus || 'all'}. Minimum severity: ${params.severity || 'info'}.`,
+          'Return a JSON object with this exact shape: {"issues":[{"severity":"string","description":"string"}],"suggestions":["string"],"score":number}',
+          `Code:\n${params.code}`,
+        ].join('\n');
+        const raw = await this.aiService.sendMessage(sessionId, prompt);
+        try {
+          const jsonMatch = raw.match(/\{[\s\S]*\}/);
+          return jsonMatch
+            ? JSON.parse(jsonMatch[0])
+            : { issues: [], suggestions: [], score: 0 };
+        } catch {
+          return { issues: [], suggestions: [], score: 0 };
+        }
+      }
+
+      case 'refactor': {
+        const prompt = [
+          `Create a refactoring plan for the following code in ${params.target}.`,
+          `Refactoring type: ${params.type || 'optimize'}. Scope: ${params.scope || 'function'}.`,
+          'Return a JSON object with this exact shape: {"description":"string","changes":[{"description":"string","code":"string"}]}',
+          `Code:\n${params.code}`,
+        ].join('\n');
+        const raw = await this.aiService.sendMessage(sessionId, prompt);
+        try {
+          const jsonMatch = raw.match(/\{[\s\S]*\}/);
+          return jsonMatch
+            ? JSON.parse(jsonMatch[0])
+            : { description: '', changes: [] };
+        } catch {
+          return { description: '', changes: [] };
+        }
+      }
+
+      case 'docs': {
+        const prompt = [
+          `Generate ${params.type || 'api'} documentation in ${params.format || 'markdown'} format for ${params.target}.`,
+          params.includeExamples ? 'Include code examples.' : '',
+          `Code:\n${params.code}`,
+        ]
+          .filter(Boolean)
+          .join('\n');
+        return this.aiService.sendMessage(sessionId, prompt);
+      }
+
+      case 'test': {
+        const prompt = [
+          `Generate ${params.coverage || 'unit'} tests using ${params.framework || 'jest'} for ${params.target}.`,
+          params.mocks ? 'Include mock objects where appropriate.' : '',
+          'Return only the test code, no explanation.',
+          `Code:\n${params.code}`,
+        ]
+          .filter(Boolean)
+          .join('\n');
+        return this.aiService.sendMessage(sessionId, prompt);
+      }
+
+      case 'analyze': {
+        const prompt = [
+          `Analyze the following code from ${params.target}.`,
+          `Aspect: ${params.aspect || 'all'}.`,
+          params.suggestions ? 'Include improvement suggestions.' : '',
+          'Return a JSON object with this exact shape: {"complexity":"string","maintainability":"string","suggestions":["string"]}',
+          `Code:\n${params.code}`,
+        ]
+          .filter(Boolean)
+          .join('\n');
+        const raw = await this.aiService.sendMessage(sessionId, prompt);
+        try {
+          const jsonMatch = raw.match(/\{[\s\S]*\}/);
+          return jsonMatch
+            ? JSON.parse(jsonMatch[0])
+            : {
+                complexity: 'unknown',
+                maintainability: 'unknown',
+                suggestions: [],
+              };
+        } catch {
+          return {
+            complexity: 'unknown',
+            maintainability: 'unknown',
+            suggestions: [],
+          };
+        }
+      }
+
+      case 'optimize': {
+        const prompt = [
+          `Create a performance optimization plan for the following code in ${params.target}.`,
+          `Optimization focus: ${params.focus || 'speed'}.`,
+          'Return a JSON object with this exact shape: {"description":"string","changes":[{"description":"string"}],"optimizedCode":"string"}',
+          `Code:\n${params.code}`,
+        ].join('\n');
+        const raw = await this.aiService.sendMessage(sessionId, prompt);
+        try {
+          const jsonMatch = raw.match(/\{[\s\S]*\}/);
+          return jsonMatch
+            ? JSON.parse(jsonMatch[0])
+            : { description: '', changes: [], optimizedCode: params.code };
+        } catch {
+          return { description: '', changes: [], optimizedCode: params.code };
+        }
+      }
+
       case 'chat':
-        return 'This is a mock response. In a real implementation, this would use the AI service.';
+        return this.aiService.sendMessage(sessionId, params.message || '');
+
+      case 'suggest-fix': {
+        const prompt = [
+          `Suggest a fix for the following issue in ${params.file}:`,
+          `Issue (${params.severity}): ${params.issue}`,
+          'Return a JSON object with this shape: {"suggestion":"string"}',
+        ].join('\n');
+        const raw = await this.aiService.sendMessage(sessionId, prompt);
+        try {
+          const jsonMatch = raw.match(/\{[\s\S]*\}/);
+          return jsonMatch ? JSON.parse(jsonMatch[0]) : { suggestion: raw };
+        } catch {
+          return { suggestion: raw };
+        }
+      }
+
       default:
         throw new Error(`Unknown AI operation: ${operation}`);
     }
@@ -824,48 +974,120 @@ export class AICommands {
   }
 
   private async loadContext(contextPath: string): Promise<string> {
-    // Load project context from specified path
-    return `// Context from ${contextPath}`;
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const stat = await fs.stat(contextPath);
+    if (stat.isDirectory()) {
+      // Read all TypeScript/JavaScript files in the directory (non-recursive, shallow)
+      const entries = await fs.readdir(contextPath);
+      const parts: string[] = [];
+      for (const entry of entries) {
+        if (/\.(ts|tsx|js|jsx)$/.test(entry)) {
+          const filePath = path.join(contextPath, entry);
+          const content = await fs.readFile(filePath, 'utf-8');
+          parts.push(`// ${filePath}\n${content}`);
+        }
+      }
+      return parts.join('\n\n');
+    }
+    return fs.readFile(contextPath, 'utf-8');
   }
 
   private async saveGeneratedCode(
-    _code: string,
+    code: string,
     outputPath: string
   ): Promise<void> {
-    // Save generated code to file
-    logger.debug(`Saving generated code to ${outputPath}`);
+    const fs = await import('fs/promises');
+    const path = await import('path');
+
+    // Ensure directory exists
+    const dir = path.dirname(outputPath);
+    await fs.mkdir(dir, { recursive: true });
+
+    // Write the generated code to file
+    await fs.writeFile(outputPath, code, 'utf-8');
+    logger.debug(`Saved generated code to ${outputPath}`);
   }
 
   private async readFile(filePath: string): Promise<string> {
-    // Read file content
-    return `// Content of ${filePath}`;
+    const fs = await import('fs/promises');
+    return fs.readFile(filePath, 'utf-8');
   }
 
   private async getChangedFiles(): Promise<string[]> {
-    // Get list of changed files from git
-    return ['src/example.ts'];
+    const { execSync } = await import('child_process');
+    try {
+      const output = execSync('git diff --name-only HEAD', {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      if (!output) {
+        return [];
+      }
+      return output.split('\n').filter(Boolean);
+    } catch {
+      // Fall back to staged changes if HEAD diff fails (e.g. no commits yet)
+      try {
+        const { execSync: exec } = await import('child_process');
+        const output = exec('git diff --name-only --cached', {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return output ? output.split('\n').filter(Boolean) : [];
+      } catch {
+        return [];
+      }
+    }
   }
 
-  private displayReviewResults(results: any[]): void {
+  private displayReviewResults(results: FileReviewResult[]): void {
     console.log(chalk.blue('\nCode Review Results:'));
     results.forEach(result => {
       console.log(`\n${chalk.cyan(result.file)} (Score: ${result.score}/100)`);
       if (result.issues.length > 0) {
-        result.issues.forEach((issue: any) => {
+        result.issues.forEach(issue => {
           console.log(`  ${issue.severity}: ${issue.description}`);
         });
       }
     });
   }
 
-  private async suggestFixes(_results: any[]): Promise<void> {
-    // Implementation for suggesting fixes
+  private async suggestFixes(results: FileReviewResult[]): Promise<void> {
     logger.info('Generating fix suggestions...');
+
+    for (const result of results) {
+      if (result.issues.length > 0) {
+        console.log(chalk.yellow(`\nSuggested fixes for ${result.file}:`));
+        for (const issue of result.issues) {
+          const fix = await this.callAI('suggest-fix', {
+            file: result.file,
+            issue: issue.description,
+            severity: issue.severity,
+          });
+          console.log(
+            `  - ${issue.description}: ${fix.suggestion || 'No automatic fix available'}`
+          );
+        }
+      }
+    }
   }
 
-  private async applyRefactoring(target: string, _plan: any): Promise<void> {
-    // Apply refactoring changes
+  private async applyRefactoring(
+    target: string,
+    plan: RefactoringPlan
+  ): Promise<void> {
+    const fs = await import('fs/promises');
+
     logger.debug(`Applying refactoring to ${target}`);
+    logger.info(`Refactoring: ${plan.description}`);
+
+    // Apply each change from the refactoring plan
+    for (const change of plan.changes) {
+      logger.debug(`  Applying: ${change.description}`);
+      if (change.code) {
+        await fs.writeFile(target, change.code, 'utf-8');
+      }
+    }
   }
 
   private getDocsOutputPath(
@@ -878,15 +1100,29 @@ export class AICommands {
   }
 
   private async saveGeneratedDocs(
-    _docs: string,
+    docs: string,
     outputPath: string
   ): Promise<void> {
-    // Save generated documentation
-    logger.debug(`Saving documentation to ${outputPath}`);
+    const fs = await import('fs/promises');
+    const path = await import('path');
+
+    // Ensure docs directory exists
+    const dir = path.dirname(outputPath);
+    await fs.mkdir(dir, { recursive: true });
+
+    // Write the generated documentation to file
+    await fs.writeFile(outputPath, docs, 'utf-8');
+    logger.debug(`Saved documentation to ${outputPath}`);
   }
 
-  private getTestOutputPath(target: string, _framework: string): string {
-    return `${target}.test.js`;
+  private getTestOutputPath(target: string, framework: string): string {
+    const path = require('path');
+    const baseName = path.basename(target, path.extname(target));
+    const dirName = path.dirname(target);
+
+    // Use framework-specific test file extensions
+    const extension = framework === 'vitest' ? '.test.ts' : '.test.js';
+    return path.join(dirName, '__tests__', `${baseName}${extension}`);
   }
 
   private async loadChatSession(sessionId: string): Promise<ChatSession> {
@@ -970,26 +1206,66 @@ export class AICommands {
     }
   }
 
-  private async runBenchmark(_target: string): Promise<any> {
-    // Run performance benchmark
-    return { time: 100, memory: 50 };
+  private async runBenchmark(target: string): Promise<BenchmarkResult> {
+    const { performance } = await import('perf_hooks');
+
+    logger.debug(`Running benchmark for ${target}`);
+
+    const startTime = performance.now();
+    const startMemory = process.memoryUsage().heapUsed / 1024 / 1024;
+
+    // Simulate loading and analyzing the file for benchmarking
+    const code = await this.readFile(target);
+    // Simple analysis to measure time
+    const lines = code.split('\n').length;
+    logger.debug(`Analyzed ${lines} lines`);
+
+    const endTime = performance.now();
+    const endMemory = process.memoryUsage().heapUsed / 1024 / 1024;
+
+    return {
+      time: Math.round(endTime - startTime),
+      memory: Math.round(endMemory - startMemory),
+    };
   }
 
   private async applyOptimization(
     target: string,
-    _optimization: any
+    optimization: OptimizationPlan
   ): Promise<void> {
-    // Apply optimization changes
+    const fs = await import('fs/promises');
+
     logger.debug(`Applying optimization to ${target}`);
+    logger.info(`Optimization: ${optimization.description}`);
+
+    // Log each change being applied
+    for (const change of optimization.changes) {
+      logger.debug(`  Applying: ${change.description}`);
+    }
+
+    // Write the optimized code to the file
+    if (optimization.optimizedCode) {
+      await fs.writeFile(target, optimization.optimizedCode, 'utf-8');
+      logger.success(`Optimization applied to ${target}`);
+    }
   }
 
-  private displayBenchmarkComparison(before: any, after: any): void {
+  private displayBenchmarkComparison(
+    before: BenchmarkResult,
+    after: BenchmarkResult
+  ): void {
     console.log(chalk.blue('\nBenchmark Comparison:'));
+    const timeDiff = after.time - before.time;
+    const memDiff = after.memory - before.memory;
+
+    const timeColor = timeDiff < 0 ? chalk.green : chalk.yellow;
+    const memColor = memDiff < 0 ? chalk.green : chalk.yellow;
+
     console.log(
-      `Time: ${before.time}ms → ${after.time}ms (${after.time - before.time}ms)`
+      `Time: ${before.time}ms → ${after.time}ms (${timeColor(timeDiff > 0 ? '+' : '')}${timeColor(timeDiff + 'ms')})`
     );
     console.log(
-      `Memory: ${before.memory}MB → ${after.memory}MB (${after.memory - before.memory}MB)`
+      `Memory: ${before.memory}MB → ${after.memory}MB (${memColor(memDiff > 0 ? '+' : '')}${memColor(memDiff + 'MB')})`
     );
   }
 }