sparda-mcp 0.69.1 → 0.70.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "sparda-mcp",
-  "version": "0.69.1",
+  "version": "0.70.0",
   "mcpName": "io.github.zyx77550/sparda-mcp",
-  "description": "AI writes. SPARDA proves. A deterministic, offline gate that catches when an AI edit removes a guard, exposes a route, or breaks an invariant — no API key, right in the agent edit loop.",
+  "description": "AI writes. SPARDA proves. A deterministic, offline gate that catches when an AI edit removes a guard, exposes a route, or breaks an invariant \u2014 no API key, right in the agent edit loop.",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "test": "vitest run",
-    "prepublishOnly": "vitest run",
+    "prepublishOnly": "node scripts/release-gate.mjs",
     "corpus": "node scripts/corpus-oracle.mjs",
     "corpus:update": "node scripts/corpus-oracle.mjs --update",
     "test:router": "node tests/router-selftest.cjs",
@@ -29,7 +29,8 @@
     "format:check": "prettier --check \"**/*.{js,cjs,mjs}\"",
     "bench:check": "node bench/check-readme.mjs",
     "mutation": "node tests/mutation/run.mjs",
-    "wedge": "node bench/wedge.mjs"
+    "wedge": "node bench/wedge.mjs",
+    "release:check": "node scripts/release-gate.mjs"
   },
   "files": [
     "src",

package/src/ubg/extract.js

@@ -799,6 +799,36 @@ export function resolveExportedFunction(mod, name, seen = new Set()) {
   return null;
 }
 
+// The CLASS twin of `resolveExportedFunction`, and it exists for the same reason one
+// level up. A monorepo package (`@novu/dal`, `@novu/application-generic`) resolves to its
+// entry file, and that entry file is a BARREL — sixty `export * from './repositories/…'`
+// lines and not one class declaration. `classInModule` looks for a class DECLARED in the
+// module it was handed, so every DI hop into a workspace package died on the barrel:
+// measured on novu, 1479 of 2039 constructor-DI hops resolved to nothing, `PinoLogger`
+// and the repository classes at the top of the list. The route's real behavior — every
+// db_write the repository performs — was simply absent from the graph.
+//
+// Bounded by `seen` (a barrel cycle terminates) and memoized by the caller, because a
+// wide barrel is walked once per hop otherwise.
+export function resolveExportedClass(mod, name, seen = new Set()) {
+  if (!mod || mod.error) return null;
+  const direct = classInModule(mod, name);
+  if (direct) return { cls: direct, mod };
+  const named = mod.reexports.get(name); // export { X } from './x'
+  if (named && !seen.has(named)) {
+    seen.add(named);
+    const hit = resolveExportedClass(parseModule(named), name, seen);
+    if (hit) return hit;
+  }
+  for (const file of mod.starReexports ?? []) {
+    if (seen.has(file)) continue;
+    seen.add(file);
+    const hit = resolveExportedClass(parseModule(file), name, seen);
+    if (hit) return hit;
+  }
+  return null;
+}
+
 function collectTopLevel(node, facts, absFile, exported) {
   if (node.type === 'ExportNamedDeclaration' && node.declaration) {
     collectTopLevel(node.declaration, facts, absFile, true);

package/src/ubg/resolve.js

@@ -26,6 +26,7 @@ import {
   methodInClassChain,
   computeThisSymbols,
   resolveExportedFunction,
+  resolveExportedClass,
   collectRepoFields,
   collectReqDerived,
   reqParamName,
@@ -156,6 +157,7 @@ function seedTaint(fn, args, callerReq) {
 // live here, scoped to the run.
 export function createResolver({ cwd, scannedFiles, helpers }) {
   const classBundles = new Map(); // memo: per (class file, class.method[, symbols])
+  const classLookups = new Map(); // memo: per (module, class name) — barrel walks
   const rel = (abs) => relOf(cwd, abs);
 
   // ---- member-call following (imports, instantiated services, this/super) ----
@@ -411,9 +413,22 @@ export function createResolver({ cwd, scannedFiles, helpers }) {
     const file = mod.imports.get(className);
     const clsMod = file ? parseModule(file) : mod;
     if (clsMod.error) return null;
-    const cls = classInModule(clsMod, className);
-    if (!cls) return null;
-    return classMethodBundle(cls, clsMod, methodName, depth, stack, thisSymbols);
+    const hit = classThroughBarrels(clsMod, className);
+    if (!hit) return null;
+    return classMethodBundle(hit.cls, hit.mod, methodName, depth, stack, thisSymbols);
+  }
+
+  // A class is looked up THROUGH barrels: declared here, or re-exported from a module
+  // this one re-exports. A monorepo package entry point is a barrel and nothing else, so
+  // without this every DI hop into a workspace package resolves to nothing at all —
+  // silently, since an unresolved hop leaves no trace of its own. Memoized per (module,
+  // class): a sixty-line barrel is otherwise re-walked once per hop.
+  function classThroughBarrels(clsMod, className) {
+    const key = `cls:${clsMod._file ?? ''}#${className}`;
+    if (classLookups.has(key)) return classLookups.get(key);
+    const hit = resolveExportedClass(clsMod, className);
+    classLookups.set(key, hit);
+    return hit;
   }
 
   // The fully-resolved scan of `<topCls>.<methodName>` — its body plus everything