@tekyzinc/gsd-t 5.22.10 → 5.24.10

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 });
         }
       }
@@ -261,7 +264,8 @@ function buildSchema(db) {
       file         TEXT NOT NULL,
       name         TEXT,
       func_id      TEXT,
-      end_line     INTEGER
+      end_line     INTEGER,
+      meta         TEXT
     );
     CREATE TABLE IF NOT EXISTS edges (
       kind    TEXT    NOT NULL,
@@ -275,6 +279,18 @@ function buildSchema(db) {
     CREATE INDEX IF NOT EXISTS nodes_file      ON nodes(file);
   `);
   migrateEndLine(db);
+  migrateMeta(db);
+}
+
+/**
+ * Idempotent migration: add `nodes.meta` (JSON) — a table's SQL name + columns,
+ * an enum's values. NULL for functions/classes. [RULE] drizzle-table-entity-and-usage-edges
+ */
+function migrateMeta(db) {
+  const cols = db.prepare("PRAGMA table_info(nodes)").all();
+  if (!cols.some((c) => c.name === 'meta')) {
+    db.exec('ALTER TABLE nodes ADD COLUMN meta TEXT');
+  }
 }
 
 /**
@@ -310,11 +326,15 @@ function migrateEndLine(db) {
  */
 function getWriteStmts(db) {
   if (db.__m94WriteStmts) return db.__m94WriteStmts;
+  // A handle opened elsewhere (the freshness re-index opens the db without
+  // buildSchema) may point at an older graph — add the columns written below.
+  migrateEndLine(db);
+  migrateMeta(db);
   const stmts = {
     deleteNodes: db.prepare('DELETE FROM nodes WHERE file = ?'),
     deleteEdgesSrc: db.prepare("DELETE FROM edges WHERE src = ? OR src LIKE ? OR src = ?"),
     insFile: db.prepare('INSERT OR REPLACE INTO files (file, content_hash, tier, indexed_at) VALUES (?, ?, ?, ?)'),
-    insNode: db.prepare('INSERT OR REPLACE INTO nodes (id, kind, tier, content_hash, file, name, func_id, end_line) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'),
+    insNode: db.prepare('INSERT OR REPLACE INTO nodes (id, kind, tier, content_hash, file, name, func_id, end_line, meta) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'),
     insEdge: db.prepare('INSERT INTO edges (kind, src, dst, partial) VALUES (?, ?, ?, ?)'),
   };
   // db.transaction() wrapper is also created once (it closes over the stmts).
@@ -324,7 +344,8 @@ function getWriteStmts(db) {
     stmts.deleteEdgesSrc.run(file, `${file}#%`, file);
     stmts.insFile.run(file, hash, tier, now);
     for (const entity of entities) {
-      stmts.insNode.run(entity.id, entity.type || 'function', tier, hash, file, entity.name || null, entity.id, entity.endLine ?? null);
+      stmts.insNode.run(entity.id, entity.type || 'function', tier, hash, file, entity.name || null, entity.id, entity.endLine ?? null,
+        entity.meta === undefined ? null : JSON.stringify(entity.meta));
     }
     for (const edge of edges) {
       stmts.insEdge.run(edge.kind, edge.src, edge.dst, edge.partial ? 1 : 0);
@@ -404,12 +425,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)
@@ -452,6 +477,7 @@ function parse_and_put(absPath, relPath, options) {
     exported: e.exported,
     parentClass: e.parentClass,
     endLine: e.endLine ?? null,   // M98 — function end line for body-slice
+    ...(e.meta === undefined ? {} : { meta: e.meta }), // table / enum: SQL name, columns, values
   }));
 
   if (db) {
@@ -530,8 +556,15 @@ 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
+  let tableCount = 0;
+  let enumCount = 0;
+  const tablesUnresolved = []; // [RULE] drizzle-table-shape-gap-named-never-skipped
 
   // Stream: parse + put each file one at a time (never accumulate the full set)
   for (const { absPath, relPath } of files) {
@@ -541,7 +574,19 @@ 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);
+      for (const ent of result.entities) {
+        if (ent.type === 'table') tableCount++;
+        if (ent.type === 'enum') enumCount++;
+        if (ent.meta && ent.meta.unresolved) tablesUnresolved.push({ file: relPath, name: ent.name, problems: ent.meta.unresolved });
+      }
       if (typeof onProgress === 'function') {
         onProgress({ file: relPath, tier: result.tier, fileCount, total: files.length });
       }
@@ -552,6 +597,20 @@ function build_index(repoRoot, options) {
     }
   }
 
+  // A full build leaves exactly the enumerated set: rows for a file that is gone
+  // or newly excluded (e.g. GSD-T's copied bin/ tools) are pruned, not kept.
+  // [RULE] status-counts-files-table
+  const enumerated = new Set(files.map((f) => f.relPath));
+  const stale = db.prepare('SELECT file FROM files').all().map((r) => r.file).filter((f) => !enumerated.has(f));
+  if (stale.length) {
+    const w = getWriteStmts(db);
+    const delFile = db.prepare('DELETE FROM files WHERE file = ?');
+    db.transaction(() => {
+      for (const f of stale) { w.deleteNodes.run(f); w.deleteEdgesSrc.run(f, `${f}#%`, f); delFile.run(f); }
+    })();
+    info(`Pruned ${stale.length} file(s) no longer in the project (deleted or excluded)`);
+  }
+
   // Record the skipped set + parse-success-rate so a query whose edges live in a
   // skipped file can return a coverage flag ('result may be incomplete — N files
   // unparsed') instead of a bare empty set that reads as authoritative truth.
@@ -592,11 +651,35 @@ 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 ? ', …' : ''}`);
+  }
+
+  // A table whose declaration had a shape the extractor could not read (a
+  // computed name, a spread of columns, a non-literal reference) is still an
+  // entity — but its columns or FKs are incomplete. Named every build, loud.
+  if (tablesUnresolved.length) {
+    warn(`${tablesUnresolved.length} table/enum declaration(s) only partly read — columns or foreign keys incomplete:`);
+    for (const t of tablesUnresolved.slice(0, 20)) warn(`  ${t.file} ${t.name}: ${t.problems.join('; ')}`);
+    if (tablesUnresolved.length > 20) warn(`  … ${tablesUnresolved.length - 20} more`);
+  }
+
   return {
     fileCount,
+    tableCount,
+    enumCount,
+    tablesUnresolved,
     entityCount,
     edgeCount,
-    tier: { floor: tierFloor, upgraded: tierUpgraded },
+    tier: { floor: tierFloor, upgraded: tierUpgraded, partial: tierPartial },
+    callEdges,
+    callEdgesUnresolved,
+    scipMissing,
     scipAvailable: scipActive,
     scipNotice,
     errors,
@@ -648,7 +731,12 @@ 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)`);
+  }
+  good(`Database tables: ${result.tableCount}, enums: ${result.enumCount}`);
   if (result.errors > 0) warn(`${result.errors} files had parse errors (skipped)`);
 
   const envelope = {
@@ -660,6 +748,10 @@ if (require.main === module) {
     entityCount: result.entityCount,
     edgeCount: result.edgeCount,
     tier: result.tier,
+    scipMissingCount: result.scipMissing.length,
+    tableCount: result.tableCount,
+    enumCount: result.enumCount,
+    tablesUnresolved: result.tablesUnresolved,
     errors: result.errors,
     durationMs: result.durationMs,
   };