@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/lib/call-graph.js

@@ -5,7 +5,7 @@
  * Works across multiple languages without external dependencies.
  */
 
-import path from "path";
+import path from 'path';
 
 // Language-specific patterns for function/method definitions
 const DEFINITION_PATTERNS = {
@@ -19,30 +19,30 @@ const DEFINITION_PATTERNS = {
     // method definitions: name() { or async name() {
     /^\s*(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm,
     // object method shorthand: name() { inside object
-    /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/g
+    /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/g,
   ],
   python: [
     // def name():
     /def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g,
     // class Name:
-    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[:(]/g
+    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[:(]/g,
   ],
   go: [
     // func name() or func (r Receiver) name()
-    /func\s+(?:\([^)]*\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g
+    /func\s+(?:\([^)]*\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g,
   ],
   rust: [
     // fn name()
     /fn\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[<(]/g,
     // impl Name
-    /impl(?:\s*<[^>]*>)?\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
+    /impl(?:\s*<[^>]*>)?\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
   ],
   java: [
     // public void name() or private static String name()
     /(?:public|private|protected)?\s*(?:static)?\s*(?:\w+)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g,
     // class Name
-    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
-  ]
+    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+  ],
 };
 
 // Pattern for function calls (language-agnostic, catches most cases)
@@ -51,19 +51,117 @@ const CALL_PATTERN = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
 // Common built-ins to exclude from call detection (all lowercase for case-insensitive matching)
 const BUILTIN_EXCLUSIONS = new Set([
   // JavaScript
-  "if", "for", "while", "switch", "catch", "function", "async", "await",
-  "return", "throw", "new", "typeof", "instanceof", "delete", "void",
-  "console", "require", "import", "export", "super", "this",
+  'if',
+  'for',
+  'while',
+  'switch',
+  'catch',
+  'function',
+  'async',
+  'await',
+  'return',
+  'throw',
+  'new',
+  'typeof',
+  'instanceof',
+  'delete',
+  'void',
+  'console',
+  'require',
+  'import',
+  'export',
+  'super',
+  'this',
   // Common functions that aren't meaningful for call graphs
-  "parseint", "parsefloat", "string", "number", "boolean", "array", "object",
-  "map", "set", "promise", "error", "json", "math", "date", "regexp",
+  'parseint',
+  'parsefloat',
+  'string',
+  'number',
+  'boolean',
+  'array',
+  'object',
+  'map',
+  'set',
+  'promise',
+  'error',
+  'json',
+  'math',
+  'date',
+  'regexp',
   // Python
-  "def", "class", "print", "len", "range", "str", "int", "float", "list", "dict",
-  "tuple", "bool", "type", "isinstance", "hasattr", "getattr", "setattr",
+  'def',
+  'class',
+  'print',
+  'len',
+  'range',
+  'str',
+  'int',
+  'float',
+  'list',
+  'dict',
+  'tuple',
+  'bool',
+  'type',
+  'isinstance',
+  'hasattr',
+  'getattr',
+  'setattr',
   // Go
-  "func", "make", "append", "cap", "panic", "recover",
+  'func',
+  'make',
+  'append',
+  'cap',
+  'panic',
+  'recover',
   // Control flow that looks like function calls
-  "else", "try", "finally", "with", "assert", "raise", "yield"
+  'else',
+  'try',
+  'finally',
+  'with',
+  'assert',
+  'raise',
+  'yield',
+  // Test frameworks
+  'describe',
+  'it',
+  'test',
+  'expect',
+  'beforeeach',
+  'aftereach',
+  'beforeall',
+  'afterall',
+  // Common prototypes / methods (too noisy)
+  'match',
+  'exec',
+  'replace',
+  'split',
+  'join',
+  'slice',
+  'splice',
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'includes',
+  'indexof',
+  'foreach',
+  'filter',
+  'reduce',
+  'find',
+  'some',
+  'every',
+  'sort',
+  'keys',
+  'values',
+  'entries',
+  'from',
+  'then',
+  'catch',
+  'finally',
+  'all',
+  'race',
+  'resolve',
+  'reject',
 ]);
 
 /**
@@ -72,29 +170,34 @@ const BUILTIN_EXCLUSIONS = new Set([
 function detectLanguage(file) {
   const ext = path.extname(file).toLowerCase();
   const langMap = {
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".ts": "javascript",
-    ".tsx": "javascript",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".py": "python",
-    ".pyw": "python",
-    ".go": "go",
-    ".rs": "rust",
-    ".java": "java",
-    ".kt": "java",
-    ".scala": "java"
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'javascript',
+    '.tsx': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.py': 'python',
+    '.pyw': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.kt': 'java',
+    '.scala': 'java',
   };
-  return langMap[ext] || "javascript"; // Default to JS patterns
+  if (langMap[ext]) {
+    return langMap[ext];
+  } else {
+    return 'javascript'; // Default to JS patterns
+  }
 }
 
 /**
  * Extract function/class definitions from content
+ * Exported for testing; treat as internal helper.
  */
 export function extractDefinitions(content, file) {
   const language = detectLanguage(file);
-  const patterns = DEFINITION_PATTERNS[language] || DEFINITION_PATTERNS.javascript;
+  const patterns = DEFINITION_PATTERNS[language];
   const definitions = new Set();
 
   for (const pattern of patterns) {
@@ -114,6 +217,7 @@ export function extractDefinitions(content, file) {
 
 /**
  * Extract function calls from content
+ * Exported for testing; treat as internal helper.
  */
 export function extractCalls(content, file) {
   const calls = new Set();
@@ -140,23 +244,23 @@ function removeStringsAndComments(content, file) {
   const ext = path.extname(file).toLowerCase();
 
   // Remove single-line comments
-  let cleaned = content.replace(/\/\/.*$/gm, "");
+  let cleaned = content.replace(/\/\/.*$/gm, '');
 
   // Remove multi-line comments
-  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, "");
+  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
 
   // Remove Python comments
-  if (ext === ".py" || ext === ".pyw") {
-    cleaned = cleaned.replace(/#.*$/gm, "");
+  if (ext === '.py' || ext === '.pyw') {
+    cleaned = cleaned.replace(/#.*$/gm, '');
     // Remove triple-quoted strings (docstrings)
-    cleaned = cleaned.replace(/"""[\s\S]*?"""/g, "");
-    cleaned = cleaned.replace(/'''[\s\S]*?'''/g, "");
+    cleaned = cleaned.replace(/"""[\s\S]*?"""/g, '');
+    cleaned = cleaned.replace(/'''[\s\S]*?'''/g, '');
   }
 
   // Remove string literals (simplified - handles most cases)
   cleaned = cleaned.replace(/"(?:[^"\\]|\\.)*"/g, '""');
   cleaned = cleaned.replace(/'(?:[^'\\]|\\.)*'/g, "''");
-  cleaned = cleaned.replace(/`(?:[^`\\]|\\.)*`/g, "``");
+  cleaned = cleaned.replace(/`(?:[^`\\]|\\.)*`/g, '``');
 
   return cleaned;
 }
@@ -170,11 +274,11 @@ export function extractCallData(content, file) {
 
   // Remove self-references (calls to functions defined in same file)
   const definitionSet = new Set(definitions);
-  const externalCalls = calls.filter(c => !definitionSet.has(c));
+  const externalCalls = calls.filter((c) => !definitionSet.has(c));
 
   return {
     definitions,
-    calls: externalCalls
+    calls: externalCalls,
   };
 }
 
@@ -182,7 +286,7 @@ export function extractCallData(content, file) {
  * Build a call graph from file data
  */
 export function buildCallGraph(fileCallData) {
-  const defines = new Map();  // symbol -> files that define it
+  const defines = new Map(); // symbol -> files that define it
   const calledBy = new Map(); // symbol -> files that call it
   const fileCalls = new Map(); // file -> symbols it calls
 
@@ -253,21 +357,32 @@ export function getRelatedFiles(callGraph, symbols, maxHops = 1) {
   return related;
 }
 
+// Patterns for extracting symbols from content
+const SYMBOL_PATTERNS = [
+  // function name()
+  /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+  // class Name
+  /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+  // const/let/var name = ...
+  /(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g,
+  // Python def/class
+  /def\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+  /class\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+  // Go func
+  /func\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+  // Rust fn
+  /fn\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+  // Java/C# methods (simplified)
+  /(?:public|private|protected|static)\s+\w+\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g
+];
+
 /**
  * Extract symbols (function/class names) from search results
  */
 export function extractSymbolsFromContent(content) {
   const symbols = new Set();
 
-  // Look for function/class definitions in the content
-  const patterns = [
-    /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-    /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-    /def\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
-    /(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g
-  ];
-
-  for (const pattern of patterns) {
+  for (const pattern of SYMBOL_PATTERNS) {
     pattern.lastIndex = 0;
     let match;
     while ((match = pattern.exec(content)) !== null) {

package/lib/cli.js

@@ -0,0 +1,154 @@
+export const DEFAULT_LOG_TAIL_LINES = 200;
+
+export function printHelp(defaultTailLines = DEFAULT_LOG_TAIL_LINES) {
+  console.info(`Heuristic MCP Server
+
+Usage:
+  heuristic-mcp [options]
+
+Options:
+  --status                 Show server and cache status
+  --fix                    With --status, remove stale cache directories
+  --clear-cache            Remove cache for current workspace (and stale global caches)
+  --logs                   Tail server logs (defaults to last 200 lines, follows)
+  --tail <lines>           Lines to show with --logs (default: ${defaultTailLines})
+  --no-follow              Do not follow log output with --logs
+  --start                  Ensure IDE config is registered (does not start server)
+  --stop                   Stop running server instances
+  --register [ide]         Register MCP server with IDE (antigravity|cursor|"Claude Desktop")
+  --workspace <path>       Workspace path (used by IDE launch / log viewer)
+  --version, -v            Show version
+  --help, -h               Show this help
+`);
+}
+
+export function parseWorkspaceDir(args) {
+  const workspaceIndex = args.findIndex((arg) => arg.startsWith('--workspace'));
+  if (workspaceIndex === -1) return null;
+
+  const arg = args[workspaceIndex];
+  let rawWorkspace = null;
+
+  if (arg.includes('=')) {
+    rawWorkspace = arg.split('=')[1];
+  } else if (workspaceIndex + 1 < args.length) {
+    rawWorkspace = args[workspaceIndex + 1];
+  }
+
+  // Check if IDE variable wasn't expanded (contains ${})
+  if (rawWorkspace && rawWorkspace.includes('${')) {
+    console.error(
+      `[Server] IDE variable not expanded: ${rawWorkspace}, falling back to auto-detected workspace`
+    );
+    return null;
+  }
+
+  return rawWorkspace || null;
+}
+
+export function collectUnknownFlags(rawArgs, knownFlags, flagsWithValue) {
+  const unknownFlags = [];
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (flagsWithValue.has(arg)) {
+      if (arg.includes('=')) continue;
+      const next = rawArgs[i + 1];
+      if (next && !next.startsWith('-')) {
+        i += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith('-') && !knownFlags.has(arg) && !arg.startsWith('--workspace=')) {
+      unknownFlags.push(arg);
+    }
+  }
+  return unknownFlags;
+}
+
+export function parseArgs(argv = process.argv) {
+  const args = argv.slice(2);
+  const rawArgs = [...args];
+
+  const wantsVersion = args.includes('--version') || args.includes('-v');
+  const wantsHelp = args.includes('--help') || args.includes('-h');
+  const wantsStatus = args.includes('--status');
+  const wantsClearCache = args.includes('--clear-cache');
+  const wantsLogs = args.includes('--logs');
+  const wantsStart = args.includes('--start');
+  const wantsStop = args.includes('--stop');
+  const wantsRegister = args.includes('--register');
+  const wantsFix = args.includes('--fix');
+  const wantsNoFollow = args.includes('--no-follow');
+
+  const isServerMode = !(
+    wantsStatus ||
+    wantsClearCache ||
+    wantsLogs ||
+    wantsStart ||
+    wantsStop ||
+    wantsRegister ||
+    wantsHelp ||
+    wantsVersion
+  );
+
+  const workspaceDir = parseWorkspaceDir(args);
+
+  let tailLines = DEFAULT_LOG_TAIL_LINES;
+  if (wantsLogs) {
+    const tailIndex = args.indexOf('--tail');
+    if (tailIndex !== -1 && args[tailIndex + 1]) {
+      const parsed = parseInt(args[tailIndex + 1], 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        tailLines = parsed;
+      }
+    }
+  }
+
+  let registerFilter = null;
+  if (wantsRegister) {
+    const filterIndex = args.indexOf('--register');
+    registerFilter =
+      args[filterIndex + 1] && !args[filterIndex + 1].startsWith('-')
+        ? args[filterIndex + 1]
+        : null;
+  }
+
+  const knownFlags = new Set([
+    '--status',
+    '--fix',
+    '--clear-cache',
+    '--logs',
+    '--tail',
+    '--no-follow',
+    '--start',
+    '--stop',
+    '--register',
+    '--workspace',
+    '--version',
+    '-v',
+    '--help',
+    '-h',
+  ]);
+  const flagsWithValue = new Set(['--tail', '--workspace', '--register']);
+  const unknownFlags = collectUnknownFlags(rawArgs, knownFlags, flagsWithValue);
+
+  return {
+    args,
+    rawArgs,
+    isServerMode,
+    workspaceDir,
+    wantsVersion,
+    wantsHelp,
+    wantsStatus,
+    wantsClearCache,
+    wantsLogs,
+    wantsStart,
+    wantsStop,
+    wantsRegister,
+    wantsFix,
+    wantsNoFollow,
+    tailLines,
+    registerFilter,
+    unknownFlags,
+  };
+}