sigmap 6.10.0 → 6.10.1

package/AGENTS.md

@@ -56,10 +56,17 @@ 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.
+## deps
+```
+src/extractors/python_ast.py ← ast
+```
+
 ## changes (last 5 commits — 0 seconds ago)
 ```
-src/eval/usefulness-scorer.js                 +scoreUsefulness  +computeUsefulnessStats
-src/workspace/detector.js                     +detectWorkspaces  +inferPackage  +_getMatchLength  +scopeToPackage
+src/discovery/language-detector.js            ~detectLanguages
+src/extractors/python.js                      +tryNativeExtract  +extract  ~extract  ~extractDocHint
+src/extractors/python_ast.py                  +annotation_to_str  +format_args  +arguments  +get_decorator_names
+src/extractors/r.js                           +extract  +definitions  +readBalancedParens  +normalizeParams
 ```
 
 ## packages
@@ -107,18 +114,6 @@ code-fence js
 code-fence ---
 ```
 
-### packages/core/index.js
-```
-module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
-function _resolveExtractor(language)
-function extract(src, language) → string[]
-function rank(query, sigIndex, opts) → { file: string, score: nu
-function buildSigIndex(cwd) → Map<string, string[]>
-function scan(sigs, filePath) → { safe: string[], redacte
-function score(cwd) → { * score: number, * grad
-function adapt(context, adapterName, opts = {}) → string
-```
-
 ### packages/adapters/copilot.js
 ```
 module.exports = { name, format, outputPath, write }
@@ -178,92 +173,19 @@ function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
-## src
-
-### src/extractors/python.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractClassMethods(stripped, startIndex)
-function tryExtractDataclassFields(stripped, classIndex)
-function tryExtractBaseModelFields(stripped, bodyStart)
-function extractClassConstants(stripped, startIndex)
-function extractReturnType(sigLine)
-function normalizeParams(params)
-function extractDocHint(src, fnName, fnSigLine)
-```
-
-### src/extractors/ruby.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function extractReturnHint(stripped, index)
-```
-
-### src/extractors/rust.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMethods(block)
-function normalizeParams(params)
-function extractReturnType(afterParen)
-```
-
-### src/extractors/scala.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/svelte.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/swift.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function extractArrowType(str)
-```
-
-### src/extractors/todos.js
-```
-module.exports = { extractTodos }
-function extractTodos(src) → {line:number, tag:string,
-```
-
-### src/extractors/vue.js
+### packages/core/index.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
+function _resolveExtractor(language)
+function extract(src, language) → string[]
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function scan(sigs, filePath) → { safe: string[], redacte
+function score(cwd) → { * score: number, * grad
+function adapt(context, adapterName, opts = {}) → string
 ```
 
-### src/eval/scorer.js
-```
-module.exports = { hitAtK, reciprocalRank, precisionAtK, aggregate, firstRank }
-function firstRank(ranked, expected) → number
-function normalizePath(p) → string
-function hitAtK(ranked, expected, k = 5) → 0|1
-function reciprocalRank(ranked, expected) → number
-function precisionAtK(ranked, expected, k = 5) → number
-function aggregate(results, k = 5) → { * hitAt5: number, // fr
-function round(x)
-```
+## src
 
 ### src/eval/runner.js
 ```
@@ -427,19 +349,6 @@ function detectVersion(cwd)
 function format(context, cwd, writtenFiles, sigmapVersion)
 ```
 
-### src/eval/analyzer.js
-```
-module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
-function isDockerfile(name)
-function getExtractorName(filePath)
-function tokenCount(sigs)
-function hasCoverage(filePath, cwd)
-function loadExtractor(name, cwd)
-function analyzeFiles(files, cwd, opts) → object[]
-function formatAnalysisTable(stats, showSlow) → string
-function formatAnalysisJSON(stats) → object
-```
-
 ### src/format/dashboard.js
 ```
 module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
@@ -582,13 +491,6 @@ function _existsAnywhere(cwd, filename, maxDepth)
 function _walkFind(dir, name, depth)
 ```
 
-### src/discovery/language-detector.js
-```
-module.exports = { detectLanguages }
-function detectLanguages(cwd)
-function _walkDepth(dir, depth, extCount)
-```
-
 ### src/discovery/sigmapignore.js
 ```
 module.exports = { loadIgnorePatterns, matchesIgnorePattern }
@@ -596,11 +498,6 @@ function loadIgnorePatterns(cwd)
 function matchesIgnorePattern(dirName, patterns)
 ```
 
-### src/discovery/source-root-registry.js
-```
-module.exports = { REGISTRY }
-```
-
 ### src/retrieval/ranker.js
 ```
 module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent }
@@ -645,6 +542,22 @@ function scoreCandidate(dirName, fullPath, context)
 function _countSourceFiles(dir, depth)
 ```
 
+### src/eval/usefulness-scorer.js
+```
+module.exports = { scoreUsefulness, computeUsefulnessStats }
+function scoreUsefulness(taskResult, rankingScore)
+function computeUsefulnessStats(taskResults)
+```
+
+### src/workspace/detector.js
+```
+module.exports = { detectWorkspaces, inferPackage, scopeToPackage }
+function detectWorkspaces(cwd)
+function inferPackage(query, workspaceDirs, cwd)
+function _getMatchLength(name, token)
+function scopeToPackage(filePath, packageDir)
+```
+
 ### src/discovery/source-root-resolver.js
 ```
 module.exports = { resolveSourceRoots }
@@ -656,11 +569,70 @@ function _dedupeNested(scored)
 function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
-### src/eval/usefulness-scorer.js
+### src/discovery/source-root-registry.js
 ```
-module.exports = { scoreUsefulness, computeUsefulnessStats }
-function scoreUsefulness(taskResult, rankingScore)
-function computeUsefulnessStats(taskResults)
+module.exports = { REGISTRY }
+```
+
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### src/eval/analyzer.js
+```
+module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
+function isDockerfile(name)
+function getExtractorName(filePath)
+function tokenCount(sigs)
+function hasCoverage(filePath, cwd)
+function loadExtractor(name, cwd)
+function analyzeFiles(files, cwd, opts) → object[]
+function formatAnalysisTable(stats, showSlow) → string
+function formatAnalysisJSON(stats) → object
+```
+
+### src/extractors/python.js
+```
+module.exports = { extract, tryNativeExtract }
+function tryNativeExtract(filePath) → string[]|null
+function extract(src, filePath) → string[]
+function extractClassMethods(stripped, startIndex)
+function tryExtractDataclassFields(stripped, classIndex)
+function tryExtractBaseModelFields(stripped, bodyStart)
+function extractClassConstants(stripped, startIndex)
+function extractReturnType(sigLine)
+function normalizeParams(params)
+function extractDocHint(src, fnName, fnSigLine)
+```
+
+### src/extractors/python_ast.py
+```
+def annotation_to_str(node)  # Convert an AST annotation node to a string representation
+def format_args(args_node)  # Format a function arguments node into a compact signature st
+def get_decorator_names(node)  # Return a list of decorator name strings for a function/class
+def is_dataclass(node)
+def is_basemodel(bases)  # Check if class bases include BaseModel or BaseSettings
+def is_optional_annotation(annotation)  # Check if an annotation represents an Optional type
+def get_docstring_hint(node)  # Extract first sentence of docstring, if present
+def extract_dataclass_fields(class_node)  # Return a collapsed fields string for a @dataclass class
+def extract_basemodel_fields(class_node)  # Return a compact {required*, optional
+def extract_class_constants(class_node)  # Yield ALL_CAPS constant assignments from class body
+def extract_method_sig(func_node)  # Format a method signature string (already indented by caller
+def extract_function_sig(func_node, src_lines)  # Format a top-level function signature string
+def extract_fastapi_routes(tree, src_lines)  # Extract FastAPI route signatures from top-level decorated fu
+def extract(filepath)
+def main()
+```
+
+### src/extractors/r.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function readBalancedParens(src, openIdx, cap = 4096)
+function normalizeParams(raw)
 ```
 
 ### src/mcp/server.js
@@ -671,12 +643,3 @@ function respondError(id, code, message)
 function dispatch(msg, cwd)
 function start(cwd)
 ```
-
-### src/workspace/detector.js
-```
-module.exports = { detectWorkspaces, inferPackage, scopeToPackage }
-function detectWorkspaces(cwd)
-function inferPackage(query, workspaceDirs, cwd)
-function _getMatchLength(name, token)
-function scopeToPackage(filePath, packageDir)
-```

package/CHANGELOG.md

@@ -10,6 +10,22 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [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.
@@ -228,6 +231,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

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.10.0',
+  version: '6.10.1',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7913,6 +7913,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 +8014,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.10.0';
+const VERSION = '6.10.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8005,14 +8094,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 +9037,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 +9056,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 +11190,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 +11198,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.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.10.0",
+  "version": "6.10.1",
   "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',
+  '.r': 'r',           '.R': 'r',
   '.vue': 'vue',
   '.svelte': 'svelte',
   '.html': 'html',     '.htm': 'html',

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "6.10.0",
+  "version": "6.10.1",
   "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',
+  '.r': 'r', '.R': 'r',
 };
 
 function detectLanguages(cwd) {

package/src/discovery/source-root-registry.js

@@ -161,6 +161,15 @@ const REGISTRY = {
     srcDirs:  ['src/main/scala','src'],
     penalties: ['target'],
   },
+
+  r: {
+    manifestFiles: ['DESCRIPTION','renv.lock'],
+    frameworks: {
+      shiny: { detectionFiles: ['app.R','ui.R','server.R'], srcDirs: ['R','inst','tests'], entrypoints: ['app.R','server.R'] },
+    },
+    srcDirs:  ['R','src','inst'],
+    penalties: ['renv','packrat','.Rcheck'],
+  },
 };
 
 module.exports = { REGISTRY };

package/src/discovery/source-root-resolver.js

@@ -181,7 +181,11 @@ function _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks) {
 function _dedupeNested(scored) {
   const result = [];
   for (const c of scored) {
-    const isNested = result.some(r => c.dir.startsWith(r.dir + '/'));
+    const cNorm = c.dir.replace(/\\/g, '/');
+    const isNested = result.some(r => {
+      const rNorm = r.dir.replace(/\\/g, '/');
+      return cNorm.startsWith(rNorm + '/');
+    });
     if (!isNested) result.push(c);
   }
   return result;

package/src/eval/analyzer.js

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

package/src/extractors/python.js

@@ -1,11 +1,42 @@
 'use strict';
 
+const path = require('path');
+
+/**
+ * Try to extract signatures using the native Python AST extractor.
+ * Returns null if Python3 is unavailable or the script returns empty results.
+ * @param {string} filePath - Absolute path to the Python file
+ * @returns {string[]|null}
+ */
+function tryNativeExtract(filePath) {
+  try {
+    const { execFileSync } = require('child_process');
+    const scriptPath = path.join(__dirname, 'python_ast.py');
+    const result = execFileSync('python3', [scriptPath, filePath], {
+      timeout: 5000,
+      encoding: 'utf8',
+    });
+    const sigs = JSON.parse(result.trim());
+    if (Array.isArray(sigs) && sigs.length > 0) return sigs;
+  } catch (_) {}
+  return null;
+}
+
 /**
  * Extract signatures from Python source code.
+ * When a real file path is provided, tries the native Python AST extractor first
+ * (more accurate for multiline signatures, stacked decorators, and type annotations).
+ * Falls back to the regex approach if Python3 is unavailable or returns no results.
  * @param {string} src - Raw file content
+ * @param {string} [filePath] - Optional absolute path to the source file
  * @returns {string[]} Array of signature strings
  */
-function extract(src) {
+function extract(src, filePath) {
+  // Prefer native AST extractor when a real file path is available
+  if (filePath && typeof filePath === 'string') {
+    const native = tryNativeExtract(filePath);
+    if (native) return native;
+  }
   if (!src || typeof src !== 'string') return [];
   const sigs = [];
 
@@ -200,4 +231,4 @@ function extractDocHint(src, fnName, fnSigLine) {
   return sentence.slice(0, 60);
 }
 
-module.exports = { extract };
+module.exports = { extract, tryNativeExtract };

package/src/extractors/python_ast.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""
+python_ast.py — Native Python AST-based signature extractor for SigMap.
+
+More accurate than the JS regex approach:
+- Handles multiline signatures correctly
+- Decorator stacking resolved properly
+- Type annotations extracted from AST nodes
+- No false positives from regex on string contents
+
+Usage (called by SigMap's python.js extractor as fallback):
+    python3 python_ast.py <filepath>
+
+Output: JSON array of signature strings (one per line → stdout)
+"""
+
+import ast
+import json
+import sys
+
+MAX_SIGS = 30
+MAX_DOC_HINT_LEN = 60
+
+
+def annotation_to_str(node):
+    """Convert an AST annotation node to a string representation."""
+    if node is None:
+        return None
+    try:
+        return ast.unparse(node)
+    except Exception:
+        # Fallback for older Python versions without ast.unparse
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            return f"{annotation_to_str(node.value)}.{node.attr}"
+        if isinstance(node, ast.Subscript):
+            val = annotation_to_str(node.value)
+            slc = annotation_to_str(node.slice)
+            return f"{val}[{slc}]"
+        if isinstance(node, ast.Index):
+            return annotation_to_str(node.value)
+        if isinstance(node, ast.Tuple):
+            parts = ", ".join(annotation_to_str(e) for e in node.elts)
+            return parts
+        if isinstance(node, ast.Constant):
+            return repr(node.value)
+        return "..."
+
+
+def format_args(args_node):
+    """Format a function arguments node into a compact signature string."""
+    parts = []
+    all_args = args_node.args or []
+    defaults = args_node.defaults or []
+    # Align defaults to the right of args
+    default_offset = len(all_args) - len(defaults)
+
+    for i, arg in enumerate(all_args):
+        name = arg.arg
+        ann = annotation_to_str(arg.annotation) if arg.annotation else None
+        default_idx = i - default_offset
+        has_default = default_idx >= 0
+        token = name
+        if ann:
+            token = f"{name}: {ann}"
+        if has_default:
+            token = f"{token}=..."
+        parts.append(token)
+
+    # *args
+    vararg = args_node.vararg
+    if vararg:
+        ann = annotation_to_str(vararg.annotation) if vararg.annotation else None
+        token = f"*{vararg.arg}"
+        if ann:
+            token = f"*{vararg.arg}: {ann}"
+        parts.append(token)
+
+    # keyword-only args
+    kwonly = args_node.kwonlyargs or []
+    kw_defaults = args_node.kw_defaults or []
+    for i, arg in enumerate(kwonly):
+        name = arg.arg
+        ann = annotation_to_str(arg.annotation) if arg.annotation else None
+        has_default = i < len(kw_defaults) and kw_defaults[i] is not None
+        token = name
+        if ann:
+            token = f"{name}: {ann}"
+        if has_default:
+            token = f"{token}=..."
+        parts.append(token)
+
+    # **kwargs
+    kwarg = args_node.kwarg
+    if kwarg:
+        ann = annotation_to_str(kwarg.annotation) if kwarg.annotation else None
+        token = f"**{kwarg.arg}"
+        if ann:
+            token = f"**{kwarg.arg}: {ann}"
+        parts.append(token)
+
+    return ", ".join(parts)
+
+
+def get_decorator_names(node):
+    """Return a list of decorator name strings for a function/class node."""
+    names = []
+    for dec in node.decorator_list:
+        if isinstance(dec, ast.Name):
+            names.append(dec.id)
+        elif isinstance(dec, ast.Attribute):
+            names.append(dec.attr)
+        elif isinstance(dec, ast.Call):
+            func = dec.func
+            if isinstance(func, ast.Name):
+                names.append(func.id)
+            elif isinstance(func, ast.Attribute):
+                names.append(func.attr)
+    return names
+
+
+def is_dataclass(node):
+    return "dataclass" in get_decorator_names(node)
+
+
+def is_basemodel(bases):
+    """Check if class bases include BaseModel or BaseSettings."""
+    for base in bases:
+        name = annotation_to_str(base) or ""
+        if "BaseModel" in name or "BaseSettings" in name:
+            return True
+    return False
+
+
+def is_optional_annotation(annotation):
+    """Check if an annotation represents an Optional type."""
+    if annotation is None:
+        return False
+    ann_str = annotation_to_str(annotation) or ""
+    return (
+        "Optional[" in ann_str
+        or ("Union[" in ann_str and "None" in ann_str)
+        or "| None" in ann_str
+        or "None |" in ann_str
+    )
+
+
+def get_docstring_hint(node):
+    """Extract first sentence of docstring, if present."""
+    try:
+        doc = ast.get_docstring(node)
+        if doc:
+            first_line = doc.strip().splitlines()[0]
+            return first_line[:MAX_DOC_HINT_LEN] if len(first_line) > MAX_DOC_HINT_LEN else first_line
+    except Exception:
+        pass
+    return None
+
+
+def extract_dataclass_fields(class_node):
+    """Return a collapsed fields string for a @dataclass class."""
+    fields = []
+    for stmt in class_node.body:
+        if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+            name = stmt.target.id
+            has_default = stmt.value is not None
+            is_optional = is_optional_annotation(stmt.annotation) or has_default
+            suffix = "?" if is_optional else ""
+            fields.append(f"{name}{suffix}")
+    return ", ".join(fields)
+
+
+def extract_basemodel_fields(class_node):
+    """Return a compact {required*, optional?} string for a BaseModel subclass."""
+    req = []
+    opt = []
+    for stmt in class_node.body:
+        if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+            name = stmt.target.id
+            has_default = stmt.value is not None
+            is_optional = is_optional_annotation(stmt.annotation) or has_default
+            if is_optional:
+                opt.append(f"{name}?")
+            else:
+                req.append(f"{name}*")
+    all_fields = req + opt
+    if not all_fields:
+        return None
+    return "{" + ", ".join(all_fields) + "}"
+
+
+def extract_class_constants(class_node):
+    """Yield ALL_CAPS constant assignments from class body."""
+    for stmt in class_node.body:
+        if isinstance(stmt, ast.Assign):
+            for target in stmt.targets:
+                if isinstance(target, ast.Name) and target.id.isupper():
+                    try:
+                        val = ast.unparse(stmt.value)
+                    except Exception:
+                        val = "..."
+                    yield f"{target.id}={val}"
+        elif isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+            name = stmt.target.id
+            if name.isupper():
+                val = "..."
+                if stmt.value:
+                    try:
+                        val = ast.unparse(stmt.value)
+                    except Exception:
+                        pass
+                yield f"{name}={val}"
+
+
+def extract_method_sig(func_node):
+    """Format a method signature string (already indented by caller)."""
+    is_async = isinstance(func_node, ast.AsyncFunctionDef)
+    prefix = "async " if is_async else ""
+    params = format_args(func_node.args)
+    ret = annotation_to_str(func_node.returns) if func_node.returns else None
+    ret_str = f" → {ret}" if ret else ""
+    return f"{prefix}def {func_node.name}({params}){ret_str}"
+
+
+def extract_function_sig(func_node, src_lines=None):
+    """Format a top-level function signature string."""
+    is_async = isinstance(func_node, ast.AsyncFunctionDef)
+    prefix = "async " if is_async else ""
+    params = format_args(func_node.args)
+    ret = annotation_to_str(func_node.returns) if func_node.returns else None
+    ret_str = f" → {ret}" if ret else ""
+    hint = get_docstring_hint(func_node)
+    hint_str = f"  # {hint}" if hint else ""
+    return f"{prefix}def {func_node.name}({params}){ret_str}{hint_str}"
+
+
+def extract_fastapi_routes(tree, src_lines):
+    """Extract FastAPI route signatures from top-level decorated functions only."""
+    routes = []
+    http_methods = {"get", "post", "put", "patch", "delete", "head"}
+    for node in tree.body:
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for dec in node.decorator_list:
+            if not isinstance(dec, ast.Call):
+                continue
+            func = dec.func
+            if not isinstance(func, ast.Attribute):
+                continue
+            method = func.attr.lower()
+            if method not in http_methods:
+                continue
+            if dec.args:
+                path_node = dec.args[0]
+                if isinstance(path_node, ast.Constant):
+                    path = path_node.value
+                    routes.append(f"{method.upper()} {path}  →  {node.name}()")
+    return routes
+
+
+def extract(filepath):
+    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+        src = f.read()
+
+    tree = ast.parse(src, filename=filepath)
+    src_lines = src.splitlines()
+    sigs = []
+
+    # Walk top-level statements only
+    for node in tree.body:
+        if len(sigs) >= MAX_SIGS:
+            break
+
+        # Classes
+        if isinstance(node, ast.ClassDef):
+            bases_str = ", ".join(annotation_to_str(b) for b in node.bases if b)
+            dec_names = get_decorator_names(node)
+
+            if is_dataclass(node):
+                fields = extract_dataclass_fields(node)
+                sigs.append(f"@dataclass {node.name}({fields})")
+            elif is_basemodel(node.bases):
+                bm_fields = extract_basemodel_fields(node)
+                base_label = next(
+                    (annotation_to_str(b) for b in node.bases
+                     if "BaseModel" in (annotation_to_str(b) or "") or "BaseSettings" in (annotation_to_str(b) or "")),
+                    "BaseModel"
+                )
+                if bm_fields:
+                    sigs.append(f"class {node.name}({base_label}) {bm_fields}")
+                else:
+                    sigs.append(f"class {node.name}({base_label})")
+            else:
+                base_part = f"({bases_str})" if bases_str else ""
+                sigs.append(f"class {node.name}{base_part}")
+
+            # Class constants
+            for const in extract_class_constants(node):
+                if len(sigs) >= MAX_SIGS:
+                    break
+                sigs.append(f"  {const}")
+
+            # Methods (skip private except __init__, skip all other dunder)
+            for stmt in node.body:
+                if len(sigs) >= MAX_SIGS:
+                    break
+                if not isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+                name = stmt.name
+                if name.startswith("_") and name != "__init__":
+                    continue
+                sigs.append(f"  {extract_method_sig(stmt)}")
+
+        # Top-level functions
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if node.name.startswith("_"):
+                continue
+            sigs.append(extract_function_sig(node, src_lines))
+
+    # FastAPI routes (extract top-level decorated functions)
+    routes = extract_fastapi_routes(tree, src_lines)
+    seen_sigs = set(sigs)
+    for route in routes:
+        if len(sigs) >= MAX_SIGS:
+            break
+        if route not in seen_sigs:
+            sigs.append(route)
+            seen_sigs.add(route)
+
+    return sigs[:MAX_SIGS]
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("[]")
+        return
+
+    filepath = sys.argv[1]
+    try:
+        sigs = extract(filepath)
+        print(json.dumps(sigs))
+    except Exception:
+        print("[]")
+
+
+if __name__ == "__main__":
+    main()

package/src/extractors/r.js

@@ -0,0 +1,136 @@
+'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 };

package/src/mcp/server.js

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