@codragraph/cli 2.1.4 → 2.1.6

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

@@ -79,6 +79,105 @@ export const VALID_NODE_LABELS = new Set([
     'Route',
     'Tool',
 ]);
+const SIMPLE_LABELLESS_MATCH_RE = /^MATCH\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/i;
+const CYPHER_LIMIT_RE = /\bLIMIT\s+(\d+)\s*;?\s*$/i;
+const CYPHER_RELATION_RE = /--|-\[|\]-|->|<-/;
+const NATIVE_UNSAFE_NODE_LABELS = new Set(['Union']);
+function quoteKnownNodeLabels(query) {
+    return query;
+}
+function getNativeUnsafeNodeLabel(query) {
+    const labelRe = /\(\s*[A-Za-z_][A-Za-z0-9_]*\s*:\s*`?([A-Za-z_][A-Za-z0-9_]*)`?(?=[\s){])/g;
+    for (const match of query.matchAll(labelRe)) {
+        const label = match[1];
+        if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+            return label;
+    }
+    return null;
+}
+function safeNodeLabelForCypher(typeOrLabel, nodeId) {
+    const explicit = typeof typeOrLabel === 'string' ? typeOrLabel.trim() : '';
+    if (explicit && VALID_NODE_LABELS.has(explicit) && !NATIVE_UNSAFE_NODE_LABELS.has(explicit)) {
+        return explicit;
+    }
+    const id = typeof nodeId === 'string' ? nodeId : '';
+    const fromId = id.includes(':') ? id.slice(0, id.indexOf(':')) : '';
+    if (fromId && VALID_NODE_LABELS.has(fromId) && !NATIVE_UNSAFE_NODE_LABELS.has(fromId)) {
+        return fromId;
+    }
+    return null;
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value.trim();
+    }
+    return '';
+}
+function parseSimpleNodeScanQuery(query) {
+    const match = /^MATCH\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)(?:\s*:\s*`?([A-Za-z_][A-Za-z0-9_]*)`?)?\s*\)\s*RETURN\s+(.+?)\s+LIMIT\s+(\d+)\s*;?\s*$/i.exec(query.trim());
+    if (!match)
+        return null;
+    const limit = Number.parseInt(match[4], 10);
+    if (!Number.isFinite(limit) || limit <= 0)
+        return null;
+    return {
+        alias: match[1],
+        label: match[2],
+        returnClause: match[3].trim(),
+        limit: Math.min(Math.trunc(limit), 1000),
+    };
+}
+function projectSimpleNodeRow(node, label, scan) {
+    const row = {};
+    const parts = scan.returnClause.split(/\s*,\s*/).filter(Boolean);
+    for (const part of parts) {
+        const asMatch = /^(.+?)\s+AS\s+([A-Za-z_][A-Za-z0-9_]*)$/i.exec(part.trim());
+        const expr = (asMatch?.[1] ?? part).trim();
+        const outKey = asMatch?.[2] ?? expr;
+        if (expr === scan.alias) {
+            row[outKey] = { ...node, _label: label };
+            continue;
+        }
+        const labelsMatch = new RegExp(`^labels\\(\\s*${scan.alias}\\s*\\)\\[0\\]$`, 'i').exec(expr);
+        if (labelsMatch) {
+            row[outKey] = label;
+            continue;
+        }
+        const propMatch = new RegExp(`^${scan.alias}\\.([A-Za-z_][A-Za-z0-9_]*)$`).exec(expr);
+        if (propMatch) {
+            row[outKey] = node[propMatch[1]];
+            continue;
+        }
+        return null;
+    }
+    return row;
+}
+function getSimpleLabellessNodeAlias(query) {
+    const trimmed = query.trim();
+    const match = SIMPLE_LABELLESS_MATCH_RE.exec(trimmed);
+    if (!match)
+        return null;
+    if (CYPHER_RELATION_RE.test(trimmed))
+        return null;
+    if (/\bMATCH\b/i.test(trimmed.slice(match[0].length)))
+        return null;
+    return match[1];
+}
+function getCypherLimit(query) {
+    const match = CYPHER_LIMIT_RE.exec(query);
+    if (!match)
+        return null;
+    const limit = Number.parseInt(match[1], 10);
+    return Number.isFinite(limit) && limit > 0 ? limit : null;
+}
+function withCypherLimit(query, limit) {
+    const safeLimit = Math.max(1, Math.trunc(limit));
+    if (CYPHER_LIMIT_RE.test(query)) {
+        return query.replace(CYPHER_LIMIT_RE, `LIMIT ${safeLimit}`);
+    }
+    return `${query.replace(/;\s*$/, '')} LIMIT ${safeLimit}`;
+}
 /** Valid relation types for impact analysis filtering */
 export const VALID_RELATION_TYPES = new Set([
     'CALLS',
@@ -1173,25 +1272,119 @@ export class LocalBackend {
         const repo = await this.resolveRepo(repoName);
         return this.cypher(repo, { query });
     }
-    async cypher(repo, params) {
-        await this.ensureInitialized(repo.id);
-        if (!isCgdbReady(repo.id)) {
-            return { error: 'LadybugDB not ready. Index may be corrupted.' };
+    async trySimpleGraphstoreNodeScan(repo, query) {
+        const scan = parseSimpleNodeScanQuery(query);
+        if (!scan)
+            return null;
+        if (scan.label && NATIVE_UNSAFE_NODE_LABELS.has(scan.label))
+            return [];
+        const objectsRoot = path.join(repo.storagePath, 'graphstore', 'objects');
+        try {
+            const stat = await fs.stat(objectsRoot);
+            if (!stat.isDirectory())
+                return null;
         }
+        catch {
+            return null;
+        }
+        const rows = [];
+        const visitDir = async (dir) => {
+            if (rows.length >= scan.limit)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (rows.length >= scan.limit)
+                    return;
+                const entryPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await visitDir(entryPath);
+                    continue;
+                }
+                if (!entry.isFile() || !entry.name.endsWith('.json'))
+                    continue;
+                try {
+                    const raw = await fs.readFile(entryPath, 'utf-8');
+                    const obj = JSON.parse(raw);
+                    const id = typeof obj.id === 'string' ? obj.id : '';
+                    if (!id || typeof obj.from === 'string' || typeof obj.to === 'string')
+                        continue;
+                    const label = id.includes(':') ? id.slice(0, id.indexOf(':')) : '';
+                    if (!label || (scan.label && label !== scan.label))
+                        continue;
+                    if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+                        continue;
+                    const row = projectSimpleNodeRow(obj, label, scan);
+                    if (row)
+                        rows.push(row);
+                }
+                catch {
+                    // Ignore malformed graphstore objects; the native path remains available.
+                }
+            }
+        };
+        await visitDir(objectsRoot);
+        return rows;
+    }
+    async cypher(repo, params) {
         // Block write operations (defense-in-depth — DB is already read-only)
         if (isWriteQuery(params.query)) {
             return {
                 error: 'Write operations (CREATE, DELETE, SET, MERGE, REMOVE, DROP, ALTER, COPY, DETACH) are not allowed. The knowledge graph is read-only.',
             };
         }
+        const query = quoteKnownNodeLabels(params.query);
+        const unsafeLabel = getNativeUnsafeNodeLabel(query);
+        if (unsafeLabel) {
+            return [];
+        }
+        const graphstoreRows = await this.trySimpleGraphstoreNodeScan(repo, query);
+        if (graphstoreRows) {
+            return graphstoreRows;
+        }
+        await this.ensureInitialized(repo.id);
+        if (!isCgdbReady(repo.id)) {
+            return { error: 'LadybugDB not ready. Index may be corrupted.' };
+        }
+        const labellessAlias = getSimpleLabellessNodeAlias(query);
         try {
-            const result = await executeQuery(repo.id, params.query);
+            const result = labellessAlias
+                ? await this.executeLabellessNodeScan(repo.id, query, labellessAlias)
+                : await executeQuery(repo.id, query);
             return result;
         }
         catch (err) {
             return { error: err.message || 'Query failed' };
         }
     }
+    async executeLabellessNodeScan(repoId, query, alias) {
+        const limit = getCypherLimit(query) ?? 100;
+        const rows = [];
+        let lastError = null;
+        for (const label of VALID_NODE_LABELS) {
+            if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+                continue;
+            if (rows.length >= limit)
+                break;
+            const labelQuery = withCypherLimit(query.replace(SIMPLE_LABELLESS_MATCH_RE, `MATCH (${alias}:\`${label}\`)`), limit - rows.length);
+            try {
+                const labelRows = await executeQuery(repoId, labelQuery);
+                rows.push(...labelRows);
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        if (rows.length === 0 && lastError) {
+            throw lastError;
+        }
+        return rows.slice(0, limit);
+    }
     /**
      * Format raw Cypher result rows as a markdown table for LLM readability.
      * Falls back to raw result if rows aren't tabular objects.
@@ -1436,7 +1629,7 @@ export class LocalBackend {
             const symbol = {
                 id: (r.id ?? r[0]),
                 name: (r.name ?? r[1]),
-                type: (r.type ?? r[2] ?? ''),
+                type: firstNonEmptyString(r.type, r.__cgLabel, r[2]),
                 filePath: (r.filePath ?? r[3]),
                 startLine: (r.startLine ?? r[4]),
                 endLine: (r.endLine ?? r[5]),
@@ -1476,7 +1669,7 @@ export class LocalBackend {
         const normalized = rows.map((r) => ({
             id: (r.id ?? r[0]),
             name: (r.name ?? r[1]),
-            type: (r.type ?? r[2] ?? ''),
+            type: firstNonEmptyString(r.type, r.__cgLabel, r[2]),
             filePath: (r.filePath ?? r[3]),
             startLine: (r.startLine ?? r[4]),
             endLine: (r.endLine ?? r[5]),
@@ -1914,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 {
@@ -1926,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',
                     });
@@ -2266,6 +2462,10 @@ export class LocalBackend {
         const impacted = [];
         const visited = new Set([symId]);
         let frontier = [symId];
+        const frontierTypes = new Map();
+        const symLabel = safeNodeLabelForCypher(symType, symId);
+        if (symLabel)
+            frontierTypes.set(symId, symLabel);
         let traversalComplete = true;
         // Fix #480: For Java (and other JVM) Class/Interface nodes, CALLS edges
         // point to Constructor nodes and IMPORTS edges point to File nodes — not
@@ -2279,16 +2479,16 @@ export class LocalBackend {
                 // Run both seed queries in parallel — they are independent.
                 const [ctorRows, fileRows] = await Promise.all([
                     executeParameterized(repo.id, `
-            MATCH (n)-[hm:CodeRelation]->(c:Constructor)
+            MATCH (n:${symLabel ?? symType})-[hm:CodeRelation]->(c:Constructor)
             WHERE n.id = $symId AND hm.type = 'HAS_METHOD'
-            RETURN c.id AS id, c.name AS name, labels(c)[0] AS type, c.filePath AS filePath
+            RETURN c.id AS id, c.name AS name, 'Constructor' AS type, c.filePath AS filePath
           `, { symId }),
                     // Restrict to DEFINES edges only — other File->Class edge types (if
                     // any) should not be treated as the owning file relationship.
                     executeParameterized(repo.id, `
-            MATCH (f:File)-[rel:CodeRelation]->(n)
+            MATCH (f:File)-[rel:CodeRelation]->(n:${symLabel ?? symType})
             WHERE n.id = $symId AND rel.type = 'DEFINES'
-            RETURN f.id AS id, f.name AS name, labels(f)[0] AS type, f.filePath AS filePath
+            RETURN f.id AS id, f.name AS name, 'File' AS type, f.filePath AS filePath
           `, { symId }),
                 ]);
                 for (const r of ctorRows) {
@@ -2296,6 +2496,9 @@ export class LocalBackend {
                     if (rid && !visited.has(rid)) {
                         visited.add(rid);
                         frontier.push(rid);
+                        const label = safeNodeLabelForCypher(r.type ?? r[2], rid);
+                        if (label)
+                            frontierTypes.set(rid, label);
                     }
                 }
                 for (const r of fileRows) {
@@ -2303,6 +2506,9 @@ export class LocalBackend {
                     if (rid && !visited.has(rid)) {
                         visited.add(rid);
                         frontier.push(rid);
+                        const label = safeNodeLabelForCypher(r.type ?? r[2], rid);
+                        if (label)
+                            frontierTypes.set(rid, label);
                     }
                 }
             }
@@ -2312,13 +2518,23 @@ export class LocalBackend {
         }
         for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
             const nextFrontier = [];
-            // Batch frontier nodes into a single Cypher query per depth level
-            const idList = frontier.map((id) => `'${id.replace(/'/g, "''")}'`).join(', ');
-            const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
             try {
-                const related = await executeQuery(repo.id, query);
+                const frontierByLabel = new Map();
+                for (const id of frontier) {
+                    const label = frontierTypes.get(id) ?? safeNodeLabelForCypher(undefined, id) ?? '';
+                    const ids = frontierByLabel.get(label) ?? [];
+                    ids.push(id);
+                    frontierByLabel.set(label, ids);
+                }
+                const related = [];
+                for (const [label, ids] of frontierByLabel) {
+                    const idList = ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(', ');
+                    const targetPattern = label ? `(n:${label})` : '(n)';
+                    const query = direction === 'upstream'
+                        ? `MATCH (caller)-[r:CodeRelation]->${targetPattern} WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
+                        : `MATCH ${targetPattern}-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
+                    related.push(...(await executeQuery(repo.id, query)));
+                }
                 for (const rel of related) {
                     const relId = rel.id || rel[1];
                     const filePath = rel.filePath || rel[4] || '';
@@ -2327,6 +2543,10 @@ export class LocalBackend {
                     if (!visited.has(relId)) {
                         visited.add(relId);
                         nextFrontier.push(relId);
+                        const relTypeLabel = firstNonEmptyString(rel.type, rel.__cgLabel, rel[3]);
+                        const relLabel = safeNodeLabelForCypher(relTypeLabel, relId);
+                        if (relLabel)
+                            frontierTypes.set(relId, relLabel);
                         const storedConfidence = rel.confidence ?? rel[6];
                         const relationType = rel.relType || rel[5];
                         // Prefer the stored confidence from the graph (set at analysis time);
@@ -2338,7 +2558,7 @@ export class LocalBackend {
                             depth,
                             id: relId,
                             name: rel.name || rel[2],
-                            type: rel.type || rel[3],
+                            type: relTypeLabel,
                             filePath,
                             relationType,
                             confidence: effectiveConfidence,

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};