@codragraph/cli 2.0.0 → 2.1.1

package/dist/mcp/core/embedder.js

@@ -6,7 +6,9 @@
  */
 import { pipeline, env } from '@huggingface/transformers';
 import { isHttpMode, getHttpDimensions, httpEmbedQuery, } from '../../core/embeddings/http-client.js';
-import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/lbug/pool-adapter.js';
+import { homedir } from 'os';
+import { join } from 'path';
+import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/cgdb/pool-adapter.js';
 // Model config
 const MODEL_ID = 'Snowflake/snowflake-arctic-embed-xs';
 // Module-level state for singleton pattern
@@ -33,8 +35,9 @@ export const initEmbedder = async () => {
             // Default cache to user-writable location. transformers.js defaults to
             // ./node_modules/.cache inside its own install dir, which is unwritable
             // when codragraph is installed globally (e.g. /usr/lib/node_modules/).
-            // Respect HF_HOME if set, otherwise fall back to ~/.cache/huggingface.
-            env.cacheDir = process.env.HF_HOME ?? `${process.env.HOME}/.cache/huggingface`;
+            // Respect HF_HOME if set, otherwise fall back to a user-writable cache
+            // path using Node's OS-aware home directory resolution.
+            env.cacheDir = process.env.HF_HOME ?? join(homedir(), '.cache', 'huggingface');
             console.error('CodraGraph: Loading embedding model (first search may take a moment)...');
             // Try GPU first (DirectML on Windows, CUDA on Linux), fall back to CPU
             const isWindows = process.platform === 'win32';

package/dist/mcp/local/local-backend.d.ts

@@ -5,7 +5,7 @@
  * Supports multiple indexed repositories via a global registry.
  * LadybugDB connections are opened lazily per repo on first query.
  */
-import { isWriteQuery } from '../../core/lbug/pool-adapter.js';
+import { isWriteQuery } from '../../core/cgdb/pool-adapter.js';
 export { isWriteQuery };
 import { type RegistryEntry } from '../../storage/repo-manager.js';
 import { GroupService } from '../../core/group/service.js';
@@ -53,7 +53,7 @@ interface RepoHandle {
     name: string;
     repoPath: string;
     storagePath: string;
-    lbugPath: string;
+    cgdbPath: string;
     indexedAt: string;
     lastCommit: string;
     remoteUrl?: string;
@@ -323,6 +323,18 @@ export declare class LocalBackend {
      * Query clusters (communities) directly from graph.
      * Used by getClustersResource — avoids legacy overview() dispatch.
      */
+    /**
+     * Query feature clusters directly from graph.
+     * FeatureCluster is the human-facing project area layer above Communities.
+     */
+    queryFeatureClusters(repoName?: string, limit?: number, query?: string): Promise<{
+        clusters: any[];
+    }>;
+    /**
+     * Query one feature cluster with members, dependencies, and process links.
+     */
+    queryFeatureContext(name: string, repoName?: string, limit?: number): Promise<any>;
+    queryFeatureImpact(name: string, repoName?: string, direction?: 'upstream' | 'downstream' | 'both', limit?: number): Promise<any>;
     queryClusters(repoName?: string, limit?: number): Promise<{
         clusters: any[];
     }>;

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

@@ -7,7 +7,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
-import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, isWriteQuery, } from '../../core/lbug/pool-adapter.js';
+import { initCgdb, executeQuery, executeParameterized, closeCgdb, isCgdbReady, isWriteQuery, } from '../../core/cgdb/pool-adapter.js';
 export { isWriteQuery };
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
@@ -18,8 +18,8 @@ import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-ma
 import { GroupService } from '../../core/group/service.js';
 import { resolveAtGroupMemberRepoPath } from '../../core/group/resolve-at-member.js';
 import { collectBestChunks } from '../../core/embeddings/types.js';
-import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/lbug/schema.js';
-import { decodeContentField } from '../../core/lbug/content-read.js';
+import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/cgdb/schema.js';
+import { decodeContentField } from '../../core/cgdb/content-read.js';
 import { PhaseTimer } from '../../core/search/phase-timer.js';
 import { checkStaleness, checkCwdMatch } from '../../core/git-staleness.js';
 // AI context generation is CLI-only (codragraph analyze)
@@ -57,6 +57,7 @@ export const VALID_NODE_LABELS = new Set([
     'CodeElement',
     'Community',
     'Process',
+    'FeatureCluster',
     'Struct',
     'Enum',
     'Macro',
@@ -95,6 +96,9 @@ export const VALID_RELATION_TYPES = new Set([
     'HANDLES_TOOL',
     'ENTRY_POINT_OF',
     'WRAPS',
+    'QUERIES',
+    'FEATURE_MEMBER_OF',
+    'FEATURE_DEPENDS_ON',
 ]);
 /**
  * Per-relation-type confidence floor for impact analysis.
@@ -138,6 +142,61 @@ function logQueryError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`CodraGraph [${context}]: ${msg}`);
 }
+function clampNumber(value, min, max, fallback) {
+    const parsed = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number.parseInt(value, 10)
+            : Number.NaN;
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(parsed)));
+}
+function normalizeStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).replace(/^['"]|['"]$/g, ''));
+    }
+    if (typeof value !== 'string' || value.length === 0)
+        return [];
+    return value
+        .replace(/^\[|\]$/g, '')
+        .split(',')
+        .map((item) => item.trim().replace(/^['"]|['"]$/g, ''))
+        .filter(Boolean);
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((v) => (v ?? '').trim()).filter(Boolean))].sort();
+}
+function isDocsFilePath(filePath) {
+    const p = (filePath || '').toLowerCase().replace(/\\/g, '/');
+    return p.includes('/docs/') || p.endsWith('.md') || p.endsWith('.mdx');
+}
+function mapFeatureClusterRow(row) {
+    const rich = row.summary !== undefined ||
+        row.repo !== undefined ||
+        row.routes !== undefined ||
+        row[10] !== undefined;
+    return {
+        id: row.id || row[0],
+        name: row.name || row[1],
+        slug: row.slug || row[2],
+        featureKind: row.featureKind || row[3],
+        summary: row.summary ?? (rich ? row[4] : ''),
+        description: row.description ?? (rich ? row[5] : row[4]),
+        repo: row.repo ?? (rich ? row[6] : undefined),
+        service: row.service ?? (rich ? row[7] : undefined),
+        signals: normalizeStringArray(row.signals ?? (rich ? row[8] : row[5])),
+        memberCount: row.memberCount ?? (rich ? row[9] : row[6]) ?? 0,
+        entryPointIds: normalizeStringArray(row.entryPointIds ?? (rich ? row[10] : row[7])),
+        routes: normalizeStringArray(row.routes ?? (rich ? row[11] : [])),
+        tools: normalizeStringArray(row.tools ?? (rich ? row[12] : [])),
+        testCoverageHints: normalizeStringArray(row.testCoverageHints ?? (rich ? row[13] : [])),
+        lastIndexedCommit: row.lastIndexedCommit ?? (rich ? row[14] : undefined),
+        confidence: row.confidence ?? (rich ? row[15] : row[8]) ?? 0,
+        source: row.source || (rich ? row[16] : row[9]) || 'heuristic',
+        crossRepoLinks: [],
+    };
+}
 /**
  * Structured per-query latency log for production aggregation (#553).
  *
@@ -182,6 +241,9 @@ export class LocalBackend {
                 query: (r, p) => this.query(r, p),
                 impactByUid: (id, uid, d, o) => this.impactByUid(id, uid, d, o),
                 context: (r, p) => this.context(r, p),
+                featureClusters: (r, p) => this.queryFeatureClusters(r.name, p.limit, p.query),
+                featureContext: (r, p) => this.queryFeatureContext(p.name, r.name, p.limit),
+                featureImpact: (r, p) => this.queryFeatureImpact(p.name, r.name, p.direction ?? 'upstream', p.limit),
             };
             this.groupToolSvc = new GroupService(port);
         }
@@ -189,7 +251,7 @@ export class LocalBackend {
     }
     /** Close all pooled LadybugDB connections (CLI one-shot; optional for long-lived MCP). */
     async dispose() {
-        await closeLbug();
+        await closeCgdb();
     }
     // ─── Initialization ──────────────────────────────────────────────
     /**
@@ -212,9 +274,9 @@ export class LocalBackend {
             const id = this.repoId(entry.name, entry.path);
             freshIds.add(id);
             const storagePath = entry.storagePath;
-            const lbugPath = path.join(storagePath, 'lbug');
+            const cgdbPath = path.join(storagePath, 'cgdb');
             // Clean up any leftover KuzuDB files from before the LadybugDB migration.
-            // If kuzu exists but lbug doesn't, warn so the user knows to re-analyze.
+            // If kuzu exists but cgdb doesn't, warn so the user knows to re-analyze.
             const kuzu = await cleanupOldKuzuFiles(storagePath);
             if (kuzu.found && kuzu.needsReindex) {
                 console.error(`CodraGraph: "${entry.name}" has a stale KuzuDB index. Run: codragraph analyze ${entry.path}`);
@@ -224,7 +286,7 @@ export class LocalBackend {
                 name: entry.name,
                 repoPath: entry.path,
                 storagePath,
-                lbugPath,
+                cgdbPath,
                 indexedAt: entry.indexedAt,
                 lastCommit: entry.lastCommit,
                 remoteUrl: entry.remoteUrl,
@@ -364,7 +426,7 @@ export class LocalBackend {
         // Check if the index was rebuilt since we opened the connection (#297).
         // Throttle staleness checks to at most once per 5 seconds per repo to
         // avoid an fs.readFile round-trip on every tool invocation.
-        if (this.initializedRepos.has(repoId) && isLbugReady(repoId)) {
+        if (this.initializedRepos.has(repoId) && isCgdbReady(repoId)) {
             const now = Date.now();
             const lastCheck = this.lastStalenessCheck.get(repoId) ?? 0;
             if (now - lastCheck < 5000)
@@ -380,10 +442,10 @@ export class LocalBackend {
                     // callers both detect staleness and double-close the pool.
                     const reinit = (async () => {
                         try {
-                            await closeLbug(repoId);
+                            await closeCgdb(repoId);
                             this.initializedRepos.delete(repoId);
                             handle.indexedAt = meta.indexedAt;
-                            await initLbug(repoId, handle.lbugPath);
+                            await initCgdb(repoId, handle.cgdbPath);
                             this.initializedRepos.add(repoId);
                         }
                         finally {
@@ -402,7 +464,7 @@ export class LocalBackend {
             }
         }
         try {
-            await initLbug(repoId, handle.lbugPath);
+            await initCgdb(repoId, handle.cgdbPath);
             this.initializedRepos.add(repoId);
         }
         catch (err) {
@@ -545,9 +607,18 @@ export class LocalBackend {
             return this.handleGroupTool(method, params || {});
         }
         const p = params && typeof params === 'object' ? params : {};
-        if ((method === 'impact' || method === 'query' || method === 'context') &&
-            typeof p.repo === 'string' &&
-            p.repo.startsWith('@')) {
+        const groupRepoMethods = new Set([
+            'impact',
+            'query',
+            'context',
+            'feature_clusters',
+            'feature_context',
+            'cluster_query',
+            'cluster_context',
+            'context_pack',
+            'cluster_impact',
+        ]);
+        if (groupRepoMethods.has(method) && typeof p.repo === 'string' && p.repo.startsWith('@')) {
             return this.callToolAtGroupRepo(method, p);
         }
         // Resolve repo from optional param (re-reads registry on miss)
@@ -582,6 +653,22 @@ export class LocalBackend {
                 return this.toolMap(repo, params);
             case 'api_impact':
                 return this.apiImpact(repo, params);
+            case 'feature_clusters':
+            case 'cluster_query':
+                return this.queryFeatureClusters(params?.repo, clampNumber(params?.limit, 1, 500, 100), String(params?.query ?? ''));
+            case 'feature_context':
+            case 'cluster_context':
+            case 'context_pack':
+                return this.queryFeatureContext(String(params?.name ??
+                    params?.slug ??
+                    params?.id ??
+                    ''), params?.repo, clampNumber(params?.limit, 1, 500, 100));
+            case 'cluster_impact':
+                return this.queryFeatureImpact(String(params?.name ??
+                    params?.slug ??
+                    params?.id ??
+                    ''), params?.repo, params?.direction ??
+                    'upstream', clampNumber(params?.limit, 1, 500, 100));
             case 'harness_swarm_run': {
                 // Same lazy-import dance as harness_run (see comments below) — keeps
                 // codragraph-harness optional and avoids a circular build-time dep.
@@ -948,10 +1035,10 @@ export class LocalBackend {
      * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
      */
     async bm25Search(repo, query, limit) {
-        const { searchFTSFromLbug } = await import('../../core/search/bm25-index.js');
+        const { searchFTSFromCgdb } = await import('../../core/search/bm25-index.js');
         let bm25Results;
         try {
-            bm25Results = await searchFTSFromLbug(query, limit, repo.id);
+            bm25Results = await searchFTSFromCgdb(query, limit, repo.id);
         }
         catch (err) {
             console.error('CodraGraph: BM25/FTS search failed (FTS indexes may not exist) -', err.message);
@@ -1088,7 +1175,7 @@ export class LocalBackend {
     }
     async cypher(repo, params) {
         await this.ensureInitialized(repo.id);
-        if (!isLbugReady(repo.id)) {
+        if (!isCgdbReady(repo.id)) {
             return { error: 'LadybugDB not ready. Index may be corrupted.' };
         }
         // Block write operations (defense-in-depth — DB is already read-only)
@@ -2685,6 +2772,57 @@ export class LocalBackend {
             }
             return svc.groupContext(contextArgs);
         }
+        if (method === 'feature_clusters' || method === 'cluster_query') {
+            const args = {
+                name: groupName,
+                query: params.query,
+                limit: params.limit,
+            };
+            if (memberRest !== undefined) {
+                args.subgroup = memberRest;
+                args.subgroupExact = true;
+            }
+            return svc.groupFeatureClusters(args);
+        }
+        if (method === 'feature_context' || method === 'cluster_context' || method === 'context_pack') {
+            const clusterName = typeof params.name === 'string' && params.name.trim() !== ''
+                ? params.name.trim()
+                : typeof params.slug === 'string' && params.slug.trim() !== ''
+                    ? params.slug.trim()
+                    : typeof params.id === 'string'
+                        ? params.id.trim()
+                        : '';
+            const args = {
+                name: groupName,
+                cluster: clusterName,
+                limit: params.limit,
+            };
+            if (memberRest !== undefined) {
+                args.subgroup = memberRest;
+                args.subgroupExact = true;
+            }
+            return svc.groupFeatureContext(args);
+        }
+        if (method === 'cluster_impact') {
+            const clusterName = typeof params.name === 'string' && params.name.trim() !== ''
+                ? params.name.trim()
+                : typeof params.slug === 'string' && params.slug.trim() !== ''
+                    ? params.slug.trim()
+                    : typeof params.id === 'string'
+                        ? params.id.trim()
+                        : '';
+            const args = {
+                name: groupName,
+                cluster: clusterName,
+                direction: params.direction,
+                limit: params.limit,
+            };
+            if (memberRest !== undefined) {
+                args.subgroup = memberRest;
+                args.subgroupExact = true;
+            }
+            return svc.groupFeatureImpact(args);
+        }
         throw new Error(`Internal: unsupported group-repo tool ${method}`);
     }
     async groupList(params) {
@@ -3082,6 +3220,246 @@ export class LocalBackend {
      * Query clusters (communities) directly from graph.
      * Used by getClustersResource — avoids legacy overview() dispatch.
      */
+    /**
+     * Query feature clusters directly from graph.
+     * FeatureCluster is the human-facing project area layer above Communities.
+     */
+    async queryFeatureClusters(repoName, limit = 100, query = '') {
+        const repo = await this.resolveRepo(repoName);
+        await this.ensureInitialized(repo.id);
+        const safeLimit = clampNumber(limit, 1, 500, 100);
+        const needle = query.trim().toLowerCase();
+        const fetchLimit = needle ? 500 : safeLimit;
+        try {
+            let clusters;
+            try {
+                clusters = await executeQuery(repo.id, `
+        MATCH (c:FeatureCluster)
+        RETURN c.id AS id, c.name AS name, c.slug AS slug, c.featureKind AS featureKind,
+               c.summary AS summary, c.description AS description, c.repo AS repo,
+               c.service AS service, c.signals AS signals, c.memberCount AS memberCount,
+               c.entryPointIds AS entryPointIds, c.routes AS routes, c.tools AS tools,
+               c.testCoverageHints AS testCoverageHints,
+               c.lastIndexedCommit AS lastIndexedCommit, c.confidence AS confidence,
+               c.source AS source
+        ORDER BY c.memberCount DESC
+        LIMIT ${fetchLimit}
+      `);
+            }
+            catch {
+                clusters = await executeQuery(repo.id, `
+          MATCH (c:FeatureCluster)
+          RETURN c.id AS id, c.name AS name, c.slug AS slug, c.featureKind AS featureKind,
+                 c.description AS description, c.signals AS signals, c.memberCount AS memberCount,
+                 c.entryPointIds AS entryPointIds, c.confidence AS confidence, c.source AS source
+          ORDER BY c.memberCount DESC
+          LIMIT ${fetchLimit}
+        `);
+            }
+            return {
+                clusters: clusters
+                    .map(mapFeatureClusterRow)
+                    .filter((cluster) => {
+                    if (!needle)
+                        return true;
+                    return [
+                        cluster.name,
+                        cluster.slug,
+                        cluster.summary,
+                        cluster.description,
+                        ...(cluster.signals || []),
+                        ...(cluster.routes || []),
+                        ...(cluster.tools || []),
+                    ]
+                        .join(' ')
+                        .toLowerCase()
+                        .includes(needle);
+                })
+                    .slice(0, safeLimit),
+            };
+        }
+        catch {
+            return { clusters: [] };
+        }
+    }
+    /**
+     * Query one feature cluster with members, dependencies, and process links.
+     */
+    async queryFeatureContext(name, repoName, limit = 100) {
+        const key = name.trim();
+        if (!key)
+            return { error: 'Feature cluster name, slug, or id is required' };
+        const repo = await this.resolveRepo(repoName);
+        await this.ensureInitialized(repo.id);
+        const safeLimit = clampNumber(limit, 1, 500, 100);
+        let clusters;
+        try {
+            clusters = await executeParameterized(repo.id, `
+      MATCH (c:FeatureCluster)
+      WHERE c.id = $key OR c.name = $key OR c.slug = $key
+      RETURN c.id AS id, c.name AS name, c.slug AS slug, c.featureKind AS featureKind,
+             c.summary AS summary, c.description AS description, c.repo AS repo,
+             c.service AS service, c.signals AS signals, c.memberCount AS memberCount,
+             c.entryPointIds AS entryPointIds, c.routes AS routes, c.tools AS tools,
+             c.testCoverageHints AS testCoverageHints,
+             c.lastIndexedCommit AS lastIndexedCommit, c.confidence AS confidence,
+             c.source AS source
+      LIMIT 1
+    `, { key });
+        }
+        catch {
+            clusters = await executeParameterized(repo.id, `
+        MATCH (c:FeatureCluster)
+        WHERE c.id = $key OR c.name = $key OR c.slug = $key
+        RETURN c.id AS id, c.name AS name, c.slug AS slug, c.featureKind AS featureKind,
+               c.description AS description, c.signals AS signals, c.memberCount AS memberCount,
+               c.entryPointIds AS entryPointIds, c.confidence AS confidence, c.source AS source
+        LIMIT 1
+      `, { key });
+        }
+        let cluster = clusters.length > 0 ? mapFeatureClusterRow(clusters[0]) : undefined;
+        if (!cluster) {
+            const fallback = await this.queryFeatureClusters(repoName, 1, key);
+            cluster = fallback.clusters[0];
+        }
+        if (!cluster)
+            return { error: `Feature cluster '${name}' not found` };
+        const clusterId = cluster.id;
+        const members = await executeParameterized(repo.id, `
+      MATCH (n)-[r:CodeRelation {type: 'FEATURE_MEMBER_OF'}]->(c:FeatureCluster {id: $clusterId})
+      RETURN DISTINCT n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath,
+             n.startLine AS startLine, n.endLine AS endLine, r.confidence AS confidence,
+             r.reason AS reason
+      ORDER BY type, filePath, startLine
+      LIMIT ${safeLimit}
+    `, { clusterId });
+        const outgoing = await executeParameterized(repo.id, `
+      MATCH (c:FeatureCluster {id: $clusterId})-[r:CodeRelation {type: 'FEATURE_DEPENDS_ON'}]->(d:FeatureCluster)
+      RETURN d.id AS id, d.name AS name, d.slug AS slug, r.confidence AS confidence, r.reason AS reason
+      ORDER BY d.name
+    `, { clusterId });
+        const incoming = await executeParameterized(repo.id, `
+      MATCH (s:FeatureCluster)-[r:CodeRelation {type: 'FEATURE_DEPENDS_ON'}]->(c:FeatureCluster {id: $clusterId})
+      RETURN s.id AS id, s.name AS name, s.slug AS slug, r.confidence AS confidence, r.reason AS reason
+      ORDER BY s.name
+    `, { clusterId });
+        const processes = await executeParameterized(repo.id, `
+      MATCH (n)-[:CodeRelation {type: 'FEATURE_MEMBER_OF'}]->(c:FeatureCluster {id: $clusterId}),
+            (n)-[:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+      RETURN DISTINCT p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel,
+             p.processType AS processType, p.stepCount AS stepCount
+      ORDER BY p.stepCount DESC
+      LIMIT 25
+    `, { clusterId });
+        const mappedMembers = members.map((m) => {
+            const id = m.id || m[0];
+            const type = m.type || m[2];
+            const filePath = m.filePath || m[3];
+            const name = m.name || m[1];
+            return {
+                id,
+                name,
+                type,
+                filePath,
+                startLine: m.startLine ?? m[4],
+                endLine: m.endLine ?? m[5],
+                role: cluster.entryPointIds.includes(id)
+                    ? 'entrypoint'
+                    : type === 'File' || type === 'Section'
+                        ? 'supporting'
+                        : 'implementation',
+                confidence: m.confidence ?? m[6] ?? 0,
+                reason: m.reason || m[7],
+            };
+        });
+        const outgoingDependencies = outgoing.map((d) => ({
+            id: d.id || d[0],
+            name: d.name || d[1],
+            slug: d.slug || d[2],
+            confidence: d.confidence ?? d[3] ?? 0,
+            reason: d.reason || d[4],
+        }));
+        const incomingDependencies = incoming.map((d) => ({
+            id: d.id || d[0],
+            name: d.name || d[1],
+            slug: d.slug || d[2],
+            confidence: d.confidence ?? d[3] ?? 0,
+            reason: d.reason || d[4],
+        }));
+        const testMembers = mappedMembers.filter((member) => isTestFilePath(member.filePath || ''));
+        const docMembers = mappedMembers.filter((member) => member.type === 'Section' || isDocsFilePath(member.filePath));
+        const warnings = [];
+        if (testMembers.length === 0) {
+            warnings.push('No obvious test members were found in this cluster.');
+        }
+        if (incomingDependencies.length + outgoingDependencies.length > 10) {
+            warnings.push('This cluster has broad feature dependencies; check impact before large edits.');
+        }
+        return {
+            cluster,
+            members: mappedMembers,
+            dependencies: {
+                outgoing: outgoingDependencies,
+                incoming: incomingDependencies,
+            },
+            entryPoints: mappedMembers.filter((member) => cluster.entryPointIds.includes(member.id) ||
+                member.type === 'Route' ||
+                member.type === 'Tool'),
+            routes: mappedMembers.filter((member) => member.type === 'Route'),
+            tools: mappedMembers.filter((member) => member.type === 'Tool'),
+            processes: processes.map((p) => ({
+                id: p.id || p[0],
+                label: p.label || p[1],
+                heuristicLabel: p.heuristicLabel || p[2],
+                processType: p.processType || p[3],
+                stepCount: p.stepCount || p[4],
+            })),
+            tests: testMembers,
+            docs: docMembers,
+            crossRepoLinks: cluster.crossRepoLinks || [],
+            safeEditSurface: {
+                files: uniqueStrings(mappedMembers.map((member) => member.filePath)),
+                symbols: uniqueStrings(mappedMembers
+                    .filter((member) => !['File', 'Folder', 'Section'].includes(member.type || ''))
+                    .map((member) => member.name)),
+                warnings,
+            },
+        };
+    }
+    async queryFeatureImpact(name, repoName, direction = 'upstream', limit = 100) {
+        const contextPack = await this.queryFeatureContext(name, repoName, limit);
+        if (contextPack?.error)
+            return contextPack;
+        const incoming = contextPack.dependencies?.incoming ?? [];
+        const outgoing = contextPack.dependencies?.outgoing ?? [];
+        const impactedClusters = direction === 'downstream'
+            ? outgoing
+            : direction === 'both'
+                ? [...incoming, ...outgoing]
+                : incoming;
+        const uniqueImpacted = Array.from(new Map(impactedClusters.map((cluster) => [cluster.id || cluster.name, cluster])).values());
+        const affectedMembers = contextPack.members?.length ?? 0;
+        const dependencyCount = uniqueImpacted.length;
+        const riskLevel = dependencyCount >= 15 || affectedMembers >= 250
+            ? 'HIGH'
+            : dependencyCount >= 5 || affectedMembers >= 75
+                ? 'MEDIUM'
+                : 'LOW';
+        return {
+            cluster: contextPack.cluster,
+            direction,
+            impactedClusters: uniqueImpacted,
+            safeEditSurface: contextPack.safeEditSurface,
+            contextPack,
+            impactSummary: {
+                affectedMembers,
+                dependencyCount,
+                incomingDependencies: incoming.length,
+                outgoingDependencies: outgoing.length,
+                riskLevel,
+            },
+        };
+    }
     async queryClusters(repoName, limit = 100) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
@@ -3222,7 +3600,7 @@ export class LocalBackend {
         };
     }
     async disconnect() {
-        await closeLbug(); // close all connections
+        await closeCgdb(); // close all connections
         // Note: we intentionally do NOT call disposeEmbedder() here.
         // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs,
         // and importing the embedder module on Node v24+ crashes if onnxruntime