sigmap 7.2.1 → 7.4.0

package/llms-full.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.2.1 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.4.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
@@ -24,7 +24,7 @@ Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 | Task success proxy | 10% | 52.2% |
 | Prompts per task | 2.84 | 1.72 (39.4% fewer) |
 | Supported languages | — | 31 |
-| MCP tools | — | 11 |
+| MCP tools | — | 15 |
 | npm runtime dependencies | — | 0 |
 
 ---
@@ -114,7 +114,7 @@ sigmap --version                         Show version
 
 ---
 
-## MCP server — 11 tools
+## MCP server — 15 tools
 
 Start with `sigmap --mcp` (stdio JSON-RPC). Configure once:
 
@@ -210,6 +210,38 @@ Recall the project decision log — recent notes left by humans or agents across
 Input:  { limit?: number }
 ```
 
+### get_callee_signatures
+
+Return the EXACT current signature(s) of named symbols (functions, classes, methods) from the index — so an agent never guesses a callee's parameter types from training memory. Call this before writing code that uses a symbol. Unknown names get a closest-match suggestion.
+
+```
+Input:  { symbols: array }
+```
+
+### sigmap_notify_file_created
+
+Tell SigMap a file was created or modified so its signatures are indexed live for the rest of the session. Call this after writing a file — the new symbols become resolvable by search_signatures / get_callee_signatures.
+
+```
+Input:  { path: string, content?: string }
+```
+
+### sigmap_notify_symbol_added
+
+Fast path: register a single new symbol signature directly in the live index without re-reading the whole file.
+
+```
+Input:  { signature: string, file: string, line?: number }
+```
+
+### sigmap_notify_file_deleted
+
+Tell SigMap a file was deleted so its symbols are dropped from the live index.
+
+```
+Input:  { path: string }
+```
+
 ---
 
 ## Configuration (gen-context.config.json)
@@ -253,9 +285,9 @@ impact = {"depth":3,"includeSigs":true}
 
 ---
 
-## Supported languages (34 extractors)
+## Supported languages (35 extractors)
 
-cpp, csharp, css, dart, dockerfile, gdscript, generic, go, graphql, html, java, javascript, kotlin, markdown, php, properties, protobuf, python, r, ruby, rust, scala, shell, sql, svelte, swift, terraform, toml, typescript, typescript_react, vue, vue_sfc, xml, yaml
+cpp, csharp, css, dart, dispatch, dockerfile, gdscript, generic, go, graphql, html, java, javascript, kotlin, markdown, php, properties, protobuf, python, r, ruby, rust, scala, shell, sql, svelte, swift, terraform, toml, typescript, typescript_react, vue, vue_sfc, xml, yaml
 
 ---
 

package/llms.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.2.1 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.4.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
@@ -27,7 +27,7 @@ Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 - Token reduction: 97.0% average across benchmark repos
 - Task success: 52.2% vs 10% without SigMap
 - Prompts per task: 1.72 vs 2.84 baseline (39.4% fewer)
-- Languages: 31 supported · MCP tools: 11
+- Languages: 31 supported · MCP tools: 15
 - Dependencies: zero npm runtime dependencies · fully offline
 
 ## Quick start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "7.2.1",
+  "version": "7.4.0",
   "description": "97% token reduction for AI coding. Extracts function & class signatures with TF-IDF ranking to feed only the right files to Claude, Cursor, Copilot, Aider, Windsurf, local LLMs & MCP. Zero dependencies, runs offline via npx.",
   "main": "packages/core/index.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "7.2.1",
+  "version": "7.4.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "7.2.1",
+  "version": "7.4.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/extractors/dispatch.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Bundle-safe extractor dispatch.
+ *
+ * `packages/core`'s extract() resolves extractors via dynamic `require(path.join(…))`,
+ * which cannot run inside the standalone bundle (no filesystem `src/`). This module
+ * uses STATIC requires so the bundler rewrites them to `__require` and the extractors
+ * resolve from the bundled factories. Used by the live-index MCP write hooks.
+ */
+
+const path = require('path');
+
+// Static language → extractor map (every entry is a bundled factory).
+const EXTRACTORS = {
+  typescript: require('./typescript'),
+  typescript_react: require('./typescript_react'),
+  javascript: require('./javascript'),
+  python: require('./python'),
+  java: require('./java'),
+  kotlin: require('./kotlin'),
+  go: require('./go'),
+  rust: require('./rust'),
+  csharp: require('./csharp'),
+  cpp: require('./cpp'),
+  ruby: require('./ruby'),
+  php: require('./php'),
+  swift: require('./swift'),
+  dart: require('./dart'),
+  scala: require('./scala'),
+  gdscript: require('./gdscript'),
+  r: require('./r'),
+  vue: require('./vue'),
+  vue_sfc: require('./vue_sfc'),
+  svelte: require('./svelte'),
+  html: require('./html'),
+  css: require('./css'),
+  yaml: require('./yaml'),
+  shell: require('./shell'),
+  sql: require('./sql'),
+  graphql: require('./graphql'),
+  terraform: require('./terraform'),
+  protobuf: require('./protobuf'),
+  toml: require('./toml'),
+  properties: require('./properties'),
+  xml: require('./xml'),
+  markdown: require('./markdown'),
+  dockerfile: require('./dockerfile'),
+  generic: require('./generic'),
+};
+
+const EXT_MAP = {
+  '.ts': 'typescript', '.tsx': 'typescript_react',
+  '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+  '.py': 'python', '.pyw': 'python',
+  '.java': 'java',
+  '.kt': 'kotlin', '.kts': 'kotlin',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.cs': 'csharp',
+  '.cpp': 'cpp', '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.cc': 'cpp',
+  '.rb': 'ruby', '.rake': 'ruby',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.dart': 'dart',
+  '.scala': 'scala', '.sc': 'scala',
+  '.gd': 'gdscript',
+  '.r': 'r', '.R': 'r',
+  '.vue': 'vue_sfc',
+  '.svelte': 'svelte',
+  '.html': 'html', '.htm': 'html',
+  '.css': 'css', '.scss': 'css', '.sass': 'css', '.less': 'css',
+  '.yml': 'yaml', '.yaml': 'yaml',
+  '.sh': 'shell', '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+  '.sql': 'sql',
+  '.graphql': 'graphql', '.gql': 'graphql',
+  '.tf': 'terraform', '.tfvars': 'terraform',
+  '.proto': 'protobuf',
+  '.toml': 'toml',
+  '.properties': 'properties',
+  '.xml': 'xml',
+  '.md': 'markdown',
+};
+
+/** Resolve a language key from a file path/name. */
+function langFor(filePathOrName) {
+  const base = path.basename(String(filePathOrName || ''));
+  if (base === 'Dockerfile' || base.startsWith('Dockerfile.')) return 'dockerfile';
+  const ext = path.extname(base).toLowerCase();
+  return EXT_MAP[ext] || null;
+}
+
+/**
+ * Extract signatures from a file's content using the right extractor.
+ * @param {string} filePathOrName - path or name (extension drives the extractor)
+ * @param {string} src - file content
+ * @returns {string[]}
+ */
+function extractFile(filePathOrName, src) {
+  if (!src || typeof src !== 'string') return [];
+  const lang = langFor(filePathOrName);
+  const mod = lang ? EXTRACTORS[lang] : null;
+  if (!mod || typeof mod.extract !== 'function') return [];
+  try {
+    const out = mod.extract(src);
+    return Array.isArray(out) ? out : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+module.exports = { extractFile, langFor };

package/src/mcp/handlers.js

@@ -543,4 +543,133 @@ function readMemory(args, cwd) {
   return out.join('\n');
 }
 
-module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory };
+/**
+ * get_callee_signatures — return the exact defining signature(s) of named
+ * symbols from the index, so an agent never guesses a callee's parameter types.
+ * Unknown names get a closest-match suggestion.
+ * @param {{symbols:string[]}} args
+ * @param {string} cwd
+ */
+function getCalleeSignatures(args, cwd) {
+  const symbols = args && Array.isArray(args.symbols)
+    ? args.symbols.map((s) => String(s).trim()).filter(Boolean)
+    : null;
+  if (!symbols || symbols.length === 0) {
+    return 'Missing required argument: symbols (non-empty string[])';
+  }
+
+  try {
+    const { buildSigIndex } = require('../retrieval/ranker');
+    const { buildSymbolCandidates, closestMatch, formatSuggestion } = require('../verify/closest-match');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) return 'No context file found. Run: node gen-context.js';
+
+    // Extract the defining symbol name from a signature line (same rules as
+    // buildSymbolCandidates) so we match definitions, not param occurrences.
+    const defName = (sig) => {
+      const cleaned = String(sig).replace(/\s*:\d+(?:-\d+)?\s*$/, '');
+      const m = cleaned.match(/\b(?:async\s+function|function|class|def|interface|type|enum|const|let|var)\s+([A-Za-z_$][\w$]*)/)
+        || cleaned.match(/([A-Za-z_$][\w$]*)\s*\(/);
+      return m ? m[1] : null;
+    };
+
+    const candidates = buildSymbolCandidates(index);
+    const blocks = [];
+    for (const symbol of symbols) {
+      const matches = [];
+      for (const [file, sigs] of index.entries()) {
+        for (const sig of sigs) {
+          if (defName(sig) === symbol) matches.push(`${sig}    (${file})`);
+        }
+      }
+      if (matches.length === 0) {
+        const cm = closestMatch(symbol, candidates);
+        const hint = cm ? ' — ' + formatSuggestion(cm) : '';
+        blocks.push(`### ${symbol}\n_not found in index${hint}_`);
+      } else {
+        blocks.push(`### ${symbol}\n${matches.join('\n')}`);
+      }
+    }
+    return blocks.join('\n\n');
+  } catch (err) {
+    return `_get_callee_signatures failed: ${err.message}_`;
+  }
+}
+
+// ── Layer 1: live-index write hooks ────────────────────────────────────────
+// Keep the sig-cache fresh while an agent creates/modifies/deletes files, so
+// new code is discoverable in the same session. buildSigIndex already merges
+// the cache (_buildSigIndexFromCache), so updates are live on the next read.
+
+function _pkgVersion(cwd) {
+  try { return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).version || '0.0.0'; }
+  catch (_) { return '0.0.0'; }
+}
+
+
+/** notify_file_created — extract a file's signatures and index it live. */
+function notifyFileCreated(args, cwd) {
+  const rel = args && args.path;
+  if (!rel) return 'Missing required argument: path';
+  try {
+    const { extractFile } = require('../extractors/dispatch');
+    const { loadCache, saveCache } = require('../cache/sig-cache');
+    const abs = path.resolve(cwd, rel);
+    let content = args.content;
+    if (typeof content !== 'string') {
+      try { content = fs.readFileSync(abs, 'utf8'); } catch (_) { content = ''; }
+    }
+    const sigs = extractFile(abs, content);
+    const version = _pkgVersion(cwd);
+    const cache = loadCache(cwd, version);
+    if (sigs.length > 0) {
+      cache.set(abs, { mtime: Date.now(), sigs });
+    }
+    saveCache(cwd, version, cache);
+    return `Indexed ${rel}: ${sigs.length} signature(s) now live.`;
+  } catch (err) {
+    return `_notify_file_created failed: ${err.message}_`;
+  }
+}
+
+/** notify_symbol_added — append one signature to a file's live cache entry. */
+function notifySymbolAdded(args, cwd) {
+  if (!args || !args.signature || !args.file) {
+    return 'Missing required arguments: signature, file';
+  }
+  try {
+    const { loadCache, saveCache } = require('../cache/sig-cache');
+    const abs = path.resolve(cwd, args.file);
+    const version = _pkgVersion(cwd);
+    const cache = loadCache(cwd, version);
+    const entry = cache.get(abs) || { mtime: Date.now(), sigs: [] };
+    const line = Number.isFinite(Number(args.line)) ? `  :${args.line}` : '';
+    const sig = String(args.signature) + line;
+    if (!entry.sigs.includes(sig)) entry.sigs.push(sig);
+    entry.mtime = Date.now();
+    cache.set(abs, entry);
+    saveCache(cwd, version, cache);
+    return `Added signature to ${args.file} (${entry.sigs.length} total).`;
+  } catch (err) {
+    return `_notify_symbol_added failed: ${err.message}_`;
+  }
+}
+
+/** notify_file_deleted — drop a file's cache-overlay entry. */
+function notifyFileDeleted(args, cwd) {
+  const rel = args && args.path;
+  if (!rel) return 'Missing required argument: path';
+  try {
+    const { loadCache, saveCache } = require('../cache/sig-cache');
+    const abs = path.resolve(cwd, rel);
+    const version = _pkgVersion(cwd);
+    const cache = loadCache(cwd, version);
+    const had = cache.delete(abs);
+    saveCache(cwd, version, cache);
+    return had ? `Removed ${rel} from the live index.` : `${rel} was not in the live cache.`;
+  } catch (err) {
+    return `_notify_file_deleted failed: ${err.message}_`;
+  }
+}
+
+module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted };

