code-graph-context 0.1.0 → 1.1.0

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

@@ -3,12 +3,16 @@
  * Parses TypeScript/NestJS projects and builds Neo4j graph
  */
 import { writeFileSync } from 'fs';
-import { join } from 'path';
+import { stat } from 'fs/promises';
+import { join, resolve } from 'path';
+import { glob } from 'glob';
 import { z } from 'zod';
+import { EXCLUDE_PATTERNS_GLOB } from '../../constants.js';
 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 { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { hashFile } from '../../utils/file-utils.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';
@@ -38,58 +42,41 @@ export const createParseTypescriptProjectTool = (server) => {
                 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,
+            const neo4jService = new Neo4jService();
+            const embeddingsService = new EmbeddingsService();
+            const graphGeneratorHandler = new GraphGeneratorHandler(neo4jService, embeddingsService);
+            const graphData = await parseProject({
+                neo4jService,
+                tsconfigPath,
+                projectPath,
+                clearExisting,
+                projectType,
             });
-            // Create graph JSON output
+            const { nodes, edges, savedCrossFileEdges } = graphData;
+            console.log(`Parsed ${nodes.length} nodes / ${edges.length} edges`);
+            await debugLog('Parsing completed', { nodeCount: nodes.length, edgeCount: edges.length });
             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);
+                // Recreate cross-file edges after incremental parse
+                if (!clearExisting && savedCrossFileEdges.length > 0) {
+                    await debugLog('Recreating cross-file edges', { edgesToRecreate: savedCrossFileEdges.length });
+                    const recreateResult = await neo4jService.run(QUERIES.RECREATE_CROSS_FILE_EDGES, {
+                        edges: savedCrossFileEdges,
+                    });
+                    const recreatedCount = recreateResult[0]?.recreatedCount ?? 0;
+                    await debugLog('Cross-file edges recreated', { recreatedCount, expected: savedCrossFileEdges.length });
+                }
                 console.log('Graph generation completed:', result);
                 await debugLog('Neo4j import completed', result);
-                const successMessage = formatParseSuccess(cleanNodes.length, cleanEdges.length, result);
-                return createSuccessResponse(successMessage);
+                return createSuccessResponse(formatParseSuccess(nodes.length, edges.length, result));
             }
             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);
+                return createSuccessResponse(formatParsePartialSuccess(nodes.length, edges.length, outputPath, neo4jError.message));
             }
         }
         catch (error) {
@@ -99,3 +86,101 @@ export const createParseTypescriptProjectTool = (server) => {
         }
     });
 };
