@codragraph/cli 2.1.5 → 2.1.6

package/dist/core/search/bm25-index.d.ts

@@ -15,7 +15,26 @@ export interface BM25SearchResult {
     score: number;
     rank: number;
     nodeIds?: string[];
+    /** False when results came from the bounded fallback scan instead of FTS. */
+    ftsUsed?: boolean;
 }
+/**
+ * FTS table set served by `searchFTSFromCgdb`. Centralised so that both
+ * the CLI/pipeline path and the MCP pool path stay in lockstep.
+ *
+ * The properties list is computed at FTS-create time via `ftsPropertiesFor`
+ * — for repos that were analysed with `--compress brotli|zstd`, the
+ * `content` column holds base64-of-encoded-bytes and would tokenise to
+ * useless tokens. Those repos get name-only FTS so search at least
+ * matches function/class names instead of returning random hits on
+ * base64 alphabet. Plain (compress='none' / unset) repos get the full
+ * `name + content` index for body-text matches. RFC 0001 Phase 2.5.
+ */
+export declare const FTS_TABLES: ReadonlyArray<{
+    table: string;
+    indexName: string;
+}>;
+export declare const ftsPropertiesFor: (compress: "none" | "brotli" | "zstd" | undefined) => readonly string[];
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *

package/dist/core/search/bm25-index.js

@@ -23,22 +23,21 @@ import { queryFTS, ensureFTSIndex, executeQuery as executeCoreQuery, } from '../
  * base64 alphabet. Plain (compress='none' / unset) repos get the full
  * `name + content` index for body-text matches. RFC 0001 Phase 2.5.
  */
