sigmap 6.5.2 → 6.6.1

package/AGENTS.md

@@ -56,15 +56,11 @@ Use this marker block for all appendable context files:
 | To query by topic | `sigmap --query "<topic>"` |
 
 Always run `sigmap ask` or `sigmap --query` before searching for files relevant to a task.
-## changes (last 5 commits — 2 days ago)
+## changes (last 5 commits — 8 minutes ago)
 ```
-src/config/loader.js                          +_legacyDetectAutoSrcDirs  ~detectAutoSrcDirs
-src/discovery/source-root-resolver.js         +resolveSourceRoots  +_detectMonorepo  +_enumerateCandidates  +_applySpecialRules
-src/discovery/language-detector.js            +detectLanguages  +_walkDepth
-src/discovery/source-root-scorer.js           +getRecentlyChangedDirs  +scoreCandidate  +_countSourceFiles
-src/discovery/framework-detector.js           +detectFrameworks  +_readDeps  +_readFile  +_existsAnywhere
-src/discovery/sigmapignore.js                 +loadIgnorePatterns  +matchesIgnorePattern
-src/retrieval/ranker.js                       +_computePenalty  ~scoreFile  ~rank  ~buildSigIndex
+src/plan/planner.js                           +createPlan
+src/retrieval/ranker.js                       +_computePenalty  +_computeHubs  +_isHub  ~scoreFile
+src/session/memory.js                         +sessionPath  +loadSession  +saveSession  +mergeSessionContext
 ```
 
 ## packages
@@ -185,27 +181,6 @@ function write(context, cwd, opts = {})
 
 ## src
 
-### src/extractors/javascript.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractClassMembers(block, returnHints)
-function buildReturnHints(src)
-function normalizeType(type)
-function formatReturnHint(type)
-function normalizeParams(params)
-```
-
-### src/extractors/kotlin.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-```
-
 ### src/extractors/php.js
 ```
 module.exports = { extract }
@@ -668,6 +643,21 @@ function loadIgnorePatterns(cwd)
 function matchesIgnorePattern(dirName, patterns)
 ```
 
+### src/plan/planner.js
+```
+module.exports = { createPlan }
+function createPlan(goal, cwd, config)
+```
+
+### src/mcp/server.js
+```
+module.exports = { start }
+function respond(id, result)
+function respondError(id, code, message)
+function dispatch(msg, cwd)
+function start(cwd)
+```
+
 ### src/retrieval/ranker.js
 ```
 module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent }
@@ -683,11 +673,12 @@ function formatRankJSON(results, query) → object
 function detectIntent(query)
 ```
 
-### src/mcp/server.js
+### src/session/memory.js
 ```
-module.exports = { start }
-function respond(id, result)
-function respondError(id, code, message)
-function dispatch(msg, cwd)
-function start(cwd)
+module.exports = { loadSession, saveSession, mergeSessionContext, clearSession }
+function sessionPath(cwd)
+function loadSession(cwd)
+function saveSession(cwd, { intent, topFiles, query })
+function mergeSessionContext(scores, session, currentIntent)
+function clearSession(cwd)
 ```

package/CHANGELOG.md

@@ -10,6 +10,24 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.6.1] — 2026-04-27
+
+### Added
+
+- **JVM project structure support** — Added auto-detection of Java, Kotlin, and Scala project directories. `srcDirs` now includes `src/main/java`, `src/main/kotlin`, `src/main/scala`, `app/src/main/java`, `app/src/main/kotlin`, `src/test/java`, and `src/test/kotlin` for out-of-the-box support of JVM-based projects.
+
+---
+
+## [6.6.0] — 2026-04-27
+
+### Added
+
+- **Session memory** — Carry context across follow-up queries within a coding session. New `src/session/memory.js` module manages session state with 4-hour TTL. Previous session's top-5 files get +0.2 score boost in next query; boost reduced to +0.1 if intent differs (topic-switch guard).
+- **`sigmap ask --followup`** — Reuse previous session's context when making follow-up queries. Session automatically saved after each `ask` command for seamless context carry-forward.
+- **`sigmap plan "<goal>"`** — Analyze change impact and plan modifications. Returns files grouped by confidence (inspect-first vs likely-to-change), impact radius, and affected tests. Supports `--json` output for agent integration.
+
+---
+
 ## [6.5.2] — 2026-04-27
 
 ### Added

