code-graph-context 0.1.0

package/dist/mcp/constants.js

@@ -0,0 +1,141 @@
+/**
+ * MCP Server Constants
+ * All constants used throughout the MCP server implementation
+ */
+// Server Configuration
+export const MCP_SERVER_CONFIG = {
+    name: 'codebase-graph',
+    version: '1.0.0',
+};
+// File Paths
+export const FILE_PATHS = {
+    debugLog: 'debug-search.log',
+    schemaOutput: 'neo4j-apoc-schema.json',
+    graphOutput: 'graph.json',
+};
+// Tool Names
+export const TOOL_NAMES = {
+    hello: 'hello',
+    searchCodebase: 'search_codebase',
+    naturalLanguageToCypher: 'natural_language_to_cypher',
+    traverseFromNode: 'traverse_from_node',
+    parseTypescriptProject: 'parse_typescript_project',
+    testNeo4jConnection: 'test_neo4j_connection',
+};
+// Tool Metadata
+export const TOOL_METADATA = {
+    [TOOL_NAMES.hello]: {
+        title: 'Hello Tool',
+        description: 'Test tool that says hello',
+    },
+    [TOOL_NAMES.searchCodebase]: {
+        title: 'Search Codebase',
+        description: `Search the codebase using semantic similarity to find relevant code, functions, classes, and implementations.
+
+Returns normalized JSON with source code snippets. Uses JSON:API pattern to deduplicate nodes.
+
+**Default Usage (Recommended)**:
+Start with default parameters for richest context in a single call. Most queries complete successfully.
+
+Parameters:
+- query: Natural language description of what you're looking for
+- limit (default: 10): Number of initial vector search results to consider
+
+**Token Optimization (Only if needed)**:
+Use these parameters ONLY if you encounter token limit errors (>25,000 tokens):
+
+- maxDepth (default: 3): Reduce to 1-2 for shallow exploration
+- maxNodesPerChain (default: 5): Limit chains shown per depth level
+- includeCode (default: true): Set false to get structure only, fetch code separately
+- snippetLength (default: 700): Reduce to 400-600 for smaller code snippets
+- skip (default: 0): For pagination (skip N results)
+
+**Progressive Strategy**:
+1. Try with defaults first
+2. If token error: Use maxDepth=1, includeCode=false for structure
+3. Then traverse deeper or Read specific files for full code`,
+    },
+    [TOOL_NAMES.naturalLanguageToCypher]: {
+        title: 'Natural Language to Cypher',
+        description: 'Convert natural language queries into Cypher queries for Neo4j. This tool is useful for generating specific queries based on user requests about the codebase.',
+    },
+    [TOOL_NAMES.traverseFromNode]: {
+        title: 'Traverse from Node',
+        description: `Traverse the graph starting from a specific node ID to explore its connections and relationships in detail.
+
+Parameters:
+- nodeId (required): The node ID to start traversal from (obtained from search_codebase)
+- maxDepth (default: 3): How many relationship hops to traverse (1-10)
+- skip (default: 0): Number of results to skip for pagination
+
+Advanced options (use when needed):
+- includeCode (default: true): Set to false for structure-only view without source code
+- maxNodesPerChain (default: 5): Limit chains shown per depth level (applied independently at each depth)
+- summaryOnly: Set to true for just file paths and statistics without detailed traversal
+
+Best practices:
+- Start with search_codebase to find initial nodes
+- Default includes source code snippets for immediate context
+- Set includeCode: false for high-level architecture view only
+- Use summaryOnly: true for a quick overview of many connections`,
+    },
+    [TOOL_NAMES.parseTypescriptProject]: {
+        title: 'Parse TypeScript Project',
+        description: 'Parse a TypeScript/NestJS project and store in Neo4j graph',
+    },
+    [TOOL_NAMES.testNeo4jConnection]: {
+        title: 'Test Neo4j Connection & APOC',
+        description: 'Test connection to Neo4j database and verify APOC plugin is available',
+    },
+};
+// Default Values
+export const DEFAULTS = {
+    searchLimit: 10,
+    traversalDepth: 3,
+    skipOffset: 0,
+    batchSize: 500,
+    maxResultsDisplayed: 30,
+    codeSnippetLength: 1000,
+    chainSnippetLength: 700,
+};
+// Messages
+export const MESSAGES = {
+    errors: {
+        noRelevantCode: 'No relevant code found.',
+        serviceNotInitialized: 'ERROR: Natural Language to Cypher service is not initialized yet. Please try again in a few moments.',
+        connectionTestFailed: 'Connection test failed',
+        neo4jRequirement: 'Note: This server requires Neo4j with APOC plugin installed',
+        genericError: 'ERROR:',
+    },
+    success: {
+        hello: 'Hello from codebase MCP!',
+        parseSuccess: 'SUCCESS:',
+        partialSuccess: 'PARTIAL SUCCESS:',
+    },
+    queries: {
+        naturalLanguagePrefix: 'Natural Language Query:',
+        cypherQueryHeader: 'Generated Cypher Query',
+        queryResultsHeader: 'Query Results',
+        noResultsFound: 'No results found for this query.',
+        moreResultsIndicator: '_... and {} more results_',
+        summaryPrefix: '**Summary:** Executed query and found {} results.',
+    },
+    neo4j: {
+        connectionTest: 'RETURN "Connected!" as message, datetime() as timestamp',
+        apocTest: 'CALL apoc.help("apoc") YIELD name RETURN count(name) as apocFunctions',
+        connectionSuccess: 'Neo4j connected: {} at {}\nAPOC plugin available with {} functions',
+    },
+    server: {
+        starting: '=== MCP Server Starting ===',
+        connected: '=== MCP Server Connected and Running ===',
+        creatingTransport: 'Creating transport...',
+        connectingTransport: 'Connecting server to transport...',
+        startingServer: 'Starting MCP server...',
+    },
+};
+// Logging Configuration
+export const LOG_CONFIG = {
+    timestampFormat: 'iso',
+    logSeparator: '---',
+    jsonIndentation: 2,
+};

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

