tlc-claude-code 1.8.5 → 2.1.0

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

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { GlobalConfig } = await import('./global-config.js');
+
+describe('GlobalConfig', () => {
+  let tempDir;
+  let originalEnv;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'global-config-test-'));
+    originalEnv = process.env.TLC_CONFIG_DIR;
+    process.env.TLC_CONFIG_DIR = tempDir;
+  });
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.TLC_CONFIG_DIR = originalEnv;
+    } else {
+      delete process.env.TLC_CONFIG_DIR;
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('creates config directory if not exists', () => {
+      const configDir = path.join(tempDir, 'subdir');
+      process.env.TLC_CONFIG_DIR = configDir;
+
+      const config = new GlobalConfig();
+      config.load();
+
+      expect(fs.existsSync(configDir)).toBe(true);
+    });
+
+    it('creates config file with defaults on first access', () => {
+      const config = new GlobalConfig();
+      const data = config.load();
+
+      expect(data).toBeDefined();
+      expect(data.version).toBe(1);
+      expect(data.roots).toEqual([]);
+      expect(data.scanDepth).toBe(5);
+    });
+
+    it('respects TLC_CONFIG_DIR environment variable', () => {
+      const customDir = path.join(tempDir, 'custom');
+      process.env.TLC_CONFIG_DIR = customDir;
+
+      const config = new GlobalConfig();
+      config.load();
+
+      const configPath = path.join(customDir, 'config.json');
+      expect(fs.existsSync(configPath)).toBe(true);
+    });
+
+    it('config schema has version field', () => {
+      const config = new GlobalConfig();
+      const data = config.load();
+
+      expect(data.version).toBe(1);
+    });
+  });
+
+  describe('getRoots', () => {
+    it('returns empty roots when not configured', () => {
+      const config = new GlobalConfig();
+
+      const roots = config.getRoots();
+
+      expect(roots).toEqual([]);
+    });
+
+    it('returns configured roots', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        const roots = config.getRoots();
+
+        expect(roots).toContain(rootPath);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('addRoot', () => {
+    it('adds root path and persists to disk', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        // Re-read from disk
+        const config2 = new GlobalConfig();
+        const roots = config2.getRoots();
+
+        expect(roots).toContain(rootPath);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+
+    it('rejects non-existent directory path', () => {
+      const config = new GlobalConfig();
+
+      expect(() => config.addRoot('/tmp/does-not-exist-xyz-123')).toThrow(/does not exist/i);
+    });
+
+    it('rejects file path (must be directory)', () => {
+      const filePath = path.join(tempDir, 'somefile.txt');
+      fs.writeFileSync(filePath, 'hello');
+
+      const config = new GlobalConfig();
+
+      expect(() => config.addRoot(filePath)).toThrow(/not a directory/i);
+    });
+
+    it('duplicate root paths rejected', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        expect(() => config.addRoot(rootPath)).toThrow(/already configured/i);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+
+    it('multiple roots supported', () => {
+      const root1 = fs.mkdtempSync(path.join(os.tmpdir(), 'root1-'));
+      const root2 = fs.mkdtempSync(path.join(os.tmpdir(), 'root2-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(root1);
+        config.addRoot(root2);
+
+        const roots = config.getRoots();
+
+        expect(roots).toHaveLength(2);
+        expect(roots).toContain(root1);
+        expect(roots).toContain(root2);
+      } finally {
+        fs.rmSync(root1, { recursive: true, force: true });
+        fs.rmSync(root2, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('removeRoot', () => {
+    it('removes root path', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+        config.removeRoot(rootPath);
+
+        const roots = config.getRoots();
+
+        expect(roots).not.toContain(rootPath);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+
+    it('removing non-existent root does not throw', () => {
+      const config = new GlobalConfig();
+
+      expect(() => config.removeRoot('/some/path')).not.toThrow();
+    });
+  });
+
+  describe('isConfigured', () => {
+    it('returns false with no roots', () => {
+      const config = new GlobalConfig();
+
+      expect(config.isConfigured()).toBe(false);
+    });
+
+    it('returns true with roots', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        expect(config.isConfigured()).toBe(true);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('scanDepth', () => {
+    it('defaults to 5', () => {
+      const config = new GlobalConfig();
+      const data = config.load();
+
+      expect(data.scanDepth).toBe(5);
+    });
+
+    it('can be updated', () => {
+      const config = new GlobalConfig();
+      config.setScanDepth(3);
+
+      const config2 = new GlobalConfig();
+      const data = config2.load();
+
+      expect(data.scanDepth).toBe(3);
+    });
+  });
+
+  describe('lastScan tracking', () => {
+    it('stores lastScan timestamp per root', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        const now = Date.now();
+        config.setLastScan(rootPath, now);
+
+        const lastScan = config.getLastScan(rootPath);
+
+        expect(lastScan).toBe(now);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+
+    it('returns null for root that has not been scanned', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        const lastScan = config.getLastScan(rootPath);
+
+        expect(lastScan).toBeNull();
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('error handling', () => {
+    it('handles corrupted JSON gracefully (resets to defaults)', () => {
+      const configPath = path.join(tempDir, 'config.json');
+      fs.writeFileSync(configPath, '{invalid json!!!');
+
+      const config = new GlobalConfig();
+      const data = config.load();
+
+      expect(data.version).toBe(1);
+      expect(data.roots).toEqual([]);
+    });
+
+    it('atomic write prevents partial file corruption', () => {
+      const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'root-'));
+
+      try {
+        const config = new GlobalConfig();
+        config.addRoot(rootPath);
+
+        // Verify file is valid JSON after write
+        const configPath = path.join(tempDir, 'config.json');
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+
+        expect(parsed.roots).toContain(rootPath);
+      } finally {
+        fs.rmSync(rootPath, { recursive: true, force: true });
+      }
+    });
+  });
+});

package/server/lib/inherited-search.js

@@ -0,0 +1,184 @@
+/**
+ * Inherited Search — wraps semantic-recall with inheritance-aware search
+ * that walks from project scope up through workspace scope, adjusting
+ * scores and deduplicating results.
+ *
+ * Workspace results receive a 0.8x score multiplier to prefer local
+ * project memories while still surfacing relevant workspace knowledge.
+ *
+ * Auto-widening: when project scope returns fewer than 3 results,
+ * the search automatically widens to include workspace results.
+ *
+ * @module inherited-search
+ */
+
+/** Minimum results before auto-widening from project to workspace */
+const AUTO_WIDEN_THRESHOLD = 3;
+
+/** Score multiplier for workspace-level results */
+const WORKSPACE_SCORE_MULTIPLIER = 0.8;
+
+/**
+ * Deduplicate results by id, keeping the entry with the highest score.
+ *
+ * @param {Array} results - Scored results that may contain duplicates
+ * @returns {Array} Deduplicated results
+ */
+function deduplicateById(results) {
+  const bestById = new Map();
+
+  for (const result of results) {
+    const existing = bestById.get(result.id);
+    if (!existing || result.score > existing.score) {
+      bestById.set(result.id, result);
+    }
+  }
+
+  return [...bestById.values()];
+}
+
+/**
+ * Apply a score multiplier to an array of results, returning new objects.
+ *
+ * @param {Array} results - Search results
+ * @param {number} multiplier - Score multiplier to apply
+ * @returns {Array} Results with adjusted scores
+ */
+function applyScoreMultiplier(results, multiplier) {
+  return results.map((r) => ({ ...r, score: r.score * multiplier }));
+}
+
+/**
+ * Create an inherited search instance that wraps semantic-recall with
+ * inheritance-aware scope walking.
+ *
+ * @param {object} deps - Dependencies
+ * @param {object} deps.semanticRecall - Semantic recall instance (from Phase 71)
+ * @param {object} deps.workspaceDetector - Workspace detector instance (from Task 1)
+ * @param {object} deps.vectorIndexer - Vector indexer instance (from Phase 71)
+ * @returns {object} Object with search and indexAll methods
+ */
+export function createInheritedSearch({ semanticRecall, workspaceDetector, vectorIndexer }) {
+  /**
+   * Fetch workspace-scope results using the workspace root as the context
+   * workspace, applying the 0.8x score multiplier.
+   *
+   * @param {string} query - Search query
+   * @param {object} context - Original context
+   * @param {object} options - Search options (without scope)
+   * @param {string} workspaceRoot - Workspace root path
+   * @returns {Promise<Array>} Workspace results with adjusted scores
+   */
+  async function fetchWorkspaceResults(query, context, options, workspaceRoot) {
+    const wsContext = { ...context, workspace: workspaceRoot };
+    const wsOptions = { ...options, scope: 'workspace' };
+    const wsResults = await semanticRecall.recall(query, wsContext, wsOptions);
+    return applyScoreMultiplier(wsResults, WORKSPACE_SCORE_MULTIPLIER);
+  }
+
+  /**
+   * Search with inheritance-aware scope walking.
+   *
+   * Scope behavior:
+   * - 'project': search project only; auto-widen to workspace if < 3 results
+   * - 'workspace': search workspace only (delegates directly to semanticRecall)
+   * - 'inherited': always search both project and workspace, merge results
+   * - 'global': delegates directly to semanticRecall with global scope
+   *
+   * @param {string} query - Search query text
+   * @param {object} context - Current context
+   * @param {object} [options] - Search options
+   * @param {string} [options.scope='project'] - Search scope
+   * @returns {Promise<Array>} Scored and ranked results
+   */
+  async function search(query, context, options = {}) {
+    const { scope = 'project', ...restOptions } = options;
+
+    // For global or workspace scope, pass through directly
+    if (scope === 'global' || scope === 'workspace') {
+      return semanticRecall.recall(query, context, { ...restOptions, scope });
+    }
+
+    // Detect workspace info for the current project
+    const wsInfo = workspaceDetector.detectWorkspace(context.workspace);
+
+    // For inherited scope: always search both project and workspace
+    if (scope === 'inherited') {
+      const projectResults = await semanticRecall.recall(
+        query,
+        context,
+        { ...restOptions, scope: 'project' },
+      );
+
+      // If not in a workspace, return project results only
+      if (!wsInfo.isInWorkspace || !wsInfo.workspaceRoot) {
+        return projectResults;
+      }
+
+      const wsResults = await fetchWorkspaceResults(
+        query,
+        context,
+        restOptions,
+        wsInfo.workspaceRoot,
+      );
+
+      // Merge, deduplicate, and sort
+      const merged = deduplicateById([...projectResults, ...wsResults]);
+      merged.sort((a, b) => b.score - a.score);
+      return merged;
+    }
+
+    // scope === 'project': search project first, auto-widen if needed
+    const projectResults = await semanticRecall.recall(
+      query,
+      context,
+      { ...restOptions, scope: 'project' },
+    );
+
+    // If enough project results or not in a workspace, return as-is
+    if (
+      projectResults.length >= AUTO_WIDEN_THRESHOLD
+      || !wsInfo.isInWorkspace
+      || !wsInfo.workspaceRoot
+    ) {
+      return projectResults;
+    }
+
+    // Auto-widen: fetch workspace results and merge
+    const wsResults = await fetchWorkspaceResults(
+      query,
+      context,
+      restOptions,
+      wsInfo.workspaceRoot,
+    );
+
+    const merged = deduplicateById([...projectResults, ...wsResults]);
+    merged.sort((a, b) => b.score - a.score);
+    return merged;
+  }
+
+  /**
+   * Index all memory for a project, including workspace memory if applicable.
+   *
+   * @param {string} projectRoot - Absolute path to the project root
+   * @returns {Promise<object>} Combined indexing results
+   */
+  async function indexAll(projectRoot) {
+    const projectResult = await vectorIndexer.indexAll(projectRoot);
+
+    const wsInfo = workspaceDetector.detectWorkspace(projectRoot);
+
+    if (wsInfo.isInWorkspace && wsInfo.workspaceRoot) {
+      const wsResult = await vectorIndexer.indexAll(wsInfo.workspaceRoot);
+      return {
+        indexed: projectResult.indexed + wsResult.indexed,
+        skipped: projectResult.skipped + wsResult.skipped,
+        errors: projectResult.errors + wsResult.errors,
+      };
+    }
+
+    return projectResult;
+  }
+
+  return { search, indexAll };
+}