@vfarcic/dot-ai 1.0.3 → 1.1.0

package/dist/interfaces/rest-api.js

@@ -42,6 +42,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestApiRouter = exports.HttpStatus = void 0;
 const node_url_1 = require("node:url");
 const openapi_generator_1 = require("./openapi-generator");
+const rest_route_registry_1 = require("./rest-route-registry");
+const routes_1 = require("./routes");
 const resource_sync_handler_1 = require("./resource-sync-handler");
 const prompts_1 = require("../tools/prompts");
 const generic_session_manager_1 = require("../core/generic-session-manager");
@@ -51,6 +53,8 @@ const ai_provider_factory_1 = require("../core/ai-provider-factory");
 const capability_tools_1 = require("../core/capability-tools");
 const resource_tools_1 = require("../core/resource-tools");
 const mermaid_tools_1 = require("../core/mermaid-tools");
+const plugin_registry_1 = require("../core/plugin-registry");
+const manage_knowledge_1 = require("../tools/manage-knowledge");
 /**
  * HTTP status codes for REST responses
  */
@@ -69,6 +73,7 @@ var HttpStatus;
  */
 class RestApiRouter {
     registry;
+    routeRegistry;
     logger;
     dotAI;
     config;
@@ -87,14 +92,23 @@ class RestApiRouter {
             requestTimeout: 1800000, // 30 minutes for long-running operations (capability scan with slower AI providers)
             ...config
         };
-        // Initialize OpenAPI generator
+        // Initialize route registry and register all routes (PRD #354)
+        this.routeRegistry = new rest_route_registry_1.RestRouteRegistry(logger);
+        (0, routes_1.registerAllRoutes)(this.routeRegistry);
+        this.logger.info('REST route registry initialized', {
+            routeCount: this.routeRegistry.getRouteCount(),
+            tags: this.routeRegistry.getTags(),
+        });
+        // Initialize OpenAPI generator with route registry (PRD #354)
         this.openApiGenerator = new openapi_generator_1.OpenApiGenerator(registry, logger, {
             basePath: this.config.basePath,
-            apiVersion: this.config.version
-        });
+            apiVersion: this.config.version,
+        }, this.routeRegistry);
     }
     /**
      * Handle incoming HTTP requests for REST API
+     *
+     * PRD #354: Uses route registry for matching, dispatches to handlers based on route path.
      */
     async handleRequest(req, res, body) {
         const requestId = this.generateRequestId();
@@ -115,141 +129,35 @@ class RestApiRouter {
                     return;
                 }
             }
-            // Parse URL and route
+            // Parse URL
             const url = new node_url_1.URL(req.url || '/', 'http://localhost');
