@monoes/monograph 1.5.0 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monograph",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "type": "module",
   "description": "Native TypeScript code intelligence engine for monomind",
   "main": "dist/src/index.js",

package/src/__tests__/pipeline/phases/wildcard-phase.test.ts

@@ -2,14 +2,22 @@ import { describe, it, expect } from 'vitest';
 import Database from 'better-sqlite3';
 import { wildcardSynthesisPhase } from '../../../pipeline/phases/wildcard-phase.js';
 import type { PipelineContext } from '../../../pipeline/types.js';
+import { CREATE_NODES, CREATE_EDGES } from '../../../storage/schema.js';
 
+// Uses the REAL production schema (including the edges FK constraint on
+// source_id/target_id) with foreign_keys actually enabled — the original
+// hand-rolled test schema had neither, so it silently passed inserts that
+// would violate the real edges table's FK constraint in production (issue #40).
 function makeDb(): Database.Database {
   const db = new Database(':memory:');
+  db.pragma('foreign_keys = ON');
+  db.exec(CREATE_NODES);
+  db.exec(CREATE_EDGES);
   db.exec(`
-    CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT, name TEXT, norm_label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER, is_exported INTEGER DEFAULT 0, language TEXT, properties TEXT);
-    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
-    INSERT INTO nodes VALUES ('n1', 'Function', 'greet', 'greet', '/mod.ts', 1, 5, null, 1, null, null);
-    INSERT INTO nodes VALUES ('n2', 'File', 'main.ts', 'main.ts', '/main.ts', null, null, null, 0, null, null);
+    INSERT INTO nodes (id, label, name, norm_label, file_path, start_line, end_line, is_exported)
+      VALUES ('n1', 'Function', 'greet', 'greet', '/mod.ts', 1, 5, 1);
+    INSERT INTO nodes (id, label, name, norm_label, file_path, is_exported)
+      VALUES ('n2', 'File', 'main.ts', 'main.ts', '/main.ts', 0);
   `);
   return db;
 }
@@ -61,4 +69,31 @@ describe('wildcardSynthesisPhase', () => {
     const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
     await expect(wildcardSynthesisPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
   });
+
+  it('skips a file with no fileNodeIndex entry instead of fabricating a source_id and violating the edges FK constraint (issue #40)', async () => {
+    // Regression: a file with no parsed symbols (e.g. blank, or a filetype
+    // the parser emits no node for) has no entry in fileNodeIndex. The old
+    // code fell back to a fabricated `file:${filePath}` id that was never a
+    // real row in `nodes`, so the edge insert below violated the edges
+    // table's FOREIGN KEY constraint on source_id and crashed the whole
+    // monograph_build. /empty.ts here is exactly that case: it's present in
+    // fileContents (parsed) but has NO corresponding node in symbolNodes.
+    const db = makeDb();
+    const source = `import * as mod from '/mod.ts';\nmod.greet("hello");`;
+    const parseOutput = {
+      allEdges: [],
+      symbolNodes: [
+        { id: 'n1', name: 'greet', label: 'Function', normLabel: 'greet', filePath: '/mod.ts', isExported: true },
+      ],
+      parseErrors: [],
+      fileContents: new Map([['/empty.ts', source]]),
+    };
+    const crossFileOutput = { resolvedEdges: [] };
+    const deps = new Map<string, any>([['parse', parseOutput], ['cross-file', crossFileOutput]]);
+
+    await expect(wildcardSynthesisPhase.execute(makeCtx(db), deps)).resolves.not.toThrow();
+
+    const edgeCount = (db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
+    expect(edgeCount).toBe(0); // nothing could legitimately attach to a file with no real node
+  });
 });

package/src/analysis/cycles.ts

