@wundr.io/cli 1.0.1 → 1.0.3

package/src/commands/init.ts

@@ -1,12 +1,16 @@
-import { Command } from 'commander';
-import inquirer from 'inquirer';
-import fs from 'fs-extra';
 import path from 'path';
+
 import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { PluginManager } from '../plugins/plugin-manager';
-import { logger } from '../utils/logger';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+
+import { initProjectRag, type RagInitOptions } from '@wundr.io/core';
 import { errorHandler } from '../utils/error-handler';
+import { logger } from '../utils/logger';
+
+import type { PluginManager } from '../plugins/plugin-manager';
+import type { ConfigManager } from '../utils/config-manager';
+import type { Command } from 'commander';
 
 /**
  * Init commands for project setup and configuration
@@ -15,7 +19,7 @@ export class InitCommands {
   constructor(
     private program: Command,
     private configManager: ConfigManager,
-    private pluginManager: PluginManager
+    private pluginManager: PluginManager,
   ) {
     this.registerCommands();
   }
@@ -33,10 +37,22 @@ export class InitCommands {
       .option('--skip-git', 'skip git initialization')
       .option('--skip-install', 'skip dependency installation')
       .option('--monorepo', 'initialize as monorepo')
+      .option('--with-rag', 'initialize RAG (Retrieval-Augmented Generation) support')
       .action(async (name, options) => {
         await this.initProject(name, options);
       });
 
+    // Initialize RAG for existing project
+    initCmd
+      .command('rag')
+      .description('initialize RAG support for an existing project')
+      .option('--force', 'force re-initialization even if config exists')
+      .option('--skip-indexing', 'skip initial file indexing')
+      .option('--project-name <name>', 'override project name')
+      .action(async options => {
+        await this.initRag(options);
+      });
+
     // Initialize configuration
     initCmd
       .command('config')
@@ -107,16 +123,90 @@ export class InitCommands {
         await this.installDependencies(projectPath);
       }
 
+      // Initialize RAG if --with-rag flag is provided
+      if (options.withRag) {
+        logger.info('Initializing RAG support...');
+        const ragResult = await initProjectRag(projectPath, {
+          projectName,
+        });
+
+        if (ragResult.success) {
+          logger.success(
+            `RAG initialized: ${ragResult.filesIndexed} files indexed`,
+          );
+          logger.info(
+            `  Framework detected: ${chalk.cyan(ragResult.framework.name)}`,
+          );
+        } else {
+          logger.warn('RAG initialization had issues:');
+          for (const error of ragResult.errors) {
+            logger.warn(`  - ${error}`);
+          }
+        }
+
+        for (const warning of ragResult.warnings) {
+          logger.warn(`  Warning: ${warning}`);
+        }
+      }
+
       logger.success(`Project ${projectName} initialized successfully!`);
-      logger.info(`Next steps:`);
+      logger.info('Next steps:');
       logger.info(`  cd ${projectName}`);
-      logger.info(`  wundr analyze`);
+      logger.info('  wundr analyze');
     } catch (error) {
       throw errorHandler.createError(
         'WUNDR_INIT_PROJECT_FAILED',
         'Failed to initialize project',
         { name, options },
-        true
+        true,
+      );
+    }
+  }
+
+  /**
+   * Initialize RAG support for existing project
+   */
+  private async initRag(options: {
+    force?: boolean;
+    skipIndexing?: boolean;
+    projectName?: string;
+  }): Promise<void> {
+    try {
+      const projectPath = process.cwd();
+      logger.info(`Initializing RAG support in: ${chalk.cyan(projectPath)}`);
+
+      const ragOptions: RagInitOptions = {
+        force: options.force,
+        skipIndexing: options.skipIndexing,
+        projectName: options.projectName,
+      };
+
+      const result = await initProjectRag(projectPath, ragOptions);
+
+      if (result.success) {
+        logger.success('RAG initialization complete!');
+        logger.info(`  Config: ${chalk.cyan(result.configPath)}`);
+        logger.info(`  Exclusions: ${chalk.cyan(result.excludePath)}`);
+        logger.info(`  Files indexed: ${chalk.cyan(result.filesIndexed)}`);
+        logger.info(
+          `  Framework: ${chalk.cyan(result.framework.name)} (${result.framework.projectType})`,
+        );
+      } else {
+        logger.error('RAG initialization failed:');
+        for (const error of result.errors) {
+          logger.error(`  - ${error}`);
+        }
+      }
+
+      for (const warning of result.warnings) {
+        logger.warn(`  Warning: ${warning}`);
+      }
+    } catch (error) {
+      throw errorHandler.createError(
+        'WUNDR_INIT_RAG_FAILED',
+        'Failed to initialize RAG',
+        { options },
+        true,
       );
     }
   }
