sigmap 6.10.1 → 6.10.2

package/CHANGELOG.md

@@ -10,6 +10,21 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.10.2] — 2026-05-11
+
+### Added
+
+- **Open-source agents documentation** — Comprehensive integration guides for OpenCode, Aider, OpenHands, and Cline with setup examples and context injection patterns. Clear separation of coding agents from inference backends.
+- **Local LLM workflows guide** — Complete setup guide for Ollama, llama.cpp, vLLM with model recommendations, performance tuning, and benchmarking. Emphasizes model-agnostic nature: no API costs, full privacy, offline capability.
+- **Integrations sidebar** — New VitePress navigation section highlighting open-source agents, local LLMs, MCP server, and Repomix integration.
+
+### Changed
+
+- **README model-agnostic messaging** — Updated to clarify support for cloud LLMs, open-source agents, and local models with full privacy. Removed proprietary-focused language.
+- **Quick-start guide** — Added links to new agent and local-LLM guides in "Next steps" section.
+
+---
+
 ## [6.10.1] — 2026-05-10
 
 ### Added

package/README.md

@@ -36,7 +36,12 @@ Zero config. Zero dependencies. Under 10 seconds.
 
 SigMap extracts function and class signatures from your codebase and feeds the right files — not the whole repo — to your AI.
 
-Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
+**Model-agnostic.** Works with:
+- **Cloud LLMs:** Claude, GPT-4, Copilot, Gemini
+- **Open-source agents:** OpenCode, Aider, OpenHands, Cline
+- **Local LLMs:** Ollama, llama.cpp, vLLM (no API keys, full privacy)
+- **Any editor:** VS Code, Cursor, Windsurf, Neovim, JetBrains
+- **Any model:** Use what you want, no vendor lock-in
 
 ---
 
@@ -46,7 +51,9 @@ Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
 - **40–98% token reduction** — 2K–4K tokens instead of 80K+
 - **52.2% task success rate** — up from 10% without context
 - **1.68 prompts per task** — down from 2.84
-- **Works with any LLM** — no API key, no cloud, no accounts
+- **No vendor lock-in** — works with any AI assistant or local LLM
+- **No API costs** — use local models (Ollama, llama.cpp, vLLM) with zero token fees
+- **Full privacy** — keep your code and context on your machine
 - **Zero npm dependencies** — `npx sigmap` on any machine
 
 ---
@@ -147,20 +154,26 @@ volta install sigmap
 
 | Adapter | Output file | Used by |
 |---|---|---|
-| `copilot` | `.github/copilot-instructions.md` | GitHub Copilot |
+| `copilot` | `.github/copilot-instructions.md` | GitHub Copilot, OpenCode |
 | `claude` | `CLAUDE.md` | Claude / Claude Code |
-| `cursor` | `.cursorrules` | Cursor |
+| `cursor` | `.cursorrules` | Cursor, Cline |
 | `windsurf` | `.windsurfrules` | Windsurf |
-| `openai` | `.github/openai-context.md` | OpenAI models |
+| `openai` | `.github/openai-context.md` | OpenAI API, Aider, local Ollama/llama.cpp |
 | `gemini` | `.github/gemini-context.md` | Google Gemini |
-| `codex` | `AGENTS.md` | OpenAI Codex · OpenCode |
+| `codex` | `AGENTS.md` | OpenAI Codex (legacy) |
 
 ```bash
-sigmap --adapter copilot   # default
-sigmap --adapter claude
-sigmap --adapter cursor
+sigmap --adapter copilot   # default — works with Copilot, OpenCode
+sigmap --adapter openai    # works with Ollama, llama.cpp, vLLM, Aider
+sigmap --adapter claude    # works with Claude Code
 ```
 
