sigmap 6.10.9 → 6.10.10

package/src/graph/builder.js

@@ -12,6 +12,12 @@
 const fs   = require('fs');
 const path = require('path');
 
+// Normalize paths for cross-platform consistency (Windows uses backslashes, Unix uses forward slashes)
+// Use lowercase to enable case-insensitive lookups on case-sensitive Windows filesystems
+function normalizePath(p) {
+  return path.normalize(p).toLowerCase();
+}
+
 // ---------------------------------------------------------------------------
 // Language-specific import extractors
 // ---------------------------------------------------------------------------
@@ -22,6 +28,7 @@ const GO_EXTS  = new Set(['.go']);
 const RS_EXTS  = new Set(['.rs']);
 const JVM_EXTS = new Set(['.java', '.kt', '.kts', '.scala', '.sc']);
 const RB_EXTS  = new Set(['.rb', '.rake']);
+const R_EXTS   = new Set(['.r', '.R']);
 
 /**
  * Resolve a JS/TS relative import string to an absolute path in fileSet.
@@ -40,7 +47,34 @@ function resolveJsPath(dir, importStr, fileSet) {
     path.join(base, 'index.js'),
   ];
   for (const c of candidates) {
-    if (fileSet.has(c)) return c;
+    const normC = normalizePath(c);
+    if (fileSet.has(normC)) return normC;
+  }
+  return null;
+}
+
+/**
+ * Resolve an R `source(...)` argument to an absolute path in fileSet.
+ * Tries the dir-relative path first, then a cwd-relative path so that
+ * `source("R/helpers.R")` resolves from the project root.
+ */
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function resolveRPath(dir, importStr, fileSet, cwd) {
+  const tried = new Set();
+  const bases = [path.resolve(dir, importStr)];
+  if (cwd) bases.push(path.resolve(cwd, importStr));
+  for (const base of bases) {
+    for (const c of [base, base + '.R', base + '.r']) {
+      const normC = normalizePath(c);
+      if (tried.has(normC)) continue;
+      tried.add(normC);
+      // Check both original and normalized paths (tests may pass non-normalized fileSet)
+      if (fileSet.has(c)) return c;
+      if (fileSet.has(normC)) return normC;
+    }
   }
   return null;
 }
