@monoes/monograph 1.4.0 → 1.5.0

package/src/storage/edge-store.ts

@@ -73,10 +73,17 @@ export function getEdgesForTarget(db: Database.Database, targetId: string): Mono
   return rows.map(rowToEdge);
 }
 
+/**
+ * Delete every edge that touches a node belonging to `filePath`, on either end.
+ * Must be called BEFORE the corresponding nodes are deleted (the subselects need
+ * the file's nodes to still exist to identify which edges to remove) — e.g.
+ * `deleteEdgesForFile` then `deleteNodesForFile`, never the reverse.
+ */
 export function deleteEdgesForFile(db: Database.Database, filePath: string): void {
   db.prepare(`
     DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file_path = ?)
-  `).run(filePath);
+       OR target_id IN (SELECT id FROM nodes WHERE file_path = ?)
+  `).run(filePath, filePath);
 }
 
 export function countEdges(db: Database.Database): number {

package/src/storage/fts-store.ts

@@ -1,5 +1,63 @@
 import type Database from 'better-sqlite3';
 
+// ── Intent-to-identifier extraction ──────────────────────────────────────────
+
+const STOPWORDS = new Set([
+  'a','an','the','is','are','was','were','be','been','being','have','has','had',
+  'do','does','did','will','would','shall','should','may','might','must','can',
+  'could','am','it','its','i','me','my','we','our','you','your','he','she',
+  'they','them','their','this','that','these','those','of','in','to','for',
+  'with','on','at','from','by','about','as','into','through','during','before',
+  'after','above','below','between','out','off','over','under','again','then',
+  'once','here','there','when','where','why','how','all','both','each','every',
+  'few','more','most','other','some','such','no','nor','not','only','own',
+  'same','so','than','too','very','just','because','but','and','or','if',
+  'while','what','which','who','whom','up','down','get','set','add','use',
+  'find','show','make','let','want','need','like','look','also','new','old',
+]);
+
+/**
+ * Extract code-relevant search terms from a natural-language query.
+ * Strips stopwords, splits camelCase/PascalCase/snake_case, and strips
+ * file extensions (so "CLAUDE.md" also tries "CLAUDE").
+ * Returns an empty array when the query is already a bare identifier.
+ */
+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 (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) {
+    const lower = word.toLowerCase();
+    if (STOPWORDS.has(lower)) continue;
+    if (word.length < 3) continue;
+
+    // Strip file extensions: "CLAUDE.md" → also add "CLAUDE"
+    const dotIdx = word.lastIndexOf('.');
+    if (dotIdx > 0 && dotIdx < word.length - 1) {
+      terms.add(word.slice(0, dotIdx));
+      terms.add(word);
+    }
+
+    // Split camelCase/PascalCase: "ExtensionBridge" → "Extension", "Bridge"
+    const camelParts = word.replace(/([a-z])([A-Z])/g, '$1 $2')
+      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+      .split(/[\s_-]+/)
+      .filter(p => p.length >= 3 && !STOPWORDS.has(p.toLowerCase()));
+    if (camelParts.length > 1) {
+      for (const part of camelParts) terms.add(part);
+    }
+
+    // Keep the original word
+    terms.add(word);
+  }
+
+  return Array.from(terms);
+}
+
 export interface FtsResult {
   id: string;
   name: string;
@@ -13,6 +71,20 @@ export interface FtsResult {
   endLine: number | null;
 }
 
+/**
+ * Quote a single FTS5 search term as a string literal when it contains characters
+ * that would otherwise be parsed as FTS5 syntax (quotes, parens, boolean keywords
+ * like AND/OR/NOT, colons, hyphens, etc). Wrapping in double-quotes forces FTS5 to
+ * treat the term as a literal string; any literal `"` inside the term is escaped by
+ * doubling it, per FTS5's own string-literal quoting rules.
+ */
+function quoteFtsTerm(term: string): string {
+  // Bare alphanumeric/underscore terms need no quoting and are the common case.
+  if (/^[A-Za-z0-9_]+$/.test(term)) return term;
+  const escaped = term.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+
 export function ftsSearch(
   db: Database.Database,
   query: string,
@@ -24,8 +96,13 @@ export function ftsSearch(
   const safeQuery = query.replace(/[*]/g, ' ').trim();
   if (!safeQuery) return [];
 
-  // Trigram handles substring matching natively — no need to append * to each term
-  const ftsQuery = safeQuery.split(/\s+/).join(' ');
+  // Trigram handles substring matching natively — no need to append * to each term.
+  // Quote each term individually so characters like `"`, `(`, `)`, or bare boolean
+  // keywords (AND/OR/NOT) don't get parsed as FTS5 query syntax.
+  const ftsQuery = safeQuery
+    .split(/\s+/)
+    .map(quoteFtsTerm)
+    .join(' ');
 
   let matchSql = `
     SELECT n.id, n.name, n.norm_label, n.file_path, n.label,
@@ -52,18 +129,89 @@ export function ftsSearch(
     // FTS MATCH can throw on malformed queries; fall through to LIKE path
   }
 
-  // For short queries (≤2 chars) trigram requires at least 3 characters to fire, so
-  // supplement with a LIKE fallback to catch single/double-character matches.
-  if (safeQuery.length <= 2) {
-    const escapedQuery = safeQuery.replace(/%/g, '\\%').replace(/_/g, '\\_');
+  // ── Intent-extraction fallback: when the raw query looks like natural language
+  // and FTS returned nothing, extract code-relevant tokens and retry FTS. ──────
+  if (matchRows.length === 0) {
+    const extracted = extractSearchTerms(safeQuery);
+    if (extracted.length > 0) {
+      // Try each extracted term individually via FTS, then merge by best rank
+      const termFtsQuery = extracted.map(quoteFtsTerm).join(' OR ');
+      let termSql = `
+        SELECT n.id, n.name, n.norm_label, n.file_path, n.label,
+               n.start_line, n.end_line, nodes_fts.rank
+        FROM nodes_fts
+        JOIN nodes n ON n.rowid = nodes_fts.rowid
+        WHERE nodes_fts MATCH ?
+      `;
+      const termParams: unknown[] = [termFtsQuery];
+      if (label) {
+        termSql += ' AND n.label = ?';
+        termParams.push(label);
+      }
+      termSql += ' ORDER BY nodes_fts.rank LIMIT ?';
+      termParams.push(limit * 2);
+      try {
+        matchRows = db.prepare(termSql).all(...(termParams as [string, ...unknown[]])) as Record<string, unknown>[];
+      } catch { /* FTS MATCH can throw on malformed queries */ }
+
+      // Also try individual LIKE for each extracted term to catch camelCase substrings
+      if (matchRows.length < limit) {
+        const seenIds = new Set(matchRows.map((r) => r.id as string));
+        for (const term of extracted) {
+          if (matchRows.length >= limit) break;
+          const escapedTerm = term.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+          const pat = `%${escapedTerm}%`;
+          let termLikeSql = `
+            SELECT n.id, n.name, n.norm_label, n.file_path, n.label,
+                   n.start_line, n.end_line, 0 AS rank
+            FROM nodes n
+            WHERE (n.name LIKE ? ESCAPE '\\' OR n.norm_label LIKE ? ESCAPE '\\')
+          `;
+          const termLikeParams: unknown[] = [pat, pat];
+          if (label) {
+            termLikeSql += ' AND n.label = ?';
+            termLikeParams.push(label);
+          }
+          termLikeSql += ' LIMIT ?';
+          termLikeParams.push(limit);
+          const likeRows = db.prepare(termLikeSql).all(...(termLikeParams as [string, ...unknown[]])) as Record<string, unknown>[];
+          for (const r of likeRows) {
+            if (!seenIds.has(r.id as string)) {
+              matchRows.push(r);
+              seenIds.add(r.id as string);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Run the LIKE fallback whenever MATCH threw (malformed/boolean-keyword query) or
+  // returned zero rows — not just for short (≤2 char) queries. Short queries need it
+  // because trigram requires ≥3 characters to fire; longer queries need it whenever
+  // MATCH couldn't handle the syntax, so a query-syntax failure doesn't silently read
+  // as "no results".
+  if (safeQuery.length <= 2 || matchRows.length === 0) {
+    const escapedQuery = safeQuery.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
     const likePattern = `%${escapedQuery}%`;
+
+    // Also try without file extension: "CLAUDE.md" → "CLAUDE"
+    const dotIdx = safeQuery.lastIndexOf('.');
+    const strippedLikePattern = (dotIdx > 0 && dotIdx < safeQuery.length - 1)
+      ? `%${safeQuery.slice(0, dotIdx).replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_')}%`
+      : null;
+
     let likeSql = `
       SELECT n.id, n.name, n.norm_label, n.file_path, n.label,
              n.start_line, n.end_line, 0 AS rank
       FROM nodes n
-      WHERE (n.name LIKE ? OR n.norm_label LIKE ? OR n.file_path LIKE ?)
-    `;
+      WHERE (n.name LIKE ? ESCAPE '\\' OR n.norm_label LIKE ? ESCAPE '\\' OR n.file_path LIKE ? ESCAPE '\\'`;
     const likeParams: unknown[] = [likePattern, likePattern, likePattern];
+    if (strippedLikePattern) {
+      likeSql += ` OR n.name LIKE ? ESCAPE '\\'`;
+      likeParams.push(strippedLikePattern);
+    }
+    likeSql += ')';
     if (label) {
       likeSql += ' AND n.label = ?';
       likeParams.push(label);
@@ -186,13 +334,13 @@ export function hybridSearch(
   // ── Strategy 2: LIKE fallback ──────────────────────────────────────────────
   // Always run for short queries (≤3 chars) or when FTS returned nothing.
   if (safeQuery.length <= 3 || ftsRows.length === 0) {
-    const escapedSafeQuery = safeQuery.replace(/%/g, '\\%').replace(/_/g, '\\_');
+    const escapedSafeQuery = safeQuery.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
     const likePattern = `%${escapedSafeQuery}%`;
     let likeSql = `
       SELECT n.id, n.name, n.norm_label, n.file_path, n.label,
              n.start_line, n.end_line
       FROM nodes n
-      WHERE (n.name LIKE ? OR n.norm_label LIKE ?)
+      WHERE (n.name LIKE ? ESCAPE '\\' OR n.norm_label LIKE ? ESCAPE '\\')
     `;
     const likeParams: unknown[] = [likePattern, likePattern];
     if (label) {

package/src/watch/watcher.ts

@@ -34,8 +34,17 @@ export async function watchAsync(
       do {
         rerun = false;
         opts.onProgress?.({ phase: 'watch', message: `Changed: ${files.slice(0, 3).join(', ')}` });
-        await buildAsync(repoPath, { onProgress: opts.onProgress, force: opts.force, codeOnly: opts.codeOnly, llmMaxSections: opts.llmMaxSections ?? 0 });
-        opts.onProgress?.({ phase: 'watch', message: 'Graph rebuilt.' });
+        try {
+          await buildAsync(repoPath, { onProgress: opts.onProgress, force: opts.force, codeOnly: opts.codeOnly, llmMaxSections: opts.llmMaxSections ?? 0 });
+          opts.onProgress?.({ phase: 'watch', message: 'Graph rebuilt.' });
+        } catch (err) {
+          // A rebuild failure (locked DB past busy_timeout, disk full, transient
+          // I/O error) must not crash the watch process — log it, notify listeners,
+          // and keep watching for the next change instead of letting an unhandled
+          // rejection escape this listener.
+          watcher.emit('monograph:error', err);
+          opts.onProgress?.({ phase: 'watch', message: `Rebuild failed: ${err instanceof Error ? err.message : String(err)}` });
+        }
       } while (rerun);
     } finally {
       building = false;

package/tsconfig.json

@@ -3,7 +3,8 @@
   "compilerOptions": {
     "outDir": "dist",
     "rootDir": ".",
-    "composite": true
+    "composite": true,
+    "types": ["node", "better-sqlite3", "express", "micromatch"]
   },
   "include": ["src/**/*.ts"],
   "exclude": ["node_modules", "dist", "__tests__", "src/**/__tests__/**", "src/**/*.test.ts", "src/**/*.spec.ts"]