sigmap 6.9.0 → 6.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.9.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.9.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.9.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.9.0',
+  version: '6.10.1',
   description: 'SigMap MCP server — code signatures on demand',
 };