@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/index-cli.test.js

@@ -0,0 +1,520 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+let lastIndexer = null;
+let lastCache = null;
+let lastServer = null;
+let indexAllMock;
+let setupFileWatcherMock;
+let hybridHandleToolCall;
+let indexHandleToolCall;
+let clearHandleToolCall;
+let findHandleToolCall;
+let annHandleToolCall;
+let callSchema;
+let listSchema;
+let logsMock;
+
+const configMock = {
+  loadConfig: vi.fn(),
+  getGlobalCacheDir: vi.fn(),
+};
+const fsMock = {
+  access: vi.fn(),
+};
+const pipelineMock = vi.fn();
+const registerMock = vi.fn();
+const stopMock = vi.fn();
+const startMock = vi.fn();
+const statusMock = vi.fn();
+
+vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+  Server: class {
+    constructor() {
+      this.handlers = new Map();
+      lastServer = this;
+    }
+    setRequestHandler(schema, handler) {
+      this.handlers.set(schema, handler);
+    }
+    async connect() {}
+  },
+}));
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+  StdioServerTransport: class {},
+}));
+vi.mock('@modelcontextprotocol/sdk/types.js', () => {
+  callSchema = Symbol('call');
+  listSchema = Symbol('list');
+  return {
+    CallToolRequestSchema: callSchema,
+    ListToolsRequestSchema: listSchema,
+  };
+});
+vi.mock('@xenova/transformers', () => ({
+  pipeline: (...args) => pipelineMock(...args),
+  env: {
+    backends: {
+      onnx: {
+        numThreads: 1,
+        wasm: { numThreads: 1 },
+      },
+    },
+  },
+}));
+vi.mock('fs/promises', () => fsMock);
+vi.mock('../lib/config.js', () => configMock);
+vi.mock('../lib/cache.js', () => ({
+  EmbeddingsCache: class {
+    constructor(config) {
+      this.config = config;
+      this.load = vi.fn().mockResolvedValue(undefined);
+      this.save = vi.fn().mockResolvedValue(undefined);
+      lastCache = this;
+    }
+  },
+}));
+vi.mock('../features/index-codebase.js', () => ({
+  CodebaseIndexer: class {
+    constructor() {
+      this.watcher = { close: vi.fn().mockResolvedValue(undefined) };
+      this.terminateWorkers = vi.fn().mockResolvedValue(undefined);
+      this.indexAll = indexAllMock;
+      this.setupFileWatcher = setupFileWatcherMock;
+      lastIndexer = this;
+    }
+  },
+  getToolDefinition: vi.fn(() => ({ name: 'index-codebase' })),
+  handleToolCall: (...args) => indexHandleToolCall(...args),
+}));
+vi.mock('../features/hybrid-search.js', () => ({
+  HybridSearch: class {},
+  getToolDefinition: vi.fn(() => ({ name: 'semantic_search' })),
+  handleToolCall: (...args) => hybridHandleToolCall(...args),
+}));
+vi.mock('../features/clear-cache.js', () => ({
+  CacheClearer: class {},
+  getToolDefinition: vi.fn(() => ({ name: 'clear_cache' })),
+  handleToolCall: (...args) => clearHandleToolCall(...args),
+}));
+vi.mock('../features/find-similar-code.js', () => ({
+  FindSimilarCode: class {},
+  getToolDefinition: vi.fn(() => ({ name: 'find_similar_code' })),
+  handleToolCall: (...args) => findHandleToolCall(...args),
+}));
+vi.mock('../features/ann-config.js', () => ({
+  AnnConfigTool: class {},
+  getToolDefinition: vi.fn(() => ({ name: 'ann_config' })),
+  handleToolCall: (...args) => annHandleToolCall(...args),
+}));
+vi.mock('../features/register.js', () => ({
+  register: (...args) => registerMock(...args),
+}));
+vi.mock('../features/lifecycle.js', () => ({
+  stop: (...args) => stopMock(...args),
+  start: (...args) => startMock(...args),
+  status: (...args) => statusMock(...args),
+  logs: (...args) => logsMock(...args),
+}));
+
+const baseConfig = {
+  searchDirectory: 'C:\\work',
+  embeddingModel: 'test-model',
+  cacheDirectory: 'C:\\cache',
+  watchFiles: false,
+};
+
+describe('index.js CLI coverage', () => {
+  let originalArgv;
+  let onSpy;
+  let exitSpy;
+  let errorSpy;
+  let infoSpy;
+  let listeners;
+
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    originalArgv = process.argv;
+    listeners = {};
+    lastIndexer = null;
+    lastCache = null;
+    lastServer = null;
+    indexAllMock = vi.fn().mockResolvedValue(undefined);
+    setupFileWatcherMock = vi.fn();
+    hybridHandleToolCall = vi.fn();
+    indexHandleToolCall = vi.fn();
+    clearHandleToolCall = vi.fn();
+    findHandleToolCall = vi.fn();
+    annHandleToolCall = vi.fn();
+    logsMock = vi.fn();
+    registerMock.mockReset();
+    stopMock.mockReset();
+    startMock.mockReset();
+    statusMock.mockReset();
+    pipelineMock.mockReset();
+    configMock.loadConfig.mockReset();
+    configMock.getGlobalCacheDir.mockReset();
+    fsMock.access.mockReset();
+    onSpy = vi.spyOn(process, 'on').mockImplementation((event, handler) => {
+      listeners[event] = handler;
+      return process;
+    });
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    onSpy.mockRestore();
+    exitSpy.mockRestore();
+    errorSpy.mockRestore();
+    infoSpy.mockRestore();
+    vi.useRealTimers();
+  });
+
+  it('registers with filter and exits', async () => {
+    process.argv = ['node', 'index.js', '--register', 'antigravity'];
+    registerMock.mockResolvedValue(undefined);
+    const exitError = new Error('exit');
+    exitSpy.mockImplementation(() => {
+      throw exitError;
+    });
+
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch (err) {
+      expect(err).toBe(exitError);
+    }
+
+    expect(registerMock).toHaveBeenCalledWith('antigravity');
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('registers without filter when argument is missing', async () => {
+    process.argv = ['node', 'index.js', '--register'];
+    registerMock.mockResolvedValue(undefined);
+    const exitError = new Error('exit');
+    exitSpy.mockImplementation(() => {
+      throw exitError;
+    });
+
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch (err) {
+      expect(err).toBe(exitError);
+    }
+
+    expect(registerMock).toHaveBeenCalledWith(null);
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('prints version and exits', async () => {
+    process.argv = ['node', 'index.js', '--version'];
+    const exitError = new Error('exit');
+    exitSpy.mockImplementation(() => {
+      throw exitError;
+    });
+
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch (err) {
+      expect(err).toBe(exitError);
+    }
+
+    const versionMessages = [...infoSpy.mock.calls, ...errorSpy.mock.calls].map((call) => call[0]);
+    const hasVersion = versionMessages.some(
+      (message) => typeof message === 'string' && /\d+\.\d+\.\d+/.test(message)
+    );
+    expect(hasVersion).toBe(true);
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('enables logs flag and strips args', async () => {
+    process.argv = ['node', 'index.js', '--logs'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    expect(process.env.SMART_CODING_VERBOSE).toBe('true');
+    expect(logsMock).toHaveBeenCalled();
+  });
+
+  it('logs memory stats when verbose is enabled', async () => {
+    process.argv = ['node', 'index.js'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue({
+      ...baseConfig,
+      verbose: true,
+    });
+    let accessResolve;
+    const accessPromise = new Promise((resolve) => {
+      accessResolve = resolve;
+    });
+    fsMock.access.mockReturnValue(accessPromise);
+    pipelineMock.mockResolvedValue(() => ({}));
+    vi.useFakeTimers();
+    const clearSpy = vi.spyOn(global, 'clearInterval');
+
+    const { main } = await import('../index.js');
+    const importPromise = main();
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(15000);
+    accessResolve();
+    await importPromise;
+
+    const messages = infoSpy.mock.calls.map((call) => call[0]);
+    const hasStartup = messages.some(
+      (message) => typeof message === 'string' && message.includes('[Server] Memory (startup)')
+    );
+    const hasModelLoad = messages.some(
+      (message) =>
+        typeof message === 'string' && message.includes('[Server] Memory (after model load)')
+    );
+    const hasCacheLoad = messages.some(
+      (message) =>
+        typeof message === 'string' && message.includes('[Server] Memory (after cache load)')
+    );
+    expect(hasStartup).toBe(true);
+    expect(hasModelLoad).toBe(true);
+    expect(hasCacheLoad).toBe(true);
+    expect(clearSpy).toHaveBeenCalled();
+
+    clearSpy.mockRestore();
+  });
+
+  it('handles lifecycle stop/start/status flags', async () => {
+    const exitError = new Error('exit');
+    exitSpy.mockImplementation(() => {
+      throw exitError;
+    });
+
+    process.argv = ['node', 'index.js', '--stop'];
+    stopMock.mockResolvedValue(undefined);
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch { /* ignore */ }
+    expect(stopMock).toHaveBeenCalled();
+
+    vi.resetModules();
+    process.argv = ['node', 'index.js', '--start'];
+    startMock.mockResolvedValue(undefined);
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch { /* ignore */ }
+    expect(startMock).toHaveBeenCalled();
+
+    vi.resetModules();
+    process.argv = ['node', 'index.js', '--status'];
+    statusMock.mockResolvedValue(undefined);
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch { /* ignore */ }
+    expect(statusMock).toHaveBeenCalled();
+  });
+
+  it('falls back when workspace variables are unexpanded', async () => {
+    process.argv = ['node', 'index.js', '--workspace', '${workspaceFolder}'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    const errors = errorSpy.mock.calls.map((call) => call[0]);
+    const hasFallback = errors.some(
+      (message) => typeof message === 'string' && message.includes('IDE variable not expanded')
+    );
+    expect(hasFallback).toBe(true);
+  });
+
+  it('parses workspace args with equals and starts watcher', async () => {
+    vi.useFakeTimers();
+    process.argv = ['node', 'index.js', '--workspace=C:\\work'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue({
+      ...baseConfig,
+      watchFiles: true,
+    });
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+    
+    // Trigger the background initialization timeout
+    await vi.runAllTimersAsync();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(setupFileWatcherMock).toHaveBeenCalled();
+  });
+
+  it('ignores workspace flag without a value', async () => {
+    process.argv = ['node', 'index.js', '--workspace'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    const errors = errorSpy.mock.calls.map((call) => call[0]);
+    const hasWorkspace = errors.some(
+      (message) => typeof message === 'string' && message.includes('Workspace mode')
+    );
+    expect(hasWorkspace).toBe(false);
+  });
+
+  it('logs background indexing errors', async () => {
+    vi.useFakeTimers();
+    process.argv = ['node', 'index.js', '--workspace', 'C:\\work'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+    indexAllMock.mockRejectedValue(new Error('index fail'));
+
+    const { main } = await import('../index.js');
+    await main();
+    
+    // Trigger the background initialization timeout
+    await vi.runAllTimersAsync();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const errors = errorSpy.mock.calls.map((call) => call[0]);
+    const hasError = errors.some(
+      (message) => typeof message === 'string' && message.includes('Background indexing error:')
+    );
+    expect(hasError).toBe(true);
+  });
+
+  it('parses workspace args and handles shutdown cleanup', async () => {
+    process.argv = ['node', 'index.js', '--workspace', 'C:\\work'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    const info = [...infoSpy.mock.calls, ...errorSpy.mock.calls].map((call) => call[0]);
+    const hasWorkspace = info.some(
+      (message) => typeof message === 'string' && message.includes('Workspace mode')
+    );
+    expect(hasWorkspace).toBe(true);
+    expect(lastIndexer).toBeTruthy();
+    expect(lastCache).toBeTruthy();
+
+    lastIndexer.terminateWorkers
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error('sigint-fail'))
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error('sigterm-fail'));
+
+    vi.useFakeTimers();
+    const runHandler = async (handler) => {
+      const promise = handler();
+      await vi.runAllTimersAsync();
+      await promise;
+    };
+
+    await runHandler(listeners.SIGINT);
+    await runHandler(listeners.SIGINT);
+    await runHandler(listeners.SIGTERM);
+    await runHandler(listeners.SIGTERM);
+
+    expect(lastIndexer.watcher.close).toHaveBeenCalled();
+    expect(lastCache.save).toHaveBeenCalled();
+  });
+
+  it('handles shutdown when no watcher, workers, or cache exist', async () => {
+    process.argv = ['node', 'index.js', '--workspace', 'C:\\work'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    lastIndexer.watcher = null;
+    lastIndexer.terminateWorkers = null;
+    lastCache = null;
+
+    vi.useFakeTimers();
+    exitSpy.mockClear();
+    const runHandler = async (handler) => {
+      const promise = handler();
+      await vi.runAllTimersAsync();
+      await promise;
+    };
+
+    await runHandler(listeners.SIGINT);
+    await runHandler(listeners.SIGTERM);
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('lists tools and routes tool calls', async () => {
+    process.argv = ['node', 'index.js', '--workspace', 'C:\\work'];
+    configMock.getGlobalCacheDir.mockReturnValue('C:\\cache-root');
+    configMock.loadConfig.mockResolvedValue(baseConfig);
+    fsMock.access.mockResolvedValue(undefined);
+    pipelineMock.mockResolvedValue(() => ({}));
+
+    const { main } = await import('../index.js');
+    await main();
+
+    const listHandler = lastServer.handlers.get(listSchema);
+    const callHandler = lastServer.handlers.get(callSchema);
+
+    const listResponse = await listHandler();
+    expect(listResponse.tools).toHaveLength(5);
+
+    hybridHandleToolCall.mockResolvedValue({ ok: true });
+    const callResponse = await callHandler({
+      params: { name: 'semantic_search' },
+    });
+    expect(hybridHandleToolCall).toHaveBeenCalled();
+    expect(callResponse).toEqual({ ok: true });
+
+    const unknown = await callHandler({ params: { name: 'unknown_tool' } });
+    expect(unknown.content[0].text).toContain('Unknown tool');
+  });
+
+  it('handles shutdown when cache is not yet initialized', async () => {
+    configMock.loadConfig.mockRejectedValue(new Error('pre-cache fail'));
+
+    try {
+      const { main } = await import('../index.js');
+      await main();
+    } catch (err) {
+      // Expected failure
+    }
+
+    await listeners.SIGINT();
+    await listeners.SIGTERM();
+
+    const errors = errorSpy.mock.calls.map((call) => call[0]);
+    const hasCacheSaved = errors.some(
+      (message) => typeof message === 'string' && message.includes('Cache saved')
+    );
+    expect(hasCacheSaved).toBe(false);
+  });
+});

package/test/index-codebase-batch.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs/promises';
+import { smartChunk, hashContent } from '../lib/utils.js';
+
+vi.mock('os', () => ({
+  default: { cpus: () => [{}] },
+  cpus: () => [{}],
+}));
+vi.mock('fs/promises');
+vi.mock('../lib/utils.js', () => ({
+  smartChunk: vi.fn(),
+  hashContent: vi.fn(),
+}));
+
+const createCache = () => ({
+  removeFileFromStore: vi.fn(),
+  deleteFileHash: vi.fn(),
+  setFileHash: vi.fn(),
+  addToStore: vi.fn(),
+  setVectorStore: vi.fn(),
+  getVectorStore: vi.fn().mockReturnValue([]),
+  pruneCallGraphData: vi.fn().mockReturnValue(0),
+  clearCallGraphData: vi.fn(),
+  save: vi.fn().mockResolvedValue(undefined),
+  rebuildCallGraph: vi.fn(),
+  ensureAnnIndex: vi.fn().mockResolvedValue(null),
+  fileHashes: new Map(),
+  fileCallData: new Map(),
+  getFileHashKeys() {
+    return Array.from(this.fileHashes.keys());
+  },
+  getFileHashCount() {
+    return this.fileHashes.size;
+  },
+  clearFileHashes() {
+    this.fileHashes.clear();
+  },
+  getFileCallDataKeys() {
+    return Array.from(this.fileCallData.keys());
+  },
+  getFileCallDataCount() {
+    return this.fileCallData.size;
+  },
+  clearFileCallData() {
+    this.fileCallData.clear();
+  },
+  setFileCallData: vi.fn(),
+});
+
+describe('CodebaseIndexer batch processing presets', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('coerces preset content and skips oversized batches', async () => {
+    const { CodebaseIndexer } = await import('../features/index-codebase.js');
+    const cache = createCache();
+    const config = {
+      searchDirectory: '/root',
+      excludePatterns: [],
+      fileExtensions: ['js'],
+      fileNames: [],
+      batchSize: 1,
+      maxFileSize: 1,
+      callGraphEnabled: false,
+      verbose: true,
+    };
+    const indexer = new CodebaseIndexer(vi.fn(), cache, config);
+    indexer.discoverFiles = vi.fn().mockResolvedValue(['/root/a.js']);
+    indexer.preFilterFiles = vi
+      .fn()
+      .mockResolvedValue([{ file: '/root/a.js', content: 12345 }]);
+
+    hashContent.mockReturnValueOnce('hash');
+
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await indexer.indexAll(false);
+
+    expect(hashContent).toHaveBeenCalledWith('12345');
+    const hasSkip = consoleSpy.mock.calls.some(
+      (call) => typeof call[0] === 'string' && call[0].includes('Skipped a.js (too large')
+    );
+    expect(hasSkip).toBe(true);
+
+    consoleSpy.mockRestore();
+  });
+
+  it('logs stat errors when preset content is missing', async () => {
+    const { CodebaseIndexer } = await import('../features/index-codebase.js');
+    const cache = createCache();
+    const config = {
+      searchDirectory: '/root',
+      excludePatterns: [],
+      fileExtensions: ['js'],
+      fileNames: [],
+      batchSize: 1,
+      maxFileSize: 100,
+      callGraphEnabled: false,
+      verbose: true,
+    };
+    const indexer = new CodebaseIndexer(vi.fn(), cache, config);
+    indexer.discoverFiles = vi.fn().mockResolvedValue(['/root/b.js']);
+    indexer.preFilterFiles = vi.fn().mockResolvedValue([{ file: '/root/b.js' }]);
+
+    fs.stat.mockRejectedValueOnce(new Error('stat fail'));
+
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await indexer.indexAll(false);
+
+    const hasStatError = consoleSpy.mock.calls.some(
+      (call) => typeof call[0] === 'string' && call[0].includes('Failed to stat')
+    );
+    expect(hasStatError).toBe(true);
+
+    consoleSpy.mockRestore();
+  });
+});