tlc-claude-code 1.8.5 → 2.1.0

package/server/lib/memory-api.test.js

@@ -0,0 +1,320 @@
+/**
+ * @file memory-api.test.js
+ * @description Tests for the Memory API endpoint handlers.
+ *
+ * Tests the factory function `createMemoryApi(deps)` which accepts injected
+ * dependencies (semanticRecall, vectorIndexer, richCapture, embeddingClient,
+ * memoryStore) and returns handler functions for memory-related HTTP endpoints.
+ *
+ * All handlers accept Express-compatible (req, res) objects and are async.
+ * Tests mock the dependencies and req/res objects directly — no Express
+ * routing is tested here.
+ */
+import { describe, it, beforeEach, expect, vi } from 'vitest';
+
+const { createMemoryApi } = await import('./memory-api.js');
+
+/**
+ * Creates a mock Express request object.
+ * @param {object} overrides - Properties to merge into the base request
+ * @returns {{ query: object, params: object, body: object }}
+ */
+function createMockReq(overrides = {}) {
+  return { query: {}, params: {}, body: {}, ...overrides };
+}
+
+/**
+ * Creates a mock Express response object with spy methods.
+ * Provides helper accessors `_getJson()` and `_getStatus()` to inspect
+ * the first call to `res.json()` and `res.status()` respectively.
+ * @returns {object} Mock response with status/json spies
+ */
+function createMockRes() {
+  const res = {
+    status: vi.fn().mockReturnThis(),
+    json: vi.fn().mockReturnThis(),
+    _getJson() { return res.json.mock.calls[0]?.[0]; },
+    _getStatus() { return res.status.mock.calls[0]?.[0]; },
+  };
+  return res;
+}
+
+/**
+ * Creates a full set of mock dependencies for createMemoryApi.
+ * Each dependency method is a vi.fn() returning a resolved promise.
+ * @returns {object} Mock deps: semanticRecall, vectorIndexer, richCapture, embeddingClient, memoryStore
+ */
+function createMockDeps() {
+  return {
+    semanticRecall: {
+      recall: vi.fn().mockResolvedValue([]),
+    },
+    vectorIndexer: {
+      indexAll: vi.fn().mockResolvedValue({ indexed: 0 }),
+    },
+    richCapture: {
+      processChunk: vi.fn().mockResolvedValue({ stored: true }),
+    },
+    embeddingClient: {
+      embed: vi.fn().mockResolvedValue([0.1, 0.2, 0.3]),
+    },
+    memoryStore: {
+      listConversations: vi.fn().mockResolvedValue({ items: [], total: 0 }),
+      getConversation: vi.fn().mockResolvedValue(null),
+      listDecisions: vi.fn().mockResolvedValue([]),
+      listGotchas: vi.fn().mockResolvedValue([]),
+      getStats: vi.fn().mockResolvedValue({ count: 0, size: 0 }),
+    },
+  };
+}
+
+describe('memory-api', () => {
+  let api;
+  let deps;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    api = createMemoryApi(deps);
+  });
+
+  describe('handleSearch', () => {
+    it('search endpoint returns semantic results', async () => {
+      const mockResults = [
+        { id: 'r1', text: 'Use JWT for auth', score: 0.92, type: 'decision', date: '2026-01-15', source: 'session', permanent: false },
+        { id: 'r2', text: 'Watch for cold starts', score: 0.85, type: 'gotcha', date: '2026-01-14', source: 'session', permanent: true },
+      ];
+      deps.semanticRecall.recall.mockResolvedValue(mockResults);
+
+      const req = createMockReq({ query: { q: 'authentication' } });
+      const res = createMockRes();
+
+      await api.handleSearch(req, res);
+
+      expect(deps.semanticRecall.recall).toHaveBeenCalledWith(
+        'authentication',
+        expect.anything(),
+        expect.anything()
+      );
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ results: mockResults })
+      );
+    });
+
+    it('search with scope parameter filters correctly', async () => {
+      deps.semanticRecall.recall.mockResolvedValue([]);
+
+      const req = createMockReq({ query: { q: 'database', scope: 'project' } });
+      const res = createMockRes();
+
+      await api.handleSearch(req, res);
+
+      expect(deps.semanticRecall.recall).toHaveBeenCalledWith(
+        'database',
+        expect.anything(),
+        expect.objectContaining({ scope: 'project' })
+      );
+    });
+
+    it('empty search returns empty results', async () => {
+      const req = createMockReq({ query: { q: '' } });
+      const res = createMockRes();
+
+      await api.handleSearch(req, res);
+
+      const body = res._getJson();
+      expect(body.results).toEqual([]);
+    });
+  });
+
+  describe('handleListConversations', () => {
+    it('conversations list returns paginated results', async () => {
+      const mockData = {
+        items: [
+          { id: 'c1', title: 'Session 1', date: '2026-02-01' },
+          { id: 'c2', title: 'Session 2', date: '2026-02-02' },
+        ],
+        total: 25,
+      };
+      deps.memoryStore.listConversations.mockResolvedValue(mockData);
+
+      const req = createMockReq({ query: { page: '2', limit: '10' } });
+      const res = createMockRes();
+
+      await api.handleListConversations(req, res);
+
+      expect(deps.memoryStore.listConversations).toHaveBeenCalledWith(
+        expect.objectContaining({ page: 2, limit: 10 })
+      );
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ items: mockData.items, total: 25 })
+      );
+    });
+  });
+
+  describe('handleGetConversation', () => {
+    it('conversation detail returns full content', async () => {
+      const mockConversation = {
+        id: 'conv-42',
+        title: 'Auth Architecture Discussion',
+        content: '## Decisions made\n- Use JWT tokens\n- Add refresh flow',
+        date: '2026-02-10',
+        decisions: ['Use JWT', 'Add refresh'],
+        files: ['server/lib/auth.js'],
+      };
+      deps.memoryStore.getConversation.mockResolvedValue(mockConversation);
+
+      const req = createMockReq({ params: { id: 'conv-42' } });
+      const res = createMockRes();
+
+      await api.handleGetConversation(req, res);
+
+      expect(deps.memoryStore.getConversation).toHaveBeenCalledWith('conv-42');
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'conv-42', content: expect.any(String) })
+      );
+    });
+
+    it('404 for unknown conversation ID', async () => {
+      deps.memoryStore.getConversation.mockResolvedValue(null);
+
+      const req = createMockReq({ params: { id: 'nonexistent-id' } });
+      const res = createMockRes();
+
+      await api.handleGetConversation(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(404);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ error: expect.any(String) })
+      );
+    });
+  });
+
+  describe('handleListDecisions', () => {
+    it('decisions endpoint returns all decisions', async () => {
+      const mockDecisions = [
+        { id: 'd1', title: 'Use Postgres', date: '2026-01-20' },
+        { id: 'd2', title: 'Use REST over GraphQL', date: '2026-01-22' },
+      ];
+      deps.memoryStore.listDecisions.mockResolvedValue(mockDecisions);
+
+      const req = createMockReq();
+      const res = createMockRes();
+
+      await api.handleListDecisions(req, res);
+
+      expect(deps.memoryStore.listDecisions).toHaveBeenCalled();
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ decisions: mockDecisions })
+      );
+    });
+  });
+
+  describe('handleListGotchas', () => {
+    it('gotchas endpoint returns all gotchas', async () => {
+      const mockGotchas = [
+        { id: 'g1', title: 'Auth warmup delay', severity: 'high' },
+        { id: 'g2', title: 'DB pool exhaustion', severity: 'medium' },
+      ];
+      deps.memoryStore.listGotchas.mockResolvedValue(mockGotchas);
+
+      const req = createMockReq();
+      const res = createMockRes();
+
+      await api.handleListGotchas(req, res);
+
+      expect(deps.memoryStore.listGotchas).toHaveBeenCalled();
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ gotchas: mockGotchas })
+      );
+    });
+  });
+
+  describe('handleGetStats', () => {
+    it('stats endpoint returns vector DB info', async () => {
+      const mockStats = {
+        count: 1523,
+        size: '45MB',
+        lastIndexed: '2026-02-14T10:30:00Z',
+        model: 'nomic-embed-text',
+      };
+      deps.memoryStore.getStats.mockResolvedValue(mockStats);
+
+      const req = createMockReq();
+      const res = createMockRes();
+
+      await api.handleGetStats(req, res);
+
+      expect(deps.memoryStore.getStats).toHaveBeenCalled();
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ count: 1523, model: 'nomic-embed-text' })
+      );
+    });
+  });
+
+  describe('handleRebuild', () => {
+    it('rebuild endpoint triggers re-indexing', async () => {
+      deps.vectorIndexer.indexAll.mockResolvedValue({ indexed: 347, duration: 12500 });
+
+      const req = createMockReq({ body: { projectRoot: '/path/to/project' } });
+      const res = createMockRes();
+
+      await api.handleRebuild(req, res);
+
+      expect(deps.vectorIndexer.indexAll).toHaveBeenCalledWith('/path/to/project');
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ indexed: 347 })
+      );
+    });
+  });
+
+  describe('handleRemember', () => {
+    it('remember endpoint stores permanent memory', async () => {
+      deps.richCapture.processChunk.mockResolvedValue({ stored: true, id: 'mem-99' });
+
+      const req = createMockReq({
+        body: {
+          text: 'Always run migrations before deploying',
+          metadata: { type: 'gotcha', project: 'my-app' },
+        },
+      });
+      const res = createMockRes();
+
+      await api.handleRemember(req, res);
+
+      expect(deps.richCapture.processChunk).toHaveBeenCalledWith(
+        'Always run migrations before deploying',
+        expect.objectContaining({ permanent: true })
+      );
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({ stored: true })
+      );
+    });
+  });
+
+  describe('project filter', () => {
+    it('project filter works across endpoints', async () => {
+      const projectId = 'proj-abc';
+
+      const convReq = createMockReq({ query: { project: projectId, page: '1', limit: '10' } });
+      const convRes = createMockRes();
+      await api.handleListConversations(convReq, convRes);
+      expect(deps.memoryStore.listConversations).toHaveBeenCalledWith(
+        expect.objectContaining({ project: projectId })
+      );
+
+      const decReq = createMockReq({ query: { project: projectId } });
+      const decRes = createMockRes();
+      await api.handleListDecisions(decReq, decRes);
+      expect(deps.memoryStore.listDecisions).toHaveBeenCalledWith(
+        expect.objectContaining({ project: projectId })
+      );
+
+      const gotReq = createMockReq({ query: { project: projectId } });
+      const gotRes = createMockRes();
+      await api.handleListGotchas(gotReq, gotRes);
+      expect(deps.memoryStore.listGotchas).toHaveBeenCalledWith(
+        expect.objectContaining({ project: projectId })
+      );
+    });
+  });
+});

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

