@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/utils-branches.test.js

@@ -0,0 +1,161 @@
+
+import { describe, it, expect, vi } from 'vitest';
+import { smartChunk } from '../lib/utils.js';
+
+describe('Utils Branch Coverage', () => {
+  const mockConfig = { embeddingModel: 'mock-model' };
+  
+  // Mock tokenizer to return predictable token counts
+  vi.mock('../lib/tokenizer.js', () => ({
+    estimateTokens: (str) => str.length,
+    getChunkingParams: () => ({
+        maxTokens: 50,
+        targetTokens: 30, // Trigger splitting heuristics
+        overlapTokens: 5
+    })
+  }));
+
+  describe('smartChunk', () => {
+    it('should ignore short chunks when flushing oversized line (line 255 branch)', () => {
+        // Condition:
+        // 1. currentChunk.length > 0 (lines 253)
+        // 2. new line causes token limit exceeded (line 252)
+        // 3. currentChunk text ("<20 chars") triggers line 255 check (chunkText.trim().length > 20)
+        
+        // Setup:
+        // Chunk 1: "short" (5 chars)
+        // Chunk 2: "very_long_line_that_exceeds_max_tokens_continuously_to_trigger_split" (60+ chars)
+        
+        const content = "short\n" + "x".repeat(60);
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        // Verification:
+        // "short" should NOT be emitted as a standalone chunk because it is < 20 chars
+        // The oversized line will be split and emitted.
+        
+        const shortChunk = chunks.find(c => c.text === 'short');
+        expect(shortChunk).toBeUndefined();
+        
+        // Check that oversized line IS produced (sanity check)
+        expect(chunks.length).toBeGreaterThan(0);
+    });
+
+    it('should ignoring short chunks when splitting (line 309 branch)', () => {
+        // Condition:
+        // 1. shouldSplit is true (line 301)
+        // 2. safeToSplit is true (line 305)
+        // 3. currentChunk.length > 0 (line 307)
+        // 4. currentChunk text < 20 chars (line 309)
+        
+        // Setup:
+        // maxTokens=50, targetTokens=30.
+        // Line 1: "short" (5 tokens)
+        // Line 2: "medium_length_line_to_trigger_limit" (35 tokens)
+        // Total 40 > 30 (target).
+        // Split should happen.
+        // "short" is flushed. < 20 chars -> dropped.
+        
+        const content = "short\n" + "m".repeat(35);
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        // "short" is dropped
+        const shortChunk = chunks.find(c => c.text === 'short');
+        expect(shortChunk).toBeUndefined();
+        
+        // The medium line should start a new chunk?
+        // Or be added to next?
+        // Logic: 
+        // if (shouldSplit...) { flush current; overlap...; current = overlap; }
+        // then push current line.
+        
+        // So "short" is flushed (dropped).
+        // Then overlap (short) becomes new current?
+        // Wait, line 319 overlap logic uses currentChunk.
+        // If "short" is < 20, it is NOT pushed to chunks.
+        // BUT it IS used for overlap!
+        // So new chunk starts with "short" + "medium..."?
+        
+        // If overlapTokens=5, "short" (5 chars) fits?
+        // If so, next chunk = "short\nmedium..."
+        
+        // Let's inspect results
+        // We expect NO chunk that is JUST "short"
+        expect(chunks.some(c => c.text.trim() === 'short')).toBe(false);
+    });
+
+    it('should handle multi-line comment continuation (line 198)', () => {
+        // Condition:
+        // 1. inComment = true (lines 196)
+        // 2. line includes '*/' (line 198)
+        
+        // Setup:
+        // Line 1: "/*" -> sets inComment=true
+        // Line 2: " content */ code"
+        
+        const content = "/*\n content */ code \n" + "x".repeat(30); 
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        // Just verify it doesn't crash and logic flows
+        // This is mainly for coverage
+        expect(chunks.length).toBeGreaterThan(0);
+    });
+
+    it('should handle multi-line comment middle lines (line 198 false branch)', () => {
+        // Condition:
+        // 1. inComment = true
+        // 2. line DOES NOT include '*/'
+        
+        // Setup:
+        // Line 1: "/*" (starts comment)
+        // Line 2: " middle line without end token " (inComment=true, .includes('*/')=false)
+        // Line 3: "*/" (ends comment)
+        
+
+
+
+        const content = "/*\n middle line that is sufficiently long to not be dropped \n*/\n" + "x".repeat(40);
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        console.error('Chunks produced:', chunks.map(c => c.text));
+
+        // Should produce chunks
+        expect(chunks.length).toBeGreaterThan(0);
+        
+        // At least one chunk should contain "middle line"
+        // (It might be merged with others or in its own chunk)
+
+        const hasText = chunks.some(c => c.text.includes('middle line'));
+        expect(hasText).toBe(true);
+    });
+
+    it('should flush long chunk when encountering oversized line (line 255/256 true branch)', () => {
+        // Condition:
+        // 1. currentChunk > 20 chars
+        // 2. Next line is oversized -> triggers flush
+        
+        const longText = "this is a sufficiently long line to be preserved";
+        const content = longText + "\n" + "x".repeat(60);
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        // Assert the long text is preserved in its own chunk
+        const preservedChunk = chunks.find(c => c.text === longText);
+        expect(preservedChunk).toBeDefined();
+    });
+
+
+    it('should flush long chunk when splitting (line 309/310 true branch)', () => {
+        // Condition:
+        // 1. shouldSplit = true
+        // 2. currentChunk > 20 chars -> triggers flush
+        
+        // Needs to be < maxTokens (50) but > 20 chars
+        const longText = "line preserved during split"; // 27 chars
+        const content = longText + "\n" + "m".repeat(35); // 35 tokens. Total 27+35 = 62 > 30 target.
+        const chunks = smartChunk(content, 'test.js', mockConfig);
+        
+        // Assert preserved
+        const hasText = chunks.some(c => c.text.includes(longText));
+        expect(hasText).toBe(true);
+    });
+  });
+});

