sigmap 5.8.0 → 6.0.0

package/gen-context.js

@@ -5291,7 +5291,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '5.8.0',
+  version: '6.0.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7009,7 +7009,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '5.8.0';
+const VERSION = '6.0.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -9081,6 +9081,74 @@ function main() {
     process.exit(0);
   }
 
+  // v5.9: `sigmap bench --submit` — format local benchmark history as a shareable community block
+  if (args[0] === 'bench' && args.includes('--submit')) {
+    const versionMeta = (() => {
+      try { return JSON.parse(fs.readFileSync(path.join(__dirname, 'version.json'), 'utf8')); }
+      catch (_) { return {}; }
+    })();
+
+    const histPath = path.join(cwd, '.context', 'benchmark-history.ndjson');
+    let localMetrics = null;
+    if (fs.existsSync(histPath)) {
+      try {
+        const entries = fs.readFileSync(histPath, 'utf8').trim().split('\n')
+          .map((l) => { try { return JSON.parse(l); } catch (_) { return null; } }).filter(Boolean);
+        const ret = [...entries].reverse().find((e) => e.type === 'retrieval');
+        const tok = [...entries].reverse().find((e) => e.type === 'token-reduction');
+        if (ret || tok) {
+          localMetrics = {
+            hitAt5Pct:       ret ? (ret.hitAt5Pct || Math.round((ret.hitAt5 || 0) * 100)) : null,
+            reductionPct:    tok ? (tok.reduction || tok.avgReductionPct || null) : null,
+            runDate:         (ret || tok).ts ? new Date((ret || tok).ts).toISOString().slice(0, 10) : null,
+          };
+        }
+      } catch (_) {}
+    }
+
+    const canonical = versionMeta.metrics || {};
+    const submission = {
+      sigmapVersion:     versionMeta.version || 'unknown',
+      benchmarkId:       versionMeta.benchmark_id || 'unknown',
+      canonicalHitAt5:   canonical.hit_at_5 != null ? Math.round(canonical.hit_at_5 * 1000) / 10 : null,
+      canonicalReduction: canonical.overall_token_reduction_pct || null,
+      local:             localMetrics,
+      submittedAt:       new Date().toISOString().slice(0, 10),
+    };
+
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify(submission, null, 2) + '\n');
+    } else {
+      const bar = '─'.repeat(56);
+      const lines = [
+        bar,
+        ' SigMap Community Benchmark Submission',
+        bar,
+        ` SigMap version : ${submission.sigmapVersion}`,
+        ` Benchmark ID   : ${submission.benchmarkId}`,
+        ` Submitted      : ${submission.submittedAt}`,
+        bar,
+        ' Canonical metrics (official release):',
+        ` hit@5          : ${submission.canonicalHitAt5 != null ? submission.canonicalHitAt5 + '%' : 'n/a'}`,
+        ` token reduction: ${submission.canonicalReduction != null ? submission.canonicalReduction + '%' : 'n/a'}`,
+      ];
+      if (localMetrics) {
+        lines.push(bar, ' Local run metrics (this repo):');
+        if (localMetrics.hitAt5Pct != null)    lines.push(` hit@5          : ${localMetrics.hitAt5Pct}%`);
+        if (localMetrics.reductionPct != null)  lines.push(` token reduction: ${localMetrics.reductionPct}%`);
+        if (localMetrics.runDate)               lines.push(` run date       : ${localMetrics.runDate}`);
+      } else {
+        lines.push(bar, ' Local run metrics: none yet — run node scripts/run-retrieval-benchmark.mjs');
+      }
+      lines.push(bar);
+      lines.push(' Paste the block above into a GitHub Discussion to share your results.');
+      lines.push(' https://github.com/manojmallick/sigmap/discussions');
+      lines.push(bar);
+      console.log(lines.join('\n'));
+    }
+    process.exit(0);
+  }
+
   // v5.2: `sigmap learn` — manual learning controls for ranking
   if (args[0] === 'learn') {
     const doReset = args.includes('--reset');

package/package.json

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

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "5.8.0",
+  "version": "6.0.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": "5.8.0",
+  "version": "6.0.0",
   "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/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.8.0',
+  version: '6.0.0',
   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);
 }