@@ -144,7 +234,7 @@ export class InitCommands {
         'WUNDR_INIT_CONFIG_FAILED',
         'Failed to initialize configuration',
         { options },
-        true
+        true,
       );
     }
   }
@@ -179,7 +269,7 @@ export class InitCommands {
       // Create workspace-specific wundr config
       await this.configManager.loadConfig();
       await this.configManager.saveConfig(
-        path.join(process.cwd(), 'wundr.config.json')
+        path.join(process.cwd(), 'wundr.config.json'),
       );
 
       logger.success('Workspace initialized successfully!');
@@ -188,7 +278,7 @@ export class InitCommands {
         'WUNDR_INIT_WORKSPACE_FAILED',
         'Failed to initialize workspace',
         { options },
-        true
+        true,
       );
     }
   }
@@ -215,7 +305,7 @@ export class InitCommands {
         'WUNDR_INIT_PLUGINS_FAILED',
         'Failed to initialize plugins',
         { options },
-        true
+        true,
       );
     }
   }
@@ -225,7 +315,7 @@ export class InitCommands {
    */
   private async createProjectStructure(
     projectPath: string,
-    options: any
+    options: any,
   ): Promise<void> {
     await fs.ensureDir(projectPath);
 
@@ -242,7 +332,7 @@ export class InitCommands {
     // Create project-specific config
     const config = await this.configManager.loadConfig();
     await this.configManager.saveConfig(
-      path.join(projectPath, 'wundr.config.json')
+      path.join(projectPath, 'wundr.config.json'),
     );
   }
 
@@ -251,7 +341,7 @@ export class InitCommands {
    */
   private async createDefaultStructure(
     projectPath: string,
-    options: any
+    options: any,
   ): Promise<void> {
     const directories = options.monorepo
       ? ['packages', 'apps', 'tools', 'docs', 'scripts', '.claude-flow']
@@ -554,11 +644,11 @@ fi
 
     await fs.writeFile(
       path.join(projectPath, 'scripts', 'verify-claims.sh'),
-      verifyScript
+      verifyScript,
     );
     await fs.chmod(
       path.join(projectPath, 'scripts', 'verify-claims.sh'),
-      '755'
+      '755',
     );
 
     // Create FAILURES.md
@@ -588,7 +678,7 @@ _(None yet - will be populated when failures are resolved)_
 
     await fs.writeFile(
       path.join(projectPath, 'docs', 'FAILURES.md'),
-      failuresMd
+      failuresMd,
     );
 
     // Create verification hooks
@@ -628,7 +718,7 @@ _(None yet - will be populated when failures are resolved)_
     await fs.writeJson(
       path.join(projectPath, '.claude-flow', 'verification-hooks.json'),
       verificationHooks,
-      { spaces: 2 }
+      { spaces: 2 },
     );
 
     // Create agent verification protocol
@@ -669,7 +759,7 @@ Remember: It's better to report a failure honestly than to claim false success.
 
     await fs.writeFile(
       path.join(projectPath, 'docs', 'AGENT_VERIFICATION_PROTOCOL.md'),
-      agentProtocol
+      agentProtocol,
     );
 
     logger.debug('Verification files created');

package/src/commands/performance-optimizer.ts

@@ -3,17 +3,21 @@
  * Implements intelligent optimization strategies for Wundr platform performance
  */
 
-import { Command } from 'commander';
-import fs from 'fs-extra';
-import path from 'path';
-import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { logger } from '../utils/logger';
-import { errorHandler } from '../utils/error-handler';
 import { spawn } from 'child_process';
+import path from 'path';
 import { performance } from 'perf_hooks';
 import { memoryUsage, cpuUsage } from 'process';
 
+import chalk from 'chalk';
+import fs from 'fs-extra';
+
+import { errorHandler } from '../utils/error-handler';
+import { logger } from '../utils/logger';
+
+import type { ConfigManager } from '../utils/config-manager';
+import type { Command } from 'commander';
+
+
 interface OptimizationResult {
   category: 'memory' | 'concurrency' | 'cpu' | 'io' | 'network';
   description: string;
@@ -133,7 +137,7 @@ class MemoryOptimizer {
   }
 
   async optimizeMemoryUsage(
-    optimizations: OptimizationResult[]
+    optimizations: OptimizationResult[],
   ): Promise<void> {
     for (const opt of optimizations.filter(o => o.automated && !o.applied)) {
       logger.info(`Applying memory optimization: ${opt.description}`);
@@ -152,7 +156,7 @@ class MemoryOptimizer {
   }
 
   private async applyMemoryOptimization(
-    opt: OptimizationResult
+    opt: OptimizationResult,
   ): Promise<void> {
     // Force garbage collection if available
     if (
@@ -171,7 +175,7 @@ class MemoryOptimizer {
     ) {
       // 1GB
       logger.warn(
-        'Consider increasing Node.js heap size with --max-old-space-size'
+        'Consider increasing Node.js heap size with --max-old-space-size',
       );
     }
   }
@@ -247,7 +251,7 @@ class ConcurrencyOptimizer {
   }
 
   async optimizeConcurrency(
-    optimizations: OptimizationResult[]
+    optimizations: OptimizationResult[],
   ): Promise<void> {
     for (const opt of optimizations.filter(o => o.automated && !o.applied)) {
       logger.info(`Applying concurrency optimization: ${opt.description}`);
@@ -262,16 +266,16 @@ class ConcurrencyOptimizer {
   }
 
   private async applyConcurrencyOptimization(
-    opt: OptimizationResult
+    opt: OptimizationResult,
   ): Promise<void> {
     if (opt.metrics?.['utilization'] && opt.metrics['utilization'] < 0.7) {
       // Increase worker thread pool for better CPU utilization
       const newWorkerCount = Math.min(
         this.workerThreads,
-        Math.floor(this.workerThreads * 1.2)
+        Math.floor(this.workerThreads * 1.2),
       );
       logger.info(
-        `Increasing worker threads from ${this.activeWorkers} to ${newWorkerCount}`
+        `Increasing worker threads from ${this.activeWorkers} to ${newWorkerCount}`,
       );
       // Implementation would update the actual worker pool
     }
@@ -355,7 +359,7 @@ export class PerformanceOptimizerCommands {
 
   constructor(
     private program: Command,
-    private configManager: ConfigManager
+    private configManager: ConfigManager,
   ) {
     this.registerCommands();
   }
@@ -403,7 +407,7 @@ export class PerformanceOptimizerCommands {
       .description('run all optimization analyses and apply safe optimizations')
       .option(
         '--dry-run',
-        'show what would be optimized without applying changes'
+        'show what would be optimized without applying changes',
       )
       .option('--report <path>', 'generate comprehensive optimization report')
       .action(async options => {
@@ -443,7 +447,7 @@ export class PerformanceOptimizerCommands {
       }
 
       logger.info(
-        `Found ${optimizations.length} memory optimization opportunities:`
+        `Found ${optimizations.length} memory optimization opportunities:`,
       );
       optimizations.forEach(opt => {
         const impactColor =
@@ -453,7 +457,7 @@ export class PerformanceOptimizerCommands {
               ? 'yellow'
               : 'green';
         console.log(
-          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`
+          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`,
         );
       });
 
@@ -468,7 +472,7 @@ export class PerformanceOptimizerCommands {
         await this.generateOptimizationReport(
           optimizations,
           options.report,
-          'memory'
+          'memory',
         );
       }
     } catch (error) {
@@ -476,7 +480,7 @@ export class PerformanceOptimizerCommands {
         'WUNDR_MEMORY_OPTIMIZATION_FAILED',
         'Failed to optimize memory usage',
         { options },
-        true
+        true,
       );
     }
   }
@@ -487,7 +491,7 @@ export class PerformanceOptimizerCommands {
 
       if (options.workers) {
         this.concurrencyOptimizer.updateActiveWorkers(
-          parseInt(options.workers)
+          parseInt(options.workers),
         );
       }
 
@@ -500,7 +504,7 @@ export class PerformanceOptimizerCommands {
       }
 
       logger.info(
-        `Found ${optimizations.length} concurrency optimization opportunities:`
+        `Found ${optimizations.length} concurrency optimization opportunities:`,
       );
       optimizations.forEach(opt => {
         const impactColor =
@@ -510,7 +514,7 @@ export class PerformanceOptimizerCommands {
               ? 'yellow'
               : 'green';
         console.log(
-          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`
+          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`,
         );
       });
 
@@ -525,7 +529,7 @@ export class PerformanceOptimizerCommands {
         'WUNDR_CONCURRENCY_OPTIMIZATION_FAILED',
         'Failed to optimize concurrency',
         { options },
-        true
+        true,
       );
     }
   }
@@ -544,7 +548,7 @@ export class PerformanceOptimizerCommands {
       }
 
       logger.info(
-        `Found ${optimizations.length} bundle optimization opportunities:`
+        `Found ${optimizations.length} bundle optimization opportunities:`,
       );
       optimizations.forEach(opt => {
         const impactColor =
@@ -554,7 +558,7 @@ export class PerformanceOptimizerCommands {
               ? 'yellow'
               : 'green';
         console.log(
-          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`
+          `  ${chalk[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`,
         );
         opt.recommendations.forEach(rec => console.log(`    • ${rec}`));
       });
@@ -563,7 +567,7 @@ export class PerformanceOptimizerCommands {
         'WUNDR_BUNDLE_OPTIMIZATION_FAILED',
         'Failed to optimize bundle',
         { options },
-        true
+        true,
       );
     }
   }
@@ -579,7 +583,7 @@ export class PerformanceOptimizerCommands {
       const concurrencyOpts =
         await this.concurrencyOptimizer.analyzeConcurrency();
       const bundleOpts = await this.assetOptimizer.analyzeBundleSize(
-        process.cwd()
+        process.cwd(),
       );
 
       allOptimizations.push(...memoryOpts, ...concurrencyOpts, ...bundleOpts);
@@ -593,18 +597,20 @@ export class PerformanceOptimizerCommands {
       const grouped = allOptimizations.reduce(
         (acc, opt) => {
           if (opt && opt.category) {
-            if (!acc[opt.category]) acc[opt.category] = [];
+            if (!acc[opt.category]) {
+acc[opt.category] = [];
+}
             acc[opt.category]!.push(opt);
           }
           return acc;
         },
-        {} as Record<string, OptimizationResult[]>
+        {} as Record<string, OptimizationResult[]>,
       );
 
-      logger.info(`\n📊 Optimization Summary:`);
+      logger.info('\n📊 Optimization Summary:');
       Object.entries(grouped).forEach(([category, opts]) => {
         console.log(
-          `  ${chalk.bold(category.toUpperCase())}: ${opts.length} opportunities`
+          `  ${chalk.bold(category.toUpperCase())}: ${opts.length} opportunities`,
         );
       });
 
@@ -613,7 +619,7 @@ export class PerformanceOptimizerCommands {
         const automated = allOptimizations.filter(o => o.automated);
         if (automated.length > 0) {
           logger.info(
-            `\n🔧 Applying ${automated.length} automated optimizations...`
+            `\n🔧 Applying ${automated.length} automated optimizations...`,
           );
 
           for (const opt of automated) {
@@ -635,7 +641,7 @@ export class PerformanceOptimizerCommands {
         const manual = allOptimizations.filter(o => !o.automated).length;
         if (manual > 0) {
           logger.info(
-            `ℹ️  ${manual} optimizations require manual intervention`
+            `ℹ️  ${manual} optimizations require manual intervention`,
           );
         }
       }
@@ -644,7 +650,7 @@ export class PerformanceOptimizerCommands {
         await this.generateOptimizationReport(
           allOptimizations,
           options.report,
-          'comprehensive'
+          'comprehensive',
         );
       }
     } catch (error) {
@@ -652,7 +658,7 @@ export class PerformanceOptimizerCommands {
         'WUNDR_COMPREHENSIVE_OPTIMIZATION_FAILED',
         'Failed to run comprehensive optimization',
         { options },
-        true
+        true,
       );
     }
   }
@@ -663,7 +669,7 @@ export class PerformanceOptimizerCommands {
     const startTime = Date.now();
 
     logger.info(
-      `🔍 Starting performance monitoring for ${options.duration} seconds...`
+      `🔍 Starting performance monitoring for ${options.duration} seconds...`,
     );
 
     const metrics: SystemMetrics[] = [];
@@ -700,7 +706,7 @@ export class PerformanceOptimizerCommands {
       const heapMB = (memory.heapUsed / 1024 / 1024).toFixed(2);
       const rssMB = (memory.rss / 1024 / 1024).toFixed(2);
       process.stdout.write(
-        `\r💾 Heap: ${heapMB}MB | RSS: ${rssMB}MB | CPU: ${cpu.user}μs`
+        `\r💾 Heap: ${heapMB}MB | RSS: ${rssMB}MB | CPU: ${cpu.user}μs`,
       );
     }, interval);
 
@@ -716,7 +722,7 @@ export class PerformanceOptimizerCommands {
       const peakHeap = Math.max(...metrics.map(m => m.memory.heapUsed));
       const peakRSS = Math.max(...metrics.map(m => m.memory.rss));
 
-      console.log(`\nMemory Statistics:`);
+      console.log('\nMemory Statistics:');
       console.log(`  Average Heap: ${(avgHeap / 1024 / 1024).toFixed(2)} MB`);
       console.log(`  Average RSS:  ${(avgRSS / 1024 / 1024).toFixed(2)} MB`);
       console.log(`  Peak Heap:    ${(peakHeap / 1024 / 1024).toFixed(2)} MB`);
@@ -786,7 +792,7 @@ export class PerformanceOptimizerCommands {
         'WUNDR_BENCHMARK_FAILED',
         'Failed to run performance benchmarks',
         { options },
-        true
+        true,
       );
     }
   }
@@ -813,7 +819,7 @@ export class PerformanceOptimizerCommands {
     // Simulate concurrent task processing
     const tasks = Array.from(
       { length: 100 },
-      (_, i) => new Promise(resolve => setTimeout(resolve, Math.random() * 10))
+      (_, i) => new Promise(resolve => setTimeout(resolve, Math.random() * 10)),
     );
     await Promise.all(tasks);
   }
@@ -833,7 +839,7 @@ export class PerformanceOptimizerCommands {
   private async generateOptimizationReport(
     optimizations: OptimizationResult[],
     reportPath: string,
-    type: string
+    type: string,
   ): Promise<void> {
     const report = {
       timestamp: new Date().toISOString(),