codeflow-hook 1.4.0 → 2.0.0

package/README.md

@@ -1,116 +1,48 @@
 # Codeflow Commander — Nexus Gateway CLI
 
-**The Command-Line Interface for the Autonomous Engineering Platform**
+**AI-Powered Code Analysis and Git Hook Management**
 
-Your gateway to the Codeflow Commander Nexus Gateway — a comprehensive AI-driven engineering ecosystem that spans the entire software development lifecycle. This CLI tool serves as the entry point to enterprise-wide autonomous engineering capabilities, from intelligent code analysis to organization-scale workflow automation.
+A lightweight command-line tool that provides AI-driven code analysis, automated git hook installation, and intelligent code review capabilities. This CLI client analyzes your local code changes using advanced AI models and helps maintain code quality through automated pre-commit and pre-push checks.
 
-This is the universal command-line client for interacting with the **Phase 4 Autonomous Engineering Platform**, featuring next-generation components including the Enterprise Knowledge Graph (EKG), Autonomous Agent Network (AAN), Multi-Modal Interface Layer (MMIL), and Predictive Intelligence Engine (PIE).
+**⚠️ Important**: This is the **client-side CLI tool** only. Enterprise features like the Enterprise Knowledge Graph (EKG), Autonomous Agent Network (AAN), and ingestion services are part of the broader Codeflow Commander platform and require separate enterprise deployment.
 
-## 🚀 Key Capabilities
+## 🚀 What This CLI Tool Provides
 
-### **Enterprise Knowledge Graph (EKG)**
-- **Cross-Repository Intelligence**: Unified knowledge across all organizational repositories
-- **Semantic Dependency Mapping**: Understand organizational code relationships and patterns
-- **Expert Discovery**: Identify domain experts through code analysis patterns
-- **Supply Chain Intelligence**: Vulnerability tracking and license compliance across repositories
+### **AI-Powered Code Analysis**
+- **Local Code Diff Analysis**: Analyze git diffs using Gemini, OpenAI GPT, or Claude AI models
+- **Quality Assessment**: Get 1-10 quality ratings with detailed feedback on code changes
+- **Security Detection**: Identify potential security vulnerabilities in code changes
+- **Performance Insights**: Receive suggestions for performance optimizations
 
-### **Autonomous Agent Network (AAN)**
-- **Workflow Automation**: Transform JIRA tickets into validated pull requests automatically
-- **Self-Healing Operations**: Monitor, detect, diagnose, and fix production issues autonomously
-- **Predictive Maintenance**: Scheduled optimization tasks and dependency updates
-- **Multi-Agent Coordination**: Intelligent conflict resolution and approval workflows
+### **Git Hook Automation**
+- **Pre-commit Hooks**: Automatic analysis of staged changes before commits
+- **Pre-push Hooks**: Comprehensive code review simulation before pushing to remote
+- **Quality Gates**: Prevent problematic commits and pushes based on AI analysis
+- **Customizable Thresholds**: Configure when to block commits based on quality scores
 
-### **Multi-Modal Interface Layer (MMIL)**
-- **Conversational Code Generation**: Natural language → complex refactorings and implementations
-- **Design-to-Code Pipeline**: Figma designs to validated production code
-- **IDE Ecosystem Integration**: Native support across VSCode, IntelliJ, Vim, and more
-- **API-First Architecture**: REST APIs for all platform capabilities
+### **Local Knowledge Base (RAG)**
+- **Project Context Indexing**: Build searchable knowledge base from your project files
+- **Context-Aware Analysis**: AI analysis considers your project's documentation and code patterns
+- **Offline Capability**: Works without internet for local analysis (with indexed knowledge)
+- **Incremental Updates**: Automatically update knowledge base as project evolves
 
-### **Predictive Intelligence Engine (PIE)**
-- **Tech Debt Forecasting**: Predict maintenance hotspots and cost estimates
-- **Performance Prediction**: Identify regressions before deployment
-- **Engineering Analytics**: Data-driven process optimization and insights
-- **Risk Assessment**: Proactive security and compliance monitoring
+### **Multi-Provider AI Support**
+- **Google Gemini**: Default AI provider with latest models (1.5 Pro, 1.5 Flash, Pro)
+- **OpenAI GPT**: Support for GPT-4, GPT-4 Turbo, GPT-3.5 Turbo
+- **Anthropic Claude**: Integration with Claude 3 Opus, Sonnet, and Haiku
+- **Custom Endpoints**: Connect to self-hosted or custom AI model endpoints
 
