tlc-claude-code 2.0.1 → 2.2.0

package/server/lib/memory-store-adapter.test.js

@@ -0,0 +1,141 @@
+/**
+ * @file memory-store-adapter.test.js
+ * @description Tests for the file-based memory store adapter.
+ *
+ * The adapter reads decisions and gotchas from .tlc/memory/team/ markdown
+ * files on disk. Returns empty arrays when directories don't exist.
+ */
+import { describe, it, beforeEach, expect, vi } from 'vitest';
+
+const { createMemoryStoreAdapter } = await import('./memory-store-adapter.js');
+
+describe('memory-store-adapter', () => {
+  let mockFs;
+
+  beforeEach(() => {
+    mockFs = {
+      existsSync: vi.fn().mockReturnValue(false),
+      readdirSync: vi.fn().mockReturnValue([]),
+      readFileSync: vi.fn().mockReturnValue(''),
+    };
+  });
+
+  describe('createMemoryStoreAdapter', () => {
+    it('returns an object with listDecisions, listGotchas, getStats', () => {
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      expect(adapter).toHaveProperty('listDecisions');
+      expect(adapter).toHaveProperty('listGotchas');
+      expect(adapter).toHaveProperty('getStats');
+      expect(typeof adapter.listDecisions).toBe('function');
+      expect(typeof adapter.listGotchas).toBe('function');
+      expect(typeof adapter.getStats).toBe('function');
+    });
+  });
+
+  describe('listDecisions', () => {
+    it('returns empty array when decisions directory does not exist', async () => {
+      mockFs.existsSync.mockReturnValue(false);
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listDecisions();
+      expect(result).toEqual([]);
+    });
+
+    it('reads markdown files from decisions directory', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync.mockReturnValue(['001-use-postgres.md', '002-rest-api.md']);
+      mockFs.readFileSync
+        .mockReturnValueOnce('# Use Postgres\n\nWe chose Postgres for the database.\n\n**Date:** 2026-01-20\n**Status:** accepted')
+        .mockReturnValueOnce('# REST over GraphQL\n\nREST is simpler for our use case.\n\n**Date:** 2026-01-22\n**Status:** accepted');
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listDecisions();
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toHaveProperty('title', 'Use Postgres');
+      expect(result[0]).toHaveProperty('content');
+      expect(result[1]).toHaveProperty('title', 'REST over GraphQL');
+    });
+
+    it('handles malformed markdown gracefully', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync.mockReturnValue(['bad.md']);
+      mockFs.readFileSync.mockReturnValue('no heading here just text');
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listDecisions();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toHaveProperty('title');
+    });
+
+    it('skips non-markdown files', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync.mockReturnValue(['decision.md', 'notes.txt', '.DS_Store']);
+      mockFs.readFileSync.mockReturnValue('# A Decision\n\nContent here');
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listDecisions();
+
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe('listGotchas', () => {
+    it('returns empty array when gotchas directory does not exist', async () => {
+      mockFs.existsSync.mockReturnValue(false);
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listGotchas();
+      expect(result).toEqual([]);
+    });
+
+    it('reads markdown files from gotchas directory', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync.mockReturnValue(['001-cold-starts.md']);
+      mockFs.readFileSync.mockReturnValue('# Cold Start Delay\n\nLambda cold starts cause 2s delay.\n\n**Severity:** high');
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listGotchas();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toHaveProperty('title', 'Cold Start Delay');
+      expect(result[0]).toHaveProperty('content');
+    });
+
+    it('handles read errors gracefully', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync.mockReturnValue(['broken.md']);
+      mockFs.readFileSync.mockImplementation(() => { throw new Error('EACCES'); });
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const result = await adapter.listGotchas();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getStats', () => {
+    it('returns zero counts when no directories exist', async () => {
+      mockFs.existsSync.mockReturnValue(false);
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const stats = await adapter.getStats();
+
+      expect(stats).toHaveProperty('decisions', 0);
+      expect(stats).toHaveProperty('gotchas', 0);
+      expect(stats).toHaveProperty('total', 0);
+    });
+
+    it('returns file counts from both directories', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readdirSync
+        .mockReturnValueOnce(['d1.md', 'd2.md', 'd3.md'])
+        .mockReturnValueOnce(['g1.md']);
+
+      const adapter = createMemoryStoreAdapter('/fake/project', { fs: mockFs });
+      const stats = await adapter.getStats();
+
+      expect(stats.decisions).toBe(3);
+      expect(stats.gotchas).toBe(1);
+      expect(stats.total).toBe(4);
+    });
+  });
+});