package/test/utils-extra.test.js

@@ -0,0 +1,116 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { smartChunk, MODEL_TOKEN_LIMITS } from '../lib/utils.js';
+
+describe('utils.js extra coverage', () => {
+  const originalLimits = { ...MODEL_TOKEN_LIMITS };
+
+  afterEach(() => {
+    // Restore limits
+    for (const key in MODEL_TOKEN_LIMITS) delete MODEL_TOKEN_LIMITS[key];
+    Object.assign(MODEL_TOKEN_LIMITS, originalLimits);
+  });
+
+  it('handles multi-line comment start (line 198 coverage)', () => {
+    // This triggers the case where '/*' is found but '*/' is NOT on the same line.
+    // The code should break the inner loop and set inComment=true.
+    const content = 'const a = 1; /* start comment\n end comment */ const b = 2;';
+    const config = { embeddingModel: 'test-model' };
+    
+    // We expect smartChunk to handle this gracefully without crashing
+    // and correctly identify lines.
+    const chunks = smartChunk(content, 'test.js', config);
+    expect(chunks.length).toBeGreaterThan(0);
+    // Ensure content is preserved
+    expect(chunks[0].text).toContain('const a = 1');
+    expect(chunks[0].text).toContain('const b = 2');
+  });
+
+  it('flushes current chunk when encountering oversized line (line 255 coverage)', () => {
+    // Set a very small token limit
+    MODEL_TOKEN_LIMITS['test-oversize'] = 20;
+    
+    // Line 1: fits (approx 5 tokens) but needs to be > 20 chars to be kept
+    const line1 = 'const small = 1; // padding to exceed 20 chars'; 
+    // Line 2: huge (exceeds 20 tokens)
+    const line2 = 'x '.repeat(50); 
+    
+    const content = `${line1}\n${line2}`;
+    const config = { embeddingModel: 'test-oversize' };
+
+    const chunks = smartChunk(content, 'test.js', config);
+
+    // Should have flushed line1 as a separate chunk before processing line2
+    // Chunk 1: line1
+    // Chunk 2+: parts of line2
+    expect(chunks[0].text.trim()).toBe(line1);
+    expect(chunks.length).toBeGreaterThan(1);
+  });
+
+  it('stops overlap calculation when limit is reached (line 309 coverage)', () => {
+    // Set limit such that overlapTokens is small.
+    // Max=100 -> Target=85 -> Overlap=15.
+    MODEL_TOKEN_LIMITS['test-overlap'] = 100;
+    
+    // We need lines that sum > 15 tokens.
+    // "const x = 1;" is approx 5-6 tokens.
+    const line = 'const val = 123456;'; // ~6-8 tokens
+    
+    // Create enough lines to force a split and trigger overlap calculation
+    // With target=85, ~15 lines will trigger a split.
+    const lines = Array(20).fill(line);
+    const content = lines.join('\n');
+    const config = { embeddingModel: 'test-overlap' };
+
+    const chunks = smartChunk(content, 'test.js', config);
+
+    // Check that we have chunks
+    expect(chunks.length).toBeGreaterThan(1);
+    
+    // The implementation of overlap (lines 300+) loops backwards.
+    // It should stop adding lines to overlap once 15 tokens are exceeded.
+    // If we have 3 lines of 8 tokens:
+    // 1. Add line 20 (8 tok). Total 8. <= 15. OK.
+    // 2. Add line 19 (8 tok). Total 16. > 15. BREAK (Line 309).
+    
+        // Verification is implicit: if it didn't break, it would add more lines 
+        // than allowed to the overlap. 
+        // We can check strictly if the overlap size is bounded, 
+        // but primarily we just want to ensure the code path is executed.
+      });
+    
+      it('handles oversized line with empty chunk (line 255 false path coverage)', () => {
+        MODEL_TOKEN_LIMITS['test-oversize-empty'] = 20;
+        
+        // Huge line at the start. currentChunk is empty.
+        const hugeLine = 'x '.repeat(50);
+        const content = hugeLine;
+        const config = { embeddingModel: 'test-oversize-empty' };
+    
+        const chunks = smartChunk(content, 'test.js', config);
+    
+        // Should process the huge line directly without crashing or duplicating
+        expect(chunks.length).toBeGreaterThan(0);
+        expect(chunks[0].text.length).toBeGreaterThan(0);
+      });
+    
+      it('terminates overlap loop when limit is exactly reached (line 309 loop condition coverage)', () => {
+        // Limit=100 -> Target=85 -> Overlap=15.
+        MODEL_TOKEN_LIMITS['test-overlap-exact'] = 100;
+        
+        // Construct lines that are exactly 5 tokens.
+        // "a b c" -> 3 words + 2 (cls/sep) = 5 tokens.
+        const line = 'a b c'; 
+        
+        // We want to fill overlap exactly to 15 (3 lines).
+        // Provide enough lines to trigger split.
+        const lines = Array(30).fill(line);
+        const content = lines.join('\n');
+        const config = { embeddingModel: 'test-overlap-exact' };
+    
+        const chunks = smartChunk(content, 'test.js', config);
+    
+        expect(chunks.length).toBeGreaterThan(1);
+        // Implicitly covers the case where loop terminates because overlapTokensCount < overlapTokens becomes false
+        // instead of breaking via 'else { break }'.
+      });
+    });