-            const pathMatch = this.parseApiPath(url.pathname);
-            if (!pathMatch) {
-                await this.sendErrorResponse(res, requestId, HttpStatus.NOT_FOUND, 'NOT_FOUND', 'API endpoint not found');
+            const method = req.method || 'GET';
+            // PRD #354: Try route registry first
+            const routeMatch = this.routeRegistry.findRoute(method, url.pathname);
+            if (routeMatch) {
+                this.logger.debug('Route matched via registry', {
+                    requestId,
+                    path: routeMatch.route.path,
+                    method: routeMatch.route.method,
+                    params: routeMatch.params,
+                });
+                // Dispatch to handler based on route path
+                await this.dispatchRoute(req, res, requestId, routeMatch, url.searchParams, body, startTime);
                 return;
             }
-            // Route to appropriate handler
-            switch (pathMatch.endpoint) {
-                case 'tools':
-                    if (req.method === 'GET') {
-                        await this.handleToolDiscovery(req, res, requestId, url.searchParams);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for tool discovery');
-                    }
-                    break;
-                case 'tool':
-                    if (req.method === 'POST' && pathMatch.toolName) {
-                        await this.handleToolExecution(req, res, requestId, pathMatch.toolName, body, startTime);
-                    }
-                    else if (req.method !== 'POST') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only POST method allowed for tool execution');
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Tool name is required');
-                    }
-                    break;
-                case 'openapi':
-                    if (req.method === 'GET') {
-                        await this.handleOpenApiSpec(req, res, requestId);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for OpenAPI specification');
-                    }
-                    break;
-                case 'resources':
-                    if (req.method === 'POST' && pathMatch.action === 'sync') {
-                        await this.handleResourceSyncRequest(req, res, requestId, body);
-                    }
-                    else if (req.method === 'GET' && pathMatch.action === 'kinds') {
-                        await this.handleGetResourceKinds(req, res, requestId, url.searchParams);
-                    }
-                    else if (req.method === 'GET' && pathMatch.action === 'search') {
-                        await this.handleSearchResources(req, res, requestId, url.searchParams);
-                    }
-                    else if (req.method === 'GET' && pathMatch.action === 'list') {
-                        await this.handleListResources(req, res, requestId, url.searchParams);
-                    }
-                    else if (pathMatch.action === 'sync' && req.method !== 'POST') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only POST method allowed for resource sync');
-                    }
-                    else if ((pathMatch.action === 'kinds' || pathMatch.action === 'list' || pathMatch.action === 'search') && req.method !== 'GET') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for this endpoint');
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.NOT_FOUND, 'NOT_FOUND', 'Unknown resources endpoint');
-                    }
-                    break;
-                case 'namespaces':
-                    if (req.method === 'GET') {
-                        await this.handleGetNamespaces(req, res, requestId);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for namespaces');
-                    }
-                    break;
-                case 'resource':
-                    if (req.method === 'GET') {
-                        await this.handleGetResource(req, res, requestId, url.searchParams);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for resource');
-                    }
-                    break;
-                case 'events':
-                    if (req.method === 'GET') {
-                        await this.handleGetEvents(req, res, requestId, url.searchParams);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for events');
-                    }
-                    break;
-                case 'logs':
-                    if (req.method === 'GET') {
-                        await this.handleGetLogs(req, res, requestId, url.searchParams);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for logs');
-                    }
-                    break;
-                case 'prompts':
-                    if (req.method === 'GET') {
-                        await this.handlePromptsListRequest(req, res, requestId);
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for prompts list');
-                    }
-                    break;
-                case 'prompt':
-                    if (req.method === 'POST' && pathMatch.promptName) {
-                        await this.handlePromptsGetRequest(req, res, requestId, pathMatch.promptName, body);
-                    }
-                    else if (req.method !== 'POST') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only POST method allowed for prompt get');
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Prompt name is required');
-                    }
-                    break;
-                case 'visualize':
-                    if (req.method === 'GET' && pathMatch.sessionId) {
-                        await this.handleVisualize(req, res, requestId, pathMatch.sessionId, url.searchParams);
-                    }
-                    else if (req.method !== 'GET') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for visualization');
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Session ID is required');
-                    }
-                    break;
-                case 'sessions':
-                    if (req.method === 'GET' && pathMatch.sessionId) {
-                        await this.handleSessionRetrieval(req, res, requestId, pathMatch.sessionId);
-                    }
-                    else if (req.method !== 'GET') {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', 'Only GET method allowed for session retrieval');
-                    }
-                    else {
-                        await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Session ID is required');
-                    }
-                    break;
-                default:
-                    await this.sendErrorResponse(res, requestId, HttpStatus.NOT_FOUND, 'NOT_FOUND', 'Unknown API endpoint');
+            // Check if path matches but method is wrong (HTTP 405 per RFC 7231)
+            const allowedMethods = this.routeRegistry.findAllowedMethods(url.pathname);
+            if (allowedMethods.length > 0) {
+                res.setHeader('Allow', allowedMethods.join(', '));
+                const methodList = allowedMethods.join(', ');
+                const message = allowedMethods.length === 1
+                    ? `Only ${methodList} method allowed`
+                    : `Only ${methodList} methods allowed`;
+                await this.sendErrorResponse(res, requestId, HttpStatus.METHOD_NOT_ALLOWED, 'METHOD_NOT_ALLOWED', message);
+                return;
             }
