@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/final-polish.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CodebaseIndexer, handleToolCall } from '../features/index-codebase.js';
+import { EmbeddingsCache } from '../lib/cache.js';
+import fs from 'fs/promises';
+
+// Mock dependencies
+vi.mock('fs/promises');
+vi.mock('../lib/call-graph.js', () => ({
+  extractCallData: vi.fn().mockReturnValue({}),
+}));
+vi.mock('../lib/utils.js', async () => {
+  const actual = await vi.importActual('../lib/utils.js');
+  return {
+    ...actual,
+    hashContent: vi.fn().mockReturnValue('fixed-hash'),
+    smartChunk: actual.smartChunk,
+  };
+});
+vi.mock('worker_threads', async () => {
+  const { EventEmitter } = await import('events');
+  class Worker extends EventEmitter {
+    constructor() {
+      super();
+      setTimeout(() => this.emit('message', { type: 'ready' }), 1);
+    }
+    terminate() {
+      return Promise.resolve();
+    }
+    postMessage(msg) {
+      if (msg.type === 'process') {
+        this.emit('message', { type: 'results', results: [], batchId: msg.batchId });
+      }
+    }
+  }
+  return { Worker };
+});
+
+vi.mock('os', async () => {
+  return {
+    default: { cpus: () => [{}, {}, {}, {}] },
+    cpus: () => [{}, {}, {}, {}],
+  };
+});
+
+describe('Final Polish Coverage', () => {
+  let indexer;
+  let config;
+  let cache;
+  let embedder;
+
+  beforeEach(() => {
+    config = {
+      workerThreads: 2,
+      verbose: true,
+      embeddingModel: 'test-model',
+      searchDirectory: '/test',
+      maxFileSize: 100,
+      fileExtensions: ['js'],
+      excludePatterns: [],
+      callGraphEnabled: true,
+    };
+
+    cache = {
+      save: vi.fn(),
+      getVectorStore: vi.fn().mockReturnValue([]),
+      setVectorStore: vi.fn(),
+      fileHashes: new Map(),
+      fileCallData: new Map(),
+      getFileHash: vi.fn(),
+      setFileHash: vi.fn(),
+      removeFileFromStore: vi.fn(),
+      addToStore: vi.fn(),
+      setFileCallData: vi.fn(),
+      clearCallGraphData: vi.fn(),
+      pruneCallGraphData: vi.fn(),
+      rebuildCallGraph: vi.fn(),
+      ensureAnnIndex: vi.fn().mockResolvedValue(),
+      deleteFileHash: vi.fn(),
+      setLastIndexDuration: vi.fn(),
+      setLastIndexStats: vi.fn(),
+      setFileHashes: vi.fn((map) => { cache.fileHashes = map; }),
+      getFileHashKeys: vi.fn().mockImplementation(() => [...cache.fileHashes.keys()]),
+      getFileCallDataKeys: vi.fn().mockImplementation(() => [...cache.fileCallData.keys()]),
+      setFileCallDataEntries: vi.fn((map) => { cache.fileCallData = map; }),
+      clearFileCallData: vi.fn(() => { cache.fileCallData = new Map(); }),
+      getFileMeta: vi.fn(),
+    };
+
+    embedder = vi.fn().mockResolvedValue({ data: [] });
+
+    indexer = new CodebaseIndexer(embedder, cache, config);
+    indexer.discoverFiles = vi.fn().mockResolvedValue(['/test/file1.js']);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('lib/cache.js', () => {
+    it('handles invalid JSON in cache metadata (line 123)', async () => {
+      // While targeting 673, let's also cover metadata parsing failure if needed
+      const config = { enableCache: true, cacheDirectory: '/c' };
+      const cache = new EmbeddingsCache(config);
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      vi.spyOn(fs, 'mkdir').mockResolvedValue();
+      // Return invalid JSON for meta
+      vi.spyOn(fs, 'readFile').mockImplementation(async (p) => {
+        if (p.endsWith('meta.json')) return '{ invalid';
+        return null;
+      });
+
+      await cache.load();
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid cache metadata'));
+    });
+
+    it('handles ANN metadata rebuilding (line 332)', async () => {
+      // Just extra coverage for ANN loading
+      const config = { enableCache: true, cacheDirectory: '/c', annEnabled: true };
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ vector: [1] }];
+
+      vi.spyOn(fs, 'readFile').mockResolvedValue('invalid-json');
+
+      const loaded = await cache.loadAnnIndexFromDisk({}, 1);
+      expect(loaded).toBe(false);
+    });
+  });
+
+  describe('features/index-codebase.js', () => {
+    it('handles stat errors in preFilterFiles (line 483)', async () => {
+      // Direct target for 515-516
+      vi.spyOn(fs, 'stat').mockRejectedValue(new Error('Stat Fail'));
+      const files = ['/test/bad.js'];
+
+      // Directly call the method
+      const results = await indexer.preFilterFiles(files);
+      expect(results).toEqual([]);
+      // We can't easily assert on `skippedCount` local var, but result length 0 implies it filtered.
+    });
+
+    it('triggers call-graph data re-indexing (line 578)', async () => {
+      // Target 662
+      const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+      // 1. All files unchanged initially
+      cache.getVectorStore.mockReturnValue([{ file: '/test/file1.js' }]);
+      cache.clearFileCallData(); // Empty!
+      cache.setFileHashes(new Map([['/test/file1.js', 'fixed-hash']]));
+      cache.getFileHash.mockReturnValue('fixed-hash');
+      cache.getFileMeta.mockReturnValue({ mtimeMs: 123, size: 50 });
+
+      // Mock fs to pass pre-check and processing
+      vi.spyOn(fs, 'stat').mockResolvedValue({ isDirectory: () => false, size: 50, mtimeMs: 123 });
+      vi.spyOn(fs, 'readFile').mockResolvedValue('content');
+
+      await indexer.indexAll(false);
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('missing call graph data'));
+      expect(cache.setFileCallData).toHaveBeenCalled();
+    });
+
+    it('returns 0 on indexFile error (line 343)', async () => {
+      vi.spyOn(fs, 'stat').mockRejectedValue(new Error('Stat Fail'));
+      const result = await indexer.indexFile('/test/bad.js');
+      expect(result).toBe(0);
+    });
+
+    it('reports processed files in tool response (line 992)', async () => {
+      // Mock indexAll result
+      indexer.indexAll = vi.fn().mockResolvedValue({
+        filesProcessed: 5,
+        chunksCreated: 10,
+        totalFiles: 5,
+        totalChunks: 10,
+      });
+
+      const request = { params: { arguments: { force: true } } };
+      const result = await handleToolCall(request, indexer);
+
+      expect(result.content[0].text).toContain('Files processed this run: 5');
+    });
+  });
+});

