code-graph-context 0.1.0

package/dist/mcp/services.js

@@ -0,0 +1,158 @@
+/**
+ * Service Initialization
+ * Handles initialization of external services like Neo4j schema and OpenAI assistant
+ */
+import fs from 'fs/promises';
+import { join } from 'path';
+import { Neo4jService } from '../storage/neo4j/neo4j.service.js';
+import { FILE_PATHS, LOG_CONFIG } from './constants.js';
+import { initializeNaturalLanguageService } from './tools/natural-language-to-cypher.tool.js';
+import { debugLog } from './utils.js';
+/**
+ * Initialize all external services required by the MCP server
+ */
+export const initializeServices = async () => {
+    await Promise.all([initializeNeo4jSchema(), initializeNaturalLanguageService()]);
+};
+/**
+ * Enrich raw Neo4j schema with FairSquare domain context
+ */
+const enrichSchemaWithDomainContext = (rawSchema) => {
+    return {
+        rawSchema,
+        domainContext: {
+            framework: 'FairSquare',
+            description: 'Custom TypeScript framework for microservices with dependency injection and repository patterns',
+            nodeTypes: {
+                Controller: {
+                    description: 'HTTP request handlers that extend the Controller base class',
+                    purpose: 'Entry points for HTTP API endpoints',
+                    commonProperties: ['name', 'filePath', 'sourceCode'],
+                    exampleQuery: 'MATCH (c:Controller) WHERE c.name =~ ".*Credit.*" RETURN c',
+                },
+                Service: {
+                    description: 'Business logic layer with @Injectable decorator',
+                    purpose: 'Encapsulate business logic and orchestrate data operations',
+                    commonProperties: ['name', 'filePath', 'dependencies'],
+                    exampleQuery: 'MATCH (s:Service)-[:INJECTS]->(dep) RETURN s.name, collect(dep.name) as dependencies',
+                },
+                Repository: {
+                    description: 'Data access layer that extends Repository base class',
+                    purpose: 'Abstract database operations and provide data access interface',
+                    commonProperties: ['name', 'filePath', 'dals'],
+                    exampleQuery: 'MATCH (r:Repository)-[:USES_DAL]->(d:DAL) RETURN r.name, collect(d.name) as dals',
+                },
+                DAL: {
+                    description: 'Data Access Layer - direct database interaction classes',
+                    purpose: 'Execute database queries and manage data persistence',
+                    commonProperties: ['name', 'filePath'],
+                    exampleQuery: 'MATCH (d:DAL)<-[:USES_DAL]-(r:Repository) RETURN d.name, count(r) as usedByCount',
+                },
+                PermissionManager: {
+                    description: 'Security layer for authorization checks',
+                    purpose: 'Control access to resources and validate permissions',
+                    commonProperties: ['name', 'filePath'],
+                    exampleQuery: 'MATCH (c:Controller)-[:PROTECTED_BY]->(pm:PermissionManager) RETURN c.name, pm.name',
+                },
+                VendorClient: {
+                    description: 'External service integration clients',
+                    purpose: 'Interface with third-party APIs and services',
+                    commonProperties: ['name', 'filePath'],
+                    exampleQuery: 'MATCH (v:VendorClient)<-[:INJECTS]-(s) RETURN v.name, collect(s.name) as usedBy',
+                },
+                RouteDefinition: {
+                    description: 'Explicit route definitions from route files. CRITICAL: Individual route details (method, path, authenticated, handler, controllerName) are stored in the "context" property as a JSON string.',
+                    purpose: 'Map HTTP paths and methods to controller handlers',
+                    commonProperties: ['name', 'context', 'filePath', 'sourceCode'],
+                    contextStructure: 'The context property contains JSON with structure: {"routes": [{"method": "POST", "path": "/v1/endpoint", "controllerName": "SomeController", "handler": "methodName", "authenticated": true}]}',
+                    parsingInstructions: 'To get individual routes: (1) Parse JSON with apoc.convert.fromJsonMap(rd.context) (2) UNWIND the routes array (3) Access route.method, route.path, route.handler, route.authenticated, route.controllerName',
+                    exampleQuery: 'MATCH (rd:RouteDefinition) WITH rd, apoc.convert.fromJsonMap(rd.context) AS ctx UNWIND ctx.routes AS route RETURN route.method, route.path, route.controllerName, route.handler, route.authenticated ORDER BY route.path',
+                },
+                HttpEndpoint: {
+                    description: 'Methods that handle HTTP requests',
+                    purpose: 'Process incoming HTTP requests and return responses',
+                    commonProperties: ['name', 'filePath', 'sourceCode'],
+                    exampleQuery: 'MATCH (e:HttpEndpoint)<-[r:ROUTES_TO_HANDLER]-(rd) WHERE apoc.convert.fromJsonMap(r.context).authenticated = true RETURN e.name, apoc.convert.fromJsonMap(r.context).path as path',
+                },
+            },
+            relationships: {
+                INJECTS: {
+                    description: 'Dependency injection relationship from @Injectable decorator',
+                    direction: 'OUTGOING',
+                    example: 'Controller -[:INJECTS]-> Service',
+                    commonPatterns: ['Controller -> Service', 'Service -> Repository', 'Service -> VendorClient'],
+                },
+                USES_DAL: {
+                    description: 'Repository uses Data Access Layer for database operations',
+                    direction: 'OUTGOING',
+                    example: 'Repository -[:USES_DAL]-> DAL',
+                    commonPatterns: ['Repository -> DAL'],
+                },
+                ROUTES_TO: {
+                    description: 'Route definition points to a Controller',
+                    direction: 'OUTGOING',
+                    example: 'RouteDefinition -[:ROUTES_TO]-> Controller',
+                    commonPatterns: ['RouteDefinition -> Controller'],
+                },
+                ROUTES_TO_HANDLER: {
+                    description: 'Route definition points to a specific handler method',
+                    direction: 'OUTGOING',
+                    example: 'RouteDefinition -[:ROUTES_TO_HANDLER]-> HttpEndpoint',
+                    contextProperties: ['path', 'method', 'authenticated', 'handler', 'controllerName'],
+                    contextNote: 'IMPORTANT: context is stored as a JSON string. Access properties using apoc.convert.fromJsonMap(r.context).propertyName',
+                    commonPatterns: ['RouteDefinition -> HttpEndpoint (Method)'],
+                },
+                PROTECTED_BY: {
+                    description: 'Controller is protected by a PermissionManager',
+                    direction: 'OUTGOING',
+                    example: 'Controller -[:PROTECTED_BY]-> PermissionManager',
+                    commonPatterns: ['Controller -> PermissionManager'],
+                },
+            },
+            commonQueryPatterns: [
+                {
+                    intent: 'Find all HTTP endpoints',
+                    query: 'MATCH (e:HttpEndpoint) RETURN e.name, e.filePath',
+                },
+                {
+                    intent: 'Find service dependency chain',
+                    query: 'MATCH path = (c:Controller)-[:INJECTS*1..3]->(s) RETURN [n in nodes(path) | n.name] as chain',
+                },
+                {
+                    intent: 'Find all authenticated routes',
+                    query: 'MATCH (rd:RouteDefinition)-[r:ROUTES_TO_HANDLER]->(m) WHERE apoc.convert.fromJsonMap(r.context).authenticated = true RETURN apoc.convert.fromJsonMap(r.context).path as path, apoc.convert.fromJsonMap(r.context).method as method, m.name',
+                },
+                {
+                    intent: 'Find controllers without permission managers',
+                    query: 'MATCH (c:Controller) WHERE NOT (c)-[:PROTECTED_BY]->(:PermissionManager) RETURN c.name',
+                },
+                {
+                    intent: 'Find what services a controller uses',
+                    query: 'MATCH (c:Controller {name: $controllerName})-[:INJECTS]->(s:Service) RETURN s.name',
+                },
+                {
+                    intent: 'Find complete execution path from controller to database',
+                    query: 'MATCH path = (c:Controller)-[:INJECTS*1..3]->(r:Repository)-[:USES_DAL]->(d:DAL) WHERE c.name = $controllerName RETURN [n in nodes(path) | n.name] as executionPath',
+                },
+            ],
+        },
+    };
+};
+/**
+ * Initialize Neo4j schema by fetching and caching it locally
+ */
+const initializeNeo4jSchema = async () => {
+    try {
+        const neo4jService = new Neo4jService();
+        const rawSchema = await neo4jService.getSchema();
+        // Enrich schema with FairSquare domain context
+        const enrichedSchema = enrichSchemaWithDomainContext(rawSchema);
+        const schemaPath = join(process.cwd(), FILE_PATHS.schemaOutput);
+        await fs.writeFile(schemaPath, JSON.stringify(enrichedSchema, null, LOG_CONFIG.jsonIndentation));
+        await debugLog('Neo4j schema cached successfully with domain context', { schemaPath });
+    }
+    catch (error) {
+        await debugLog('Failed to initialize Neo4j schema', error);
+        // Don't throw - service can still function without cached schema
+    }
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Hello Tool
+ * Simple test tool to verify MCP connection
+ */
+import { TOOL_NAMES, TOOL_METADATA, MESSAGES } from '../constants.js';
+import { createSuccessResponse } from '../utils.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));
+};

