sigmap 7.3.0 → 7.5.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.3.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.5.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 | — | 12 |
+| MCP tools | — | 15 |
 | npm runtime dependencies | — | 0 |
 
 ---
@@ -114,7 +114,7 @@ sigmap --version                         Show version
 
 ---
 
-## MCP server — 12 tools
+## MCP server — 15 tools
 
 Start with `sigmap --mcp` (stdio JSON-RPC). Configure once:
 
@@ -218,6 +218,30 @@ Return the EXACT current signature(s) of named symbols (functions, classes, meth
 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)
@@ -261,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.3.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.5.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: 12
+- 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.3.0",
+  "version": "7.5.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.3.0",
+  "version": "7.5.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.3.0",
+  "version": "7.5.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/cache/freshen.js

@@ -0,0 +1,123 @@
+'use strict';
+
+/**
+ * Read-time self-heal (IMPL.md Layer 1, "safety net" tier).
+ *
+ * Keeps the sig-cache in line with the current source tree so the index reflects
+ * on-disk reality even when no write hook was called. Re-extracts files modified
+ * since the context file was generated (bounded to actual session edits, not the
+ * whole tree), drops cache entries for deleted files, and persists. buildSigIndex
+ * already merges the cache, so the next read is fresh.
+ *
+ * Throttled per cwd. Skips entirely when there is no generated index to heal
+ * (a cold repo should run `generate` or use the notify hooks).
+ *
+ * Zero-dependency, bundle-safe (fs + dispatch + sig-cache).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadCache, saveCache, getChangedFiles } = require('./sig-cache');
+const { extractFile, langFor } = require('../extractors/dispatch');
+
+const DEFAULT_SRC_DIRS = ['src', 'app', 'lib', 'packages', 'services', 'api'];
+const DEFAULT_EXCLUDE = [
+  'node_modules', '.git', 'dist', 'build', 'out', '__pycache__',
+  '.next', 'coverage', 'target', 'vendor', '.context',
+];
+const CONTEXT_PATHS = [
+  ['.github', 'copilot-instructions.md'],
+  ['CLAUDE.md'], ['AGENTS.md'], ['.github', 'context-cold.md'],
+];
+const THROTTLE_MS = 1500;
+const _lastRun = new Map();
+
+function _readConfig(cwd) {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(cwd, 'gen-context.config.json'), 'utf8'));
+    return cfg && typeof cfg === 'object' ? cfg : {};
+  } catch (_) { return {}; }
+}
+
+function _pkgVersion(cwd) {
+  try { return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).version || '0.0.0'; }
+  catch (_) { return '0.0.0'; }
+}
+
+/** Newest mtime among existing generated context files, or 0 if none. */
+function _contextMtime(cwd) {
+  let newest = 0;
+  for (const parts of CONTEXT_PATHS) {
+    try { newest = Math.max(newest, fs.statSync(path.join(cwd, ...parts)).mtimeMs); } catch (_) {}
+  }
+  return newest;
+}
+
+function _walk(dir, exclude, out, depth, maxDepth) {
+  if (depth > maxDepth) return;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+  for (const e of entries) {
+    if (exclude.has(e.name)) continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) _walk(full, exclude, out, depth + 1, maxDepth);
+    else if (e.isFile() && langFor(e.name)) out.push(full);
+  }
+}
+
+/**
+ * Re-extract source files changed since the last generate; drop deleted files.
+ * @param {string} cwd
+ * @param {{force?:boolean, now?:number}} [opts]
+ * @returns {number} cache entries touched
+ */
+function freshen(cwd, opts = {}) {
+  const now = opts.now != null ? opts.now : Date.now();
+  if (!opts.force) {
+    if (now - (_lastRun.get(cwd) || 0) < THROTTLE_MS) return 0;
+  }
+  _lastRun.set(cwd, now);
+
+  try {
+    const version = _pkgVersion(cwd);
+    const cache = loadCache(cwd, version);
+    const ctxMtime = _contextMtime(cwd);
+    // Nothing to heal: no generated context AND no live cache overlay.
+    if (ctxMtime === 0 && cache.size === 0) return 0;
+
+    const cfg = _readConfig(cwd);
+    const srcDirs = Array.isArray(cfg.srcDirs) && cfg.srcDirs.length ? cfg.srcDirs : DEFAULT_SRC_DIRS;
+    const exclude = new Set([...DEFAULT_EXCLUDE, ...(Array.isArray(cfg.exclude) ? cfg.exclude : [])]);
+    const maxDepth = Number.isFinite(cfg.maxDepth) ? cfg.maxDepth : 8;
+
+    const files = [];
+    for (const d of srcDirs) {
+      const abs = path.isAbsolute(d) ? d : path.join(cwd, d);
+      if (fs.existsSync(abs)) _walk(abs, exclude, files, 0, maxDepth);
+    }
+
+    // Candidates = files modified since the context was generated, or not yet cached.
+    const candidates = files.filter((f) => {
+      try { return fs.statSync(f).mtimeMs > ctxMtime || !cache.has(f); } catch (_) { return false; }
+    });
+    const { changed } = getChangedFiles(candidates, cache);
+
+    let touched = 0;
+    for (const f of changed) {
+      try {
+        const sigs = extractFile(f, fs.readFileSync(f, 'utf8'));
+        cache.set(f, { mtime: fs.statSync(f).mtimeMs, sigs });
+        touched++;
+      } catch (_) {}
+    }
+    // Note: deletions are NOT swept here — a cache entry may be a `notify`
+    // overlay for a file not yet on disk. Explicit removal is `notify_file_deleted`.
+
+    if (touched > 0) saveCache(cwd, version, cache);
+    return touched;
+  } catch (_) {
+    return 0;
+  }
+}
+
+module.exports = { freshen };

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

@@ -72,6 +72,7 @@ function searchSignatures(args, cwd) {
 
   const query = args.query.toLowerCase();
   try {
+    try { require('../cache/freshen').freshen(cwd); } catch (_) {}
     const { buildSigIndex } = require('../retrieval/ranker');
     const index = buildSigIndex(cwd);
     if (index.size === 0) {
@@ -559,6 +560,7 @@ function getCalleeSignatures(args, cwd) {
   }
 
   try {
+    try { require('../cache/freshen').freshen(cwd); } catch (_) {}
     const { buildSigIndex } = require('../retrieval/ranker');
     const { buildSymbolCandidates, closestMatch, formatSuggestion } = require('../verify/closest-match');
     const index = buildSigIndex(cwd);
@@ -596,4 +598,80 @@ function getCalleeSignatures(args, cwd) {
   }
 }
 
-module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory, getCalleeSignatures };
+// ── 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, getCalleeSignatures } = 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.3.0',
+  version: '7.5.0',
   description: 'SigMap MCP server — code signatures on demand',
 };
 
@@ -78,6 +78,9 @@ function dispatch(msg, 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,10 +1,11 @@
 'use strict';
 
 /**
- * MCP tool definitions for SigMap (12 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,
- * get_callee_signatures.
+ * get_callee_signatures, sigmap_notify_file_created, sigmap_notify_symbol_added,
+ * sigmap_notify_file_deleted.
  */
 
 const TOOLS = [
@@ -235,6 +236,48 @@ const TOOLS = [
       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 };