package/test/utils.test.js

@@ -0,0 +1,131 @@
+/**
+ * Tests for utils helpers not covered elsewhere
+ */
+
+import { describe, it, expect } from 'vitest';
+import { smartChunk, MODEL_TOKEN_LIMITS } from '../lib/utils.js';
+
+describe('smartChunk', () => {
+  it('handles inline block comments on the same line', () => {
+    const content = '/* inline comment */ const x = 1;\nfunction test() { return x; }';
+    const config = { embeddingModel: 'jinaai/jina-embeddings-v2-base-code' };
+
+    const chunks = smartChunk(content, 'example.js', config);
+
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(chunks[0].text).toContain('const x = 1');
+  });
+
+  it('handles block comments that end mid-line', () => {
+    const content = '/* start comment\nend */ const y = 2;\nfunction ok() { return y; }';
+    const config = { embeddingModel: 'jinaai/jina-embeddings-v2-base-code' };
+
+    const chunks = smartChunk(content, 'example.js', config);
+
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(chunks[0].text).toContain('const y = 2');
+  });
+
+  it('splits large content respecting boundaries and overlap', () => {
+    // Generate content larger than typical token limit
+    const lines = [];
+    for (let i = 0; i < 500; i++) {
+      lines.push(`function function_${i}() { return ${i}; }`);
+    }
+    const content = lines.join('\n');
+
+    // Mock config with small limit to force frequent splitting
+    // Note: getChunkingParams returns fixed values usually, unless mocked.
+    // But we can rely on default limits (usually ~1000 tokens)
+    // 500 lines of code should trigger split.
+
+    const config = { embeddingModel: 'test-model' };
+    const chunks = smartChunk(content, 'test.js', config);
+
+    expect(chunks.length).toBeGreaterThan(1);
+    // Check overlap
+    if (chunks.length > 1) {
+      // First few lines of chunk 2 should be in chunk 1 (if overlap exists)
+      // This validates lines 255-280 (split logic)
+    }
+  });
+
+  it('handles complex syntax state tracking', () => {
+    const content = `
+      function test() {
+        const str = "string with { brace } and /* comment */ inside";
+        const str2 = 'single quote with " inside';
+        const escape = "escaped \\" quote and \\\\ backslash"; // Hit line 197
+        const escape2 = 'escaped \\' quote'; 
+        
+        const str3 = \`template with \${val} inside\`;
+        // Line comment with { brace }
+        /* Block comment 
+           with { brace } */ const trailing = 1; // Hit line 183
+        
+        /* Clean end 
+           comment */
+        
+        /* inline block */ const after = 1;
+        
+        if (true) {
+           return { val: [1, 2] };
+        }
+      }
+    `;
+    const config = { embeddingModel: 'test-model' };
+    smartChunk(content, 'test.js', config);
+    // Mainly ensuring no crash and coverage of state machine (lines 176-230)
+  });
+
+  it('splits chunks when target token budget is exceeded', () => {
+    MODEL_TOKEN_LIMITS['test-split'] = 18;
+    const line = 'alpha beta gamma delta';
+    const content = `${line}\n${line}\n${line}`;
+    const config = { embeddingModel: 'test-split' };
+
+    const chunks = smartChunk(content, 'test.js', config);
+
+    expect(chunks.length).toBeGreaterThan(1);
+    expect(chunks[0].text.trim().length).toBeGreaterThan(20);
+  });
+
+  it('splits oversized lines and keeps long chunks', () => {
+    MODEL_TOKEN_LIMITS['test-tiny-oversize'] = 12;
+    const firstLine = 'alpha beta gamma delta';
+    const secondLine = 'one two three four five six seven eight nine ten eleven';
+    const content = `${firstLine}\n${secondLine}`;
+    const config = { embeddingModel: 'test-tiny-oversize' };
+
+    const chunks = smartChunk(content, 'test.txt', config);
+
+    expect(chunks.some((chunk) => chunk.text.includes(firstLine))).toBe(true);
+    expect(chunks.some((chunk) => chunk.text.length > 20)).toBe(true);
+  });
+
+  it('handles empty input', () => {
+    expect(smartChunk('', 'test.js', {})).toEqual([]);
+  });
+});
+
+import { dotSimilarity, hashContent } from '../lib/utils.js';
+
+describe('Similarity Metrics', () => {
+  it('dotSimilarity calculates correct dot product', () => {
+    const a = [1, 2, 3];
+    const b = [4, 5, 6];
+    // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
+    expect(dotSimilarity(a, b)).toBe(32);
+  });
+});
+
+describe('Hashing', () => {
+  it('hashContent produces stable MD5 hex', () => {
+    const content = 'hello world';
+    const hash = hashContent(content);
+    expect(typeof hash).toBe('string');
+    expect(hash).toHaveLength(32); // MD5 hex
+    expect(hash).toBe(hashContent(content)); // Deterministic
+    expect(hash).not.toBe(hashContent('goodbye'));
+  });
+});