package/dist/mcp/tools/index.js

@@ -0,0 +1,24 @@
+/**
+ * MCP Tool Factory
+ * Centralized tool creation and registration
+ */
+import { createHelloTool } from './hello.tool.js';
+import { createNaturalLanguageToCypherTool } from './natural-language-to-cypher.tool.js';
+import { createParseTypescriptProjectTool } from './parse-typescript-project.tool.js';
+import { createSearchCodebaseTool } from './search-codebase.tool.js';
+import { createTestNeo4jConnectionTool } from './test-neo4j-connection.tool.js';
+import { createTraverseFromNodeTool } from './traverse-from-node.tool.js';
+/**
+ * Register all MCP tools with the server
+ */
+export const registerAllTools = (server) => {
+    // Register basic tools
+    createHelloTool(server);
+    createTestNeo4jConnectionTool(server);
+    // Register core functionality tools
+    createSearchCodebaseTool(server);
+    createTraverseFromNodeTool(server);
+    createNaturalLanguageToCypherTool(server);
+    // Register project parsing tool
+    createParseTypescriptProjectTool(server);
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Natural Language to Cypher Tool
+ * Converts natural language queries to Cypher using OpenAI GPT-4
+ */
+import { z } from 'zod';
+import { NaturalLanguageToCypherService } from '../../core/embeddings/natural-language-to-cypher.service.js';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA, MESSAGES } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, formatQueryResults, debugLog } from '../utils.js';
+// Service instance - initialized asynchronously
+let naturalLanguageToCypherService = null;
+/**
+ * Initialize the Natural Language to Cypher service
+ */
+export const initializeNaturalLanguageService = async () => {
+    try {
+        const service = new NaturalLanguageToCypherService();
+        const schemaPath = 'neo4j-apoc-schema.json';
+        await service.getOrCreateAssistant(schemaPath);
+        naturalLanguageToCypherService = service;
+        await debugLog('Natural Language to Cypher service initialized successfully');
+    }
+    catch (error) {
+        await debugLog('Failed to initialize Natural Language to Cypher service', error);
+        naturalLanguageToCypherService = null;
+    }
+};
+export const createNaturalLanguageToCypherTool = (server) => {
+    server.registerTool(TOOL_NAMES.naturalLanguageToCypher, {
+        title: TOOL_METADATA[TOOL_NAMES.naturalLanguageToCypher].title,
+        description: TOOL_METADATA[TOOL_NAMES.naturalLanguageToCypher].description,
+        inputSchema: {
+            query: z.string().describe('Natural language query to convert to Cypher'),
+        },
+    }, async ({ query }) => {
+        try {
+            if (!naturalLanguageToCypherService) {
+                await debugLog('Natural language service not available', { query });
+                return createSuccessResponse(MESSAGES.errors.serviceNotInitialized);
+            }
+            await debugLog('Natural language to Cypher conversion started', { query });
+            const cypherResult = await naturalLanguageToCypherService.promptToQuery(query);
+            const neo4jService = new Neo4jService();
+            // Execute the generated Cypher query
+            const results = await neo4jService.run(cypherResult.cypher, cypherResult.parameters ?? {});
+            await debugLog('Cypher query executed', {
+                cypher: cypherResult.cypher,
+                resultsCount: results.length,
+            });
+            const formattedResponse = formatQueryResults(results, query, cypherResult);
+            return createSuccessResponse(JSON.stringify(formattedResponse, null, 2));
+        }
+        catch (error) {
+            console.error('Natural language to Cypher error:', error);
+            await debugLog('Natural language to Cypher error', { query, error });
+            return createErrorResponse(error);
+        }
+    });
+};

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