package/test/final.test.js

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { extractDefinitions } from '../lib/call-graph.js';
+import { ProjectDetector } from '../lib/project-detector.js';
+import { EmbeddingsCache } from '../lib/cache.js';
+import fs from 'fs/promises';
+
+vi.mock('fs/promises');
+
+describe('Final Coverage Gaps', () => {
+  describe('lib/call-graph.js fallback language', () => {
+    it('handles unknown extensions by falling back to javascript patterns', () => {
+      const content = 'function unknownExt() {}';
+      const definitions = extractDefinitions(content, 'test.unknown');
+      expect(definitions).toContain('unknownExt');
+    });
+  });
+
+  describe('lib/project-detector.js edge cases', () => {
+    it('hits depth limit and ignores deep directories', async () => {
+      const detector = new ProjectDetector('/root');
+      vi.mocked(fs.readdir).mockResolvedValue([{ name: 'dir1', isDirectory: () => true }]);
+
+      // We want to trigger depth > 2 return in checkDir
+      // initializeWorkers logic is recursive.
+      await detector.detectProjectTypes();
+      // Coverage should show line 16 hit
+    });
+
+    it('handles missing ignore pattern for detected type', () => {
+      const detector = new ProjectDetector('/root');
+      // Force a type that doesn't exist in IGNORE_PATTERNS
+      detector.detectedTypes.add('mystery-project');
+      const patterns = detector.getSmartIgnorePatterns();
+      expect(patterns).toBeDefined();
+      expect(patterns.length).toBeGreaterThan(0); // Should still have common patterns
+    });
+  });
+
+  describe('lib/cache.js edge cases', () => {
+    it('covers initHnswIndex deeper retry branches', () => {
+      const mockIndex = {
+        initIndex: vi
+          .fn()
+          .mockImplementationOnce(() => {
+            throw new Error('fail 1');
+          })
+          .mockImplementationOnce(() => {
+            throw new Error('fail 2');
+          })
+          .mockReturnValue(true),
+      };
+      // External functions aren't directly exportable, but we can hit them via buildAnnIndex
+      // or by importing the private functions if we were in a different setup.
+      // Since cache.js doesn't export initHnswIndex, we use buildAnnIndex.
+
+      const cache = new EmbeddingsCache({ annMetric: 'l2' });
+      cache.vectorStore = [{ vector: [1, 2] }];
+
+      // Use function instead of arrow for constructor
+      const HierarchicalNSW = vi.fn(function () {
+        return mockIndex;
+      });
+      cache.buildAnnIndex(HierarchicalNSW, 2);
+
+      expect(mockIndex.initIndex).toHaveBeenCalledTimes(3);
+    });
+
+    it('covers clearCallGraphData error logging', async () => {
+      const cache = new EmbeddingsCache({
+        enableCache: true,
+        cacheDirectory: '/path',
+        verbose: true,
+      });
+      vi.mocked(fs.rm).mockRejectedValue(new Error('unlink failed'));
+
+      vi.spyOn(console, 'warn').mockImplementation(() => {});
+      await cache.clearCallGraphData({ removeFile: true });
+
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to remove call-graph cache')
+      );
+    });
+
+    it('covers getRelatedFiles missing graph path', async () => {
+      const cache = new EmbeddingsCache({ callGraphEnabled: true });
+      // Correct format for fileCallData: file -> { definitions: [], calls: [] }
+      cache.setFileCallData('f.js', { definitions: [], calls: [] });
+      // Avoid rebuildCallGraph which is async/lazy
+      cache.callGraph = null;
+
+      const result = await cache.getRelatedFiles(['sym']);
+      expect(result.size).toBe(0);
+    });
+  });
+});

