@monoes/monograph 1.5.0 → 1.5.2

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

@@ -32,7 +32,11 @@ export const wildcardSynthesisPhase: PipelinePhase<WildcardSynthesisOutput> = {
     `);
 
     for (const [filePath, source] of fileContents) {
-      const fileNodeId = fileNodeIndex.get(filePath) ?? `file:${filePath}`;
+      const fileNodeId = fileNodeIndex.get(filePath);
+      // No real node for this file (e.g. no parsed symbols) — there's no
+      // valid row to attach a source_id to, and fabricating one violates the
+      // edges table's FOREIGN KEY constraint on source_id (issue #40).
+      if (!fileNodeId) continue;
       const { synthesizedEdges } = synthesizeWildcardImports(fileNodeId, source, allKnownNodes, allKnownEdges);
 
       for (const edge of synthesizedEdges) {

package/src/search/hybrid-query.ts

@@ -48,7 +48,7 @@ export async function hybridQuery(
   const normalizedQuery = normalizeSearchTerm(query);
 
   // ── BM25 via FTS5 ──────────────────────────────────────────────────────────
-  const bm25Limit = 50;
+  const bm25Limit = Math.max(limit, 50);
   const bm25Raw = ftsSearch(db, normalizedQuery, bm25Limit, label);
   const bm25Results: RankedResult[] = bm25Raw.map((r) => ({
     id: r.id,

package/src/storage/fts-store.ts

@@ -24,10 +24,14 @@ const STOPWORDS = new Set([
  */
 export function extractSearchTerms(query: string): string[] {
   const words = query.split(/[\s,;:!?()\[\]{}'"]+/).filter(Boolean);
-  // If query is a single token or all tokens are code-like, it's already an identifier query
+  // If query is a single token, it's already a bare identifier query — nothing to extract.
+  // (We used to also bail out for short, stopword-free multi-token queries under the
+  // assumption they were "already an identifier query", but that misfires for queries
+  // like "ExtensionBridge keepalive reconnect" — three distinct identifier-ish tokens
+  // that FTS5 MATCH ANDs together and fails to find as a single row. Since this function
+  // only runs as a fallback after the raw MATCH already returned zero rows, there's no
+  // extra cost to always extracting terms for multi-token queries.)
   if (words.length <= 1) return [];
-  const hasStopword = words.some(w => STOPWORDS.has(w.toLowerCase()));
-  if (!hasStopword && words.length <= 3) return [];
 
   const terms = new Set<string>();
   for (const word of words) {

package/src/watch/watcher.ts

@@ -13,6 +13,8 @@ export interface WatchAsyncOptions extends WatcherOptions {
   force?: boolean;
   codeOnly?: boolean;
   llmMaxSections?: number;
+  /** Auto-stop after this many ms of no file changes. Default 30min. 0 = never. */
+  idleTimeoutMs?: number;
 }
 
 /** Convenience: start a watcher and trigger buildAsync on every change. Returns stop() fn. */
@@ -23,11 +25,25 @@ export async function watchAsync(
   const { buildAsync } = await import('../pipeline/orchestrator.js');
   const watcher = new MonographWatcher(repoPath, { debounceMs: opts.debounceMs ?? 3000 });
 
+  // Idle timeout: auto-stop after prolonged inactivity to reclaim resources.
+  const idleMs = opts.idleTimeoutMs ?? 30 * 60_000; // default 30min
+  let idleTimer: ReturnType<typeof setTimeout> | null = null;
+  const resetIdle = (): void => {
+    if (idleMs <= 0) return;
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      opts.onProgress?.({ phase: 'watch', message: `No changes for ${Math.round(idleMs / 60_000)}min — auto-stopping watcher.` });
+      watcher.stop().catch(() => {});
+    }, idleMs);
+    (idleTimer as { unref?: () => void }).unref?.();
+  };
+
   // monolean: full rebuild per change-batch, serialized — true incremental rebuild
   // (re-parse only changed files) requires restructuring the phase pipeline.
   let building = false;
   let rerun = false;
   watcher.on('monograph:updated', async (files: string[]) => {
+    resetIdle();
     if (building) { rerun = true; return; } // coalesce saves that land mid-build
     building = true;
     try {
@@ -52,7 +68,13 @@ export async function watchAsync(
   });
 
   await watcher.start();
-  return { stop: () => watcher.stop() };
+  resetIdle(); // start the idle clock
+  return {
+    stop: async () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      await watcher.stop();
+    },
+  };
 }
 
 export class MonographWatcher extends EventEmitter {

package/src/web/api.ts

@@ -95,23 +95,27 @@ export function queryGraphData(db: Database.Database): GraphData {
 
   const edges: ApiEdge[] = [];
   if (nodeIds.size > 0) {
-    // Scan edges and keep those where at least one endpoint is a visible node
+    // Use a temp table so SQLite filters edges instead of scanning full table in JS
+    db.exec('CREATE TEMP TABLE IF NOT EXISTS _vis_nodes (id TEXT PRIMARY KEY)');
+    db.exec('DELETE FROM _vis_nodes');
+    const insertVis = db.prepare('INSERT OR IGNORE INTO _vis_nodes (id) VALUES (?)');
+    const insertAll = db.transaction((ids: string[]) => { for (const id of ids) insertVis.run(id); });
+    insertAll([...nodeIds]);
+
     const edgeRows = db
-      .prepare('SELECT source_id, target_id, relation, confidence_score FROM edges')
+      .prepare(`SELECT e.source_id, e.target_id, e.relation, e.confidence_score FROM edges e
+        JOIN _vis_nodes s ON e.source_id = s.id
+        JOIN _vis_nodes t ON e.target_id = t.id
+        LIMIT 10000`)
       .all() as Record<string, unknown>[];
 
     for (const r of edgeRows) {
-      const src = r['source_id'] as string;
-      const tgt = r['target_id'] as string;
-      if (nodeIds.has(src) && nodeIds.has(tgt)) {
-        edges.push({
-          sourceId: src,
-          targetId: tgt,
-          relation: r['relation'] as string,
-          confidenceScore: r['confidence_score'] as number,
-        });
-        if (edges.length >= 10000) break;
-      }
+      edges.push({
+        sourceId: r['source_id'] as string,
+        targetId: r['target_id'] as string,
+        relation: r['relation'] as string,
+        confidenceScore: r['confidence_score'] as number,
+      });
     }
   }