@@ -50,9 +84,14 @@ function resolveJsPath(dir, importStr, fileSet) {
  * @param {string} filePath - absolute path to the file
  * @param {string} content  - file source content
  * @param {Set<string>} fileSet - set of all known absolute file paths
+ * @param {string}  [cwd]   - project root, used to resolve R `source("R/...")` calls
+ * @param {{ rPackage?: string, rLocalDefs?: Map<string,string> }} [ctx]
+ *        Optional cross-file context. When present and the file is R, a
+ *        `localPkg::fn` reference (where `localPkg` matches `rPackage`) is
+ *        resolved to the file in `rLocalDefs` that defines `fn`.
  * @returns {string[]} resolved absolute paths this file imports
  */
-function extractFileDeps(filePath, content, fileSet) {
+function extractFileDeps(filePath, content, fileSet, cwd, ctx) {
   const ext = path.extname(filePath).toLowerCase();
   const dir = path.dirname(filePath);
   const found = [];
@@ -91,7 +130,10 @@ function extractFileDeps(filePath, content, fileSet) {
       const candidate = modPart
         ? path.join(base, modPart + '.py')
         : null;
-      if (candidate && fileSet.has(candidate)) found.push(candidate);
+      if (candidate) {
+        const normC = normalizePath(candidate);
+        if (fileSet.has(normC)) found.push(normC);
+      }
     }
 
     // Absolute imports: from package.module import ... (infer from project structure)
@@ -105,8 +147,9 @@ function extractFileDeps(filePath, content, fileSet) {
         path.resolve(dir, '..', modulePath, '__init__.py'),
       ];
       for (const c of candidates) {
-        if (fileSet.has(c)) {
-          found.push(c);
+        const normC = normalizePath(c);
+        if (fileSet.has(normC)) {
+          found.push(normC);
           break;
         }
       }
@@ -129,9 +172,10 @@ function extractFileDeps(filePath, content, fileSet) {
     for (const imp of imports) {
       const suffix = imp.split('/').pop();
       for (const f of fileSet) {
-        if (f.endsWith(path.sep + suffix + '.go') ||
-            f.includes(path.sep + suffix + path.sep)) {
-          found.push(f);
+        const normF = normalizePath(f);
+        if (normF.endsWith(path.sep + suffix + '.go') ||
+            normF.includes(path.sep + suffix + path.sep)) {
+          found.push(normF);
           break;
         }
       }
@@ -145,10 +189,12 @@ function extractFileDeps(filePath, content, fileSet) {
     let m;
     while ((m = reMod.exec(content)) !== null) {
       const candidate = path.join(dir, m[1] + '.rs');
-      if (fileSet.has(candidate)) found.push(candidate);
+      const normC = normalizePath(candidate);
+      if (fileSet.has(normC)) found.push(normC);
       // Also try mod/mod.rs
       const candidate2 = path.join(dir, m[1], 'mod.rs');
-      if (fileSet.has(candidate2)) found.push(candidate2);
+      const normC2 = normalizePath(candidate2);
+      if (fileSet.has(normC2)) found.push(normC2);
     }
   }
 
@@ -162,7 +208,8 @@ function extractFileDeps(filePath, content, fileSet) {
       const asPath = m[1].replace(/\./g, path.sep);
       for (const jvmExt of ['.java', '.kt', '.kts', '.scala', '.sc']) {
         for (const f of fileSet) {
-          if (f.endsWith(asPath + jvmExt)) { found.push(f); break; }
+          const normF = normalizePath(f);
+          if (normF.endsWith(normalizePath(asPath + jvmExt))) { found.push(normF); break; }
         }
       }
     }
@@ -175,7 +222,44 @@ function extractFileDeps(filePath, content, fileSet) {
     while ((m = re.exec(content)) !== null) {
       const base = path.resolve(dir, m[1]);
       const candidate  = base.endsWith('.rb') ? base : base + '.rb';
-      if (fileSet.has(candidate)) found.push(candidate);
+      const normC = normalizePath(candidate);
+      if (fileSet.has(normC)) found.push(normC);
+    }
+  }
+
+  // ── R ─────────────────────────────────────────────────────────────────────
+  // R doesn't have JS-style relative imports inside packages — files in R/ are
+  // auto-sourced in alphabetical order. We emit edges for:
+  //   1. Explicit `source("path/file.R")` calls (common in Shiny / scripts).
+  //   2. `localPkg::fn` references where `localPkg` matches the project's
+  //      own DESCRIPTION#Package — resolved via the symbol→file map in ctx.
+  // `library(pkg)` / external `pkg::fn` calls are not graph edges.
+  if (R_EXTS.has(ext)) {
+    const stripped = content.replace(/#.*$/gm, '');
+    const reSrc = /(?:^|[^\w.])source\s*\(\s*["']([^"']+)["']/g;
+    let m;
+    while ((m = reSrc.exec(stripped)) !== null) {
+      const r = resolveRPath(dir, m[1], fileSet, cwd);
+      if (r) found.push(r);
+    }
+    if (ctx && ctx.rPackage && ctx.rLocalDefs && ctx.rLocalDefs.size > 0) {
+      const pkg = ctx.rPackage;
+      // Match `pkg::fn` or `pkg:::fn`. The `::` form needs to be the local
+      // package — references to other packages are external.
+      const reNs = new RegExp(`\\b${escapeRegex(pkg)}:::?([A-Za-z][\\w.]*)`, 'g');
+      while ((m = reNs.exec(stripped)) !== null) {
+        const target = ctx.rLocalDefs.get(m[1]);
+        if (!target) continue;
+        const normTarget = normalizePath(target);
+        const normFilePath = normalizePath(filePath);
+        if (normTarget === normFilePath) continue;
+        // Check both original and normalized paths (tests may pass non-normalized fileSet)
+        if (fileSet.has(target)) {
+          found.push(target);
+        } else if (fileSet.has(normTarget)) {
+          found.push(normTarget);
+        }
+      }
     }
   }
 
@@ -191,17 +275,24 @@ function extractFileDeps(filePath, content, fileSet) {
  *
  * @param {string[]} files - absolute file paths to analyze
  * @param {string}   cwd   - project root (used only for error reporting)
+ * @param {{ rPackage?: string, rLocalDefs?: Map<string,string> }} [ctx]
+ *        Optional cross-file context for namespace-aware resolution. Built
+ *        automatically by `buildFromCwd` when DESCRIPTION + NAMESPACE exist.
  * @returns {{ forward: Map<string,string[]>, reverse: Map<string,string[]> }}
  */
-function build(files, cwd) {
+function build(files, cwd, ctx) {
   const fileSet = new Set(files.map((f) => path.resolve(f)));
+  // Create a normalized version for cross-platform case-insensitive lookups
+  const fileSetNormalized = new Set([...fileSet].map(normalizePath));
   const forward = new Map();
   const reverse = new Map();
 
   // Initialise every known file in both maps (ensures isolated files appear)
+  // Store using normalized paths for Windows compatibility
   for (const f of fileSet) {
-    if (!forward.has(f)) forward.set(f, []);
-    if (!reverse.has(f)) reverse.set(f, []);
+    const normF = normalizePath(f);
+    if (!forward.has(normF)) forward.set(normF, []);
+    if (!reverse.has(normF)) reverse.set(normF, []);
   }
 
   for (const filePath of fileSet) {
@@ -212,12 +303,13 @@ function build(files, cwd) {
       continue;
     }
 
-    const deps = extractFileDeps(filePath, content, fileSet);
+    const normFilePath = normalizePath(filePath);
+    const deps = extractFileDeps(filePath, content, fileSetNormalized, cwd, ctx);
     if (deps.length > 0) {
-      forward.set(filePath, deps);
+      forward.set(normFilePath, deps);
       for (const dep of deps) {
         if (!reverse.has(dep)) reverse.set(dep, []);
-        reverse.get(dep).push(filePath);
+        reverse.get(dep).push(normFilePath);
       }
     }
   }
@@ -236,7 +328,9 @@ function build(files, cwd) {
  * @returns {{ forward: Map<string,string[]>, reverse: Map<string,string[]> }}
  */
 function buildFromCwd(cwd, opts) {
-  const { srcDirs = ['src', 'app', 'lib'], exclude = ['node_modules', '.git', 'dist', 'build'] } = opts || {};
+  // R-package layouts use `R/` and `inst/`; Shiny apps put helpers in `R/`.
+  // The existence check below makes these no-ops in non-R projects.
+  const { srcDirs = ['src', 'app', 'lib', 'R', 'inst'], exclude = ['node_modules', '.git', 'dist', 'build'] } = opts || {};
   const excludeSet = new Set(exclude);
 
   function walkDir(dir, depth) {
@@ -252,7 +346,8 @@ function buildFromCwd(cwd, opts) {
       } else if (e.isFile()) {
         const ext = path.extname(e.name).toLowerCase();
         if (JS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) ||
-            RS_EXTS.has(ext) || JVM_EXTS.has(ext) || RB_EXTS.has(ext)) {
+            RS_EXTS.has(ext) || JVM_EXTS.has(ext) || RB_EXTS.has(ext) ||
+            R_EXTS.has(ext)) {
           out.push(full);
         }
       }
@@ -265,13 +360,27 @@ function buildFromCwd(cwd, opts) {
     const absDir = path.resolve(cwd, sd);
     if (fs.existsSync(absDir)) files.push(...walkDir(absDir, 0));
   }
-  // Also include root-level entry files
-  for (const rootFile of ['gen-context.js', 'index.js', 'main.js', 'app.js']) {
+  // Also include root-level entry files (R: app.R/server.R/ui.R/global.R for Shiny)
+  for (const rootFile of ['gen-context.js', 'index.js', 'main.js', 'app.js',
+                          'app.R', 'server.R', 'ui.R', 'global.R']) {
     const abs = path.resolve(cwd, rootFile);
     if (fs.existsSync(abs)) files.push(abs);
   }
 
-  return build(files, cwd);
+  // Build R namespace context if this looks like an R package.
+  let ctx;
+  try {
+    const { readDescription, collectLocalDefs } = require('../discovery/r-manifest');
+    const desc = readDescription(cwd);
+    if (desc && desc.package) {
+      const rFiles = files.filter((f) => R_EXTS.has(path.extname(f).toLowerCase()));
+      if (rFiles.length > 0) {
+        ctx = { rPackage: desc.package, rLocalDefs: collectLocalDefs(rFiles) };
+      }
+    }
+  } catch (_) { /* manifest module missing or read failed — proceed without ctx */ }
+
+  return build(files, cwd, ctx);
 }
 
-module.exports = { build, buildFromCwd, extractFileDeps };
+module.exports = { build, buildFromCwd, extractFileDeps, normalizePath };

package/src/graph/impact.js

@@ -12,6 +12,11 @@
 const path = require('path');
 const { buildFromCwd } = require('./builder');
 
+// Normalize paths for cross-platform consistency (same as in builder.js)
+function normalizePath(p) {
+  return path.normalize(p).toLowerCase();
+}
+
 // ---------------------------------------------------------------------------
 // Core BFS traversal
 // ---------------------------------------------------------------------------
@@ -111,7 +116,7 @@ function isRouteFile(f) { return ROUTE_PATTERNS.some((re) => re.test(f.replace(/
 function getImpact(changedFile, graph, opts) {
   const { depth = 0, cwd = process.cwd() } = opts || {};
 
-  const absChanged = path.resolve(cwd, changedFile);
+  const absChanged = normalizePath(path.resolve(cwd, changedFile));
 
   // Bail gracefully if file not in graph
   if (!graph || !graph.reverse) {

package/src/mcp/server.js

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

package/src/retrieval/ranker.js

@@ -83,8 +83,9 @@ function _computeHubs(graph) {
 
 // Common utility paths that should be treated as hubs regardless of fanout
 function _isHub(filePath) {
-  return /\/(utils|helpers|shared|common|constants|types|interfaces|index)\.(ts|tsx|js|jsx)$/.test(filePath)
-      || filePath.endsWith('/index.ts') || filePath.endsWith('/index.js');
+  return /\/(utils|helpers|shared|common|constants|types|interfaces|index|zzz|globals)\.(ts|tsx|js|jsx|r|R)$/.test(filePath)
+      || filePath.endsWith('/index.ts') || filePath.endsWith('/index.js')
+      || filePath.endsWith('/R/utils.R') || filePath.endsWith('/R/zzz.R') || filePath.endsWith('/R/globals.R');
 }
 
 /**
@@ -277,6 +278,24 @@ function rank(query, sigIndex, opts) {
     }
   }
 
+  // Compute confidence levels based on score distribution
+  if (scored.length > 0) {
+    const scores = scored.map(s => s.score);
+    const maxScore = Math.max(...scores);
+    const minScore = Math.min(...scores);
+    const scoreRange = maxScore - minScore || 1;
+
+    // Confidence tiers: top 33% = high, next 33% = medium, rest = low
+    for (const entry of scored) {
+      if (entry.score <= 0) {
+        entry.confidence = 'low';
+      } else {
+        const normalized = (entry.score - minScore) / scoreRange;
+        entry.confidence = normalized > 0.66 ? 'high' : normalized > 0.33 ? 'medium' : 'low';
+      }
+    }
+  }
+
   scored.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
   return scored.slice(0, topK);
 }