sigmap 6.10.0 → 6.10.2

package/CHANGELOG.md

@@ -10,6 +10,37 @@ 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
+
+- **R language support (Phase 1)** — Extract function signatures from `.r` and `.R` files with support for function definitions (`<-`, `=`, `<<-` forms), multi-line arguments with string-literal protection, S4 patterns (setGeneric, setMethod, setClass), and private function filtering. Shiny framework detection via `app.R`/`ui.R`/`server.R` triplet.
+- **Native Python AST extractor** — Fallback to `python_ast.py` using `ast.parse()` for accurate extraction of complex signatures (multiline args, stacked decorators, complex generics). Preserves regex fallback for Python 2 / no-Python3 environments. Zero breaking changes to output format.
+
+### Fixed
+
+- **ReferenceError in `--query`** — Fixed variable scope issue where `adpIdx` was undefined when no context file present. Moved variable declaration to proper scope before conditional block.
+- **Windows path handling** — Normalized path separators in nested path deduplication. Windows backslashes no longer cause false negatives when matching nested source roots.
+- **.contextignore patterns** — Fixed bracket character classes (`[Bb]in/`) being treated as literals. Fixed trailing slashes on directory patterns not matching nested paths. Added error handling for malformed bracket syntax.
+- **Claude adapter in per-module and hot-cold strategies** — Fixed adapter not being written to output in per-module and hot-cold context strategies.
+
+---
+
 ## [6.10.0] — 2026-05-05
 
 ### Added

package/README.md