@@ -0,0 +1,101 @@
+/**
+ * Parse TypeScript Project Tool
+ * Parses TypeScript/NestJS projects and builds Neo4j graph
+ */
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { z } from 'zod';
+import { CORE_TYPESCRIPT_SCHEMA } from '../../core/config/schema.js';
+import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
+import { ParserFactory } from '../../core/parsers/parser-factory.js';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, FILE_PATHS, LOG_CONFIG } from '../constants.js';
+import { GraphGeneratorHandler } from '../handlers/graph-generator.handler.js';
+import { createErrorResponse, createSuccessResponse, formatParseSuccess, formatParsePartialSuccess, debugLog, } from '../utils.js';
+export const createParseTypescriptProjectTool = (server) => {
+    server.registerTool(TOOL_NAMES.parseTypescriptProject, {
+        title: TOOL_METADATA[TOOL_NAMES.parseTypescriptProject].title,
+        description: TOOL_METADATA[TOOL_NAMES.parseTypescriptProject].description,
+        inputSchema: {
+            projectPath: z.string().describe('Path to the TypeScript project root directory'),
+            tsconfigPath: z.string().describe('Path to TypeScript project tsconfig.json file'),
+            clearExisting: z.boolean().optional().describe('Clear existing graph data first'),
+            excludeNodeTypes: z
+                .array(z.string())
+                .optional()
+                .describe('Node types to skip during parsing, e.g. ["TestFile", "Parameter"]'),
+            projectType: z
+                .enum(['nestjs', 'fairsquare', 'both', 'vanilla', 'auto'])
+                .optional()
+                .default('auto')
+                .describe('Project framework type (auto-detect by default)'),
+        },
+    }, async ({ tsconfigPath, projectPath, clearExisting, projectType = 'auto' }) => {
+        try {
+            await debugLog('TypeScript project parsing started', {
+                projectPath,
+                tsconfigPath,
+                clearExisting,
+                projectType,
+            });
+            // Create parser with auto-detection or specified type
+            let parser;
+            if (projectType === 'auto') {
+                parser = await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath);
+            }
+            else {
+                parser = ParserFactory.createParser({
+                    workspacePath: projectPath,
+                    tsConfigPath: tsconfigPath,
+                    projectType: projectType,
+                });
+            }
+            // Parse the workspace
+            const { nodes, edges } = await parser.parseWorkspace();
+            const { nodes: cleanNodes, edges: cleanEdges } = parser.exportToJson();
+            console.log(`Parsed ${cleanNodes.length} nodes / ${cleanEdges.length} edges`);
+            await debugLog('Parsing completed', {
+                nodeCount: cleanNodes.length,
+                edgeCount: cleanEdges.length,
+            });
+            // Create graph JSON output
+            const outputPath = join(projectPath, FILE_PATHS.graphOutput);
+            // Get detected framework schemas from parser
+            const frameworkSchemas = parser['frameworkSchemas']?.map((s) => s.name) ?? ['Auto-detected'];
+            const graphData = {
+                nodes: cleanNodes,
+                edges: cleanEdges,
+                metadata: {
+                    coreSchema: CORE_TYPESCRIPT_SCHEMA.name,
+                    frameworkSchemas,
+                    projectType,
+                    generated: new Date().toISOString(),
+                },
+            };
+            writeFileSync(outputPath, JSON.stringify(graphData, null, LOG_CONFIG.jsonIndentation));
+            console.log(`Graph data written to ${outputPath}`);
+            // Attempt to import to Neo4j
+            try {
+                const neo4jService = new Neo4jService();
+                const embeddingsService = new EmbeddingsService();
+                const graphGeneratorHandler = new GraphGeneratorHandler(neo4jService, embeddingsService);
+                const result = await graphGeneratorHandler.generateGraph(outputPath, DEFAULTS.batchSize, clearExisting);
+                console.log('Graph generation completed:', result);
+                await debugLog('Neo4j import completed', result);
+                const successMessage = formatParseSuccess(cleanNodes.length, cleanEdges.length, result);
+                return createSuccessResponse(successMessage);
+            }
+            catch (neo4jError) {
+                console.error('Neo4j import failed:', neo4jError);
+                await debugLog('Neo4j import failed', neo4jError);
+                const partialSuccessMessage = formatParsePartialSuccess(cleanNodes.length, cleanEdges.length, outputPath, neo4jError.message);
+                return createSuccessResponse(partialSuccessMessage);
+            }
+        }
+        catch (error) {
+            console.error('Parse tool error:', error);
+            await debugLog('Parse tool error', { projectPath, tsconfigPath, error });
+            return createErrorResponse(error);
+        }
+    });
+};

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

