code-graph-context 2.0.1 → 2.3.0

package/dist/mcp/tools/detect-duplicate-code.tool.js

@@ -0,0 +1,450 @@
+/**
+ * Detect Duplicate Code Tool
+ * Identifies duplicate code using structural (AST hash) and semantic (embedding similarity) analysis
+ */
+import { z } from 'zod';
+import { toNumber, isUIComponent, getMonorepoAppName, getShortPath, truncateSourceCode, } from '../../core/utils/shared-utils.js';
+import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, debugLog, resolveProjectIdOrError } from '../utils.js';
+/**
+ * Determine confidence based on duplicate characteristics.
+ */
+const determineConfidence = (type, similarity, itemCount) => {
+    if (type === 'structural') {
+        // Structural duplicates with identical hash are high confidence
+        return 'HIGH';
+    }
+    // Semantic duplicates: confidence based on similarity and item count
+    if (similarity >= 0.9 && itemCount >= 2) {
+        return 'HIGH';
+    }
+    if (similarity >= 0.85) {
+        return 'MEDIUM';
+    }
+    return 'LOW';
+};
+/**
+ * Check if items are in different monorepo apps.
+ */
+const areInDifferentApps = (items) => {
+    const apps = new Set(items.map((i) => getMonorepoAppName(i.filePath)).filter(Boolean));
+    return apps.size > 1;
+};
+/**
+ * Analyze duplicates and generate category + recommendation.
+ */
+const analyzeAndRecommend = (type, items) => {
+    const names = [...new Set(items.map((i) => i.name))].slice(0, 3).join(', ');
+    const filesAffected = new Set(items.map((i) => i.filePath)).size;
+    // Check for UI component patterns
+    const allUIComponents = items.every((i) => isUIComponent(i.filePath));
+    if (allUIComponents) {
+        return {
+            category: 'ui-component',
+            recommendation: `UI components ${names} have similar structure - likely intentional co-location`,
+        };
+    }
+    // Check for monorepo cross-app duplicates
+    if (areInDifferentApps(items)) {
+        const apps = [...new Set(items.map((i) => getMonorepoAppName(i.filePath)).filter(Boolean))];
+        return {
+            category: 'cross-app',
+            recommendation: `Code duplicated across apps (${apps.slice(0, 3).join(', ')}) - consider shared package if unifying`,
+        };
+    }
+    // Same file duplicates
+    if (filesAffected === 1) {
+        return {
+            category: 'same-file',
+            recommendation: type === 'structural'
+                ? `Consider extracting shared logic from ${names} into a single method`
+                : `Review ${names} for potential consolidation`,
+        };
+    }
+    // Cross-file duplicates (default)
+    return {
+        category: 'cross-file',
+        recommendation: type === 'structural'
+            ? `Consider extracting ${names} into a shared utility function`
+            : `Semantically similar code in ${names} - consider unifying the approach`,
+    };
+};
+/**
+ * Map scope to core types for filtering.
+ */
+const getScopeFilter = (scope) => {
+    switch (scope) {
+        case 'methods':
+            return ['MethodDeclaration'];
+        case 'functions':
+            return ['FunctionDeclaration'];
+        case 'classes':
+            return ['ClassDeclaration'];
+        case 'all':
+        default:
+            return ['MethodDeclaration', 'FunctionDeclaration', 'ClassDeclaration'];
+    }
+};
+export const createDetectDuplicateCodeTool = (server) => {
+    server.registerTool(TOOL_NAMES.detectDuplicateCode, {
+        title: TOOL_METADATA[TOOL_NAMES.detectDuplicateCode].title,
+        description: TOOL_METADATA[TOOL_NAMES.detectDuplicateCode].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
+            type: z
+                .enum(['structural', 'semantic', 'all'])
+                .optional()
+                .describe('Detection approach: structural (AST hash), semantic (embeddings), or all (default: all)')
+                .default('all'),
+            minSimilarity: z
+                .number()
+                .min(0.5)
+                .max(1.0)
+                .optional()
+                .describe('Minimum similarity for semantic duplicates (0.5-1.0, default: 0.80)')
+                .default(0.8),
+            includeCode: z
+                .boolean()
+                .optional()
+                .describe('Include source code snippets in results (default: false)')
+                .default(false),
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe('Maximum number of duplicate groups to return (default: 20)')
+                .default(20),
+            scope: z
+                .enum(['methods', 'functions', 'classes', 'all'])
+                .optional()
+                .describe('Node types to analyze (default: all)')
+                .default('all'),
+            summaryOnly: z
+                .boolean()
+                .optional()
+                .describe('Return only summary statistics without full duplicates list (default: false)')
+                .default(false),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('Number of groups to skip for pagination (default: 0)')
+                .default(0),
+            vectorNeighbors: z
+                .number()
+                .int()
+                .min(10)
+                .max(200)
+                .optional()
+                .describe('Number of vector neighbors to search per node for semantic duplicates (default: 50, higher = more thorough)')
+                .default(50),
+        },
+    }, async ({ projectId, type = 'all', minSimilarity = 0.8, includeCode = false, maxResults = 20, scope = 'all', summaryOnly = false, offset = 0, vectorNeighbors = 50, }) => {
+        const neo4jService = new Neo4jService();
+        try {
+            // Resolve project ID
+            const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+            if (!projectResult.success)
+                return projectResult.error;
+            const resolvedProjectId = projectResult.projectId;
+            await debugLog('Duplicate code detection started', {
+                projectId: resolvedProjectId,
+                type,
+                minSimilarity,
+                scope,
+            });
+            const coreTypes = getScopeFilter(scope);
+            const duplicateGroups = [];
+            let groupCounter = 1;
+            const includeStructuralInOutput = type === 'structural' || type === 'all';
+            // 1. Find structural duplicates (always run for filtering, only include in output if requested)
+            // This ensures semantic-only mode filters out exact copy pairs
+            const structuralPairs = new Set(); // Pairs of nodeIds that are exact copies
+            {
+                const structuralResult = (await neo4jService.run(QUERIES.FIND_STRUCTURAL_DUPLICATES, {
+                    projectId: resolvedProjectId,
+                    coreTypes,
+                    limit: Math.floor(maxResults * 10), // Get extra for grouping (each group has multiple items)
+                }));
+                // Group by normalizedHash
+                const hashGroups = new Map();
+                for (const item of structuralResult) {
+                    const hash = item.normalizedHash;
+                    if (!hash)
+                        continue;
+                    const duplicateItem = {
+                        nodeId: item.nodeId,
+                        name: item.name,
+                        coreType: item.coreType,
+                        semanticType: item.semanticType ?? null,
+                        filePath: item.filePath,
+                        lineNumber: toNumber(item.lineNumber),
+                    };
+                    if (includeCode) {
+                        duplicateItem.sourceCode = truncateSourceCode(item.sourceCode);
+                    }
+                    if (!hashGroups.has(hash)) {
+                        hashGroups.set(hash, []);
+                    }
+                    hashGroups.get(hash).push(duplicateItem);
+                }
+                // Convert to duplicate groups (only groups with 2+ items are duplicates)
+                for (const [, items] of hashGroups) {
+                    if (items.length >= 2) {
+                        // Track all pairs within this group for semantic filtering
+                        // This ensures we only filter pairs that are EXACT copies of each other
+                        for (let i = 0; i < items.length; i++) {
+                            for (let j = i + 1; j < items.length; j++) {
+                                const pairKey = [items[i].nodeId, items[j].nodeId].sort().join('::');
+                                structuralPairs.add(pairKey);
+                            }
+                        }
+                        // Only add to output if structural was requested
+                        if (includeStructuralInOutput) {
+                            const { category, recommendation } = analyzeAndRecommend('structural', items);
+                            duplicateGroups.push({
+                                groupId: `dup_${groupCounter++}`,
+                                type: 'structural',
+                                similarity: 1.0,
+                                confidence: determineConfidence('structural', 1.0, items.length),
+                                category,
+                                items,
+                                recommendation,
+                            });
+                        }
+                    }
+                }
+            }
+            // 2. Find semantic duplicates (embedding similarity)
+            // Diagnostic counters to debug filtering
+            let semanticQueryResults = 0;
+            let filteredAsSameFile = 0;
+            let filteredAsSeenPair = 0;
+            let filteredAsStructural = 0;
+            let filteredAsUsedInGroup = 0;
+            let semanticQueryError = null;
+            if (type === 'semantic' || type === 'all') {
+                let semanticResult = [];
+                try {
+                    semanticResult = (await neo4jService.run(QUERIES.FIND_SEMANTIC_DUPLICATES, {
+                        projectId: resolvedProjectId,
+                        coreTypes,
+                        minSimilarity,
+                        vectorNeighbors,
+                        limit: Math.floor(maxResults * 2), // Get extra for filtering (ensure integer)
+                    }));
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Check for vector index errors
+                    if (errorMessage.includes('vector') ||
+                        errorMessage.includes('index') ||
+                        errorMessage.includes('embedding')) {
+                        semanticQueryError =
+                            'Semantic duplicate detection requires embeddings. ' +
+                                'Re-parse the project with embeddings enabled (useEmbeddings: true) to enable this feature.';
+                        await debugLog('Semantic query skipped - vector index not available', { error: errorMessage });
+                    }
+                    else {
+                        // Re-throw non-vector-index errors
+                        throw error;
+                    }
+                }
+                // Process semantic pairs
+                const seenPairs = new Set();
+                const usedInSemanticGroup = new Set();
+                for (const pair of semanticResult) {
+                    semanticQueryResults++;
+                    const nodeId1 = pair.nodeId1;
+                    const nodeId2 = pair.nodeId2;
+                    const similarity = toNumber(pair.similarity);
+                    // Skip if same file (same-file similarity is expected)
+                    if (pair.filePath1 === pair.filePath2) {
+                        filteredAsSameFile++;
+                        continue;
+                    }
+                    // Skip if already seen this pair
+                    const pairKey = [nodeId1, nodeId2].sort().join('::');
+                    if (seenPairs.has(pairKey)) {
+                        filteredAsSeenPair++;
+                        continue;
+                    }
+                    seenPairs.add(pairKey);
+                    // Skip if this specific pair is already a structural duplicate (exact copies of each other)
+                    if (structuralPairs.has(pairKey)) {
+                        filteredAsStructural++;
+                        continue;
+                    }
+                    // Skip if either node is already in a semantic duplicate group (first match wins)
+                    if (usedInSemanticGroup.has(nodeId1) || usedInSemanticGroup.has(nodeId2)) {
+                        filteredAsUsedInGroup++;
+                        continue;
+                    }
+                    const items = [
+                        {
+                            nodeId: nodeId1,
+                            name: pair.name1,
+                            coreType: pair.coreType1,
+                            semanticType: pair.semanticType1 ?? null,
+                            filePath: pair.filePath1,
+                            lineNumber: toNumber(pair.lineNumber1),
+                        },
+                        {
+                            nodeId: nodeId2,
+                            name: pair.name2,
+                            coreType: pair.coreType2,
+                            semanticType: pair.semanticType2 ?? null,
+                            filePath: pair.filePath2,
+                            lineNumber: toNumber(pair.lineNumber2),
+                        },
+                    ];
+                    if (includeCode) {
+                        items[0].sourceCode = truncateSourceCode(pair.sourceCode1);
+                        items[1].sourceCode = truncateSourceCode(pair.sourceCode2);
+                    }
+                    const { category, recommendation } = analyzeAndRecommend('semantic', items);
+                    duplicateGroups.push({
+                        groupId: `dup_${groupCounter++}`,
+                        type: 'semantic',
+                        similarity: Math.round(similarity * 1000) / 1000,
+                        confidence: determineConfidence('semantic', similarity, 2),
+                        category,
+                        items,
+                        recommendation,
+                    });
+                    // Mark both nodes as used to prevent appearing in multiple groups
+                    usedInSemanticGroup.add(nodeId1);
+                    usedInSemanticGroup.add(nodeId2);
+                }
+                // Log semantic query diagnostics
+                await debugLog('Semantic query diagnostics', {
+                    rawResults: semanticQueryResults,
+                    filteredAsSameFile,
+                    filteredAsSeenPair,
+                    filteredAsStructural,
+                    filteredAsUsedInGroup,
+                    structuralPairsCount: structuralPairs.size,
+                    finalSemanticGroups: duplicateGroups.filter((g) => g.type === 'semantic').length,
+                });
+            }
+            // Sort by similarity (descending)
+            duplicateGroups.sort((a, b) => b.similarity - a.similarity);
+            // Calculate statistics on ALL groups before pagination
+            const allStructuralGroups = duplicateGroups.filter((g) => g.type === 'structural');
+            const allSemanticGroups = duplicateGroups.filter((g) => g.type === 'semantic');
+            const totalGroups = duplicateGroups.length;
+            const totalDuplicates = duplicateGroups.reduce((sum, g) => sum + g.items.length, 0);
+            const affectedFiles = [...new Set(duplicateGroups.flatMap((g) => g.items.map((i) => i.filePath)))].sort();
+            const byType = {
+                structural: {
+                    groups: allStructuralGroups.length,
+                    items: allStructuralGroups.reduce((sum, g) => sum + g.items.length, 0),
+                },
+                semantic: {
+                    groups: allSemanticGroups.length,
+                    items: allSemanticGroups.reduce((sum, g) => sum + g.items.length, 0),
+                },
+            };
+            // Check embedding count for diagnostic (do this before building summary)
+            let embeddingCount = 0;
+            let semanticDiagnostic = null;
+            if ((type === 'semantic' || type === 'all') && allSemanticGroups.length === 0) {
+                const embeddingCountResult = await neo4jService.run(`MATCH (n:Embedded) WHERE n.projectId = $projectId RETURN count(n) AS count`, { projectId: resolvedProjectId });
+                embeddingCount = toNumber(embeddingCountResult[0]?.count);
+                if (embeddingCount === 0) {
+                    semanticDiagnostic = {
+                        nodesWithEmbeddings: 0,
+                        message: 'No nodes have embeddings. Re-parse with OPENAI_API_KEY set to enable semantic duplicate detection.',
+                    };
+                }
+                else {
+                    semanticDiagnostic = {
+                        nodesWithEmbeddings: embeddingCount,
+                        message: `${embeddingCount} nodes have embeddings but no semantic duplicates found above ${minSimilarity} similarity threshold.`,
+                    };
+                }
+                // Log diagnostic so user sees it in debug output
+                await debugLog('Semantic duplicate diagnostic', semanticDiagnostic);
+            }
+            // Build summary with warning if no embeddings
+            let summary = totalGroups === 0
+                ? 'No duplicate code found'
+                : `Found ${totalGroups} duplicate code groups across ${affectedFiles.length} files`;
+            if (semanticQueryError) {
+                summary += ` (Warning: ${semanticQueryError})`;
+            }
+            else if ((type === 'semantic' || type === 'all') && embeddingCount === 0 && allSemanticGroups.length === 0) {
+                summary += ' (Warning: No embeddings for semantic detection)';
+            }
+            // Build result based on summaryOnly flag
+            let result;
+            if (summaryOnly) {
+                // Summary mode: statistics only, no full arrays
+                const fileDuplicateCounts = {};
+                for (const group of duplicateGroups) {
+                    for (const item of group.items) {
+                        const shortPath = getShortPath(item.filePath);
+                        fileDuplicateCounts[shortPath] = (fileDuplicateCounts[shortPath] ?? 0) + 1;
+                    }
+                }
+                const topFilesByDuplicates = Object.entries(fileDuplicateCounts)
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 20)
+                    .map(([file, count]) => ({ file, count }));
+                result = {
+                    summary,
+                    totalGroups,
+                    totalDuplicates,
+                    byType,
+                    affectedFiles,
+                    topFilesByDuplicates,
+                };
+            }
+            else {
+                // Paginated mode: apply offset/maxResults
+                const paginatedGroups = duplicateGroups.slice(offset, offset + maxResults);
+                const hasMore = offset + maxResults < duplicateGroups.length;
+                result = {
+                    summary,
+                    totalGroups,
+                    totalDuplicates,
+                    byType,
+                    duplicates: paginatedGroups,
+                    pagination: {
+                        offset,
+                        limit: maxResults,
+                        returned: paginatedGroups.length,
+                        hasMore,
+                    },
+                    affectedFiles,
+                };
+            }
+            // Add pre-computed diagnostic to result
+            if (semanticDiagnostic) {
+                result.semanticDiagnostic = semanticDiagnostic;
+            }
+            await debugLog('Duplicate code detection complete', {
+                projectId: resolvedProjectId,
+                totalGroups,
+                structuralGroups: allStructuralGroups.length,
+                semanticGroups: allSemanticGroups.length,
+                summaryOnly,
+                offset,
+                maxResults,
+            });
+            return createSuccessResponse(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            console.error('Duplicate code detection error:', error);
+            await debugLog('Duplicate code detection error', { projectId, error });
+            return createErrorResponse(error);
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};

package/dist/mcp/tools/hello.tool.js

@@ -3,11 +3,25 @@
  * Simple test tool to verify MCP connection
  */
 import { TOOL_NAMES, TOOL_METADATA, MESSAGES } from '../constants.js';
-import { createSuccessResponse } from '../utils.js';
+import { createSuccessResponse, debugLog } from '../utils.js';
+import { logToolCallStart, logToolCallEnd } from './index.js';
 export const createHelloTool = (server) => {
     server.registerTool(TOOL_NAMES.hello, {
         title: TOOL_METADATA[TOOL_NAMES.hello].title,
         description: TOOL_METADATA[TOOL_NAMES.hello].description,
         inputSchema: {},
-    }, async () => createSuccessResponse(MESSAGES.success.hello));
+    }, async () => {
+        const startTime = Date.now();
+        const callId = await logToolCallStart('hello');
+        try {
+            const result = createSuccessResponse(MESSAGES.success.hello);
+            await logToolCallEnd('hello', callId, true, Date.now() - startTime);
+            return result;
+        }
+        catch (error) {
+            await debugLog('Hello tool error', { error: String(error) });
+            await logToolCallEnd('hello', callId, false, Date.now() - startTime);
+            throw error;
+        }
+    });
 };

