@monoes/monograph 1.2.10 → 1.3.0

package/src/pipeline/orchestrator.ts

@@ -47,8 +47,10 @@ export interface BuildOptions extends Partial<PipelineOptions> {
 // ad-hoc lock file that the others don't know about — concurrent builds then fail
 // with "database is locked". Serialize here, the one place all builders pass through.
 async function acquireBuildLock(dbPath: string): Promise<(() => void) | null> {
-  const { writeFileSync, readFileSync, statSync, unlinkSync } = await import('fs');
+  const { writeFileSync, readFileSync, statSync, unlinkSync, mkdirSync } = await import('fs');
+  const { dirname } = await import('path');
   const lockPath = dbPath + '.build-lock';
+  mkdirSync(dirname(lockPath), { recursive: true });
   const tryAcquire = (): boolean => {
     try { writeFileSync(lockPath, String(process.pid), { flag: 'wx' }); return true; }
     catch { return false; }
@@ -130,46 +132,42 @@ async function buildAsyncLocked(
 
     const outputs = await runner.run(ctx);
 
-    // Every full build reuses the same DB in place (no truncate-on-open), and no
-    // phase ever deletes nodes for files that were renamed/deleted since the last
-    // build. Left unchecked, orphaned rows (and their FTS/edge fallout) accumulate
-    // forever across repeated rebuilds. Sweep them here, once, after scan knows the
-    // authoritative current file set.
-    const scanOut = outputs.get('scan') as { filePaths: string[] } | undefined;
-    if (scanOut) {
-      const liveFiles = new Set(scanOut.filePaths.map((f) => resolve(f)));
-      const staleFiles = (
-        db.prepare('SELECT DISTINCT file_path FROM nodes WHERE file_path IS NOT NULL').all() as { file_path: string }[]
-      )
-        .map((r) => r.file_path)
-        .filter((f) => !liveFiles.has(resolve(ctx.repoPath, f)));
-      if (staleFiles.length > 0) {
-        const deleteStale = db.transaction((files: string[]) => {
-          // Edges FK-reference nodes with no ON DELETE CASCADE, and a stale node
-          // can be referenced from either side (another file's export pointing at
-          // it, or it importing another file) — clear both directions first.
-          const deleteEdges = db.prepare(`
-            DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file_path = ?)
-               OR target_id IN (SELECT id FROM nodes WHERE file_path = ?)
-          `);
-          const deleteNodesStmt = db.prepare('DELETE FROM nodes WHERE file_path = ?');
-          for (const f of files) {
-            deleteEdges.run(f, f);
-            deleteNodesStmt.run(f);
-          }
-        });
-        deleteStale(staleFiles);
+    // Skip post-pipeline work when all files were cached (nothing changed)
+    if (!ctx.allFilesCached) {
+      // Sweep orphaned rows for files that were renamed/deleted since the last build.
+      const scanOut = outputs.get('scan') as { filePaths: string[] } | undefined;
+      if (scanOut) {
+        const liveFiles = new Set(scanOut.filePaths.map((f) => resolve(f)));
+        const staleFiles = (
+          db.prepare('SELECT DISTINCT file_path FROM nodes WHERE file_path IS NOT NULL').all() as { file_path: string }[]
+        )
+          .map((r) => r.file_path)
+          .filter((f) => !liveFiles.has(resolve(ctx.repoPath, f)));
+        if (staleFiles.length > 0) {
+          const deleteStale = db.transaction((files: string[]) => {
+            const deleteEdges = db.prepare(`
+              DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file_path = ?)
+                 OR target_id IN (SELECT id FROM nodes WHERE file_path = ?)
+            `);
+            const deleteNodesStmt = db.prepare('DELETE FROM nodes WHERE file_path = ?');
+            for (const f of files) {
+              deleteEdges.run(f, f);
+              deleteNodesStmt.run(f);
+            }
+          });
+          deleteStale(staleFiles);
+        }
       }
+
+      const suggestOut = outputs.get('suggest') as { questions: SuggestedQuestion[] } | undefined;
+      const questions = suggestOut?.questions ?? [];
+      await generateGraphReport(resolve(repoPath), undefined, dbPath, questions);
     }
 
     const hash = getCurrentCommitHash(resolve(repoPath));
     if (hash) {
       db.prepare("INSERT OR REPLACE INTO index_meta VALUES ('last_commit_hash', ?)").run(hash);
     }
-
-    const suggestOut = outputs.get('suggest') as { questions: SuggestedQuestion[] } | undefined;
-    const questions = suggestOut?.questions ?? [];
-    await generateGraphReport(resolve(repoPath), undefined, dbPath, questions);
   } finally {
     closeDb(db);
   }

package/src/pipeline/phases/communities.ts

@@ -108,6 +108,9 @@ export const communitiesPhase: PipelinePhase<CommunitiesOutput> = {
   name: 'communities',
   deps: ['parse', 'cross-file', 'mro'],
   async execute(ctx, deps) {
+    if (ctx.allFilesCached) {
+      return { memberships: new Map(), communityLabels: new Map(), cohesionScores: new Map() };
+    }
     const { resolvedEdges } = deps.get('cross-file') as CrossFileOutput;
     const { allEdges } = deps.get('parse') as ParseOutput;
     const allUsedEdges: MonographEdge[] = [...allEdges, ...resolvedEdges];

package/src/pipeline/phases/cross-file.ts

@@ -1,5 +1,5 @@
-import type { PipelinePhase, PipelineContext } from '../types.js';
-import type { MonographEdge, MonographNode } from '../../types.js';
+import type { PipelinePhase } from '../types.js';
+import type { MonographEdge } from '../../types.js';
 import { makeId, CONFIDENCE_SCORE } from '../../types.js';
 import { insertEdges } from '../../storage/edge-store.js';
 import type { ParseOutput } from './parse.js';
@@ -9,41 +9,26 @@ export interface CrossFileOutput {
   resolvedEdges: MonographEdge[];
 }
 
+// monolean: IMPORTS name-matching removed — it matched import names against a
+// global symbol index (e.g. `import fs` → random Variable named `fs` in wrong file).
+// scope-resolution.ts now handles cross-file CALLS via source-parsed import maps.
 export const crossFilePhase: PipelinePhase<CrossFileOutput> = {
   name: 'cross-file',
   deps: ['parse', 'structure'],
   async execute(_ctx, deps) {
-    const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
+    const { allEdges } = deps.get('parse') as ParseOutput;
     const { fileNodes } = deps.get('structure') as StructureOutput;
 
-    /** Extract the last path segment of a '/'-separated string (faster than split+pop). */
     function lastSegment(s: string): string {
       const idx = s.lastIndexOf('/');
       return idx === -1 ? s : s.slice(idx + 1);
     }
 
-    /** Strip leading `import_` prefix, then return the last path segment. */
     function targetBasename(rawId: string): string {
       const stripped = rawId.startsWith('import_') ? rawId.slice(7) : rawId;
       return lastSegment(stripped);
     }
 
-    // Symbol name → symbol node ID.
-    // Pre-key lowercase variants so IMPORTS resolution is a single Map.get() instead of two.
-    const nameIndex = new Map<string, string>();
-    for (const node of symbolNodes) {
-      nameIndex.set(node.name, node.id);
-      const lower = node.name.toLowerCase();
-      if (lower !== node.name) nameIndex.set(lower, node.id);
-      if (node.normLabel) {
-        nameIndex.set(node.normLabel, node.id);
-        const normLower = node.normLabel.toLowerCase();
-        if (normLower !== node.normLabel) nameIndex.set(normLower, node.id);
-      }
-    }
-
-    // Basename (without extension) → File node ID, for resolving RE_EXPORTS.
-    // Use lastIndexOf to avoid allocating a full split array per file path.
     const fileBasenameIndex = new Map<string, string>();
     for (const fileNode of fileNodes) {
       const basename = lastSegment(fileNode.filePath ?? '').toLowerCase();
@@ -56,22 +41,7 @@ export const crossFilePhase: PipelinePhase<CrossFileOutput> = {
     const resolvedEdges: MonographEdge[] = [];
 
     for (const edge of allEdges) {
-      if (edge.relation === 'IMPORTS') {
-        const targetName = targetBasename(edge.targetId);
-        // Single lookup — lowercase variants are pre-keyed in nameIndex
-        const resolvedId = nameIndex.get(targetName) ?? nameIndex.get(targetName.toLowerCase());
-
-        if (resolvedId && resolvedId !== edge.targetId) {
-          resolvedEdges.push({
-            ...edge,
-            id: makeId(edge.sourceId, resolvedId, 'resolved'),
-            targetId: resolvedId,
-            confidence: 'INFERRED',
-            confidenceScore: CONFIDENCE_SCORE.INFERRED,
-          });
-        }
-      } else if (edge.relation === 'RE_EXPORTS') {
-        // Resolve to a File node ID using the pre-built basename index
+      if (edge.relation === 'RE_EXPORTS') {
         const basename = targetBasename(edge.targetId).toLowerCase();
         const dotIdx = basename.lastIndexOf('.');
         const noExt = dotIdx === -1 ? basename : basename.slice(0, dotIdx);

package/src/pipeline/phases/orm.ts

@@ -77,6 +77,7 @@ export const ormPhase: PipelinePhase<OrmOutput> = {
   name: 'orm',
   deps: ['parse', 'structure'],
   async execute(ctx, deps) {
+    if (ctx.allFilesCached) return { entities: [], entityNodes: [], fieldNodes: [], hasFieldEdges: [] };
     const { fileNodes } = deps.get('structure') as StructureOutput;
     const entities: EntityDef[] = [];
     const entityNodes: MonographNode[] = [];