+            // No match found
+            await this.sendErrorResponse(res, requestId, HttpStatus.NOT_FOUND, 'NOT_FOUND', 'API endpoint not found');
         }
         catch (error) {
             this.logger.error('REST API request failed', error instanceof Error ? error : new Error(String(error)), {
@@ -260,96 +168,40 @@ class RestApiRouter {
         }
     }
     /**
-     * Parse API path and extract route information
+     * Dispatch request to appropriate handler based on matched route
+     * PRD #354: Central dispatch using handler map for registry-matched routes.
      */
-    parseApiPath(pathname) {
-        // Expected patterns:
-        // /api/v1/tools -> tools discovery
-        // /api/v1/tools/{toolName} -> tool execution
-        // /api/v1/openapi -> OpenAPI spec
-        // /api/v1/resources/sync -> resource sync from controller
-        // /api/v1/resources/kinds -> list resource kinds (PRD #328)
-        // /api/v1/resources/search -> semantic search for resources (PRD #328)
-        // /api/v1/resource -> get single resource with full details (PRD #328)
-        // /api/v1/resources -> list resources with filtering (PRD #328)
-        // /api/v1/namespaces -> list namespaces (PRD #328)
-        // /api/v1/events -> get events for a resource (PRD #328)
-        // /api/v1/logs -> get pod logs (PRD #328)
-        // /api/v1/prompts -> prompts list
-        // /api/v1/prompts/{promptName} -> prompt get
-        const basePath = `${this.config.basePath}/${this.config.version}`;
-        if (!pathname.startsWith(basePath)) {
-            return null;
-        }
-        const pathSuffix = pathname.substring(basePath.length);
-        // Remove leading slash
-        const cleanPath = pathSuffix.startsWith('/') ? pathSuffix.substring(1) : pathSuffix;
-        if (cleanPath === 'tools') {
-            return { endpoint: 'tools' };
-        }
-        if (cleanPath === 'openapi') {
-            return { endpoint: 'openapi' };
-        }
-        if (cleanPath.startsWith('tools/')) {
-            const toolName = cleanPath.substring(6); // Remove 'tools/'
-            if (toolName) {
-                return { endpoint: 'tool', toolName };
-            }
-        }
-        // Handle resources endpoints (PRD #328)
-        if (cleanPath === 'resources/kinds') {
-            return { endpoint: 'resources', action: 'kinds' };
-        }
-        if (cleanPath === 'resources/search') {
-            return { endpoint: 'resources', action: 'search' };
-        }
-        if (cleanPath === 'resources/sync') {
-            return { endpoint: 'resources', action: 'sync' };
-        }
-        if (cleanPath === 'resources') {
-            return { endpoint: 'resources', action: 'list' };
-        }
-        // Handle single resource endpoint (PRD #328)
-        if (cleanPath === 'resource') {
-            return { endpoint: 'resource' };
-        }
-        // Handle namespaces endpoint (PRD #328)
-        if (cleanPath === 'namespaces') {
-            return { endpoint: 'namespaces' };
-        }
-        // Handle events endpoint (PRD #328)
-        if (cleanPath === 'events') {
-            return { endpoint: 'events' };
-        }
-        // Handle logs endpoint (PRD #328)
-        if (cleanPath === 'logs') {
-            return { endpoint: 'logs' };
-        }
-        // Handle prompts endpoints
-        if (cleanPath === 'prompts') {
-            return { endpoint: 'prompts' };
-        }
-        if (cleanPath.startsWith('prompts/')) {
-            const promptName = cleanPath.substring(8); // Remove 'prompts/'
-            if (promptName) {
-                return { endpoint: 'prompt', promptName };
-            }
-        }
-        // Handle visualize endpoint (PRD #317)
-        if (cleanPath.startsWith('visualize/')) {
-            const sessionId = cleanPath.substring(10); // Remove 'visualize/'
-            if (sessionId) {
-                return { endpoint: 'visualize', sessionId };
-            }
+    async dispatchRoute(req, res, requestId, routeMatch, searchParams, body, startTime) {
+        const { route, params } = routeMatch;
+        const routeKey = `${route.method}:${route.path}`;
+        // Handler map: route key -> handler function
+        const handlers = {
+            'GET:/api/v1/tools': () => this.handleToolDiscovery(req, res, requestId, searchParams),
+            'POST:/api/v1/tools/:toolName': () => this.handleToolExecution(req, res, requestId, params.toolName, body, startTime),
+            'GET:/api/v1/openapi': () => this.handleOpenApiSpec(req, res, requestId),
+            'GET:/api/v1/resources': () => this.handleListResources(req, res, requestId, searchParams),
+            'GET:/api/v1/resources/kinds': () => this.handleGetResourceKinds(req, res, requestId, searchParams),
+            'GET:/api/v1/resources/search': () => this.handleSearchResources(req, res, requestId, searchParams),
+            'POST:/api/v1/resources/sync': () => this.handleResourceSyncRequest(req, res, requestId, body),
+            'GET:/api/v1/resource': () => this.handleGetResource(req, res, requestId, searchParams),
+            'GET:/api/v1/namespaces': () => this.handleGetNamespaces(req, res, requestId),
+            'GET:/api/v1/events': () => this.handleGetEvents(req, res, requestId, searchParams),
+            'GET:/api/v1/logs': () => this.handleGetLogs(req, res, requestId, searchParams),
+            'GET:/api/v1/prompts': () => this.handlePromptsListRequest(req, res, requestId),
+            'POST:/api/v1/prompts/:promptName': () => this.handlePromptsGetRequest(req, res, requestId, params.promptName, body),
+            'GET:/api/v1/visualize/:sessionId': () => this.handleVisualize(req, res, requestId, params.sessionId, searchParams),
+            'GET:/api/v1/sessions/:sessionId': () => this.handleSessionRetrieval(req, res, requestId, params.sessionId),
+            'DELETE:/api/v1/knowledge/source/:sourceIdentifier': () => this.handleDeleteKnowledgeSource(req, res, requestId, params.sourceIdentifier),
+            'POST:/api/v1/knowledge/ask': () => this.handleKnowledgeAsk(req, res, requestId, body),
+        };
+        const handler = handlers[routeKey];
+        if (handler) {
+            await handler();
         }
-        // Handle generic session retrieval endpoint (works for any tool: remediate, query, recommend, etc.)
-        if (cleanPath.startsWith('sessions/')) {
-            const sessionId = cleanPath.substring(9); // Remove 'sessions/'
-            if (sessionId) {
-                return { endpoint: 'sessions', sessionId };
-            }
+        else {
+            this.logger.warn('Route matched but no handler found', { requestId, routeKey });
+            await this.sendErrorResponse(res, requestId, HttpStatus.NOT_FOUND, 'NOT_FOUND', 'Handler not found for route');
         }
-        return null;
     }
     /**
      * Handle tool discovery requests
@@ -383,7 +235,7 @@ class RestApiRouter {
                 filters: { category, tag, search }
             });
         }
-        catch (error) {
+        catch {
             await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'DISCOVERY_ERROR', 'Failed to retrieve tool information');
         }
     }
@@ -721,13 +573,14 @@ class RestApiRouter {
             // Fetch status via plugin separately if requested
             const result = await (0, resource_tools_1.listResources)({ kind, apiVersion, namespace, limit, offset });
             // Enrich with live status via plugin if requested
-            if (includeStatus && result.resources.length > 0 && this.pluginManager?.isPluginTool('kubectl_get_resource_json')) {
+            // PRD #359: Use unified plugin registry
+            if (includeStatus && result.resources.length > 0 && (0, plugin_registry_1.isPluginInitialized)()) {
                 const statusPromises = result.resources.map(async (resource) => {
                     const resourceType = resource.apiGroup
                         ? `${resource.kind.toLowerCase()}.${resource.apiGroup}`
                         : resource.kind.toLowerCase();
                     const resourceId = `${resourceType}/${resource.name}`;
-                    const pluginResponse = await this.pluginManager.invokeTool('kubectl_get_resource_json', {
+                    const pluginResponse = await (0, plugin_registry_1.invokePluginTool)('agentic-tools', 'kubectl_get_resource_json', {
                         resource: resourceId,
                         namespace: resource.namespace,
                         field: 'status'
@@ -833,15 +686,16 @@ class RestApiRouter {
             this.logger.info('Processing get resource request', { requestId, kind, apiVersion, name, namespace });
             // Extract apiGroup from apiVersion (e.g., "apps/v1" -> "apps", "v1" -> "")
             const apiGroup = apiVersion.includes('/') ? apiVersion.split('/')[0] : '';
-            // PRD #343: Use plugin for kubectl operations
-            if (!this.pluginManager?.isPluginTool('kubectl_get_resource_json')) {
-                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Kubernetes plugin not available');
+            // PRD #359: Use unified plugin registry
+            if (!(0, plugin_registry_1.isPluginInitialized)()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Plugin system not initialized');
                 return;
             }
             // Build resource identifier (kind.group/name or kind/name for core resources)
             const resourceType = apiGroup ? `${kind.toLowerCase()}.${apiGroup}` : kind.toLowerCase();
             const resourceId = `${resourceType}/${name}`;
-            const pluginResponse = await this.pluginManager.invokeTool('kubectl_get_resource_json', {
+            // PRD #359: Use unified plugin registry for kubectl operations
+            const pluginResponse = await (0, plugin_registry_1.invokePluginTool)('agentic-tools', 'kubectl_get_resource_json', {
                 resource: resourceId,
                 namespace: namespace
             });
@@ -925,9 +779,9 @@ class RestApiRouter {
                 return;
             }
             this.logger.info('Processing get events request', { requestId, name, kind, namespace, uid });
-            // PRD #343: Use plugin for kubectl operations
-            if (!this.pluginManager?.isPluginTool('kubectl_events')) {
-                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Kubernetes plugin not available');
+            // PRD #359: Use unified plugin registry
+            if (!(0, plugin_registry_1.isPluginInitialized)()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Plugin system not initialized');
                 return;
             }
             // Build field selector for involvedObject filtering
@@ -938,11 +792,12 @@ class RestApiRouter {
             if (uid) {
                 fieldSelectors.push(`involvedObject.uid=${uid}`);
             }
-            const pluginResponse = await this.pluginManager.invokeTool('kubectl_events', {
+            // PRD #359: Use unified plugin registry for kubectl operations
+            const pluginResponse = await (0, plugin_registry_1.invokePluginTool)('agentic-tools', 'kubectl_events', {
                 namespace: namespace,
                 args: [`--field-selector=${fieldSelectors.join(',')}`]
             });
-            let events = [];
+            const events = [];
             if (pluginResponse.success && pluginResponse.result) {
                 const pluginResult = pluginResponse.result;
                 if (pluginResult.success && pluginResult.data) {
@@ -1025,9 +880,9 @@ class RestApiRouter {
                 }
             }
             this.logger.info('Processing get logs request', { requestId, name, namespace, container, tailLines });
-            // PRD #343: Use plugin for kubectl operations
-            if (!this.pluginManager?.isPluginTool('kubectl_logs')) {
-                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Kubernetes plugin not available');
+            // PRD #359: Use unified plugin registry
+            if (!(0, plugin_registry_1.isPluginInitialized)()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Plugin system not initialized');
                 return;
             }
             // Build args for kubectl_logs
@@ -1038,7 +893,8 @@ class RestApiRouter {
             if (container) {
                 args.push('-c', container);
             }
-            const pluginResponse = await this.pluginManager.invokeTool('kubectl_logs', {
+            // PRD #359: Use unified plugin registry for kubectl operations
+            const pluginResponse = await (0, plugin_registry_1.invokePluginTool)('agentic-tools', 'kubectl_logs', {
                 resource: name,
                 namespace: namespace,
                 args: args.length > 0 ? args : undefined
@@ -1119,7 +975,8 @@ class RestApiRouter {
     async handlePromptsGetRequest(req, res, requestId, promptName, body) {
         try {
             this.logger.info('Processing prompt get request', { requestId, promptName });
-            const result = await (0, prompts_1.handlePromptsGetRequest)({ name: promptName, arguments: body?.arguments }, this.logger, requestId);
+            const bodyObj = body;
+            const result = await (0, prompts_1.handlePromptsGetRequest)({ name: promptName, arguments: bodyObj?.arguments }, this.logger, requestId);
             const response = {
                 success: true,
                 data: result,
@@ -1210,29 +1067,31 @@ class RestApiRouter {
                 return;
             }
             // PRD #320: Select prompt based on tool name (defaults to 'query' for backwards compatibility)
-            const toolName = primarySession.data.toolName || 'query';
+            const toolName = (primarySession.data.toolName || 'query');
             const promptName = (0, visualization_1.getPromptForTool)(toolName);
             this.logger.info('Loading visualization prompt', { requestId, sessionIds, toolName, promptName });
             // Load system prompt with session context
             // PRD #320: Unified visualization prompt with tool-aware data selection
             let intent;
             let data;
+            // Cast to allow access to tool-specific properties
+            const sessionData = primarySession.data;
             switch (toolName) {
                 case 'recommend':
-                    intent = primarySession.data.intent || '';
+                    intent = sessionData.intent || '';
                     data = isMultiSession ? sessions.map(s => s.data) : primarySession.data;
                     break;
                 case 'remediate':
-                    intent = primarySession.data.issue || '';
-                    data = primarySession.data.finalAnalysis || primarySession.data;
+                    intent = sessionData.issue || '';
+                    data = sessionData.finalAnalysis || primarySession.data;
                     break;
                 case 'operate':
-                    intent = primarySession.data.intent || '';
+                    intent = sessionData.intent || '';
                     data = primarySession.data;
                     break;
                 case 'version':
                     // PRD #320: Version tool provides system health status
-                    intent = `System health: ${primarySession.data.summary?.overall || 'unknown'}`;
+                    intent = `System health: ${sessionData.summary?.overall || 'unknown'}`;
                     data = primarySession.data;
                     break;
                 default:
@@ -1423,12 +1282,337 @@ class RestApiRouter {
             await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'SESSION_RETRIEVAL_ERROR', 'Failed to retrieve session', { error: errorMessage });
         }
     }
+    /**
+     * Handle DELETE /api/v1/knowledge/source/:sourceIdentifier (PRD #356)
+     * Delete all knowledge base chunks for a source identifier
+     * Used by controller for GitKnowledgeSource cleanup
+     */
+    async handleDeleteKnowledgeSource(req, res, requestId, sourceIdentifier) {
+        try {
+            // URL-decode the sourceIdentifier (it may contain / encoded as %2F)
+            const decodedSourceIdentifier = decodeURIComponent(sourceIdentifier);
+            this.logger.info('Processing delete knowledge source request', {
+                requestId,
+                sourceIdentifier: decodedSourceIdentifier,
+            });
+            // Check plugin availability
+            if (!(0, plugin_registry_1.isPluginInitialized)()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Plugin system not initialized');
+                return;
+            }
+            const KNOWLEDGE_COLLECTION = 'knowledge-base';
+            const PLUGIN_NAME = 'agentic-tools';
+            // Step 1: Query all chunks matching the sourceIdentifier in metadata
+            const queryResponse = await (0, plugin_registry_1.invokePluginTool)(PLUGIN_NAME, 'vector_query', {
+                collection: KNOWLEDGE_COLLECTION,
+                filter: {
+                    must: [{ key: 'metadata.sourceIdentifier', match: { value: decodedSourceIdentifier } }],
+                },
+                limit: 10000, // High limit to get all chunks for a source
+            });
+            if (!queryResponse.success) {
+                const error = queryResponse.error;
+                const errorMessage = error?.message || error?.error || 'Query failed';
+                // If collection doesn't exist (Not Found), return success with 0 deleted
+                if (errorMessage.includes('Not Found') || errorMessage.includes('not found')) {
+                    this.logger.info('Collection not found - returning success with 0 deleted', {
+                        requestId,
+                        sourceIdentifier: decodedSourceIdentifier,
+                    });
+                    const response = {
+                        success: true,
+                        data: {
+                            sourceIdentifier: decodedSourceIdentifier,
+                            chunksDeleted: 0,
+                        },
+                        meta: {
+                            timestamp: new Date().toISOString(),
+                            requestId,
+                            version: this.config.version,
+                        },
+                    };
+                    await this.sendJsonResponse(res, HttpStatus.OK, response);
+                    return;
+                }
+                this.logger.error('Plugin query failed', new Error(errorMessage), {
+                    requestId,
+                    sourceIdentifier: decodedSourceIdentifier,
+                });
+                await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'DELETE_SOURCE_ERROR', 'Failed to query chunks for deletion', { error: errorMessage });
+                return;
+            }
+            // Extract results from plugin response
+            const queryResult = queryResponse.result;
+            if (!queryResult.success) {
+                const errorMessage = queryResult.error || queryResult.message;
+                // If collection doesn't exist, return success with 0 deleted
+                if (errorMessage.includes('Not Found') || errorMessage.includes('not found')) {
+                    this.logger.info('Collection not found - returning success with 0 deleted', {
+                        requestId,
+                        sourceIdentifier: decodedSourceIdentifier,
+                    });
+                    const response = {
+                        success: true,
+                        data: {
+                            sourceIdentifier: decodedSourceIdentifier,
+                            chunksDeleted: 0,
+                        },
+                        meta: {
+                            timestamp: new Date().toISOString(),
+                            requestId,
+                            version: this.config.version,
+                        },
+                    };
+                    await this.sendJsonResponse(res, HttpStatus.OK, response);
+                    return;
+                }
+                await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'DELETE_SOURCE_ERROR', 'Failed to query chunks for deletion', { error: errorMessage });
+                return;
+            }
+            const chunksToDelete = queryResult.data || [];
+            // If no chunks found, return success with 0 deleted
+            if (chunksToDelete.length === 0) {
+                this.logger.info('No chunks found for source identifier', {
+                    requestId,
+                    sourceIdentifier: decodedSourceIdentifier,
+                });
+                const response = {
+                    success: true,
+                    data: {
+                        sourceIdentifier: decodedSourceIdentifier,
+                        chunksDeleted: 0,
+                    },
+                    meta: {
+                        timestamp: new Date().toISOString(),
+                        requestId,
+                        version: this.config.version,
+                    },
+                };
+                await this.sendJsonResponse(res, HttpStatus.OK, response);
+                return;
+            }
+            // Step 2: Delete each chunk by ID
+            let deletedCount = 0;
+            for (const chunk of chunksToDelete) {
+                this.logger.debug('Deleting chunk', { requestId, chunkId: chunk.id });
+                const deleteResponse = await (0, plugin_registry_1.invokePluginTool)(PLUGIN_NAME, 'vector_delete', {
+                    collection: KNOWLEDGE_COLLECTION,
+                    id: chunk.id,
+                });
+                if (!deleteResponse.success) {
+                    const error = deleteResponse.error;
+                    const errorMessage = error?.message || 'Delete failed';
+                    this.logger.error('Failed to delete chunk', new Error(errorMessage), {
+                        requestId,
+                        chunkId: chunk.id,
+                        deletedSoFar: deletedCount,
+                    });
+                    await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'DELETE_SOURCE_ERROR', 'Failed to delete chunk', { chunkId: chunk.id, error: errorMessage, chunksDeletedBeforeFailure: deletedCount });
+                    return;
+                }
+                deletedCount++;
+            }
+            this.logger.info('Delete knowledge source operation completed', {
+                requestId,
+                sourceIdentifier: decodedSourceIdentifier,
+                chunksDeleted: deletedCount,
+            });
+            const response = {
+                success: true,
+                data: {
+                    sourceIdentifier: decodedSourceIdentifier,
+                    chunksDeleted: deletedCount,
+                },
+                meta: {
+                    timestamp: new Date().toISOString(),
+                    requestId,
+                    version: this.config.version,
+                },
+            };
+            await this.sendJsonResponse(res, HttpStatus.OK, response);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('Delete knowledge source request failed', error instanceof Error ? error : new Error(String(error)), {
+                requestId,
+                sourceIdentifier,
+            });
+            await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'DELETE_SOURCE_ERROR', 'Failed to delete knowledge source', { error: errorMessage });
+        }
+    }
+    /**
+     * Handle POST /api/v1/knowledge/ask (PRD #356)
+     * Ask a question and receive an AI-synthesized answer from the knowledge base.
+     * Uses an agentic approach with toolLoop to allow multiple searches if needed.
+     */
+    async handleKnowledgeAsk(req, res, requestId, body) {
+        try {
+            // Validate request body
+            if (!body || typeof body !== 'object') {
+                await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Request body must be a JSON object');
+                return;
+            }
+            const { query, limit = 20, uriFilter } = body;
+            // Validate limit parameter (must be positive integer)
+            if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'INVALID_PARAMETER', 'The "limit" parameter must be a positive integer');
+                return;
+            }
+            // Validate required query parameter
+            if (!query || typeof query !== 'string' || query.trim().length === 0) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.BAD_REQUEST, 'BAD_REQUEST', 'Missing or empty required parameter: query');
+                return;
+            }
+            this.logger.info('Processing knowledge ask request', {
+                requestId,
+                queryLength: query.length,
+                limit,
+                hasUriFilter: !!uriFilter,
+            });
+            // Check plugin availability (needed for search)
+            if (!(0, plugin_registry_1.isPluginInitialized)()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'PLUGIN_UNAVAILABLE', 'Plugin system not initialized');
+                return;
+            }
+            // Check AI provider availability
+            const aiProvider = (0, ai_provider_factory_1.createAIProvider)();
+            if (!aiProvider.isInitialized()) {
+                await this.sendErrorResponse(res, requestId, HttpStatus.SERVICE_UNAVAILABLE, 'AI_NOT_CONFIGURED', 'AI provider not configured. Set ANTHROPIC_API_KEY or another provider API key.');
+                return;
+            }
+            // Define the search tool for the AI
+            const searchTool = {
+                name: 'search_knowledge_base',
+                description: 'Search the knowledge base for relevant information. Returns chunks of text from documents that match the query semantically.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The search query - can be a question or keywords',
+                        },
+                    },
+                    required: ['query'],
+                },
+            };
+            // Collect all chunks from search results across iterations
+            const allChunks = [];
+            // Tool executor that calls searchKnowledgeBase
+            const toolExecutor = async (toolName, input) => {
+                if (toolName !== 'search_knowledge_base') {
+                    return {
+                        success: false,
+                        error: `Unknown tool: ${toolName}`,
+                    };
+                }
+                const searchInput = input;
+                const result = await (0, manage_knowledge_1.searchKnowledgeBase)({
+                    query: searchInput.query,
+                    limit,
+                    uriFilter,
+                });
+                if (!result.success) {
+                    return {
+                        success: false,
+                        error: result.error,
+                        message: 'Search failed',
+                    };
+                }
+                // Collect chunks for the response
+                for (const chunk of result.chunks) {
+                    // Avoid duplicates (same id)
+                    if (!allChunks.some(c => c.uri === chunk.uri && c.chunkIndex === chunk.chunkIndex)) {
+                        allChunks.push({
+                            content: chunk.content,
+                            uri: chunk.uri,
+                            score: chunk.score,
+                            chunkIndex: chunk.chunkIndex,
+                        });
+                    }
+                }
+                // Return results to the AI
+                if (result.chunks.length === 0) {
+                    return {
+                        success: true,
+                        message: 'No matching documents found in the knowledge base.',
+                        chunks: [],
+                    };
+                }
+                return {
+                    success: true,
+                    message: `Found ${result.chunks.length} relevant chunks.`,
+                    chunks: result.chunks.map(c => ({
+                        content: c.content,
+                        uri: c.uri,
+                        score: c.score,
+                    })),
+                };
+            };
+            // Load system prompt
+            const systemPrompt = (0, shared_prompt_loader_1.loadPrompt)('knowledge-ask');
+            // Execute tool loop
+            this.logger.info('Starting knowledge ask tool loop', { requestId });
+            const result = await aiProvider.toolLoop({
+                systemPrompt,
+                userMessage: query,
+                tools: [searchTool],
+                toolExecutor,
+                maxIterations: 5,
+                operation: 'knowledge-ask',
+                evaluationContext: {
+                    user_intent: query,
+                },
+            });
+            this.logger.info('Knowledge ask tool loop completed', {
+                requestId,
+                iterations: result.iterations,
+                chunksCollected: allChunks.length,
+                toolCallsCount: result.toolCallsExecuted.length,
+            });
+            // Deduplicate sources from collected chunks
+            const sourceMap = new Map();
+            for (const chunk of allChunks) {
+                if (!sourceMap.has(chunk.uri)) {
+                    sourceMap.set(chunk.uri, { uri: chunk.uri });
+                }
+            }
+            const sources = Array.from(sourceMap.values());
+            // Build response
+            const response = {
+                success: true,
+                data: {
+                    answer: result.finalMessage,
+                    sources,
+                    chunks: allChunks,
+                },
+                meta: {
+                    timestamp: new Date().toISOString(),
+                    requestId,
+                    version: this.config.version,
+                },
+            };
+            await this.sendJsonResponse(res, HttpStatus.OK, response);
+            this.logger.info('Knowledge ask completed', {
+                requestId,
+                sourcesFound: sources.length,
+                chunksReturned: allChunks.length,
+                answerLength: result.finalMessage.length,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('Knowledge ask request failed', error instanceof Error ? error : new Error(String(error)), {
+                requestId,
+            });
+            await this.sendErrorResponse(res, requestId, HttpStatus.INTERNAL_SERVER_ERROR, 'SYNTHESIS_ERROR', 'Failed to process knowledge ask request', { error: errorMessage });
+        }
+    }
     /**
      * Set CORS headers
      */
     setCorsHeaders(res) {
         res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
         res.setHeader('Access-Control-Max-Age', '86400');
     }
@@ -1476,5 +1660,12 @@ class RestApiRouter {
     getConfig() {
         return { ...this.config };
     }
+    /**
+     * Get the route registry for OpenAPI generation and fixture validation
+     * PRD #354: Exposes route registry for downstream consumers
+     */
+    getRouteRegistry() {
+        return this.routeRegistry;
+    }
 }
 exports.RestApiRouter = RestApiRouter;