package/server/lib/memory-wiring-e2e.test.js

@@ -0,0 +1,93 @@
+/**
+ * Memory wiring E2E tests - Phase 84 Task 4
+ *
+ * Proves the full memory loop: exchange → observeAndRemember → file written → adapter reads back.
+ * This is the definitive test that memory actually works end-to-end.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+import { observeAndRemember } from './memory-observer.js';
+import { createMemoryStoreAdapter } from './memory-store-adapter.js';
+
+describe('memory wiring e2e', () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-wiring-e2e-'));
+    // Create full memory directory structure
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', 'team', 'decisions'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', 'team', 'gotchas'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', '.local', 'preferences'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', '.local', 'sessions'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, '.tlc.json'), JSON.stringify({ project: 'wiring-test' }));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('decision exchange → file created → adapter reads it back', async () => {
+    const exchange = {
+      user: "let's use PostgreSQL instead of MySQL for better JSONB support.",
+      assistant: 'Good choice. PostgreSQL has excellent JSONB support.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Adapter reads it back
+    const adapter = createMemoryStoreAdapter(testDir);
+    const decisions = await adapter.listDecisions();
+    expect(decisions.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('gotcha exchange → file created → adapter reads it back', async () => {
+    const exchange = {
+      user: 'watch out for the SQLite WAL mode issue under concurrent writes.',
+      assistant: 'Noted. Serialize database operations to avoid corruption.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    const adapter = createMemoryStoreAdapter(testDir);
+    const gotchas = await adapter.listGotchas();
+    expect(gotchas.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('stats reflect actual file counts', async () => {
+    // Write a decision
+    const exchange = {
+      user: "we decided to use Redis as our caching layer instead of Memcached.",
+      assistant: 'Redis is more versatile for caching.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    const adapter = createMemoryStoreAdapter(testDir);
+    const stats = await adapter.getStats();
+    expect(stats.decisions).toBeGreaterThanOrEqual(1);
+    expect(stats.total).toBeGreaterThanOrEqual(1);
+  });
+
+  it('empty project returns empty arrays without crashing', async () => {
+    const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-empty-'));
+    fs.writeFileSync(path.join(emptyDir, '.tlc.json'), JSON.stringify({ project: 'empty' }));
+
+    const adapter = createMemoryStoreAdapter(emptyDir);
+    const decisions = await adapter.listDecisions();
+    const gotchas = await adapter.listGotchas();
+    const stats = await adapter.getStats();
+
+    expect(decisions).toEqual([]);
+    expect(gotchas).toEqual([]);
+    expect(stats.total).toBe(0);
+
+    fs.rmSync(emptyDir, { recursive: true, force: true });
+  });
+});

package/server/lib/nginx-config.js

@@ -0,0 +1,114 @@
+/**
+ * Nginx Config Generator — server blocks, wildcard routing, SSL
+ * Phase 80 Task 5 (replaces caddy-config.js)
+ */
+
+const { isValidDomain } = require('./input-sanitizer.js');
+
+/**
+ * Generate Nginx site config for a project
+ * @param {Object} options
+ * @param {string} options.domain - Server domain
+ * @param {number} options.port - App port
+ * @param {string} options.proxyPass - Upstream URL
+ * @returns {string} Nginx config
+ */
+function generateSiteConfig({ domain, port, proxyPass }) {
+  if (!isValidDomain(domain)) throw new Error(`Invalid domain: ${domain}`);
+  return `# TLC generated Nginx config for ${domain}
+server {
+    listen 80;
+    server_name ${domain};
+
+    location / {
+        proxy_pass ${proxyPass};
+
+        # Proxy headers
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # WebSocket support
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        # Timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+}
+`;
+}
+
+/**
+ * Generate wildcard Nginx config for branch previews
+ * @param {string} baseDomain - Base domain (e.g. myapp.dev)
+ * @param {Object} options
+ * @param {Array} [options.branches] - [{ subdomain, port }]
+ * @returns {string} Nginx config
+ */
+function generateWildcardConfig(baseDomain, options = {}) {
+  if (!isValidDomain(baseDomain)) throw new Error(`Invalid domain: ${baseDomain}`);
+  const branches = options.branches || [];
+
+  // Map blocks for each branch
+  const mapEntries = branches
+    .map(b => `        ${b.subdomain}.${baseDomain} 127.0.0.1:${b.port};`)
+    .join('\n');
+
+  return `# TLC wildcard config for *.${baseDomain}
+
+map $host $branch_upstream {
+    default "";
+${mapEntries}
+}
+
+# Default server for unknown subdomains
+server {
+    listen 80 default_server;
+    server_name *.${baseDomain};
+
+    location / {
+        if ($branch_upstream = "") {
+            return 404 "No deployment for this branch";
+        }
+        proxy_pass http://$branch_upstream;
+
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+`;
+}
+
+/**
+ * Generate SSL config snippet for a domain
+ * @param {string} domain
+ * @returns {string} SSL config lines
+ */
+function generateSslConfig(domain) {
+  if (!isValidDomain(domain)) throw new Error(`Invalid domain: ${domain}`);
+  return `    # SSL Configuration for ${domain}
+    listen 443 ssl;
+    ssl_certificate /etc/letsencrypt/live/${domain}/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/${domain}/privkey.pem;
+
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_prefer_server_ciphers on;
+    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
+
+    # HSTS
+    add_header Strict-Transport-Security "max-age=63072000" always;
+`;
+}
+
+module.exports = { generateSiteConfig, generateWildcardConfig, generateSslConfig };

