@softerist/heuristic-mcp 2.1.12 → 2.1.23

package/features/lifecycle.js

@@ -6,30 +6,55 @@ export async function stop() {
   console.log('[Lifecycle] Stopping Heuristic MCP servers...');
   try {
     const platform = process.platform;
-    let command = '';
+    const currentPid = process.pid;
+    let pids = [];
 
     if (platform === 'win32') {
-      // Windows: Use wmic to find node processes running our script
-      command = `wmic process where "CommandLine like '%heuristic-mcp/index.js%'" delete`;
+      const { stdout } = await execPromise(`wmic process where "CommandLine like '%heuristic-mcp/index.js%'" get ProcessId`);
+      pids = stdout.trim().split(/\s+/).filter(p => p && !isNaN(p) && parseInt(p) !== currentPid);
     } else {
-      // Unix/Linux/Mac: Use pkill to find the process matching the script path
-      // We exclude the current process to avoid suicide if we are running from the same script
-      // however, usually the CLI runner is a different PID than the server.
-      command = `pkill -f "heuristic-mcp/index.js"`;
+      // Unix: Use pgrep to get all matching PIDs
+      try {
+        const { stdout } = await execPromise(`pgrep -f \"heuristic-mcp.*index.js\"`);
+        const allPids = stdout.trim().split(/\s+/).filter(p => p && !isNaN(p));
+
+        // Filter out current PID and dead processes
+        pids = [];
+        for (const p of allPids) {
+            const pid = parseInt(p);
+            if (pid === currentPid) continue;
+            try {
+                process.kill(pid, 0);
+                pids.push(p);
+            } catch (e) {}
+        }
+      } catch (e) {
+        // pgrep returns code 1 if no processes found, which is fine
+        if (e.code === 1) pids = [];
+        else throw e;
+      }
     }
 
-    await execPromise(command);
-    console.log('[Lifecycle] ✅ Stopped all running instances.');
-  } catch (error) {
-    // pkill (Linux/Mac) returns exit code 1 if no process matched.
-    // wmic (Windows) might throw specific errors if none found.
-    // We treat exit code 1 as "Success, nothing was running".
-    if (error.code === 1 || error.code === '1' || error.message.includes('No Instance(s) Available')) {
+    if (pids.length === 0) {
       console.log('[Lifecycle] No running instances found (already stopped).');
-    } else {
-      // Don't fail hard, just warn
-      console.warn(`[Lifecycle] Warning: Stop command finished with unexpected result: ${error.message}`);
+      return;
     }
+
+    // Kill each process
+    let killedCount = 0;
+    for (const pid of pids) {
+      try {
+        process.kill(parseInt(pid), 'SIGTERM');
+        killedCount++;
+      } catch (e) {
+        // Ignore if process already gone
+        if (e.code !== 'ESRCH') console.warn(`[Lifecycle] Failed to kill PID ${pid}: ${e.message}`);
+      }
+    }
+
+    console.log(`[Lifecycle] ✅ Stopped ${killedCount} running instance(s).`);
+  } catch (error) {
+    console.warn(`[Lifecycle] Warning: Stop command encountered an error: ${error.message}`);
   }
 }
 
@@ -49,17 +74,37 @@ export async function start() {
 export async function status() {
     try {
         const platform = process.platform;
-        let command = '';
+        const currentPid = process.pid;
+        let pids = [];
 
         if (platform === 'win32') {
-            command = `wmic process where "CommandLine like '%heuristic-mcp/index.js%'" get ProcessId`;
+            const { stdout } = await execPromise(`wmic process where "CommandLine like '%heuristic-mcp/index.js%'" get ProcessId`);
+            pids = stdout.trim().split(/\s+/).filter(p => p && !isNaN(p) && parseInt(p) !== currentPid);
         } else {
-            // pgrep -f matches the full command line
-            command = `pgrep -f "heuristic-mcp/index.js"`;
-        }
+            try {
+                const { stdout } = await execPromise(`pgrep -f "heuristic-mcp.*index.js"`);
+                const allPids = stdout.trim().split(/\s+/).filter(p => p && !isNaN(p));
+
+                // Filter out current PID and dead processes (e.g. ephemeral shell wrappers)
+                const validPids = [];
+                for (const p of allPids) {
+                    const pid = parseInt(p);
+                    if (pid === currentPid) continue;
 
-        const { stdout } = await execPromise(command);
-        const pids = stdout.trim().split(/\s+/).filter(pid => pid && !isNaN(pid));
+                    try {
+                        // Check if process is still alive
+                        process.kill(pid, 0);
+                        validPids.push(p);
+                    } catch (e) {
+                         // Process is dead or access denied
+                    }
+                }
+                pids = validPids;
+            } catch (e) {
+                if (e.code === 1) pids = [];
+                else throw e;
+            }
+        }
 
         if (pids.length > 0) {
             console.log(`[Lifecycle] 🟢 Server is RUNNING. PID(s): ${pids.join(', ')}`);
@@ -67,11 +112,164 @@ export async function status() {
             console.log('[Lifecycle] ⚪ Server is STOPPED.');
         }
     } catch (error) {
-        // pgrep returns exit code 1 if no process found
-        if (error.code === 1 || error.code === '1' || error.message.includes('No Instance(s) Available')) {
-             console.log('[Lifecycle] ⚪ Server is STOPPED.');
+         console.error(`[Lifecycle] Failed to check status: ${error.message}`);
+    }
+}
+
+export async function logs() {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+    const crypto = await import('crypto');
+
+    console.log('[Logs] Searching for cache directories...\n');
+
+    // Determine global cache root
+    function getGlobalCacheDir() {
+        if (process.platform === 'win32') {
+            return process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+        } else if (process.platform === 'darwin') {
+            return path.join(os.homedir(), 'Library', 'Caches');
+        }
+        return process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+    }
+
+    const globalCacheRoot = path.join(getGlobalCacheDir(), 'heuristic-mcp');
+
+    try {
+        // List all cache directories
+        const cacheDirs = await fs.readdir(globalCacheRoot).catch(() => []);
+
+        if (cacheDirs.length === 0) {
+            console.log('[Logs] No cache directories found.');
+            console.log(`[Logs] Expected location: ${globalCacheRoot}`);
+            return;
+        }
+
+        console.log(`[Logs] Found ${cacheDirs.length} cache director${cacheDirs.length === 1 ? 'y' : 'ies'} in ${globalCacheRoot}\n`);
+
+        for (const dir of cacheDirs) {
+            const cacheDir = path.join(globalCacheRoot, dir);
+            const metaFile = path.join(cacheDir, 'meta.json');
+
+            console.log(`${'─'.repeat(60)}`);
+            console.log(`📁 Cache: ${dir}`);
+            console.log(`   Path: ${cacheDir}`);
+
+            try {
+                const metaData = JSON.parse(await fs.readFile(metaFile, 'utf-8'));
+
+                console.log(`   Status: ✅ Valid cache`);
+                console.log(`   Workspace: ${metaData.workspace || 'Unknown'}`);
+                console.log(`   Files indexed: ${metaData.filesIndexed ?? 'N/A'}`);
+                console.log(`   Chunks stored: ${metaData.chunksStored ?? 'N/A'}`);
+                console.log(`   Embedding model: ${metaData.embeddingModel}`);
+
+                if (metaData.lastSaveTime) {
+                    const saveDate = new Date(metaData.lastSaveTime);
+                    const now = new Date();
+                    const ageMs = now - saveDate;
+                    const ageHours = Math.floor(ageMs / (1000 * 60 * 60));
+                    const ageMins = Math.floor((ageMs % (1000 * 60 * 60)) / (1000 * 60));
+
+                    console.log(`   Last saved: ${saveDate.toLocaleString()} (${ageHours}h ${ageMins}m ago)`);
+                }
+
+                // Check file sizes
+                const files = ['embeddings.json', 'file-hashes.json', 'call-graph.json', 'ann-index.bin'];
+                const sizes = [];
+                for (const file of files) {
+                    try {
+                        const stat = await fs.stat(path.join(cacheDir, file));
+                        sizes.push(`${file}: ${(stat.size / 1024).toFixed(1)}KB`);
+                    } catch {}
+                }
+                if (sizes.length > 0) {
+                    console.log(`   Files: ${sizes.join(', ')}`);
+                }
+
+                // Verify indexing completion
+                if (metaData.filesIndexed && metaData.filesIndexed > 0 && metaData.chunksStored && metaData.chunksStored > 0) {
+                    console.log(`   Indexing: ✅ COMPLETE (${metaData.filesIndexed} files → ${metaData.chunksStored} chunks)`);
+                } else if (metaData.filesIndexed === 0) {
+                    console.log(`   Indexing: ⚠️  NO FILES (check excludePatterns in config)`);
+                } else {
+                    console.log(`   Indexing: ⚠️  INCOMPLETE or UNKNOWN`);
+                }
+
+            } catch (e) {
+                console.log(`   Status: ❌ Invalid or corrupted (${e.message})`);
+            }
+        }
+
+        console.log(`${'─'.repeat(60)}\n`);
+
+        // Show important paths
+        console.log('[Paths] Important locations:');
+
+        // Global npm bin
+        const { execSync } = await import('child_process');
+        let npmBin = 'unknown';
+        try {
+            npmBin = execSync('npm bin -g', { encoding: 'utf-8' }).trim();
+        } catch {}
+
+        // Check all known MCP config paths (same as register.js)
+        const home = os.homedir();
+        const mcpConfigs = [];
+
+        // Antigravity
+        const antigravityConfig = path.join(home, '.gemini', 'antigravity', 'mcp_config.json');
+        const antigravityExists = await fs.access(antigravityConfig).then(() => true).catch(() => false);
+        mcpConfigs.push({ name: 'Antigravity', path: antigravityConfig, exists: antigravityExists });
+
+        // Claude Desktop
+        let claudeConfig = null;
+        if (process.platform === 'darwin') {
+            claudeConfig = path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        } else if (process.platform === 'win32') {
+            claudeConfig = path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+        }
+        if (claudeConfig) {
+            const claudeExists = await fs.access(claudeConfig).then(() => true).catch(() => false);
+            mcpConfigs.push({ name: 'Claude Desktop', path: claudeConfig, exists: claudeExists });
+        }
+
+        // VS Code (MCP extension uses settings.json or dedicated config)
+        let vscodeConfig = null;
+        if (process.platform === 'darwin') {
+            vscodeConfig = path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+        } else if (process.platform === 'win32') {
+            vscodeConfig = path.join(process.env.APPDATA || '', 'Code', 'User', 'settings.json');
+        } else {
+            vscodeConfig = path.join(home, '.config', 'Code', 'User', 'settings.json');
+        }
+        const vscodeExists = await fs.access(vscodeConfig).then(() => true).catch(() => false);
+        mcpConfigs.push({ name: 'VS Code', path: vscodeConfig, exists: vscodeExists });
+
+        // Cursor (uses similar structure to VS Code)
+        let cursorConfig = null;
+        if (process.platform === 'darwin') {
+            cursorConfig = path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json');
+        } else if (process.platform === 'win32') {
+            cursorConfig = path.join(process.env.APPDATA || '', 'Cursor', 'User', 'settings.json');
         } else {
-             console.error(`[Lifecycle] Failed to check status: ${error.message}`);
+            cursorConfig = path.join(home, '.config', 'Cursor', 'User', 'settings.json');
+        }
+        const cursorExists = await fs.access(cursorConfig).then(() => true).catch(() => false);
+        mcpConfigs.push({ name: 'Cursor', path: cursorConfig, exists: cursorExists });
+
+        console.log(`   📦 Global npm bin: ${npmBin}`);
+        console.log(`   ⚙️  MCP configs:`);
+        for (const cfg of mcpConfigs) {
+            const status = cfg.exists ? '\x1b[32m(exists)\x1b[0m' : '\x1b[90m(not found)\x1b[0m';
+            console.log(`      - ${cfg.name}: ${cfg.path} ${status}`);
         }
+        console.log(`   💾 Cache root: ${globalCacheRoot}`);
+        console.log(`   📁 Current dir: ${process.cwd()}`);
+        console.log('');
+
+    } catch (error) {
+        console.error(`[Logs] Error reading cache: ${error.message}`);
     }
 }

package/features/register.js

@@ -23,35 +23,59 @@ function getConfigPaths() {
   const paths = [];
 
   // Antigravity
-  if (platform === 'win32') {
+  paths.push({
+    name: 'Antigravity',
+    path: path.join(home, '.gemini', 'antigravity', 'mcp_config.json')
+  });
+
+  // Claude Desktop
+  if (platform === 'darwin') {
     paths.push({
-      name: 'Antigravity',
-      path: expandPath('%USERPROFILE%\\.gemini\\antigravity\\mcp_config.json')
+      name: 'Claude Desktop',
+      path: path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
     });
-  } else {
+  } else if (platform === 'win32') {
     paths.push({
-      name: 'Antigravity',
-      path: expandPath('~/.gemini/antigravity/mcp_config.json')
+      name: 'Claude Desktop',
+      path: path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json')
     });
   }
 
-  // Claude Desktop
+  // VS Code (MCP extension config in settings.json)
   if (platform === 'darwin') {
     paths.push({
-      name: 'Claude Desktop',
-      path: expandPath('~/Library/Application Support/Claude/claude_desktop_config.json')
+      name: 'VS Code',
+      path: path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json')
     });
   } else if (platform === 'win32') {
     paths.push({
-      name: 'Claude Desktop',
-      path: expandPath('%APPDATA%\\Claude\\claude_desktop_config.json')
+      name: 'VS Code',
+      path: path.join(process.env.APPDATA || '', 'Code', 'User', 'settings.json')
+    });
+  } else {
+    paths.push({
+      name: 'VS Code',
+      path: path.join(home, '.config', 'Code', 'User', 'settings.json')
     });
   }
 
-  // Cursor (Cascade) - Settings are usually in settings.json but MCP might have a specific spot?
-  // Cursor often uses VS Code's settings.json for some things, but explicit MCP support varies.
-  // For now, we'll stick to Antigravity and Claude as confirmed targets.
-  // NOTE: If Cursor adds a specific mcp_config, add it here.
+  // Cursor (uses similar structure to VS Code)
+  if (platform === 'darwin') {
+    paths.push({
+      name: 'Cursor',
+      path: path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json')
+    });
+  } else if (platform === 'win32') {
+    paths.push({
+      name: 'Cursor',
+      path: path.join(process.env.APPDATA || '', 'Cursor', 'User', 'settings.json')
+    });
+  } else {
+    paths.push({
+      name: 'Cursor',
+      path: path.join(home, '.config', 'Cursor', 'User', 'settings.json')
+    });
+  }
 
   return paths;
 }
@@ -135,6 +159,15 @@ export async function register(filter = null) {
     forceLog('\n\x1b[36m' + '='.repeat(60));
     forceLog('   🚀 Heuristic MCP Installed & Configured!   ');
     forceLog('='.repeat(60) + '\x1b[0m');
+
+    // Show important paths
+    const home = os.homedir();
+    const cacheRoot = process.platform === 'win32'
+        ? path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'heuristic-mcp')
+        : process.platform === 'darwin'
+        ? path.join(home, 'Library', 'Caches', 'heuristic-mcp')
+        : path.join(process.env.XDG_CACHE_HOME || path.join(home, '.cache'), 'heuristic-mcp');
+
     forceLog(`
 \x1b[33mACTION REQUIRED:\x1b[0m
 1. \x1b[1mRestart your IDE\x1b[0m (or reload the window) to load the new config.
@@ -145,7 +178,13 @@ export async function register(filter = null) {
 - \x1b[1mIndexing:\x1b[0m Will begin immediately after restart.
 - \x1b[1mUsage:\x1b[0m You can work while it indexes (it catches up!).
 
+\x1b[90mPATHS:\x1b[0m
+- \x1b[1mMCP Config:\x1b[0m ${configPaths.map(p => p.path).join(', ')}
+- \x1b[1mCache:\x1b[0m ${cacheRoot}
+- \x1b[1mCheck status:\x1b[0m heuristic-mcp --logs
+
 \x1b[36mHappy Coding! 🤖\x1b[0m
     `);
+    forceLog(`\n\x1b[90m(Please wait while npm finalizes the installation...)\x1b[0m`);
   }
 }

package/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { stop, start, status } from "./features/lifecycle.js";
+import { stop, start, status, logs } from "./features/lifecycle.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { pipeline } from "@xenova/transformers";
@@ -41,6 +41,11 @@ if (args.includes('--status')) {
   process.exit(0);
 }
 
+if (args.includes('--logs')) {
+  await logs();
+  process.exit(0);
+}
+
 // Check if --register flag is present
 if (args.includes('--register')) {
   // Extract optional filter (e.g. --register antigravity)
@@ -134,6 +139,7 @@ async function initialize() {
 
   // Initialize cache
   cache = new EmbeddingsCache(config);
+  console.error(`[Server] Cache directory: ${config.cacheDirectory}`);
   await cache.load();
 
   // Initialize features
@@ -240,6 +246,20 @@ process.on('SIGINT', async () => {
 
 process.on('SIGTERM', async () => {
   console.error("\n[Server] Received SIGTERM, shutting down...");
+
+  // Stop file watcher
+  if (indexer && indexer.watcher) {
+    await indexer.watcher.close();
+    console.error("[Server] File watcher stopped");
+  }
+
+  // Save cache
+  if (cache) {
+    await cache.save();
+    console.error("[Server] Cache saved");
+  }
+
+  console.error("[Server] Goodbye!");
   process.exit(0);
 });
 

package/lib/cache.js

@@ -193,9 +193,16 @@ export class EmbeddingsCache {
       const cacheFile = path.join(this.config.cacheDirectory, "embeddings.json");
       const hashFile = path.join(this.config.cacheDirectory, "file-hashes.json");
       const metaFile = path.join(this.config.cacheDirectory, CACHE_META_FILE);
+
+      // Include indexing stats in meta for verification
+      const uniqueFiles = new Set(this.vectorStore.map(chunk => chunk.file));
       this.cacheMeta = {
         version: CACHE_META_VERSION,
-        embeddingModel: this.config.embeddingModel
+        embeddingModel: this.config.embeddingModel,
+        lastSaveTime: new Date().toISOString(),
+        filesIndexed: uniqueFiles.size,
+        chunksStored: this.vectorStore.length,
+        workspace: this.config.searchDirectory || null
       };
 
       await Promise.all([

package/lib/config.js

@@ -1,5 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
+import os from "os";
+import crypto from "crypto";
 import { fileURLToPath } from "url";
 import { ProjectDetector } from "./project-detector.js";
 
@@ -58,7 +60,7 @@ const DEFAULT_CONFIG = {
   maxFileSize: 1048576, // 1MB - skip files larger than this
   maxResults: 5,
   enableCache: true,
-  cacheDirectory: "./.smart-coding-cache",
+  cacheDirectory: null, // Will be set dynamically by loadConfig()
   watchFiles: true,
   verbose: false,
   workerThreads: "auto", // "auto" = CPU cores - 1, or set a number
@@ -127,7 +129,34 @@ export async function loadConfig(workspaceDir = null) {
 
     // Set search and cache directories
     config.searchDirectory = baseDir;
-    config.cacheDirectory = path.join(baseDir, ".smart-coding-cache");
+
+    // Determine cache directory
+    if (userConfig.cacheDirectory) {
+      // User explicitly set a cache path in their config.json
+      config.cacheDirectory = path.isAbsolute(userConfig.cacheDirectory)
+        ? userConfig.cacheDirectory
+        : path.join(baseDir, userConfig.cacheDirectory);
+    } else {
+      // Use global cache directory to prevent cluttering project root
+      // Hash the absolute path to ensure uniqueness per project
+      const projectHash = crypto.createHash('md5').update(baseDir).digest('hex').slice(0, 12);
+      const globalCacheRoot = getGlobalCacheDir();
+      config.cacheDirectory = path.join(globalCacheRoot, "heuristic-mcp", projectHash);
+
+      // Support legacy .smart-coding-cache if it already exists in the project root
+      const legacyPath = path.join(baseDir, ".smart-coding-cache");
+      try {
+        const stats = await fs.stat(legacyPath);
+        if (stats.isDirectory()) {
+          config.cacheDirectory = legacyPath;
+          if (config.verbose) {
+            console.error(`[Config] Using existing local cache: ${legacyPath}`);
+          }
+        }
+      } catch {
+        // Legacy folder doesn't exist, using global path
+      }
+    }
 
     // Smart project detection
     if (config.smartIndexing !== false) {
@@ -375,6 +404,19 @@ export async function loadConfig(workspaceDir = null) {
   return config;
 }
 
+/**
+ * Get platform-specific global cache directory
+ */
+function getGlobalCacheDir() {
+  if (process.platform === 'win32') {
+    return process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Caches');
+  }
+  return process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+}
+
 export function getConfig() {
   return config;
 }

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@softerist/heuristic-mcp",
-  "version": "2.1.12",
-  "description": "An enhanced MCP server providing intelligent semantic code search with find-similar-code, recency ranking, and improved chunking. Fork of smart-coding-mcp.",
-  "type": "module",
-  "main": "index.js",
-  "bin": {
-    "heuristic-mcp": "index.js"
-  },
-  "scripts": {
-    "start": "node index.js",
-    "dev": "node --watch index.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clear-cache": "node scripts/clear-cache.js",
-    "postinstall": "node index.js --register"
-  },
+    "version": "2.1.23",
+    "description": "An enhanced MCP server providing intelligent semantic code search with find-similar-code, recency ranking, and improved chunking. Fork of smart-coding-mcp.",
+    "type": "module",
+    "main": "index.js",
+    "bin": {
+      "heuristic-mcp": "index.js"
+    },
+    "scripts": {
+      "start": "node index.js",
+      "dev": "node --watch index.js",
+      "test": "vitest run",
+      "test:watch": "vitest",
+      "clear-cache": "node scripts/clear-cache.js",
+      "postinstall": "node scripts/postinstall.js"
+    },
   "keywords": [
     "mcp",
     "semantic-search",

package/scripts/postinstall.js

@@ -0,0 +1,9 @@
+import { register } from '../features/register.js';
+
+// Run the registration process
+console.log('[PostInstall] Running Heuristic MCP registration...');
+register().catch(err => {
+    console.error('[PostInstall] Registration failed:', err.message);
+    // Don't fail the install if registration fails, just warn
+    process.exit(0);
+});