package/test/verify_fixes.js

@@ -0,0 +1,76 @@
+import { loadConfig } from '../lib/config.js';
+import { CodebaseIndexer } from '../features/index-codebase.js';
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function verify() {
+  console.log('--- Verifying Fixes ---');
+
+  // 1. Verify Config: embeddingProcessPerBatch default
+  console.log('1. Checking config defaults...');
+  const config = await loadConfig(); 
+  
+  if (config.embeddingProcessPerBatch === false) {
+     console.log('✅ embeddingProcessPerBatch is false by default');
+  } else {
+     console.log('⚠️ embeddingProcessPerBatch is true');
+  }
+
+  // 2. Verify Config: workerThreads 'auto' resolution
+  console.log(`   Resolved workerThreads: ${config.workerThreads}`);
+  
+  if (config.workerThreads !== 'auto' && typeof config.workerThreads === 'number') {
+      const cpus = os.cpus().length;
+      // If config.json has 0, it stays 0. We'll check if the logic allows auto cap.
+      // We manually test the auto logic here since loadConfig might load from file.
+      const mockConfig = { workerThreads: 'auto' };
+      // Simulate the logic we added to config.js:
+      if (mockConfig.workerThreads === 'auto') {
+        const calculated = Math.max(1, Math.min(2, cpus - 1));
+        console.log(`✅ Auto logic would resolve to: ${calculated}`);
+      }
+  }
+
+  // 3. Verify CodebaseIndexer uses workers
+  console.log('2. Checking CodebaseIndexer worker logic...');
+  const mockConfig = { 
+      workerThreads: 2, 
+      embeddingProcessPerBatch: false,
+      excludePatterns: [],
+      searchDirectory: process.cwd()
+  };
+  const indexer = new CodebaseIndexer({}, {}, mockConfig);
+  
+  const useWorkers = indexer.shouldUseWorkers();
+  if (useWorkers) {
+      console.log('✅ shouldUseWorkers() is TRUE when embeddingProcessPerBatch is false');
+  } else {
+      console.error('❌ shouldUseWorkers() should be TRUE');
+  }
+
+  // 4. Verify Ignore Logic
+  console.log('3. Checking .gitignore logic...');
+  try {
+      await fs.writeFile('.gitignore', 'secret_folder/\n*.secret', 'utf8');
+      await indexer.loadGitignore();
+      
+      const isExcludedDirectory = indexer.isExcluded('secret_folder/file.txt');
+      const isExcludedFile = indexer.isExcluded('app.secret');
+      const isIncluded = indexer.isExcluded('app.js');
+      
+      if (isExcludedDirectory && isExcludedFile && !isIncluded) {
+          console.log('✅ .gitignore logic is working correctly');
+      } else {
+          console.error(`❌ .gitignore failure: dir=${isExcludedDirectory}, file=${isExcludedFile}, valid=${!isIncluded}`);
+      }
+      
+      await fs.unlink('.gitignore');
+  } catch (e) {
+      console.error('Test setup failed:', e);
+  }
+
+  console.log('--- Verification Complete ---');
+}
+
+verify().catch(console.error);