-### **Governance Safety Framework (GSF)**
-- **Autonomous Permissions**: Dynamic access control based on context and risk
-- **Real-time Compliance**: Continuous regulatory and policy validation
-- **Emergency Controls**: System-wide safety mechanisms and overrides
-- **Human-in-the-Loop**: Graduated approval workflows for different risk levels
+## 📦 How It Works
 
-### **Distributed Execution Engine (DEE)**
-- **Repository Federation**: Coordinate operations across multiple repositories
-- **Workflow Orchestration**: Complex process execution with dependency management
-- **State Synchronization**: Federated data consistency across the enterprise
-- **Resource Optimization**: Intelligent load balancing and execution management
+The CLI tool operates entirely on your local machine and analyzes your code changes using AI. Here's the workflow:
 
-## 🏗️ Architecture Overview
+1. **Local Analysis**: When you run analysis, the tool captures your git diff locally
+2. **AI Processing**: Sends the diff to your configured AI provider (Gemini/OpenAI/Claude)
+3. **Context Enhancement**: Optionally includes your project's indexed knowledge for better analysis
+4. **Feedback Generation**: Returns quality scores, issues, and recommendations
+5. **Hook Integration**: Automatically runs during git operations to maintain code quality
 
-The CLI serves as your interface to the Codeflow Commander Nexus Gateway — a distributed, autonomous engineering platform designed for enterprise-scale operation.
-
-```
-┌─────────────────────────────────────────────────────────┐
-│               MULTI-MODAL INTERFACE LAYER (MMIL)      │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Conversational  │ │ Design→Code     │ │  IDE        │ │
-│  │ Interfaces      │ │ Pipeline        │ │ Integrations│ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│         AUTONOMOUS AGENT NETWORK (AAN) - ORCHESTRATOR  │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Workflow Agents │ │ Maintenance     │ │ Self-Heal   │ │
-│  │                 │ │ Bots            │ │ Agents      │ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│      GOVERNANCE & SAFETY FRAMEWORK - RISK CONTROL      │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Permission      │ │ Audit &        │ │ Emergency    │ │
-│  │ Engine          │ │ Compliance      │ │ Controls    │ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│     ENTERPRISE KNOWLEDGE GRAPH (EKG) - INTELLIGENCE    │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Cross-Repo      │ │ Semantic        │ │ Expert      │ │
-│  │ Dependencies    │ │ Mapping         │ │ Discovery   │ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│  PREDICTIVE INTELLIGENCE ENGINE (PIE) - FORECASTING    │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Tech Debt       │ │ Performance     │ │ Risk        │ │
-│  │ Forecasting     │ │ Prediction      │ │ Analytics   │ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│      DISTRIBUTED EXECUTION ENGINE (DEE) - RUNTIME      │
-│  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
-│  │ Repository      │ │ Workflow        │ │ State       │ │
-│  │ Federation      │ │ Orchestration   │ │ Sync        │ │
-│  └─────────────────┘ └─────────────────┘ └─────────────┘ │
-└─────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-┌─────────────────────────────────────────────────────────┐
-│         EXTERNAL SYSTEMS INTEGRATION                    │
-│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐       │
-│  │GitHub│ │GitLab│ │JIRA │ │Slack│ │Jenkins│     │
-│  │Actions│ │     │ │     │ │     │ │       │     │
-│  └─────┘ └─────┘ └─────┘ └─────┘ └─────┘       │
-└─────────────────────────────────────────────────────────┘
-```
+**No data is sent to external servers** except for AI API calls to your configured provider. Your code stays on your machine.
 
 ## 📦 Installation
 
@@ -269,33 +201,117 @@ codeflow-hook analyze-diff --help # Analysis options
 - Best practice recommendations
 - Maintainability evaluation
 
-## 🔬 Enterprise Technology Stack
+## 💡 Usage Examples
+
+### Standard Development Workflow
+
+```bash
+# Stage your changes
+git add .
+
+# Pre-commit hook automatically runs AI analysis
+git commit -m "feat: add new authentication"
+
+# Pre-push hook runs tests and full AI review
+git push origin main
+```
+
+### Manual Analysis
+
+```bash
+# Analyze uncommitted changes
+git diff | codeflow-hook analyze-diff
+
+# Analyze specific files
+git diff path/to/file.js | codeflow-hook analyze-diff
+
+# Analyze between commits
+git diff HEAD~1 HEAD | codeflow-hook analyze-diff
+```
+
+## 🎯 AI Analysis Output
+
+The tool provides:
+
+- **Rating**: 1-10 quality score with color coding
+- **Summary**: Brief assessment of changes
+- **Issues**: Specific problems with solutions
+- **Recommendations**: Improvement suggestions
+
+Example output:
+```
+⭐ **Rating:** 9/10
+📝 **Summary:** Clean implementation with good separation of concerns
+
+⚠️ **Issues:**
+- Consider adding input validation for edge cases
 
-### **Multi-Modal AI Integration**
-The Nexus Gateway integrates multiple AI modalities for comprehensive engineering intelligence:
+💡 **Recommendations:**
+- Add comprehensive error handling
+- Consider extracting common logic to a utility function
+```
 