+const parseProject = async (options) => {
+    const { neo4jService, tsconfigPath, projectPath, clearExisting = true, projectType = 'auto' } = options;
+    const parser = projectType === 'auto'
+        ? await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath)
+        : ParserFactory.createParser({
+            workspacePath: projectPath,
+            tsConfigPath: tsconfigPath,
+            projectType: projectType,
+        });
+    let incrementalStats;
+    let savedCrossFileEdges = [];
+    if (clearExisting) {
+        // Full rebuild: parse all files
+        await parser.parseWorkspace();
+    }
+    else {
+        // Incremental: detect changes and parse only affected files
+        const { filesToReparse, filesToDelete } = await detectChangedFiles(projectPath, neo4jService);
+        incrementalStats = { filesReparsed: filesToReparse.length, filesDeleted: filesToDelete.length };
+        await debugLog('Incremental change detection', { filesToReparse, filesToDelete });
+        const filesToRemoveFromGraph = [...filesToDelete, ...filesToReparse];
+        if (filesToRemoveFromGraph.length > 0) {
+            // Save cross-file edges before deletion (they'll be recreated after import)
+            savedCrossFileEdges = await getCrossFileEdges(neo4jService, filesToRemoveFromGraph);
+            await debugLog('Saved cross-file edges', { count: savedCrossFileEdges.length, edges: savedCrossFileEdges });
+            await deleteSourceFileSubgraphs(neo4jService, filesToRemoveFromGraph);
+        }
+        if (filesToReparse.length > 0) {
+            await debugLog('Incremental parse starting', {
+                filesChanged: filesToReparse.length,
+                filesDeleted: filesToDelete.length,
+            });
+            // Load existing nodes from Neo4j for edge target matching
+            const existingNodes = await loadExistingNodesForEdgeDetection(neo4jService, filesToRemoveFromGraph);
+            await debugLog('Loaded existing nodes for edge detection', { count: existingNodes.length });
+            parser.setExistingNodes(existingNodes);
+            await parser.parseWorkspace(filesToReparse);
+        }
+        else {
+            await debugLog('Incremental parse: no changes detected');
+        }
+    }
+    const { nodes, edges } = parser.exportToJson();
+    const frameworkSchemas = parser['frameworkSchemas']?.map((s) => s.name) ?? ['Auto-detected'];
+    return {
+        nodes,
+        edges,
+        savedCrossFileEdges,
+        metadata: {
+            coreSchema: CORE_TYPESCRIPT_SCHEMA.name,
+            frameworkSchemas,
+            projectType,
+            generated: new Date().toISOString(),
+            ...(incrementalStats && { incremental: incrementalStats }),
+        },
+    };
+};
+const deleteSourceFileSubgraphs = async (neo4jService, filePaths) => {
+    await neo4jService.run(QUERIES.DELETE_SOURCE_FILE_SUBGRAPHS, { filePaths });
+};
+const loadExistingNodesForEdgeDetection = async (neo4jService, excludeFilePaths) => {
+    const queryResult = await neo4jService.run(QUERIES.GET_EXISTING_NODES_FOR_EDGE_DETECTION, { excludeFilePaths });
+    return queryResult;
+};
+const getCrossFileEdges = async (neo4jService, filePaths) => {
+    const queryResult = await neo4jService.run(QUERIES.GET_CROSS_FILE_EDGES, { filePaths });
+    return queryResult;
+};
+const detectChangedFiles = async (projectPath, neo4jService) => {
+    const relativeFiles = await glob('**/*.ts', { cwd: projectPath, ignore: EXCLUDE_PATTERNS_GLOB });
+    const currentFiles = new Set(relativeFiles.map((f) => resolve(projectPath, f)));
+    const queryResult = await neo4jService.run(QUERIES.GET_SOURCE_FILE_TRACKING_INFO);
+    const indexedFiles = queryResult;
+    const indexedMap = new Map(indexedFiles.map((f) => [f.filePath, f]));
+    const filesToReparse = [];
+    const filesToDelete = [];
+    for (const absolutePath of currentFiles) {
+        const indexed = indexedMap.get(absolutePath);
+        if (!indexed) {
+            filesToReparse.push(absolutePath);
+            continue;
+        }
+        const fileStats = await stat(absolutePath);
+        if (fileStats.mtimeMs === indexed.mtime && fileStats.size === indexed.size) {
+            continue;
+        }
+        const currentHash = await hashFile(absolutePath);
+        if (currentHash !== indexed.contentHash) {
+            filesToReparse.push(absolutePath);
+        }
+    }
+    for (const indexedPath of indexedMap.keys()) {
+        if (!currentFiles.has(indexedPath)) {
+            filesToDelete.push(indexedPath);
+        }
+    }
+    return { filesToReparse, filesToDelete };
+};

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

@@ -14,12 +14,6 @@ export const createSearchCodebaseTool = (server) => {
         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()
@@ -50,19 +44,19 @@ export const createSearchCodebaseTool = (server) => {
                 .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, }) => {
+    }, async ({ query, maxDepth = DEFAULTS.traversalDepth, maxNodesPerChain = 5, skip = 0, includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, useWeightedTraversal = true, }) => {
         try {
-            await debugLog('Search codebase started', { query, limit });
+            await debugLog('Search codebase started', { query });
             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()),
+                limit: 1,
                 embedding,
             });
             if (vectorResults.length === 0) {
-                await debugLog('No relevant code found', { query, limit });
+                await debugLog('No relevant code found', { query });
                 return createSuccessResponse(MESSAGES.errors.noRelevantCode);
             }
             const startNode = vectorResults[0].node;

package/dist/mcp/utils.js

@@ -2,22 +2,8 @@
  * MCP Server Utility Functions
  * Common utility functions used across the MCP server
  */
