sigmap 6.10.0 → 6.10.2

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.0",
+  "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,8 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala',   '.sc': 'scala',
+  '.gd': 'gdscript',
+  '.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.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,8 @@ 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',
 };
 
 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,8 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala',   '.sc': 'scala',
+  '.gd': 'gdscript',
+  '.r': 'r',           '.R': 'r',
   '.vue': 'vue',
   '.svelte': 'svelte',
   '.html': 'html',     '.htm': 'html',

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/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 };