@@ -0,0 +1,143 @@
+/**
+ * Graph Generator Handler
+ * Handles importing parsed graph data into Neo4j with embeddings
+ */
+import fs from 'fs/promises';
+import { QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { DEFAULTS } from '../constants.js';
+import { debugLog } from '../utils.js';
+export class GraphGeneratorHandler {
+    neo4jService;
+    embeddingsService;
+    static EMBEDDED_LABEL = 'Embedded';
+    constructor(neo4jService, embeddingsService) {
+        this.neo4jService = neo4jService;
+        this.embeddingsService = embeddingsService;
+    }
+    async generateGraph(graphJsonPath, batchSize = DEFAULTS.batchSize, clearExisting = true) {
+        console.log(`Generating graph from JSON file: ${graphJsonPath}`);
+        await debugLog('Starting graph generation', { graphJsonPath, batchSize, clearExisting });
+        try {
+            const graphData = await this.loadGraphData(graphJsonPath);
+            const { nodes, edges, metadata } = graphData;
+            console.log(`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();
+            }
+            await this.importNodes(nodes, batchSize);
+            await this.importEdges(edges, batchSize);
+            await this.createVectorIndexes();
+            const result = {
+                nodesImported: nodes.length,
+                edgesImported: edges.length,
+                metadata,
+            };
+            await debugLog('Graph generation completed', result);
+            return result;
+        }
+        catch (error) {
+            console.error('generateGraph error:', error);
+            await debugLog('Graph generation error', error);
+            throw error;
+        }
+    }
+    async loadGraphData(graphJsonPath) {
+        const fileContent = await fs.readFile(graphJsonPath, 'utf-8');
+        return JSON.parse(fileContent);
+    }
+    async clearExistingData() {
+        console.log('Clearing existing graph data...');
+        await this.neo4jService.run(QUERIES.CLEAR_DATABASE);
+        await debugLog('Existing graph data cleared');
+    }
+    async importNodes(nodes, batchSize) {
+        console.log(`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}`);
+            await debugLog('Node batch imported', {
+                batchStart: i + 1,
+                batchEnd,
+                created: result[0].created,
+            });
+        }
+    }
+    async processNodeBatch(nodes) {
+        return Promise.all(nodes.map(async (node) => {
+            const embedding = await this.embedNodeSourceCode(node);
+            return {
+                ...node,
+                labels: embedding ? [...node.labels, GraphGeneratorHandler.EMBEDDED_LABEL] : node.labels,
+                properties: {
+                    ...this.flattenProperties(node.properties),
+                    embedding,
+                },
+            };
+        }));
+    }
+    async importEdges(edges, batchSize) {
+        console.log(`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,
+                properties: this.flattenProperties(edge.properties),
+            }));
+            const result = await this.neo4jService.run(QUERIES.CREATE_RELATIONSHIP, { edges: batch });
+            const batchEnd = Math.min(i + batchSize, edges.length);
+            console.log(`Created ${result[0].created} edges in batch ${i + 1}-${batchEnd}`);
+            await debugLog('Edge batch imported', {
+                batchStart: i + 1,
+                batchEnd,
+                created: result[0].created,
+            });
+        }
+    }
+    async createVectorIndexes() {
+        console.log('Creating vector indexes...');
+        await this.neo4jService.run(QUERIES.CREATE_EMBEDDED_VECTOR_INDEX);
+        await debugLog('Vector indexes created');
+    }
+    async embedNodeSourceCode(node) {
+        if (!node.properties?.sourceCode || node.skipEmbedding) {
+            return null;
+        }
+        try {
+            const sourceCode = node.properties.sourceCode;
+            const embedding = await this.embeddingsService.embedText(sourceCode);
+            await debugLog('Node embedded', { nodeId: node.id, codeLength: sourceCode.length });
+            return embedding;
+        }
+        catch (error) {
+            console.warn(`Failed to embed node ${node.id}:`, error);
+            await debugLog('Embedding failed', { nodeId: node.id, error });
+            return null;
+        }
+    }
+    flattenProperties(properties) {
+        const flattened = {};
+        for (const [key, value] of Object.entries(properties)) {
+            if (this.isComplexObject(value)) {
+                // Convert nested objects to JSON strings for Neo4j compatibility
+                flattened[key] = JSON.stringify(value);
+            }
+            else if (this.isComplexArray(value)) {
+                // Convert arrays with objects to JSON strings
+                flattened[key] = JSON.stringify(value);
+            }
+            else {
+                // Keep scalar values as-is
+                flattened[key] = value;
+            }
+        }
+        return flattened;
+    }
+    isComplexObject(value) {
+        return value && typeof value === 'object' && !Array.isArray(value);
+    }
+    isComplexArray(value) {
+        return Array.isArray(value) && value.some((item) => typeof item === 'object');
+    }
+}

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

