@tekyzinc/gsd-t 5.21.10 → 5.23.10

package/bin/gsd-t-graph-edge-extract.cjs

@@ -173,7 +173,7 @@ function extractImportedNames(importNode) {
  * SCIP upgrade will replace these with fully-resolved funcIds.
  *
  * [RULE] who-calls-function-identity-disambiguated: src is the funcId of the
- * enclosing function (or a synthetic _anon@line if top-level); dst is the
+ * enclosing function (or a synthetic route/anonymous caller id, else _toplevel); dst is the
  * callee's best-effort funcId.
  */
 function resolveCalleeName(fnNode) {
@@ -185,6 +185,57 @@ function resolveCalleeName(fnNode) {
   return null;
 }
 
+// ── Anonymous callers (route handlers + callbacks) ───────────────────────────
+//
+// A call inside an anonymous function has no named caller. Before this, such a
+// call was credited to `file#_toplevel` (and a const-arrow body was walked twice,
+// crediting every call in it to _toplevel as well as to the real function). A
+// Hono/Express route file is almost entirely `router.get('/p', mw, async (c) =>
+// { helper() })`, so who-calls answered with one meaningless "_toplevel" caller
+// or — when the dst never resolved — nothing at all.
+//
+// Now every anonymous body gets a caller identity that says where it is:
+//   route handler   → `file#GET /locations/:id@3217`   (method + path + line)
+//   other callback  → the enclosing NAMED function, when there is one
+//   top-level cb    → `file#anonymous@<line>`
+// [RULE] anonymous-caller-synthesized-never-dropped
+
+const ROUTE_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'del', 'all', 'options', 'head', 'use']);
+
+function isAnonymousFn(node) {
+  if (!node) return false;
+  if (node.type === 'arrow_function') return true;
+  if (node.type === 'function' || node.type === 'function_expression') {
+    return !node.childForFieldName('name');
+  }
+  return false;
+}
+
+/**
+ * `router.get('/path', ...)` → "GET /path"; anything else → null.
+ * The method match is case-insensitive (a domain value, not an identifier).
+ */
+function routeLabel(fnNode, argsNode) {
+  if (!fnNode || fnNode.type !== 'member_expression' || !argsNode) return null;
+  const prop = fnNode.childForFieldName('property');
+  if (!prop) return null;
+  const method = prop.text.toLowerCase();
+  if (!ROUTE_METHODS.has(method)) return null;
+  const first = argsNode.namedChild(0);
+  if (!first || (first.type !== 'string' && first.type !== 'template_string')) return null;
+  return `${method.toUpperCase()} ${first.text.slice(1, -1)}`;
+}
+
+/**
+ * A registration with no anonymous handler (`router.get('/x', requireAuth(), handler)`)
+ * is only treated as a route when its first argument looks like a URL path, so a
+ * `cache.get('key', compute())` is never mistaken for one.
+ */
+function isRoutePath(firstArg) {
+  if (!firstArg) return false;
+  return firstArg.text.slice(1).startsWith('/');
+}
+
 // ── Python-specific extraction ────────────────────────────────────────────────
 
 function walkPython(rootNode, relPath, entities, edges) {
@@ -298,6 +349,7 @@ function walkPython(rootNode, relPath, entities, edges) {
             source: enclosingFuncId,
             target: `UNRESOLVED#${calleeName}`,
             line: node.startPosition.row + 1,
+            col: fn.startPosition.column, // [RULE] scip-tier-proportional
           });
         }
       }
@@ -374,13 +426,58 @@ function walkTSJS(rootNode, relPath, entities, edges) {
             source: srcId,
             target: `UNRESOLVED#${calleeName}`,
             line: node.startPosition.row + 1,
+            // callee column — lets the SCIP upgrader tell a call the compiler saw
+            // from one it never looked at. [RULE] scip-tier-proportional
+            col: fn.startPosition.column,
+          });
+        }
+
+        // Route registration: the route itself becomes the caller, named by
+        // method + path + line — for its anonymous handler AND for every
+        // middleware call in its arguments (`requireAuth()`, `requireLocationTenant()`).
+        // Crediting middleware to the enclosing scope collapsed 95 routes into one
+        // `_toplevel` caller per file. [RULE] anonymous-caller-synthesized-never-dropped
+        // [RULE] route-middleware-args-credited-to-route
+        const label = routeLabel(fn, args);
+        const handlers = label ? args.namedChildren.filter(isAnonymousFn) : [];
+        const middlewareCalls = label && isRoutePath(args.namedChild(0))
+          ? args.namedChildren.slice(1).filter((a) => a.type === 'call_expression') : [];
+        if (handlers.length || middlewareCalls.length) {
+          const line = node.startPosition.row + 1;
+          const routeId = `${relPath}#${label}@${line}`;
+          entities.push({
+            id: routeId,
+            name: label,
+            type: 'function',
+            line,
+            endLine: node.endPosition.row + 1,
+            exported: false,
+            synthetic: 'route-handler',
           });
+          // Node objects are re-created per access, so match handlers by position.
+          const handlerStarts = new Set(handlers.map((h) => h.startIndex));
+          walk(fn, enclosingFuncId, enclosingClass);
+          for (let i = 0; i < args.childCount; i++) {
+            const arg = args.child(i);
+            if (!handlerStarts.has(arg.startIndex) || !isAnonymousFn(arg)) { walk(arg, routeId, enclosingClass); continue; }
+            for (let j = 0; j < arg.childCount; j++) walk(arg.child(j), routeId, enclosingClass);
+          }
+          return;
         }
       }
 
       // Fall through to walk children (the call_expression can contain more nodes)
     }
 
