codeflow-hook 1.3.0 → 2.0.0

package/bin/codeflow-hook.js

@@ -8,9 +8,11 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os'; // Make sure os is imported
 import readline from 'readline';
-import { indexProject } from './rag.js';
 import { orchestrateReview } from './agents.js';
 
+// Import CLI integration service
+import { indexProject, analyzeDiff } from '../lib/cli-integration/dist/index.js';
+
 // Export for use in agents module
 export { callAIProvider };
 
@@ -18,8 +20,8 @@ const program = new Command();
 
 program
   .name('codeflow-hook')
-  .description('Interactive CI/CD simulator and AI-powered code reviewer')
-  .version('1.0.0');
+  .description('Interactive CI/CD simulator and AI-powered code reviewer with EKG backend integration')
+  .version('4.0.0');
 
 // Configure AI provider settings
 program
@@ -199,41 +201,34 @@ program
     }
   });
 
-// Index project knowledge base for RAG
+// Index repository via EKG Ingestion Service (Phase 4)
 program
   .command('index')
-  .description('Index project files for Retrieval-Augmented Generation (RAG)')
-  .option('-d, --dry-run', 'Show what files would be indexed without actually indexing')
+  .description('Index repository via EKG Ingestion Service')
+  .option('-d, --dry-run', 'Show what would be indexed without actually indexing')
   .action(async (options) => {
     try {
-      const configPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
+      const spinner = ora('Submitting repository for EKG analysis...').start();
 
-      if (!fs.existsSync(configPath)) {
-        console.log(chalk.red('No configuration found. Run: codeflow-hook config -k <api-key>'));
-        process.exit(1);
-      }
+      const result = await indexProject({
+        dryRun: options.dryRun || false
+      });
 
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      const spinner = ora('Indexing project knowledge base...').start();
+      spinner.succeed('Repository indexing initiated');
+      console.log(chalk.green(`✅ ${result.message}`));
 
-      if (options.dryRun) {
-        spinner.stop();
-        console.log(chalk.blue('🔍 Dry run mode - files to be indexed:'));
-        const { findKeyFiles } = await import('./rag.js');
-        const keyFiles = await findKeyFiles(process.cwd());
-        keyFiles.forEach(file => console.log(chalk.gray(`  - ${file}`)));
-        console.log(chalk.green(`📊 Total files to index: ${keyFiles.length}`));
-        return;
+      if (result.repositoryId) {
+        console.log(chalk.blue(`📋 Repository ID: ${result.repositoryId}`));
       }
 
-      const result = await indexProject(config);
+      if (result.stats) {
+        console.log(chalk.gray(`📊 Stats: ${JSON.stringify(result.stats, null, 2)}`));
+      }
 
-      spinner.succeed('Knowledge base indexing complete');
-      console.log(chalk.green(`✅ Indexed ${result.indexedFiles} files with ${result.totalChunks} chunks`));
-      console.log(chalk.blue('📁 Knowledge base stored in: .codeflow/index/'));
+      console.log(chalk.cyan('🔗 Repository submitted to EKG Ingestion Service for analysis'));
 
     } catch (error) {
-      console.error(chalk.red(`❌ Indexing failed: ${error.message}`));
+      console.log(chalk.red(`❌ Indexing failed: ${error.message}`));
       process.exit(1);
     }
   });
@@ -298,13 +293,12 @@ exit 0
     }
   });
 
-// Analyze diff with specialized AI agents
+// Analyze diff with EKG Query Service context enhancement (Phase 4)
 program
   .command('analyze-diff')
-  .description('Analyze git diff using specialized AI agents (RAG-enhanced)')
+  .description('Analyze git diff using EKG context enhancement')
   .argument('[diff]', 'Git diff content')