package/test/worker-errors.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventEmitter } from 'events';
+
+// Enable worker error tests by default since we mock the worker properly
+const runWorkerErrors = true;
+const maybeDescribe = describe;
+
+maybeDescribe('Worker Error Handling', () => {
+  let indexer;
+  let config;
+  let cache;
+  let workers;
+  let WorkerConstructor;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    workers = [];
+    WorkerConstructor = vi.fn(function () {
+      const worker = new EventEmitter();
+      worker.postMessage = vi.fn();
+      worker.terminate = vi.fn();
+      worker.threadId = workers.length + 1;
+      workers.push(worker);
+      queueMicrotask(() => {
+        worker.emit('message', { type: 'ready' });
+      });
+      return worker;
+    });
+
+    vi.doMock('worker_threads', () => ({
+      Worker: WorkerConstructor,
+    }));
+
+    vi.doMock('os', () => ({
+      default: { cpus: () => [{}, {}, {}, {}] },
+      cpus: () => [{}, {}, {}, {}],
+    }));
+
+    // Dynamic import
+    const { CodebaseIndexer } = await import('../features/index-codebase.js');
+
+    config = {
+      workerThreads: 2,
+      verbose: true,
+      embeddingModel: 'test',
+    };
+
+    cache = {
+      addToStore: vi.fn(),
+    };
+
+    indexer = new CodebaseIndexer(vi.fn(), cache, config, null);
+
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should handle offline workers and fallback', async () => {
+    const initPromise = indexer.initializeWorkers();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await initPromise;
+
+    const chunks = [{ text: 'a' }, { text: 'b' }];
+    const fallbackSpy = vi.spyOn(indexer, 'processChunksSingleThreaded').mockResolvedValue([]);
+
+    const promise = indexer.processChunksWithWorkers(chunks);
+
+    // Trigger error
+    await new Promise((r) => setTimeout(r, 10));
+
+    try {
+      // Emit error on the event emitter.
+      // The indexer attached a listener via 'once'.
+      // Vitest might complain if unhandled, so we wrap.
+      workers[0].emit('error', new Error('Worker crash'));
+    } catch (_e) { /* ignore */ }
+
+    await promise;
+
+    expect(fallbackSpy).toHaveBeenCalled();
+    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Worker 0 crashed'));
+  });
+
+  it('should handle worker startup failure', async () => {
+    WorkerConstructor.mockImplementationOnce(function () {
+      throw new Error('Init bad');
+    });
+    await indexer.initializeWorkers();
+    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to create worker'));
+  });
+});

