tlc-claude-code 1.2.26 → 1.2.28

package/server/lib/claude-injector.test.js

@@ -0,0 +1,161 @@
+import { describe, it, beforeEach, afterEach, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { injectMemoryContext, extractMemorySection, MEMORY_SECTION_MARKERS } from './claude-injector.js';
+
+describe('claude-injector', () => {
+  let testDir;
+  let claudeMdPath;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-injector-test-'));
+    claudeMdPath = path.join(testDir, 'CLAUDE.md');
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('injectMemoryContext', () => {
+    it('creates CLAUDE.md if missing', async () => {
+      await injectMemoryContext(testDir, '## Active Memory\n\nTest content');
+
+      expect(fs.existsSync(claudeMdPath)).toBe(true);
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('Active Memory');
+    });
+
+    it('appends memory section to existing CLAUDE.md', async () => {
+      fs.writeFileSync(claudeMdPath, '# Project\n\nExisting content\n');
+
+      await injectMemoryContext(testDir, '## Preferences\n\n- style: functional');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('Existing content');
+      expect(content).toContain('Preferences');
+      expect(content).toContain('functional');
+    });
+
+    it('replaces existing memory section without duplication', async () => {
+      const initial = `# Project
+
+${MEMORY_SECTION_MARKERS.START}
+## Old Memory
+
+Old content
+${MEMORY_SECTION_MARKERS.END}
+
+## Other Section
+`;
+      fs.writeFileSync(claudeMdPath, initial);
+
+      await injectMemoryContext(testDir, '## New Memory\n\nNew content');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('New Memory');
+      expect(content).toContain('New content');
+      expect(content).not.toContain('Old Memory');
+      expect(content).not.toContain('Old content');
+      expect(content).toContain('Other Section');
+    });
+
+    it('preserves content before and after memory section', async () => {
+      const initial = `# Project Title
+
+Introduction paragraph.
+
+${MEMORY_SECTION_MARKERS.START}
+## Memory
+Content
+${MEMORY_SECTION_MARKERS.END}
+
+## Commands
+
+- /help
+`;
+      fs.writeFileSync(claudeMdPath, initial);
+
+      await injectMemoryContext(testDir, '## Updated Memory\n\nUpdated');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('Project Title');
+      expect(content).toContain('Introduction paragraph');
+      expect(content).toContain('Commands');
+      expect(content).toContain('/help');
+      expect(content).toContain('Updated Memory');
+    });
+
+    it('handles empty memory context gracefully', async () => {
+      fs.writeFileSync(claudeMdPath, '# Project\n\nContent\n');
+
+      await injectMemoryContext(testDir, '');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('Project');
+      // Should still have markers even if empty
+      expect(content).toContain(MEMORY_SECTION_MARKERS.START);
+    });
+
+    it('adds markers around injected content', async () => {
+      await injectMemoryContext(testDir, '## Memory\n\nContent');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain(MEMORY_SECTION_MARKERS.START);
+      expect(content).toContain(MEMORY_SECTION_MARKERS.END);
+    });
+
+    it('handles CLAUDE.md with only whitespace', async () => {
+      fs.writeFileSync(claudeMdPath, '   \n\n  \n');
+
+      await injectMemoryContext(testDir, '## Memory\n\nContent');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toContain('Memory');
+    });
+  });
+
+  describe('extractMemorySection', () => {
+    it('extracts content between markers', () => {
+      const content = `Before
+${MEMORY_SECTION_MARKERS.START}
+## Memory
+Content here
+${MEMORY_SECTION_MARKERS.END}
+After`;
+
+      const extracted = extractMemorySection(content);
+
+      expect(extracted).toContain('Memory');
+      expect(extracted).toContain('Content here');
+      expect(extracted).not.toContain('Before');
+      expect(extracted).not.toContain('After');
+    });
+
+    it('returns null if no memory section', () => {
+      const content = '# Just a normal file\n\nNo memory here';
+
+      const extracted = extractMemorySection(content);
+
+      expect(extracted).toBeNull();
+    });
+
+    it('returns null for malformed markers', () => {
+      const content = `${MEMORY_SECTION_MARKERS.START}
+No end marker`;
+
+      const extracted = extractMemorySection(content);
+
+      expect(extracted).toBeNull();
+    });
+
+    it('handles empty section between markers', () => {
+      const content = `${MEMORY_SECTION_MARKERS.START}
+${MEMORY_SECTION_MARKERS.END}`;
+
+      const extracted = extractMemorySection(content);
+
+      expect(extracted).toBe('');
+    });
+  });
+});

package/server/lib/consensus-engine.js

@@ -0,0 +1,135 @@
+/**
+ * Consensus Engine - Aggregate reviews from multiple models
+ */
+
+class ConsensusEngine {
+  constructor(adapters, config = {}) {
+    this.adapters = adapters;
+    this.config = {
+      consensusType: 'majority',
+      requireMinimum: 2,
+      budgetAware: true,
+      ...config,
+    };
+  }
+
+  /**
+   * Run review across all adapters
+   * @param {string} code - Code to review
+   * @param {Object} context - Review context
+   * @returns {Promise<Object>} Aggregated review result
+   */
+  async review(code, context = {}) {
+    // Filter adapters by budget if configured
+    const availableAdapters = this.config.budgetAware
+      ? this.adapters.filter(a => a.canAfford())
+      : this.adapters;
+
+    // Run all reviews in parallel
+    const results = await Promise.allSettled(
+      availableAdapters.map(async a => {
+        const result = await a.review(code, context);
+        return result;
+      })
+    );
+
+    const reviews = [];
+    const warnings = [];
+
+    results.forEach((result, i) => {
+      if (result.status === 'fulfilled') {
+        reviews.push(result.value);
+      } else {
+        warnings.push(`${availableAdapters[i].name} failed: ${result.reason.message}`);
+      }
+    });
+
+    // Check minimum requirement
+    if (reviews.length < this.config.requireMinimum) {
+      throw new Error(`Insufficient reviews: got ${reviews.length}, need ${this.config.requireMinimum}`);
+    }
+
+    // Calculate consensus
+    const consensus = ConsensusEngine.calculateConsensus(reviews, this.config.consensusType);
+    const costs = ConsensusEngine.summarizeCosts(reviews);
+
+    return {
+      reviews,
+      warnings,
+      consensus,
+      costs,
+      consensusType: reviews.length === 1 ? 'single-model' : this.config.consensusType,
+    };
+  }
+
+  /**
+   * Calculate consensus from reviews
+   * @param {Array} reviews - Array of review results
+   * @param {string} type - Consensus type ('majority' or 'unanimous')
+   * @returns {Object} Consensus result
+   */
+  static calculateConsensus(reviews, type = 'majority') {
+    const issueMap = new Map();
+
+    // Collect all issues
+    for (const review of reviews) {
+      for (const issue of (review.issues || [])) {
+        const key = issue.id || ConsensusEngine.hashIssue(issue);
+        if (!issueMap.has(key)) {
+          issueMap.set(key, { ...issue, votes: 0, voters: [] });
+        }
+        const entry = issueMap.get(key);
+        entry.votes++;
+        entry.voters.push(review.model);
+      }
+    }
+
+    // Filter by consensus type
+    const threshold = type === 'unanimous' ? reviews.length : 1;
+
+    const consensusIssues = Array.from(issueMap.values())
+      .filter(issue => issue.votes >= threshold)
+      .map(issue => ({
+        ...issue,
+        confidence: issue.votes / reviews.length,
+      }))
+      .sort((a, b) => b.confidence - a.confidence);
+
+    return {
+      issues: consensusIssues,
+      totalReviews: reviews.length,
+      consensusThreshold: threshold,
+    };
+  }
+
+  /**
+   * Create hash for issue deduplication
+   * @param {Object} issue - Issue object
+   * @returns {string} Hash
+   */
+  static hashIssue(issue) {
+    return `${issue.line || ''}-${issue.message || ''}-${issue.severity || ''}`.toLowerCase();
+  }
+
+  /**
+   * Summarize costs across reviews
+   * @param {Array} reviews - Array of review results
+   * @returns {Object} Cost summary
+   */
+  static summarizeCosts(reviews) {
+    const byModel = {};
+    let total = 0;
+
+    for (const review of reviews) {
+      const cost = review.cost || 0;
+      byModel[review.model] = cost;
+      total += cost;
+    }
+
+    return { byModel, total };
+  }
+}
+
+module.exports = {
+  ConsensusEngine,
+};

package/server/lib/consensus-engine.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ConsensusEngine } from './consensus-engine.js';
+
+// Mock adapters
+const createMockAdapter = (name, issues = []) => ({
+  name,
+  canAfford: vi.fn(() => true),
+  review: vi.fn(() => Promise.resolve({
+    issues,
+    suggestions: [],
+    score: 80,
+    model: name,
+    tokensUsed: 100,
+    cost: 0.01,
+  })),
+});
+
+describe('ConsensusEngine', () => {
+  describe('review', () => {
+    it('aggregates reviews from multiple models', async () => {
+      const adapters = [
+        createMockAdapter('claude'),
+        createMockAdapter('openai'),
+        createMockAdapter('deepseek'),
+      ];
+
+      const engine = new ConsensusEngine(adapters);
+      const result = await engine.review('const x = 1;');
+
+      expect(result.reviews).toHaveLength(3);
+      expect(result.reviews.map(r => r.model)).toEqual(['claude', 'openai', 'deepseek']);
+    });
+
+    it('runs reviews in parallel', async () => {
+      const delay = ms => new Promise(r => setTimeout(r, ms));
+      const adapters = [
+        { name: 'a', canAfford: () => true, review: async () => { await delay(50); return { issues: [], suggestions: [], score: 80, model: 'a', tokensUsed: 0, cost: 0 }; } },
+        { name: 'b', canAfford: () => true, review: async () => { await delay(50); return { issues: [], suggestions: [], score: 80, model: 'b', tokensUsed: 0, cost: 0 }; } },
+        { name: 'c', canAfford: () => true, review: async () => { await delay(50); return { issues: [], suggestions: [], score: 80, model: 'c', tokensUsed: 0, cost: 0 }; } },
+      ];
+
+      const engine = new ConsensusEngine(adapters);
+      const start = Date.now();
+      await engine.review('code');
+      const elapsed = Date.now() - start;
+
+      // Should take ~50ms (parallel), not ~150ms (sequential)
+      expect(elapsed).toBeLessThan(120);
+    });
+
+    it('handles model failures gracefully', async () => {
+      const adapters = [
+        createMockAdapter('claude'),
+        {
+          name: 'failing',
+          canAfford: () => true,
+          review: () => Promise.reject(new Error('API error')),
+        },
+        createMockAdapter('deepseek'),
+      ];
+
+      const engine = new ConsensusEngine(adapters);
+      const result = await engine.review('code');
+
+      expect(result.reviews).toHaveLength(2);
+      expect(result.warnings).toContain('failing failed: API error');
+    });
+
+    it('skips models over budget', async () => {
+      const adapters = [
+        createMockAdapter('claude'),
+        { ...createMockAdapter('openai'), canAfford: () => false },
+        createMockAdapter('deepseek'),
+      ];
+
+      const engine = new ConsensusEngine(adapters, { budgetAware: true });
+      const result = await engine.review('code');
+
+      expect(result.reviews).toHaveLength(2);
+      expect(result.reviews.map(r => r.model)).toEqual(['claude', 'deepseek']);
+    });
+
+    it('throws if insufficient reviews', async () => {
+      const adapters = [
+        { ...createMockAdapter('claude'), review: () => Promise.reject(new Error('fail')) },
+        { ...createMockAdapter('openai'), review: () => Promise.reject(new Error('fail')) },
+      ];
+
+      const engine = new ConsensusEngine(adapters, { requireMinimum: 2 });
+
+      await expect(engine.review('code')).rejects.toThrow('Insufficient reviews');
+    });
+  });
+
+  describe('calculateConsensus', () => {
+    it('calculates majority consensus', () => {
+      const reviews = [
+        { model: 'claude', issues: [{ id: 'A', severity: 'high' }] },
+        { model: 'openai', issues: [{ id: 'A', severity: 'high' }, { id: 'B', severity: 'low' }] },
+        { model: 'deepseek', issues: [{ id: 'A', severity: 'medium' }] },
+      ];
+
+      const consensus = ConsensusEngine.calculateConsensus(reviews, 'majority');
+
+      // Issue A flagged by all 3 - confidence 1.0
+      const issueA = consensus.issues.find(i => i.id === 'A');
+      expect(issueA.confidence).toBe(1.0);
+
+      // Issue B flagged by 1 of 3 - confidence 0.33
+      const issueB = consensus.issues.find(i => i.id === 'B');
+      expect(issueB.confidence).toBeCloseTo(0.33, 1);
+    });
+
+    it('uses unanimous consensus when configured', () => {
+      const reviews = [
+        { model: 'claude', issues: [{ id: 'A' }] },
+        { model: 'openai', issues: [{ id: 'A' }, { id: 'B' }] },
+        { model: 'deepseek', issues: [{ id: 'A' }] },
+      ];
+
+      const consensus = ConsensusEngine.calculateConsensus(reviews, 'unanimous');
+
+      // Only issue A is unanimous
+      expect(consensus.issues).toHaveLength(1);
+      expect(consensus.issues[0].id).toBe('A');
+    });
+
+    it('calculates total cost', () => {
+      const reviews = [
+        { model: 'claude', cost: 0 },
+        { model: 'openai', cost: 0.12 },
+        { model: 'deepseek', cost: 0.02 },
+      ];
+
+      const result = ConsensusEngine.summarizeCosts(reviews);
+
+      expect(result.total).toBeCloseTo(0.14, 2);
+      expect(result.byModel.openai).toBe(0.12);
+    });
+  });
+
+  describe('single model fallback', () => {
+    it('returns single-model consensus type', async () => {
+      const adapters = [createMockAdapter('claude')];
+
+      const engine = new ConsensusEngine(adapters, { requireMinimum: 1 });
+      const result = await engine.review('code');
+
+      expect(result.consensusType).toBe('single-model');
+    });
+  });
+});

