code-graph-context 1.1.0 → 2.0.0

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

@@ -0,0 +1,376 @@
+/**
+ * Watch Manager Service
+ * Manages file watchers for incremental graph updates across projects
+ * Uses @parcel/watcher for high-performance file watching
+ */
+import * as watcher from '@parcel/watcher';
+import { debugLog } from '../utils.js';
+const DEFAULT_EXCLUDE_PATTERNS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.git/**',
+    '**/*.d.ts',
+    '**/*.js.map',
+    '**/*.js',
+];
+const DEFAULT_DEBOUNCE_MS = 1000;
+const MAX_WATCHERS = 10;
+const MAX_PENDING_EVENTS = 1000;
+class WatchManager {
+    watchers = new Map();
+    mcpServer = null;
+    incrementalParseHandler = null;
+    /**
+     * Set the MCP server instance for sending notifications
+     */
+    setMcpServer(server) {
+        this.mcpServer = server;
+    }
+    /**
+     * Set the incremental parse handler function
+     */
+    setIncrementalParseHandler(handler) {
+        this.incrementalParseHandler = handler;
+    }
+    /**
+     * Send a notification via MCP logging (if supported)
+     */
+    sendNotification(notification) {
+        if (!this.mcpServer) {
+            return;
+        }
+        // sendLoggingMessage returns a Promise - use .catch() to handle rejection
+        this.mcpServer
+            .sendLoggingMessage({
+            level: notification.type.includes('failed') ? 'error' : 'info',
+            logger: 'file-watcher',
+            data: notification,
+        })
+            .catch(() => {
+            // MCP logging not supported - silently ignore
+            // This is expected if the client doesn't support logging capability
+        });
+    }
+    /**
+     * Start watching a project for file changes
+     */
+    async startWatching(config) {
+        // Check if already watching this project
+        if (this.watchers.has(config.projectId)) {
+            const existing = this.watchers.get(config.projectId);
+            return this.getWatcherInfoFromState(existing);
+        }
+        // Enforce maximum watcher limit
+        if (this.watchers.size >= MAX_WATCHERS) {
+            throw new Error(`Maximum watcher limit (${MAX_WATCHERS}) reached. ` + `Stop an existing watcher before starting a new one.`);
+        }
+        const fullConfig = {
+            projectPath: config.projectPath,
+            projectId: config.projectId,
+            tsconfigPath: config.tsconfigPath,
+            debounceMs: config.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+            excludePatterns: config.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS,
+        };
+        await debugLog('Creating @parcel/watcher subscription', {
+            watchPath: fullConfig.projectPath,
+            ignored: fullConfig.excludePatterns,
+        });
+        // Create state object first (subscription will be added after)
+        const state = {
+            projectId: fullConfig.projectId,
+            projectPath: fullConfig.projectPath,
+            tsconfigPath: fullConfig.tsconfigPath,
+            subscription: null, // Will be set after successful subscription
+            config: fullConfig,
+            pendingEvents: [],
+            debounceTimer: null,
+            isProcessing: false,
+            isStopping: false,
+            lastUpdateTime: null,
+            status: 'active',
+        };
+        try {
+            // Subscribe to file changes using @parcel/watcher
+            const subscription = await watcher.subscribe(fullConfig.projectPath, (err, events) => {
+                if (err) {
+                    this.handleWatcherError(state, err);
+                    return;
+                }
+                for (const event of events) {
+                    try {
+                        // Filter for TypeScript files
+                        if (!event.path.endsWith('.ts') && !event.path.endsWith('.tsx')) {
+                            continue;
+                        }
+                        // Map parcel event types to our event types
+                        let eventType;
+                        if (event.type === 'create') {
+                            eventType = 'add';
+                        }
+                        else if (event.type === 'delete') {
+                            eventType = 'unlink';
+                        }
+                        else {
+                            eventType = 'change';
+                        }
+                        this.handleFileEvent(state, eventType, event.path);
+                    }
+                    catch (error) {
+                        debugLog('Error processing file event', { error: String(error), path: event.path });
+                    }
+                }
+            }, {
+                ignore: fullConfig.excludePatterns,
+            });
+            state.subscription = subscription;
+            this.watchers.set(fullConfig.projectId, state);
+            await debugLog('Watcher started', { projectId: fullConfig.projectId, projectPath: fullConfig.projectPath });
+            // Check for changes that occurred while watcher was off (run in background)
+            this.syncMissedChanges(state);
+            return this.getWatcherInfoFromState(state);
+        }
+        catch (error) {
+            await debugLog('Failed to start watcher', { error: String(error) });
+            throw error;
+        }
+    }
+    /**
+     * Handle a file system event
+     */
+    handleFileEvent(state, type, filePath) {
+        debugLog('File event received', { type, filePath, projectId: state.projectId, status: state.status });
+        // Ignore events if watcher is stopping or not active
+        if (state.isStopping || state.status !== 'active') {
+            debugLog('Ignoring event - watcher not active or stopping', {
+                status: state.status,
+                isStopping: state.isStopping,
+            });
+            return;
+        }
+        const event = {
+            type,
+            filePath,
+            timestamp: Date.now(),
+        };
+        // Prevent unbounded event accumulation - drop oldest events if buffer is full
+        if (state.pendingEvents.length >= MAX_PENDING_EVENTS) {
+            debugLog('Event buffer full, dropping oldest events', { projectId: state.projectId });
+            state.pendingEvents = state.pendingEvents.slice(-Math.floor(MAX_PENDING_EVENTS / 2));
+        }
+        state.pendingEvents.push(event);
+        debugLog('Event added to pending', { pendingCount: state.pendingEvents.length });
+        // Clear existing debounce timer
+        if (state.debounceTimer) {
+            clearTimeout(state.debounceTimer);
+        }
+        // Send immediate notification about file change detected
+        this.sendNotification({
+            type: 'file_change_detected',
+            projectId: state.projectId,
+            projectPath: state.projectPath,
+            data: {
+                filesChanged: state.pendingEvents.filter((e) => e.type === 'change').map((e) => e.filePath),
+                filesAdded: state.pendingEvents.filter((e) => e.type === 'add').map((e) => e.filePath),
+                filesDeleted: state.pendingEvents.filter((e) => e.type === 'unlink').map((e) => e.filePath),
+            },
+            timestamp: new Date().toISOString(),
+        });
+        // Set new debounce timer
+        state.debounceTimer = setTimeout(() => {
+            this.processEvents(state).catch((error) => {
+                console.error('[WatchManager] Error in processEvents:', error);
+            });
+        }, state.config.debounceMs);
+    }
+    /**
+     * Process accumulated file events after debounce period
+     */
+    async processEvents(state) {
+        // Don't process if already processing, no events, or watcher is stopping
+        if (state.isProcessing || state.pendingEvents.length === 0 || state.isStopping)
+            return;
+        state.isProcessing = true;
+        const events = [...state.pendingEvents];
+        state.pendingEvents = [];
+        state.debounceTimer = null;
+        const startTime = Date.now();
+        this.sendNotification({
+            type: 'incremental_parse_started',
+            projectId: state.projectId,
+            projectPath: state.projectPath,
+            data: {
+                filesChanged: events.filter((e) => e.type === 'change').map((e) => e.filePath),
+                filesAdded: events.filter((e) => e.type === 'add').map((e) => e.filePath),
+                filesDeleted: events.filter((e) => e.type === 'unlink').map((e) => e.filePath),
+            },
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            if (!this.incrementalParseHandler) {
+                throw new Error('Incremental parse handler not configured');
+            }
+            const result = await this.incrementalParseHandler(state.projectPath, state.projectId, state.tsconfigPath);
+            state.lastUpdateTime = new Date();
+            const elapsedMs = Date.now() - startTime;
+            this.sendNotification({
+                type: 'incremental_parse_completed',
+                projectId: state.projectId,
+                projectPath: state.projectPath,
+                data: {
+                    filesChanged: events.filter((e) => e.type === 'change').map((e) => e.filePath),
+                    filesAdded: events.filter((e) => e.type === 'add').map((e) => e.filePath),
+                    filesDeleted: events.filter((e) => e.type === 'unlink').map((e) => e.filePath),
+                    nodesUpdated: result.nodesUpdated,
+                    edgesUpdated: result.edgesUpdated,
+                    elapsedMs,
+                },
+                timestamp: new Date().toISOString(),
+            });
+            console.log(`[WatchManager] Incremental parse completed for ${state.projectId}: ` +
+                `${result.nodesUpdated} nodes, ${result.edgesUpdated} edges in ${elapsedMs}ms`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.sendNotification({
+                type: 'incremental_parse_failed',
+                projectId: state.projectId,
+                projectPath: state.projectPath,
+                data: {
+                    error: errorMessage,
+                    elapsedMs: Date.now() - startTime,
+                },
+                timestamp: new Date().toISOString(),
+            });
+            console.error(`[WatchManager] Incremental parse failed for ${state.projectId}:`, error);
+        }
+        finally {
+            state.isProcessing = false;
+        }
+    }
+    /**
+     * Handle watcher error
+     */
+    handleWatcherError(state, error) {
+        state.status = 'error';
+        state.errorMessage = error instanceof Error ? error.message : String(error);
+        debugLog('Watcher error', { projectId: state.projectId, error: state.errorMessage });
+        // Clean up the failed watcher to prevent it from staying in error state indefinitely
+        this.stopWatching(state.projectId).catch((cleanupError) => {
+            console.error(`[WatchManager] Failed to cleanup errored watcher ${state.projectId}:`, cleanupError);
+        });
+    }
+    /**
+     * Sync any changes that occurred while the watcher was off
+     * Runs in the background without blocking watcher startup
+     * Promise is tracked on state to allow cleanup during stop
+     */
+    syncMissedChanges(state) {
+        if (!this.incrementalParseHandler)
+            return;
+        // Track the promise on state so stopWatching can wait for it
+        state.syncPromise = this.incrementalParseHandler(state.projectPath, state.projectId, state.tsconfigPath)
+            .then((result) => {
+            if (result.nodesUpdated > 0 || result.edgesUpdated > 0) {
+                console.log(`[WatchManager] Synced missed changes for ${state.projectId}: ` +
+                    `${result.nodesUpdated} nodes, ${result.edgesUpdated} edges`);
+            }
+        })
+            .catch((error) => {
+            // Only log if watcher hasn't been stopped
+            if (!state.isStopping) {
+                console.error(`[WatchManager] Failed to sync missed changes for ${state.projectId}:`, error);
+            }
+        })
+            .finally(() => {
+            state.syncPromise = undefined;
+        });
+    }
+    /**
+     * Stop watching a project
+     * Waits for any in-progress processing to complete before cleanup
+     */
+    async stopWatching(projectId) {
+        const state = this.watchers.get(projectId);
+        if (!state) {
+            return false;
+        }
+        // Mark as stopping to prevent new event processing
+        state.isStopping = true;
+        state.status = 'paused';
+        // Clear debounce timer
+        if (state.debounceTimer) {
+            clearTimeout(state.debounceTimer);
+            state.debounceTimer = null;
+        }
+        // Wait for any in-progress processing to complete (with timeout)
+        const maxWaitMs = 30000; // 30 second timeout
+        const startTime = Date.now();
+        while (state.isProcessing && Date.now() - startTime < maxWaitMs) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        // Wait for sync promise if it exists (with timeout)
+        if (state.syncPromise) {
+            try {
+                await Promise.race([
+                    state.syncPromise,
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Sync timeout')), 5000)),
+                ]);
+            }
+            catch {
+                // Timeout or error - continue with cleanup
+            }
+        }
+        // Unsubscribe from @parcel/watcher (only if subscription exists)
+        if (state.subscription) {
+            try {
+                await state.subscription.unsubscribe();
+            }
+            catch (error) {
+                console.warn(`[WatchManager] Error unsubscribing watcher for ${projectId}:`, error);
+            }
+        }
+        this.watchers.delete(projectId);
+        console.log(`[WatchManager] Stopped watching project: ${projectId}`);
+        return true;
+    }
+    /**
+     * Get watcher info for a project
+     */
+    getWatcherInfo(projectId) {
+        const state = this.watchers.get(projectId);
+        if (!state)
+            return undefined;
+        return this.getWatcherInfoFromState(state);
+    }
+    /**
+     * List all active watchers
+     */
+    listWatchers() {
+        return Array.from(this.watchers.values()).map((state) => this.getWatcherInfoFromState(state));
+    }
+    /**
+     * Stop all watchers (for shutdown)
+     */
+    async stopAllWatchers() {
+        const projectIds = Array.from(this.watchers.keys());
+        await Promise.all(projectIds.map((id) => this.stopWatching(id)));
+        console.log(`[WatchManager] Stopped all ${projectIds.length} watchers`);
+    }
+    /**
+     * Convert internal state to public info
+     */
+    getWatcherInfoFromState(state) {
+        return {
+            projectId: state.projectId,
+            projectPath: state.projectPath,
+            status: state.status,
+            lastUpdateTime: state.lastUpdateTime?.toISOString() ?? null,
+            pendingChanges: state.pendingEvents.length,
+            debounceMs: state.config.debounceMs,
+            errorMessage: state.errorMessage,
+        };
+    }
+}
+// Singleton instance
+export const watchManager = new WatchManager();

package/dist/mcp/services.js

@@ -31,12 +31,12 @@ const discoverSchemaFromGraph = async (neo4jService) => {
             nodeTypes: nodeTypes.map((r) => ({
                 label: r.label,
                 count: typeof r.nodeCount === 'object' ? r.nodeCount.toNumber() : r.nodeCount,
-                properties: r.sampleProperties || [],
+                properties: r.sampleProperties ?? [],
             })),
             relationshipTypes: relationshipTypes.map((r) => ({
                 type: r.relationshipType,
                 count: typeof r.relCount === 'object' ? r.relCount.toNumber() : r.relCount,
-                connections: r.connections || [],
+                connections: r.connections ?? [],
             })),
             semanticTypes: semanticTypes.map((r) => ({
                 type: r.semanticType,

package/dist/mcp/tools/check-parse-status.tool.js

@@ -0,0 +1,64 @@
+/**
+ * Check Parse Status Tool
+ * Returns the status of an async parsing job
+ */
+import { z } from 'zod';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { jobManager } from '../services/job-manager.js';
+import { createErrorResponse, createSuccessResponse } from '../utils.js';
+const formatProgress = (job) => {
+    const { progress } = job;
+    const progressPct = progress.filesTotal > 0 ? Math.round((progress.filesProcessed / progress.filesTotal) * 100) : 0;
+    const unit = progress.phase === 'resolving' ? 'edges' : 'files';
+    const lines = [
+        `Status: ${job.status}`,
+        `Phase: ${progress.phase}`,
+        `Progress: ${progressPct}% (${progress.filesProcessed}/${progress.filesTotal} ${unit})`,
+    ];
+    if (progress.totalChunks > 0) {
+        lines.push(`Chunk: ${progress.currentChunk}/${progress.totalChunks}`);
+    }
+    lines.push(`Nodes: ${progress.nodesImported}`);
+    lines.push(`Edges: ${progress.edgesImported}`);
+    return lines.join('\n');
+};
+const formatCompleted = (job) => {
+    if (!job.result) {
+        return 'Parsing completed (no result data)';
+    }
+    return [
+        `Parsing completed!`,
+        ``,
+        `Nodes: ${job.result.nodesImported}`,
+        `Edges: ${job.result.edgesImported}`,
+        `Time: ${(job.result.elapsedMs / 1000).toFixed(2)}s`,
+        `Project ID: ${job.projectId}`,
+    ].join('\n');
+};
+const formatFailed = (job) => {
+    return `Parsing failed: ${job.error ?? 'Unknown error'}`;
+};
+export const createCheckParseStatusTool = (server) => {
+    server.registerTool(TOOL_NAMES.checkParseStatus, {
+        title: TOOL_METADATA[TOOL_NAMES.checkParseStatus].title,
+        description: TOOL_METADATA[TOOL_NAMES.checkParseStatus].description,
+        inputSchema: {
+            jobId: z.string().describe('Job ID returned from async parse_typescript_project'),
+        },
+    }, async ({ jobId }) => {
+        const job = jobManager.getJob(jobId);
+        if (!job) {
+            return createErrorResponse(`Job not found: ${jobId}\n\nJobs are automatically cleaned up after 1 hour.`);
+        }
+        switch (job.status) {
+            case 'completed':
+                return createSuccessResponse(formatCompleted(job));
+            case 'failed':
+                return createErrorResponse(formatFailed(job));
+            case 'pending':
+            case 'running':
+            default:
+                return createSuccessResponse(formatProgress(job));
+        }
+    });
+};

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

@@ -6,7 +6,7 @@
 import { z } from 'zod';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
-import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+import { createErrorResponse, createSuccessResponse, debugLog, resolveProjectIdOrError } from '../utils.js';
 // Default relationship weights for core AST relationships
 const DEFAULT_RELATIONSHIP_WEIGHTS = {
     // Critical - inheritance/interface contracts
@@ -35,6 +35,7 @@ export const createImpactAnalysisTool = (server) => {
         title: TOOL_METADATA[TOOL_NAMES.impactAnalysis].title,
         description: TOOL_METADATA[TOOL_NAMES.impactAnalysis].description,
         inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
             nodeId: z
                 .string()
                 .optional()
@@ -53,13 +54,24 @@ export const createImpactAnalysisTool = (server) => {
                 .default(4),
             frameworkConfig: FrameworkConfigSchema.optional().describe('Framework-specific configuration for risk scoring. Includes relationshipWeights (e.g., {"INJECTS": 0.9}), highRiskTypes (e.g., ["Controller", "Service"]), and optional name.'),
         },
-    }, async ({ nodeId, filePath, maxDepth = 4, frameworkConfig }) => {
+    }, async ({ projectId, nodeId, filePath, maxDepth = 4, frameworkConfig }) => {
+        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 (!nodeId && !filePath) {
                 return createErrorResponse('Either nodeId or filePath must be provided');
             }
-            await debugLog('Impact analysis started', { nodeId, filePath, maxDepth, frameworkConfig });
-            const neo4jService = new Neo4jService();
+            await debugLog('Impact analysis started', {
+                projectId: resolvedProjectId,
+                nodeId,
+                filePath,
+                maxDepth,
+                frameworkConfig,
+            });
             // Merge default weights with framework-specific weights
             const weights = { ...DEFAULT_RELATIONSHIP_WEIGHTS, ...frameworkConfig?.relationshipWeights };
             const highRiskTypes = new Set(frameworkConfig?.highRiskTypes ?? []);
@@ -67,9 +79,9 @@ export const createImpactAnalysisTool = (server) => {
             let directDependents;
             if (nodeId) {
                 // Get target node info
-                const targetResult = await neo4jService.run(QUERIES.GET_NODE_BY_ID, { nodeId });
+                const targetResult = await neo4jService.run(QUERIES.GET_NODE_BY_ID, { nodeId, projectId: resolvedProjectId });
                 if (targetResult.length === 0) {
-                    return createErrorResponse(`Node with ID "${nodeId}" not found`);
+                    return createErrorResponse(`Node with ID "${nodeId}" not found in project "${resolvedProjectId}"`);
                 }
                 const target = targetResult[0];
                 targetInfo = {
@@ -79,25 +91,76 @@ export const createImpactAnalysisTool = (server) => {
                     filePath: target.filePath ?? '',
                 };
                 // Get direct dependents using cross-file edge pattern
-                const directResult = await neo4jService.run(QUERIES.GET_NODE_IMPACT, { nodeId });
+                const directResult = await neo4jService.run(QUERIES.GET_NODE_IMPACT, {
+                    nodeId,
+                    projectId: resolvedProjectId,
+                });
                 directDependents = normalizeDependents(directResult);
             }
             else {
-                // File-based analysis
-                targetInfo = {
-                    id: filePath,
-                    name: filePath.split('/').pop() ?? filePath,
-                    type: 'SourceFile',
-                    filePath: filePath,
-                };
-                // Get all external dependents on this file
-                const fileResult = await neo4jService.run(QUERIES.GET_FILE_IMPACT, { filePath });
-                directDependents = normalizeDependents(fileResult);
+                // File-based analysis - find all Class/Function/Interface entities in the file
+                // and aggregate their impact analysis results
+                const entitiesQuery = `
+            MATCH (n)
+            WHERE n.projectId = $projectId
+              AND (n.filePath = $filePath OR n.filePath ENDS WITH '/' + $filePath)
+              AND (n:Class OR n:Function OR n:Interface)
+            RETURN n.id AS nodeId, n.name AS name, labels(n) AS labels,
+                   n.semanticType AS semanticType, n.coreType AS coreType
+          `;
+                const entities = await neo4jService.run(entitiesQuery, {
+                    filePath,
+                    projectId: resolvedProjectId,
+                });
+                if (entities.length === 0) {
+                    // No exportable entities found
+                    targetInfo = {
+                        id: filePath,
+                        name: filePath.split('/').pop() ?? filePath,
+                        type: 'SourceFile',
+                        filePath: filePath,
+                    };
+                    directDependents = [];
+                }
+                else {
+                    // Use first entity as the primary target for display
+                    const primaryEntity = entities[0];
+                    targetInfo = {
+                        id: primaryEntity.nodeId,
+                        name: primaryEntity.name ?? filePath.split('/').pop() ?? filePath,
+                        type: primaryEntity.semanticType ?? primaryEntity.coreType ?? 'Class',
+                        filePath: filePath,
+                    };
+                    // Aggregate impact from all entities in the file
+                    const allDependentsMap = new Map();
+                    for (const entity of entities) {
+                        const entityResult = await neo4jService.run(QUERIES.GET_NODE_IMPACT, {
+                            nodeId: entity.nodeId,
+                            projectId: resolvedProjectId,
+                        });
+                        for (const dep of normalizeDependents(entityResult)) {
+                            // Dedupe by nodeId, keeping highest weight
+                            const existing = allDependentsMap.get(dep.nodeId);
+                            if (!existing || dep.weight > existing.weight) {
+                                allDependentsMap.set(dep.nodeId, dep);
+                            }
+                        }
+                    }
+                    directDependents = Array.from(allDependentsMap.values());
+                    // Update nodeId for transitive analysis if we have dependents
+                    if (directDependents.length > 0 && entities.length > 0) {
+                        // Use first entity's nodeId for transitive analysis
+                        nodeId = primaryEntity.nodeId;
+                    }
+                }
             }
             // Get transitive dependents if nodeId provided
             let transitiveDependents = [];
             if (nodeId && maxDepth > 1) {
-                const transitiveResult = await neo4jService.run(QUERIES.GET_TRANSITIVE_DEPENDENTS(maxDepth), { nodeId });
+                const transitiveResult = await neo4jService.run(QUERIES.GET_TRANSITIVE_DEPENDENTS(maxDepth), {
+                    nodeId,
+                    projectId: resolvedProjectId,
+                });
                 transitiveDependents = normalizeTransitiveDependents(transitiveResult);
                 // Filter out direct dependents from transitive
                 const directIds = new Set(directDependents.map((d) => d.nodeId));
@@ -147,6 +210,9 @@ export const createImpactAnalysisTool = (server) => {
             await debugLog('Impact analysis error', { nodeId, filePath, error });
             return createErrorResponse(error);
         }
+        finally {
+            await neo4jService.close();
+        }
     });
 };
 // Helper functions

package/dist/mcp/tools/index.js

@@ -2,11 +2,16 @@
  * MCP Tool Factory
  * Centralized tool creation and registration
  */
+import { createCheckParseStatusTool } from './check-parse-status.tool.js';
 import { createHelloTool } from './hello.tool.js';
 import { createImpactAnalysisTool } from './impact-analysis.tool.js';
+import { createListProjectsTool } from './list-projects.tool.js';
+import { createListWatchersTool } from './list-watchers.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 { createStartWatchProjectTool } from './start-watch-project.tool.js';
+import { createStopWatchProjectTool } from './stop-watch-project.tool.js';
 import { createTestNeo4jConnectionTool } from './test-neo4j-connection.tool.js';
 import { createTraverseFromNodeTool } from './traverse-from-node.tool.js';
 /**
@@ -21,6 +26,13 @@ export const registerAllTools = (server) => {
     createTraverseFromNodeTool(server);
     createNaturalLanguageToCypherTool(server);
     createImpactAnalysisTool(server);
-    // Register project parsing tool
+    // Register project parsing tools
     createParseTypescriptProjectTool(server);
+    createCheckParseStatusTool(server);
+    // Register project management tools
+    createListProjectsTool(server);
+    // Register file watch tools
+    createStartWatchProjectTool(server);
+    createStopWatchProjectTool(server);
+    createListWatchersTool(server);
 };