+    // ── anonymous function with no named scope around it ─────────────────
+    // Inside a named function, a callback's calls belong to that function
+    // (enclosingFuncId passes through). Outside one, give it a located id.
+    if (!enclosingFuncId && isAnonymousFn(node)) {
+      const anonId = `${relPath}#anonymous@${node.startPosition.row + 1}`;
+      for (let i = 0; i < node.childCount; i++) walk(node.child(i), anonId, enclosingClass);
+      return;
+    }
+
     // ── function_declaration ──────────────────────────────────────────────
     if (t === 'function_declaration' || t === 'function') {
       const nameNode = node.childForFieldName('name');
@@ -451,6 +548,7 @@ function walkTSJS(rootNode, relPath, entities, edges) {
     // const foo = () => ... or const foo = function...
     if (t === 'lexical_declaration' || t === 'variable_declaration') {
       const isExp = isExportedNode(node);
+      const walkedValues = new Set(); // bodies already walked under their own funcId
       for (let i = 0; i < node.namedChildCount; i++) {
         const decl = node.namedChild(i);
         if (decl.type === 'variable_declarator') {
@@ -474,10 +572,23 @@ function walkTSJS(rootNode, relPath, entities, edges) {
             for (let j = 0; j < valueNode.childCount; j++) {
               walk(valueNode.child(j), funcId, enclosingClass);
             }
+            walkedValues.add(valueNode.startIndex);
           }
         }
       }
-      // Continue walking children for the declaration itself
+      // Walk the rest of the declaration, but NOT a function body already walked
+      // above — walking it again credited each of its calls to a second, wrong
+      // caller (_toplevel). [RULE] anonymous-caller-synthesized-never-dropped
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child.type !== 'variable_declarator') { walk(child, enclosingFuncId, enclosingClass); continue; }
+        for (let j = 0; j < child.childCount; j++) {
+          const part = child.child(j);
+          if (walkedValues.has(part.startIndex) && part.type !== 'identifier') continue;
+          walk(part, enclosingFuncId, enclosingClass);
+        }
+      }
+      return;
     }
 
     // ── export_statement (bare re-exports: export { x, y }) ──────────────

package/bin/gsd-t-graph-exclude.cjs