+**Open-source agents & local LLMs:**
+
+Use SigMap with open-source tools and fully self-hosted setups:
+- **[Open-source agents guide →](https://manojmallick.github.io/sigmap/guide/agents)** — OpenCode, Aider, OpenHands, Cline
+- **[Local LLMs guide →](https://manojmallick.github.io/sigmap/guide/local-llms)** — Ollama, llama.cpp, vLLM (no API keys, full privacy)
+
 **IDE extensions:**
 
 | IDE | Install | Source | Features |

package/gen-context.js

@@ -2980,6 +2980,148 @@ __factories["./src/extractors/prdiff"] = function(module, exports) {
 
 };
 
+// ── ./src/extractors/r ──
+__factories["./src/extractors/r"] = function(module, exports) {
+
+  'use strict';
+
+  /**
+   * Extract signatures from R source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+
+    // Strip line comments. R uses # comments. Roxygen2 (#') comments are
+    // stripped along with regular ones; Phase 2 may parse them.
+    const stripped = src.replace(/#.*$/gm, '');
+
+    // Function definitions:
+    //   name <- function(args) { ... }
+    //   name = function(args) { ... }
+    //   name <<- function(args) { ... }
+    // Args may span multiple lines and contain default values, so we need to
+    // match a balanced parenthesis group rather than a single line.
+    const funcRe = /^(?:[ \t]*)([\w.]+)\s*(?:<<-|<-|=)\s*function\s*\(/gm;
+    let m;
+    while ((m = funcRe.exec(stripped)) !== null) {
+      const name = m[1];
+      if (name.startsWith('.')) continue; // private convention
+      const argsStart = funcRe.lastIndex;
+      const args = readBalancedParens(stripped, argsStart - 1);
+      if (args === null) continue;
+      sigs.push(`${name} <- function(${normalizeParams(args)})`);
+    }
+
+    // S4 setMethod / setGeneric:
+    //   setGeneric("name", function(args) standardGeneric("name"))
+    //   setMethod("name", "ClassName", function(args) { ... })
+    for (const sm of stripped.matchAll(/^[ \t]*setGeneric\s*\(\s*["']([\w.]+)["']/gm)) {
+      sigs.push(`setGeneric("${sm[1]}")`);
+    }
+    for (const sm of stripped.matchAll(/^[ \t]*setMethod\s*\(\s*["']([\w.]+)["']\s*,\s*["']([\w.]+)["']/gm)) {
+      sigs.push(`setMethod("${sm[1]}", "${sm[2]}")`);
+    }
+
+    // S4 class definitions:
+    //   setClass("Name", representation(...), ...)
+    for (const sm of stripped.matchAll(/^[ \t]*setClass\s*\(\s*["']([\w.]+)["']/gm)) {
+      sigs.push(`setClass("${sm[1]}")`);
+    }
+
+    return sigs.slice(0, 30);
+  }
+
+  /**
+   * Read a parenthesis-balanced substring starting at the position of the
+   * opening '(' character, returning the inner content (without the outer
+   * parens). Returns null if no matching close paren is found within `cap`
+   * characters, which guards against runaway scans on malformed input.
+   */
+  function readBalancedParens(src, openIdx, cap = 4096) {
+    if (src[openIdx] !== '(') return null;
+    let depth = 1;
+    let i = openIdx + 1;
+    const end = Math.min(src.length, openIdx + cap);
+    let inString = null; // null | '"' | "'"
+    while (i < end) {
+      const ch = src[i];
+      if (inString) {
+        if (ch === '\\') { i += 2; continue; }
+        if (ch === inString) inString = null;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") { inString = ch; i++; continue; }
+      if (ch === '(') depth++;
+      else if (ch === ')') {
+        depth--;
+        if (depth === 0) return src.slice(openIdx + 1, i);
+      }
+      i++;
+    }
+    return null;
+  }
+
+  /**
+   * Compress whitespace inside a parameter list, collapse multi-line default
+   * expressions onto a single line, and trim. The goal is one-line readable
+   * signatures, not a faithful AST.
+   *
+   * String literals are protected so that commas/equals inside default values
+   * like sep = "," don't get respaced.
+   */
+  function normalizeParams(raw) {
+    const tokens = [];
+    let buf = '';
+    let inString = null;
+    for (let i = 0; i < raw.length; i++) {
+      const ch = raw[i];
+      if (inString) {
+        buf += ch;
+        if (ch === '\\' && i + 1 < raw.length) { buf += raw[i + 1]; i++; continue; }
+        if (ch === inString) inString = null;
+        continue;
+      }
+      if (ch === '"' || ch === "'") { inString = ch; buf += ch; continue; }
+      buf += ch;
+    }
+    // Now buf === raw with strings preserved character-for-character.
+    // Walk again: collapse non-string runs of whitespace, normalize ', ' and ' = '.
+    let out = '';
+    inString = null;
+    for (let i = 0; i < buf.length; i++) {
+      const ch = buf[i];
+      if (inString) {
+        out += ch;
+        if (ch === '\\' && i + 1 < buf.length) { out += buf[i + 1]; i++; continue; }
+        if (ch === inString) inString = null;
+        continue;
+      }
+      if (ch === '"' || ch === "'") { inString = ch; out += ch; continue; }
+      if (/\s/.test(ch)) {
+        if (out.length && !/\s$/.test(out)) out += ' ';
+        continue;
+      }
+      if (ch === ',') {
+        out = out.replace(/\s+$/, '') + ', ';
+        continue;
+      }
+      if (ch === '=') {
+        out = out.replace(/\s+$/, '') + ' = ';
+        continue;
+      }
+      out += ch;
+    }
+    return out.trim();
+  }
+
+  module.exports = { extract };
+
+};
+
 // ── ./src/format/cache ──
 __factories["./src/format/cache"] = function(module, exports) {
   
@@ -5387,7 +5529,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.10.1',
+  version: '6.10.2',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -8014,7 +8156,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.10.1';
+const VERSION = '6.10.2';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {

package/package.json

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

package/packages/adapters/index.js

@@ -11,14 +11,16 @@
 
 const path = require('path');
 
-const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
+// Third-party adapters: 'willow' writes atoms to a Willow MCP knowledge store
+// instead of a flat file (see willow.js for configuration).
+const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex', 'willow'];
 
 // Lazy-load adapters so unused ones don't pay any require() cost
 const _cache = {};
 
 /**
  * Load and return an adapter module by name.
- * @param {string} name - Adapter name (copilot|claude|cursor|windsurf|openai|gemini|codex)
+ * @param {string} name - Adapter name (copilot|claude|cursor|windsurf|openai|gemini|codex|willow)
  * @returns {{ name: string, format: Function, outputPath: Function }|null}
  */
 function getAdapter(name) {

package/packages/adapters/willow.js

@@ -0,0 +1,200 @@
+'use strict';
+
+/**
+ * Willow adapter — writes SigMap context to Willow MCP knowledge store.
+ *
+ * Instead of writing a flat .willow-context.md file, this adapter sends
+ * signature atoms to a Willow MCP server (https://github.com/rudi193-cmd/willow-1.9)
+ * via HTTP POST. Each indexed file becomes a searchable knowledge atom.
+ *
+ * Contract:
+ *   format(context, opts?) → string   (markdown for display/debug)
+ *   outputPath(cwd)        → string   (placeholder — no file written)
+ *   write(context, cwd, opts?) → Promise<void> (POSTs to Willow MCP, must await)
+ *
+ * Configuration (env vars or opts):
+ *   WILLOW_MCP_URL   — MCP server base URL (default: http://localhost:8000)
+ *   WILLOW_AGENT     — agent namespace (default: sigmap)
+ *   WILLOW_TIMEOUT   — fetch timeout in ms (default: 30000)
+ *   WILLOW_MAX_ATOM_SIZE — max atom size in bytes (default: 100000)
+ *   WILLOW_RETRIES   — max retry attempts for transient failures (default: 3)
+ */
+
+const crypto = require('crypto');
+const name = 'willow';
+const DEFAULT_MCP_URL = 'http://localhost:8000';
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_ATOM_SIZE = 100000;
+const DEFAULT_RETRIES = 3;
+
+/**
+ * Format SigMap context as markdown for display or debug.
+ * @param {string} context - Raw SigMap context string
+ * @param {object} [opts] - Unused; reserved for future options
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const ts = new Date().toISOString();
+  return `<!-- SigMap Willow context — ${ts} -->\n\n${context}`;
+}
+
+/**
+ * Return the placeholder output path (no file is written by this adapter).
+ * @param {string} cwd - Working directory
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return '.willow-context.md';
+}
+
+/**
+ * Generate a cryptographically strong ID for an atom.
+ * Uses SHA256 hash of the filepath to ensure uniqueness and prevent collisions.
+ * @param {string} filepath - File path to hash
+ * @returns {string} - sigmap-{32-char-hex}
+ */
+function generateAtomId(filepath) {
+  const hash = crypto
+    .createHash('sha256')
+    .update(filepath)
+    .digest('hex');
+  return `sigmap-${hash}`;
+}
+
+/**
+ * Fetch with timeout support.
+ * @param {string} url - URL to fetch
+ * @param {object} opts - Fetch options
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<Response>}
+ */
+async function fetchWithTimeout(url, opts, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * POST an atom to Willow with exponential backoff retry.
+ * @param {object} atom - Atom to ingest
+ * @param {string} mcpUrl - MCP server URL
+ * @param {number} timeoutMs - Fetch timeout
+ * @param {number} maxRetries - Max retry attempts
+ * @returns {Promise<boolean>} - True if succeeded, false if all retries exhausted
+ */
+async function postAtomWithRetry(atom, mcpUrl, timeoutMs, maxRetries) {
+  let lastErr;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const resp = await fetchWithTimeout(
+        `${mcpUrl}/tools/call`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            name: 'willow_knowledge_ingest',
+            arguments: {
+              app_id: atom.agent,
+              title: atom.title,
+              summary: atom.summary,
+              domain: atom.domain,
+              source_type: atom.source_type,
+              category: 'code',
+              record_id: atom.id,
+            },
+          }),
+        },
+        timeoutMs,
+      );
+
+      if (resp.ok) {
+        return true;
+      }
+
+      if (resp.status >= 500) {
+        lastErr = new Error(`HTTP ${resp.status}`);
+        if (attempt < maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt)));
+          continue;
+        }
+      } else {
+        process.stderr.write(`[willow-adapter] ${atom.id}: HTTP ${resp.status} (not retryable)\n`);
+        return false;
+      }
+    } catch (err) {
+      lastErr = err;
+      if (attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt)));
+        continue;
+      }
+    }
+  }
+
+  process.stderr.write(
+    `[willow-adapter] ${atom.id}: failed after ${maxRetries} attempts: ${lastErr?.message || 'unknown'}\n`,
+  );
+  return false;
+}
+
+/**
+ * POST each file section from SigMap context to the Willow MCP knowledge store.
+ * Each `## filepath` section becomes one searchable knowledge atom.
+ * Failures are per-atom and logged to stderr; function never throws.
+ * IMPORTANT: This is async — caller MUST await write() before process exit.
+ *
+ * @param {string} context - Raw SigMap context string
+ * @param {string} cwd - Working directory (used as project label)
+ * @param {object} [opts] - Optional overrides: { mcpUrl, agent, timeoutMs, maxAtomSize, maxRetries }
+ * @returns {Promise<void>}
+ */
+async function write(context, cwd, opts = {}) {
+  if (!context) return;
+
+  const mcpUrl = opts.mcpUrl || process.env.WILLOW_MCP_URL || DEFAULT_MCP_URL;
+  const agent = opts.agent || process.env.WILLOW_AGENT || 'sigmap';
+  const timeoutMs = opts.timeoutMs || parseInt(process.env.WILLOW_TIMEOUT, 10) || DEFAULT_TIMEOUT_MS;
+  const maxAtomSize = opts.maxAtomSize || parseInt(process.env.WILLOW_MAX_ATOM_SIZE, 10) || DEFAULT_MAX_ATOM_SIZE;
+  const maxRetries = opts.maxRetries || parseInt(process.env.WILLOW_RETRIES, 10) || DEFAULT_RETRIES;
+
+  const sections = context.split(/\n(?=##\s)/);
+  const atoms = sections
+    .map((section) => {
+      const titleMatch = section.match(/^##\s+(.+)/);
+      if (!titleMatch) return null;
+
+      const title = titleMatch[1].trim();
+      const contentSize = section.length;
+
+      if (contentSize > maxAtomSize) {
+        process.stderr.write(`[willow-adapter] ${title}: oversized (${contentSize} > ${maxAtomSize} bytes)\n`);
+        return null;
+      }
+
+      return {
+        id: generateAtomId(title),
+        title,
+        summary: `${title} (${contentSize} bytes)`,
+        content: section.trim(),
+        domain: 'code',
+        source_type: 'sigmap',
+        agent,
+        project: cwd ? require('path').basename(cwd) : 'unknown',
+      };
+    })
+    .filter(Boolean);
+
+  if (!atoms.length) return;
+
+  await Promise.all(
+    atoms.map((atom) => postAtomWithRetry(atom, mcpUrl, timeoutMs, maxRetries).catch((err) => {
+      process.stderr.write(`[willow-adapter] ${atom.id}: unexpected error: ${err.message}\n`);
+    })),
+  );
+}
+
+module.exports = { name, format, outputPath, write };

package/packages/cli/package.json

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

package/packages/core/index.js

@@ -29,6 +29,7 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala',   '.sc': 'scala',
+  '.gd': 'gdscript',
   '.r': 'r',           '.R': 'r',
   '.vue': 'vue',
   '.svelte': 'svelte',

package/packages/core/package.json

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

package/src/discovery/language-detector.js

@@ -19,6 +19,7 @@ const EXT_TO_LANG = {
   '.java': 'java', '.kt': 'kotlin', '.cs': 'csharp', '.cpp': 'cpp',
   '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.swift': 'swift',
   '.dart': 'dart', '.scala': 'scala', '.php': 'php',
+  '.gd': 'gdscript',
   '.r': 'r', '.R': 'r',
 };
 

package/src/eval/analyzer.js

@@ -29,6 +29,7 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala',   '.sc': 'scala',
+  '.gd': 'gdscript',
   '.r': 'r',           '.R': 'r',
   '.vue': 'vue',
   '.svelte': 'svelte',

package/src/extractors/gdscript.js

@@ -0,0 +1,131 @@
+'use strict';
+
+/**
+ * Extract signatures from Godot GDScript source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src.replace(/#.*$/gm, '');
+
+  let className = null;
+  let baseName = null;
+  const addedClasses = new Set();
+
+  const cm = stripped.match(/^class_name\s+(\w+)(?:\s+extends\s+([\w.]+))?/m);
+  if (cm) {
+    className = cm[1];
+    if (cm[2]) baseName = cm[2];
+  }
+  if (!baseName) {
+    const em = stripped.match(/^extends\s+([\w."/]+)/m);
+    if (em) baseName = em[1];
+  }
+
+  if (className) {
+    sigs.push(baseName ? `class ${className}(${baseName})` : `class ${className}`);
+    addedClasses.add(className);
+  } else if (baseName) {
+    sigs.push(`extends ${baseName}`);
+  }
+
+  const indent = (className || baseName) ? '  ' : '';
+
+  for (const m of stripped.matchAll(/^signal\s+(\w+)(?:\s*\(([^)]*)\))?/gm)) {
+    sigs.push(`${indent}signal ${m[1]}(${normalizeParams(m[2] || '')})`);
+  }
+
+  for (const m of stripped.matchAll(/^enum\s+(\w+)\s*\{([^}]*)\}/gm)) {
+    const members = m[2]
+      .split(',')
+      .map((s) => s.trim().split(/\s*=/)[0].trim())
+      .filter(Boolean);
+    sigs.push(`${indent}enum ${m[1]} { ${members.slice(0, 6).join(', ')} }`);
+  }
+
+  let constCount = 0;
+  for (const m of stripped.matchAll(/^const\s+(\w+)(?:\s*:\s*[^=\n]+)?\s*:?=\s*([^\n]+)$/gm)) {
+    let val = m[2].trim();
+    const preloadMatch = val.match(/^preload\s*\(([^)]+)\)/);
+    if (preloadMatch) {
+      val = `preload(${preloadMatch[1]})`;
+    } else if (val.length > 40) {
+      val = val.slice(0, 37) + '...';
+    }
+    sigs.push(`${indent}const ${m[1]} = ${val}`);
+    if (++constCount >= 5) break;
+  }
+
+  for (const m of stripped.matchAll(/^((?:@\w+(?:\([^)]*\))?\s+)*)var\s+(\w+)(?:\s*:\s*([^=\n]+?))?(?:\s*:?=\s*[^\n]+)?$/gm)) {
+    const decorators = m[1] || '';
+    const name = m[2];
+    const hasDecorator = /@\w+/.test(decorators);
+    if (!hasDecorator && name.startsWith('_')) continue;
+    
+    let prefix = decorators.replace(/\([^)]*\)/g, '').trim().split(/\s+/).join(' ');
+    if (prefix) prefix += ' ';
+    
+    const type = (m[3] || '').trim();
+    const typeStr = type ? `: ${type}` : '';
+    sigs.push(`${indent}${prefix}var ${name}${typeStr}`);
+  }
+
+  for (const m of stripped.matchAll(/^(static\s+)?func\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^:\n]+))?\s*:/gm)) {
+    const params = normalizeParams(m[3]);
+    const ret = (m[4] || '').trim();
+    const retStr = ret ? ` → ${ret.slice(0, 30)}` : '';
+    const staticKw = m[1] ? 'static ' : '';
+    sigs.push(`${indent}${staticKw}func ${m[2]}(${params})${retStr}`);
+  }
+
+  for (const m of stripped.matchAll(/^class\s+(\w+)(?:\s+extends\s+(\w+))?\s*:/gm)) {
+    if (addedClasses.has(m[1])) continue;
+    addedClasses.add(m[1]);
+    sigs.push(m[2] ? `class ${m[1]}(${m[2]})` : `class ${m[1]}`);
+    const startIdx = m.index + m[0].length;
+    for (const meth of extractInnerMembers(stripped, startIdx)) {
+      sigs.push(`  ${meth}`);
+    }
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractInnerMembers(stripped, startIndex) {
+  const members = [];
+  const lines = stripped.slice(startIndex).split('\n');
+  for (const line of lines) {
+    if (line.trim() === '') continue;
+    if (!/^\s+/.test(line)) break;
+    const fm = line.match(/^\s+(static\s+)?func\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^:\n]+))?\s*:/);
+    if (fm) {
+      const params = normalizeParams(fm[3]);
+      const ret = (fm[4] || '').trim();
+      const retStr = ret ? ` → ${ret.slice(0, 30)}` : '';
+      const staticKw = fm[1] ? 'static ' : '';
+      members.push(`${staticKw}func ${fm[2]}(${params})${retStr}`);
+    }
+  }
+  return members.slice(0, 6);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim()
+    .split(',')
+    .map((p) => {
+      const part = p.trim();
+      if (!part) return '';
+      const eqIdx = part.indexOf('=');
+      const noDefault = eqIdx !== -1 ? part.slice(0, eqIdx).trim() : part;
+      return noDefault.split(':')[0].trim();
+    })
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/map/import-graph.js

@@ -145,4 +145,4 @@ function analyze(files, cwd) {
   return lines.join('\n');
 }
 
-module.exports = { analyze };
+module.exports = { analyze, extractImports };

package/src/mcp/server.js

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