package/test/worker-init.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CodebaseIndexer } from '../features/index-codebase.js';
+
+// Mock worker_threads
+vi.mock('worker_threads', async () => {
+  const { EventEmitter } = await import('events');
+  class Worker extends EventEmitter {
+    constructor(path, options) {
+      super();
+      this.path = path;
+      this.options = options;
+
+      // Simulate async initialization
+      setTimeout(() => {
+        if (options.workerData && options.workerData.embeddingModel === 'fail-model') {
+          this.emit('message', { type: 'error', error: 'Simulated Init Failure' });
+        } else {
+          this.emit('message', { type: 'ready' });
+        }
+      }, 10);
+    }
+    terminate() {
+      return Promise.resolve();
+    }
+    postMessage(msg) {}
+  }
+  return { Worker };
+});
+
+// Mock os to ensure we have multiple CPUs
+vi.mock('os', async () => {
+  const actual = await vi.importActual('os');
+  return {
+    ...actual,
+    default: {
+      ...actual, // Spread actual properties to default for default import compatibility
+      cpus: () => [{}, {}, {}, {}], // 4 CPUs
+    },
+    cpus: () => [{}, {}, {}, {}], // Named export
+  };
+});
+
+describe('CodebaseIndexer Worker Initialization', () => {
+  let indexer;
+  let config;
+  let cache;
+  let embedder;
+
+  beforeEach(() => {
+    config = {
+      workerThreads: 2,
+      verbose: true,
+      embeddingModel: 'test-model',
+    };
+    cache = {
+      save: vi.fn(),
+      getVectorStore: () => [],
+    };
+    embedder = vi.fn();
+    indexer = new CodebaseIndexer(embedder, cache, config);
+  });
+
+  afterEach(async () => {
+    await indexer.terminateWorkers();
+    vi.restoreAllMocks();
+  });
+
+  it('should initialize workers successfully and handle ready message (Line 132)', async () => {
+    // This triggers initializeWorkers with 2 workers
+    // The mock Worker emits "ready", so line 132 should be executed
+    await indexer.initializeWorkers();
+
+    expect(indexer.workers.length).toBe(2);
+    // Also verify workers are in the array
+    expect(indexer.workers[0]).toBeDefined();
+  });
+
+  it('should handle worker initialization failure (Line 134)', async () => {
+    config.embeddingModel = 'fail-model';
+    // This will cause the mock worker to emit "error"
+    // initializeWorkers catches the error and falls back to single threaded
+    // But specifically we want to see if it catches the error from the promise.
+
+    // initializeWorkers catches errors internally and logs them, then terminates workers.
+    // It doesn't throw.
+
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await indexer.initializeWorkers();
+
+    // It should have failed to initialize workers, so workers array should be empty
+    // (because terminateWorkers is called in catch block)
+    expect(indexer.workers.length).toBe(0);
+
+    // Check if error was logged
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Worker initialization failed')
+    );
+
+    consoleSpy.mockRestore();
+  });
+});