codeflow-hook 1.4.0 → 2.1.0

package/bin/codeflow-hook.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Command } from 'commander';
 import chalk from 'chalk';
@@ -8,11 +8,10 @@ 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 '../services/cli-integration/src/index.js';
+import { indexProject, analyzeDiff } from '../lib/cli-integration/dist/index.js';
 
 // Export for use in agents module
 export { callAIProvider };
@@ -344,6 +343,92 @@ program
     }
   });
 
+// 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);
+        }
+      }
+
+      // Apply customizations
+      if (options.mode) {
+        pipelineConfig.settings.mode = options.mode.toUpperCase();
+      }
+
+      if (options.commitMessage) {
+        pipelineConfig.environment = {
+          ...pipelineConfig.environment,
+          COMMIT_MESSAGE: options.commitMessage
+        };
+      }
+
+      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);
+      }
+
+      // 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(`❌ Simulation failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 // Show status
 program
   .command('status')
@@ -763,5 +848,100 @@ function displayEKGAnalysisResults(analysis) {
   }
 }
 
+// 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;