package/server/lib/context-builder.js

@@ -0,0 +1,112 @@
+/**
+ * Context Builder - Build session context from memory
+ */
+
+const { loadTeamDecisions, loadTeamGotchas, loadPersonalPreferences, loadRecentSessions } = require('./memory-reader.js');
+
+/**
+ * Estimate token count from text (rough: ~4 chars per token)
+ * @param {string} text - Text to estimate
+ * @returns {number} Estimated token count
+ */
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Build session context from all memory sources
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Options
+ * @param {number} options.maxTokens - Maximum tokens for context
+ * @returns {Promise<string>} Formatted context for CLAUDE.md
+ */
+async function buildSessionContext(projectRoot, options = {}) {
+  const { maxTokens = 2000 } = options;
+
+  const sections = [];
+
+  // Load all memory
+  const [decisions, gotchas, preferences, sessions] = await Promise.all([
+    loadTeamDecisions(projectRoot),
+    loadTeamGotchas(projectRoot),
+    loadPersonalPreferences(projectRoot),
+    loadRecentSessions(projectRoot, 10),
+  ]);
+
+  // Check if any memory exists
+  const hasMemory = decisions.length > 0 ||
+    gotchas.length > 0 ||
+    Object.keys(preferences).length > 0 ||
+    sessions.length > 0;
+
+  if (!hasMemory) {
+    return '';
+  }
+
+  // Build preferences section
+  if (Object.keys(preferences).length > 0) {
+    const prefsLines = ['## Preferences', ''];
+    for (const [key, value] of Object.entries(preferences)) {
+      if (typeof value === 'object') {
+        prefsLines.push(`- **${key}:** ${JSON.stringify(value)}`);
+      } else {
+        prefsLines.push(`- **${key}:** ${value}`);
+      }
+    }
+    sections.push({ content: prefsLines.join('\n'), priority: 1 });
+  }
+
+  // Build decisions section (most recent first)
+  if (decisions.length > 0) {
+    const sortedDecisions = [...decisions].reverse();
+    const decisionLines = ['## Recent Decisions', ''];
+    for (const d of sortedDecisions.slice(0, 5)) {
+      decisionLines.push(`- **${d.title}**: ${d.reasoning?.substring(0, 100) || ''}`);
+    }
+    sections.push({ content: decisionLines.join('\n'), priority: 2 });
+  }
+
+  // Build gotchas section
+  if (gotchas.length > 0) {
+    const gotchaLines = ['## Gotchas', ''];
+    for (const g of gotchas.slice(0, 5)) {
+      gotchaLines.push(`- **${g.title}**: ${g.issue?.substring(0, 100) || ''}`);
+    }
+    sections.push({ content: gotchaLines.join('\n'), priority: 3 });
+  }
+
+  // Build recent activity section
+  if (sessions.length > 0) {
+    const activityLines = ['## Recent Activity', ''];
+    for (const s of sessions.slice(-5)) {
+      if (s.content) {
+        activityLines.push(`- ${s.type}: ${s.content}`);
+      }
+    }
+    if (activityLines.length > 2) {
+      sections.push({ content: activityLines.join('\n'), priority: 4 });
+    }
+  }
+
+  // Sort by priority and build final context
+  sections.sort((a, b) => a.priority - b.priority);
+
+  let context = '';
+  let currentTokens = 0;
+
+  for (const section of sections) {
+    const sectionTokens = estimateTokens(section.content);
+    if (currentTokens + sectionTokens <= maxTokens) {
+      context += section.content + '\n\n';
+      currentTokens += sectionTokens;
+    }
+  }
+
+  return context.trim();
+}
+
+module.exports = {
+  buildSessionContext,
+  estimateTokens,
+};