-  .option('--legacy', 'Use legacy monolithic analysis instead of agentic workflow')
-  .option('--no-rag', 'Disable RAG context retrieval')
+  .option('--legacy', 'Use legacy analysis instead of EKG-enhanced analysis')
   .action(async (diff, options) => {
     try {
       // Read diff content from stdin or argument
@@ -317,63 +311,120 @@ program
         diffContent = Buffer.concat(chunks).toString('utf8');
       }
 
-      const configPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
-
-      if (!fs.existsSync(configPath)) {
-        console.log(chalk.red('No configuration found. Run: codeflow-hook config -k <api-key>'));
-        process.exit(1);
-      }
-
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-
       if (diffContent.trim() === '') {
         console.log(chalk.gray('ℹ️  No changes to analyze'));
         return;
       }
 
-      // Legacy mode: use original monolithic analysis
-      if (options.legacy) {
-        const spinner = ora(`Analyzing code with ${config.provider}...`).start();
-        const prompt = generateCodeReviewPrompt(diffContent);
+      console.log(chalk.blue('🔬 Analyzing diff with EKG context enhancement...'));
 
-        let result;
-        try {
-          result = await callAIProvider(config, prompt);
-        } catch (error) {
-          spinner.fail('Analysis failed');
-          console.error(chalk.red(`AI API Error: ${error.message}`));
+      const result = await analyzeDiff(diffContent, {
+        legacy: options.legacy || false,
+        outputFormat: 'console'
+      });
+
+      if (result.success) {
+        console.log(chalk.green(`✅ ${result.message}`));
+        displayEKGAnalysisResults(result.analysis);
+
+        if (result.stats) {
+          console.log(chalk.gray(`📊 EKG Queries: ${result.stats.ekg_queries}`));
+          console.log(chalk.gray(`👥 Similar Repos Found: ${result.stats.similar_repos_found}`));
+          console.log(chalk.gray(`⏱️  Analysis Time: ${result.stats.analysis_time}ms`));
+        }
+      } else {
+        console.log(chalk.red(`❌ Analysis failed: ${result.message}`));
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.log(chalk.red(`❌ Analysis error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Run pipeline simulation (Enhanced Frontend Integration)
+program
+  .command('simulate')
+  .description('Run configurable CI/CD pipeline simulation')
+  .argument('[template]', 'Pipeline template ID (nodejs-basic, enterprise-advanced, fast-dev, chaotic-test, microservices-parallel)')
+  .option('-c, --config <file>', 'Custom pipeline configuration JSON file')
+  .option('-o, --output <file>', 'Output results to JSON file')
+  .option('-m, --mode <mode>', 'Simulation mode (REALISTIC, FAST, DETERMINISTIC, CHAOTIC)', 'REALISTIC')
+  .option('--commit-message <message>', 'Custom commit message for simulation')
+  .option('--json', 'Output results as JSON only')
+  .action(async (template, options) => {
+    try {
+      let pipelineConfig;
+
+      // Load configuration from file or template
+      if (options.config) {
+        console.log(chalk.blue(`📄 Loading pipeline config from: ${options.config}`));
+        const fs = await import('fs/promises');
+        const configData = await fs.readFile(options.config, 'utf8');
+        pipelineConfig = JSON.parse(configData);
+      } else {
+        const templateId = template || 'nodejs-basic';
+        console.log(chalk.blue(`🎯 Using pipeline template: ${templateId}`));
+
+        // Import simulation engine and config manager dynamically
+        const { PipelineConfigManager } = await import('../lib/cli-integration/dist/pipelineConfigs.js');
+        pipelineConfig = PipelineConfigManager.getPipelineById(templateId);
+
+        if (!pipelineConfig) {
+          console.log(chalk.red(`❌ Unknown pipeline template: ${templateId}`));
+          console.log(chalk.gray('Available templates:'));
+          const templates = PipelineConfigManager.getAvailableTemplates();
+          templates.forEach(t => {
+            console.log(chalk.gray(`  • ${t.id}: ${t.description}`));
+          });
           process.exit(1);
         }
+      }
 
-        spinner.succeed('Analysis complete');
-        displayAnalysisResults(result);
-        return;
+      // Apply customizations
+      if (options.mode) {
+        pipelineConfig.settings.mode = options.mode.toUpperCase();
       }
 
-      // Agentic workflow mode
-      const spinner = ora(`Running specialized code review agents...`).start();
+      if (options.commitMessage) {
+        pipelineConfig.environment = {
+          ...pipelineConfig.environment,
+          COMMIT_MESSAGE: options.commitMessage
+        };
+      }
 
-      let results;
-      try {
-        if (options.rag === false) {
-          // Force no RAG context
-          const { orchestrateReviewWithoutRAG } = await import('./agents.js');
-          results = await orchestrateReviewWithoutRAG(diffContent, config);
-        } else {
-          // Use RAG-enabled workflow
-          results = await orchestrateReview(diffContent, config);
-        }
-      } catch (error) {
-        spinner.fail('Analysis failed');
-        console.error(chalk.red(`Agent analysis failed: ${error.message}`));
-        process.exit(1);
+      console.log(chalk.blue(`🚀 Starting pipeline simulation: ${pipelineConfig.name}`));
+      console.log(chalk.gray(`   Mode: ${pipelineConfig.settings.mode}`));
+      console.log(chalk.gray(`   Stages: ${pipelineConfig.stages.length}`));
+
+      const spinner = ora('Running pipeline simulation...').start();
+
+      // Import and run simulation engine
+      const { simulationEngine } = await import('../lib/cli-integration/dist/simulationEngine.js');
+      const result = await simulationEngine.executePipeline(pipelineConfig);
+
+      spinner.succeed('Simulation completed');
+
+      // Display results
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        displaySimulationResults(result);
       }
 
-      spinner.succeed('Agentic analysis complete');
-      displayAgenticResults(results);
+      // Save to file if requested
+      if (options.output) {
+        const fs = await import('fs/promises');
+        await fs.writeFile(options.output, JSON.stringify(result, null, 2), 'utf8');
+        console.log(chalk.green(`💾 Results saved to: ${options.output}`));
+      }
+
+      // Exit with appropriate code
+      process.exit(result.status === 'success' ? 0 : 1);
 
     } catch (error) {
-      console.log(chalk.red(`Configuration error: ${error.message}`));
+      console.log(chalk.red(`❌ Simulation failed: ${error.message}`));
       process.exit(1);
     }
   });
@@ -734,5 +785,163 @@ function getTypeIcon(type) {
   }
 }
 
+// Display EKG-enhanced analysis results (Phase 4)
+function displayEKGAnalysisResults(analysis) {
+  if (!analysis) {
+    console.log(chalk.yellow('⚠️  No analysis results available'));
+    return;
+  }
+
+  // Display summary
+  if (analysis.summary) {
+    console.log(chalk.blue('📊 Analysis Summary:'));
+    console.log(`   📁 Files modified: ${analysis.summary.totalFiles}`);
+    console.log(`   ➕ Additions: ${analysis.summary.totalAdditions}`);
+    console.log(`   ➖ Deletions: ${analysis.summary.totalDeletions}`);
+    console.log(`   🧠 EKG enhanced: ${analysis.summary.ekgEnhanced ? 'Yes' : 'No'}`);
+    console.log();
+  }
+
+  // Display EKG context information
+  if (analysis.ekg_context) {
+    console.log(chalk.blue('🧠 EKG Context:'));
+    console.log(`   📚 Patterns analyzed: ${analysis.ekg_context.patterns_analyzed || 0}`);
+    console.log(`   👥 Similar repositories: ${analysis.ekg_context.similar_repositories_found || 0}`);
+    console.log(`   🔍 Repository known to EKG: ${analysis.ekg_context.repository_known ? 'Yes' : 'No'}`);
+    console.log();
+  }
+
+  // Display issues
+  if (analysis.issues && analysis.issues.length > 0) {
+    console.log(chalk.yellow('⚠️ Issues Found:'));
+    analysis.issues.forEach(issue => {
+      const severityColor = getSeverityColor(issue.severity);
+      const typeIcon = getTypeIcon(issue.type);
+      console.log(`   ${severityColor}${typeIcon} ${issue.severity}: ${issue.description}`);
+    });
+    console.log();
+  }
+
+  // Display recommendations
+  if (analysis.recommendations && analysis.recommendations.length > 0) {
+    console.log(chalk.green('💡 Recommendations:'));
+    analysis.recommendations.forEach(rec => {
+      const severityColor = getSeverityColor(rec.severity);
+      console.log(`   ${severityColor}• ${rec.description}`);
+      if (rec.file) {
+        console.log(chalk.gray(`     📁 File: ${rec.file}`));
+      }
+    });
+    console.log();
+  }
+
+  // Display file details
+  if (analysis.files && analysis.files.length > 0) {
+    console.log(chalk.blue('📂 Files Changed:'));
+    analysis.files.forEach(file => {
+      const changeType = file.isNew ? 'NEW' : 'MODIFIED';
+      const changeColor = file.isNew ? chalk.green : chalk.blue;
+      console.log(`${changeColor}   ${changeType} ${file.path} (${file.language})`);
+      console.log(chalk.gray(`      +${file.additions} -${file.deletions} changes`));
+    });
+    console.log();
+  }
+}
+
+// Display pipeline simulation results
+function displaySimulationResults(result) {
+  if (!result) {
+    console.log(chalk.yellow('⚠️  No simulation results available'));
+    return;
+  }
+
+  // Overall status
+  const statusIcon = result.status === 'success' ? '✅' :
+                    result.status === 'failed' ? '❌' :
+                    result.status === 'partial' ? '⚠️' : '⏸️';
+  const statusColor = result.status === 'success' ? chalk.green :
+                     result.status === 'failed' ? chalk.red :
+                     result.status === 'partial' ? chalk.yellow : chalk.gray;
+
+  console.log(statusColor(`${statusIcon} Pipeline ${result.status.toUpperCase()}`));
+  console.log(chalk.blue(`📋 Execution ID: ${result.executionId}`));
+  console.log(chalk.gray(`⏱️  Duration: ${(result.metrics.totalDuration / 1000).toFixed(2)}s`));
+  console.log();
+
+  // Pipeline metrics
+  console.log(chalk.blue('📊 Pipeline Metrics:'));
+  console.log(`   📊 Stages: ${result.metrics.successCount}/${result.metrics.stageCount} passed`);
+  if (result.metrics.failureCount > 0) {
+    console.log(chalk.red(`   ❌ Failed: ${result.metrics.failureCount}`));
+  }
+  if (result.metrics.skippedCount > 0) {
+    console.log(chalk.yellow(`   ⏭️  Skipped: ${result.metrics.skippedCount}`));
+  }
+  console.log(`   📈 Avg Stage Duration: ${(result.metrics.averageStageDuration / 1000).toFixed(2)}s`);
+  if (result.metrics.bottleneckStage) {
+    console.log(chalk.yellow(`   🐌 Bottleneck: ${result.metrics.bottleneckStage}`));
+  }
+  console.log();
+
+  // Resource utilization
+  console.log(chalk.blue('💻 Resource Utilization:'));
+  console.log(`   🖥️  Avg CPU: ${result.metrics.resourceUtilization.avgCpu}%`);
+  console.log(`   🧠 Avg Memory: ${result.metrics.resourceUtilization.avgMemory}MB`);
+  console.log(`   🔥 Peak CPU: ${result.metrics.resourceUtilization.peakCpu}%`);
+  console.log(`   💾 Peak Memory: ${result.metrics.resourceUtilization.peakMemory}MB`);
+  console.log();
+
+  // Stage details
+  console.log(chalk.blue('🔧 Stage Results:'));
+  result.stages.forEach(stage => {
+    const stageIcon = stage.status === 'SUCCESS' ? '✅' :
+                     stage.status === 'FAILED' ? '❌' :
+                     stage.status === 'SKIPPED' ? '⏭️' : '⏳';
+    const stageColor = stage.status === 'SUCCESS' ? chalk.green :
+                      stage.status === 'FAILED' ? chalk.red :
+                      stage.status === 'SKIPPED' ? chalk.yellow : chalk.gray;
+
+    const duration = stage.duration ? `${(stage.duration / 1000).toFixed(2)}s` : 'N/A';
+    console.log(`${stageColor(`   ${stageIcon} ${stage.id}: ${duration}`)}`);
+
+    // Show metrics if available
+    if (stage.metrics) {
+      console.log(chalk.gray(`      CPU: ${stage.metrics.cpuUsage}%, Mem: ${stage.metrics.memoryUsage}MB`));
+    }
+
+    // Show errors if any
+    if (stage.errors && stage.errors.length > 0) {
+      stage.errors.forEach(error => {
+        console.log(chalk.red(`      💥 ${error.message}`));
+      });
+    }
+  });
+  console.log();
+
+  // Artifacts
+  if (result.artifacts && result.artifacts.length > 0) {
+    console.log(chalk.blue('📦 Generated Artifacts:'));
+    result.artifacts.forEach(artifact => {
+      console.log(`   📄 ${artifact.name} (${(artifact.size / 1024 / 1024).toFixed(2)}MB)`);
+      console.log(chalk.gray(`      ${artifact.path}`));
+    });
+    console.log();
+  }
+
+  // Execution logs summary
+  if (result.logs && result.logs.length > 0) {
+    console.log(chalk.blue('📝 Execution Summary:'));
+    // Show last few log lines
+    const recentLogs = result.logs.slice(-5);
+    recentLogs.forEach(log => {
+      console.log(chalk.gray(`   ${log}`));
+    });
+    if (result.logs.length > 5) {
+      console.log(chalk.gray(`   ... and ${result.logs.length - 5} more log entries`));
+    }
+    console.log();
+  }
+}
+
 // Make sure the final line uses parseAsync
 program.parseAsync(process.argv);

package/lib/cli-integration/dist/index.d.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * CLI Integration Service - Phase 4
+ *
+ * Bridges the local CLI commands with EKG backend services.
+ * Transforms CLI operations from local processing to backend-driven workflows.
+ *
+ * Key transformations:
+ * - `codeflow index` → EKG Ingestion Service webhook simulation
+ * - `codeflow analyze-diff` → EKG Query Service context-enhanced analysis
+ */
+/**
+ * CLI Integration Service
+ * Provides methods that CLI commands can call to interact with EKG backend
+ */
+export declare class CLIIntegrationService {
+    private config;
+    private git;
+    constructor();
+    /**
+     * Index repository for EKG - equivalent to `codeflow index`
+     *
+     * Sends repository URL to EKG Ingestion Service for analysis and graph population
+     */
+    indexRepository(options?: {
+        repositoryUrl?: string;
+        dryRun?: boolean;
+    }): Promise<{
+        success: boolean;
+        repositoryId?: string;
+        message: string;
+        stats?: {
+            indexedFiles: number;
+            analysisTime: number;
+            webhookAccepted: boolean;
+        };
+    }>;
+    /**
+     * Analyze code diff with EKG context enhancement
+     *
+     * Sends diff to Query Service for EKG-enhanced analysis instead of local RAG
+     */
+    analyzeDiff(diffContent: string, options?: {
+        legacy?: boolean;
+        outputFormat?: 'console' | 'json';
+    }): Promise<{
+        success: boolean;
+        analysis: any;
+        message: string;
+        stats?: {
+            ekg_queries: number;
+            similar_repos_found: number;
+            analysis_time: number;
+        };
+    }>;
+    /**
+     * Analyze diff content and extract structured information
+     */
+    private analyzeDiffContent;
+    /**
+     * Query EKG for context on affected files
+     */
+    private getEKGContext;
+    /**
+     * Generate enhanced analysis using EKG context
+     */
+    private generateEKGEnhancedAnalysis;
+    /**
+     * Get current repository information
+     */
+    private getRepositoryInfo;
+    /**
+     * Get list of files that would be indexed
+     */
+    private getIndexableFiles;
+    /**
+     * Make HTTP request to backend service with retry logic
+     */
+    private makeBackendRequest;
+    /**
+     * Make GraphQL request to Query Service
+     */
+    private makeGraphQLRequest;
+    /**
+     * Generate repository ID (similar to ingestion service)
+     */
+    private generateRepositoryId;
+    /**
+     * Get current user information
+     */
+    private getCurrentUser;
+    /**
+     * Detect language from file extension
+     */
+    private detectLanguage;
+    /**
+     * Format error for logging and display
+     */
+    private formatError;
+}
+export declare const cliIntegrationService: CLIIntegrationService;
+export declare const indexProject: (options?: {
+    repositoryUrl?: string;
+    dryRun?: boolean;
+}) => Promise<{
+    success: boolean;
+    repositoryId?: string;
+    message: string;
+    stats?: {
+        indexedFiles: number;
+        analysisTime: number;
+        webhookAccepted: boolean;
+    };
+}>;
+export declare const analyzeDiff: (diffContent: string, options?: {
+    legacy?: boolean;
+    outputFormat?: 'console' | 'json';
+}) => Promise<{
+    success: boolean;
+    analysis: any;
+    message: string;
+    stats?: {
+        ekg_queries: number;
+        similar_repos_found: number;
+        analysis_time: number;
+    };
+}>;
+export default cliIntegrationService;