-const FTS_TABLES = [
+export const FTS_TABLES = [
     { table: 'File', indexName: 'file_fts' },
     { table: 'Function', indexName: 'function_fts' },
     { table: 'Class', indexName: 'class_fts' },
     { table: 'Method', indexName: 'method_fts' },
     { table: 'Interface', indexName: 'interface_fts' },
 ];
-const ftsPropertiesFor = (compress) => !compress || compress === 'none' ? ['name', 'content'] : ['name'];
+export const ftsPropertiesFor = (compress) => (!compress || compress === 'none' ? ['name', 'content'] : ['name']);
 /**
- * Look up `meta.compress` for a repo. The MCP path passes `repoId`
- * (registry-derived); the CLI path passes nothing and we walk up from
- * cwd. Returns `'none'` whenever the lookup fails so the safe default
- * (full FTS index) is used — the failure mode is reduced search
- * quality, never wrong results.
+ * Look up query-related index metadata for a repo. The MCP path passes `repoId`
+ * (registry-derived); the CLI/core path passes nothing and we walk up from
+ * cwd. Read-only callers use `ftsReady` to avoid expensive probes for
+ * FTS indexes that older analyses never wrote.
  */
-async function getCompressMode(repoId) {
+async function getSearchMeta(repoId) {
     try {
         const repoMod = await import('../../storage/repo-manager.js');
         if (repoId) {
@@ -50,16 +49,22 @@ async function getCompressMode(repoId) {
                 const base = entry.name.toLowerCase();
                 if (base === repoId || repoId.startsWith(`${base}-`)) {
                     const meta = await repoMod.loadMeta(entry.storagePath);
-                    return meta?.compress ?? 'none';
+                    return {
+                        compress: meta?.compress ?? 'none',
+                        ftsReady: meta?.searchIndexes?.fts === true,
+                    };
                 }
             }
-            return 'none';
+            return { compress: 'none', ftsReady: false };
         }
         const repo = await repoMod.findRepo(process.cwd());
-        return repo?.meta?.compress ?? 'none';
+        return {
+            compress: repo?.meta?.compress ?? 'none',
+            ftsReady: repo?.meta?.searchIndexes?.fts,
+        };
     }
     catch {
-        return 'none';
+        return { compress: 'none', ftsReady: repoId ? false : undefined };
     }
 }
 const FALLBACK_SCAN_LIMIT = 50_000;
@@ -105,6 +110,22 @@ function searchTerms(query) {
         ?.filter((term) => term.length > 1 && !BOOLEAN_QUERY_TOKENS.has(term));
     return [...new Set(terms ?? [])];
 }
+function searchTermVariants(query) {
+    const rawTerms = query.match(/[\p{L}\p{N}_]+/gu) ?? [];
+    const variants = new Set();
+    for (const raw of rawTerms) {
+        const lower = raw.toLowerCase();
+        if (raw.length <= 1 || BOOLEAN_QUERY_TOKENS.has(lower))
+            continue;
+        variants.add(raw);
+        variants.add(lower);
+        variants.add(raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase());
+    }
+    return [...variants];
+}
+function cypherString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "''")}'`;
+}
 function scoreFallbackNode(node, query, properties) {
     const terms = searchTerms(query);
     if (terms.length === 0)
@@ -131,10 +152,15 @@ function scoreFallbackNode(node, query, properties) {
 }
 async function queryFallbackViaExecutor(executor, tableName, properties, query, limit) {
     try {
+        const variants = searchTermVariants(query);
+        const conditions = variants.flatMap((term) => properties.map((property) => `node.${property} CONTAINS ${cypherString(term)}`));
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' OR ')}` : '';
+        const candidateLimit = Math.min(FALLBACK_SCAN_LIMIT, Math.max(limit * 25, 200));
         const rows = await executor(`
       MATCH (node:${tableName})
+      ${whereClause}
       RETURN node
-      LIMIT ${FALLBACK_SCAN_LIMIT}
+      LIMIT ${candidateLimit}
     `);
         return rows
             .map((row) => {
@@ -158,10 +184,7 @@ async function fallbackSearchAllTables(executor, query, limit,
 // pre-Phase-2 behaviour (`['name', 'content']`) for callers that don't
 // pass a value.
 properties = ['name', 'content']) {
-    const results = [];
-    for (const { table } of FTS_TABLES) {
-        results.push(await queryFallbackViaExecutor(executor, table, properties, query, limit));
-    }
+    const results = await Promise.all(FTS_TABLES.map(({ table }) => queryFallbackViaExecutor(executor, table, properties, query, limit)));
     return results;
 }
 /**
@@ -179,6 +202,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
     if (!query.trim() || limit <= 0)
         return [];
     let fileResults, functionResults, classResults, methodResults, interfaceResults;
+    let usedFallback = false;
     if (repoId) {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
@@ -188,34 +212,46 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
         const executor = (cypher) => executeQuery(repoId, cypher);
         // The MCP/LocalBackend pool is opened read-only so it can safely coexist
         // with `codragraph analyze`. Do not issue CREATE_FTS_INDEX here: when
-        // persisted FTS indexes are missing, QUERY_FTS_INDEX falls through to the
-        // bounded BM25 fallback below without noisy write-failure retries.
+        // persisted FTS indexes are missing, meta.searchIndexes lets us skip
+        // QUERY_FTS_INDEX and go straight to the bounded fallback below.
         // RFC 0001 Phase 2.5: drop `content` from fallback scoring for repos
         // analysed with --compress brotli|zstd — the column holds encoded bytes.
-        const compress = await getCompressMode(repoId);
-        const properties = ftsPropertiesFor(compress);
-        fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
-        functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
-        classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
-        methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit);
-        interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
+        const meta = await getSearchMeta(repoId);
+        const properties = ftsPropertiesFor(meta.compress);
+        if (meta.ftsReady) {
+            fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
+            functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
+            classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
+            methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit);
+            interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
+        }
+        else {
+            usedFallback = true;
+            fileResults = [];
+            functionResults = [];
+            classResults = [];
+            methodResults = [];
+            interfaceResults = [];
+        }
         if (fileResults.length +
             functionResults.length +
             classResults.length +
             methodResults.length +
             interfaceResults.length ===
             0) {
+            usedFallback = true;
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
                 await fallbackSearchAllTables(executor, query, limit, properties);
         }
     }
     else {
         // Use core cgdb adapter (CLI / pipeline context) — also sequential for safety.
-        // Lazy-create FTS indexes on first query (analyze no longer does it).
+        // Defensive fallback for older indexes or direct core callers: create FTS
+        // indexes on first query when this process owns a writable connection.
         // RFC 0001 Phase 2.5 — same `compress`-aware property selection as the MCP
         // path; the CLI walks up from cwd to find the repo's meta.json.
-        const compress = await getCompressMode();
-        const properties = ftsPropertiesFor(compress);
+        const meta = await getSearchMeta();
+        const properties = ftsPropertiesFor(meta.compress);
         for (const { table, indexName } of FTS_TABLES) {
             await ensureFTSIndex(table, indexName, [...properties]).catch(() => { });
         }
@@ -230,6 +266,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
             methodResults.length +
             interfaceResults.length ===
             0) {
+            usedFallback = true;
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
                 await fallbackSearchAllTables(executeCoreQuery, query, limit, properties);
         }
@@ -258,6 +295,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
             filePath,
             score: top3.reduce((acc, e) => acc + e.score, 0),
             nodeIds: top3.map((e) => e.nodeId).filter((id) => id),
+            ftsUsed: !usedFallback,
         });
     }
     // Sort by score descending and add rank
@@ -269,5 +307,6 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
         score: r.score,
         rank: index + 1,
         nodeIds: r.nodeIds,
+        ftsUsed: r.ftsUsed,
     }));
 };

package/dist/mcp/local/local-backend.js

@@ -2107,10 +2107,12 @@ export class LocalBackend {
                 queryParams[`hunkEnd${i}`] = hunk.endLine;
             });
             const symbolQuery = `
-        MATCH (n) WHERE n.filePath ENDS WITH $filePath
+        MATCH (f:File)-[r:CodeRelation]->(n)
+        WHERE r.type IN ['DEFINES', 'CONTAINS']
+          AND f.filePath ENDS WITH $filePath
           AND n.startLine IS NOT NULL AND n.endLine IS NOT NULL
           AND (${overlapConditions})
-        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type,
+        RETURN n.id AS id, n.name AS name, '' AS type,
                n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine
       `;
             try {
@@ -2119,7 +2121,8 @@ export class LocalBackend {
                     changedSymbols.push({
                         id: sym.id || sym[0],
                         name: sym.name || sym[1],
-                        type: sym.type || sym[2],
+                        type: safeNodeLabelForCypher(sym.type, sym.id || sym[0]) ??
+                            firstNonEmptyString(sym.type, sym.__cgLabel, sym[2]),
                         filePath: sym.filePath || sym[3],
                         change_type: 'touched',
                     });

package/dist/storage/repo-manager.d.ts

@@ -83,6 +83,35 @@ export interface RepoMeta {
      * — they decode at the read boundary.
      */
     compress?: 'none' | 'brotli' | 'zstd';
+    /**
+     * Query-time index capabilities written by analyze after optional search
+     * indexes are successfully created. Read-only MCP/CLI query paths use this
+     * to avoid expensive probes for indexes that older analyses never wrote.
+     */
+    searchIndexes?: {
+        fts?: boolean;
+    };
+    /**
+     * Runtime policy chosen by `analyze --profile auto|lean|balanced|power`.
+     * This is diagnostic metadata only; readers must not require it because
+     * older indexes do not have a policy record.
+     */
+    adaptiveProfile?: {
+        requested?: 'auto' | 'lean' | 'balanced' | 'power';
+        resolved?: 'lean' | 'balanced' | 'power';
+        platform?: NodeJS.Platform;
+        arch?: NodeJS.Architecture;
+        cpuCount?: number;
+        totalMemoryBytes?: number;
+        heapLimitBytes?: number;
+        compression?: 'none' | 'brotli' | 'zstd';
+        embeddingMode?: 'auto' | 'off' | 'on';
+        embeddingNodeLimit?: number;
+        embeddingDecision?: 'enabled' | 'skipped';
+        embeddingReason?: string;
+        workerPoolSize?: number;
+        workerSubBatchSize?: number;
+    };
     /**
      * Canonical `origin` remote URL captured at index time. Used to
      * fingerprint the same logical repo across multiple on-disk clones

package/dist/web/assets/__vite-browser-external-BIHI7g3E.js

@@ -0,0 +1 @@
+const e={};export{e as default};