@@ -0,0 +1,304 @@
+/**
+ * Traversal Handler
+ * Handles graph traversal operations with formatting and pagination
+ */
+import { MAX_TRAVERSAL_DEPTH } from '../../constants.js';
+import { QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { DEFAULTS } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+export class TraversalHandler {
+    neo4jService;
+    static NODE_NOT_FOUND_QUERY = 'MATCH (n) WHERE n.id = $nodeId RETURN n';
+    constructor(neo4jService) {
+        this.neo4jService = neo4jService;
+    }
+    async traverseFromNode(nodeId, embedding, options = {}) {
+        const { maxDepth = DEFAULTS.traversalDepth, skip = DEFAULTS.skipOffset, direction = 'BOTH', relationshipTypes, includeStartNodeDetails = true, includeCode = false, maxNodesPerChain = 5, summaryOnly = false, title = `Node Traversal from: ${nodeId}`, snippetLength = DEFAULTS.codeSnippetLength, useWeightedTraversal = false, } = options;
+        try {
+            await debugLog('Starting node traversal', { nodeId, maxDepth, skip });
+            const startNode = await this.getStartNode(nodeId);
+            if (!startNode) {
+                return createErrorResponse(`Node with ID "${nodeId}" not found.`);
+            }
+            const maxNodesPerDepth = Math.ceil(maxNodesPerChain * 1.5);
+            const traversalData = useWeightedTraversal
+                ? await this.performTraversalByDepth(nodeId, embedding, maxDepth, maxNodesPerDepth, direction, relationshipTypes)
+                : await this.performTraversal(nodeId, embedding, maxDepth, skip, direction, relationshipTypes);
+            if (!traversalData) {
+                return createSuccessResponse(`No connections found for node "${nodeId}".`);
+            }
+            const result = summaryOnly
+                ? this.formatSummaryOnlyJSON(startNode, traversalData, title)
+                : this.formatTraversalJSON(startNode, traversalData, title, includeStartNodeDetails, includeCode, maxNodesPerChain, snippetLength);
+            await debugLog('Traversal completed', {
+                connectionsFound: traversalData.connections.length,
+                uniqueFiles: this.getUniqueFileCount(traversalData.connections),
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result) }],
+            };
+        }
+        catch (error) {
+            console.error('Node traversal error:', error);
+            await debugLog('Node traversal error', { nodeId, error });
+            return createErrorResponse(error);
+        }
+    }
+    async getStartNode(nodeId) {
+        const startNodeResult = await this.neo4jService.run(TraversalHandler.NODE_NOT_FOUND_QUERY, { nodeId });
+        return startNodeResult.length > 0 ? startNodeResult[0].n : null;
+    }
+    async performTraversal(nodeId, embedding, maxDepth, skip, direction = 'BOTH', relationshipTypes) {
+        const traversal = await this.neo4jService.run(QUERIES.EXPLORE_ALL_CONNECTIONS(Math.min(maxDepth, MAX_TRAVERSAL_DEPTH), direction, relationshipTypes), {
+            nodeId,
+            skip: parseInt(skip.toString()),
+        });
+        if (traversal.length === 0) {
+            return null;
+        }
+        const result = traversal[0]?.result ?? {};
+        return {
+            connections: result.connections ?? [],
+            graph: result.graph ?? { nodes: [], relationships: [] },
+        };
+    }
+    async performTraversalByDepth(nodeId, embedding, maxDepth, maxNodesPerDepth, direction = 'BOTH', relationshipTypes) {
+        // Track visited nodes to avoid cycles
+        const visitedNodeIds = new Set([nodeId]);
+        // Track the path (chain of relationships) to reach each node
+        // Key: nodeId, Value: array of relationships from start node to this node
+        const pathsToNode = new Map();
+        pathsToNode.set(nodeId, []); // Start node has empty path
+        // Track which nodes to explore at each depth
+        let currentSourceIds = [nodeId];
+        // Result accumulators
+        const allConnections = [];
+        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}`);
+                break;
+            }
+            const traversalResults = await this.neo4jService.run(QUERIES.EXPLORE_DEPTH_LEVEL(direction, maxNodesPerDepth), {
+                sourceNodeIds: currentSourceIds,
+                visitedNodeIds: Array.from(visitedNodeIds),
+                currentDepth: parseInt(depth.toString()),
+                queryEmbedding: embedding,
+                depthDecay: 0.85,
+            });
+            if (traversalResults.length === 0) {
+                console.log(`No connections found at depth ${depth}`);
+                break;
+            }
+            // Collect node IDs for next depth exploration
+            const nextSourceIds = [];
+            for (const row of traversalResults) {
+                const { node, relationship, sourceNodeId, scoring } = row.result;
+                const neighborId = node.id;
+                // Skip if already visited (safety check)
+                if (visitedNodeIds.has(neighborId))
+                    continue;
+                // Mark as visited
+                visitedNodeIds.add(neighborId);
+                nextSourceIds.push(neighborId);
+                // Build the relationship chain:
+                // This node's chain = parent's chain + this relationship
+                const parentPath = pathsToNode.get(sourceNodeId) ?? [];
+                const thisPath = [
+                    ...parentPath,
+                    {
+                        type: relationship.type,
+                        start: relationship.startNodeId,
+                        end: relationship.endNodeId,
+                        properties: relationship.properties,
+                        score: scoring.combinedScore,
+                    },
+                ];
+                pathsToNode.set(neighborId, thisPath);
+                // Create connection with full relationship chain
+                const connection = {
+                    depth,
+                    node: node,
+                    relationshipChain: thisPath,
+                };
+                allConnections.push(connection);
+                // Accumulate unique nodes
+                nodeMap.set(neighborId, node);
+            }
+            // Move to next depth with the newly discovered nodes
+            currentSourceIds = nextSourceIds;
+        }
+        return {
+            connections: allConnections,
+        };
+    }
+    groupConnectionsByDepth(connections) {
+        return connections.reduce((acc, conn) => {
+            const depth = conn.depth;
+            acc[depth] ??= [];
+            acc[depth].push(conn);
+            return acc;
+        }, {});
+    }
+    getRelationshipDirection(connection, startNodeId) {
+        // Check the first relationship in the chain to determine direction from start node
+        const firstRel = connection.relationshipChain?.[0];
+        if (!firstRel?.start || !firstRel.end) {
+            return 'UNKNOWN';
+        }
+        // If the start node is the source of the first relationship, it's OUTGOING
+        // If the start node is the target of the first relationship, it's INCOMING
+        if (firstRel.start === startNodeId) {
+            return 'OUTGOING';
+        }
+        else if (firstRel.end === startNodeId) {
+            return 'INCOMING';
+        }
+        return 'UNKNOWN';
+    }
+    getUniqueFileCount(connections) {
+        return new Set(connections.map((c) => c.node.properties.filePath).filter(Boolean)).size;
+    }
+    formatTraversalJSON(startNode, traversalData, title, includeStartNodeDetails, includeCode, maxNodesPerChain, snippetLength) {
+        // JSON:API normalization - collect all unique nodes
+        const nodeMap = new Map();
+        // Get common root path from all nodes
+        const allNodes = [startNode, ...traversalData.connections.map((c) => c.node)];
+        const projectRoot = this.getCommonRootPath(allNodes);
+        // Add start node to map
+        if (includeStartNodeDetails) {
+            const startNodeData = this.formatNodeJSON(startNode, includeCode, snippetLength, projectRoot);
+            nodeMap.set(startNode.properties.id, startNodeData);
+        }
+        // Collect all unique nodes from connections
+        traversalData.connections.forEach((conn) => {
+            const nodeId = conn.node.properties.id;
+            if (!nodeMap.has(nodeId)) {
+                nodeMap.set(nodeId, this.formatNodeJSON(conn.node, includeCode, snippetLength, projectRoot));
+            }
+        });
+        const byDepth = this.groupConnectionsByDepth(traversalData.connections);
+        return {
+            projectRoot,
+            totalConnections: traversalData.connections.length,
+            uniqueFiles: this.getUniqueFileCount(traversalData.connections),
+            maxDepth: Object.keys(byDepth).length > 0 ? Math.max(...Object.keys(byDepth).map((d) => parseInt(d))) : 0,
+            startNodeId: includeStartNodeDetails ? startNode.properties.id : undefined,
+            nodes: Object.fromEntries(nodeMap),
+            depths: this.formatConnectionsByDepthWithReferences(byDepth, maxNodesPerChain),
+        };
+    }
+    formatSummaryOnlyJSON(startNode, traversalData, title) {
+        const byDepth = this.groupConnectionsByDepth(traversalData.connections);
+        const totalConnections = traversalData.connections.length;
+        const maxDepthFound = Object.keys(byDepth).length > 0 ? Math.max(...Object.keys(byDepth).map((d) => parseInt(d))) : 0;
+        const uniqueFiles = this.getUniqueFileCount(traversalData.connections);
+        const allNodes = [startNode, ...traversalData.connections.map((c) => c.node)];
+        const projectRoot = this.getCommonRootPath(allNodes);
+        const fileMap = new Map();
+        traversalData.connections.forEach((conn) => {
+            const filePath = conn.node.properties.filePath;
+            if (filePath) {
+                const relativePath = this.makeRelativePath(filePath, projectRoot);
+                fileMap.set(relativePath, (fileMap.get(relativePath) ?? 0) + 1);
+            }
+        });
+        const connectedFiles = Array.from(fileMap.entries())
+            .sort((a, b) => b[1] - a[1])
+            .map(([file, count]) => ({ file, nodeCount: count }));
+        const maxSummaryFiles = DEFAULTS.maxResultsDisplayed;
+        return {
+            projectRoot,
+            startNodeId: startNode.properties.id,
+            nodes: {
+                [startNode.properties.id]: this.formatNodeJSON(startNode, false, 0, projectRoot),
+            },
+            totalConnections,
+            maxDepth: maxDepthFound,
+            uniqueFiles,
+            files: connectedFiles.slice(0, maxSummaryFiles),
+            ...(fileMap.size > maxSummaryFiles && { hasMore: fileMap.size - maxSummaryFiles }),
+        };
+    }
+    formatNodeJSON(node, includeCode, snippetLength, projectRoot) {
+        const result = {
+            id: node.properties.id,
+            type: node.properties.semanticType ?? node.labels.at(-1) ?? 'Unknown',
+            filePath: projectRoot ? this.makeRelativePath(node.properties.filePath, projectRoot) : node.properties.filePath,
+        };
+        if (node.properties.name) {
+            result.name = node.properties.name;
+        }
+        if (includeCode && node.properties.sourceCode && node.properties.coreType !== 'SourceFile') {
+            const code = node.properties.sourceCode;
+            const maxLength = snippetLength; // Use the provided snippet length
+            if (code.length <= maxLength) {
+                result.sourceCode = code;
+            }
+            else {
+                // Show first half and last half of the snippet
+                const half = Math.floor(maxLength / 2);
+                result.sourceCode =
+                    code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
+                result.hasMore = true;
+                result.truncated = code.length - maxLength;
+            }
+        }
+        return result;
+    }
+    formatConnectionsByDepthWithReferences(byDepth, maxNodesPerChain) {
+        return Object.keys(byDepth)
+            .sort((a, b) => parseInt(a) - parseInt(b))
+            .map((depth) => {
+            const depthConnections = byDepth[parseInt(depth)];
+            const connectionsToShow = Math.min(depthConnections.length, maxNodesPerChain);
+            const chains = depthConnections.slice(0, connectionsToShow).map((conn) => {
+                return (conn.relationshipChain?.map((rel) => ({
+                    type: rel.type,
+                    from: rel.start,
+                    to: rel.end,
+                })) ?? []);
+            });
+            return {
+                depth: parseInt(depth),
+                count: depthConnections.length,
+                chains,
+                ...(depthConnections.length > connectionsToShow && {
+                    hasMore: depthConnections.length - connectionsToShow,
+                }),
+            };
+        });
+    }
+    getCommonRootPath(nodes) {
+        const filePaths = nodes.map((n) => n.properties.filePath).filter(Boolean);
+        if (filePaths.length === 0)
+            return process.cwd();
+        // Split all paths into parts
+        const pathParts = filePaths.map((p) => p.split('/'));
+        // Find common prefix
+        const commonParts = [];
+        const firstPath = pathParts[0];
+        for (let i = 0; i < firstPath.length; i++) {
+            const part = firstPath[i];
+            if (pathParts.every((p) => p[i] === part)) {
+                commonParts.push(part);
+            }
+            else {
+                break;
+            }
+        }
+        return commonParts.join('/') || '/';
+    }
+    makeRelativePath(absolutePath, projectRoot) {
+        if (!absolutePath)
+            return '';
+        if (!projectRoot || projectRoot === '/')
+            return absolutePath;
+        // Ensure both paths end consistently
+        const root = projectRoot.endsWith('/') ? projectRoot : projectRoot + '/';
+        if (absolutePath.startsWith(root)) {
+            return absolutePath.substring(root.length);
+        }
+        return absolutePath;
+    }
+}

package/dist/mcp/mcp.server.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ *
+ * MCP Server - Main Entry Point
+ * Clean, modular architecture for the Code Graph Context MCP Server
+ */
+// Load environment variables from .env file
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+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') });
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { MCP_SERVER_CONFIG, MESSAGES } from './constants.js';
+import { initializeServices } from './services.js';
+import { registerAllTools } from './tools/index.js';
+import { debugLog } from './utils.js';
+/**
+ * Main server initialization and startup
+ */
+const startServer = async () => {
+    console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.starting }));
+    // Create MCP server instance
+    const server = new McpServer({
+        name: MCP_SERVER_CONFIG.name,
+        version: MCP_SERVER_CONFIG.version,
+    });
+    // Register all tools
+    registerAllTools(server);
+    // Initialize external services (non-blocking)
+    initializeServices().catch((error) => {
+        debugLog('Service initialization error', error);
+    });
+    // Create and connect transport
+    console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.creatingTransport }));
+    const transport = new StdioServerTransport();
+    console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.connectingTransport }));
+    await server.connect(transport);
+    console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.connected }));
+};
+// Start the server
+console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.startingServer }));
+await startServer();