@codragraph/cli 2.0.0 → 2.1.1

package/dist/mcp/resources.js

@@ -41,6 +41,12 @@ export function getResourceTemplates() {
             description: 'All functional areas (Leiden clusters)',
             mimeType: 'text/yaml',
         },
+        {
+            uriTemplate: 'codragraph://repo/{name}/feature-clusters',
+            name: 'Repo Feature Clusters',
+            description: 'Human-facing product/domain feature areas with members and dependencies',
+            mimeType: 'text/yaml',
+        },
         {
             uriTemplate: 'codragraph://repo/{name}/processes',
             name: 'Repo Processes',
@@ -59,6 +65,12 @@ export function getResourceTemplates() {
             description: 'Deep dive into a specific functional area',
             mimeType: 'text/yaml',
         },
+        {
+            uriTemplate: 'codragraph://repo/{name}/feature/{featureName}',
+            name: 'Feature Context',
+            description: 'Members, line ranges, dependencies, and flows for one feature cluster',
+            mimeType: 'text/yaml',
+        },
         {
             uriTemplate: 'codragraph://repo/{name}/process/{processName}',
             name: 'Process Trace',
@@ -194,6 +206,14 @@ export function parseResourceUri(uri) {
                 param: rest.replace(/^cluster\//, ''),
             };
         }
+        if (rest.startsWith('feature/')) {
+            return {
+                kind: 'repo',
+                repoName,
+                resourceType: 'feature',
+                param: rest.replace(/^feature\//, ''),
+            };
+        }
         if (rest.startsWith('process/')) {
             return {
                 kind: 'repo',
@@ -229,12 +249,16 @@ export async function readResource(uri, backend) {
             return getContextResource(backend, repoName);
         case 'clusters':
             return getClustersResource(backend, repoName);
+        case 'feature-clusters':
+            return getFeatureClustersResource(backend, repoName);
         case 'processes':
             return getProcessesResource(backend, repoName);
         case 'schema':
             return getSchemaResource();
         case 'cluster':
             return getClusterDetailResource(parsed.param, backend, repoName);
+        case 'feature':
+            return getFeatureDetailResource(parsed.param, backend, repoName);
         case 'process':
             return getProcessDetailResource(parsed.param, backend, repoName);
         case 'graphstore/log':
@@ -308,6 +332,7 @@ async function getContextResource(backend, repoName) {
     lines.push(`  files: ${context.stats.fileCount}`);
     lines.push(`  symbols: ${context.stats.functionCount}`);
     lines.push(`  processes: ${context.stats.processCount}`);
+    lines.push(`  feature_clusters: ${repo.stats?.featureClusters || 0}`);
     lines.push('');
     lines.push('tools_available:');
     lines.push('  - query: Process-grouped code intelligence (execution flows related to a concept)');
@@ -323,8 +348,10 @@ async function getContextResource(backend, repoName) {
     lines.push('resources_available:');
     lines.push('  - codragraph://repos: All indexed repositories');
     lines.push(`  - codragraph://repo/${context.projectName}/clusters: All functional areas`);
+    lines.push(`  - codragraph://repo/${context.projectName}/feature-clusters: Human-facing feature areas`);
     lines.push(`  - codragraph://repo/${context.projectName}/processes: All execution flows`);
     lines.push(`  - codragraph://repo/${context.projectName}/cluster/{name}: Module details`);
+    lines.push(`  - codragraph://repo/${context.projectName}/feature/{name}: Feature context pack`);
     lines.push(`  - codragraph://repo/${context.projectName}/process/{name}: Process trace`);
     lines.push('  - codragraph://group/{name}/contracts: Group contract registry (optional ?type=&repo=&unmatchedOnly=)');
     lines.push('  - codragraph://group/{name}/status: Group index / contract staleness');
@@ -362,6 +389,39 @@ async function getClustersResource(backend, repoName) {
 /**
  * Processes resource — queries graph directly via backend.queryProcesses()
  */
+/**
+ * Feature clusters resource - human-facing product/domain areas.
+ */
+async function getFeatureClustersResource(backend, repoName) {
+    try {
+        const result = await backend.queryFeatureClusters(repoName, 100);
+        if (!result.clusters || result.clusters.length === 0) {
+            return 'feature_clusters: []\n# No feature clusters detected. Run: codragraph analyze';
+        }
+        const displayLimit = 30;
+        const lines = ['feature_clusters:'];
+        for (const cluster of result.clusters.slice(0, displayLimit)) {
+            lines.push(`  - name: "${cluster.name || cluster.slug || cluster.id}"`);
+            lines.push(`    slug: "${cluster.slug || ''}"`);
+            lines.push(`    kind: ${cluster.featureKind || 'feature'}`);
+            if (cluster.summary)
+                lines.push(`    summary: "${cluster.summary}"`);
+            lines.push(`    members: ${cluster.memberCount || 0}`);
+            if (cluster.routes?.length)
+                lines.push(`    routes: ${cluster.routes.length}`);
+            if (cluster.tools?.length)
+                lines.push(`    tools: ${cluster.tools.length}`);
+            lines.push(`    confidence: ${Math.round((cluster.confidence || 0) * 100)}%`);
+        }
+        if (result.clusters.length > displayLimit) {
+            lines.push(`\n# Showing top ${displayLimit} of ${result.clusters.length} feature clusters. Use feature_context for details.`);
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `error: ${err.message}`;
+    }
+}
 async function getProcessesResource(backend, repoName) {
     try {
         const result = await backend.queryProcesses(repoName, 50);
@@ -402,6 +462,7 @@ nodes:
   - CodeElement: Catch-all for other code elements
   - Community: Auto-detected functional area (Leiden algorithm)
   - Process: Execution flow trace
+  - FeatureCluster: Human-facing feature/domain cluster for targeted context
 
 additional_node_types: "Multi-language: Struct, Enum, Macro, Typedef, Union, Namespace, Trait, Impl, TypeAlias, Const, Static, Property, Record, Delegate, Annotation, Constructor, Template, Module (use backticks in queries: \`Struct\`, \`Enum\`, etc.)"
 
@@ -411,6 +472,7 @@ node_properties:
   Function: "parameterCount (INT32), returnType (STRING), isVariadic (BOOL), visibility (STRING), isStatic (BOOL), isAbstract (BOOL), isFinal (BOOL), isAsync (BOOL), parameterTypes (STRING[]), annotations (STRING[])"
   Property: "declaredType (STRING) — the field's type annotation (e.g., 'Address', 'City'). Used for field-access chain resolution."
   Constructor: "parameterCount (INT32), visibility (STRING), isStatic (BOOL), parameterTypes (STRING[])"
+  FeatureCluster: "name (STRING), slug (STRING), featureKind (STRING), summary (STRING), repo (STRING), service (STRING), memberCount (INT32), entryPointIds (STRING[]), routes (STRING[]), tools (STRING[]), testCoverageHints (STRING[]), lastIndexedCommit (STRING), confidence (DOUBLE), signals (STRING[])"
   Community: "heuristicLabel (STRING), cohesion (DOUBLE), symbolCount (INT32), keywords (STRING[]), description (STRING), enrichedBy (STRING)"
   Process: "heuristicLabel (STRING), processType (STRING — 'intra_community' or 'cross_community'), stepCount (INT32), communities (STRING[]), entryPointId (STRING), terminalId (STRING)"
 
@@ -428,6 +490,10 @@ relationships:
   - METHOD_IMPLEMENTS: ConcreteMethod implements InterfaceMethod (matched by name + parameterTypes)
   - MEMBER_OF: Symbol belongs to community
   - STEP_IN_PROCESS: Symbol is step N in process
+  - WRAPS: Wrapper/decorator relationship
+  - QUERIES: Data/query relationship
+  - FEATURE_MEMBER_OF: Symbol/file belongs to a FeatureCluster
+  - FEATURE_DEPENDS_ON: FeatureCluster depends on another FeatureCluster via member edges
 
 relationship_table: "All relationships use a single CodeRelation table with a 'type' property. Properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)"
 
@@ -487,6 +553,66 @@ async function getClusterDetailResource(name, backend, repoName) {
 /**
  * Process detail resource — queries graph directly via backend.queryProcessDetail()
  */
+async function getFeatureDetailResource(name, backend, repoName) {
+    try {
+        const result = await backend.queryFeatureContext(name, repoName);
+        if (result.error) {
+            return `error: ${result.error}`;
+        }
+        const cluster = result.cluster;
+        const members = result.members || [];
+        const outgoing = result.dependencies?.outgoing || [];
+        const incoming = result.dependencies?.incoming || [];
+        const processes = result.processes || [];
+        const lines = [
+            `feature: "${cluster.name || cluster.slug || cluster.id}"`,
+            `slug: "${cluster.slug || ''}"`,
+            `kind: ${cluster.featureKind || 'feature'}`,
+            `members: ${cluster.memberCount || members.length}`,
+            `confidence: ${Math.round((cluster.confidence || 0) * 100)}%`,
+        ];
+        if (members.length > 0) {
+            lines.push('');
+            lines.push('members:');
+            for (const member of members.slice(0, 30)) {
+                lines.push(`  - name: ${member.name}`);
+                lines.push(`    type: ${member.type}`);
+                lines.push(`    file: ${member.filePath || ''}`);
+                if (member.startLine !== undefined)
+                    lines.push(`    startLine: ${member.startLine}`);
+                if (member.endLine !== undefined)
+                    lines.push(`    endLine: ${member.endLine}`);
+            }
+        }
+        if (outgoing.length > 0 || incoming.length > 0) {
+            lines.push('');
+            lines.push('dependencies:');
+            if (outgoing.length > 0) {
+                lines.push('  outgoing:');
+                for (const dep of outgoing.slice(0, 15)) {
+                    lines.push(`    - ${dep.name || dep.slug || dep.id}`);
+                }
+            }
+            if (incoming.length > 0) {
+                lines.push('  incoming:');
+                for (const dep of incoming.slice(0, 15)) {
+                    lines.push(`    - ${dep.name || dep.slug || dep.id}`);
+                }
+            }
+        }
+        if (processes.length > 0) {
+            lines.push('');
+            lines.push('processes:');
+            for (const proc of processes.slice(0, 10)) {
+                lines.push(`  - ${proc.heuristicLabel || proc.label || proc.id}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `error: ${err.message}`;
+    }
+}
 async function getProcessDetailResource(name, backend, repoName) {
     try {
         const result = await backend.queryProcessDetail(name, repoName);
@@ -539,6 +665,12 @@ async function getSetupResource(backend) {
             '| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence |',
             '| `detect_changes` | Git-diff impact — what do your current changes affect |',
             '| `rename` | Multi-file coordinated rename with confidence-tagged edits |',
+            '| `feature_clusters` | Product/domain feature map for targeted context |',
+            '| `feature_context` | Members, line ranges, dependencies, and flows for one feature |',
+            '| `cluster_query` | Cluster-first alias for `feature_clusters` |',
+            '| `cluster_context` | Cluster-first alias for `feature_context` |',
+            '| `context_pack` | Compact context pack for one feature cluster |',
+            '| `cluster_impact` | Feature-level blast radius across cluster dependencies |',
             '| `cypher` | Raw graph queries |',
             '| `list_repos` | Discover indexed repos |',
             '',
@@ -546,8 +678,15 @@ async function getSetupResource(backend) {
             '',
             `- \`codragraph://repo/${repo.name}/context\` — Stats, staleness check`,
             `- \`codragraph://repo/${repo.name}/clusters\` — All functional areas`,
+            `- \`codragraph://repo/${repo.name}/feature-clusters\` — Human-facing feature areas`,
+            `- \`codragraph://repo/${repo.name}/feature/{name}\` — Feature context pack`,
             `- \`codragraph://repo/${repo.name}/processes\` — All execution flows`,
             `- \`codragraph://repo/${repo.name}/schema\` — Graph schema for Cypher`,
+            '',
+            '## Cross-platform commands',
+            '',
+            '- Use `npx @codragraph/cli ...` or `codragraph ...` in Windows PowerShell, macOS bash/zsh, and Linux shells.',
+            '- Prefer `npm --prefix <package> <script>` from repo root for package checks instead of shell-specific `cd dir && ...` chains.',
         ];
         sections.push(lines.join('\n'));
     }

package/dist/mcp/server.js

@@ -15,7 +15,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CompatibleStdioServerTransport } from './compatible-stdio-transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { CODRAGRAPH_TOOLS } from './tools.js';
-import { realStdoutWrite } from './core/lbug-adapter.js';
+import { realStdoutWrite } from './core/cgdb-adapter.js';
 import { getResourceDefinitions, getResourceTemplates, readResource } from './resources.js';
 /**
  * Next-step hints appended to tool responses.
@@ -208,7 +208,7 @@ export function createMCPServer(backend) {
                     { name: 'repo', description: 'Repository (omit if only one indexed)', required: false },
                     {
                         name: 'symbolId',
-                        description: 'Stable symbol id (PK in the lbug node table)',
+                        description: 'Stable symbol id (PK in the cgdb node table)',
                         required: true,
                     },
                     {
@@ -484,7 +484,7 @@ Follow these steps:
 export async function startMCPServer(backend) {
     const server = createMCPServer(backend);
     // Use the shared stdout reference captured at module-load time by the
-    // lbug-adapter.  Avoids divergence if anything patches stdout between
+    // cgdb-adapter.  Avoids divergence if anything patches stdout between
     // module load and server start.
     const _safeStdout = new Proxy(process.stdout, {
         get(target, prop, receiver) {

package/dist/mcp/tools.js

@@ -84,6 +84,177 @@ SERVICE: optional monorepo path prefix (POSIX-style, case-sensitive segments). W
             required: ['query'],
         },
     },
+    {
+        name: 'feature_clusters',
+        description: `List human-facing feature clusters such as Settings, AI, Auth, Billing, MCP, or Ingestion.
+
+WHEN TO USE: First step for targeted implementation/refactoring when you need the functional area map before loading files. This is the product/domain layer above algorithmic Community nodes.
+AFTER THIS: Use feature_context(name) for members with file paths and line ranges, then context() or impact() on specific symbols.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional cluster owner search term (e.g. "settings", "AI", "billing").',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max feature clusters to return (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'feature_context',
+        description: `Get a complete context pack for one FeatureCluster.
+
+Returns the cluster metadata, member symbols/files with line ranges, outgoing/incoming feature dependencies, and related execution processes.
+
+WHEN TO USE: Before editing a feature area like Settings or AI. This narrows exploration to the exact files and symbols in that feature cluster.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Feature cluster name, slug, or id (e.g. "Settings", "settings").',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max members to return (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'cluster_query',
+        description: `Cluster-first alias for feature_clusters.
+
+WHEN TO USE: Ask which product/domain cluster owns an area like Settings, AI, Auth, or Billing before loading files.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional cluster owner search term (e.g. "settings", "AI", "billing").',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max feature clusters to return (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'cluster_context',
+        description: `Cluster-first alias for feature_context.
+
+Returns a FeatureCluster context pack with members, entry points, routes, tools, tests, docs, dependencies, and safe edit surface.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Feature cluster name, slug, or id (e.g. "Settings", "settings").',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max members to return (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'context_pack',
+        description: `Get the compact agent context pack for a FeatureCluster.
+
+WHEN TO USE: Before a refactor or implementation task where the agent should avoid re-exploring the full repo.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Feature cluster name, slug, or id (e.g. "AI", "ai").',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max members to return (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'cluster_impact',
+        description: `Assess feature-level blast radius for a FeatureCluster.
+
+Returns upstream/downstream cluster dependencies plus the same context pack and safe edit surface used for targeted edits.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Feature cluster name, slug, or id.',
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['upstream', 'downstream', 'both'],
+                    description: 'Dependency direction to inspect.',
+                    default: 'upstream',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max members to include in the context pack (default: 100)',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 500,
+                },
+            },
+            required: ['name'],
+        },
+    },
     {
         name: 'cypher',
         description: `Execute Cypher query against the code knowledge graph.
@@ -92,10 +263,10 @@ WHEN TO USE: Complex structural queries that search/explore can't answer. READ c
 AFTER THIS: Use context() on result symbols for deeper context.
 
 SCHEMA:
-- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process, Route, Tool
+- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process, FeatureCluster, Route, Tool
 - Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
 - All edges via single CodeRelation table with 'type' property
-- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, METHOD_OVERRIDES, METHOD_IMPLEMENTS, MEMBER_OF, STEP_IN_PROCESS, HANDLES_ROUTE, FETCHES, HANDLES_TOOL, ENTRY_POINT_OF
+- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, METHOD_OVERRIDES, METHOD_IMPLEMENTS, MEMBER_OF, STEP_IN_PROCESS, HANDLES_ROUTE, FETCHES, HANDLES_TOOL, ENTRY_POINT_OF, WRAPS, QUERIES, FEATURE_MEMBER_OF, FEATURE_DEPENDS_ON
 - Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
 
 EXAMPLES:
@@ -129,6 +300,7 @@ TIPS:
 - All relationships use single CodeRelation table — filter with {type: 'CALLS'} etc.
 - Community = auto-detected functional area (Leiden algorithm). Properties: heuristicLabel, cohesion, symbolCount, keywords, description, enrichedBy
 - Process = execution flow trace from entry point to terminal. Properties: heuristicLabel, processType, stepCount, communities, entryPointId, terminalId
+- FeatureCluster = product/domain area for targeted context packs. Properties: name, slug, featureKind, summary, repo, service, memberCount, entryPointIds, routes, tools, testCoverageHints, lastIndexedCommit, confidence, signals
 - Use heuristicLabel (not label) for human-readable community/process names`,
         inputSchema: {
             type: 'object',
@@ -806,7 +978,7 @@ Pair with codragraph_context first to get the symbol's stable id (e.g. \`fn:src/
             type: 'object',
             properties: {
                 repo: { type: 'string', description: 'Indexed repo (omit if only one).' },
-                symbolId: { type: 'string', description: 'Stable symbol id (PK in the lbug node table).' },
+                symbolId: { type: 'string', description: 'Stable symbol id (PK in the cgdb node table).' },
                 table: {
                     type: 'string',
                     description: 'Optional table hint to narrow the search (Function, Class, Method, Interface, …).',

package/dist/server/analyze-worker.js

@@ -11,7 +11,7 @@
  *   Child -> Parent: { type: 'error', message: string }
  */
 import { runFullAnalysis } from '../core/run-analyze.js';
-import { closeLbug } from '../core/lbug/lbug-adapter.js';
+import { closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 function send(msg) {
     process.send?.(msg);
 }
@@ -28,7 +28,7 @@ process.on('unhandledRejection', (reason) => {
 process.on('SIGTERM', async () => {
     send({ type: 'error', message: 'Analysis cancelled (worker received SIGTERM)' });
     try {
-        await closeLbug();
+        await closeCgdb();
     }
     catch { }
     process.exit(0);