-**🤖 Conversational Interface Layer**: Natural language processing for requirement analysis and complex code generation
-**🎨 Design-to-Code Pipeline**: Computer vision and ML models for design artifact ingestion
-**📊 Predictive Analytics Engine**: Time-series analysis and machine learning for trend forecasting
-**🔍 Semantic Code Analysis**: Advanced NLP for code understanding and pattern recognition
+## 🔧 Configuration
 
-### **Autonomous Agent Architecture**
-The core platform intelligence is delivered through specialized agent networks:
+Configuration is stored in `~/.codeflow-hook/config.json`:
 
-**🎯 Workflow Execution Agents**:
-- Ticket-to-PR automation with full engineering lifecycle management
-- Self-healing operations with automated issue detection and remediation
-- Dependency management with intelligent version conflict resolution
+```json
+{
+  "provider": "gemini",
+  "apiKey": "your-api-key",
+  "apiUrl": "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent",
+  "model": "gemini-pro"
+}
+```
+
+### Supported AI Providers
 
-**🔬 Observational Intelligence Agents**:
-- Predictive maintenance scheduling based on code analysis patterns
-- Performance regression detection using historical benchmarking
-- Risk assessment with real-time compliance monitoring
+- **Gemini**: `provider: "gemini"` - Default, uses Google AI
+- **OpenAI**: `provider: "openai"` - GPT models
+- **Claude**: `provider: "claude"` - Anthropic models
+
+Each provider has optimized prompts and supports custom endpoints.
 
-**🤝 Collaborative Learning Agents**:
-- Cross-repository knowledge synthesis and pattern mining
-- Expert identification through contribution analysis
-- Team productivity optimization through workflow analysis
+## 📋 Requirements
+
+- Node.js 16+
+- Git repository
+- Gemini API key
+
+##  Security
+
+- API keys stored locally (not in your repo)
+- Have to make an .env file for the credentials
+- No data sent to third parties except Google Gemini
+- Code diffs analyzed locally before sending
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**"No configuration found"**
+```bash
+codeflow-hook config -k YOUR_API_KEY
+```
+
+**Hooks not running**
+```bash
+- **Design Pattern Compliance**: Validation against organizational architectural standards
+- **Coupling Analysis**: Detection of tight coupling and circular dependencies
+- **Layer Architecture**: Enforcement of proper separation between presentation, business logic, and data layers
+- **Complexity Assessment**: Monitoring of code complexity and maintainability metrics
+
+**⚡ Performance Agent**:
+- **Algorithm Analysis**: Detection of inefficient algorithms and time/space complexity issues
+- **Memory Optimization**: Identification of memory leaks and inefficient data structures
+- **I/O Optimization**: Analysis of database queries, file operations, and network calls
+- **Caching Opportunities**: Recommendations for implementing caching strategies
+
+**✨ Quality Agent**:
+- **Code Style Enforcement**: Automated linting and formatting consistency checks
+- **Documentation Analysis**: Validation of code comments, JSDoc, and README completeness
+- **Test Coverage Assessment**: Analysis of unit test coverage and quality
+- **Dead Code Detection**: Identification of unused functions, variables, and imports
 
 ### **Federated Data Architecture**
 Enterprise-scale data management across distributed repositories:
@@ -482,7 +498,9 @@ Built with ❤️ using enterprise-grade technologies:
 
 ### **Core Intelligence Stack**
 - **Multi-Modal AI Integration**: Google Gemini, OpenAI GPT-4, Anthropic Claude
-- **Distributed Graph Database**: Neo4j Enterprise for Knowledge Graph operations
+- **Distributed Graph Database**: Amazon Neptune for Enterprise Knowledge Graph operations
+- **Ingestion & Query Services**: Microservices architecture with GraphQL APIs
+- **Autonomous Agent Network**: Specialized agents for Security, Architecture, Performance, and Quality analysis
 - **Federated Learning Infrastructure**: PyTorch and TensorFlow for ML model training
 - **Container Orchestration**: Kubernetes for enterprise-scale deployment
 

package/bin/codeflow-hook.js

@@ -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;