package/test/find-similar-code.test.js

@@ -0,0 +1,191 @@
+import path from 'path';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  FindSimilarCode,
+  getToolDefinition,
+  handleToolCall,
+} from '../features/find-similar-code.js';
+
+const makeEmbedder = (vector) => vi.fn().mockResolvedValue({ data: Float32Array.from(vector) });
+
+describe('FindSimilarCode', () => {
+  it('returns a helpful message when the index is empty', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const cache = { getVectorStore: () => [], ensureLoaded: vi.fn() };
+    const config = { searchDirectory: process.cwd() };
+    const tool = new FindSimilarCode(embedder, cache, config);
+
+    const result = await tool.execute({ code: 'const x = 1;' });
+
+    expect(result.results).toEqual([]);
+    expect(result.message).toMatch(/No code has been indexed/);
+  });
+
+  it('dedupes ANN candidates and falls back when too few remain', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const vectorStore = [
+      {
+        file: 'C:/repo/a.js',
+        startLine: 1,
+        endLine: 2,
+        content: 'alpha',
+        vector: [1, 0],
+      },
+      {
+        file: 'C:/repo/b.js',
+        startLine: 3,
+        endLine: 4,
+        content: 'beta',
+        vector: [0.5, 0.5],
+      },
+    ];
+    const cache = {
+      getVectorStore: () => vectorStore,
+      queryAnn: vi.fn().mockResolvedValue([0, 0]),
+      getChunkVector: (chunk) => chunk.vector,
+      getChunkContent: (chunk) => chunk.content,
+      ensureLoaded: vi.fn(),
+    };
+    const config = {
+      annEnabled: true,
+      annCandidateMultiplier: 1,
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      searchDirectory: 'C:/repo',
+    };
+    const tool = new FindSimilarCode(embedder, cache, config);
+
+    const result = await tool.execute({
+      code: 'gamma',
+      maxResults: 2,
+      minSimilarity: 0,
+    });
+
+    expect(cache.queryAnn).toHaveBeenCalled();
+    expect(result.results.length).toBe(2);
+  });
+
+  it('skips exact text matches against the input', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const vectorStore = [
+      {
+        file: 'C:/repo/a.js',
+        startLine: 1,
+        endLine: 2,
+        content: 'same code',
+        vector: [1, 0],
+      },
+      {
+        file: 'C:/repo/b.js',
+        startLine: 3,
+        endLine: 4,
+        content: 'other code',
+        vector: [0, 1],
+      },
+    ];
+    const cache = {
+      getVectorStore: () => vectorStore,
+      queryAnn: vi.fn().mockResolvedValue([0, 1]),
+      getChunkVector: (chunk) => chunk.vector,
+      getChunkContent: (chunk) => chunk.content,
+      ensureLoaded: vi.fn(),
+    };
+    const config = { annEnabled: true, searchDirectory: 'C:/repo' };
+    const tool = new FindSimilarCode(embedder, cache, config);
+
+    const result = await tool.execute({
+      code: 'same code',
+      maxResults: 2,
+      minSimilarity: 0,
+    });
+
+    expect(result.results.length).toBe(1);
+    expect(result.results[0].content).toBe('other code');
+  });
+
+  it('handles ANN candidates that are below the minimum', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const vectorStore = [
+      {
+        file: 'C:/repo/a.js',
+        startLine: 1,
+        endLine: 2,
+        content: 'alpha',
+        vector: [1, 0],
+      },
+      {
+        file: 'C:/repo/b.js',
+        startLine: 3,
+        endLine: 4,
+        content: 'beta',
+        vector: [0, 1],
+      },
+    ];
+    const cache = {
+      getVectorStore: () => vectorStore,
+      queryAnn: vi.fn().mockResolvedValue([0]),
+      getChunkVector: (chunk) => chunk.vector,
+      getChunkContent: (chunk) => chunk.content,
+      ensureLoaded: vi.fn(),
+    };
+    const config = { annEnabled: true, searchDirectory: 'C:/repo' };
+    const tool = new FindSimilarCode(embedder, cache, config);
+
+    const result = await tool.execute({
+      code: 'gamma',
+      maxResults: 2,
+      minSimilarity: 0,
+    });
+
+    expect(result.results.length).toBe(2);
+  });
+
+  it('formats results with relative paths and code fences', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const cache = { getVectorStore: () => [], ensureLoaded: vi.fn() };
+    const config = { searchDirectory: 'C:/repo' };
+    const tool = new FindSimilarCode(embedder, cache, config);
+    const results = [
+      {
+        file: 'C:/repo/src/example.js',
+        startLine: 10,
+        endLine: 12,
+        content: 'const x = 1;',
+        similarity: 0.9,
+      },
+    ];
+
+    const formatted = await tool.formatResults(results);
+
+    expect(formatted).toContain(path.normalize('src/example.js'));
+    expect(formatted).toContain('```js');
+  });
+
+  it('returns a message when formatting empty results', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const cache = { getVectorStore: () => [], ensureLoaded: vi.fn() };
+    const config = { searchDirectory: 'C:/repo' };
+    const tool = new FindSimilarCode(embedder, cache, config);
+
+    await expect(tool.formatResults([])).resolves.toBe('No similar code patterns found in the codebase.');
+  });
+
+  it('handles tool calls with messages', async () => {
+    const embedder = makeEmbedder([1, 0]);
+    const cache = { getVectorStore: () => [], ensureLoaded: vi.fn() };
+    const config = { searchDirectory: 'C:/repo' };
+    const tool = new FindSimilarCode(embedder, cache, config);
+    const request = { params: { arguments: { code: 'x' } } };
+
+    const response = await handleToolCall(request, tool);
+
+    expect(response.content[0].text).toMatch(/No code has been indexed/);
+  });
+
+  it('exposes tool definition', () => {
+    const definition = getToolDefinition();
+
+    expect(definition.name).toBe('d_find_similar_code');
+    expect(definition.inputSchema.required).toContain('code');
+  });
+});