@@ -0,0 +1,81 @@
+'use strict';
+/**
+ * gsd-t-graph-exclude.cjs — per-project exclude list for the code graph.
+ *
+ * Some repos carry large trees that are not the production application —
+ * design exports, Figma-generated component dumps, prototypes, archived
+ * scripts. They bloat the index, slow SCIP, and put look-alike symbols into
+ * who-calls. A project lists them in `.gsd-t/graph-exclude.json`:
+ *
+ *   { "exclude": ["design/", "figma-exports/**", "scripts/archive/", "**\/*.figma.tsx"] }
+ *
+ * Pattern rules (paths are repo-relative, forward slashes, matched case-insensitively):
+ *   - no `*`            → a path prefix: "design/" or "design" excludes that folder
+ *   - `*`               → any run of characters except "/"
+ *   - `**`              → any run of characters including "/"
+ *
+ * The indexer AND the freshness walker both read this module, so a file the
+ * indexer skipped never shows up as a phantom "new file" on the next query.
+ * [RULE] freshness-excludes-match-indexer-skipdirs
+ *
+ * A malformed file HALTS (throws): silently ignoring it would index exactly the
+ * trees the user asked to keep out, with nothing saying so.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const EXCLUDE_FILE = path.join('.gsd-t', 'graph-exclude.json');
+const REGEX_SPECIALS = /[.+?^${}()|[\]\\]/g;
+
+function toRegex(pattern) {
+  const p = String(pattern).trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+  if (!p) return null;
+  if (!p.includes('*')) {
+    // Plain prefix: the path itself, or anything under it.
+    const base = p.replace(/\/+$/, '').replace(REGEX_SPECIALS, '\\$&');
+    return new RegExp(`^${base}(/|$)`, 'i');
+  }
+  let re = '';
+  for (let i = 0; i < p.length; i++) {
+    const c = p[i];
+    if (c === '*' && p[i + 1] === '*') {
+      i++;
+      if (p[i + 1] === '/') { i++; re += '(?:.*/)?'; } else re += '.*';
+    } else if (c === '*') re += '[^/]*';
+    else re += c.replace(REGEX_SPECIALS, '\\$&');
+  }
+  return new RegExp(`^${re}(/|$)`, 'i');
+}
+
+function validateList(parsed) {
+  const list = parsed ? parsed.exclude : undefined;
+  if (!Array.isArray(list)) return false;
+  return list.every((x) => typeof x === 'string');
+}
+
+/**
+ * Load the project's exclude list. Throws on a malformed file.
+ * @returns {{ patterns: string[], source: string|null, isExcluded: (relPath: string) => boolean }}
+ */
+function loadGraphExcludes(projectRoot) {
+  const file = path.join(projectRoot, EXCLUDE_FILE);
+  if (!fs.existsSync(file)) return { patterns: [], source: null, isExcluded: () => false };
+  let parsed;
+  try { parsed = JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (e) { throw new Error(`${EXCLUDE_FILE} is not valid JSON (${e.message}) — fix it or delete it`); }
+  if (!validateList(parsed)) {
+    throw new Error(`${EXCLUDE_FILE} must be { "exclude": ["folder/", "glob/**", ...] }`);
+  }
+  const regexes = parsed.exclude.map(toRegex).filter(Boolean);
+  return {
+    patterns: parsed.exclude,
+    source: EXCLUDE_FILE,
+    isExcluded: (relPath) => {
+      const rel = String(relPath).split(path.sep).join('/');
+      return regexes.some((r) => r.test(rel));
+    },
+  };
+}
+
+module.exports = { loadGraphExcludes, EXCLUDE_FILE, _toRegex: toRegex };

package/bin/gsd-t-graph-freshness.cjs

@@ -220,7 +220,11 @@ function compute_touched_files(db, projectRoot) {
   }
 
   // Walk the current working tree
-  const liveFiles = walkTree(projectRoot);
+  // Same exclude list as the indexer, so an excluded file is never a phantom ADD
+  // and a newly-excluded one drops out as a DELETE. [RULE] freshness-excludes-match-indexer-skipdirs
+  const { isExcluded } = require('./gsd-t-graph-exclude.cjs').loadGraphExcludes(projectRoot);
+  const liveFiles = walkTree(projectRoot)
+    .filter((abs) => !isExcluded(path.relative(projectRoot, abs)));
 
   const liveRelSet = new Set();
   const edits = [];

package/bin/gsd-t-graph-index.cjs

@@ -196,18 +196,21 @@ function contentHash(absPath) {
 
 function enumerateFiles(root) {
   const results = [];
+  // Project exclude list (.gsd-t/graph-exclude.json) — ancillary trees such as
+  // design/Figma exports that are not the application. Throws on a malformed file.
+  const { isExcluded } = require('./gsd-t-graph-exclude.cjs').loadGraphExcludes(root);
   function walk(dir) {
     let entries;
     try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
     catch { return; }
     for (const e of entries) {
+      const absPath = path.join(dir, e.name);
+      const relPath = path.relative(root, absPath).split(path.sep).join('/');
       if (e.isDirectory()) {
-        if (!shouldSkipDir(e.name)) walk(path.join(dir, e.name));
+        if (!shouldSkipDir(e.name) && !isExcluded(relPath)) walk(absPath);
       } else if (e.isFile()) {
         const ext = path.extname(e.name).toLowerCase();
-        if (PARSED_EXTS.has(ext)) {
-          const absPath = path.join(dir, e.name);
-          const relPath = path.relative(root, absPath).split(path.sep).join('/');
+        if (PARSED_EXTS.has(ext) && !isExcluded(relPath)) {
           results.push({ absPath, relPath, ext });
         }
       }
@@ -404,12 +407,16 @@ function parse_and_put(absPath, relPath, options) {
       finalEntities = upgraded.entities;
       finalEdges = upgraded.edges;
     }
-  } else if (existingTier === 'compiler-accurate') {
+  } else if (existingTier === 'compiler-accurate' || existingTier === 'compiler-partial') {
     // [RULE] reindex-tier-never-silently-downgraded — no SCIP context this call
     // (e.g. a metadata-only re-index like M98's body end-line backfill). A file that
     // WAS compiler-accurate must NOT silently drop to plain floor; label it STALE-SCIP
     // so the tier reflects "previously accurate, not re-resolved" rather than a lie.
     tier = 'tree-sitter-floor-STALE-SCIP';
+  } else if (existingTier === 'tree-sitter-floor-SCIP-MISSING') {
+    // Same principle: a file SCIP never indexed stays labelled as such until a
+    // full build (with SCIP) says otherwise. [RULE] scip-missing-file-detected-never-silent
+    tier = existingTier;
   }
 
   // Normalize edges to store schema (map from parser-floor shape to store shape)
@@ -530,8 +537,12 @@ function build_index(repoRoot, options) {
   let edgeCount = 0;
   let tierFloor = 0;
   let tierUpgraded = 0;
+  let tierPartial = 0; // [RULE] scip-tier-proportional
+  let callEdges = 0;
+  let callEdgesUnresolved = 0;
   let errors = 0;
   const skippedFiles = [];
+  const scipMissing = []; // files SCIP ran for but produced no document for
 
   // Stream: parse + put each file one at a time (never accumulate the full set)
   for (const { absPath, relPath } of files) {
@@ -541,7 +552,14 @@ function build_index(repoRoot, options) {
       entityCount += result.entities.length;
       edgeCount += result.edges.length;
       if (result.tier === 'compiler-accurate') tierUpgraded++;
+      else if (result.tier === 'compiler-partial') tierPartial++;
       else tierFloor++;
+      for (const e of result.edges) {
+        if (e.kind !== 'call-site' && e.kind !== 'CALL') continue;
+        callEdges++;
+        if (String(e.target || e.dst).startsWith('UNRESOLVED#')) callEdgesUnresolved++;
+      }
+      if (result.tier === 'tree-sitter-floor-SCIP-MISSING') scipMissing.push(relPath);
       if (typeof onProgress === 'function') {
         onProgress({ file: relPath, tier: result.tier, fileCount, total: files.length });
       }
@@ -592,11 +610,23 @@ function build_index(repoRoot, options) {
     console.error(`\x1b[33m[IDX NOTICE]\x1b[0m ${scipNotice}`);
   }
 
+  // A file the SCIP indexer skipped keeps every call target unresolved, so
+  // who-calls cannot see its callers. Loud, every build — not a fallback, a
+  // report. `gsd-t graph status` repeats it. [RULE] scip-missing-file-detected-never-silent
+  if (scipMissing.length) {
+    const shown = scipMissing.slice(0, 10).join(', ');
+    warn(`${scipMissing.length} file(s) not in the SCIP index — their call edges stay unresolved ` +
+      `(tier tree-sitter-floor-SCIP-MISSING): ${shown}${scipMissing.length > 10 ? ', …' : ''}`);
+  }
+
   return {
     fileCount,
     entityCount,
     edgeCount,
-    tier: { floor: tierFloor, upgraded: tierUpgraded },
+    tier: { floor: tierFloor, upgraded: tierUpgraded, partial: tierPartial },
+    callEdges,
+    callEdgesUnresolved,
+    scipMissing,
     scipAvailable: scipActive,
     scipNotice,
     errors,
@@ -648,7 +678,11 @@ if (require.main === module) {
   });
 
   good(`Indexed ${result.fileCount} files, ${result.entityCount} entities, ${result.edgeCount} edges in ${result.durationMs}ms`);
-  good(`Tiers — floor: ${result.tier.floor}, compiler-accurate: ${result.tier.upgraded}`);
+  good(`Tiers — floor: ${result.tier.floor}, compiler-accurate: ${result.tier.upgraded}, compiler-partial: ${result.tier.partial}`);
+  if (result.callEdges) {
+    info(`Call edges unresolved: ${result.callEdgesUnresolved} of ${result.callEdges} ` +
+      `(${(100 * result.callEdgesUnresolved / result.callEdges).toFixed(1)}% — library calls such as console.log never resolve)`);
+  }
   if (result.errors > 0) warn(`${result.errors} files had parse errors (skipped)`);
 
   const envelope = {
@@ -660,6 +694,7 @@ if (require.main === module) {
     entityCount: result.entityCount,
     edgeCount: result.edgeCount,
     tier: result.tier,
+    scipMissingCount: result.scipMissing.length,
     errors: result.errors,
     durationMs: result.durationMs,
   };