codeflow-hook 1.1.0 → 1.3.0

package/README.md

@@ -1,14 +1,116 @@
-# Codeflow Hook - AI-Powered Git Hooks
+# Codeflow Commander — Nexus Gateway CLI
 
-An interactive CI/CD simulator and lightweight pre-push code reviewer that uses Google Gemini AI to analyze your code changes before commits and pushes.
+**The Command-Line Interface for the Autonomous Engineering Platform**
 
-## 🚀 Features
+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.
 
-- **AI Code Review**: Get intelligent code analysis powered by Gemini AI
-- **Automated Git Hooks**: Automatic pre-commit and pre-push checks
-- **CI/CD Simulation**: Simulates full pipeline including tests and security checks
-- **Easy Installation**: Simple CLI setup for any project
-- **Developer-Friendly**: Clear feedback with actionable suggestions
+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).
+
+## 🚀 Key Capabilities
+
+### **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
+
+### **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
+
+### **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
+
+### **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
+
+### **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
+
+### **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
+
+## 🏗️ Architecture Overview
+
+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│ │     │ │     │ │     │ │       │     │
+│  └─────┘ └─────┘ └─────┘ └─────┘ └─────┘       │
+└─────────────────────────────────────────────────────────┘
+```
 
 ## 📦 Installation
 
@@ -65,7 +167,25 @@ This creates:
 - `pre-commit`: AI analysis of staged changes
 - `pre-push`: Full CI/CD simulation (tests + AI review)
 
-### 3. Check Status
+### 3. Index Project Knowledge (RAG Setup)
+
+Build a local knowledge base for context-aware analysis:
+
+```bash
+# Index current project files for RAG
+codeflow-hook index
+
+# Dry run to see what files would be indexed
+codeflow-hook index --dry-run
+```
+
+The knowledge base is stored in `.codeflow/index/` and includes:
+- README.md and documentation files
+- Source code files (.ts, .tsx, .js, .jsx, .json)
+- Configuration files (package.json, jest.config.*, etc.)
+- Architecture and design documents
+
+### 4. Check Status
 
 ```bash
 codeflow-hook status
@@ -73,24 +193,60 @@ codeflow-hook status
 
 ## 🛠️ Commands
 
-### Analyze Specific Changes
+### Core Commands
+
+**Index Project Knowledge**:
+```bash
+# Build local RAG knowledge base
+codeflow-hook index
 
-Manually analyze a git diff:
+# Preview what will be indexed
+codeflow-hook index --dry-run
+```
 
+**Analyze Diff**:
 ```bash
+# Analyze staged changes
 git diff --staged | codeflow-hook analyze-diff
+
+# Disable RAG context (faster but less precise)
+git diff | codeflow-hook analyze-diff --no-rag
+
+# Use legacy monolithic analysis
+git diff | codeflow-hook analyze-diff --legacy
+```
+
+**Configuration & Setup**:
+```bash
+# Configure AI provider
+codeflow-hook config -p gemini -k YOUR_API_KEY
+
+# Install git hooks
+codeflow-hook install
+
+# Check installation status
+codeflow-hook status
 ```
 
-### Reinstall Hooks
+### Advanced Options
 
 ```bash
+# Use legacy mode for backwards compatibility
+codeflow-hook analyze-diff --legacy
+
+# Skip RAG for faster analysis
+codeflow-hook analyze-diff --no-rag
+
+# Custom hooks directory
 codeflow-hook install --hooks-dir .custom-hooks
 ```
 
 ### View Help
 
 ```bash
-codeflow-hook --help
+codeflow-hook --help             # Main help
+codeflow-hook index --help      # Index command help
+codeflow-hook analyze-diff --help # Analysis options
 ```
 
 ## 🔄 How It Works
@@ -113,6 +269,88 @@ codeflow-hook --help
 - Best practice recommendations
 - Maintainability evaluation
 
