sigmap 5.9.0 → 6.0.1

package/gen-context.js

@@ -4520,6 +4520,71 @@ __factories["./src/map/route-table"] = function(module, exports) {
   
 };
 
+// ── ./src/cache/sig-cache ──
+__factories["./src/cache/sig-cache"] = function(module, exports) {
+  'use strict';
+
+  const fs   = require('fs');
+  const path = require('path');
+
+  const CACHE_FILE = '.sigmap-cache.json';
+
+  function cachePath(cwd) {
+    return path.join(cwd, CACHE_FILE);
+  }
+
+  function loadCache(cwd, currentVersion) {
+    try {
+      const raw = fs.readFileSync(cachePath(cwd), 'utf8');
+      const data = JSON.parse(raw);
+      if (data.sigmapVersion !== currentVersion) return new Map();
+      return new Map(Object.entries(data.entries || {}));
+    } catch (_) {
+      return new Map();
+    }
+  }
+
+  function saveCache(cwd, currentVersion, cache) {
+    try {
+      const data = {
+        sigmapVersion: currentVersion,
+        entries: Object.fromEntries(cache),
+      };
+      fs.writeFileSync(cachePath(cwd), JSON.stringify(data), 'utf8');
+    } catch (_) {}
+  }
+
+  function getChangedFiles(files, cache) {
+    const changed = [];
+    const unchanged = [];
+    for (const f of files) {
+      try {
+        const mtime = fs.statSync(f).mtimeMs;
+        const cached = cache.get(f);
+        if (!cached || cached.mtime !== mtime) {
+          changed.push(f);
+        } else {
+          unchanged.push(f);
+        }
+      } catch (_) {
+        changed.push(f);
+      }
+    }
+    return { changed, unchanged };
+  }
+
+  function updateCacheEntries(cache, extracted) {
+    for (const { file, sigs } of extracted) {
+      try {
+        const mtime = fs.statSync(file).mtimeMs;
+        cache.set(file, { mtime, sigs });
+      } catch (_) {}
+    }
+  }
+
+  module.exports = { loadCache, saveCache, getChangedFiles, updateCacheEntries };
+};
+
 // ── ./src/graph/builder ──
 __factories["./src/graph/builder"] = function(module, exports) {
   'use strict';
@@ -5291,7 +5356,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '5.9.0',
+  version: '6.0.1',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7009,7 +7074,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '5.9.0';
+const VERSION = '6.0.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8844,10 +8909,30 @@ function main() {
   }
 
   const invokedFrom = process.cwd();
-  const cwd = resolveProjectRoot(invokedFrom);
+
+  // --cwd <dir>: restrict scanning to that directory instead of the project root
+  const cwdFlagIdx = args.indexOf('--cwd');
+  const cwdFlag = cwdFlagIdx !== -1 ? (args[cwdFlagIdx + 1] || '').trim() : null;
+  if (cwdFlag !== null && (!cwdFlag || cwdFlag.startsWith('--'))) {
+    console.error('[sigmap] --cwd requires a directory path');
+    process.exit(1);
+  }
+  const cwd = cwdFlag
+    ? path.resolve(invokedFrom, cwdFlag)
+    : resolveProjectRoot(invokedFrom);
   const scriptPath = process.argv[1] || path.join(invokedFrom, 'gen-context.js');
 