package/src/mcp/server.js

@@ -14,11 +14,11 @@
 
 const readline = require('readline');
 const { TOOLS } = require('./tools');
-const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory } = require('./handlers');
+const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted } = require('./handlers');
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '7.2.1',
+  version: '7.4.0',
   description: 'SigMap MCP server — code signatures on demand',
 };
 
@@ -77,6 +77,10 @@ function dispatch(msg, cwd) {
       else if (name === 'get_impact') text = getImpact(args, cwd);
       else if (name === 'get_lines') text = getLines(args, cwd);
       else if (name === 'read_memory') text = readMemory(args, cwd);
+      else if (name === 'get_callee_signatures') text = getCalleeSignatures(args, cwd);
+      else if (name === 'sigmap_notify_file_created') text = notifyFileCreated(args, cwd);
+      else if (name === 'sigmap_notify_symbol_added') text = notifySymbolAdded(args, cwd);
+      else if (name === 'sigmap_notify_file_deleted') text = notifyFileDeleted(args, cwd);
       else {
         respondError(id, -32601, `Unknown tool: ${name}`);
         return;

package/src/mcp/tools.js

@@ -1,9 +1,11 @@
 'use strict';
 
 /**
- * MCP tool definitions for SigMap (11 tools).
+ * MCP tool definitions for SigMap (15 tools).
  * read_context, search_signatures, get_map, create_checkpoint, get_routing,
- * explain_file, list_modules, query_context, get_impact, get_lines, read_memory.
+ * explain_file, list_modules, query_context, get_impact, get_lines, read_memory,
+ * get_callee_signatures, sigmap_notify_file_created, sigmap_notify_symbol_added,
+ * sigmap_notify_file_deleted.
  */
 
 const TOOLS = [
@@ -215,6 +217,67 @@ const TOOLS = [
       required: [],
     },
   },
+  {
+    name: 'get_callee_signatures',
+    description:
+      'Return the EXACT current signature(s) of named symbols (functions, classes, ' +
+      "methods) from the index — so an agent never guesses a callee's parameter types " +
+      'from training memory. Call this before writing code that uses a symbol. ' +
+      'Unknown names get a closest-match suggestion.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbols: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Symbol names to resolve (e.g. ["validateToken", "UserService"]).',
+        },
+      },
+      required: ['symbols'],
+    },
+  },
+  {
+    name: 'sigmap_notify_file_created',
+    description:
+      'Tell SigMap a file was created or modified so its signatures are indexed ' +
+      'live for the rest of the session. Call this after writing a file — the new ' +
+      'symbols become resolvable by search_signatures / get_callee_signatures.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path relative to the project root.' },
+        content: { type: 'string', description: 'Optional file content; read from disk if omitted.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'sigmap_notify_symbol_added',
+    description:
+      'Fast path: register a single new symbol signature directly in the live ' +
+      'index without re-reading the whole file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        signature: { type: 'string', description: 'The signature line (e.g. "function check(key)").' },
+        file: { type: 'string', description: 'File path the symbol belongs to (relative to root).' },
+        line: { type: 'number', description: 'Optional 1-based line number.' },
+      },
+      required: ['signature', 'file'],
+    },
+  },
+  {
+    name: 'sigmap_notify_file_deleted',
+    description:
+      'Tell SigMap a file was deleted so its symbols are dropped from the live index.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Deleted file path relative to the project root.' },
+      },
+      required: ['path'],
+    },
+  },
 ];
 
 module.exports = { TOOLS };