package/server/lib/context-builder.test.js

@@ -0,0 +1,120 @@
+import { describe, it, beforeEach, afterEach, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { buildSessionContext, estimateTokens } from './context-builder.js';
+import { initMemoryStructure } from './memory-storage.js';
+import { writeTeamDecision, writeTeamGotcha, writePersonalPreference, appendSessionLog } from './memory-writer.js';
+
+describe('context-builder', () => {
+  let testDir;
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-context-test-'));
+    await initMemoryStructure(testDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('buildSessionContext', () => {
+    it('returns empty context when no memory exists', async () => {
+      const context = await buildSessionContext(testDir);
+      expect(context).toBe('');
+    });
+
+    it('includes personal preferences', async () => {
+      await writePersonalPreference(testDir, 'codeStyle', 'functional');
+      await writePersonalPreference(testDir, 'exports', 'named');
+
+      const context = await buildSessionContext(testDir);
+
+      expect(context).toContain('functional');
+      expect(context).toContain('named');
+    });
+
+    it('includes team decisions', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Use Postgres',
+        reasoning: 'JSONB support',
+      });
+
+      const context = await buildSessionContext(testDir);
+
+      expect(context).toContain('Postgres');
+    });
+
+    it('includes team gotchas', async () => {
+      await writeTeamGotcha(testDir, {
+        title: 'Auth Warmup',
+        issue: 'Service needs 2 seconds',
+      });
+
+      const context = await buildSessionContext(testDir);
+
+      expect(context).toContain('Auth Warmup');
+    });
+
+    it('includes recent session activity', async () => {
+      await appendSessionLog(testDir, { type: 'decision', content: 'chose REST API' });
+
+      const context = await buildSessionContext(testDir);
+
+      expect(context).toContain('REST API');
+    });
+
+    it('limits context to token budget', async () => {
+      // Create lots of decisions
+      for (let i = 0; i < 50; i++) {
+        await writeTeamDecision(testDir, {
+          title: `Decision ${i}`,
+          reasoning: 'A'.repeat(200), // Long reasoning
+        });
+      }
+
+      const context = await buildSessionContext(testDir, { maxTokens: 500 });
+      const tokens = estimateTokens(context);
+
+      expect(tokens).toBeLessThanOrEqual(500);
+    });
+
+    it('formats context as markdown', async () => {
+      await writeTeamDecision(testDir, { title: 'Use Postgres', reasoning: 'JSONB' });
+      await writePersonalPreference(testDir, 'style', 'functional');
+
+      const context = await buildSessionContext(testDir);
+
+      expect(context).toContain('## ');
+      expect(context).toContain('- ');
+    });
+
+    it('prioritizes recent items', async () => {
+      await writeTeamDecision(testDir, { title: 'Old Decision', reasoning: 'old' });
+      // Simulate time passing
+      await new Promise(r => setTimeout(r, 10));
+      await writeTeamDecision(testDir, { title: 'New Decision', reasoning: 'new' });
+
+      const context = await buildSessionContext(testDir, { maxTokens: 100 });
+
+      // New decision should appear if space is limited
+      expect(context).toContain('New Decision');
+    });
+  });
+
+  describe('estimateTokens', () => {
+    it('estimates tokens from text', () => {
+      const text = 'Hello world this is a test';
+      const tokens = estimateTokens(text);
+
+      // Rough estimate: ~1 token per 4 chars
+      expect(tokens).toBeGreaterThan(0);
+      expect(tokens).toBeLessThan(text.length);
+    });
+
+    it('returns 0 for empty text', () => {
+      expect(estimateTokens('')).toBe(0);
+      expect(estimateTokens(null)).toBe(0);
+    });
+  });
+});