-  if (cwd !== invokedFrom) {
+  if (cwdFlag) {
+    if (!fs.existsSync(cwd)) {
+      console.error(`[sigmap] --cwd directory does not exist: ${cwd}`);
+      process.exit(1);
+    }
+    if (!fs.statSync(cwd).isDirectory()) {
+      console.error(`[sigmap] --cwd must be a directory, not a file: ${cwd}`);
+      process.exit(1);
+    }
+    console.warn(`[sigmap] --cwd: restricting scan to ${cwd}`);
+  } else if (cwd !== invokedFrom) {
     console.warn(`[sigmap] using project root: ${cwd}`);
   }
 
@@ -8870,6 +8955,11 @@ function main() {
 
   const config = loadConfig(cwd);
 
+  // --cwd restricts scanning: override srcDirs so only the given directory is scanned
+  if (cwdFlag) {
+    config.srcDirs = ['.'];
+  }
+
   // ── --output <file> — parse early so every subsequent block can use it ─────
   // Resolves the custom output path and merges it into config.customOutput.
   // Also persists the resolved relative path to gen-context.config.json so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "5.9.0",
+  "version": "6.0.1",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/adapters/codex.js

@@ -14,19 +14,19 @@
 
 const path = require('path');
 const fs = require('fs');
-const openai = require('./openai');
 
 const name = 'codex';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 /**
- * Format context using the OpenAI adapter format.
+ * Format context for AGENTS.md — clean markdown, no LLM preamble.
  * @param {string} context - Raw signature context string
  * @param {object} [opts]
  * @returns {string}
  */
 function format(context, opts = {}) {
-  return openai.format(context, opts);
+  if (!context || typeof context !== 'string' || !context.trim()) return '';
+  return `# Code signatures\n\n${context}`;
 }
 
 /**

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "5.9.0",
+  "version": "6.0.1",
   "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": "5.9.0",
+  "version": "6.0.1",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/cache/sig-cache.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * Incremental extraction cache (v6.1).
+ *
+ * Stores extracted signatures keyed by file path + mtime so only
+ * modified files are re-extracted on subsequent runs.
+ *
+ * Cache file: .sigmap-cache.json in cwd (gitignored).
+ * Format:
+ *   { sigmapVersion: string, entries: { [absPath]: { mtime: number, sigs: string[] } } }
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const CACHE_FILE = '.sigmap-cache.json';
+
+function cachePath(cwd) {
+  return path.join(cwd, CACHE_FILE);
+}
+
+/**
+ * Load the cache from disk.
+ * Returns a Map<absPath, { mtime: number, sigs: string[] }>.
+ * Returns an empty Map if cache is absent, corrupt, or from a different version.
+ *
+ * @param {string} cwd
+ * @param {string} currentVersion - sigmap VERSION constant
+ * @returns {Map<string, { mtime: number, sigs: string[] }>}
+ */
+function loadCache(cwd, currentVersion) {
+  try {
+    const raw = fs.readFileSync(cachePath(cwd), 'utf8');
+    const data = JSON.parse(raw);
+    // Bust cache on version change to avoid stale sig formats
+    if (data.sigmapVersion !== currentVersion) return new Map();
+    return new Map(Object.entries(data.entries || {}));
+  } catch (_) {
+    return new Map();
+  }
+}
+
+/**
+ * Persist the cache to disk.
+ *
+ * @param {string} cwd
+ * @param {string} currentVersion
+ * @param {Map<string, { mtime: number, sigs: string[] }>} cache
+ */
+function saveCache(cwd, currentVersion, cache) {
+  try {
+    const data = {
+      sigmapVersion: currentVersion,
+      entries: Object.fromEntries(cache),
+    };
+    fs.writeFileSync(cachePath(cwd), JSON.stringify(data), 'utf8');
+  } catch (_) {
+    // Non-fatal: cache save failure just means a full re-extract next run
+  }
+}
+
+/**
+ * Given a list of absolute file paths, return only those whose mtime
+ * differs from the cached value (or that are not cached at all).
+ *
+ * @param {string[]} files - absolute paths
+ * @param {Map<string, { mtime: number, sigs: string[] }>} cache
+ * @returns {{ changed: string[], unchanged: string[] }}
+ */
+function getChangedFiles(files, cache) {
+  const changed = [];
+  const unchanged = [];
+  for (const f of files) {
+    try {
+      const mtime = fs.statSync(f).mtimeMs;
+      const cached = cache.get(f);
+      if (!cached || cached.mtime !== mtime) {
+        changed.push(f);
+      } else {
+        unchanged.push(f);
+      }
+    } catch (_) {
+      changed.push(f); // file unreadable → treat as changed
+    }
+  }
+  return { changed, unchanged };
+}
+
+/**
+ * Update cache entries for a batch of files after fresh extraction.
+ *
+ * @param {Map<string, { mtime: number, sigs: string[] }>} cache
+ * @param {{ file: string, sigs: string[] }[]} extracted - freshly extracted results
+ */
+function updateCacheEntries(cache, extracted) {
+  for (const { file, sigs } of extracted) {
+    try {
+      const mtime = fs.statSync(file).mtimeMs;
+      cache.set(file, { mtime, sigs });
+    } catch (_) {}
+  }
+}
+
+module.exports = { loadCache, saveCache, getChangedFiles, updateCacheEntries };

package/src/extractors/typescript.js

@@ -146,11 +146,14 @@ function extractInterfaceMembers(block) {
   return members.slice(0, 8);
 }
 
+const _CTRL_KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'do', 'try', 'catch', 'finally', 'else', 'return']);
+
 function extractClassMembers(block) {
   const members = [];
-  // Public methods (skip private/protected/_ prefixed)
+  // Public methods (skip private/protected/_ prefixed and control-flow keywords)
   const methodRe = /^\s+(?:public\s+|static\s+|async\s+|override\s+)*(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{;]+)?\s*\{/gm;
   for (const m of block.matchAll(methodRe)) {
+    if (_CTRL_KEYWORDS.has(m[1])) continue;
     if (/^(private|protected|_)/.test(m[1])) continue;
     if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
     const isAsync = m[0].includes('async ') ? 'async ' : '';

package/src/mcp/handlers.js

@@ -446,11 +446,15 @@ function queryContext(args, cwd) {
 
   try {
     const { rank, buildSigIndex, formatRankTable } = require('../retrieval/ranker');
+    const { buildFromCwd } = require('../graph/builder');
     const index = buildSigIndex(cwd);
     if (index.size === 0) return 'No signatures indexed. Run: node gen-context.js';
 
     const topK = Math.min(Math.max(1, parseInt(args.topK, 10) || 10), 25);
-    const results = rank(args.query, index, { topK, cwd });
+    // Build dependency graph for neighbor boost — non-fatal if it fails
+    let graph = null;
+    try { graph = buildFromCwd(cwd); } catch (_) {}
+    const results = rank(args.query, index, { topK, cwd, graph });
     return formatRankTable(results, args.query);
   } catch (err) {
     return `_query_context failed: ${err.message}_`;

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '5.9.0',
+  version: '6.0.1',
   description: 'SigMap MCP server — code signatures on demand',
 };
 

package/src/retrieval/ranker.js

@@ -29,6 +29,7 @@ const DEFAULT_WEIGHTS = {
   prefixMatch: 0.3,      // partial prefix hit (query token ≥ 4 chars)
   pathMatch: 0.8,        // query token appears in the file path
   recencyBoost: 1.5,     // multiplier applied when file is in recencySet
+  graphBoost: 0.4,       // additive bonus for 1-hop import neighbors of matching files
 };
 
 /**
@@ -99,6 +100,7 @@ function scoreFile(filePath, sigs, queryTokens, weights) {
  * @param {Set<string>} [opts.recencySet]         - set of recently-changed file paths
  * @param {object}  [opts.weights]               - override scoring weights
  * @param {string}  [opts.cwd]                   - project root for learned ranking weights
+ * @param {{ forward: Map<string,string[]> }} [opts.graph] - dependency graph for neighbor boost
  * @returns {{ file: string, score: number, sigs: string[], tokens: number }[]}
  */
 function rank(query, sigIndex, opts) {
@@ -110,6 +112,8 @@ function rank(query, sigIndex, opts) {
   const recencySet = (opts && opts.recencySet) || null;
   const weights = (opts && opts.weights) ? Object.assign({}, DEFAULT_WEIGHTS, opts.weights) : DEFAULT_WEIGHTS;
   const learnedWeights = opts && opts.cwd ? loadWeights(opts.cwd) : null;
+  const graph = (opts && opts.graph && opts.graph.forward instanceof Map) ? opts.graph : null;
+  const cwd = (opts && opts.cwd) || null;
 
   const queryTokens = tokenize(query);
   if (queryTokens.length === 0) {
@@ -143,6 +147,30 @@ function rank(query, sigIndex, opts) {
     });
   }
 
+  // Graph neighbor boost: for each file with score > 0, add graphBoost to 1-hop forward
+  // neighbors that are also in the index. sigIndex uses relative paths; graph uses absolute.
+  if (graph && cwd) {
+    const path = require('path');
+    // Build a map: relative path → index position in scored array for O(1) lookup
+    const relToIdx = new Map();
+    for (let i = 0; i < scored.length; i++) {
+      relToIdx.set(scored[i].file, i);
+    }
+    for (const entry of scored) {
+      if (entry.score <= 0) continue;
+      // Resolve relative path to absolute for graph lookup
+      const abs = path.resolve(cwd, entry.file);
+      const neighbors = graph.forward.get(abs) || [];
+      for (const neighborAbs of neighbors) {
+        const neighborRel = path.relative(cwd, neighborAbs).replace(/\\/g, '/');
+        const idx = relToIdx.get(neighborRel);
+        if (idx !== undefined) {
+          scored[idx].score += weights.graphBoost;
+        }
+      }
+    }
+  }
+
   scored.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
   return scored.slice(0, topK);
 }