@@ -0,0 +1,97 @@
+/**
+ * Search Codebase Tool
+ * Semantic search using vector embeddings to find relevant code
+ */
+import { z } from 'zod';
+import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
+import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, MESSAGES } from '../constants.js';
+import { TraversalHandler } from '../handlers/traversal.handler.js';
+import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+export const createSearchCodebaseTool = (server) => {
+    server.registerTool(TOOL_NAMES.searchCodebase, {
+        title: TOOL_METADATA[TOOL_NAMES.searchCodebase].title,
+        description: TOOL_METADATA[TOOL_NAMES.searchCodebase].description,
+        inputSchema: {
+            query: z.string().describe('Natural language query to search the codebase'),
+            limit: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Maximum number of results to return (default: ${DEFAULTS.searchLimit})`)
+                .default(DEFAULTS.searchLimit),
+            maxDepth: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Maximum depth to traverse relationships (default: ${DEFAULTS.traversalDepth}, max: 10)`)
+                .default(DEFAULTS.traversalDepth),
+            maxNodesPerChain: z
+                .number()
+                .int()
+                .optional()
+                .describe('Maximum chains to show per depth level (default: 5, applied independently at each depth)')
+                .default(5),
+            skip: z.number().int().optional().describe('Number of results to skip for pagination (default: 0)').default(0),
+            includeCode: z
+                .boolean()
+                .optional()
+                .describe('Include source code snippets in results (default: true)')
+                .default(true),
+            snippetLength: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Length of code snippets to include (default: ${DEFAULTS.codeSnippetLength})`)
+                .default(DEFAULTS.codeSnippetLength),
+            useWeightedTraversal: z
+                .boolean()
+                .optional()
+                .describe('Use weighted traversal strategy that scores each node for relevance (default: false)')
+                .default(true),
+        },
+    }, async ({ query, limit = DEFAULTS.searchLimit, maxDepth = DEFAULTS.traversalDepth, maxNodesPerChain = 5, skip = 0, includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, useWeightedTraversal = true, }) => {
+        try {
+            await debugLog('Search codebase started', { query, limit });
+            const neo4jService = new Neo4jService();
+            const embeddingsService = new EmbeddingsService();
+            const traversalHandler = new TraversalHandler(neo4jService);
+            const embedding = await embeddingsService.embedText(query);
+            const vectorResults = await neo4jService.run(QUERIES.VECTOR_SEARCH, {
+                limit: parseInt(limit.toString()),
+                embedding,
+            });
+            if (vectorResults.length === 0) {
+                await debugLog('No relevant code found', { query, limit });
+                return createSuccessResponse(MESSAGES.errors.noRelevantCode);
+            }
+            const startNode = vectorResults[0].node;
+            const nodeId = startNode.properties.id;
+            await debugLog('Vector search completed, starting traversal', {
+                nodeId,
+                resultsCount: vectorResults.length,
+                maxDepth,
+                maxNodesPerChain,
+                skip,
+                includeCode,
+                snippetLength,
+            });
+            return await traversalHandler.traverseFromNode(nodeId, embedding, {
+                maxDepth,
+                direction: 'BOTH', // Show both incoming (who calls this) and outgoing (what this calls)
+                includeCode,
+                maxNodesPerChain,
+                skip,
+                summaryOnly: false,
+                snippetLength,
+                title: `Exploration from Node: ${nodeId}`,
+                useWeightedTraversal,
+            });
+        }
+        catch (error) {
+            console.error('Search codebase error:', error);
+            await debugLog('Search codebase error', error);
+            return createErrorResponse(error);
+        }
+    });
+};

package/dist/mcp/tools/test-neo4j-connection.tool.js

@@ -0,0 +1,39 @@
+/**
+ * Test Neo4j Connection Tool
+ * Verifies Neo4j connectivity and APOC plugin availability
+ */
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA, MESSAGES } from '../constants.js';
+import { createErrorResponse, createSuccessResponse } from '../utils.js';
+export const createTestNeo4jConnectionTool = (server) => {
+    server.registerTool(TOOL_NAMES.testNeo4jConnection, {
+        title: TOOL_METADATA[TOOL_NAMES.testNeo4jConnection].title,
+        description: TOOL_METADATA[TOOL_NAMES.testNeo4jConnection].description,
+        inputSchema: {},
+    }, async () => {
+        const driver = new Neo4jService().getDriver();
+        try {
+            const session = driver.session();
+            try {
+                const basicResult = await session.run(MESSAGES.neo4j.connectionTest);
+                const apocResult = await session.run(MESSAGES.neo4j.apocTest);
+                const apocCount = apocResult.records[0].get('apocFunctions').toNumber();
+                const message = MESSAGES.neo4j.connectionSuccess
+                    .replace('{}', basicResult.records[0].get('message'))
+                    .replace('{}', basicResult.records[0].get('timestamp'))
+                    .replace('{}', apocCount.toString());
+                return createSuccessResponse(message);
+            }
+            finally {
+                await session.close();
+            }
+        }
+        catch (error) {
+            const errorMessage = `${MESSAGES.errors.connectionTestFailed}: ${error.message}\n${MESSAGES.errors.neo4jRequirement}`;
+            return createErrorResponse(errorMessage);
+        }
+        finally {
+            await driver.close();
+        }
+    });
+};

package/dist/mcp/tools/traverse-from-node.tool.js

@@ -0,0 +1,97 @@
+/**
+ * Traverse From Node Tool
+ * Deep graph traversal from a specific node with pagination support
+ */
+import { z } from 'zod';
+import { MAX_TRAVERSAL_DEPTH } from '../../constants.js';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA, DEFAULTS } from '../constants.js';
+import { TraversalHandler } from '../handlers/traversal.handler.js';
+import { createErrorResponse, sanitizeNumericInput, debugLog } from '../utils.js';
+export const createTraverseFromNodeTool = (server) => {
+    server.registerTool(TOOL_NAMES.traverseFromNode, {
+        title: TOOL_METADATA[TOOL_NAMES.traverseFromNode].title,
+        description: TOOL_METADATA[TOOL_NAMES.traverseFromNode].description,
+        inputSchema: {
+            nodeId: z.string().describe('The node ID to start traversal from'),
+            maxDepth: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Maximum depth to traverse (default: ${DEFAULTS.traversalDepth}, max: ${MAX_TRAVERSAL_DEPTH})`)
+                .default(DEFAULTS.traversalDepth),
+            skip: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Number of results to skip for pagination (default: ${DEFAULTS.skipOffset})`)
+                .default(DEFAULTS.skipOffset),
+            direction: z
+                .enum(['OUTGOING', 'INCOMING', 'BOTH'])
+                .optional()
+                .describe('Filter by relationship direction: OUTGOING (what this calls), INCOMING (who calls this), BOTH (default)')
+                .default('BOTH'),
+            relationshipTypes: z
+                .array(z.string())
+                .optional()
+                .describe('Filter by specific relationship types (e.g., ["INJECTS", "USES_REPOSITORY"]). If not specified, shows all relationships.'),
+            includeCode: z
+                .boolean()
+                .optional()
+                .describe('Include source code snippets in results (default: true, set to false for structure-only view)')
+                .default(true),
+            maxNodesPerChain: z
+                .number()
+                .int()
+                .optional()
+                .describe('Maximum chains to show per depth level (default: 5, applied independently at each depth)')
+                .default(5),
+            summaryOnly: z
+                .boolean()
+                .optional()
+                .describe('Return only summary with file paths and statistics (default: false)')
+                .default(false),
+            snippetLength: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Code snippet character length when includeCode is true (default: ${DEFAULTS.codeSnippetLength})`)
+                .default(DEFAULTS.codeSnippetLength),
+        },
+    }, async ({ nodeId, maxDepth = DEFAULTS.traversalDepth, skip = DEFAULTS.skipOffset, direction = 'BOTH', relationshipTypes, includeCode = true, maxNodesPerChain = 5, summaryOnly = false, snippetLength = DEFAULTS.codeSnippetLength, }) => {
+        try {
+            const sanitizedMaxDepth = sanitizeNumericInput(maxDepth, DEFAULTS.traversalDepth, MAX_TRAVERSAL_DEPTH);
+            const sanitizedSkip = sanitizeNumericInput(skip, DEFAULTS.skipOffset);
+            await debugLog('Node traversal started', {
+                nodeId,
+                maxDepth: sanitizedMaxDepth,
+                skip: sanitizedSkip,
+                direction,
+                relationshipTypes,
+                includeCode,
+                maxNodesPerChain,
+                summaryOnly,
+                snippetLength,
+            });
+            const neo4jService = new Neo4jService();
+            const traversalHandler = new TraversalHandler(neo4jService);
+            return await traversalHandler.traverseFromNode(nodeId, [], {
+                maxDepth: sanitizedMaxDepth,
+                skip: sanitizedSkip,
+                direction,
+                relationshipTypes,
+                includeStartNodeDetails: true,
+                includeCode,
+                maxNodesPerChain,
+                summaryOnly,
+                snippetLength,
+                title: `Node Traversal from: ${nodeId}`,
+            });
+        }
+        catch (error) {
+            console.error('Node traversal error:', error);
+            await debugLog('Node traversal error', { nodeId, error });
+            return createErrorResponse(error);
+        }
+    });
+};