code-graph-context 1.1.0 → 2.0.0

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

@@ -0,0 +1,62 @@
+/**
+ * List Projects Tool
+ * Lists all parsed projects in the database
+ */
+import { LIST_PROJECTS_QUERY } from '../../core/utils/project-id.js';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+export const createListProjectsTool = (server) => {
+    server.registerTool(TOOL_NAMES.listProjects, {
+        title: TOOL_METADATA[TOOL_NAMES.listProjects].title,
+        description: TOOL_METADATA[TOOL_NAMES.listProjects].description,
+        inputSchema: {},
+    }, 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.');
+            }
+            const projects = results.map((r) => ({
+                projectId: r.projectId,
+                name: r.name,
+                path: r.path,
+                status: r.status ?? 'unknown',
+                nodeCount: r.nodeCount,
+                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) => {
+                if (p.status === 'complete' && p.nodeCount !== null) {
+                    return `  Stats: ${p.nodeCount} nodes, ${p.edgeCount ?? 0} edges`;
+                }
+                return '';
+            };
+            const projectList = projects
+                .map((p) => `- ${p.name} [${p.status}]\n` +
+                `  ID: ${p.projectId}\n` +
+                `  Path: ${p.path}\n` +
+                formatStats(p) +
+                (formatStats(p) ? '\n' : '') +
+                `  Updated: ${p.updatedAt}`)
+                .join('\n\n');
+            const tip = '\n\nTip: Use the project name (e.g., "' +
+                projects[0].name +
+                '") in other tools instead of the full projectId.';
+            return createSuccessResponse(header + projectList + tip);
+        }
+        catch (error) {
+            console.error('List projects error:', error);
+            await debugLog('List projects error', { error });
+            return createErrorResponse(error);
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};

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

@@ -0,0 +1,51 @@
+/**
+ * List Watchers Tool
+ * Lists all active file watchers
+ */
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { watchManager } from '../services/watch-manager.js';
+import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+export const createListWatchersTool = (server) => {
+    server.registerTool(TOOL_NAMES.listWatchers, {
+        title: TOOL_METADATA[TOOL_NAMES.listWatchers].title,
+        description: TOOL_METADATA[TOOL_NAMES.listWatchers].description,
+        inputSchema: {},
+    }, async () => {
+        try {
+            await debugLog('Listing watchers');
+            const watchers = watchManager.listWatchers();
+            if (watchers.length === 0) {
+                return createSuccessResponse('No active file watchers.\n\n' +
+                    'To start watching a project:\n' +
+                    '- 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) => {
+                const lines = [
+                    `- ${w.projectId} [${w.status}]`,
+                    `  Path: ${w.projectPath}`,
+                    `  Debounce: ${w.debounceMs}ms`,
+                    `  Pending changes: ${w.pendingChanges}`,
+                ];
+                if (w.lastUpdateTime) {
+                    lines.push(`  Last update: ${w.lastUpdateTime}`);
+                }
+                if (w.errorMessage) {
+                    lines.push(`  Error: ${w.errorMessage}`);
+                }
+                return lines.join('\n');
+            })
+                .join('\n\n');
+            const tip = '\n\nUse stop_watch_project with a project ID to stop watching.';
+            return createSuccessResponse(header + watcherList + tip);
+        }
+        catch (error) {
+            console.error('List watchers error:', error);
+            await debugLog('List watchers error', { error });
+            return createErrorResponse(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+};

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

@@ -6,7 +6,7 @@ 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';
+import { createErrorResponse, createSuccessResponse, formatQueryResults, debugLog, resolveProjectIdOrError, } from '../utils.js';
 // Service instance - initialized asynchronously
 let naturalLanguageToCypherService = null;
 /**
@@ -30,20 +30,43 @@ export const createNaturalLanguageToCypherTool = (server) => {
         title: TOOL_METADATA[TOOL_NAMES.naturalLanguageToCypher].title,
         description: TOOL_METADATA[TOOL_NAMES.naturalLanguageToCypher].description,
         inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
             query: z.string().describe('Natural language query to convert to Cypher'),
         },
-    }, async ({ query }) => {
+    }, async ({ projectId, query }) => {
+        const neo4jService = new Neo4jService();
         try {
+            // Resolve project ID from name, path, or ID
+            const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+            if (!projectResult.success)
+                return projectResult.error;
+            const resolvedProjectId = projectResult.projectId;
             if (!naturalLanguageToCypherService) {
-                await debugLog('Natural language service not available', { query });
+                await debugLog('Natural language service not available', { projectId: resolvedProjectId, 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('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 };
+            try {
+                await neo4jService.run(`EXPLAIN ${cypherResult.cypher}`, parameters);
+            }
+            catch (validationError) {
+                const message = validationError instanceof Error ? validationError.message : String(validationError);
+                await debugLog('Generated Cypher validation failed', {
+                    cypher: cypherResult.cypher,
+                    error: message,
+                });
+                return createErrorResponse(`Generated Cypher query has syntax errors:\n\n` +
+                    `Query: ${cypherResult.cypher}\n\n` +
+                    `Error: ${message}\n\n` +
+                    `Try rephrasing your request or use a simpler query.`);
+            }
+            // 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,
             });
@@ -55,5 +78,8 @@ export const createNaturalLanguageToCypherTool = (server) => {
             await debugLog('Natural language to Cypher error', { query, error });
             return createErrorResponse(error);
         }
+        finally {
+            await neo4jService.close();
+        }
     });
 };