@softerist/heuristic-mcp 2.1.46 → 3.0.0

package/test/coverage-maximizer.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CodebaseIndexer, handleToolCall } from '../features/index-codebase.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Mock dependencies
+vi.mock('fs/promises');
+vi.mock('../lib/call-graph.js', () => ({
+  extractCallData: vi.fn(),
+}));
+vi.mock('../lib/utils.js', async () => {
+  const actual = await vi.importActual('../lib/utils.js');
+  return {
+    ...actual,
+    hashContent: vi.fn().mockReturnValue('fixed-hash'), // predictable 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('CodebaseIndexer Coverage Maximizer', () => {
+  let indexer;
+  let config;
+  let cache;
+  let embedder;
+  let extractCallDataMock;
+
+  beforeEach(async () => {
+    const callGraph = await import('../lib/call-graph.js');
+    extractCallDataMock = callGraph.extractCallData;
+    extractCallDataMock.mockReturnValue({}); // Default success
+
+    config = {
+      workerThreads: 2,
+      verbose: true, // Important for logging branches
+      embeddingModel: 'test-model',
+      searchDirectory: '/test',
+      maxFileSize: 100,
+      fileExtensions: ['js'],
+      excludePatterns: [],
+      callGraphEnabled: true,
+    };
+
+    const cacheMock = {
+      save: vi.fn(),
+      getVectorStore: vi.fn().mockReturnValue([]),
+      setVectorStore: vi.fn(),
+      reset: vi.fn(),
+      fileHashes: new Map(),
+      fileCallData: new Map(),
+      getFileHash: vi.fn(),
+      setFileHash: vi.fn(),
+      removeFileFromStore: vi.fn(),
+      addToStore: vi.fn(),
+      setFileCallData: vi.fn(),
+      setFileCallDataEntries: vi.fn((entries) => {
+        if (entries instanceof Map) {
+          cacheMock.fileCallData = entries;
+        } else {
+          cacheMock.fileCallData = new Map(Object.entries(entries || {}));
+        }
+      }),
+      clearFileCallData: vi.fn(() => {
+        cacheMock.fileCallData = new Map();
+      }),
+      clearCallGraphData: vi.fn(),
+      pruneCallGraphData: vi.fn().mockReturnValue(5), // Cover line 612 (if > 0)
+      rebuildCallGraph: vi.fn(),
+      ensureAnnIndex: vi.fn().mockResolvedValue(),
+      deleteFileHash: vi.fn(),
+      setLastIndexDuration: vi.fn(),
+      setLastIndexStats: vi.fn(),
+      setFileHashes: vi.fn((map) => { cacheMock.fileHashes = map; }),
+      getFileHashKeys: vi.fn().mockImplementation(() => [...cacheMock.fileHashes.keys()]),
+      getFileCallDataKeys: vi.fn().mockImplementation(() => [...cacheMock.fileCallData.keys()]),
+      getFileMeta: vi.fn(),
+    };
+    cache = cacheMock;
+
+    embedder = vi.fn().mockResolvedValue({ data: [] });
+
+    indexer = new CodebaseIndexer(embedder, cache, config);
+    // Mock discoverFiles to control input
+    indexer.discoverFiles = vi.fn().mockResolvedValue(['/test/file1.js']);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('Line 146: Worker initialization failure catch block', async () => {
+    // Actually, let's verify line 343: indexFile error handling.
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(fs, 'stat').mockRejectedValue(new Error('Stat failed'));
+
+    await indexer.indexFile('/test/bad.js');
+
+    // Expect 2 args
+    expect(warnSpy.mock.calls.length + errorSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  it('Line 357 & 362: indexFile size and directory checks', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    // 357: isDirectory
+    vi.spyOn(fs, 'stat').mockResolvedValue({
+      isDirectory: () => true,
+      size: 50,
+    });
+    await indexer.indexFile('/test/dir');
+
+    // 362: maxFileSize
+    vi.spyOn(fs, 'stat').mockResolvedValue({
+      isDirectory: () => false,
+      size: 1000, // > 100
+    });
+    await indexer.indexFile('/test/large.js');
+
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('too large'));
+  });
+
+  it('Lines 515-516: preFilterFiles error handling', async () => {
+    vi.spyOn(fs, 'stat').mockRejectedValue(new Error('PreFilter Fail'));
+
+    // Trigger preFilterFiles via indexAll or directly
+    const files = ['/test/bad.js'];
+    const results = await indexer.preFilterFiles(files);
+
+    // Should catch error and return null (filtered out)
+    expect(results.length).toBe(0);
+  });
+
+  it('Lines 603 & 612: indexAll pruning branches', async () => {
+    const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+    // Mock cached files that are NOT in discovered files
+    cache.setFileHashes(new Map([['/test/deleted.js', 'hash']]));
+    cache.setFileCallDataEntries(new Map([['/test/deleted.js', {}]]));
+
+    // discoverFiles returns ["/test/file1.js"] (mocked in beforeEach)
+
+    await indexer.indexAll(false); // force=false to enable pruning
+
+    expect(cache.removeFileFromStore).toHaveBeenCalledWith('/test/deleted.js');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Pruned 1 deleted/excluded files')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Pruned 5 call-graph entries'));
+  });
+
+  it('Line 662: indexAll missing call graph data re-indexing', async () => {
+    const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+    // Setup state
+    cache.getVectorStore.mockReturnValue([{ file: '/test/file1.js' }]);
+    cache.clearFileCallData(); // Empty, so file1.js is missing data
+    // Use fixed-hash to match mock
+    cache.setFileHashes(new Map([['/test/file1.js', 'fixed-hash']]));
+    cache.getFileHash.mockReturnValue('fixed-hash');
+    cache.getFileMeta.mockReturnValue({ mtimeMs: 123, size: 50 });
+
+    // Mock fs for re-indexing check
+    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'));
+    // Should have processed file1.js
+    expect(cache.setFileCallData).toHaveBeenCalled();
+  });
+
+  it('Line 746 & 773: indexAll loop and call graph extraction error', async () => {
+    // Force extractCallData to throw
+    extractCallDataMock.mockImplementation(() => {
+      throw new Error('Parse Error');
+    });
+
+    // Must ensure filesToProcess is NOT empty
+    vi.spyOn(fs, 'stat').mockResolvedValue({ isDirectory: () => false, size: 50, mtimeMs: 123 });
+    vi.spyOn(fs, 'readFile').mockResolvedValue('content');
+    // Ensure hash mismatch so it processes
+    cache.getFileHash.mockReturnValue('old-hash');
+
+    await indexer.indexAll(true);
+
+    expect(extractCallDataMock).toHaveBeenCalled();
+    expect(cache.setFileCallData).not.toHaveBeenCalled();
+  });
+
+  it('Line 992: handleToolCall stats', async () => {
+    const request = { params: { arguments: { force: true } } };
+
+    // Mock indexAll to return specific stats
+    indexer.indexAll = vi.fn().mockResolvedValue({
+      skipped: false,
+      filesProcessed: 5,
+      chunksCreated: 10,
+      totalFiles: 5,
+      totalChunks: 10,
+    });
+
+    const result = await handleToolCall(request, indexer);
+    expect(result.content[0].text).toContain('Files processed this run: 5');
+  });
+});

package/test/debug-analysis.js

@@ -0,0 +1,107 @@
+
+import { smartChunk } from './lib/utils.js';
+
+const mockConfig = { embeddingModel: 'mock-model' };
+
+// Mock tokenizer
+import { vi } from 'vitest';
+const estimateTokens = (str) => str.length;
+const getChunkingParams = () => ({
+    maxTokens: 50,
+    targetTokens: 30, 
+    overlapTokens: 5
+});
+
+// Mocking dependencies manually since we are running with node directly
+// We need to overwrite the imports in utils.js or mock them.
+// Since utils.js imports from tokenizer.js, we can't easily mock that with just node unless we use a loader or modify utils.js.
+// So instead, let's create a temporary modified version of utils.js or just run the test file with console.info and capture output.
+
+// Actually, I can use the existing test file but add logging there and run with `npm test ...` and look closer at output?
+// The previous run captured stderr, but maybe I missed it?
+// The output showed "Failed Tests 1", but no console.error output from my previous change.
+
+// Wait, I see "stderr | test/index-codebase-phase2.test.js" in previous logs, but not for utils-branches.test.js.
+// Vitest might suppress console output if test fails? Or implies it.
+
+// Let's rely on reading the code again manually.
+
+// Code:
+/*
+196:     if (inComment) {
+197:       // Look for end of block comment
+198:       if (line.includes('*\u002f')) {
+             ...
+200:         // If there's content after the comment, process it (simplified)
+201:         if (parts[parts.length - 1].trim().length > 0) {
+202:           inComment = false;
+204:           // We just assume the line is mixed and skip granular checks
+205:         } else {
+206:           inComment = false;
+207:         }
+208:       }
+209:     } 
+*/
+
+// If `inComment` is true and line does NOT include `*/`, it goes to... nowhere?
+// line 209 ends the `if (inComment)` block.
+// Then line 251: `// Split lines that are too large...`
+// Then line 336: `currentChunk.push(line);`
+
+// Wait. If `inComment` is true, we just skip the character analysis (lines 210-249).
+// We DO fall through to `currentChunk.push(line)` (line 336).
+
+// So "middle line" SHOULD be added to `currentChunk`.
+
+// Why is it not in the output?
+// Maybe `estimateTokens` is returning 0 or small number, and it gets flushed/dropped?
+// `smartChunk` calls `estimateTokens(line)` (line 192).
+
+// In my test: `expect(chunks[0].text).toContain('middle line');`
+// `chunks` length IS > 0 (checked).
+// But text doesn't contain it.
+
+// Maybe it was put in a chunk that was then dropped?
+// `chunkText.trim().length > 20` check?
+// content was `/*\n middle line \n*/\n` + "x".repeat(40)
+// Line 1: `/*` -> pushed.
+// Line 2: ` middle line ` -> pushed.
+// Line 3: `*/` -> pushed.
+// Line 4: `xxxxxxxx...` -> pushed?
+
+// Wait, line tokens.
+// "middle line" has spaces. `trim()` length is ~11 chars.
+// If it's pushed to `currentChunk`.
+// Then we hit the oversized line (x*40).
+// Line 252: `if (lineTokens > maxTokens)`
+// x*40 is 40 tokens. maxTokens is 50. So it is NOT oversized.
+
+// Wait, input setup: `const content = "/*\n middle line \n*/\n" + "x".repeat(40);`
+// Line 4 is "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" (40 chars).
+
+// currentChunk has: "/*", " middle line ", "*/", "xxxx..."
+// Total tokens?
+// 2 + 13 + 2 + 40 = 57.
+// targetTokens is 30.
+// So `wouldExceedLimit` (line 283) might be true?
+
+// Line 283: `currentChunk` (17 tokens) + `line` (40 tokens) = 57 > 30.
+// `wouldExceedLimit` = true.
+
+// `shouldSplit` = true (line 301).
+// `safeToSplit` = true (line 305).
+
+// Line 307: `if (shouldSplit && safeToSplit && currentChunk.length > 0)`
+// -> Flush currentChunk ("/*", " middle line ", "*/").
+// -> Text: "/*\n middle line \n*/". Length ~ 20.
+
+// "/*" (2) + "\n" (1) + " middle line " (13) + "\n" (1) + "*/" (2) = 19 chars.
+// 20 chars? "/*\n middle line \n*/" has length 2 + 1 + 13 + 1 + 2 = 19.
+// `chunkText.trim().length > 20` (line 255/309) -> 19 <= 20 -> FALSE.
+// CHUNK DROPPED!
+
+// That explains it. The chunk containing the comment is being dropped because it's too small.
+
+// Fix: Make the comment content longer!
+
+console.info('Analysis complete: Middle line chunk is dropped because total size is < 20 chars.');