+## 🔬 Enterprise Technology Stack
+
+### **Multi-Modal AI Integration**
+The Nexus Gateway integrates multiple AI modalities for comprehensive engineering intelligence:
+
+**🤖 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
+
+### **Autonomous Agent Architecture**
+The core platform intelligence is delivered through specialized agent networks:
+
+**🎯 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
+
+**🔬 Observational Intelligence Agents**:
+- Predictive maintenance scheduling based on code analysis patterns
+- Performance regression detection using historical benchmarking
+- Risk assessment with real-time compliance monitoring
+
+**🤝 Collaborative Learning Agents**:
+- Cross-repository knowledge synthesis and pattern mining
+- Expert identification through contribution analysis
+- Team productivity optimization through workflow analysis
+
+### **Federated Data Architecture**
+Enterprise-scale data management across distributed repositories:
+
+**🌐 Enterprise Knowledge Graph (EKG)**:
+- Multi-modal data integration (code, documentation, metrics, design artifacts)
+- Semantic relationship mapping across the entire organization
+- Real-time knowledge updates with conflict-free replication
+
+**📈 Predictive Intelligence Engine (PIE)**:
+- Time-series analytics for development velocity and quality trends
+- Anomaly detection using unsupervised learning algorithms
+- Forecasting models trained on enterprise development data
+
+### **Distributed Execution Framework**
+Coordination of autonomous operations across multiple systems:
+
+**⚡ Distributed Execution Engine (DEE)**:
+- Multi-repository workflow orchestration with dependency management
+- Resource optimization through intelligent load balancing
+- Federated state management with eventual consistency guarantees
+
+**🔐 Governance Safety Framework (GSF)**:
+- Risk-based permission evaluation with dynamic access controls
+- Multi-level audit trails with blockchain-verified immutability
+- Emergency stop mechanisms with graduated escalation protocols
+
+### **Structured Intelligence Output Format**
+Enterprise reporting with actionable insights and automated workflows:
+
+```
+🏢 Enterprise Code Review Summary:
+   🔒 Organization-wide Security risks: 2
+   🏗️ Architecture Optimization opportunities: 7
+   📝 Cross-repository Maintainability issues: 15
+   🎯 Predictive Maintenance alerts: 3
+
+📊 Trend Analysis:
+   📈 Code quality velocity: +12% (improving)
+   📉 Tech debt accumulation: -8% (reducing)
+   🎲 Risk exposure index: LOW (confidence: 94%)
+
+📋 Recommended Actions:
+   🔧 Automated fixes available for 23 issues
+   🚀 Cross-repository refactor suggested for auth module
+   📅 Maintenance window scheduled for Q4 dependency updates
+```
+
+### **Multi-Repository Analysis Benefits**
+- **Scale**: Analyzes thousands of repositories simultaneously
+- **Intelligence**: Learns organizational patterns and standards
+- **Automation**: Initiates cross-cutting improvements autonomously
+- **Governance**: Ensures compliance across all engineering activities
+- **Prediction**: Forecasts development bottlenecks before they occur
+
 ## 💡 Usage Examples
 
 ### Standard Development Workflow
@@ -240,12 +478,41 @@ MIT License - see LICENSE file for details
 
 ## 🎉 Acknowledgments
 
-Built with ❤️ using:
-- Google Gemini AI
-- Commander.js for CLI
-- Chalk for terminal colors
-- Ora for loading spinners
+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
+- **Federated Learning Infrastructure**: PyTorch and TensorFlow for ML model training
+- **Container Orchestration**: Kubernetes for enterprise-scale deployment
+
+### **Development & CLI Framework**
+- **Commander.js**: Professional CLI experience and command orchestration
+- **Chalk & Ora**: Advanced terminal rendering with progress indicators
+- **Axios**: Enterprise HTTP client with retry logic and circuit breakers
+- **Node.js & TypeScript**: Type-safe, scalable runtime environment
+
+### **Enterprise Integrations**
+- **Git Platforms**: Native GitHub, GitLab, and Bitbucket integration
+- **Project Management**: JIRA, Linear, and Azure DevOps workflows
+- **Communication**: Slack, Microsoft Teams, and Discord integrations
+- **Monitoring**: Datadog, New Relic, and Prometheus telemetry
+
+### **Security & Governance**
+- **Audit Framework**: Blockchain-verified audit trails
+- **Access Management**: OAuth 2.0, SAML, and LDAP integration
+- **Encryption**: End-to-end encryption with key management
+- **Compliance**: SOC 2, GDPR, and enterprise security standards
 
 ---
 