package/server/lib/nginx-config.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+
+const { generateSiteConfig, generateWildcardConfig, generateSslConfig } = await import('./nginx-config.js');
+
+describe('Nginx Config Generator', () => {
+  describe('generateSiteConfig', () => {
+    it('produces valid Nginx server block', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('server {');
+      expect(config).toContain('server_name myapp.dev');
+      expect(config).toContain('proxy_pass http://127.0.0.1:3000');
+    });
+
+    it('includes proxy headers', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('proxy_set_header Host');
+      expect(config).toContain('proxy_set_header X-Real-IP');
+      expect(config).toContain('proxy_set_header X-Forwarded-For');
+    });
+
+    it('includes WebSocket upgrade headers', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('proxy_http_version 1.1');
+      expect(config).toContain('Upgrade');
+      expect(config).toContain('Connection');
+    });
+
+    it('listens on port 80 by default', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('listen 80');
+    });
+  });
+
+  describe('generateWildcardConfig', () => {
+    it('routes subdomains to container ports', () => {
+      const config = generateWildcardConfig('myapp.dev', {
+        branches: [
+          { subdomain: 'feat-login', port: 4001 },
+          { subdomain: 'main', port: 4000 },
+        ],
+      });
+      expect(config).toContain('*.myapp.dev');
+      expect(config).toContain('feat-login');
+      expect(config).toContain('4001');
+    });
+
+    it('includes default server for unknown subdomains', () => {
+      const config = generateWildcardConfig('myapp.dev', { branches: [] });
+      expect(config).toContain('default_server');
+    });
+  });
+
+  describe('generateSslConfig', () => {
+    it('references Lets Encrypt certificate paths', () => {
+      const config = generateSslConfig('myapp.dev');
+      expect(config).toContain('ssl_certificate');
+      expect(config).toContain('/etc/letsencrypt');
+      expect(config).toContain('myapp.dev');
+    });
+
+    it('includes SSL security settings', () => {
+      const config = generateSslConfig('myapp.dev');
+      expect(config).toContain('ssl_protocols');
+    });
+  });
+});

package/server/lib/ollama-health.js

