tlc-claude-code 1.8.5 → 2.1.0

package/server/lib/test-inventory.test.js

@@ -0,0 +1,360 @@
+/**
+ * @file test-inventory.test.js
+ * @description Tests for the Test Suite Inventory API (Phase 75, Task 2).
+ *
+ * Tests the factory function `createTestInventory(deps)` which accepts injected
+ * dependencies (globSync, fs) and returns functions for discovering test files,
+ * counting tests per file, grouping by directory, and reading cached test runs.
+ *
+ * Factory returns: { getTestInventory(projectPath), getLastTestRun(projectPath) }
+ *
+ * All dependencies are fully mocked with vi.fn() — no real filesystem access.
+ * These tests are written BEFORE the implementation (Red phase).
+ */
+import { describe, it, beforeEach, expect, vi } from 'vitest';
+import { createTestInventory } from './test-inventory.js';
+
+// ---------------------------------------------------------------------------
+// Mock factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a mock globSync function that returns the given file paths.
+ * @param {string[]} files - Array of file paths to return from globSync
+ * @returns {Function} vi.fn() that returns the files array
+ */
+function createMockGlob(files = []) {
+  return vi.fn().mockReturnValue(files);
+}
+
+/**
+ * Creates a mock fs object with readFileSync and existsSync stubs.
+ * readFileSync returns content from the fileContents map, or throws ENOENT.
+ * existsSync returns true if the path exists in the map.
+ * @param {Object<string, string>} fileContents - Map of file path to file content
+ * @returns {{ readFileSync: Function, existsSync: Function }} Mock fs object
+ */
+function createMockFs(fileContents = {}) {
+  return {
+    readFileSync: vi.fn((p) => {
+      if (p in fileContents) return fileContents[p];
+      throw new Error(`ENOENT: no such file or directory, open '${p}'`);
+    }),
+    existsSync: vi.fn((p) => p in fileContents),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Sample test file contents for counting
+// ---------------------------------------------------------------------------
+
+/** A typical test file with 3 tests (2 it + 1 test) */
+const threeTestFile = `
+import { describe, it, expect } from 'vitest';
+
+describe('auth', () => {
+  it('logs in with valid credentials', () => {
+    expect(true).toBe(true);
+  });
+
+  it('rejects invalid password', () => {
+    expect(true).toBe(true);
+  });
+
+  test('handles missing email', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+
+/** A test file with 2 tests using it.only and it.skip */
+const twoTestFileWithModifiers = `
+import { describe, it, expect } from 'vitest';
+
+describe('session', () => {
+  it.only('creates new session', () => {
+    expect(true).toBe(true);
+  });
+
+  it.skip('expires after timeout', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+
+/** A test file with 1 test using test.only */
+const oneTestFile = `
+import { describe, test, expect } from 'vitest';
+
+describe('utils', () => {
+  test.only('formats date correctly', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+
+/** An empty test file (no it/test calls) */
+const emptyTestFile = `
+import { describe, expect } from 'vitest';
+
+describe('placeholder', () => {
+  // TODO: add tests
+});
+`;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('test-inventory', () => {
+  let inventory;
+  let mockGlob;
+  let mockFs;
+
+  beforeEach(() => {
+    mockGlob = createMockGlob();
+    mockFs = createMockFs();
+    inventory = createTestInventory({ globSync: mockGlob, fs: mockFs });
+  });
+
+  describe('getTestInventory', () => {
+    it('discovers test files by glob patterns', () => {
+      const files = [
+        '/project/server/lib/auth.test.js',
+        '/project/server/lib/tasks.test.ts',
+        '/project/dashboard-web/src/App.test.tsx',
+        '/project/server/lib/utils.spec.js',
+      ];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(emptyTestFile);
+
+      inventory.getTestInventory('/project');
+
+      // Verify globSync was called with patterns that cover all test extensions
+      const callArgs = mockGlob.mock.calls[0];
+      const patterns = callArgs[0];
+
+      // Should search for .test.js, .test.ts, .test.tsx, and .spec.* patterns
+      expect(patterns).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining('*.test.js'),
+          expect.stringContaining('*.test.ts'),
+          expect.stringContaining('*.test.tsx'),
+          expect.stringContaining('*.spec.*'),
+        ])
+      );
+    });
+
+    it('groups files by directory', () => {
+      const files = [
+        '/project/server/lib/auth.test.js',
+        '/project/server/lib/tasks.test.js',
+        '/project/dashboard-web/src/Login.test.tsx',
+        '/project/dashboard-web/src/App.test.tsx',
+      ];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(threeTestFile);
+
+      const result = inventory.getTestInventory('/project');
+
+      expect(result.groups).toHaveLength(2);
+
+      const groupNames = result.groups.map((g) => g.name);
+      expect(groupNames).toContain('server/lib');
+      expect(groupNames).toContain('dashboard-web/src');
+
+      const serverGroup = result.groups.find((g) => g.name === 'server/lib');
+      expect(serverGroup.fileCount).toBe(2);
+
+      const dashGroup = result.groups.find((g) => g.name === 'dashboard-web/src');
+      expect(dashGroup.fileCount).toBe(2);
+    });
+
+    it('counts tests per file (it/test occurrences)', () => {
+      const files = ['/project/server/lib/auth.test.js'];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(threeTestFile);
+
+      const result = inventory.getTestInventory('/project');
+
+      const file = result.groups[0].files[0];
+      expect(file.testCount).toBe(3);
+    });
+
+    it('summary totals are correct', () => {
+      const files = [
+        '/project/server/lib/auth.test.js',
+        '/project/server/lib/session.test.js',
+        '/project/server/lib/utils.test.js',
+      ];
+      mockGlob.mockReturnValue(files);
+
+      // auth has 3, session has 2, utils has 1 = 6 total
+      const contents = {
+        '/project/server/lib/auth.test.js': threeTestFile,
+        '/project/server/lib/session.test.js': twoTestFileWithModifiers,
+        '/project/server/lib/utils.test.js': oneTestFile,
+      };
+      mockFs.readFileSync.mockImplementation((p) => {
+        if (p in contents) return contents[p];
+        throw new Error(`ENOENT: ${p}`);
+      });
+
+      const result = inventory.getTestInventory('/project');
+
+      expect(result.totalFiles).toBe(3);
+      expect(result.totalTests).toBe(6);
+
+      // Group total should also sum correctly
+      const group = result.groups[0];
+      expect(group.testCount).toBe(6);
+      expect(group.fileCount).toBe(3);
+    });
+
+    it('groups sorted by test count descending', () => {
+      const files = [
+        // Group A: server/lib — 1 file with 1 test
+        '/project/server/lib/utils.test.js',
+        // Group B: dashboard-web/src — 1 file with 3 tests
+        '/project/dashboard-web/src/App.test.tsx',
+      ];
+      mockGlob.mockReturnValue(files);
+
+      const contents = {
+        '/project/server/lib/utils.test.js': oneTestFile,
+        '/project/dashboard-web/src/App.test.tsx': threeTestFile,
+      };
+      mockFs.readFileSync.mockImplementation((p) => {
+        if (p in contents) return contents[p];
+        throw new Error(`ENOENT: ${p}`);
+      });
+
+      const result = inventory.getTestInventory('/project');
+
+      // dashboard-web/src has 3 tests, server/lib has 1 — dashboard first
+      expect(result.groups[0].name).toBe('dashboard-web/src');
+      expect(result.groups[0].testCount).toBe(3);
+      expect(result.groups[1].name).toBe('server/lib');
+      expect(result.groups[1].testCount).toBe(1);
+    });
+
+    it('ignores node_modules and dist', () => {
+      mockGlob.mockReturnValue([]);
+
+      inventory.getTestInventory('/project');
+
+      const callArgs = mockGlob.mock.calls[0];
+      const options = callArgs[1];
+
+      // The options should include ignore patterns for node_modules, dist, .git
+      expect(options).toBeDefined();
+      expect(options.ignore).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining('node_modules'),
+          expect.stringContaining('dist'),
+          expect.stringContaining('.git'),
+        ])
+      );
+    });
+
+    it('returns empty inventory for no test files', () => {
+      mockGlob.mockReturnValue([]);
+
+      const result = inventory.getTestInventory('/project');
+
+      expect(result.totalFiles).toBe(0);
+      expect(result.totalTests).toBe(0);
+      expect(result.groups).toEqual([]);
+    });
+
+    it('handles mixed extensions (.test.js, .test.ts, .test.tsx)', () => {
+      const files = [
+        '/project/src/auth.test.js',
+        '/project/src/config.test.ts',
+        '/project/src/App.test.tsx',
+      ];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(oneTestFile);
+
+      const result = inventory.getTestInventory('/project');
+
+      expect(result.totalFiles).toBe(3);
+      // All three files should be discovered regardless of extension
+      const filePaths = result.groups[0].files.map((f) => f.relativePath);
+      expect(filePaths).toContain('src/auth.test.js');
+      expect(filePaths).toContain('src/config.test.ts');
+      expect(filePaths).toContain('src/App.test.tsx');
+    });
+
+    it('handles spec files (.spec.js)', () => {
+      const files = [
+        '/project/src/utils.spec.js',
+        '/project/src/helpers.spec.ts',
+      ];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(threeTestFile);
+
+      const result = inventory.getTestInventory('/project');
+
+      expect(result.totalFiles).toBe(2);
+      const filePaths = result.groups[0].files.map((f) => f.relativePath);
+      expect(filePaths).toContain('src/utils.spec.js');
+      expect(filePaths).toContain('src/helpers.spec.ts');
+    });
+
+    it('works with nested directory structures', () => {
+      const files = [
+        '/project/server/lib/auth/login.test.js',
+        '/project/server/lib/auth/logout.test.js',
+        '/project/server/lib/tasks.test.js',
+        '/project/dashboard-web/src/pages/Home.test.tsx',
+      ];
+      mockGlob.mockReturnValue(files);
+      mockFs.readFileSync.mockReturnValue(oneTestFile);
+
+      const result = inventory.getTestInventory('/project');
+
+      // Nested dirs should be grouped by their top-level directory segments
+      const groupNames = result.groups.map((g) => g.name);
+
+      // server/lib/auth/ and server/lib/ files should group under server/lib
+      // (or similar sensible grouping)
+      expect(groupNames.length).toBeGreaterThanOrEqual(2);
+
+      // All 4 files should be accounted for
+      expect(result.totalFiles).toBe(4);
+    });
+  });
+
+  describe('getLastTestRun', () => {
+    it('returns null when no cached run exists', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = inventory.getLastTestRun('/project');
+
+      expect(result).toBeNull();
+    });
+
+    it('returns cached test run data when available', () => {
+      const cachedRun = JSON.stringify({
+        timestamp: '2026-02-09T10:30:00Z',
+        passed: 347,
+        failed: 3,
+        total: 350,
+        duration: 12500,
+      });
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(cachedRun);
+
+      const result = inventory.getLastTestRun('/project');
+
+      expect(result).not.toBeNull();
+      expect(result.timestamp).toBe('2026-02-09T10:30:00Z');
+      expect(result.passed).toBe(347);
+      expect(result.failed).toBe(3);
+      expect(result.total).toBe(350);
+      expect(result.duration).toBe(12500);
+    });
+  });
+});

package/server/lib/vector-indexer.js

@@ -0,0 +1,246 @@
+/**
+ * Vector Indexer — embeds and indexes memory content into the vector store.
+ *
+ * Reads markdown files from memory/decisions/, memory/gotchas/, and
+ * memory/conversations/, strips formatting, generates embeddings, and
+ * inserts into the vector store for semantic search.
+ *
+ * @module vector-indexer
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+/** Memory subdirectories and their types */
+const MEMORY_DIRS = [
+  { dir: 'decisions', type: 'decision' },
+  { dir: 'gotchas', type: 'gotcha' },
+  { dir: 'conversations', type: 'conversation' },
+];
+
+/**
+ * Strip markdown formatting from text for cleaner embeddings.
+ * @param {string} text
+ * @returns {string}
+ */
+function stripMarkdown(text) {
+  return text
+    .replace(/^---[\s\S]*?---\n?/m, '')  // Remove frontmatter
+    .replace(/^#+\s+/gm, '')              // Remove # headers
+    .replace(/\*\*([^*]+)\*\*/g, '$1')    // Remove bold
+    .replace(/\*([^*]+)\*/g, '$1')        // Remove italic
+    .replace(/`([^`]+)`/g, '$1')          // Remove inline code
+    .replace(/```[\s\S]*?```/g, '')       // Remove code blocks
+    .replace(/^\s*[-*]\s+/gm, '')         // Remove list markers
+    .replace(/\n{3,}/g, '\n\n')           // Collapse multiple newlines
+    .trim();
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ * @param {string} content
+ * @returns {{ permanent: boolean }}
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { permanent: false };
+
+  const yaml = match[1];
+  const permanentMatch = yaml.match(/permanent:\s*(true|false)/i);
+  return {
+    permanent: permanentMatch ? permanentMatch[1].toLowerCase() === 'true' : false,
+  };
+}
+
+/**
+ * Detect memory type from file path based on parent directory.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function detectType(filePath) {
+  for (const { dir, type } of MEMORY_DIRS) {
+    if (filePath.includes(`/${dir}/`) || filePath.includes(`\\${dir}\\`)) {
+      return type;
+    }
+  }
+  return 'unknown';
+}
+
+/**
+ * Generate a deterministic ID for a file.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function fileId(filePath) {
+  return crypto.createHash('sha256').update(filePath).digest('hex').slice(0, 16);
+}
+
+/**
+ * List all .md files in a directory (non-recursive).
+ * @param {string} dirPath
+ * @returns {string[]}
+ */
+function listMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return [];
+  return fs.readdirSync(dirPath)
+    .filter((f) => f.endsWith('.md'))
+    .map((f) => path.join(dirPath, f))
+    .sort();
+}
+
+/**
+ * Create a vector indexer that embeds and stores memory content.
+ *
+ * @param {object} deps
+ * @param {object} deps.vectorStore - Vector store instance
+ * @param {object} deps.embeddingClient - Embedding client instance
+ * @returns {object} Indexer with indexAll/indexFile/indexChunk/isIndexed/rebuildIndex
+ */
+export function createVectorIndexer({ vectorStore, embeddingClient }) {
+  /**
+   * Index all memory files from a project.
+   */
+  async function indexAll(projectRoot, options = {}) {
+    const { onProgress } = options;
+    const memoryRoot = path.join(projectRoot, 'memory');
+
+    // Collect all files to index
+    const filesToIndex = [];
+    for (const { dir, type } of MEMORY_DIRS) {
+      const dirPath = path.join(memoryRoot, dir);
+      const files = listMarkdownFiles(dirPath);
+      for (const f of files) {
+        filesToIndex.push({ path: f, type });
+      }
+    }
+
+    let indexed = 0;
+    let skipped = 0;
+    let errors = 0;
+
+    for (let i = 0; i < filesToIndex.length; i++) {
+      const file = filesToIndex[i];
+      try {
+        const result = await indexSingleFile(projectRoot, file.path, file.type);
+        if (result.success) {
+          indexed++;
+        } else {
+          errors++;
+        }
+      } catch {
+        errors++;
+      }
+
+      if (onProgress) {
+        onProgress({
+          indexed: indexed,
+          total: filesToIndex.length,
+          current: path.basename(file.path),
+        });
+      }
+    }
+
+    return { indexed, skipped, errors };
+  }
+
+  /**
+   * Index a single file.
+   */
+  async function indexFile(projectRoot, filePath) {
+    const type = detectType(filePath);
+    return indexSingleFile(projectRoot, filePath, type);
+  }
+
+  /**
+   * Internal: index a single file with known type.
+   */
+  async function indexSingleFile(projectRoot, filePath, type) {
+    try {
+      const rawContent = fs.readFileSync(filePath, 'utf8');
+      const frontmatter = parseFrontmatter(rawContent);
+      const cleanText = stripMarkdown(rawContent);
+
+      if (!cleanText || cleanText.length === 0) {
+        return { success: false };
+      }
+
+      const embedding = await embeddingClient.embed(cleanText);
+      if (!embedding) {
+        return { success: false };
+      }
+
+      const id = fileId(filePath);
+      vectorStore.insert({
+        id,
+        text: cleanText,
+        embedding,
+        type,
+        project: null,
+        workspace: projectRoot,
+        branch: null,
+        timestamp: Date.now(),
+        sourceFile: filePath,
+        permanent: frontmatter.permanent,
+      });
+
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+
+  /**
+   * Index a conversation chunk object directly (not from file).
+   */
+  async function indexChunk(projectRoot, chunk) {
+    try {
+      const text = chunk.text || '';
+      if (!text) return { success: false };
+
+      const embedding = await embeddingClient.embed(text);
+      if (!embedding) return { success: false };
+
+      vectorStore.insert({
+        id: chunk.id,
+        text,
+        embedding,
+        type: chunk.type || 'conversation',
+        project: chunk.project || null,
+        workspace: chunk.workspace || projectRoot,
+        branch: null,
+        timestamp: chunk.timestamp || Date.now(),
+        sourceFile: chunk.sourceFile || null,
+        permanent: chunk.permanent || false,
+      });
+
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+
+  /**
+   * Check if a file is already indexed in the store.
+   */
+  async function isIndexed(filePath) {
+    const all = vectorStore.getAll();
+    return all.some((entry) => entry.sourceFile === filePath);
+  }
+
+  /**
+   * Drop all vectors and re-index everything from text files.
+   */
+  async function rebuildIndex(projectRoot) {
+    vectorStore.rebuild();
+    await indexAll(projectRoot);
+  }
+
+  return {
+    indexAll,
+    indexFile,
+    indexChunk,
+    isIndexed,
+    rebuildIndex,
+  };
+}