tlc-claude-code 1.7.0 → 1.8.0

package/server/lib/code-gate/multi-model-reviewer.test.js

@@ -0,0 +1,217 @@
+/**
+ * Multi-Model Reviewer Tests
+ *
+ * Sends code reviews to 2+ LLM models and aggregates findings.
+ * Different models catch different bugs.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  createMultiModelReviewer,
+  sendToModels,
+  aggregateFindings,
+  deduplicateFindings,
+  calculateConsensus,
+  mergeSummaries,
+} = require('./multi-model-reviewer.js');
+
+describe('Multi-Model Reviewer', () => {
+  describe('sendToModels', () => {
+    it('sends to multiple models in parallel', async () => {
+      const mockReviewFn = vi.fn()
+        .mockResolvedValueOnce({
+          findings: [{ severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Remove console' }],
+          summary: 'Model A review',
+        })
+        .mockResolvedValueOnce({
+          findings: [{ severity: 'warn', file: 'b.js', line: 5, rule: 'no-unused', message: 'Unused var' }],
+          summary: 'Model B review',
+        });
+
+      const results = await sendToModels('diff content', ['model-a', 'model-b'], {
+        reviewFn: mockReviewFn,
+      });
+
+      expect(mockReviewFn).toHaveBeenCalledTimes(2);
+      expect(results).toHaveLength(2);
+    });
+
+    it('falls back when one model fails', async () => {
+      const mockReviewFn = vi.fn()
+        .mockResolvedValueOnce({
+          findings: [{ severity: 'warn', file: 'a.js', line: 1, rule: 'test', message: 'Issue' }],
+          summary: 'Model A OK',
+        })
+        .mockRejectedValueOnce(new Error('Model B timeout'));
+
+      const results = await sendToModels('diff', ['model-a', 'model-b'], {
+        reviewFn: mockReviewFn,
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].model).toBe('model-a');
+    });
+
+    it('returns empty when all models fail', async () => {
+      const mockReviewFn = vi.fn()
+        .mockRejectedValueOnce(new Error('fail'))
+        .mockRejectedValueOnce(new Error('fail'));
+
+      const results = await sendToModels('diff', ['a', 'b'], {
+        reviewFn: mockReviewFn,
+      });
+
+      expect(results).toHaveLength(0);
+    });
+
+    it('single model mode still works', async () => {
+      const mockReviewFn = vi.fn().mockResolvedValue({
+        findings: [{ severity: 'block', file: 'x.js', line: 1, rule: 'sec', message: 'XSS' }],
+        summary: 'Single model review',
+      });
+
+      const results = await sendToModels('diff', ['only-model'], {
+        reviewFn: mockReviewFn,
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].findings).toHaveLength(1);
+    });
+
+    it('timeout applies per-model', async () => {
+      const mockReviewFn = vi.fn().mockImplementation((diff, model) => {
+        if (model === 'slow-model') {
+          return new Promise((resolve) => setTimeout(resolve, 10000));
+        }
+        return Promise.resolve({ findings: [], summary: 'OK' });
+      });
+
+      const results = await sendToModels('diff', ['fast-model', 'slow-model'], {
+        reviewFn: mockReviewFn,
+        timeout: 50,
+      });
+
+      // fast-model should succeed, slow-model should timeout
+      expect(results.some(r => r.model === 'fast-model')).toBe(true);
+    });
+  });
+
+  describe('aggregateFindings', () => {
+    it('aggregates findings from 2 models', () => {
+      const modelResults = [
+        {
+          model: 'model-a',
+          findings: [
+            { severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Console' },
+          ],
+          summary: 'A review',
+        },
+        {
+          model: 'model-b',
+          findings: [
+            { severity: 'block', file: 'b.js', line: 5, rule: 'security', message: 'XSS' },
+          ],
+          summary: 'B review',
+        },
+      ];
+
+      const result = aggregateFindings(modelResults);
+      expect(result.findings).toHaveLength(2);
+    });
+
+    it('tracks flaggedBy for each finding', () => {
+      const modelResults = [
+        {
+          model: 'model-a',
+          findings: [
+            { severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Console' },
+          ],
+        },
+        {
+          model: 'model-b',
+          findings: [
+            { severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Console log' },
+          ],
+        },
+      ];
+
+      const result = aggregateFindings(modelResults);
+      // Both flagged same file+line+rule, so should be deduplicated
+      const finding = result.findings.find(f => f.rule === 'no-console');
+      expect(finding.flaggedBy).toContain('model-a');
+      expect(finding.flaggedBy).toContain('model-b');
+    });
+
+    it('higher severity wins on conflict', () => {
+      const modelResults = [
+        {
+          model: 'model-a',
+          findings: [
+            { severity: 'warn', file: 'a.js', line: 1, rule: 'test-rule', message: 'Issue' },
+          ],
+        },
+        {
+          model: 'model-b',
+          findings: [
+            { severity: 'block', file: 'a.js', line: 1, rule: 'test-rule', message: 'Serious issue' },
+          ],
+        },
+      ];
+
+      const result = aggregateFindings(modelResults);
+      const finding = result.findings.find(f => f.rule === 'test-rule');
+      expect(finding.severity).toBe('block');
+    });
+  });
+
+  describe('deduplicateFindings', () => {
+    it('deduplicates identical findings by file+line+rule', () => {
+      const findings = [
+        { severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Console', flaggedBy: ['model-a'] },
+        { severity: 'warn', file: 'a.js', line: 1, rule: 'no-console', message: 'Console log', flaggedBy: ['model-b'] },
+      ];
+
+      const deduped = deduplicateFindings(findings);
+      expect(deduped).toHaveLength(1);
+      expect(deduped[0].flaggedBy).toContain('model-a');
+      expect(deduped[0].flaggedBy).toContain('model-b');
+    });
+  });
+
+  describe('calculateConsensus', () => {
+    it('calculates consensus percentage', () => {
+      const finding = { flaggedBy: ['model-a', 'model-b'] };
+      const totalModels = 3;
+
+      const consensus = calculateConsensus(finding, totalModels);
+      // 2/3 = ~66.7%
+      expect(consensus).toBeCloseTo(66.7, 0);
+    });
+  });
+
+  describe('mergeSummaries', () => {
+    it('merges summaries from all models', () => {
+      const modelResults = [
+        { model: 'model-a', summary: 'Found 1 issue' },
+        { model: 'model-b', summary: 'Code looks mostly clean' },
+      ];
+
+      const merged = mergeSummaries(modelResults);
+      expect(merged).toContain('model-a');
+      expect(merged).toContain('model-b');
+      expect(merged).toContain('Found 1 issue');
+      expect(merged).toContain('Code looks mostly clean');
+    });
+  });
+
+  describe('createMultiModelReviewer', () => {
+    it('respects model list from config', () => {
+      const reviewer = createMultiModelReviewer({
+        models: ['gpt-4', 'claude-3'],
+        reviewFn: vi.fn(),
+      });
+      expect(reviewer).toBeDefined();
+      expect(reviewer.models).toEqual(['gpt-4', 'claude-3']);
+    });
+  });
+});

package/server/lib/infra/infra-generator.js

@@ -0,0 +1,331 @@
+/**
+ * Infrastructure Blueprint Generator
+ *
+ * Generates Docker dev environment with observability stack
+ * (Prometheus, Grafana, MailHog, MinIO, pgAdmin) from selectable services.
+ *
+ * @module infra/infra-generator
+ */
+
+/** Available infrastructure services */
+const AVAILABLE_SERVICES = [
+  'postgres', 'redis', 'prometheus', 'grafana', 'mailhog', 'minio', 'pgadmin',
+];
+
+/** Default ports for each service */
+const DEFAULT_PORTS = {
+  postgres: 5432,
+  redis: 6379,
+  prometheus: 9090,
+  grafana: 3000,
+  mailhog: 8025,
+  minio: 9000,
+  pgadmin: 5050,
+};
+
+/** Network assignments per service */
+const SERVICE_NETWORKS = {
+  postgres: ['app', 'storage'],
+  redis: ['app'],
+  prometheus: ['monitoring'],
+  grafana: ['monitoring'],
+  mailhog: ['app'],
+  minio: ['app', 'storage'],
+  pgadmin: ['app', 'storage'],
+};
+
+/** Dollar sign helper for template literals */
+const D = '$';
+
+/**
+ * Generate service YAML block
+ * @param {string} service - Service name
+ * @param {Object} ports - Port overrides
+ * @returns {string} YAML block for the service
+ */
+function generateServiceBlock(service, ports = {}) {
+  const port = ports[service] || DEFAULT_PORTS[service];
+  const networks = SERVICE_NETWORKS[service] || ['app'];
+  const networkYaml = networks.map(n => '        - ' + n).join('\n');
+
+  const lines = [];
+
+  switch (service) {
+    case 'postgres':
+      lines.push(
+        '    postgres:',
+        '      image: postgres:16-alpine',
+        '      ports:',
+        '        - "' + port + ':5432"',
+        '      environment:',
+        '        POSTGRES_USER: ' + D + '{POSTGRES_USER:-app}',
+        '        POSTGRES_PASSWORD: ' + D + '{POSTGRES_PASSWORD:-secret}',
+        '        POSTGRES_DB: ' + D + '{POSTGRES_DB:-app_dev}',
+        '      volumes:',
+        '        - postgres_data:/var/lib/postgresql/data',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD-SHELL", "pg_isready -U ' + D + D + '{POSTGRES_USER:-app}"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'redis':
+      lines.push(
+        '    redis:',
+        '      image: redis:7-alpine',
+        '      ports:',
+        '        - "' + port + ':6379"',
+        '      volumes:',
+        '        - redis_data:/data',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "redis-cli", "ping"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'prometheus':
+      lines.push(
+        '    prometheus:',
+        '      image: prom/prometheus:latest',
+        '      ports:',
+        '        - "' + port + ':9090"',
+        '      volumes:',
+        '        - prometheus_data:/prometheus',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "wget", "--spider", "-q", "http://localhost:9090/-/healthy"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'grafana':
+      lines.push(
+        '    grafana:',
+        '      image: grafana/grafana:latest',
+        '      ports:',
+        '        - "' + port + ':3000"',
+        '      environment:',
+        '        GF_SECURITY_ADMIN_PASSWORD: ' + D + '{GRAFANA_PASSWORD:-admin}',
+        '        GF_DATASOURCES_DEFAULT_NAME: prometheus',
+        '        GF_DATASOURCES_DEFAULT_TYPE: prometheus',
+        '        GF_DATASOURCES_DEFAULT_URL: http://prometheus:9090',
+        '      volumes:',
+        '        - grafana_data:/var/lib/grafana',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "wget", "--spider", "-q", "http://localhost:3000/api/health"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'mailhog':
+      lines.push(
+        '    mailhog:',
+        '      image: mailhog/mailhog:latest',
+        '      ports:',
+        '        - "' + port + ':8025"',
+        '        - "1025:1025"',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "wget", "--spider", "-q", "http://localhost:8025"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'minio':
+      lines.push(
+        '    minio:',
+        '      image: minio/minio:latest',
+        '      ports:',
+        '        - "' + port + ':9000"',
+        '        - "9001:9001"',
+        '      environment:',
+        '        MINIO_ROOT_USER: ' + D + '{MINIO_ROOT_USER:-minioadmin}',
+        '        MINIO_ROOT_PASSWORD: ' + D + '{MINIO_ROOT_PASSWORD:-minioadmin}',
+        '      command: server /data --console-address ":9001"',
+        '      volumes:',
+        '        - minio_data:/data',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "mc", "ready", "local"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+
+    case 'pgadmin':
+      lines.push(
+        '    pgadmin:',
+        '      image: dpage/pgadmin4:latest',
+        '      ports:',
+        '        - "' + port + ':80"',
+        '      environment:',
+        '        PGADMIN_DEFAULT_EMAIL: ' + D + '{PGADMIN_DEFAULT_EMAIL:-admin@local.dev}',
+        '        PGADMIN_DEFAULT_PASSWORD: ' + D + '{PGADMIN_DEFAULT_PASSWORD:-admin}',
+        '      volumes:',
+        '        - pgadmin_data:/var/lib/pgadmin',
+        '      networks:',
+        networkYaml,
+        '      healthcheck:',
+        '        test: ["CMD", "wget", "--spider", "-q", "http://localhost:80/misc/ping"]',
+        '        interval: 10s',
+        '        timeout: 5s',
+        '        retries: 5'
+      );
+      break;
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate volume definition with explicit name
+ * @param {string} service - Service name
+ * @returns {string} Volume YAML with name property
+ */
+function generateVolumeBlock(service) {
+  const volumeName = service + '_data';
+  return '    ' + volumeName + ':\n      name: ' + volumeName;
+}
+
+/**
+ * Get unique networks needed for selected services
+ * @param {string[]} services - Selected services
+ * @returns {string[]} Unique network names
+ */
+function getRequiredNetworks(services) {
+  const networks = new Set();
+  for (const service of services) {
+    const serviceNets = SERVICE_NETWORKS[service] || ['app'];
+    for (const net of serviceNets) {
+      networks.add(net);
+    }
+  }
+  return Array.from(networks);
+}
+
+/**
+ * Generate docker-compose.yml content
+ * @param {Object} options - Generation options
+ * @param {string[]} options.services - Services to include
+ * @param {Object} options.ports - Port overrides
+ * @returns {Object} { content, filename }
+ */
+function generateDockerCompose(options = {}) {
+  const { services = [], ports = {} } = options;
+
+  let content = 'version: "3.8"\n\nservices:\n';
+
+  if (services.length === 0) {
+    content += '    # No services selected\n';
+  } else {
+    const blocks = services
+      .filter(s => AVAILABLE_SERVICES.includes(s))
+      .map(s => generateServiceBlock(s, ports));
+    content += blocks.join('\n\n') + '\n';
+  }
+
+  // Volumes section
+  if (services.length > 0) {
+    content += '\nvolumes:\n';
+    for (const service of services) {
+      if (AVAILABLE_SERVICES.includes(service)) {
+        content += generateVolumeBlock(service) + '\n';
+      }
+    }
+  }
+
+  // Networks section
+  const networks = getRequiredNetworks(services);
+  if (networks.length > 0) {
+    content += '\nnetworks:\n';
+    for (const net of networks) {
+      content += '    ' + net + ':\n      name: ' + net + '\n';
+    }
+  }
+
+  return {
+    content,
+    filename: 'docker-compose.dev.yml',
+  };
+}
+
+/**
+ * Generate .env.example file content
+ * @param {Object} options - Generation options
+ * @param {string[]} options.services - Services to include
+ * @returns {Object} { content, filename }
+ */
+function generateEnvExample(options = {}) {
+  const { services = [] } = options;
+  const lines = ['# Infrastructure Environment Variables', ''];
+
+  const envVars = {
+    postgres: [
+      'POSTGRES_USER=app',
+      'POSTGRES_PASSWORD=secret',
+      'POSTGRES_DB=app_dev',
+    ],
+    redis: [
+      'REDIS_URL=redis://localhost:6379',
+    ],
+    prometheus: [
+      'PROMETHEUS_URL=http://localhost:9090',
+    ],
+    grafana: [
+      'GRAFANA_PASSWORD=admin',
+    ],
+    mailhog: [
+      'SMTP_HOST=localhost',
+      'SMTP_PORT=1025',
+    ],
+    minio: [
+      'MINIO_ROOT_USER=minioadmin',
+      'MINIO_ROOT_PASSWORD=minioadmin',
+      'MINIO_ENDPOINT=http://localhost:9000',
+    ],
+    pgadmin: [
+      'PGADMIN_DEFAULT_EMAIL=admin@local.dev',
+      'PGADMIN_DEFAULT_PASSWORD=admin',
+    ],
+  };
+
+  for (const service of services) {
+    const vars = envVars[service];
+    if (vars) {
+      lines.push('# ' + service.charAt(0).toUpperCase() + service.slice(1));
+      lines.push(...vars);
+      lines.push('');
+    }
+  }
+
+  return {
+    content: lines.join('\n'),
+    filename: '.env.example',
+  };
+}
+
+module.exports = {
+  generateDockerCompose,
+  generateEnvExample,
+  AVAILABLE_SERVICES,
+};

package/server/lib/infra/infra-generator.test.js

@@ -0,0 +1,146 @@
+/**
+ * Infrastructure Blueprint Generator Tests
+ *
+ * Generates Docker dev environment with observability stack.
+ */
+import { describe, it, expect } from 'vitest';
+
+const {
+  generateDockerCompose,
+  generateEnvExample,
+  AVAILABLE_SERVICES,
+} = require('./infra-generator.js');
+
+describe('Infrastructure Blueprint Generator', () => {
+  describe('generateDockerCompose', () => {
+    it('generates docker-compose with postgres', () => {
+      const result = generateDockerCompose({ services: ['postgres'] });
+
+      expect(result.content).toContain('postgres');
+      expect(result.content).toContain('image:');
+      expect(result.content).toContain('volumes:');
+    });
+
+    it('generates docker-compose with full observability stack', () => {
+      const result = generateDockerCompose({
+        services: ['postgres', 'redis', 'prometheus', 'grafana', 'mailhog', 'minio', 'pgadmin'],
+      });
+
+      expect(result.content).toContain('postgres');
+      expect(result.content).toContain('redis');
+      expect(result.content).toContain('prometheus');
+      expect(result.content).toContain('grafana');
+      expect(result.content).toContain('mailhog');
+      expect(result.content).toContain('minio');
+      expect(result.content).toContain('pgadmin');
+    });
+
+    it('each volume has explicit name property', () => {
+      const result = generateDockerCompose({
+        services: ['postgres', 'redis'],
+      });
+
+      // Parse volumes section - every volume should have name: property
+      const volumesSection = result.content.split('volumes:').pop();
+      // Check that volume definitions include name:
+      expect(volumesSection).toContain('name:');
+    });
+
+    it('no external: true in any volume', () => {
+      const result = generateDockerCompose({
+        services: ['postgres', 'redis', 'prometheus', 'grafana'],
+      });
+
+      expect(result.content).not.toContain('external: true');
+      expect(result.content).not.toContain('external:true');
+    });
+
+    it('services on correct networks', () => {
+      const result = generateDockerCompose({
+        services: ['postgres', 'prometheus', 'minio'],
+      });
+
+      expect(result.content).toContain('app');
+      expect(result.content).toContain('monitoring');
+      expect(result.content).toContain('storage');
+    });
+
+    it('health checks present for each service', () => {
+      const services = ['postgres', 'redis', 'prometheus', 'grafana', 'mailhog', 'minio', 'pgadmin'];
+      const result = generateDockerCompose({ services });
+
+      // Count healthcheck occurrences - should be at least one per service
+      const healthcheckCount = (result.content.match(/healthcheck:/g) || []).length;
+      expect(healthcheckCount).toBe(services.length);
+    });
+
+    it('ports configurable via options', () => {
+      const result = generateDockerCompose({
+        services: ['postgres'],
+        ports: { postgres: 5555 },
+      });
+
+      expect(result.content).toContain('5555');
+    });
+
+    it('includes pgAdmin with connection pre-configured', () => {
+      const result = generateDockerCompose({
+        services: ['postgres', 'pgadmin'],
+      });
+
+      expect(result.content).toContain('pgadmin');
+      expect(result.content).toContain('PGADMIN_DEFAULT_EMAIL');
+    });
+
+    it('includes Grafana with Prometheus datasource', () => {
+      const result = generateDockerCompose({
+        services: ['prometheus', 'grafana'],
+      });
+
+      expect(result.content).toContain('grafana');
+      expect(result.content).toContain('prometheus');
+    });
+
+    it('empty service list returns minimal compose', () => {
+      const result = generateDockerCompose({ services: [] });
+
+      expect(result.content).toContain('version:');
+      expect(result.content).toContain('services:');
+    });
+
+    it('returns structured output (not writes files)', () => {
+      const result = generateDockerCompose({
+        services: ['postgres'],
+      });
+
+      expect(result).toMatchObject({
+        content: expect.any(String),
+        filename: expect.any(String),
+      });
+    });
+  });
+
+  describe('generateEnvExample', () => {
+    it('generates .env.example with all vars', () => {
+      const result = generateEnvExample({
+        services: ['postgres', 'redis', 'minio'],
+      });
+
+      expect(result.content).toContain('POSTGRES');
+      expect(result.content).toContain('REDIS');
+      expect(result.content).toContain('MINIO');
+    });
+  });
+
+  describe('AVAILABLE_SERVICES', () => {
+    it('lists all expected services', () => {
+      expect(AVAILABLE_SERVICES).toContain('postgres');
+      expect(AVAILABLE_SERVICES).toContain('redis');
+      expect(AVAILABLE_SERVICES).toContain('prometheus');
+      expect(AVAILABLE_SERVICES).toContain('grafana');
+      expect(AVAILABLE_SERVICES).toContain('mailhog');
+      expect(AVAILABLE_SERVICES).toContain('minio');
+      expect(AVAILABLE_SERVICES).toContain('pgadmin');
+    });
+  });
+});