@@ -0,0 +1,91 @@
+/**
+ * Ollama health checker.
+ *
+ * Checks whether Ollama is installed, running, and has the required
+ * embedding model. Returns actionable messages for each failure state.
+ * Results are cached for 60 seconds.
+ *
+ * @module ollama-health
+ */
+
+const OLLAMA_URL = process.env.OLLAMA_URL || 'http://localhost:11434';
+const REQUIRED_MODEL = 'mxbai-embed-large';
+const CACHE_TTL_MS = 60 * 1000;
+
+/** @enum {string} */
+const OLLAMA_STATUS = {
+  READY: 'ready',
+  NOT_INSTALLED: 'not_installed',
+  NOT_RUNNING: 'not_running',
+  NO_MODEL: 'no_model',
+};
+
+let cachedResult = null;
+let cachedAt = 0;
+
+/**
+ * Check Ollama health status.
+ *
+ * @param {object} [deps] - Injectable dependencies for testing
+ * @param {Function} [deps.fetch] - Fetch implementation
+ * @returns {Promise<{status: string, message: string, action: string}>}
+ */
+async function checkOllamaHealth(deps = {}) {
+  const now = Date.now();
+  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
+    return cachedResult;
+  }
+
+  const fetchFn = deps.fetch || globalThis.fetch;
+
+  try {
+    const response = await fetchFn(`${OLLAMA_URL}/api/tags`, {
+      signal: AbortSignal.timeout(3000),
+    });
+
+    if (!response.ok) {
+      cachedResult = {
+        status: OLLAMA_STATUS.NOT_RUNNING,
+        message: 'Ollama responded with an error',
+        action: 'Restart Ollama: ollama serve',
+      };
+      cachedAt = now;
+      return cachedResult;
+    }
+
+    const data = await response.json();
+    const models = data.models || [];
+    const hasModel = models.some(m => m.name && m.name.startsWith(REQUIRED_MODEL));
+
+    if (hasModel) {
+      cachedResult = {
+        status: OLLAMA_STATUS.READY,
+        message: 'Memory: full (pattern detection + semantic search)',
+        action: '',
+      };
+    } else {
+      cachedResult = {
+        status: OLLAMA_STATUS.NO_MODEL,
+        message: `Ollama running but ${REQUIRED_MODEL} model not found`,
+        action: `ollama pull ${REQUIRED_MODEL}`,
+      };
+    }
+  } catch {
+    cachedResult = {
+      status: OLLAMA_STATUS.NOT_RUNNING,
+      message: 'Ollama not running. Semantic search disabled, pattern detection still works.',
+      action: 'brew install ollama && ollama serve && ollama pull mxbai-embed-large',
+    };
+  }
+
+  cachedAt = now;
+  return cachedResult;
+}
+
+/** Clear the cache (for testing). */
+checkOllamaHealth._clearCache = function () {
+  cachedResult = null;
+  cachedAt = 0;
+};
+
+module.exports = { checkOllamaHealth, OLLAMA_STATUS };

package/server/lib/ollama-health.test.js

@@ -0,0 +1,74 @@
+/**
+ * Ollama health checker tests - Phase 84 Task 1
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { checkOllamaHealth, OLLAMA_STATUS } from './ollama-health.js';
+
+describe('ollama-health', () => {
+  beforeEach(() => {
+    // Clear cache between tests
+    checkOllamaHealth._clearCache?.();
+  });
+
+  it('returns ready when Ollama responds with correct model', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'mxbai-embed-large:latest' }] }),
+    });
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.status).toBe(OLLAMA_STATUS.READY);
+    expect(result.message).toContain('full');
+  });
+
+  it('returns not_running when connection refused', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect([OLLAMA_STATUS.NOT_INSTALLED, OLLAMA_STATUS.NOT_RUNNING]).toContain(result.status);
+    expect(result.action).toBeDefined();
+  });
+
+  it('returns no_model when Ollama responds but model missing', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'llama3:latest' }] }),
+    });
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.status).toBe(OLLAMA_STATUS.NO_MODEL);
+    expect(result.action).toContain('ollama pull');
+  });
+
+  it('caches result within 60s window', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'mxbai-embed-large:latest' }] }),
+    });
+
+    const result1 = await checkOllamaHealth({ fetch: mockFetch });
+    const result2 = await checkOllamaHealth({ fetch: mockFetch });
+
+    expect(result1.status).toBe(result2.status);
+    // Should only call fetch once due to caching
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns actionable message for each status', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.action).toBeTruthy();
+    expect(typeof result.action).toBe('string');
+    expect(result.message).toBeTruthy();
+  });
+
+  it('exports status constants', () => {
+    expect(OLLAMA_STATUS.READY).toBe('ready');
+    expect(OLLAMA_STATUS.NOT_INSTALLED).toBe('not_installed');
+    expect(OLLAMA_STATUS.NOT_RUNNING).toBe('not_running');
+    expect(OLLAMA_STATUS.NO_MODEL).toBe('no_model');
+  });
+});