code-graph-context 2.5.4 → 2.6.1

package/dist/mcp/handlers/graph-generator.handler.js

@@ -23,12 +23,12 @@ export class GraphGeneratorHandler {
         this.projectId = projectId;
     }
     async generateGraph(graphJsonPath, batchSize = DEFAULTS.batchSize, clearExisting = true) {
-        console.log(`Generating graph from JSON file: ${graphJsonPath}`);
+        console.error(`Generating graph from JSON file: ${graphJsonPath}`);
         await debugLog('Starting graph generation', { graphJsonPath, batchSize, clearExisting, projectId: this.projectId });
         try {
             const graphData = await this.loadGraphData(graphJsonPath);
             const { nodes, edges, metadata } = graphData;
-            console.log(`Generating graph with ${nodes.length} nodes and ${edges.length} edges`);
+            console.error(`Generating graph with ${nodes.length} nodes and ${edges.length} edges`);
             await debugLog('Graph data loaded', { nodeCount: nodes.length, edgeCount: edges.length });
             if (clearExisting) {
                 await this.clearExistingData();
@@ -57,18 +57,18 @@ export class GraphGeneratorHandler {
     }
     async clearExistingData() {
         if (this.projectId) {
-            console.log(`Clearing existing graph data for project: ${this.projectId}...`);
+            console.error(`Clearing existing graph data for project: ${this.projectId}...`);
             await this.neo4jService.run(QUERIES.CLEAR_PROJECT, { projectId: this.projectId });
             await debugLog('Existing project graph data cleared', { projectId: this.projectId });
         }
         else {
-            console.log('Clearing ALL existing graph data (no projectId set)...');
+            console.error('Clearing ALL existing graph data (no projectId set)...');
             await this.neo4jService.run(QUERIES.CLEAR_DATABASE);
             await debugLog('Existing graph data cleared');
         }
     }
     async createProjectIndexes() {
-        console.log('Creating project indexes...');
+        console.error('Creating project indexes...');
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_INDEX_EMBEDDED);
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_INDEX_SOURCEFILE);
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_ID_INDEX_EMBEDDED);
@@ -77,12 +77,12 @@ export class GraphGeneratorHandler {
         await debugLog('Project indexes created');
     }
     async importNodes(nodes, batchSize) {
-        console.log(`Importing ${nodes.length} nodes with embeddings...`);
+        console.error(`Importing ${nodes.length} nodes with embeddings...`);
         for (let i = 0; i < nodes.length; i += batchSize) {
             const batch = await this.processNodeBatch(nodes.slice(i, i + batchSize));
             const result = await this.neo4jService.run(QUERIES.CREATE_NODE, { nodes: batch });
             const batchEnd = Math.min(i + batchSize, nodes.length);
-            console.log(`Created ${result[0].created} nodes in batch ${i + 1}-${batchEnd}`);
+            console.error(`Created ${result[0].created} nodes in batch ${i + 1}-${batchEnd}`);
             await debugLog('Node batch imported', {
                 batchStart: i + 1,
                 batchEnd,
@@ -158,7 +158,7 @@ export class GraphGeneratorHandler {
         return nodeResults;
     }
     async importEdges(edges, batchSize) {
-        console.log(`Importing ${edges.length} edges using APOC...`);
+        console.error(`Importing ${edges.length} edges using APOC...`);
         for (let i = 0; i < edges.length; i += batchSize) {
             const batch = edges.slice(i, i + batchSize).map((edge) => ({
                 ...edge,
@@ -169,7 +169,7 @@ export class GraphGeneratorHandler {
                 projectId: this.projectId,
             });
             const batchEnd = Math.min(i + batchSize, edges.length);
-            console.log(`Created ${result[0].created} edges in batch ${i + 1}-${batchEnd}`);
+            console.error(`Created ${result[0].created} edges in batch ${i + 1}-${batchEnd}`);
             await debugLog('Edge batch imported', {
                 batchStart: i + 1,
                 batchEnd,
@@ -178,7 +178,7 @@ export class GraphGeneratorHandler {
         }
     }
     async createVectorIndexes() {
-        console.log('Creating vector indexes...');
+        console.error('Creating vector indexes...');
         await this.neo4jService.run(QUERIES.CREATE_EMBEDDED_VECTOR_INDEX);
         await debugLog('Vector indexes created');
     }

package/dist/mcp/handlers/traversal.handler.js

@@ -153,7 +153,7 @@ export class TraversalHandler {
         const nodeMap = new Map(); // Dedupe nodes
         for (let depth = 1; depth <= maxDepth; depth++) {
             if (currentSourceIds.length === 0) {
-                console.log(`No source nodes to explore at depth ${depth}`);
+                console.error(`No source nodes to explore at depth ${depth}`);
                 break;
             }
             const traversalResults = await this.neo4jService.run(QUERIES.EXPLORE_DEPTH_LEVEL(direction, maxNodesPerDepth), {
@@ -165,7 +165,7 @@ export class TraversalHandler {
                 projectId,
             });
             if (traversalResults.length === 0) {
-                console.log(`No connections found at depth ${depth}`);
+                console.error(`No connections found at depth ${depth}`);
                 break;
             }
             // Collect node IDs for next depth exploration

package/dist/mcp/mcp.server.js

@@ -13,7 +13,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Go up two levels from dist/mcp/mcp.server.js to the root
 const rootDir = join(__dirname, '..', '..');
-dotenv.config({ path: join(rootDir, '.env') });
+dotenv.config({ path: join(rootDir, '.env'), quiet: true });
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { MCP_SERVER_CONFIG, MESSAGES } from './constants.js';

package/dist/mcp/services/job-manager.js

@@ -33,7 +33,7 @@ class JobManager {
         this.cleanupInterval = setInterval(() => {
             const cleaned = this.cleanupOldJobs();
             if (cleaned > 0) {
-                console.log(`[JobManager] Cleaned up ${cleaned} old jobs`);
+                console.error(`[JobManager] Cleaned up ${cleaned} old jobs`);
             }
         }, JOBS.cleanupIntervalMs);
         // Don't prevent Node.js from exiting if this is the only timer
@@ -63,7 +63,7 @@ class JobManager {
                     `Please wait for jobs to complete or cancel existing jobs.`);
             }
             if (cleaned > 0) {
-                console.log(`[JobManager] Auto-cleaned ${cleaned} old jobs to make room for new job`);
+                console.error(`[JobManager] Auto-cleaned ${cleaned} old jobs to make room for new job`);
             }
         }
         const id = generateJobId();

package/dist/mcp/services/watch-manager.js

@@ -249,7 +249,7 @@ class WatchManager {
                 },
                 timestamp: new Date().toISOString(),
             });
-            console.log(`[WatchManager] Incremental parse completed for ${state.projectId}: ` +
+            console.error(`[WatchManager] Incremental parse completed for ${state.projectId}: ` +
                 `${result.nodesUpdated} nodes, ${result.edgesUpdated} edges in ${elapsedMs}ms`);
         }
         catch (error) {
@@ -309,7 +309,7 @@ class WatchManager {
                 edgesUpdated: result.edgesUpdated
             });
             if (result.nodesUpdated > 0 || result.edgesUpdated > 0) {
-                console.log(`[WatchManager] Synced missed changes for ${state.projectId}: ` +
+                console.error(`[WatchManager] Synced missed changes for ${state.projectId}: ` +
                     `${result.nodesUpdated} nodes, ${result.edgesUpdated} edges`);
             }
         })
@@ -370,7 +370,7 @@ class WatchManager {
             }
         }
         this.watchers.delete(projectId);
-        console.log(`[WatchManager] Stopped watching project: ${projectId}`);
+        console.error(`[WatchManager] Stopped watching project: ${projectId}`);
         return true;
     }
     /**
@@ -394,7 +394,7 @@ class WatchManager {
     async stopAllWatchers() {
         const projectIds = Array.from(this.watchers.keys());
         await Promise.all(projectIds.map((id) => this.stopWatching(id)));
-        console.log(`[WatchManager] Stopped all ${projectIds.length} watchers`);
+        console.error(`[WatchManager] Stopped all ${projectIds.length} watchers`);
     }
     /**
      * Convert internal state to public info

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

@@ -158,12 +158,6 @@ export const createDetectDeadCodeTool = (server) => {
             if (!projectResult.success)
                 return projectResult.error;
             const resolvedProjectId = projectResult.projectId;
-            await debugLog('Dead code detection started', {
-                projectId: resolvedProjectId,
-                excludePatterns,
-                excludeSemanticTypes,
-                minConfidence,
-            });
             // Query project's actual semantic types (data-driven, per-project detection)
             const semanticTypesResult = (await neo4jService.run(QUERIES.GET_PROJECT_SEMANTIC_TYPES, {
                 projectId: resolvedProjectId,
@@ -389,16 +383,6 @@ export const createDetectDeadCodeTool = (server) => {
                     affectedFiles,
                 };
             }
-            await debugLog('Dead code detection complete', {
-                projectId: resolvedProjectId,
-                totalCount: deadCodeItems.length,
-                filteredCount: filteredItems.length,
-                filterCategory,
-                riskLevel,
-                summaryOnly,
-                offset,
-                limit,
-            });
             return createSuccessResponse(JSON.stringify(result, null, 2));
         }
         catch (error) {

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

@@ -151,12 +151,6 @@ export const createDetectDuplicateCodeTool = (server) => {
             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;
@@ -320,16 +314,6 @@ export const createDetectDuplicateCodeTool = (server) => {
                     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);
@@ -367,8 +351,6 @@ export const createDetectDuplicateCodeTool = (server) => {
                         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
@@ -427,15 +409,6 @@ export const createDetectDuplicateCodeTool = (server) => {
             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) {

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

@@ -81,13 +81,6 @@ export const createImpactAnalysisTool = (server) => {
             if (!nodeId && !filePath) {
                 return createErrorResponse('Either nodeId or filePath must be provided');
             }
-            await debugLog('Impact analysis started', {
-                projectId: resolvedProjectId,
-                nodeId,
-                filePath,
-                maxDepth,
-                frameworkConfig,
-            });
             // Merge default weights with framework-specific weights
             const weights = { ...DEFAULT_RELATIONSHIP_WEIGHTS, ...frameworkConfig?.relationshipWeights };
             const highRiskTypes = new Set(frameworkConfig?.highRiskTypes ?? []);
@@ -213,12 +206,6 @@ export const createImpactAnalysisTool = (server) => {
                 affectedFiles,
                 criticalPaths,
             };
-            await debugLog('Impact analysis complete', {
-                nodeId: nodeId ?? filePath,
-                riskLevel,
-                directCount: directDependents.length,
-                transitiveCount: transitiveDependents.length,
-            });
             return createSuccessResponse(JSON.stringify(result, null, 2));
         }
         catch (error) {

package/dist/mcp/tools/index.js

@@ -2,7 +2,6 @@
  * 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';
@@ -30,25 +29,15 @@ let globalToolCallCount = 0;
 /**
  * Log tool call start (exported for use by individual tools)
  */
-export const logToolCallStart = async (toolName, params) => {
+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;
+    return globalToolCallCount;
 };
 /**
  * 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',
-    });
+export const logToolCallEnd = async (_toolName, _callId, _success, _duration) => {
+    // No-op - verbose logging disabled
 };
 /**
  * Register all MCP tools with the server

package/dist/mcp/tools/list-projects.tool.js

@@ -14,7 +14,6 @@ export const createListProjectsTool = (server) => {
     }, async () => {
         const neo4jService = new Neo4jService();
         try {
-            await debugLog('Listing projects');
             const results = await neo4jService.run(LIST_PROJECTS_QUERY, {});
             if (results.length === 0) {
                 return createSuccessResponse('No projects found. Use parse_typescript_project to add a project first.');
@@ -28,7 +27,6 @@ export const createListProjectsTool = (server) => {
                 edgeCount: r.edgeCount,
                 updatedAt: r.updatedAt?.toString() ?? 'Unknown',
             }));
-            await debugLog('Projects listed', { count: projects.length });
             // Format output for readability
             const header = `Found ${projects.length} project(s):\n\n`;
             const formatStats = (p) => {

package/dist/mcp/tools/list-watchers.tool.js

@@ -12,7 +12,6 @@ export const createListWatchersTool = (server) => {
         inputSchema: {},
     }, async () => {
         try {
-            await debugLog('Listing watchers');
             const watchers = watchManager.listWatchers();
             if (watchers.length === 0) {
                 return createSuccessResponse('No active file watchers.\n\n' +
@@ -20,7 +19,6 @@ export const createListWatchersTool = (server) => {
                     '- Use start_watch_project with a projectId\n' +
                     '- Or use parse_typescript_project with watch: true (requires async: false)');
             }
-            await debugLog('Watchers listed', { count: watchers.length });
             const header = `Found ${watchers.length} active watcher(s):\n\n`;
             const watcherList = watchers
                 .map((w) => {

package/dist/mcp/tools/natural-language-to-cypher.tool.js

@@ -47,7 +47,6 @@ export const createNaturalLanguageToCypherTool = (server) => {
                 await debugLog('Natural language service not available', { projectId: resolvedProjectId, query });
                 return createSuccessResponse(MESSAGES.errors.serviceNotInitialized);
             }
-            await debugLog('Natural language to Cypher conversion started', { projectId: resolvedProjectId, query });
             const cypherResult = await naturalLanguageToCypherService.promptToQuery(query, resolvedProjectId);
             // Validate Cypher syntax using EXPLAIN (no execution, just parse)
             const parameters = { ...cypherResult.parameters, projectId: resolvedProjectId };
@@ -67,11 +66,6 @@ export const createNaturalLanguageToCypherTool = (server) => {
             }
             // Execute the validated query
             const results = await neo4jService.run(cypherResult.cypher, parameters);
-            await debugLog('Cypher query executed', {
-                projectId: resolvedProjectId,
-                cypher: cypherResult.cypher,
-                resultsCount: results.length,
-            });
             const formattedResponse = formatQueryResults(results, query, cypherResult);
             return createSuccessResponse(JSON.stringify(formattedResponse, null, 2));
         }

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -225,10 +225,10 @@ export const createParseTypescriptProjectTool = (server) => {
             const discoveredFiles = await parser.discoverSourceFiles();
             const totalFiles = discoveredFiles.length;
             const shouldUseStreaming = useStreaming === 'always' || (useStreaming === 'auto' && totalFiles > PARSING.streamingThreshold && chunkSize > 0);
-            console.log(`📊 Project has ${totalFiles} files. Streaming: ${shouldUseStreaming ? 'enabled' : 'disabled'}`);
+            console.error(`📊 Project has ${totalFiles} files. Streaming: ${shouldUseStreaming ? 'enabled' : 'disabled'}`);
             if (shouldUseStreaming && clearExisting !== false) {
                 // Use streaming import for large projects
-                console.log(`🚀 Using streaming import with chunk size ${chunkSize}`);
+                console.error(`🚀 Using streaming import with chunk size ${chunkSize}`);
                 await debugLog('Using streaming import', { totalFiles, chunkSize });
                 // Create Project node BEFORE starting import (status: parsing)
                 const projectName = await getProjectName(projectPath);
@@ -298,7 +298,7 @@ export const createParseTypescriptProjectTool = (server) => {
                 projectType,
             });
             const { nodes, edges, savedCrossFileEdges, resolvedProjectId: finalProjectId } = graphData;
-            console.log(`Parsed ${nodes.length} nodes / ${edges.length} edges for project ${finalProjectId}`);
+            console.error(`Parsed ${nodes.length} nodes / ${edges.length} edges for project ${finalProjectId}`);
             await debugLog('Parsing completed', {
                 nodeCount: nodes.length,
                 edgeCount: edges.length,
@@ -306,7 +306,7 @@ export const createParseTypescriptProjectTool = (server) => {
             });
             const outputPath = join(projectPath, FILE_PATHS.graphOutput);
             writeFileSync(outputPath, JSON.stringify(graphData, null, LOG_CONFIG.jsonIndentation));
-            console.log(`Graph data written to ${outputPath}`);
+            console.error(`Graph data written to ${outputPath}`);
             try {
                 // Set projectId for project-scoped operations (clear, indexes)
                 graphGeneratorHandler.setProjectId(finalProjectId);
@@ -321,7 +321,7 @@ export const createParseTypescriptProjectTool = (server) => {
                     const recreatedCount = recreateResult[0]?.recreatedCount ?? 0;
                     await debugLog('Cross-file edges recreated', { recreatedCount, expected: savedCrossFileEdges.length });
                 }
-                console.log('Graph generation completed:', result);
+                console.error('Graph generation completed:', result);
                 await debugLog('Neo4j import completed', result);
                 // Update Project node status to complete
                 await neo4jService.run(UPDATE_PROJECT_STATUS_QUERY, {

package/dist/mcp/tools/search-codebase.tool.js

@@ -63,7 +63,6 @@ export const createSearchCodebaseTool = (server) => {
             const sanitizedMaxNodesPerChain = sanitizeNumericInput(maxNodesPerChain, 5);
             const sanitizedSkip = sanitizeNumericInput(skip, 0);
             const sanitizedSnippetLength = sanitizeNumericInput(snippetLength, DEFAULTS.codeSnippetLength);
-            await debugLog('Search codebase started', { projectId: resolvedProjectId, query });
             const embeddingsService = new EmbeddingsService();
             const traversalHandler = new TraversalHandler(neo4jService);
             const embedding = await embeddingsService.embedText(query);
@@ -75,7 +74,6 @@ export const createSearchCodebaseTool = (server) => {
                 minSimilarity,
             });
             if (vectorResults.length === 0) {
-                await debugLog('No relevant code found', { projectId: resolvedProjectId, query, minSimilarity });
                 return createSuccessResponse(`No code found with similarity >= ${minSimilarity}. ` +
                     `Try rephrasing your query or lowering the minSimilarity threshold. Query: "${query}"`);
             }
@@ -84,26 +82,9 @@ export const createSearchCodebaseTool = (server) => {
             const similarityScore = vectorResults[0].score;
             // Check if best match meets threshold - prevents traversing low-relevance results
             if (similarityScore < minSimilarity) {
-                await debugLog('Best match below similarity threshold', {
-                    projectId: resolvedProjectId,
-                    query,
-                    score: similarityScore,
-                    threshold: minSimilarity,
-                });
                 return createSuccessResponse(`No sufficiently relevant code found. Best match score: ${similarityScore.toFixed(3)} ` +
                     `(threshold: ${minSimilarity}). Try rephrasing your query.`);
             }
-            await debugLog('Vector search completed, starting traversal', {
-                projectId: resolvedProjectId,
-                nodeId,
-                similarityScore,
-                resultsCount: vectorResults.length,
-                maxDepth: sanitizedMaxDepth,
-                maxNodesPerChain: sanitizedMaxNodesPerChain,
-                skip: sanitizedSkip,
-                includeCode,
-                snippetLength: sanitizedSnippetLength,
-            });
             // Include similarity score in the title so users can see relevance
             const scoreDisplay = typeof similarityScore === 'number' ? similarityScore.toFixed(3) : 'N/A';
             return await traversalHandler.traverseFromNode(nodeId, embedding, {