@wundr.io/cli 1.0.11 → 1.0.13

package/src/commands/analyze-optimized.ts

@@ -10,7 +10,6 @@ import { Command } from 'commander';
 import * as fs from 'fs-extra';
 import ora from 'ora';
 
-
 // Use analysis-engine modules for testing
 // Temporarily using inline implementation for CodeAnalyzer
 
@@ -90,7 +89,10 @@ interface BenchmarkSuiteConfig {
 // Functional implementations for testing
 class MemoryMonitor {
   private config: MemoryMonitorConfig;
-  private eventHandlers: Map<string, EventCallback<MemoryAlert | MemoryLeakAnalysis>[]> = new Map();
+  private eventHandlers: Map<
+    string,
+    EventCallback<MemoryAlert | MemoryLeakAnalysis>[]
+  > = new Map();
   private monitoringInterval: NodeJS.Timeout | null = null;
   private samples: number[] = [];
 
@@ -102,7 +104,10 @@ class MemoryMonitor {
     };
   }
 
-  on(event: string, callback: EventCallback<MemoryAlert | MemoryLeakAnalysis>): void {
+  on(
+    event: string,
+    callback: EventCallback<MemoryAlert | MemoryLeakAnalysis>
+  ): void {
     if (!this.eventHandlers.has(event)) {
       this.eventHandlers.set(event, []);
     }
@@ -123,10 +128,16 @@ class MemoryMonitor {
       this.samples.push(currentMemory);
 
       // Check for memory threshold alerts
-      if (currentMemory > this.config.maxMemoryUsage! * this.config.alertThreshold!) {
+      if (
+        currentMemory >
+        this.config.maxMemoryUsage! * this.config.alertThreshold!
+      ) {
         this.emit('memory-alert', {
           type: 'threshold',
-          severity: currentMemory > this.config.maxMemoryUsage! ? 'critical' : 'warning',
+          severity:
+            currentMemory > this.config.maxMemoryUsage!
+              ? 'critical'
+              : 'warning',
           current: currentMemory,
           threshold: this.config.maxMemoryUsage!,
         });
@@ -139,7 +150,8 @@ class MemoryMonitor {
         const lastSample = recentSamples[9];
         if (firstSample !== undefined && lastSample !== undefined) {
           const growthRate = (lastSample - firstSample) / 10;
-          if (growthRate > 1024 * 1024) { // Growing more than 1MB per sample
+          if (growthRate > 1024 * 1024) {
+            // Growing more than 1MB per sample
             this.emit('memory-leak-detected', {
               detected: true,
               growthRate,
@@ -161,10 +173,14 @@ class MemoryMonitor {
 
   getMetrics() {
     const currentMemory = process.memoryUsage();
-    const peakHeapUsed = this.samples.length > 0 ? Math.max(...this.samples) : currentMemory.heapUsed * 1.2;
-    const averageHeapUsed = this.samples.length > 0
-      ? this.samples.reduce((a, b) => a + b, 0) / this.samples.length
-      : currentMemory.heapUsed;
+    const peakHeapUsed =
+      this.samples.length > 0
+        ? Math.max(...this.samples)
+        : currentMemory.heapUsed * 1.2;
+    const averageHeapUsed =
+      this.samples.length > 0
+        ? this.samples.reduce((a, b) => a + b, 0) / this.samples.length
+        : currentMemory.heapUsed;
 
     return {
       data: {
@@ -249,14 +265,20 @@ class SimpleAnalyzer {
 class OptimizedBaseAnalysisService {
   private analyzer: SimpleAnalyzer;
   private config: AnalysisServiceConfig;
-  private eventHandlers: Map<string, EventCallback<ProgressEvent | MemoryLeakWarning>[]> = new Map();
+  private eventHandlers: Map<
+    string,
+    EventCallback<ProgressEvent | MemoryLeakWarning>[]
+  > = new Map();
 
   constructor(config: AnalysisServiceConfig) {
     this.config = config;
     this.analyzer = new SimpleAnalyzer();
   }
 
-  on(event: string, callback: EventCallback<ProgressEvent | MemoryLeakWarning>): void {
+  on(
+    event: string,
+    callback: EventCallback<ProgressEvent | MemoryLeakWarning>
+  ): void {
     if (!this.eventHandlers.has(event)) {
       this.eventHandlers.set(event, []);
     }
@@ -271,7 +293,10 @@ class OptimizedBaseAnalysisService {
   }
 
   async initialize(): Promise<void> {
-    this.emit('progress', { type: 'phase', message: 'Initializing analysis service...' });
+    this.emit('progress', {
+      type: 'phase',
+      message: 'Initializing analysis service...',
+    });
 
     // Ensure output directory exists
     await fs.ensureDir(this.config.outputDir);
@@ -389,7 +414,7 @@ class PerformanceBenchmarkSuite {
           metrics: {
             avgExecutionTime: executionTime,
             peakMemory: memoryAfter,
-            filesPerSecond: 1000 / executionTime * 100,
+            filesPerSecond: (1000 / executionTime) * 100,
           },
         },
       });
@@ -397,7 +422,10 @@ class PerformanceBenchmarkSuite {
 
     // Save results if profiling is enabled
     if (this.config.enableProfiling) {
-      const outputPath = path.join(this.config.outputDir!, 'benchmark-results.json');
+      const outputPath = path.join(
+        this.config.outputDir!,
+        'benchmark-results.json'
+      );
       await fs.writeJson(outputPath, results, { spaces: 2 });
     }
 
@@ -423,7 +451,12 @@ class PerformanceBenchmarkSuite {
     const recoveryTime = Date.now() - this.startTime;
 
     return {
-      stabilityScore: Math.min(100, Math.round(100 - ((peakMemory - memoryBefore) / this.config.memoryLimit!) * 100)),
+      stabilityScore: Math.min(
+        100,
+        Math.round(
+          100 - ((peakMemory - memoryBefore) / this.config.memoryLimit!) * 100
+        )
+      ),
       peakMemory,
       recoveryTime,
     };
@@ -457,24 +490,24 @@ export function createOptimizedAnalyzeCommand(): Command {
   const command = new Command('analyze-optimized')
     .alias('ao')
     .description(
-      'Run optimized analysis with memory management and high concurrency',
+      'Run optimized analysis with memory management and high concurrency'
     )
     .argument('<directory>', 'Directory to analyze')
     .option(
       '-o, --output <path>',
       'Output directory for results',
-      './wundr-analysis',
+      './wundr-analysis'
     )
     .option(
       '-f, --format <format>',
       'Output format (json, html, markdown, all)',
-      'json',
+      'json'
     )
     .option('-v, --verbose', 'Verbose output with detailed progress', false)
     .option(
       '--max-memory <size>',
       'Maximum memory usage (e.g., 250MB, 1GB)',
-      '250MB',
+      '250MB'
     )
     .option('--max-workers <count>', 'Maximum number of workers', '32')
     .option('--enable-streaming', 'Enable streaming for large codebases', true)
@@ -484,7 +517,7 @@ export function createOptimizedAnalyzeCommand(): Command {
     .option(
       '--cache-enabled',
       'Enable caching for faster repeated analysis',
-      true,
+      true
     )
     .option('--include <patterns...>', 'File patterns to include', [
       '**/*.{ts,tsx,js,jsx}',
@@ -505,7 +538,7 @@ export function createOptimizedAnalyzeCommand(): Command {
  */
 async function runOptimizedAnalysis(
   directory: string,
-  options: OptimizedAnalysisOptions,
+  options: OptimizedAnalysisOptions
 ): Promise<void> {
   const startTime = Date.now();
   const spinner = ora('Initializing optimized analysis...').start();
@@ -550,8 +583,8 @@ async function runOptimizedAnalysis(
       if (options.verbose) {
         spinner.warn(
           color(
-            `Memory Alert: ${alert.type} - ${Math.round(alert.current / 1024 / 1024)}MB`,
-          ),
+            `Memory Alert: ${alert.type} - ${Math.round(alert.current / 1024 / 1024)}MB`
+          )
         );
       }
     });
@@ -559,8 +592,8 @@ async function runOptimizedAnalysis(
     memoryMonitor.on('memory-leak-detected', (analysis: any) => {
       spinner.warn(
         chalk.red(
-          `Memory leak detected! Growth rate: ${Math.round(analysis.growthRate / 1024)}KB/s`,
-        ),
+          `Memory leak detected! Growth rate: ${Math.round(analysis.growthRate / 1024)}KB/s`
+        )
       );
     });
 
@@ -597,8 +630,8 @@ async function runOptimizedAnalysis(
       analysisService.on('memory-leak-warning', (warning: any) => {
         spinner.warn(
           chalk.yellow(
-            `Memory Warning: ${warning.severity} - Growth: ${Math.round(warning.growthRate / 1024)}KB/s`,
-          ),
+            `Memory Warning: ${warning.severity} - Growth: ${Math.round(warning.growthRate / 1024)}KB/s`
+          )
         );
       });
     }
@@ -626,27 +659,27 @@ async function runOptimizedAnalysis(
     console.log(chalk.cyan('📊 Performance Summary:'));
     console.log(chalk.gray(`   Duration: ${formatDuration(duration)}`));
     console.log(
-      chalk.gray(`   Files analyzed: ${result.data?.summary.totalFiles || 0}`),
+      chalk.gray(`   Files analyzed: ${result.data?.summary.totalFiles || 0}`)
     );
     console.log(
       chalk.gray(
-        `   Entities found: ${result.data?.summary.totalEntities || 0}`,
-      ),
+        `   Entities found: ${result.data?.summary.totalEntities || 0}`
+      )
     );
     console.log(
       chalk.gray(
-        `   Peak memory: ${formatFileSize(memoryMetrics.peak.heapUsed)}`,
-      ),
+        `   Peak memory: ${formatFileSize(memoryMetrics.peak.heapUsed)}`
+      )
     );
     console.log(
       chalk.gray(
-        `   Average memory: ${formatFileSize(memoryMetrics.average.heapUsed)}`,
-      ),
+        `   Average memory: ${formatFileSize(memoryMetrics.average.heapUsed)}`
+      )
     );
     console.log(
       chalk.gray(
-        `   Processing rate: ${Math.round((result.data?.summary.totalFiles || 0) / (duration / 1000))} files/sec`,
-      ),
+        `   Processing rate: ${Math.round((result.data?.summary.totalFiles || 0) / (duration / 1000))} files/sec`
+      )
     );
 
     // Analysis results
@@ -654,49 +687,49 @@ async function runOptimizedAnalysis(
       console.log(chalk.cyan('\n🔍 Analysis Results:'));
       console.log(
         chalk.gray(
-          `   Duplicate clusters: ${result.data.summary.duplicateClusters}`,
-        ),
+          `   Duplicate clusters: ${result.data.summary.duplicateClusters}`
+        )
       );
       console.log(
         chalk.gray(
-          `   Circular dependencies: ${result.data.summary.circularDependencies}`,
-        ),
+          `   Circular dependencies: ${result.data.summary.circularDependencies}`
+        )
       );
       console.log(
-        chalk.gray(`   Code smells: ${result.data.summary.codeSmells}`),
+        chalk.gray(`   Code smells: ${result.data.summary.codeSmells}`)
       );
       console.log(
         chalk.gray(
-          `   Technical debt score: ${result.data.summary.technicalDebt}/100`,
-        ),
+          `   Technical debt score: ${result.data.summary.technicalDebt}/100`
+        )
       );
     }
 
     // Memory efficiency
     const memoryEfficiency = calculateMemoryEfficiency(
       result.data?.summary.totalFiles || 0,
-      memoryMetrics.peak.heapUsed,
+      memoryMetrics.peak.heapUsed
     );
     console.log(chalk.cyan('\n💾 Memory Efficiency:'));
     console.log(
-      chalk.gray(`   Efficiency score: ${memoryEfficiency.toFixed(1)}%`),
+      chalk.gray(`   Efficiency score: ${memoryEfficiency.toFixed(1)}%`)
     );
     console.log(
       chalk.gray(
-        `   Memory per file: ${Math.round(memoryMetrics.average.heapUsed / Math.max(1, result.data?.summary.totalFiles || 1) / 1024)}KB`,
-      ),
+        `   Memory per file: ${Math.round(memoryMetrics.average.heapUsed / Math.max(1, result.data?.summary.totalFiles || 1) / 1024)}KB`
+      )
     );
 
     // Leak analysis
     if (memoryMetrics.leakAnalysis.leakDetected) {
       console.log(chalk.red('\n⚠️  Memory Leak Detected:'));
       console.log(
-        chalk.gray(`   Severity: ${memoryMetrics.leakAnalysis.severity}`),
+        chalk.gray(`   Severity: ${memoryMetrics.leakAnalysis.severity}`)
       );
       console.log(
         chalk.gray(
-          `   Growth rate: ${Math.round(memoryMetrics.leakAnalysis.growthRate / 1024)}KB/s`,
-        ),
+          `   Growth rate: ${Math.round(memoryMetrics.leakAnalysis.growthRate / 1024)}KB/s`
+        )
       );
     }
 
@@ -737,18 +770,18 @@ async function runOptimizedAnalysis(
         console.log(chalk.cyan('⚡ Benchmark Results:'));
         console.log(
           chalk.gray(
-            `   Speedup: ${mainResult.results.improvement.speedup.toFixed(1)}x`,
-          ),
+            `   Speedup: ${mainResult.results.improvement.speedup.toFixed(1)}x`
+          )
         );
         console.log(
           chalk.gray(
-            `   Memory reduction: ${mainResult.results.improvement.memoryReduction.toFixed(1)}%`,
-          ),
+            `   Memory reduction: ${mainResult.results.improvement.memoryReduction.toFixed(1)}%`
+          )
         );
         console.log(
           chalk.gray(
-            `   Throughput increase: ${mainResult.results.improvement.throughputIncrease.toFixed(1)}%`,
-          ),
+            `   Throughput increase: ${mainResult.results.improvement.throughputIncrease.toFixed(1)}%`
+          )
         );
       }
 
@@ -760,7 +793,7 @@ async function runOptimizedAnalysis(
     spinner.fail('Analysis failed');
     console.error(
       chalk.red('\n❌ Error:'),
-      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error.message : String(error)
     );
 
     if (options.verbose && error instanceof Error) {
@@ -802,14 +835,14 @@ function parseMemoryLimit(memoryStr: string): number {
  */
 function formatDuration(ms: number): string {
   if (ms < 1000) {
-return `${ms}ms`;
-}
+    return `${ms}ms`;
+  }
   if (ms < 60000) {
-return `${(ms / 1000).toFixed(1)}s`;
-}
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
   if (ms < 3600000) {
-return `${(ms / 60000).toFixed(1)}m`;
-}
+    return `${(ms / 60000).toFixed(1)}m`;
+  }
   return `${(ms / 3600000).toFixed(1)}h`;
 }
 
@@ -834,12 +867,12 @@ function formatFileSize(bytes: number): string {
  */
 function calculateMemoryEfficiency(
   fileCount: number,
-  memoryUsed: number,
+  memoryUsed: number
 ): number {
   const expectedMemory = fileCount * 50 * 1024; // 50KB per file baseline
   const efficiency = Math.max(
     0,
-    100 - ((memoryUsed - expectedMemory) / expectedMemory) * 100,
+    100 - ((memoryUsed - expectedMemory) / expectedMemory) * 100
   );
   return Math.min(100, efficiency);
 }
@@ -851,12 +884,12 @@ export function createBenchmarkCommand(): Command {
   const command = new Command('benchmark')
     .alias('bench')
     .description(
-      'Run performance benchmarks for memory and concurrency optimizations',
+      'Run performance benchmarks for memory and concurrency optimizations'
     )
     .option(
       '-o, --output <path>',
       'Output directory for benchmark results',
-      './benchmark-results',
+      './benchmark-results'
     )
     .option('--iterations <count>', 'Number of benchmark iterations', '3')
     .option('--memory-limit <size>', 'Memory limit for testing', '500MB')
@@ -905,41 +938,41 @@ async function runBenchmarks(options: any): Promise<void> {
     const avgSpeedup =
       results.reduce(
         (sum: any, r: any) => sum + r.results.improvement.speedup,
-        0,
+        0
       ) / results.length;
     const avgMemoryReduction =
       results.reduce(
         (sum: any, r: any) => sum + r.results.improvement.memoryReduction,
-        0,
+        0
       ) / results.length;
     const avgThroughputIncrease =
       results.reduce(
         (sum: any, r: any) => sum + r.results.improvement.throughputIncrease,
-        0,
+        0
       ) / results.length;
 
     console.log(chalk.cyan(`🚀 Average Speedup: ${avgSpeedup.toFixed(1)}x`));
     console.log(
       chalk.cyan(
-        `💾 Average Memory Reduction: ${avgMemoryReduction.toFixed(1)}%`,
-      ),
+        `💾 Average Memory Reduction: ${avgMemoryReduction.toFixed(1)}%`
+      )
     );
     console.log(
       chalk.cyan(
-        `📊 Average Throughput Increase: ${avgThroughputIncrease.toFixed(1)}%`,
-      ),
+        `📊 Average Throughput Increase: ${avgThroughputIncrease.toFixed(1)}%`
+      )
     );
 
     console.log(
       chalk.green(
-        `\n📁 Results saved to: ${options.output || './benchmark-results'}\n`,
-      ),
+        `\n📁 Results saved to: ${options.output || './benchmark-results'}\n`
+      )
     );
   } catch (error) {
     spinner.fail('Benchmarks failed');
     console.error(
       chalk.red('\n❌ Error:'),
-      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error.message : String(error)
     );
     process.exit(1);
   }

package/src/commands/analyze.ts

@@ -17,7 +17,7 @@ export class AnalyzeCommands {
   constructor(
     private program: Command,
     private _configManager: ConfigManager,
-    private _pluginManager: PluginManager,
+    private _pluginManager: PluginManager
   ) {
     this.registerCommands();
   }
@@ -39,7 +39,7 @@ export class AnalyzeCommands {
       .option(
         '--format <format>',
         'output format (json, table, graph)',
-        'table',
+        'table'
       )
       .action(async options => {
         await this.analyzeDependencies(options);
@@ -150,7 +150,7 @@ export class AnalyzeCommands {
         'WUNDR_ANALYZE_DEPS_FAILED',
         'Failed to analyze dependencies',
         { options },
-        true,
+        true
       );
     }
   }
@@ -200,7 +200,7 @@ export class AnalyzeCommands {
         'WUNDR_ANALYZE_QUALITY_FAILED',
         'Failed to analyze code quality',
         { options },
-        true,
+        true
       );
     }
   }
@@ -245,7 +245,7 @@ export class AnalyzeCommands {
         'WUNDR_ANALYZE_PERF_FAILED',
         'Failed to analyze performance',
         { options },
-        true,
+        true
       );
     }
   }
@@ -289,7 +289,7 @@ export class AnalyzeCommands {
         'WUNDR_ANALYZE_ARCH_FAILED',
         'Failed to analyze architecture',
         { options },
-        true,
+        true
       );
     }
   }
@@ -331,7 +331,7 @@ export class AnalyzeCommands {
         'WUNDR_ANALYZE_ALL_FAILED',
         'Failed to run comprehensive analysis',
         { options },
-        true,
+        true
       );
     }
   }
@@ -365,7 +365,7 @@ export class AnalyzeCommands {
         'WUNDR_SCAN_FAILED',
         'Failed to scan for issues',
         { scanPath, options },
-        true,
+        true
       );
     }
   }
@@ -485,7 +485,7 @@ export class AnalyzeCommands {
 
   private async performDirectoryScan(
     scanPath: string,
-    options: any,
+    options: any
   ): Promise<Finding[]> {
     // Implementation for directory scanning
     return [];
@@ -510,7 +510,7 @@ export class AnalyzeCommands {
    */
   private async outputResults(
     results: AnalysisResult,
-    format: string,
+    format: string
   ): Promise<void> {
     switch (format) {
       case 'json':
@@ -537,7 +537,7 @@ export class AnalyzeCommands {
           Line: f.line || 'N/A',
           Description: f.description,
           Fixable: f.fixable ? '✓' : '✗',
-        })),
+        }))
       );
     }
 
@@ -550,7 +550,7 @@ export class AnalyzeCommands {
       console.log(chalk.green('\nRecommendations:'));
       results.recommendations.forEach((rec, i) => {
         console.log(
-          `${i + 1}. ${rec.title} (${rec.impact} impact, ${rec.effort} effort)`,
+          `${i + 1}. ${rec.title} (${rec.impact} impact, ${rec.effort} effort)`
         );
       });
     }
@@ -562,7 +562,7 @@ export class AnalyzeCommands {
   }
 
   private async generateComprehensiveReport(
-    results: AnalysisResult[],
+    results: AnalysisResult[]
   ): Promise<void> {
     // Implementation for comprehensive report generation
     logger.info('Generating comprehensive report...');
@@ -570,7 +570,7 @@ export class AnalyzeCommands {
 
   private async exportResults(
     results: AnalysisResult[],
-    exportPath: string,
+    exportPath: string
   ): Promise<void> {
     await fs.writeJson(exportPath, results, { spaces: 2 });
     logger.success(`Results exported to ${exportPath}`);