@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/register.test.js

@@ -0,0 +1,262 @@
+// Note: This test file cannot achieve 100% coverage because some code paths
+// in register.js are specific to Windows, macOS, and Linux. The tests are
+// running on a single platform, so the other platform-specific code is not
+// executed.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const fsPromisesMock = {};
+const fsMock = {};
+
+vi.mock('fs/promises', () => ({ default: fsPromisesMock }));
+vi.mock('fs', () => fsMock);
+
+const setPlatform = (value) => {
+  Object.defineProperty(process, 'platform', { value, configurable: true });
+};
+
+describe('register', () => {
+  const originalEnv = { ...process.env };
+  const originalPlatform = process.platform;
+  let consoleError;
+
+  beforeEach(() => {
+    fsPromisesMock.access = vi.fn();
+    fsPromisesMock.mkdir = vi.fn();
+    fsPromisesMock.readFile = vi.fn();
+    fsPromisesMock.writeFileSync = vi.fn();
+    fsMock.writeFileSync = vi.fn();
+    fsMock.existsSync = vi.fn();
+    fsMock.statSync = vi.fn();
+    consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+    setPlatform(originalPlatform);
+    consoleError.mockRestore();
+    vi.resetModules();
+  });
+
+  it('creates a config when Antigravity is detected', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(fsPromisesMock.mkdir).toHaveBeenCalled();
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('prints manual config when no IDE configs are writable', async () => {
+    delete process.env.ANTIGRAVITY_AGENT;
+    delete process.env.CURSOR_AGENT;
+    setPlatform('win32');
+    fsMock.existsSync.mockReturnValue(false);
+    fsMock.statSync.mockImplementation(() => {
+      throw new Error('missing');
+    });
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(consoleError).toHaveBeenCalledWith(expect.stringContaining('Manual Config'));
+  });
+
+  it('detects Antigravity via fallback directory check', async () => {
+    delete process.env.ANTIGRAVITY_AGENT;
+    delete process.env.CURSOR_AGENT;
+    setPlatform('linux');
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.statSync.mockReturnValue({ isDirectory: () => true });
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(fsPromisesMock.mkdir).toHaveBeenCalled();
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('uses darwin config paths for Claude Desktop and Cursor', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('darwin');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(fsPromisesMock.mkdir).toHaveBeenCalled();
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('handles corrupt config files gracefully', async () => {
+    delete process.env.ANTIGRAVITY_AGENT;
+    process.env.CURSOR_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue('{not-json');
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(consoleError).toHaveBeenCalledWith(expect.stringContaining('Warning'));
+    expect(fsMock.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  it('handles empty config files as new', async () => {
+    delete process.env.ANTIGRAVITY_AGENT;
+    process.env.CURSOR_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue('   ');
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('skips non-matching IDEs when filter is provided', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+
+    await register('cursor');
+
+    expect(fsMock.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  it('logs when config directory cannot be created', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockRejectedValue(new Error('nope'));
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(consoleError).toHaveBeenCalledWith(
+      expect.stringContaining('Cannot create config directory')
+    );
+  });
+
+  it('logs registration failures when writing config fails', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue('{}');
+    fsMock.writeFileSync.mockImplementation(() => {
+      throw new Error('write failed');
+    });
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(consoleError).toHaveBeenCalledWith(expect.stringContaining('Failed to register'));
+  });
+
+  it('registers config on non-win32 platforms', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('linux');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('falls back to console.error when tty logging fails', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('linux');
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+    fsMock.writeFileSync.mockImplementation((targetPath) => {
+      if (targetPath === '/dev/tty') {
+        throw new Error('tty denied');
+      }
+    });
+
+    const { register } = await import('../features/register.js');
+
+    await register();
+
+    expect(consoleError).toHaveBeenCalled();
+  });
+
+  it('handles missing APPDATA on Windows', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    delete process.env.APPDATA;
+    fsPromisesMock.access.mockRejectedValue(new Error('missing'));
+    fsPromisesMock.mkdir.mockResolvedValue();
+
+    const { register } = await import('../features/register.js');
+    await register();
+
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('handles missing INIT_CWD for Antigravity', async () => {
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    delete process.env.INIT_CWD;
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue('{}');
+
+    const { register } = await import('../features/register.js');
+    await register();
+
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('handles existing mcpServers object', async () => {
+    delete process.env.ANTIGRAVITY_AGENT;
+    process.env.CURSOR_AGENT = '1';
+    setPlatform('win32');
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue(JSON.stringify({ mcpServers: { other: {} } }));
+
+    const { register } = await import('../features/register.js');
+    await register();
+
+    const written = JSON.parse(fsMock.writeFileSync.mock.calls[0][1]);
+    expect(written.mcpServers.other).toBeDefined();
+    expect(written.mcpServers['heuristic-mcp']).toBeDefined();
+  });
+
+  it('handles missing LOCALAPPDATA on Windows', async () => {
+    // This targets line 205
+    process.env.ANTIGRAVITY_AGENT = '1';
+    setPlatform('win32');
+    delete process.env.LOCALAPPDATA;
+    // Ensure registerCount > 0 to hit the block
+    fsPromisesMock.access.mockResolvedValue();
+    fsPromisesMock.readFile.mockResolvedValue('{}');
+
+    const { register } = await import('../features/register.js');
+    await register();
+
+    expect(fsMock.writeFileSync).toHaveBeenCalled();
+  });
+});

package/test/tokenizer.test.js

@@ -1,6 +1,6 @@
 /**
  * Tests for Tokenizer utilities
- * 
+ *
  * Tests the token estimation and model-specific limits including:
  * - Token estimation for various text types
  * - Model token limits lookup
@@ -9,12 +9,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { 
-  estimateTokens, 
-  getModelTokenLimit, 
+import {
+  estimateTokens,
+  getModelTokenLimit,
   getChunkingParams,
-  exceedsTokenLimit,
-  MODEL_TOKEN_LIMITS 
+  MODEL_TOKEN_LIMITS,
 } from '../lib/tokenizer.js';
 
 describe('Token Estimation', () => {
@@ -24,30 +23,30 @@ describe('Token Estimation', () => {
       expect(estimateTokens(null)).toBe(0);
       expect(estimateTokens(undefined)).toBe(0);
     });
-    
+
     it('should count simple words correctly', () => {
       // Simple words get ~1 token each + 2 for CLS/SEP
       const result = estimateTokens('hello world');
       expect(result).toBeGreaterThanOrEqual(4); // 2 words + 2 special tokens
       expect(result).toBeLessThanOrEqual(6);
     });
-    
+
     it('should add extra tokens for long words', () => {
       const shortWord = estimateTokens('cat');
       const longWord = estimateTokens('internationalization');
-      
+
       // Long words should have more tokens due to subword splitting
       expect(longWord).toBeGreaterThan(shortWord);
     });
-    
+
     it('should count special characters', () => {
       const withoutSpecial = estimateTokens('hello world');
       const withSpecial = estimateTokens('hello(); world{}');
-      
+
       // Special characters add to token count
       expect(withSpecial).toBeGreaterThan(withoutSpecial);
     });
-    
+
     it('should handle code snippets', () => {
       const code = `
         function test() {
@@ -55,18 +54,18 @@ describe('Token Estimation', () => {
           return x * 2;
         }
       `;
-      
+
       const tokens = estimateTokens(code);
-      
+
       // Code has many special chars, should have reasonable token count
       expect(tokens).toBeGreaterThan(10);
       expect(tokens).toBeLessThan(100);
     });
-    
+
     it('should handle multiline text', () => {
       const multiline = 'line one\nline two\nline three';
       const tokens = estimateTokens(multiline);
-      
+
       expect(tokens).toBeGreaterThan(5);
     });
   });
@@ -76,117 +75,80 @@ describe('Model Token Limits', () => {
   describe('MODEL_TOKEN_LIMITS', () => {
     it('should have default limit', () => {
       expect(MODEL_TOKEN_LIMITS['default']).toBeDefined();
-      expect(MODEL_TOKEN_LIMITS['default']).toBe(256);
-    });
-    
-    it('should have limits for MiniLM models', () => {
-      expect(MODEL_TOKEN_LIMITS['Xenova/all-MiniLM-L6-v2']).toBe(256);
-      expect(MODEL_TOKEN_LIMITS['Xenova/all-MiniLM-L12-v2']).toBe(256);
+      expect(MODEL_TOKEN_LIMITS['default']).toBe(512);
     });
-    
-    it('should have limits for code-specific models', () => {
-      expect(MODEL_TOKEN_LIMITS['Xenova/codebert-base']).toBe(512);
-      expect(MODEL_TOKEN_LIMITS['Xenova/graphcodebert-base']).toBe(512);
-    });
-    
-    it('should have limits for E5 and BGE models', () => {
-      expect(MODEL_TOKEN_LIMITS['Xenova/e5-small-v2']).toBe(512);
-      expect(MODEL_TOKEN_LIMITS['Xenova/bge-base-en-v1.5']).toBe(512);
+
+    it('should have limits for Jina models', () => {
+      expect(MODEL_TOKEN_LIMITS['jinaai/jina-embeddings-v2-base-code']).toBe(8192);
     });
   });
 
   describe('getModelTokenLimit', () => {
     it('should return correct limit for known models', () => {
-      expect(getModelTokenLimit('Xenova/all-MiniLM-L6-v2')).toBe(256);
-      expect(getModelTokenLimit('Xenova/codebert-base')).toBe(512);
+      expect(getModelTokenLimit('jinaai/jina-embeddings-v2-base-code')).toBe(8192);
     });
-    
+
     it('should return default for unknown models', () => {
-      expect(getModelTokenLimit('unknown/model-name')).toBe(256);
+      expect(getModelTokenLimit('unknown/model-name')).toBe(512);
     });
-    
+
     it('should return default for null/undefined', () => {
-      expect(getModelTokenLimit(null)).toBe(256);
-      expect(getModelTokenLimit(undefined)).toBe(256);
+      expect(getModelTokenLimit(null)).toBe(512);
+      expect(getModelTokenLimit(undefined)).toBe(512);
     });
-    
+
     it('should be case-insensitive', () => {
       const normalCase = getModelTokenLimit('Xenova/all-MiniLM-L6-v2');
       const lowerCase = getModelTokenLimit('xenova/all-minilm-l6-v2');
-      
+
       expect(lowerCase).toBe(normalCase);
     });
+
+    it('should match known models case-insensitively', () => {
+      const mixedCase = getModelTokenLimit('JINAAI/JINA-EMBEDDINGS-V2-BASE-CODE');
+      expect(mixedCase).toBe(8192);
+    });
   });
 });
 
 describe('Chunking Parameters', () => {
   describe('getChunkingParams', () => {
     it('should return correct params for default model', () => {
-      const params = getChunkingParams('Xenova/all-MiniLM-L6-v2');
-      
-      expect(params.maxTokens).toBe(256);
-      expect(params.targetTokens).toBeLessThan(256); // 85% of max
-      expect(params.targetTokens).toBeGreaterThan(200);
+      const params = getChunkingParams('jinaai/jina-embeddings-v2-base-code');
+
+      expect(params.maxTokens).toBe(8192);
+      expect(params.targetTokens).toBeLessThan(8192); // 85% of max
+      expect(params.targetTokens).toBeGreaterThan(6000);
       expect(params.overlapTokens).toBeLessThan(params.targetTokens);
     });
-    
+
     it('should calculate ~85% for target tokens', () => {
-      const params = getChunkingParams('Xenova/codebert-base'); // 512 limit
-      
-      // 85% of 512 = 435.2 -> floor = 435
-      expect(params.targetTokens).toBe(Math.floor(512 * 0.85));
+      const params = getChunkingParams('jinaai/jina-embeddings-v2-base-code'); // 8192 limit
+
+      // 85% of 8192 = 6963.2 -> floor = 6963
+      expect(params.targetTokens).toBe(Math.floor(8192 * 0.85));
     });
-    
+
     it('should calculate ~18% overlap', () => {
-      const params = getChunkingParams('Xenova/all-MiniLM-L6-v2');
-      
+      const params = getChunkingParams('jinaai/jina-embeddings-v2-base-code');
+
       const expectedOverlap = Math.floor(params.targetTokens * 0.18);
       expect(params.overlapTokens).toBe(expectedOverlap);
     });
-    
+
     it('should return all three parameters', () => {
       const params = getChunkingParams('Xenova/all-MiniLM-L6-v2');
-      
+
       expect(params).toHaveProperty('maxTokens');
       expect(params).toHaveProperty('targetTokens');
       expect(params).toHaveProperty('overlapTokens');
     });
-    
+
     it('should handle unknown models with defaults', () => {
       const params = getChunkingParams('unknown/model');
-      
-      expect(params.maxTokens).toBe(256);
-      expect(params.targetTokens).toBeLessThan(256);
-    });
-  });
-});
 
-describe('Token Limit Checking', () => {
-  describe('exceedsTokenLimit', () => {
-    it('should return false for short text', () => {
-      const shortText = 'hello world';
-      expect(exceedsTokenLimit(shortText, 'Xenova/all-MiniLM-L6-v2')).toBe(false);
-    });
-    
-    it('should return true for very long text', () => {
-      // Create text that definitely exceeds 256 tokens
-      const longText = 'word '.repeat(500);
-      expect(exceedsTokenLimit(longText, 'Xenova/all-MiniLM-L6-v2')).toBe(true);
-    });
-    
-    it('should consider different model limits', () => {
-      // Create text that exceeds 256 but not 512
-      const mediumText = 'word '.repeat(300);
-      
-      // Should exceed small model limit
-      expect(exceedsTokenLimit(mediumText, 'Xenova/all-MiniLM-L6-v2')).toBe(true);
-      
-      // Should not exceed large model limit
-      expect(exceedsTokenLimit(mediumText, 'Xenova/codebert-base')).toBe(false);
-    });
-    
-    it('should handle empty text', () => {
-      expect(exceedsTokenLimit('', 'Xenova/all-MiniLM-L6-v2')).toBe(false);
+      expect(params.maxTokens).toBe(512);
+      expect(params.targetTokens).toBeLessThan(512);
     });
   });
 });
@@ -208,18 +170,18 @@ describe('Integration: Token Estimation Accuracy', () => {
         }
       }
     `;
-    
+
     const tokens = estimateTokens(typicalCodeChunk);
-    
+
     // Should be within typical chunk size
     expect(tokens).toBeGreaterThan(30);
     expect(tokens).toBeLessThan(200);
   });
-  
+
   it('should keep small code chunks under model limits', () => {
     // A small chunk should definitely be under the limit
     const safeChunk = 'const x = 1;\n'.repeat(10);
-    
-    expect(exceedsTokenLimit(safeChunk, 'Xenova/all-MiniLM-L6-v2')).toBe(false);
+    const limit = getModelTokenLimit('jinaai/jina-embeddings-v2-base-code');
+    expect(estimateTokens(safeChunk)).toBeLessThanOrEqual(limit);
   });
 });

package/test/ultra-maximizer.test.js

@@ -0,0 +1,116 @@
+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';
+import path from 'path';
+
+// Mock dependencies
+vi.mock('fs/promises');
+vi.mock('worker_threads', async () => {
+  const { EventEmitter } = await import('events');
+  class Worker extends EventEmitter {
+    constructor() {
+      super();
+      // Don't emit ready automatically to allow manual control in tests
+    }
+    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('Ultra Maximizer', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('lib/cache.js Internals', () => {
+    it('Line 673: logs call-graph load in verbose mode', async () => {
+      const config = {
+        enableCache: true,
+        cacheDirectory: '/cache',
+        embeddingModel: 'test',
+        fileExtensions: ['js'],
+        verbose: true, // Crucial for line 673
+      };
+      const cache = new EmbeddingsCache(config);
+      const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+      // Mock file system for load()
+      vi.spyOn(fs, 'mkdir').mockResolvedValue();
+      vi.spyOn(fs, 'readFile').mockImplementation(async (p) => {
+        if (p.endsWith('meta.json')) return JSON.stringify({ version: 1, embeddingModel: 'test' });
+        if (p.endsWith('embeddings.json')) return '[]';
+        if (p.endsWith('file-hashes.json')) return '{}';
+        if (p.endsWith('call-graph.json')) return JSON.stringify({ 'f.js': {} });
+        return null;
+      });
+
+      await cache.load();
+
+      expect(cache.getFileCallDataCount()).toBe(1);
+      expect(cache.hasFileCallData('f.js')).toBe(true);
+    });
+  });
+
+  describe('features/index-codebase.js Worker Path', () => {
+    it('Line 146: covers initializeWorkers failure and termination', async () => {
+      const config = { workerThreads: 2, verbose: true, embeddingModel: 'test' };
+      const embedder = vi.fn();
+      const cache = { save: vi.fn(), getVectorStore: () => [] };
+      const indexer = new CodebaseIndexer(embedder, cache, config);
+
+      // Mock Worker to fail immediately/emit error
+      const { Worker } = await import('worker_threads');
+      // We can't change the class constructor behavior easily here.
+      // But we can emit error on the worker instances after creation?
+      // initializeWorkers creates workers and waits for "ready".
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const terminateSpy = vi.spyOn(indexer, 'terminateWorkers');
+
+      // We need to trigger the "error" event on the worker.
+      // We can spy on the workers array push?
+      // Or wait a tick?
+
+      // Let's rely on the timeout? No, timeout takes too long.
+      // We need to get access to the worker instance.
+
+      // Better strategy: Mock the Worker constructor to return a specific instance we control.
+      // But vi.mock is hoisted.
+      // We can modify prototype?
+
+      // Actually, we can just run initializeWorkers, then manually emit error on indexer.workers[0].
+
+      const initPromise = indexer.initializeWorkers();
+
+      // Wait a tick for workers to be created
+      await new Promise((r) => setTimeout(r, 0));
+
+      if (indexer.workers.length > 0) {
+        indexer.workers[0].emit('message', { type: 'error', error: 'Init Fail' });
+      }
+
+      await initPromise;
+
+      // initializeWorkers catches the error and calls terminateWorkers (Line 146)
+      expect(terminateSpy).toHaveBeenCalled();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Worker initialization failed')
+      );
+    });
+  });
+});