tlc-claude-code 1.2.27 → 1.2.29

package/server/lib/review-orchestrator.js

@@ -0,0 +1,273 @@
+/**
+ * Review Orchestrator - Orchestrate multi-model reviews with consensus
+ */
+
+const { ConsensusEngine } = require('./consensus-engine.js');
+const { collectFiles, readFileContent } = require('./file-collector.js');
+
+/**
+ * Orchestrate code review across multiple models
+ */
+class ReviewOrchestrator {
+  constructor(adapters, options = {}) {
+    this.adapters = adapters;
+    this.options = {
+      consensusType: 'majority',
+      requireMinimum: 1,
+      budgetAware: true,
+      maxFileSizeKB: 100,
+      ...options,
+    };
+    this.consensusEngine = new ConsensusEngine(adapters, this.options);
+  }
+
+  /**
+   * Review a single file
+   * @param {string} filePath - File path
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} Review result
+   */
+  async reviewFile(filePath, context = {}) {
+    const { content, error } = readFileContent(filePath);
+
+    if (error) {
+      return {
+        file: filePath,
+        error,
+        issues: [],
+        costs: { byModel: {}, total: 0 },
+      };
+    }
+
+    // Check file size
+    const sizeKB = Buffer.byteLength(content, 'utf-8') / 1024;
+    if (sizeKB > this.options.maxFileSizeKB) {
+      return {
+        file: filePath,
+        warning: `File too large: ${sizeKB.toFixed(1)}KB > ${this.options.maxFileSizeKB}KB limit`,
+        issues: [],
+        costs: { byModel: {}, total: 0 },
+      };
+    }
+
+    try {
+      const result = await this.consensusEngine.review(content, {
+        ...context,
+        file: filePath,
+      });
+
+      return {
+        file: filePath,
+        issues: result.consensus?.issues || [],
+        suggestions: this.aggregateSuggestions(result.reviews),
+        costs: result.costs,
+        models: result.reviews.map(r => r.model),
+        warnings: result.warnings,
+        consensusType: result.consensusType,
+      };
+    } catch (err) {
+      return {
+        file: filePath,
+        error: err.message,
+        issues: [],
+        costs: { byModel: {}, total: 0 },
+      };
+    }
+  }
+
+  /**
+   * Review multiple files
+   * @param {string[]} files - Array of file paths
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} Aggregated review result
+   */
+  async reviewFiles(files, context = {}) {
+    const fileResults = [];
+    const allModels = new Set();
+    let totalCost = 0;
+    const costsByModel = {};
+
+    for (const file of files) {
+      const result = await this.reviewFile(file, context);
+      fileResults.push(result);
+
+      // Aggregate models
+      if (result.models) {
+        result.models.forEach(m => allModels.add(m));
+      }
+
+      // Aggregate costs
+      if (result.costs) {
+        totalCost += result.costs.total || 0;
+        for (const [model, cost] of Object.entries(result.costs.byModel || {})) {
+          costsByModel[model] = (costsByModel[model] || 0) + cost;
+        }
+      }
+    }
+
+    return this.summarizeResults(fileResults, Array.from(allModels), {
+      byModel: costsByModel,
+      total: totalCost,
+    });
+  }
+
+  /**
+   * Review a directory
+   * @param {string} dir - Directory path
+   * @param {Object} options - Collection options
+   * @returns {Promise<Object>} Aggregated review result
+   */
+  async reviewDirectory(dir, options = {}) {
+    const { files, stats } = collectFiles(dir, options);
+
+    if (stats.error) {
+      return {
+        files: [],
+        models: [],
+        error: stats.error,
+        fileResults: [],
+        totalIssues: 0,
+        averageConfidence: 0,
+        totalCost: 0,
+        costs: { byModel: {}, total: 0 },
+      };
+    }
+
+    if (files.length === 0) {
+      return {
+        files: [],
+        models: [],
+        warning: 'No files found to review',
+        fileResults: [],
+        totalIssues: 0,
+        averageConfidence: 0,
+        totalCost: 0,
+        costs: { byModel: {}, total: 0 },
+      };
+    }
+
+    return this.reviewFiles(files, { directory: dir });
+  }
+
+  /**
+   * Summarize review results
+   * @param {Array} fileResults - Results per file
+   * @param {Array} models - Models used
+   * @param {Object} costs - Cost summary
+   * @returns {Object} Summary
+   */
+  summarizeResults(fileResults, models, costs) {
+    // Collect all issues across files
+    const allIssues = [];
+    for (const result of fileResults) {
+      for (const issue of result.issues || []) {
+        allIssues.push({ ...issue, file: result.file });
+      }
+    }
+
+    // Calculate average confidence
+    let totalConfidence = 0;
+    let confidenceCount = 0;
+    for (const result of fileResults) {
+      for (const issue of result.issues || []) {
+        if (issue.confidence !== undefined) {
+          totalConfidence += issue.confidence;
+          confidenceCount++;
+        }
+      }
+    }
+    const averageConfidence = confidenceCount > 0 ? totalConfidence / confidenceCount : 0;
+
+    // Get consensus issues (across all files)
+    const consensusIssues = this.getConsensusIssues(fileResults);
+
+    return {
+      files: fileResults.map(r => r.file),
+      models,
+      fileResults,
+      totalIssues: allIssues.length,
+      averageConfidence,
+      totalCost: costs.total,
+      costs,
+      consensusIssues,
+      modelAgreement: models.length > 1,
+    };
+  }
+
+  /**
+   * Get issues that appear across multiple files
+   * @param {Array} fileResults - Results per file
+   * @returns {Array} Consensus issues
+   */
+  getConsensusIssues(fileResults) {
+    const issueMap = new Map();
+
+    for (const result of fileResults) {
+      for (const issue of result.issues || []) {
+        // Key by message (normalized)
+        const key = (issue.message || '').toLowerCase().trim();
+        if (!key) continue;
+
+        if (!issueMap.has(key)) {
+          issueMap.set(key, {
+            id: issue.id || key,
+            message: issue.message,
+            severity: issue.severity,
+            voters: issue.voters || [],
+            confidence: issue.confidence || 0,
+            files: [],
+          });
+        }
+        const entry = issueMap.get(key);
+        entry.files.push(result.file);
+      }
+    }
+
+    return Array.from(issueMap.values())
+      .sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /**
+   * Aggregate suggestions from all reviews
+   * @param {Array} reviews - Review results
+   * @returns {Array} Unique suggestions
+   */
+  aggregateSuggestions(reviews) {
+    const suggestions = new Set();
+    for (const review of reviews || []) {
+      for (const suggestion of review.suggestions || []) {
+        suggestions.add(suggestion);
+      }
+    }
+    return Array.from(suggestions);
+  }
+
+  /**
+   * Get available models (within budget)
+   * @returns {Array} Available adapter names
+   */
+  getAvailableModels() {
+    if (!this.options.budgetAware) {
+      return this.adapters.map(a => a.name);
+    }
+    return this.adapters
+      .filter(a => a.canAfford())
+      .map(a => a.name);
+  }
+
+  /**
+   * Get usage summary across all adapters
+   * @returns {Object} Usage by model
+   */
+  getUsageSummary() {
+    const usage = {};
+    for (const adapter of this.adapters) {
+      usage[adapter.name] = adapter.getUsage();
+    }
+    return usage;
+  }
+}
+
+module.exports = {
+  ReviewOrchestrator,
+};

package/server/lib/review-orchestrator.test.js

@@ -0,0 +1,300 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { ReviewOrchestrator } from './review-orchestrator.js';
+
+// Create mock adapter
+const createMockAdapter = (name, issues = [], options = {}) => ({
+  name,
+  canAfford: vi.fn(() => options.canAfford !== false),
+  getUsage: vi.fn(() => options.usage || { daily: 0, monthly: 0, requests: 0 }),
+  review: vi.fn(() => Promise.resolve({
+    issues,
+    suggestions: options.suggestions || [],
+    score: options.score || 80,
+    model: name,
+    tokensUsed: 100,
+    cost: options.cost || 0.01,
+  })),
+});
+
+describe('ReviewOrchestrator', () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-review-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('constructor', () => {
+    it('initializes with adapters', () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+      expect(orchestrator.adapters).toHaveLength(1);
+    });
+
+    it('accepts options', () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters, { consensusType: 'unanimous' });
+      expect(orchestrator.options.consensusType).toBe('unanimous');
+    });
+  });
+
+  describe('reviewFile', () => {
+    it('reviews a single file', async () => {
+      const filePath = path.join(testDir, 'test.js');
+      fs.writeFileSync(filePath, 'const x = 1;');
+
+      const adapters = [createMockAdapter('claude', [{ id: 'A', severity: 'high', message: 'Issue' }])];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFile(filePath);
+
+      expect(result.file).toBe(filePath);
+      expect(result.issues).toHaveLength(1);
+    });
+
+    it('returns error for non-existent file', async () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const result = await orchestrator.reviewFile('/nonexistent/file.js');
+
+      expect(result.error).toBeTruthy();
+      expect(result.issues).toEqual([]);
+    });
+
+    it('skips files over size limit', async () => {
+      const filePath = path.join(testDir, 'large.js');
+      fs.writeFileSync(filePath, 'x'.repeat(200 * 1024)); // 200KB
+
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters, { maxFileSizeKB: 100 });
+
+      const result = await orchestrator.reviewFile(filePath);
+
+      expect(result.warning).toContain('too large');
+      expect(result.issues).toEqual([]);
+    });
+
+    it('tracks costs', async () => {
+      const filePath = path.join(testDir, 'test.js');
+      fs.writeFileSync(filePath, 'const x = 1;');
+
+      const adapters = [
+        createMockAdapter('claude', [], { cost: 0.01 }),
+        createMockAdapter('openai', [], { cost: 0.02 }),
+      ];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFile(filePath);
+
+      expect(result.costs.total).toBeCloseTo(0.03, 2);
+    });
+
+    it('includes models used', async () => {
+      const filePath = path.join(testDir, 'test.js');
+      fs.writeFileSync(filePath, 'const x = 1;');
+
+      const adapters = [
+        createMockAdapter('claude'),
+        createMockAdapter('openai'),
+      ];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFile(filePath);
+
+      expect(result.models).toContain('claude');
+      expect(result.models).toContain('openai');
+    });
+  });
+
+  describe('reviewFiles', () => {
+    it('reviews multiple files', async () => {
+      fs.writeFileSync(path.join(testDir, 'a.js'), 'code a');
+      fs.writeFileSync(path.join(testDir, 'b.js'), 'code b');
+
+      const adapters = [createMockAdapter('claude', [{ id: 'A', message: 'Issue' }])];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFiles([
+        path.join(testDir, 'a.js'),
+        path.join(testDir, 'b.js'),
+      ]);
+
+      expect(result.files).toHaveLength(2);
+      expect(result.fileResults).toHaveLength(2);
+    });
+
+    it('aggregates costs across files', async () => {
+      fs.writeFileSync(path.join(testDir, 'a.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'b.js'), 'code');
+
+      const adapters = [createMockAdapter('claude', [], { cost: 0.01 })];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFiles([
+        path.join(testDir, 'a.js'),
+        path.join(testDir, 'b.js'),
+      ]);
+
+      expect(result.totalCost).toBeCloseTo(0.02, 2);
+    });
+
+    it('counts total issues', async () => {
+      fs.writeFileSync(path.join(testDir, 'a.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'b.js'), 'code');
+
+      const adapters = [createMockAdapter('claude', [
+        { id: 'A', message: 'Issue A' },
+        { id: 'B', message: 'Issue B' },
+      ])];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewFiles([
+        path.join(testDir, 'a.js'),
+        path.join(testDir, 'b.js'),
+      ]);
+
+      expect(result.totalIssues).toBe(4); // 2 issues per file
+    });
+  });
+
+  describe('reviewDirectory', () => {
+    it('reviews all files in directory', async () => {
+      fs.writeFileSync(path.join(testDir, 'a.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'b.js'), 'code');
+
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewDirectory(testDir);
+
+      expect(result.files).toHaveLength(2);
+    });
+
+    it('returns error for invalid directory', async () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const result = await orchestrator.reviewDirectory('/nonexistent');
+
+      expect(result.error).toBeTruthy();
+    });
+
+    it('returns warning for empty directory', async () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const result = await orchestrator.reviewDirectory(testDir);
+
+      expect(result.warning).toContain('No files');
+    });
+
+    it('respects extension filter', async () => {
+      fs.writeFileSync(path.join(testDir, 'a.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'b.ts'), 'code');
+      fs.writeFileSync(path.join(testDir, 'c.css'), 'code');
+
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters, { requireMinimum: 1 });
+
+      const result = await orchestrator.reviewDirectory(testDir, { extensions: ['.js'] });
+
+      expect(result.files).toHaveLength(1);
+    });
+  });
+
+  describe('summarizeResults', () => {
+    it('calculates average confidence', () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      // Provide pre-formed results with known confidence values
+      const fileResults = [
+        {
+          file: 'a.js',
+          issues: [
+            { id: 'A', message: 'Issue', confidence: 0.8 },
+            { id: 'B', message: 'Issue 2', confidence: 0.6 },
+          ],
+        },
+      ];
+
+      const summary = orchestrator.summarizeResults(fileResults, ['claude'], { byModel: {}, total: 0 });
+
+      expect(summary.averageConfidence).toBeCloseTo(0.7, 1);
+    });
+
+    it('handles files with no issues', () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const fileResults = [{ file: 'a.js', issues: [] }];
+      const summary = orchestrator.summarizeResults(fileResults, ['claude'], { byModel: {}, total: 0 });
+
+      expect(summary.averageConfidence).toBe(0);
+    });
+  });
+
+  describe('getAvailableModels', () => {
+    it('returns all models when budgetAware is false', () => {
+      const adapters = [
+        createMockAdapter('claude', [], { canAfford: false }),
+        createMockAdapter('openai', [], { canAfford: true }),
+      ];
+      const orchestrator = new ReviewOrchestrator(adapters, { budgetAware: false });
+
+      const models = orchestrator.getAvailableModels();
+      expect(models).toEqual(['claude', 'openai']);
+    });
+
+    it('returns only affordable models when budgetAware is true', () => {
+      const adapters = [
+        createMockAdapter('claude', [], { canAfford: false }),
+        createMockAdapter('openai', [], { canAfford: true }),
+      ];
+      const orchestrator = new ReviewOrchestrator(adapters, { budgetAware: true });
+
+      const models = orchestrator.getAvailableModels();
+      expect(models).toEqual(['openai']);
+    });
+  });
+
+  describe('getUsageSummary', () => {
+    it('returns usage for all adapters', () => {
+      const adapters = [
+        createMockAdapter('claude', [], { usage: { daily: 1, monthly: 10, requests: 5 } }),
+        createMockAdapter('openai', [], { usage: { daily: 2, monthly: 20, requests: 10 } }),
+      ];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const usage = orchestrator.getUsageSummary();
+
+      expect(usage.claude.daily).toBe(1);
+      expect(usage.openai.daily).toBe(2);
+    });
+  });
+
+  describe('aggregateSuggestions', () => {
+    it('combines unique suggestions', () => {
+      const adapters = [createMockAdapter('claude')];
+      const orchestrator = new ReviewOrchestrator(adapters);
+
+      const reviews = [
+        { suggestions: ['A', 'B'] },
+        { suggestions: ['B', 'C'] },
+      ];
+
+      const suggestions = orchestrator.aggregateSuggestions(reviews);
+      expect(suggestions).toHaveLength(3);
+      expect(suggestions).toContain('A');
+      expect(suggestions).toContain('B');
+      expect(suggestions).toContain('C');
+    });
+  });
+});