tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/semantic-analyzer.js

@@ -0,0 +1,198 @@
+/**
+ * Semantic Analyzer
+ * Use AI to detect naming issues and semantic problems
+ */
+
+const { ConsensusEngine } = require('./consensus-engine.js');
+
+class SemanticAnalyzer {
+  constructor(options = {}) {
+    this.adapters = options.adapters || [];
+    this.useConsensus = options.useConsensus !== false && this.adapters.length > 1;
+    this.budgetAware = options.budgetAware !== false;
+    this.requireMinimum = options.requireMinimum ?? 1;
+
+    if (this.useConsensus) {
+      this.consensusEngine = new ConsensusEngine(this.adapters, {
+        consensusType: options.consensusType || 'majority',
+        requireMinimum: this.requireMinimum,
+        budgetAware: this.budgetAware,
+      });
+    }
+  }
+
+  /**
+   * Analyze code for semantic issues
+   * @param {string} code - Source code to analyze
+   * @param {string} filename - Filename for context
+   * @param {Object} extraContext - Additional context to pass to adapters
+   * @returns {Object} Analysis result with issues
+   */
+  async analyze(code, filename, extraContext = {}) {
+    if (!code || code.trim() === '') {
+      return {
+        issues: [],
+        byType: {},
+        cost: 0,
+        warnings: [],
+      };
+    }
+
+    const context = {
+      filename,
+      type: 'semantic',
+      ...extraContext,
+    };
+
+    // Filter adapters by budget if configured
+    const availableAdapters = this.budgetAware
+      ? this.adapters.filter((a) => a.canAfford())
+      : this.adapters;
+
+    if (availableAdapters.length === 0) {
+      return {
+        issues: [],
+        byType: {},
+        cost: 0,
+        warnings: ['No adapters available (budget exceeded or none configured)'],
+      };
+    }
+
+    // Use consensus engine for multi-model
+    if (this.useConsensus && availableAdapters.length > 1) {
+      return this.analyzeWithConsensus(code, context);
+    }
+
+    // Single model analysis
+    return this.analyzeWithSingleModel(code, context, availableAdapters[0]);
+  }
+
+  /**
+   * Analyze with consensus engine (multiple models)
+   */
+  async analyzeWithConsensus(code, context) {
+    try {
+      const result = await this.consensusEngine.review(code, context);
+
+      const issues = [];
+      const warnings = result.warnings || [];
+
+      // Collect all issues from reviews
+      for (const review of result.reviews) {
+        for (const issue of review.issues || []) {
+          issues.push({
+            ...issue,
+            model: review.model,
+          });
+        }
+      }
+
+      // Categorize by type
+      const byType = this.categorizeByType(issues);
+
+      return {
+        issues,
+        byType,
+        consensus: result.consensus,
+        cost: result.costs.total,
+        warnings,
+        models: result.reviews.map((r) => r.model),
+      };
+    } catch (error) {
+      return {
+        issues: [],
+        byType: {},
+        cost: 0,
+        warnings: [error.message],
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Analyze with a single model
+   */
+  async analyzeWithSingleModel(code, context, adapter) {
+    const warnings = [];
+    let issues = [];
+    let cost = 0;
+
+    try {
+      const result = await adapter.review(code, context);
+      issues = result.issues || [];
+      cost = result.cost || 0;
+    } catch (error) {
+      warnings.push(`${adapter.name} failed: ${error.message}`);
+    }
+
+    const byType = this.categorizeByType(issues);
+
+    return {
+      issues,
+      byType,
+      cost,
+      warnings,
+    };
+  }
+
+  /**
+   * Categorize issues by type
+   */
+  categorizeByType(issues) {
+    const byType = {};
+
+    for (const issue of issues) {
+      const type = issue.type || 'unknown';
+      if (!byType[type]) {
+        byType[type] = [];
+      }
+      byType[type].push(issue);
+    }
+
+    return byType;
+  }
+
+  /**
+   * Create a prompt for semantic analysis
+   * Used when calling LLM adapters
+   */
+  static createPrompt(code, context) {
+    return `Analyze this code for naming and semantic issues.
+
+File: ${context.filename}
+
+Code:
+\`\`\`
+${code}
+\`\`\`
+
+Look for:
+1. Poor variable names (single letters, cryptic abbreviations)
+2. Poor function names (vague like 'doIt', 'process', 'handle')
+3. Unclear function purposes (doing too many things)
+4. Inconsistent naming conventions
+5. Magic numbers without explanation
+
+For each issue found, provide:
+- type: "naming" or "clarity"
+- severity: "error", "warning", or "info"
+- line: line number
+- message: description of the issue
+- suggestion: how to fix it
+
+Respond in JSON format:
+{
+  "issues": [
+    {
+      "type": "naming",
+      "severity": "warning",
+      "line": 5,
+      "message": "Variable 'x' has unclear name",
+      "suggestion": "Rename to descriptive name like 'userCount'"
+    }
+  ]
+}`;
+  }
+}
+
+module.exports = { SemanticAnalyzer };

package/server/lib/semantic-analyzer.test.js

@@ -0,0 +1,474 @@
+/**
+ * Semantic Analyzer Tests
+ * Task 3: Use AI to detect naming issues and semantic problems
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('SemanticAnalyzer', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('poor naming detection', () => {
+    it('flags single-letter variable names', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [
+            {
+              type: 'naming',
+              severity: 'warning',
+              message: "Variable 'x' has unclear name",
+              line: 2,
+              suggestion: 'Consider renaming to a descriptive name like userCount',
+            },
+          ],
+          cost: 0.001,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const code = `
+        function process(x) {
+          const y = x * 2;
+          return y;
+        }
+      `;
+
+      const result = await analyzer.analyze(code, 'test.js');
+
+      expect(result.issues.some(i => i.type === 'naming')).toBe(true);
+      expect(result.issues.some(i => i.message.includes('x'))).toBe(true);
+    });
+
+    it('flags cryptic function names', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [
+            {
+              type: 'naming',
+              severity: 'warning',
+              message: "Function 'fn1' has unclear name",
+              line: 1,
+              suggestion: 'Rename to describe what it does, e.g., calculateTotal',
+            },
+            {
+              type: 'naming',
+              severity: 'warning',
+              message: "Function 'doIt' is too vague",
+              line: 5,
+              suggestion: 'Be specific about what action is performed',
+            },
+          ],
+          cost: 0.001,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const code = `
+        function fn1() { return 1; }
+        function doIt() { return 2; }
+        function proc() { return 3; }
+      `;
+
+      const result = await analyzer.analyze(code, 'test.js');
+
+      expect(result.issues.some(i => i.message.includes('fn1'))).toBe(true);
+      expect(result.issues.some(i => i.message.includes('doIt'))).toBe(true);
+    });
+
+    it('suggests descriptive alternatives', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [
+            {
+              type: 'naming',
+              severity: 'warning',
+              message: "Variable 'd' in date context",
+              line: 2,
+              suggestion: 'Rename to currentDate or dateValue',
+            },
+          ],
+          cost: 0.001,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const code = `
+        function formatDate(d) {
+          return d.toISOString();
+        }
+      `;
+
+      const result = await analyzer.analyze(code, 'test.js');
+
+      expect(result.issues[0].suggestion).toBeDefined();
+      expect(result.issues[0].suggestion.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('unclear function purpose', () => {
+    it('identifies unclear function purposes', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [
+            {
+              type: 'clarity',
+              severity: 'info',
+              message: 'Function does multiple unrelated things',
+              line: 1,
+              suggestion: 'Consider splitting into separate functions',
+            },
+          ],
+          cost: 0.001,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const code = `
+        function handle(data) {
+          validate(data);
+          save(data);
+          notify(data);
+          log(data);
+          return transform(data);
+        }
+      `;
+
+      const result = await analyzer.analyze(code, 'test.js');
+
+      expect(result.issues.some(i => i.type === 'clarity')).toBe(true);
+    });
+  });
+
+  describe('multi-model consensus', () => {
+    it('uses consensus engine for multi-model analysis', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const adapter1 = {
+        name: 'model1',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'model1',
+          issues: [
+            { type: 'naming', message: "Variable 'x' unclear", line: 1 },
+          ],
+          cost: 0.01,
+        }),
+      };
+
+      const adapter2 = {
+        name: 'model2',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'model2',
+          issues: [
+            { type: 'naming', message: "Variable 'x' unclear", line: 1 },
+            { type: 'naming', message: "Variable 'y' unclear", line: 2 },
+          ],
+          cost: 0.02,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({
+        adapters: [adapter1, adapter2],
+        useConsensus: true,
+      });
+
+      const code = 'const x = 1; const y = 2;';
+      const result = await analyzer.analyze(code, 'test.js');
+
+      expect(result.consensus).toBeDefined();
+      expect(result.consensus.issues.length).toBeGreaterThan(0);
+
+      // Issue found by both models should have higher confidence
+      const xIssue = result.consensus.issues.find(i => i.message.includes('x'));
+      expect(xIssue.confidence).toBe(1); // 2/2 models
+    });
+
+    it('shows confidence scores based on agreement', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const adapter1 = {
+        name: 'model1',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'model1',
+          issues: [
+            { type: 'naming', message: 'Issue A', line: 1 },
+          ],
+          cost: 0.01,
+        }),
+      };
+
+      const adapter2 = {
+        name: 'model2',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'model2',
+          issues: [
+            { type: 'naming', message: 'Issue A', line: 1 },
+            { type: 'naming', message: 'Issue B', line: 2 },
+          ],
+          cost: 0.02,
+        }),
+      };
+
+      const adapter3 = {
+        name: 'model3',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'model3',
+          issues: [
+            { type: 'naming', message: 'Issue A', line: 1 },
+          ],
+          cost: 0.015,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({
+        adapters: [adapter1, adapter2, adapter3],
+        useConsensus: true,
+      });
+
+      const result = await analyzer.analyze('code', 'test.js');
+
+      // Issue A: 3/3 = 100% confidence
+      // Issue B: 1/3 = 33% confidence
+      const issueA = result.consensus.issues.find(i => i.message === 'Issue A');
+      const issueB = result.consensus.issues.find(i => i.message === 'Issue B');
+
+      expect(issueA.confidence).toBe(1);
+      expect(issueB.confidence).toBeCloseTo(0.33, 1);
+    });
+  });
+
+  describe('budget limits', () => {
+    it('respects budget limits', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const expensiveAdapter = {
+        name: 'expensive',
+        canAfford: () => false,
+        review: vi.fn(),
+      };
+
+      const cheapAdapter = {
+        name: 'cheap',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'cheap',
+          issues: [],
+          cost: 0.001,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({
+        adapters: [expensiveAdapter, cheapAdapter],
+        budgetAware: true,
+      });
+
+      await analyzer.analyze('const x = 1;', 'test.js');
+
+      expect(expensiveAdapter.review).not.toHaveBeenCalled();
+      expect(cheapAdapter.review).toHaveBeenCalled();
+    });
+
+    it('tracks costs across analysis', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [],
+          cost: 0.05,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const result = await analyzer.analyze('code', 'test.js');
+
+      expect(result.cost).toBe(0.05);
+    });
+  });
+
+  describe('error handling', () => {
+    it('gracefully handles model failures', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const failingAdapter = {
+        name: 'failing',
+        canAfford: () => true,
+        review: vi.fn().mockRejectedValue(new Error('API error')),
+      };
+
+      const workingAdapter = {
+        name: 'working',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'working',
+          issues: [{ type: 'naming', message: 'Found issue', line: 1 }],
+          cost: 0.01,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({
+        adapters: [failingAdapter, workingAdapter],
+      });
+
+      const result = await analyzer.analyze('code', 'test.js');
+
+      expect(result.warnings).toContain('failing failed: API error');
+      expect(result.issues).toHaveLength(1);
+    });
+
+    it('returns empty results when all models fail', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const failingAdapter = {
+        name: 'failing',
+        canAfford: () => true,
+        review: vi.fn().mockRejectedValue(new Error('API error')),
+      };
+
+      const analyzer = new SemanticAnalyzer({
+        adapters: [failingAdapter],
+        requireMinimum: 0,
+      });
+
+      const result = await analyzer.analyze('code', 'test.js');
+
+      expect(result.issues).toEqual([]);
+      expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    it('handles empty code gracefully', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [],
+          cost: 0,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const result = await analyzer.analyze('', 'test.js');
+
+      expect(result.issues).toEqual([]);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('context passing', () => {
+    it('passes file context to adapters', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [],
+          cost: 0.01,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      await analyzer.analyze('code', 'src/utils/helpers.js');
+
+      expect(mockAdapter.review).toHaveBeenCalledWith(
+        'code',
+        expect.objectContaining({
+          filename: 'src/utils/helpers.js',
+          type: 'semantic',
+        })
+      );
+    });
+
+    it('passes custom context to adapters', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [],
+          cost: 0.01,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      await analyzer.analyze('code', 'test.js', { projectType: 'react' });
+
+      expect(mockAdapter.review).toHaveBeenCalledWith(
+        'code',
+        expect.objectContaining({
+          projectType: 'react',
+        })
+      );
+    });
+  });
+
+  describe('issue categorization', () => {
+    it('categorizes issues by type', async () => {
+      const { SemanticAnalyzer } = await import('./semantic-analyzer.js');
+
+      const mockAdapter = {
+        name: 'mock',
+        canAfford: () => true,
+        review: vi.fn().mockResolvedValue({
+          model: 'mock',
+          issues: [
+            { type: 'naming', message: 'Poor name', line: 1 },
+            { type: 'clarity', message: 'Unclear purpose', line: 2 },
+            { type: 'naming', message: 'Another poor name', line: 3 },
+          ],
+          cost: 0.01,
+        }),
+      };
+
+      const analyzer = new SemanticAnalyzer({ adapters: [mockAdapter] });
+
+      const result = await analyzer.analyze('code', 'test.js');
+
+      expect(result.byType).toBeDefined();
+      expect(result.byType.naming).toHaveLength(2);
+      expect(result.byType.clarity).toHaveLength(1);
+    });
+  });
+});