package/dist/mcp/tools/impact-analysis.tool.js

@@ -7,19 +7,35 @@ import { z } from 'zod';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
 import { createErrorResponse, createSuccessResponse, debugLog, resolveProjectIdOrError } from '../utils.js';
-// Default relationship weights for core AST relationships
+/**
+ * Default relationship weights for impact/risk analysis.
+ *
+ * NOTE: These weights are intentionally different from CoreEdge.relationshipWeight
+ * in the core schema. They serve different purposes:
+ *
+ * - Core schema weights (traversalWeight): "What relationships help me understand the code?"
+ *   → CALLS is high (0.85) because following execution flow aids comprehension
+ *
+ * - Impact analysis weights: "What breaks if I modify this node?"
+ *   → EXTENDS/IMPLEMENTS are highest (0.95) because changing a base class/interface
+ *     breaks ALL subclasses/implementers - inheritance is a hard contract
+ *
+ * Example: A class with 50 callers and 10 subclasses
+ * - For traversal: follow the 50 CALLS to understand usage patterns
+ * - For impact: the 10 subclasses are CRITICAL - they inherit the contract
+ */
 const DEFAULT_RELATIONSHIP_WEIGHTS = {
-    // Critical - inheritance/interface contracts
+    // Critical - inheritance/interface contracts (changing base breaks ALL children)
     EXTENDS: 0.95,
     IMPLEMENTS: 0.95,
-    // High - direct code dependencies
+    // High - direct code dependencies (callers may break but often handle changes)
     CALLS: 0.75,
     HAS_MEMBER: 0.65,
     TYPED_AS: 0.6,
     // Medium - module dependencies
     IMPORTS: 0.5,
     EXPORTS: 0.5,
-    // Lower - structural
+    // Lower - structural (container doesn't break if child changes)
     CONTAINS: 0.3,
     HAS_PARAMETER: 0.3,
     DECORATED_WITH: 0.4,

package/dist/mcp/tools/index.js

@@ -2,7 +2,10 @@
  * MCP Tool Factory
  * Centralized tool creation and registration
  */
+import { debugLog } from '../utils.js';
 import { createCheckParseStatusTool } from './check-parse-status.tool.js';
+import { createDetectDeadCodeTool } from './detect-dead-code.tool.js';
+import { createDetectDuplicateCodeTool } from './detect-duplicate-code.tool.js';
 import { createHelloTool } from './hello.tool.js';
 import { createImpactAnalysisTool } from './impact-analysis.tool.js';
 import { createListProjectsTool } from './list-projects.tool.js';
@@ -12,8 +15,36 @@ import { createParseTypescriptProjectTool } from './parse-typescript-project.too
 import { createSearchCodebaseTool } from './search-codebase.tool.js';
 import { createStartWatchProjectTool } from './start-watch-project.tool.js';
 import { createStopWatchProjectTool } from './stop-watch-project.tool.js';
+import { createSwarmCleanupTool } from './swarm-cleanup.tool.js';
+import { createSwarmPheromoneTool } from './swarm-pheromone.tool.js';
+import { createSwarmSenseTool } from './swarm-sense.tool.js';
 import { createTestNeo4jConnectionTool } from './test-neo4j-connection.tool.js';
 import { createTraverseFromNodeTool } from './traverse-from-node.tool.js';
+// Track tool calls for debugging
+let globalToolCallCount = 0;
+/**
+ * Log tool call start (exported for use by individual tools)
+ */
+export const logToolCallStart = async (toolName, params) => {
+    globalToolCallCount++;
+    const callId = globalToolCallCount;
+    await debugLog(`Tool call START: ${toolName}`, {
+        callId,
+        totalCalls: globalToolCallCount,
+        params: params ? JSON.stringify(params).substring(0, 500) : 'none',
+    });
+    return callId;
+};
+/**
+ * Log tool call end (exported for use by individual tools)
+ */
+export const logToolCallEnd = async (toolName, callId, success, duration) => {
+    await debugLog(`Tool call END: ${toolName}`, {
+        callId,
+        success,
+        duration: duration ? `${duration}ms` : 'unknown',
+    });
+};
 /**
  * Register all MCP tools with the server
  */
@@ -26,6 +57,8 @@ export const registerAllTools = (server) => {
     createTraverseFromNodeTool(server);
     createNaturalLanguageToCypherTool(server);
     createImpactAnalysisTool(server);
+    createDetectDeadCodeTool(server);
+    createDetectDuplicateCodeTool(server);
     // Register project parsing tools
     createParseTypescriptProjectTool(server);
     createCheckParseStatusTool(server);
@@ -35,4 +68,8 @@ export const registerAllTools = (server) => {
     createStartWatchProjectTool(server);
     createStopWatchProjectTool(server);
     createListWatchersTool(server);
+    // Register swarm coordination tools
+    createSwarmPheromoneTool(server);
+    createSwarmSenseTool(server);
+    createSwarmCleanupTool(server);
 };