package/gen-context.js

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.5.2',
+  version: '6.6.1',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -6211,6 +6211,124 @@ __factories["./src/tracking/logger"] = function(module, exports) {
   
 };
 
+// ── ./src/session/memory ──
+__factories["./src/session/memory"] = function(module, exports) {
+  'use strict';
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const SESSION_TTL_MS = 4 * 60 * 60 * 1000;   // 4 hours — one coding session
+
+  function sessionPath(cwd) {
+    return path.join(cwd, '.context', 'session.json');
+  }
+
+  function loadSession(cwd) {
+    const p = sessionPath(cwd);
+    if (!fs.existsSync(p)) return null;
+    try {
+      const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (Date.now() - raw.ts > SESSION_TTL_MS) return null;  // expired
+      return raw;
+    } catch {
+      return null;
+    }
+  }
+
+  function saveSession(cwd, { intent, topFiles, query }) {
+    const p = sessionPath(cwd);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({
+      ts: Date.now(),
+      intent,
+      topFiles,   // [{ file, score }] — top 5 from last ask
+      lastQuery: query,
+    }));
+  }
+
+  function mergeSessionContext(scores, session, currentIntent) {
+    if (!session) return scores;
+
+    const boostAmount = session.intent === currentIntent ? 0.20 : 0.10;
+    const sessionBoost = new Map(session.topFiles.map(f => [f.file, boostAmount]));
+
+    return scores.map(r => ({
+      ...r,
+      score: r.score + (sessionBoost.get(r.file) || 0),
+    }));
+  }
+
+  function clearSession(cwd) {
+    const p = sessionPath(cwd);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+
+  module.exports = { loadSession, saveSession, mergeSessionContext, clearSession };
+};
+
+// ── ./src/plan/planner ──
+__factories["./src/plan/planner"] = function(module, exports) {
+  'use strict';
+
+  const { buildFromCwd } = __require('./src/graph/builder');
+  const { getImpact } = __require('./src/graph/impact');
+  const { buildSigIndex, rank, detectIntent } = __require('./src/retrieval/ranker');
+  const { buildTestIndex, isTested } = __require('./src/extractors/coverage');
+
+  function createPlan(goal, cwd, config) {
+    const intent = detectIntent(goal);
+    const sigIndex = buildSigIndex(cwd);
+    if (sigIndex.size === 0) {
+      return { error: 'no context found' };
+    }
+
+    const ranked = rank(goal, sigIndex, { topK: 15, cwd });
+    const highConf = ranked.filter(r => r.confidence === 'high').slice(0, 5);
+    const medConf = ranked.filter(r => r.confidence === 'medium').slice(0, 5);
+
+    let impact = null;
+    if (highConf.length > 0) {
+      const entryFile = highConf[0].file;
+      try {
+        const graph = buildFromCwd(cwd);
+        impact = getImpact(entryFile, graph, { maxDepth: 3, cwd });
+      } catch (_) {
+        // Graph build failed, continue without impact
+      }
+    }
+
+    let testedFiles = [];
+    try {
+      const testIndex = buildTestIndex(cwd, config.testDirs || ['test', 'tests', '__tests__', 'spec']);
+      testedFiles = highConf.filter(r => {
+        const sigs = r.sigs || [];
+        const fnNames = sigs.map(s => {
+          const m = s.match(/(?:function|def|fn)\s+(\w+)/);
+          return m ? m[1] : null;
+        }).filter(Boolean);
+        return fnNames.some(fn => isTested(fn, testIndex));
+      });
+    } catch (_) {
+      // Coverage index failed, continue without test info
+    }
+
+    return {
+      goal,
+      intent,
+      inspectFirst: highConf.map(r => r.file),
+      likelyToChange: medConf.map(r => r.file),
+      impactRadius: impact ? {
+        direct: [...(impact.direct || [])],
+        transitive: [...(impact.transitive || [])],
+      } : null,
+      testsAffected: testedFiles.map(r => r.file),
+    };
+  }
+
+  module.exports = { createPlan };
+};
+
 // ── ./src/retrieval/tokenizer ──
 __factories["./src/retrieval/tokenizer"] = function(module, exports) {
   'use strict';
@@ -7737,7 +7855,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.5.2';
+const VERSION = '6.6.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -9791,6 +9909,7 @@ function main() {
 
     const { detectIntent, buildSigIndex, rank } = requireSourceOrBundled('./src/retrieval/ranker');
     const { coverageScore } = requireSourceOrBundled('./src/analysis/coverage-score');
+    const { loadSession, saveSession, mergeSessionContext } = requireSourceOrBundled('./src/session/memory');
 
     const intent = detectIntent(query);
     const intentWeights = getIntentWeights(intent);
@@ -9801,7 +9920,21 @@ function main() {
       process.exit(1);
     }
 
-    const ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
+    let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
+
+    // v6.8: --followup support — carry session context forward
+    const isFollowup = args.includes('--followup');
+    const session = isFollowup ? loadSession(cwd) : null;
+    if (session) {
+      ranked = mergeSessionContext(ranked, session, intent);
+      ranked.sort((a, b) => b.score - a.score);
+      if (!args.includes('--json')) {
+        process.stderr.write(`[sigmap] ♻  followup — carrying context from: "${session.lastQuery.slice(0, 60)}"\n`);
+      }
+    }
+
+    // v6.8: Save session for future --followup calls
+    saveSession(cwd, { intent, topFiles: ranked.slice(0, 5).map(r => ({ file: r.file, score: r.score })), query });
     const miniCtx = buildMiniContext(ranked, cwd);
     const outPath = path.join(cwd, '.context', 'query-context.md');
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
@@ -9947,6 +10080,77 @@ function main() {
     process.exit(0);
   }
 
+  // v6.8: `sigmap plan "<goal>"` — analyze what files need changes and impact radius
+  if (args[0] === 'plan') {
+    const goal = args[1];
+    if (!goal || goal.startsWith('--')) {
+      console.error('[sigmap] Usage: sigmap plan "<goal>"');
+      console.error('  Example: sigmap plan "add rate limiting to the API"');
+      process.exit(1);
+    }
+
+    const { detectIntent, buildSigIndex, rank } = requireSourceOrBundled('./src/retrieval/ranker');
+
+    const intent = detectIntent(goal);
+    const intentWeights = getIntentWeights(intent);
+
+    const sigIndex = buildSigIndex(cwd);
+    if (sigIndex.size === 0) {
+      console.error('[sigmap] no context file found. Run: sigmap (to generate first)');
+      process.exit(1);
+    }
+
+    const ranked = rank(goal, sigIndex, { topK: 15, weights: intentWeights, cwd });
+
+    // Separate into confidence levels
+    const highConf = ranked.filter(r => r.confidence === 'high').slice(0, 5);
+    const medConf = ranked.filter(r => r.confidence === 'medium').slice(0, 5);
+
+    // Compute impact radius (simplified — no graph for now)
+    let impact = null;
+
+    // Identify likely-affected tests (simplified — checks for .test. or .spec. in filename)
+    const testedFiles = highConf.filter(r => /\.(test|spec)\.(js|ts|py)$|_test\.(js|ts|py)$/.test(r.file));
+
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify({
+        goal, intent,
+        inspectFirst: highConf.map(r => r.file),
+        likelyToChange: medConf.map(r => r.file),
+        impactRadius: impact,
+        testsAffected: testedFiles.map(r => r.file),
+      }, null, 2) + '\n');
+    } else {
+      const bar = '─'.repeat(50);
+      console.log(bar);
+      console.log(` sigmap plan  "${goal}"`);
+      console.log(` Intent     : ${intent}`);
+      console.log(bar);
+      console.log('');
+      console.log(' Inspect first (highest relevance):');
+      if (highConf.length === 0) {
+        console.log('   (no files found)');
+      } else {
+        highConf.forEach((r, i) => console.log(`   ${i + 1}. ${path.relative(cwd, r.file)}`));
+      }
+      console.log('');
+      console.log(' Likely to change:');
+      if (medConf.length === 0) {
+        console.log('   (no files found)');
+      } else {
+        medConf.forEach((r, i) => console.log(`   ${i + 1}. ${path.relative(cwd, r.file)}`));
+      }
+      if (testedFiles.length > 0) {
+        console.log('');
+        console.log(' Tests to run after change:');
+        testedFiles.forEach(r => console.log(`   • ${path.relative(cwd, r.file)}`));
+      }
+      console.log('');
+      console.log(bar);
+    }
+    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 = (() => {

package/package.json

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

package/src/config/defaults.js

@@ -26,6 +26,10 @@ const DEFAULTS = {
     'pages', 'components', 'hooks', 'routes', 'controllers',
     'models', 'views', 'resources', 'config', 'db',
     'projects', 'apps', 'libs', 'instance', 'blueprints',
+    // JVM project structures (Java, Kotlin, Scala)
+    'src/main/java', 'src/main/kotlin', 'src/main/scala',
+    'app/src/main/java', 'app/src/main/kotlin',
+    'src/test/java', 'src/test/kotlin',
   ],
 
   // Directory/file names to exclude entirely

package/src/mcp/server.js

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

package/src/plan/planner.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { buildFromCwd } = require('../graph/builder');
+const { getImpact } = require('../graph/impact');
+const { buildSigIndex, rank, detectIntent } = require('../retrieval/ranker');
+const { buildTestIndex, isTested } = require('../extractors/coverage');
+
+module.exports = { createPlan };
+
+function createPlan(goal, cwd, config) {
+  // Step 1: Detect intent and rank files for the goal
+  const intent = detectIntent(goal);
+  const sigIndex = buildSigIndex(cwd);
+  if (sigIndex.size === 0) {
+    return { error: 'no context found' };
+  }
+
+  const ranked = rank(goal, sigIndex, { topK: 15, cwd });
+
+  // Step 2: Separate into confidence levels
+  const highConf = ranked.filter(r => r.confidence === 'high').slice(0, 5);
+  const medConf = ranked.filter(r => r.confidence === 'medium').slice(0, 5);
+
+  // Step 3: Compute impact radius for highest-confidence file
+  let impact = null;
+  if (highConf.length > 0) {
+    const entryFile = highConf[0].file;
+    try {
+      const graph = buildFromCwd(cwd);
+      impact = getImpact(entryFile, graph, { maxDepth: 3, cwd });
+    } catch (_) {
+      // Graph build failed, continue without impact
+    }
+  }
+
+  // Step 4: Identify likely-affected tests
+  let testedFiles = [];
+  try {
+    const testIndex = buildTestIndex(cwd, config.testDirs || ['test', 'tests', '__tests__', 'spec']);
+    testedFiles = highConf.filter(r => {
+      const sigs = r.sigs || [];
+      const fnNames = sigs.map(s => {
+        const m = s.match(/(?:function|def|fn)\s+(\w+)/);
+        return m ? m[1] : null;
+      }).filter(Boolean);
+      return fnNames.some(fn => isTested(fn, testIndex));
+    });
+  } catch (_) {
+    // Coverage index failed, continue without test info
+  }
+
+  return {
+    goal,
+    intent,
+    inspectFirst: highConf.map(r => r.file),
+    likelyToChange: medConf.map(r => r.file),
+    impactRadius: impact ? {
+      direct: [...(impact.direct || [])],
+      transitive: [...(impact.transitive || [])],
+    } : null,
+    testsAffected: testedFiles.map(r => r.file),
+  };
+}

package/src/session/memory.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = { loadSession, saveSession, mergeSessionContext, clearSession };
+
+const SESSION_TTL_MS = 4 * 60 * 60 * 1000;   // 4 hours — one coding session
+
+function sessionPath(cwd) {
+  return path.join(cwd, '.context', 'session.json');
+}
+
+function loadSession(cwd) {
+  const p = sessionPath(cwd);
+  if (!fs.existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (Date.now() - raw.ts > SESSION_TTL_MS) return null;  // expired
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+function saveSession(cwd, { intent, topFiles, query }) {
+  const p = sessionPath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({
+    ts: Date.now(),
+    intent,
+    topFiles,   // [{ file, score }] — top 5 from last ask
+    lastQuery: query,
+  }));
+}
+
+// Merge session context as additional ranking signal:
+// any file that appeared in the previous session's top-5 gets a +0.2 boost
+// Reduce to +0.1 if the intent has changed (topic switch guard)
+function mergeSessionContext(scores, session, currentIntent) {
+  if (!session) return scores;
+
+  const boostAmount = session.intent === currentIntent ? 0.20 : 0.10;
+  const sessionBoost = new Map(session.topFiles.map(f => [f.file, boostAmount]));
+
+  return scores.map(r => ({
+    ...r,
+    // Additive boost — cannot reduce a score
+    score: r.score + (sessionBoost.get(r.file) || 0),
+  }));
+}
+
+function clearSession(cwd) {
+  const p = sessionPath(cwd);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}