@@ -0,0 +1,160 @@
+/**
+ * Memory Bridge E2E Tests - Phase 82 Task 5
+ *
+ * Tests the full pipeline: capture → observeAndRemember → pattern detect → file store.
+ * Proves the memory system achieves its original goal.
+ *
+ * RED: depends on capture-bridge.js (Task 1) and capture-guard.js (Task 4).
+ */
+
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+import { captureExchange, drainSpool, SPOOL_FILENAME } from './capture-bridge.js';
+import { observeAndRemember } from './memory-observer.js';
+
+describe('memory-bridge e2e', () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-bridge-e2e-'));
+    // Create 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'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, '.tlc.json'), JSON.stringify({ project: 'e2e-test' }));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('decision in exchange creates decision file', async () => {
+    // Pattern detector analyzes the user field for decision patterns
+    const exchange = {
+      user: "let's use PostgreSQL instead of MySQL because we need JSONB support.",
+      assistant: 'Good choice. PostgreSQL has excellent JSONB support.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+
+    // Wait for setImmediate-based async processing
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Check that a decision file was created
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('gotcha in exchange creates gotcha file', async () => {
+    // Pattern detector looks for "watch out for X" in user field
+    const exchange = {
+      user: 'watch out for the PGlite WASM driver under concurrent writes.',
+      assistant: 'Good catch. Serialize database operations to avoid crashes.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    const gotchasDir = path.join(testDir, '.tlc', 'memory', 'team', 'gotchas');
+    const files = fs.readdirSync(gotchasDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('full pipeline: captureExchange → observe → file stored', async () => {
+    // Simulate what the Stop hook does: POST to a mock server that calls observeAndRemember
+    let capturedExchange = null;
+
+    // Mock fetch that simulates the server calling observeAndRemember
+    const mockFetch = vi.fn().mockImplementation(async (url, opts) => {
+      const body = JSON.parse(opts.body);
+      for (const ex of body.exchanges) {
+        capturedExchange = ex;
+        await observeAndRemember(testDir, ex);
+      }
+      return { ok: true, json: async () => ({ captured: body.exchanges.length }) };
+    });
+
+    await captureExchange({
+      cwd: testDir,
+      // Pattern detector analyzes user field — put decision language there
+      assistantMessage: 'Good choice, JWT is better for horizontal scaling.',
+      userMessage: "let's use JWT tokens instead of sessions for authentication.",
+      sessionId: 'e2e-sess-1',
+    }, { fetch: mockFetch });
+
+    await new Promise(resolve => setTimeout(resolve, 300));
+
+    // Verify the exchange was captured
+    expect(capturedExchange).not.toBeNull();
+    expect(capturedExchange.user).toContain('JWT tokens');
+
+    // Verify a decision file was created
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('spool entry captured after drain', async () => {
+    const spoolDir = path.join(testDir, '.tlc', 'memory');
+    const spoolPath = path.join(spoolDir, SPOOL_FILENAME);
+
+    // Write a spooled entry with a decision (pattern in user field)
+    const spooledEntry = JSON.stringify({
+      projectId: 'e2e-test',
+      exchanges: [{
+        user: "we decided to use SQLite for the vector store.",
+        assistant: 'SQLite embeds directly and needs no separate process.',
+        timestamp: Date.now(),
+      }],
+    });
+    fs.writeFileSync(spoolPath, spooledEntry + '\n');
+
+    // Mock fetch that calls observeAndRemember (like the real server would)
+    const mockFetch = vi.fn().mockImplementation(async (url, opts) => {
+      const body = JSON.parse(opts.body);
+      for (const ex of body.exchanges) {
+        await observeAndRemember(testDir, ex);
+      }
+      return { ok: true, json: async () => ({ captured: body.exchanges.length }) };
+    });
+
+    await drainSpool(spoolDir, { fetch: mockFetch });
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Spool should be drained
+    if (fs.existsSync(spoolPath)) {
+      expect(fs.readFileSync(spoolPath, 'utf-8').trim()).toBe('');
+    }
+
+    // Decision file should have been created from the spooled exchange
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('capture guard deduplicates identical exchanges', async () => {
+    // Dedup happens at the capture guard level, not the observer
+    const { createCaptureGuard } = await import('./capture-guard.js');
+    const guard = createCaptureGuard();
+
+    const exchange = {
+      user: "we decided to use Redis as our caching layer.",
+      assistant: 'Redis is great for caching.',
+      timestamp: Date.now(),
+    };
+
+    // First call returns the exchange
+    const first = guard.deduplicate([exchange], 'e2e-test');
+    expect(first).toHaveLength(1);
+
+    // Same exchange immediately — deduplicated
+    const second = guard.deduplicate([exchange], 'e2e-test');
+    expect(second).toHaveLength(0);
+  });
+});

package/server/lib/memory-committer.js

@@ -23,7 +23,24 @@ async function detectUncommittedMemory(projectRoot) {
     return [];
   }
 
-  // Get all files in team directory
+  // Try git status first — only return modified/untracked files
+  try {
+    const teamRelative = path.relative(projectRoot, teamDir);
+    const { stdout } = await execAsync(
+      `git status --porcelain -- "${teamRelative}"`,
+      { cwd: projectRoot }
+    );
+    if (stdout.trim().length === 0) return [];
+
+    return stdout.trim().split('\n')
+      .map(line => line.slice(3).trim()) // strip status prefix (e.g. "?? ", " M ")
+      .filter(f => f.endsWith('.json') || f.endsWith('.md'))
+      .filter(f => !f.endsWith('conventions.md'));
+  } catch {
+    // Not a git repo or git not available — fall back to walkDir
+  }
+
+  // Fallback: return all files (non-git directory)
   const files = [];
 
   async function walkDir(dir) {
@@ -33,10 +50,7 @@ async function detectUncommittedMemory(projectRoot) {
       if (entry.isDirectory()) {
         await walkDir(fullPath);
       } else if (entry.name.endsWith('.json') || entry.name.endsWith('.md')) {
-        // Skip template files like conventions.md
         if (entry.name === 'conventions.md') continue;
-
-        // Get path relative to projectRoot
         const relativePath = path.relative(projectRoot, fullPath);
         files.push(relativePath);
       }

package/server/lib/memory-committer.test.js

@@ -58,6 +58,27 @@ describe('memory-committer', () => {
 
       expect(uncommitted.every(f => !f.includes('.local'))).toBe(true);
     });
+
+    // Phase 81 Task 4: detectUncommittedMemory should use git status
+    it('returns empty for already-committed files in a git repo', async () => {
+      // Create a git repo, add a decision, and commit it
+      const { execSync } = await import('child_process');
+      execSync('git init', { cwd: testDir, stdio: 'pipe' });
+      execSync('git config user.email "test@test.com"', { cwd: testDir, stdio: 'pipe' });
+      execSync('git config user.name "Test"', { cwd: testDir, stdio: 'pipe' });
+
+      await writeTeamDecision(testDir, {
+        title: 'Committed Decision',
+        reasoning: 'Already committed',
+      });
+
+      execSync('git add -A', { cwd: testDir, stdio: 'pipe' });
+      execSync('git commit -m "initial"', { cwd: testDir, stdio: 'pipe' });
+
+      // Now detect uncommitted — should be empty since everything is committed
+      const uncommitted = await detectUncommittedMemory(testDir);
+      expect(uncommitted).toHaveLength(0);
+    });
   });
 
   describe('generateCommitMessage', () => {