@@ -203,14 +203,18 @@ export function detectCycles(db: MonographDb): CycleDetectionResult {
   const nodeIds = nodeRows.map(n => n.id);
   const sccs = tarjanSCC(adjacency, nodeIds);
 
-  // Only SCCs with size > 1 are actual cycles
-  const cycleSCCs = sccs.filter(scc => scc.length > 1);
+  // SCCs with size > 1 are multi-node cycles; size-1 SCCs are cycles only if self-referencing
+  const cycleSCCs = sccs.filter(scc =>
+    scc.length > 1 || (scc.length === 1 && adjacency.get(scc[0])?.includes(scc[0])),
+  );
 
   const cycles: DependencyCycle[] = [];
   const filesInCyclesSet = new Set<string>();
 
   for (const scc of cycleSCCs) {
-    const elementaryCycles = findCyclesInSCC(scc, adjacency, 20);
+    const elementaryCycles = scc.length === 1
+      ? [[scc[0], scc[0]]]
+      : findCyclesInSCC(scc, adjacency, 20);
     for (const cyclePath of elementaryCycles) {
       // cyclePath is [...nodes, startNode] — last element = first
       const cycleNodes = cyclePath.slice(0, -1);

package/src/analysis/trace.ts

@@ -226,27 +226,7 @@ export function traceDependency(
 
   const directSet = new Set(directImporters);
 
-  // BFS to find transitive importers
-  // Build a file→files-it-imports map for internal files
-  const fileImports = new Map<string, Set<string>>();
-  for (const edge of importEdges) {
-    if (!fileImports.has(edge.sourceFile)) {
-      fileImports.set(edge.sourceFile, new Set());
-    }
-  }
-
-  // Build a reverse map: file → files that import it
-  const importedBy = new Map<string, Set<string>>();
-  for (const edge of importEdges) {
-    if (!importedBy.has(edge.sourceFile)) {
-      importedBy.set(edge.sourceFile, new Set());
-    }
-    // We track which files import this package, then who imports those files
-  }
-
-  // For transitive: BFS from direct importers outward through reverse import graph
-  // We need: who imports the direct importers (via internal imports)
-  // Build reverse internal-import map from edges where targetPackage looks like a file path
+  // BFS to find transitive importers via reverse import graph
   const reverseImportMap = new Map<string, Set<string>>();
   for (const edge of importEdges) {
     if (!reverseImportMap.has(edge.targetPackage)) {

package/src/analysis/worker-pool.ts

@@ -44,22 +44,23 @@ export class WorkerPool {
         workerData: task.input,
         resourceLimits: { stackSizeMb: this.stackSizeMb },
       });
-      const cleanup = () => {
+      let settled = false;
+      const settle = (fn: () => void) => {
+        if (settled) return;
+        settled = true;
+        fn();
         this._active--;
         this._drain();
       };
       worker.on('message', (v: unknown) => {
-        task.resolve(v);
-        cleanup();
+        settle(() => task.resolve(v));
       });
       worker.on('error', (err: unknown) => {
-        task.reject(err);
-        cleanup();
+        settle(() => task.reject(err));
       });
       worker.on('exit', (code: number) => {
         if (code !== 0) {
-          task.reject(new Error(`Worker exited with code ${code}`));
-          cleanup();
+          settle(() => task.reject(new Error(`Worker exited with code ${code}`)));
         }
       });
     }

package/src/cli/skill-gen.ts

@@ -59,12 +59,8 @@ export async function generateSkillFiles(
 
   const db = openDb(dbPath);
 
-  let communities: CommunityRow[];
   try {
-    communities = queryCommunities(db);
-  } finally {
-    closeDb(db);
-  }
+  const communities = queryCommunities(db);
 
   if (communities.length === 0) {
     return { filesWritten: [], communityCount: 0 };
@@ -75,15 +71,8 @@ export async function generateSkillFiles(
   const filesWritten: string[] = [];
 
   for (const community of communities) {
-    const db2 = openDb(dbPath);
-    let members: MemberRow[];
-    let crossConnections: EdgeRow[];
-    try {
-      members = queryMembers(db2, community.community_id);
-      crossConnections = queryCrossConnections(db2, community.community_id);
-    } finally {
-      closeDb(db2);
-    }
+    const members = queryMembers(db, community.community_id);
+    const crossConnections = queryCrossConnections(db, community.community_id);
 
     const content = renderSkillMarkdown(community, members, crossConnections, repoPath);
 
@@ -94,6 +83,9 @@ export async function generateSkillFiles(
   }
 
   return { filesWritten, communityCount: communities.length };
+  } finally {
+    closeDb(db);
+  }
 }
 
 // ============================================================================

package/src/export/html.ts

@@ -74,6 +74,7 @@ export function toHtml(nodes: MonographNode[], edges: MonographEdge[]): string {
     return {
       id: n.id,
       label: shortLabel,
+      _fullName: n.name,
       title: buildTooltip(n, deg),
       group: n.communityId ?? 0,
       color: {
@@ -398,7 +399,7 @@ function showInfoCard(nodeId) {
   if (!node) return;
   const neighbors = network.getConnectedNodes(nodeId);
   document.getElementById('ic-type').textContent = node._nodeType || '';
-  document.getElementById('ic-name').textContent = node.label;
+  document.getElementById('ic-name').textContent = node._fullName || node.label;
   const fp = node._filePath ? escHtml(node._filePath) : '';
   const fpShort = node._filePath ? escHtml(node._filePath.split('/').pop()) : '';
   document.getElementById('ic-meta').innerHTML =
@@ -420,7 +421,7 @@ function onSearch(q) {
   searchActive = !!q;
   const lq = q.toLowerCase();
   if (!q) { resetHighlight(); return; }
-  const matchIds = new Set(ALL_NODES.filter(n => n.label.toLowerCase().includes(lq) || (n._filePath && n._filePath.toLowerCase().includes(lq))).map(n => n.id));
+  const matchIds = new Set(ALL_NODES.filter(n => (n._fullName || n.label).toLowerCase().includes(lq) || (n._filePath && n._filePath.toLowerCase().includes(lq))).map(n => n.id));
   nodesDS.update(ALL_NODES.map(n => ({ id: n.id, opacity: matchIds.has(n.id) ? 1 : 0.06 })));
   edgesDS.update(ALL_EDGES.map(e => ({ id: e.id, opacity: matchIds.has(e.from) && matchIds.has(e.to) ? 0.7 : 0.03 })));
   // Focus on first match

package/src/graph/regex-search.ts

@@ -25,11 +25,13 @@ export function regexSearchNodes(
 ): RegexNodeMatch[] {
   const re = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
 
+  // Scan all rows and apply regex filter in JS, then cap at limit.
+  // LIMIT in SQL would silently miss matches beyond the first N rows.
   const rows = db.prepare(
     `SELECT id, label, name, norm_label, file_path, start_line, end_line,
             community_id, is_exported, language, properties
-     FROM nodes LIMIT ?`,
-  ).all(limit) as {
+     FROM nodes`,
+  ).all() as {
     id: string;
     label: string;
     name: string;
@@ -69,9 +71,10 @@ export function regexSearchNodes(
 
       if (value && re.test(value)) {
         results.push({ node, field });
-        break; // report once per node even if multiple fields match
+        break;
       }
     }
+    if (results.length >= limit) break;
   }
 
   return results;
@@ -103,8 +106,8 @@ export function regexSearchEdges(
 
   const rows = db.prepare(
     `SELECT id, source_id, target_id, relation, confidence, confidence_score, reason
-     FROM edges LIMIT ?`,
-  ).all(limit) as {
+     FROM edges`,
+  ).all() as {
     id: string;
     source_id: string;
     target_id: string;
@@ -138,6 +141,7 @@ export function regexSearchEdges(
         break;
       }
     }
+    if (results.length >= limit) break;
   }
 
   return results;

package/src/pipeline/phases/call-site-extractors.ts

@@ -0,0 +1,169 @@
+// ── Call site extraction by language ──────────────────────────────────────────
+
+export interface CallSite {
+  callerFileNodeId: string;
+  callerFilePath: string;
+  calleeRaw: string;
+  form: 'method' | 'direct' | 'dynamic';
+  receiverName?: string;
+  methodName?: string;
+}
+
+// ── Language keyword sets ────────────────────────────────────────────────────
+
+const JS_KEYWORDS = new Set([
+  'if', 'for', 'while', 'switch', 'return', 'function', 'class', 'new', 'typeof',
+  'await', 'catch', 'throw', 'delete', 'void', 'instanceof', 'in', 'of',
+  'import', 'export', 'yield', 'async', 'super', 'this', 'const', 'let', 'var',
+  'try', 'finally', 'break', 'continue', 'debugger', 'with', 'do',
+]);
+
+const PY_KEYWORDS = new Set([
+  'if', 'for', 'while', 'with', 'return', 'def', 'class', 'import', 'from',
+  'raise', 'yield', 'lambda', 'await', 'async', 'del', 'pass', 'assert',
+  'except', 'elif', 'else', 'not', 'and', 'or', 'in', 'is', 'print',
+]);
+
+const GO_KEYWORDS = new Set([
+  'if', 'for', 'range', 'return', 'func', 'type', 'var', 'const', 'import', 'package',
+  'go', 'defer', 'select', 'case', 'default', 'break', 'continue', 'goto', 'fallthrough',
+  'chan', 'map', 'struct', 'interface', 'make', 'new', 'len', 'cap', 'append', 'delete',
+  'panic', 'recover', 'close', 'switch', 'else',
+]);
+
+const JAVA_KEYWORDS = new Set([
+  'if', 'for', 'while', 'do', 'switch', 'case', 'return', 'class', 'interface', 'enum',
+  'new', 'extends', 'implements', 'import', 'package', 'throw', 'throws', 'catch', 'try',
+  'finally', 'static', 'final', 'abstract', 'public', 'private', 'protected', 'void',
+  'break', 'continue', 'default', 'else', 'instanceof', 'this', 'super',
+]);
+
+const RUST_KEYWORDS = new Set([
+  'if', 'let', 'for', 'while', 'loop', 'match', 'return', 'fn', 'struct', 'enum', 'trait',
+  'impl', 'use', 'mod', 'pub', 'super', 'self', 'type', 'where', 'in', 'as', 'mut',
+  'ref', 'move', 'async', 'await', 'dyn', 'extern', 'crate', 'static', 'const', 'unsafe',
+  'break', 'continue', 'else',
+]);
+
+// ── Extension sets ───────────────────────────────────────────────────────────
+
+export const TS_JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+export const CJS_MJS_EXTS = new Set(['.cjs', '.mjs']);
+const PY_EXTS = new Set(['.py']);
+const GO_EXTS = new Set(['.go']);
+const JAVA_EXTS = new Set(['.java']);
+const RUST_EXTS = new Set(['.rs']);
+
+export function isSupportedExt(ext: string): boolean {
+  return TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) || JAVA_EXTS.has(ext) || RUST_EXTS.has(ext);
+}
+
+// ── Generic extractor for languages with method.call and direct() patterns ──
+
+function extractSimpleCallSites(
+  source: string,
+  filePath: string,
+  fileNodeId: string,
+  keywords: Set<string>,
+  directCharClass = '[A-Za-z_][\\w]*',
+): CallSite[] {
+  const sites: CallSite[] = [];
+  const methodPattern = /(\w+)\.(\w+)\s*\(/g;
+  let m: RegExpExecArray | null;
+  while ((m = methodPattern.exec(source)) !== null) {
+    sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
+  }
+  const directPattern = new RegExp(`(?<![.[\\w])(${directCharClass})\\s*\\(`, 'g');
+  while ((m = directPattern.exec(source)) !== null) {
+    const name = m[1]!;
+    if (keywords.has(name)) continue;
+    sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct' });
+  }
+  return sites;
+}
+
+export function extractGoCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
+  return extractSimpleCallSites(source, filePath, fileNodeId, GO_KEYWORDS);
+}
+
+export function extractJavaCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
+  return extractSimpleCallSites(source, filePath, fileNodeId, JAVA_KEYWORDS, '[A-Za-z_$][\\w$]*');
+}
+
+export function extractRustCallSites(source: string, filePath: string, fileNodeId: string): CallSite[] {
+  return extractSimpleCallSites(source, filePath, fileNodeId, RUST_KEYWORDS);
+}
+
+// ── Main extractor: dispatches by file extension ─────────────────────────────
+
+export function extractCallSites(
+  source: string,
+  filePath: string,
+  fileNodeId: string,
+  ext: string,
+): CallSite[] {
+  if (GO_EXTS.has(ext)) return extractGoCallSites(source, filePath, fileNodeId);
+  if (JAVA_EXTS.has(ext)) return extractJavaCallSites(source, filePath, fileNodeId);
+  if (RUST_EXTS.has(ext)) return extractRustCallSites(source, filePath, fileNodeId);
+
+  const sites: CallSite[] = [];
+
+  if (TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext)) {
+    const methodPattern = /(\w+)\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
+    let m: RegExpExecArray | null;
+    while ((m = methodPattern.exec(source)) !== null) {
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
+    }
+
+    const chainedPattern = /[)\]]\s*\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
+    while ((m = chainedPattern.exec(source)) !== null) {
+      const name = m[1];
+      if (JS_KEYWORDS.has(name)) continue;
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `?.${name}`, form: 'method', methodName: name });
+    }
+
+    const directPattern = /(?<![.[\w])([A-Za-z_$][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
+    while ((m = directPattern.exec(source)) !== null) {
+      const name = m[1];
+      if (JS_KEYWORDS.has(name)) continue;
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct', methodName: name });
+    }
+
+    const newPattern = /\bnew\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
+    while ((m = newPattern.exec(source)) !== null) {
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `new ${m[1]}`, form: 'direct', methodName: m[1] });
+    }
+
+    const dynamicPattern = /\w+\s*\[[\w'"` ]+\]\s*\(/g;
+    while ((m = dynamicPattern.exec(source)) !== null) {
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: m[0], form: 'dynamic' });
+    }
+  } else if (PY_EXTS.has(ext)) {
+    const methodPattern = /(\w+)\.(\w+)\s*\(/g;
+    let m: RegExpExecArray | null;
+    while ((m = methodPattern.exec(source)) !== null) {
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: `${m[1]}.${m[2]}`, form: 'method', receiverName: m[1], methodName: m[2] });
+    }
+
+    const directPattern = /(?<![.[\w])([A-Za-z_][\w]*)\s*\(/g;
+    while ((m = directPattern.exec(source)) !== null) {
+      const name = m[1];
+      if (PY_KEYWORDS.has(name)) continue;
+      sites.push({ callerFileNodeId: fileNodeId, callerFilePath: filePath, calleeRaw: name, form: 'direct', methodName: name });
+    }
+  }
+
+  return sites;
+}
+
+// ── Constructor assignment tracking ──────────────────────────────────────────
+
+export function extractConstructorAssignments(source: string): Map<string, string> {
+  const result = new Map<string, string>();
+  const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
+  let m: RegExpExecArray | null;
+  while ((m = pattern.exec(source)) !== null) {
+    result.set(m[1], m[2]);
+  }
+  return result;
+}