package/test/helpers.js

@@ -11,6 +11,8 @@ import { HybridSearch } from '../features/hybrid-search.js';
 import { pipeline } from '@xenova/transformers';
 import fs from 'fs/promises';
 import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
 
 // Cached embedder instance (shared across tests for speed)
 let sharedEmbedder = null;
@@ -23,9 +25,13 @@ const DEFAULT_MOCK_DIMENSIONS = 64;
  */
 export async function getEmbedder(config) {
   if (!sharedEmbedder) {
-    console.log('[TestHelper] Loading embedding model (first time)...');
+    if (config.verbose) {
+      console.error('[TestHelper] Loading embedding model (first time)...');
+    }
     sharedEmbedder = await pipeline('feature-extraction', config.embeddingModel);
-    console.log('[TestHelper] Embedding model loaded');
+    if (config.verbose) {
+      console.error('[TestHelper] Embedding model loaded');
+    }
   }
   return sharedEmbedder;
 }
@@ -62,10 +68,10 @@ function normalizeVector(vector) {
 function createMockEmbedder({ dimensions = DEFAULT_MOCK_DIMENSIONS } = {}) {
   return async (text, options = {}) => {
     const vector = new Float32Array(dimensions);
-    const tokens = String(text ?? "")
+    const tokens = String(text ?? '')
       .toLowerCase()
       .split(/[^a-z0-9_]+/g)
-      .filter(token => token.length > 1);
+      .filter((token) => token.length > 1);
 
     for (const token of tokens) {
       const index = hashToken(token) % dimensions;
@@ -82,17 +88,43 @@ function createMockEmbedder({ dimensions = DEFAULT_MOCK_DIMENSIONS } = {}) {
 }
 
 /**
- * Create test fixtures with initialized components
+ * Create test fixtures with initialized components and isolated environment
  * @param {Object} options - Options for fixture creation
  * @returns {Object} Initialized components for testing
  */
 export async function createTestFixtures(options = {}) {
+  // Create a unique temporary directory for this test run
+  const sessionId = crypto.randomBytes(6).toString('hex');
+  const tempRootDir = path.join(os.tmpdir(), `heuristic-mcp-test-${sessionId}`);
+  const searchDir = path.join(tempRootDir, 'project');
+  const cacheDir = path.join(tempRootDir, 'cache');
+
+  await fs.mkdir(searchDir, { recursive: true });
+  await fs.mkdir(cacheDir, { recursive: true });
+
+  // Create some dummy files in the fixture directory
+  // This prevents tests from indexing the real heuristic-mcp codebase
+  await fs.writeFile(
+    path.join(searchDir, 'test.js'),
+    'function hello() {\n  console.info("hello world");\n}\n\n// embedder CodebaseIndexer test fixture\nmodule.exports = { hello };'
+  );
+  await fs.writeFile(
+    path.join(searchDir, 'utils.py'),
+    'def add(a, b):\n    """Adds two numbers"""\n    return a + b\n\nif __name__ == "__main__":\n    print(add(2, 3))'
+  );
+  await fs.writeFile(path.join(searchDir, 'README.md'), '# Test Project\n\nThis is a test.');
+
+  // Load baseline config
   const config = await loadConfig();
 
-  // Override config for testing if needed
+  // Redirect to isolated test directories
+  config.searchDirectory = searchDir;
+  config.cacheDirectory = cacheDir;
+
+  // Override config for testing
   if (options.verbose !== undefined) config.verbose = options.verbose;
   if (options.workerThreads !== undefined) config.workerThreads = options.workerThreads;
-  if (isVitest()) config.workerThreads = 1;
+  if (isVitest() && options.forceWorkers !== true) config.workerThreads = 0;
 
   const useRealEmbedder = options.useRealEmbedder === true;
   const embedder = useRealEmbedder
@@ -107,12 +139,15 @@ export async function createTestFixtures(options = {}) {
   const hybridSearch = new HybridSearch(embedder, cache, config);
 
   return {
+    tempRootDir,
+    searchDir,
+    cacheDir,
     config,
     embedder,
     cache,
     indexer,
     cacheClearer,
-    hybridSearch
+    hybridSearch,
   };
 }
 
@@ -127,6 +162,15 @@ export async function cleanupFixtures(fixtures) {
       await fixtures.indexer.watcher.close();
     }
   }
+
+  // Remove temporary test directory
+  if (fixtures.tempRootDir) {
+    try {
+      await fs.rm(fixtures.tempRootDir, { recursive: true, force: true });
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+  }
 }
 
 /**
@@ -151,9 +195,46 @@ export function createMockRequest(toolName, args = {}) {
   return {
     params: {
       name: toolName,
-      arguments: args
-    }
+      arguments: args,
+    },
+  };
+}
+
+/**
+ * Create a standard cache stub for HybridSearch tests.
+ * Provides the full required interface with sensible defaults.
+ */
+export function createHybridSearchCacheStub({ vectorStore = [], ...overrides } = {}) {
+  let store = vectorStore;
+  const base = {
+    getVectorStore: () => store,
+    setVectorStore: (next) => {
+      store = Array.isArray(next) ? next : [];
+    },
+    getStoreSize: () => store.length,
+    getVector: (idx) => store[idx]?.vector ?? null,
+    getChunk: (idx) => store[idx] ?? null,
+    getChunkContent: async (chunkOrIndex) => {
+      if (typeof chunkOrIndex === 'number') {
+        return store[chunkOrIndex]?.content ?? null;
+      }
+      return chunkOrIndex?.content ?? null;
+    },
+    getChunkVector: (chunkOrIndex) => {
+      if (typeof chunkOrIndex === 'number') {
+        return store[chunkOrIndex]?.vector ?? null;
+      }
+      return chunkOrIndex?.vector ?? null;
+    },
+    queryAnn: async () => null,
+    getRelatedFiles: async () => new Map(),
+    getFileMeta: () => null,
+    startRead: () => {},
+    endRead: () => {},
+    waitForReaders: async () => {},
   };
+
+  return { ...base, ...overrides };
 }
 
 /**
@@ -167,7 +248,7 @@ export async function waitFor(condition, timeout = 5000, interval = 100) {
   const start = Date.now();
   while (Date.now() - start < timeout) {
     if (await condition()) return true;
-    await new Promise(resolve => setTimeout(resolve, interval));
+    await new Promise((resolve) => setTimeout(resolve, interval));
   }
   return false;
 }

package/test/helpers.test.js

@@ -0,0 +1,46 @@
+/**
+ * Additional coverage for test helpers
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('@xenova/transformers', () => ({
+  pipeline: vi.fn(async () => async () => ({
+    data: new Float32Array([1, 0, 0]),
+  })),
+}));
+
+import fs from 'fs/promises';
+import { pipeline } from '@xenova/transformers';
+import { createTestFixtures, getEmbedder, clearTestCache, waitFor } from './helpers.js';
+
+describe('Test helpers', () => {
+  it('caches embedder instance across calls', async () => {
+    const config = { embeddingModel: 'test-model' };
+    const first = await getEmbedder(config);
+    const second = await getEmbedder(config);
+
+    expect(first).toBe(second);
+    expect(pipeline).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates fixtures with mock embedder and normalization', async () => {
+    const fixtures = await createTestFixtures({ useRealEmbedder: false });
+    const output = await fixtures.embedder('', { normalize: true });
+
+    expect(output.data.length).toBeGreaterThan(0);
+    expect(fixtures.cache).toBeDefined();
+    expect(fixtures.indexer).toBeDefined();
+  });
+
+  it('handles clearTestCache errors gracefully', async () => {
+    const rmSpy = vi.spyOn(fs, 'rm').mockRejectedValue(new Error('boom'));
+    await expect(clearTestCache({ cacheDirectory: 'missing' })).resolves.toBeUndefined();
+    rmSpy.mockRestore();
+  });
+
+  it('waitFor returns false when condition is never met', async () => {
+    const result = await waitFor(async () => false, 50, 10);
+    expect(result).toBe(false);
+  });
+});