-**Ready to supercharge your development workflow? Install Codeflow Hook today!**
+**🚀 Ready to transform your organization's engineering capabilities?**
+
+Join the autonomous engineering revolution with Codeflow Commander Nexus Gateway — where AI meets enterprise-scale software development.
+
+**Install today and experience organization-wide autonomous engineering:**
+```bash
+npm install -g codeflow-hook
+```
+
+**Visit [codeflow-commander-nexus-gateway](https://github.com/Sharv619/codeflow-commander---nexus-gateway) to explore the full platform.**

package/bin/agents.js

@@ -0,0 +1,324 @@
+// Specialized AI Agents for code review
+// Implements agentic workflow with structured outputs
+
+import { callAIProvider } from './codeflow-hook.js';
+
+// Security Review Agent
+export async function securityReview(codeBlock, context, config) {
+  const prompt = `You are a Security Code Review Specialist. Your mission is to identify security vulnerabilities in the provided code changes.
+
+ANALYSIS SCOPE:
+- SQL injection vulnerabilities
+- Cross-site scripting (XSS) attacks
+- Cross-site request forgery (CSRF)
+- Insecure dependencies or outdated packages
+- Key exposure or credential leaks
+- Authentication bypass vulnerabilities
+- Directory traversal attacks
+- Path manipulation flaws
+- Deprecation warnings that could indicate security risks
+
+INPUT CODE:
+\`\`\`
+${codeBlock}
+\`\`\`
+
+CONTEXT (Reference Code from Project Knowledge Base):
+${context}
+
+You MUST respond with valid JSON in this format. Be thorough but concise:
+[
+  {
+    "type": "SECURITY",
+    "severity": "CRITICAL|HIGH|MEDIUM|LOW",
+    "description": "Clear description of the vulnerability",
+    "line": "Line number or range where issue occurs, or 'N/A' if not specific"
+  }
+]
+
+If no security issues found, return an empty array: []`;
+
+  try {
+    const response = await callAIProvider(config, prompt);
+    const parsed = parseAgentResponse(response);
+    return parsed;
+  } catch (error) {
+    console.warn(`Security review failed: ${error.message}`);
+    return [];
+  }
+}
+
+// Architecture Review Agent
+export async function architectureReview(codeBlock, context, config) {
+  const prompt = `You are an Architecture Code Review Specialist. Your mission is to evaluate architectural adherence and code organization.
+
+ANALYSIS SCOPE:
+- Design pattern violations or misuse
+- Separation of concerns breaches
+- Business logic in inappropriate layers (e.g., controllers, views)
+- Missing dependency injection where needed
+- Tight coupling between components
+- Cyclomatic complexity issues (>10 branches)
+- Large functions/methods (>50 lines)
+- Singleton pattern misuse
+- Data access patterns and ORM usage
+- Error handling architecture
+
+INPUT CODE:
+\`\`\`
+${codeBlock}
+\`\`\`
+
+CONTEXT (Reference Code from Project Knowledge Base):
+${context}
+
+You MUST respond with valid JSON in this format. Be thorough but concise:
+[
+  {
+    "type": "ARCHITECTURE",
+    "severity": "CRITICAL|HIGH|MEDIUM|LOW",
+    "description": "Clear description of the architectural issue",
+    "line": "Line number or range where issue occurs, or 'N/A' if not specific"
+  }
+]
+
+If no architectural issues found, return an empty array: []`;
+
+  try {
+    const response = await callAIProvider(config, prompt);
+    const parsed = parseAgentResponse(response);
+    return parsed;
+  } catch (error) {
+    console.warn(`Architecture review failed: ${error.message}`);
+    return [];
+  }
+}
+
+// Style and Documentation Review Agent
+export async function styleAndDocReview(codeBlock, context, config) {
+  const prompt = `You are a Code Style and Documentation Review Specialist. Your mission is to assess maintainability, readability, and documentation quality.
+
+ANALYSIS SCOPE:
+- Missing or inadequate JSDoc/TypeScript documentation
+- Poor variable/function naming conventions
+- Inconsistent code formatting
+- Missing error handling documentation
+- Inadequate function comments for complex logic
+- Violation of language-specific style guides
+- Long parameter lists (>4 parameters)
+- Magic numbers without constants
+- Inconsistent spacing or indentation
+- Missing type annotations (TypeScript)
+
+INPUT CODE:
+\`\`\`
+${codeBlock}
+\`\`\`
+
+CONTEXT (Reference Code from Project Knowledge Base):
+${context}
+
+You MUST respond with valid JSON in this format. Be thorough but concise:
+[
+  {
+    "type": "MAINTAINABILITY",
+    "severity": "CRITICAL|HIGH|MEDIUM|LOW",
+    "description": "Clear description of the style/documentation issue",
+    "line": "Line number or range where issue occurs, or 'N/A' if not specific"
+  }
+]
+
+If no issues found, return an empty array: []`;
+
+  try {
+    const response = await callAIProvider(config, prompt);
+    const parsed = parseAgentResponse(response);
+    return parsed;
+  } catch (error) {
+    console.warn(`Style/Doc review failed: ${error.message}`);
+    return [];
+  }
+}
+
+// Utility function to parse agent responses
+function parseAgentResponse(response) {
+  try {
+    // Extract JSON from response (agents may add extra text)
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return Array.isArray(parsed) ? parsed : [];
+    }
+
+    // Try parsing the whole response
+    const parsed = JSON.parse(response);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    console.warn(`Failed to parse agent response: ${error.message}`);
+    return [];
+  }
+}
+
+// Code decomposition utilities
+export class CodeDecomposer {
+  static decomposeDiff(diffContent) {
+    const scopes = [];
+    const lines = diffContent.split('\n');
+
+    let currentFile = null;
+    let currentHunk = null;
+    let hunkLines = [];
+
+    for (const line of lines) {
+      if (line.startsWith('diff --git')) {
+        // New file
+        const fileMatch = line.match(/b\/(.+)/);
+        if (fileMatch) {
+          currentFile = fileMatch[1];
+        }
+      } else if (line.startsWith('@@')) {
+        // New hunk
+        if (currentHunk && hunkLines.length > 0) {
+          scopes.push(this.analyzeHunk(currentFile, currentHunk, hunkLines));
+        }
+        currentHunk = line;
+        hunkLines = [];
+      } else if (line.startsWith('+') || line.startsWith('-')) {
+        // Changed line
+        hunkLines.push(line);
+      }
+    }
+
+    // Process final hunk
+    if (currentHunk && hunkLines.length > 0) {
+      scopes.push(this.analyzeHunk(currentFile, currentHunk, hunkLines));
+    }
+
+    return scopes;
+  }
+
+  static analyzeHunk(filePath, hunkHeader, lines) {
+    const addedLines = lines.filter(line => line.startsWith('+')).map(line => line.substring(1));
+    const removedLines = lines.filter(line => line.startsWith('-')).map(line => line.substring(1));
+
+    // Parse hunk header for line numbers
+    const lineMatch = hunkHeader.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    const startLine = lineMatch ? parseInt(lineMatch[1]) : 1;
+
+    // Group lines into logical scopes
+    return this.groupIntoScopes(addedLines, removedLines, startLine, filePath);
+  }
+
+  static groupIntoScopes(addedLines, removedLines, startLine, filePath) {
+    const scopes = [];
+
+    // For simplicity, we'll treat all changes as one scope per hunk
+    // In a more advanced implementation, we could parse AST to identify functions/classes
+    const scope = {
+      filePath,
+      startLine,
+      endLine: startLine + addedLines.length,
+      code: addedLines.join('\n'),
+      addedLines,
+      removedLines,
+      type: this.inferScopeType(filePath, addedLines.join('\n'))
+    };
+
+    scopes.push(scope);
+    return scopes;
+  }
+
+  static inferScopeType(filePath, code) {
+    if (code.includes('function ') || code.includes('=>') || code.includes('const ') && code.includes('= (')) {
+      return 'function';
+    }
+    if (code.includes('class ')) {
+      return 'class';
+    }
+    if (code.includes('import ')) {
+      return 'imports';
+    }
+    if (code.includes('interface ') || code.includes('type ')) {
+      return 'type_definition';
+    }
+    return 'general';
+  }
+}
+
+// Main orchestration function
+export async function orchestrateReview(diffContent, config, projectRoot = process.cwd()) {
+  const { decomposeDiff } = CodeDecomposer;
+
+  // Import retrieveContext dynamically to avoid circular imports
+  const { retrieveContext } = await import('./rag.js');
+
+  // Decompose diff into scopes
+  const scopes = decomposeDiff(diffContent);
+  const allResults = [];
+
+  for (const scope of scopes) {
+    if (!scope.code.trim()) continue;
+
+    // Retrieve context for this scope
+    const context = await retrieveContext(scope.code, config, projectRoot, 3);
+
+    // Run all specialized reviews in parallel
+    const [securityResults, architectureResults, styleResults] = await Promise.all([
+      securityReview(scope.code, context, config),
+      architectureReview(scope.code, context, config),
+      styleAndDocReview(scope.code, context, config)
+    ]);
+
+    // Combine and annotate results
+    const scopeResults = [
+      ...this.annotateResults(securityResults, scope),
+      ...this.annotateResults(architectureResults, scope),
+      ...this.annotateResults(styleResults, scope)
+    ];
+
+    allResults.push(...scopeResults);
+  }
+
+  return allResults;
+}
+
+// Annotate results with scope information
+function annotateResults(results, scope) {
+  return results.map(result => ({
+    ...result,
+    file: scope.filePath,
+    lineRange: `${scope.startLine}-${scope.endLine}`,
+    scopeType: scope.type
+  }));
+}
+
+// Version without RAG context retrieval
+export async function orchestrateReviewWithoutRAG(diffContent, config, projectRoot = process.cwd()) {
+  const scopes = CodeDecomposer.decomposeDiff(diffContent);
+  const allResults = [];
+
+  for (const scope of scopes) {
+    if (!scope.code.trim()) continue;
+
+    // Skip context retrieval - use empty context
+    const context = '';
+
+    // Run all specialized reviews in parallel
+    const [securityResults, architectureResults, styleResults] = await Promise.all([
+      securityReview(scope.code, context, config),
+      architectureReview(scope.code, context, config),
+      styleAndDocReview(scope.code, context, config)
+    ]);
+
+    // Combine and annotate results
+    const scopeResults = [
+      ...annotateResults(securityResults, scope),
+      ...annotateResults(architectureResults, scope),
+      ...annotateResults(styleResults, scope)
+    ];
+
+    allResults.push(...scopeResults);
+  }
+
+  return allResults;
+}