@@ -12,7 +12,8 @@
 [![Zero deps](https://img.shields.io/badge/dependencies-zero-22c55e)](package.json)
 [![License: MIT](https://img.shields.io/badge/License-MIT-7c6af7.svg)](LICENSE)
 [![GitHub Stars](https://img.shields.io/github/stars/manojmallick/sigmap?style=flat&color=f59e0b&logo=github)](https://github.com/manojmallick/sigmap/stargazers)
-[![Hacker News](https://img.shields.io/badge/Hacker%20News-Discussion-orange?logo=ycombinator)](https://news.ycombinator.com/item?id=47956790)
+[![Star History Chart](https://api.star-history.com/svg?repos=manojmallick/sigmap&type=Date)](https://star-history.com/#manojmallick/sigmap&Date)
+[![Discover on ShyPD](https://img.shields.io/badge/ShyPD-Discover-7c6af7?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgdmlld0JveD0iMCAwIDE2IDE2Ij48Y2lyY2xlIGN4PSI4IiBjeT0iOCIgcj0iOCIgZmlsbD0id2hpdGUiLz48L3N2Zz4=&logoColor=7c6af7)](https://shypd.ai/tools/sigmap)
 
 </div>
 
@@ -20,9 +21,11 @@
 
 ## Try it now
 
+**No install required.** Run instantly on any machine:
+
 ```bash
 npx sigmap
-sigmap ask "Where is auth handled?"
+npx sigmap ask "Where is auth handled?"
 ```
 
 Zero config. Zero dependencies. Under 10 seconds.
@@ -33,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
 
 ---
 
@@ -43,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
 
 ---
@@ -144,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 |
@@ -228,6 +244,20 @@ If SigMap saves you context or API spend, a ⭐ on [GitHub](https://github.com/m
 
 ---
 
+## Contributing
+
+SigMap welcomes contributions! 
+
+**Before submitting a PR:**
+1. Read [CONTRIBUTING.md](CONTRIBUTING.md)
+2. Check [Discussions → Announcements](../../discussions) for workflow setup
+3. Target the `develop` branch (not main)
+4. Follow the [contributor checklist](.github/CONTRIBUTOR_CHECKLIST.txt)
+
+See [.github/PULL_REQUEST_TEMPLATE.md](.github/PULL_REQUEST_TEMPLATE.md) for the PR checklist. All contributors are credited in the CHANGELOG and release notes.
+
+---
+
 ## Why not embeddings?
 
 | | Embeddings | SigMap |

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.0',
+  version: '6.10.2',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7913,6 +8055,95 @@ __factories["./src/discovery/source-root-resolver"] = function(module, exports)
   module.exports = { resolveSourceRoots };
 };
 
+// ── ./src/workspace/detector ──
+__factories["./src/workspace/detector"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  module.exports = { detectWorkspaces, inferPackage, scopeToPackage };
+
+  function detectWorkspaces(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) return [];
+
+    let pkg;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+      return [];
+    }
+
+    const patterns = pkg.workspaces || [];
+    const dirs = [];
+
+    // Handle both flat array and object with packages field (Yarn v2 format)
+    const patternArray = Array.isArray(patterns) ? patterns : (patterns.packages || []);
+
+    for (const p of patternArray) {
+      const base = p.replace(/\/\*\*?$/, '');
+      const resolved = path.join(cwd, base);
+      if (fs.existsSync(resolved)) {
+        try {
+          for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+            if (entry.isDirectory()) dirs.push(path.join(resolved, entry.name));
+          }
+        } catch (_) {}
+      }
+    }
+
+    return dirs;
+  }
+
+  // Infer package from query tokens: "add rate limiting to payments" → "packages/payments"
+  function inferPackage(query, workspaceDirs, cwd) {
+    const tokens = query.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+
+    // Find longest matching package name
+    let bestMatch = null;
+    let bestLen = 0;
+    let bestMatchLen = 0;
+
+    for (const dir of workspaceDirs) {
+      const name = path.basename(dir).toLowerCase();
+      for (const token of tokens) {
+        const matchLen = _getMatchLength(name, token);
+        // Only consider matches; use longest match, and break ties by longest package name
+        if (matchLen > 0 && (matchLen > bestLen || (matchLen === bestLen && name.length > bestMatchLen))) {
+          bestMatch = dir;
+          bestLen = matchLen;
+          bestMatchLen = name.length;
+        }
+      }
+    }
+
+    return bestMatch;
+  }
+
+  function _getMatchLength(name, token) {
+    if (name === token) return 1000 + name.length;  // Exact match is best
+    if (name.startsWith(token) && token.length >= 3) return 100 + token.length;
+    if (token.startsWith(name) && name.length >= 3) return name.length;
+    return 0;
+  }
+
+  // Return boost multiplier for files inside the inferred package
+  function scopeToPackage(filePath, packageDir) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const normalizedPkg = packageDir.replace(/\\/g, '/');
+
+    // Ensure we match the directory boundary, not just a prefix
+    // e.g., packages/payment should not match packages/payment-old
+    if (normalized.startsWith(normalizedPkg)) {
+      const afterPrefix = normalized.slice(normalizedPkg.length);
+      // Check if next char is / or if it's the exact match
+      if (afterPrefix === '' || afterPrefix[0] === '/') {
+        return 0.30;
+      }
+    }
+    return 0;
+  }
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -7925,7 +8156,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.10.0';
+const VERSION = '6.10.2';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8005,14 +8236,22 @@ function loadIgnorePatterns(cwd) {
 function matchesIgnore(relPath, patterns) {
   for (const pat of patterns) {
     const normalized = pat.replace(/\\/g, '/');
-    // Simple glob: support * and ** and trailing /
-    const regexStr = normalized
-      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    // Strip trailing slash (gitignore style — directory patterns)
+    const patternToUse = normalized.endsWith('/')
+      ? normalized.slice(0, -1)
+      : normalized;
+    // Escape regex special chars but NOT brackets (keep them for character classes)
+    const regexStr = patternToUse
+      .replace(/[.+^${}()|\\]/g, '\\$&')
       .replace(/\*\*/g, '___DOUBLE___')
       .replace(/\*/g, '[^/]*')
       .replace(/___DOUBLE___/g, '.*');
-    const regex = new RegExp(`(^|/)${regexStr}($|/)`);
-    if (regex.test(relPath)) return true;
+    try {
+      const regex = new RegExp(`(^|/)${regexStr}($|/)`);
+      if (regex.test(relPath)) return true;
+    } catch (_) {
+      // Malformed bracket syntax or invalid regex — skip this pattern
+    }
   }
   return false;
 }
@@ -8940,7 +9179,7 @@ function runPerModuleStrategy(cwd, config, fileEntries, inputTokenTotal) {
   overviewLines.push('> Inject the relevant module file into your IDE context window.');
   overviewLines.push('> For cross-module questions load both files.');
   const overviewContent = overviewLines.join('\n') + '\n';
-  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  const primaryTargets = config.outputs || ['copilot'];
   writeOutputs(overviewContent, primaryTargets, cwd, config);
 
   const overviewTokens = estimateTokens(overviewContent);
@@ -8959,7 +9198,7 @@ function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTot
   const hotContent = hotEntries.length > 0
     ? formatOutput(hotEntries, cwd, false, config, null)
     : '<!-- Generated by SigMap — no recently changed files -->\n';
-  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  const primaryTargets = config.outputs || ['copilot'];
   writeOutputs(hotContent, primaryTargets, cwd, config);
   const hotTokens = estimateTokens(hotContent);
 
@@ -11093,6 +11332,7 @@ function main() {
       // Priority: --output flag > --adapter flag > buildSigIndex probe order
       //   (customOutput from config is handled inside buildSigIndex itself)
       let queryOpts;
+      const adpIdx = args.indexOf('--adapter');
 
       // 1. --output <file> pins to an explicit path
       if (config.customOutput) {
@@ -11100,17 +11340,14 @@ function main() {
       }
 
       // 2. --adapter <name> pins to that adapter's output path (if --output not given)
-      if (!queryOpts) {
-        const adpIdx = args.indexOf('--adapter');
-        if (adpIdx >= 0) {
-          const adapterName = (args[adpIdx + 1] || '').trim().toLowerCase();
-          const VALID_ADAPTERS = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
-          if (VALID_ADAPTERS.includes(adapterName)) {
-            try {
-              const adapterMod = __require('./packages/adapters/' + adapterName);
-              queryOpts = { contextPath: adapterMod.outputPath(cwd) };
-            } catch (_) {}
-          }
+      if (!queryOpts && adpIdx >= 0) {
+        const adapterName = (args[adpIdx + 1] || '').trim().toLowerCase();
+        const VALID_ADAPTERS = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
+        if (VALID_ADAPTERS.includes(adapterName)) {
+          try {
+            const adapterMod = __require('./packages/adapters/' + adapterName);
+            queryOpts = { contextPath: adapterMod.outputPath(cwd) };
+          } catch (_) {}
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.10.0",
+  "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) {