@codragraph/cli 2.1.0 → 2.1.1

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

@@ -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);
         }
@@ -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.
@@ -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);

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