code-graph-context 1.0.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

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

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));
+        }
+    });
+};