-import fs from 'fs/promises';
-import path from 'path';
-import { FILE_PATHS, LOG_CONFIG, MESSAGES } from './constants.js';
-/**
- * Debug logging utility
- */
-export const debugLog = async (message, data) => {
-    const timestamp = new Date().toISOString();
-    const logEntry = `[${timestamp}] ${message}\n${data ? JSON.stringify(data, null, LOG_CONFIG.jsonIndentation) : ''}\n${LOG_CONFIG.logSeparator}\n`;
-    try {
-        await fs.appendFile(path.join(process.cwd(), FILE_PATHS.debugLog), logEntry);
-    }
-    catch (error) {
-        console.error('Failed to write debug log:', error);
-    }
-};
+import { MESSAGES } from './constants.js';
+export { debugLog } from '../utils/file-utils.js';
 /**
  * Standard error response format for MCP tools
  */
@@ -69,7 +55,8 @@ export const formatNodeInfo = (value, key) => {
             else {
                 // Show first 500 and last 500 characters
                 const half = Math.floor(maxLength / 2);
-                result.sourceCode = code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
+                result.sourceCode =
+                    code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
                 result.hasMore = true;
                 result.truncated = code.length - maxLength;
             }

package/dist/storage/neo4j/neo4j.service.js

@@ -81,15 +81,70 @@ export const QUERIES = {
   RETURN {
     id: node.id,
     labels: labels(node),
-    properties: apoc.map.removeKeys(properties(node), ['embedding'])
+    properties: apoc.map.removeKeys(properties(node), ['embedding', 'contentHash', 'mtime', 'size'])
   } as node, score
   ORDER BY score DESC
 `,
     // Check if index exists
     CHECK_VECTOR_INDEX: `
-    SHOW INDEXES YIELD name, type 
+    SHOW INDEXES YIELD name, type
     WHERE name = 'node_embedding_idx' AND type = 'VECTOR'
     RETURN count(*) > 0 as exists
+  `,
+    GET_SOURCE_FILE_TRACKING_INFO: `
+    MATCH (sf:SourceFile)
+    RETURN sf.filePath AS filePath, sf.mtime AS mtime, sf.size AS size, sf.contentHash AS contentHash
+  `,
+    // Get cross-file edges before deletion (edges where one endpoint is outside the subgraph)
+    // These will be recreated after import using deterministic IDs
+    GET_CROSS_FILE_EDGES: `
+    MATCH (sf:SourceFile)
+    WHERE sf.filePath IN $filePaths
+    OPTIONAL MATCH (sf)-[*]->(child)
+    WITH collect(DISTINCT sf) + collect(DISTINCT child) AS nodesToDelete
+    UNWIND nodesToDelete AS n
+    MATCH (n)-[r]-(other)
+    WHERE NOT other IN nodesToDelete
+    RETURN DISTINCT
+      startNode(r).id AS startNodeId,
+      endNode(r).id AS endNodeId,
+      type(r) AS edgeType,
+      properties(r) AS edgeProperties
+  `,
+    // Delete source file subgraphs (nodes and all their edges)
+    DELETE_SOURCE_FILE_SUBGRAPHS: `
+    MATCH (sf:SourceFile)
+    WHERE sf.filePath IN $filePaths
+    OPTIONAL MATCH (sf)-[*]->(child)
+    DETACH DELETE sf, child
+  `,
+    // Recreate cross-file edges after import (uses deterministic IDs)
+    RECREATE_CROSS_FILE_EDGES: `
+    UNWIND $edges AS edge
+    MATCH (startNode {id: edge.startNodeId})
+    MATCH (endNode {id: edge.endNodeId})
+    CALL apoc.create.relationship(startNode, edge.edgeType, edge.edgeProperties, endNode) YIELD rel
+    RETURN count(rel) AS recreatedCount
+  `,
+    // Clean up dangling edges (edges pointing to non-existent nodes)
+    // Run after incremental parse to remove edges to renamed/deleted nodes
+    CLEANUP_DANGLING_EDGES: `
+    MATCH ()-[r]->()
+    WHERE startNode(r) IS NULL OR endNode(r) IS NULL
+    DELETE r
+    RETURN count(r) AS deletedCount
+  `,
+    // Get existing nodes (excluding files being reparsed) for edge target matching
+    // Returns minimal info needed for edge detection: id, name, coreType, semanticType
+    GET_EXISTING_NODES_FOR_EDGE_DETECTION: `
+    MATCH (sf:SourceFile)-[*]->(n)
+    WHERE NOT sf.filePath IN $excludeFilePaths
+    RETURN n.id AS id,
+           n.name AS name,
+           n.coreType AS coreType,
+           n.semanticType AS semanticType,
+           labels(n) AS labels,
+           sf.filePath AS filePath
   `,
     EXPLORE_ALL_CONNECTIONS: (maxDepth = MAX_TRAVERSAL_DEPTH, direction = 'BOTH', relationshipTypes) => {
         const safeMaxDepth = Math.min(Math.max(maxDepth, 1), MAX_TRAVERSAL_DEPTH);
@@ -123,7 +178,7 @@ export const QUERIES = {
         RETURN {
           id: connected.id,
           labels: labels(connected),
-          properties: apoc.map.removeKeys(properties(connected), ['embedding'])
+          properties: apoc.map.removeKeys(properties(connected), ['embedding', 'contentHash', 'mtime', 'size'])
         } as node,
         depth,
         [rel in relationships(path) | {
@@ -148,7 +203,7 @@ export const QUERIES = {
         startNode: {
           id: start.id,
           labels: labels(start),
-          properties: apoc.map.removeKeys(properties(start), ['embedding'])
+          properties: apoc.map.removeKeys(properties(start), ['embedding', 'contentHash', 'mtime', 'size'])
         },
         connections: connections,
         totalConnections: size(allConnections),
@@ -156,7 +211,7 @@ export const QUERIES = {
           nodes: [conn in connections | conn.node] + [{
             id: start.id,
             labels: labels(start),
-            properties: apoc.map.removeKeys(properties(start), ['embedding'])
+            properties: apoc.map.removeKeys(properties(start), ['embedding', 'contentHash', 'mtime', 'size'])
           }],
           relationships: reduce(rels = [], conn in connections | rels + conn.relationshipChain)
         }
@@ -252,7 +307,7 @@ export const QUERIES = {
         node: {
           id: neighbor.id,
           labels: labels(neighbor),
-          properties: apoc.map.removeKeys(properties(neighbor), ['embedding'])
+          properties: apoc.map.removeKeys(properties(neighbor), ['embedding', 'contentHash', 'mtime', 'size'])
         },
         relationship: {
           type: type(rel),
@@ -274,4 +329,144 @@ export const QUERIES = {
       LIMIT ${maxNodesPerDepth}
     `;
     },
+    // ============================================
+    // DYNAMIC SCHEMA DISCOVERY QUERIES
+    // ============================================
+    /**
+     * Get all distinct node labels with counts and sample properties
+     */
+    DISCOVER_NODE_TYPES: `
+    CALL db.labels() YIELD label
+    CALL {
+      WITH label
+      MATCH (n) WHERE label IN labels(n)
+      WITH n LIMIT 1
+      RETURN keys(n) AS sampleProperties
+    }
+    CALL {
+      WITH label
+      MATCH (n) WHERE label IN labels(n)
+      RETURN count(n) AS nodeCount
+    }
+    RETURN label, nodeCount, sampleProperties
+    ORDER BY nodeCount DESC
+  `,
+    /**
+     * Get all distinct relationship types with counts and which node types they connect
+     */
+    DISCOVER_RELATIONSHIP_TYPES: `
+    CALL db.relationshipTypes() YIELD relationshipType
+    CALL {
+      WITH relationshipType
+      MATCH (a)-[r]->(b) WHERE type(r) = relationshipType
+      WITH labels(a)[0] AS fromLabel, labels(b)[0] AS toLabel
+      RETURN fromLabel, toLabel
+      LIMIT 10
+    }
+    CALL {
+      WITH relationshipType
+      MATCH ()-[r]->() WHERE type(r) = relationshipType
+      RETURN count(r) AS relCount
+    }
+    RETURN relationshipType, relCount, collect(DISTINCT {from: fromLabel, to: toLabel}) AS connections
+    ORDER BY relCount DESC
+  `,
+    /**
+     * Get sample nodes of each semantic type for context
+     */
+    DISCOVER_SEMANTIC_TYPES: `
+    MATCH (n)
+    WHERE n.semanticType IS NOT NULL
+    WITH n.semanticType AS semanticType, count(*) AS count
+    ORDER BY count DESC
+    RETURN semanticType, count
+  `,
+    /**
+     * Get example query patterns based on actual graph structure
+     */
+    DISCOVER_COMMON_PATTERNS: `
+    MATCH (a)-[r]->(b)
+    WITH labels(a)[0] AS fromType, type(r) AS relType, labels(b)[0] AS toType, count(*) AS count
+    WHERE count > 5
+    RETURN fromType, relType, toType, count
+    ORDER BY count DESC
+    LIMIT 20
+  `,
+    // ============================================
+    // IMPACT ANALYSIS QUERIES
+    // Reuses cross-file edge pattern to find dependents
+    // ============================================
+    /**
+     * Get node details by ID
+     */
+    GET_NODE_BY_ID: `
+    MATCH (n) WHERE n.id = $nodeId
+    RETURN n.id AS id,
+           n.name AS name,
+           labels(n) AS labels,
+           n.semanticType AS semanticType,
+           n.coreType AS coreType,
+           n.filePath AS filePath
+  `,
+    /**
+     * Get impact of changing a node - finds all external nodes that depend on it
+     * Based on GET_CROSS_FILE_EDGES pattern but for a single node
+     */
+    GET_NODE_IMPACT: `
+    MATCH (target) WHERE target.id = $nodeId
+    MATCH (dependent)-[r]->(target)
+    WHERE dependent.id <> target.id
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      type(r) AS relationshipType,
+      coalesce(r.relationshipWeight, 0.5) AS weight
+  `,
+    /**
+     * Get impact of changing a file - finds all external nodes that depend on nodes in this file
+     * Directly reuses GET_CROSS_FILE_EDGES pattern
+     */
+    GET_FILE_IMPACT: `
+    MATCH (sf:SourceFile {filePath: $filePath})
+    OPTIONAL MATCH (sf)-[*]->(child)
+    WITH collect(DISTINCT sf) + collect(DISTINCT child) AS nodesInFile
+    UNWIND nodesInFile AS n
+    MATCH (dependent)-[r]->(n)
+    WHERE NOT dependent IN nodesInFile
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      type(r) AS relationshipType,
+      coalesce(r.relationshipWeight, 0.5) AS weight,
+      n.id AS targetNodeId,
+      n.name AS targetNodeName
+  `,
+    /**
+     * Get transitive dependents - nodes that depend on dependents (for deeper impact)
+     */
+    GET_TRANSITIVE_DEPENDENTS: (maxDepth = 4) => `
+    MATCH (target) WHERE target.id = $nodeId
+    MATCH path = (dependent)-[*2..${maxDepth}]->(target)
+    WITH dependent,
+         length(path) AS depth,
+         [r IN relationships(path) | type(r)] AS relationshipPath
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      depth,
+      relationshipPath
+    ORDER BY depth ASC
+  `,
 };

package/dist/utils/file-utils.js

@@ -0,0 +1,20 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const DEBUG_LOG_FILE = 'debug-search.log';
+const LOG_SEPARATOR = '---';
+const JSON_INDENT = 2;
+export const hashFile = async (filePath) => {
+    const content = await fs.readFile(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+};
+export const debugLog = async (message, data) => {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message}\n${data ? JSON.stringify(data, null, JSON_INDENT) : ''}\n${LOG_SEPARATOR}\n`;
+    try {
+        await fs.appendFile(path.join(process.cwd(), DEBUG_LOG_FILE), logEntry);
+    }
+    catch (error) {
+        console.error('Failed to write debug log:', error);
+    }
+};

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "code-graph-context",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
+  "homepage": "https://github.com/drewdrewH/code-graph-context#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/drewdrewH/code-graph-context.git"