@vfarcic/dot-ai 1.11.0 → 1.12.0

package/dist/core/ai-provider-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../src/core/ai-provider-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AA6BjC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU;IA2BnD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,aAAa,IAAI,UAAU;IAoFlC;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAWrD;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,IAAI,MAAM,EAAE;IAMxC;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}
+{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../src/core/ai-provider-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AA8BjC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU;IA2BnD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,aAAa,IAAI,UAAU;IAoFlC;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAWrD;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,IAAI,MAAM,EAAE;IAMxC;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}

package/dist/core/ai-provider-factory.js

@@ -28,6 +28,7 @@ const PROVIDER_ENV_KEYS = {
     google: 'GOOGLE_GENERATIVE_AI_API_KEY', // Standard Vercel AI SDK env var (also checks GOOGLE_API_KEY as fallback)
     google_flash: 'GOOGLE_GENERATIVE_AI_API_KEY', // PRD #294: Uses same API key as regular Google
     kimi: 'MOONSHOT_API_KEY', // PRD #353: Moonshot AI Kimi K2.5
+    alibaba: 'ALIBABA_API_KEY', // PRD #382: Alibaba Qwen 3.5 Plus
     xai: 'XAI_API_KEY',
 };
 const IMPLEMENTED_PROVIDERS = Object.keys(model_config_1.CURRENT_MODELS);

package/dist/core/mcp-client-manager.d.ts

@@ -0,0 +1,88 @@
+/**
+ * MCP Client Manager for dot-ai MCP Server Integration
+ *
+ * Connects to external MCP servers running in the cluster, discovers their tools,
+ * and makes them available to dot-ai operations (remediate, operate, query) via
+ * the attachTo routing mechanism.
+ *
+ * PRD #358: MCP Server Integration
+ */
+import { McpServerConfig, DiscoveredMcpServer, McpServerStats, McpAttachableOperation } from './mcp-client-types';
+import { Logger } from './error-handling';
+import { AITool, ToolExecutor } from './ai-provider.interface';
+/**
+ * Manages MCP server connections, tool discovery, and tool routing.
+ *
+ * Follows the same structural patterns as PluginManager but uses
+ * the MCP SDK (Client + StreamableHTTPClientTransport) instead of HTTP REST.
+ */
+export declare class McpClientManager {
+    private readonly logger;
+    /** MCP SDK Client instances keyed by server name */
+    private readonly clients;
+    /** Transport instances keyed by server name (needed for cleanup) */
+    private readonly transports;
+    /** Discovered server metadata keyed by server name */
+    private readonly discoveredServers;
+    /** Maps namespaced tool name → server name for routing */
+    private readonly toolToServer;
+    constructor(logger: Logger);
+    /**
+     * Parse MCP server configuration from file.
+     *
+     * Reads from /etc/dot-ai-mcp/mcp-servers.json (mounted from ConfigMap in K8s).
+     * Returns empty array if file doesn't exist (MCP servers only work in-cluster).
+     * Throws on invalid JSON or malformed configuration.
+     */
+    static parseMcpServerConfig(): McpServerConfig[];
+    /**
+     * Discover all configured MCP servers.
+     *
+     * Connects to each server, performs MCP handshake, and discovers available tools.
+     * All servers must connect successfully — any failure throws McpDiscoveryError.
+     */
+    discoverMcpServers(configs: McpServerConfig[]): Promise<void>;
+    /**
+     * Connect to a single MCP server and discover its tools.
+     */
+    private connectAndDiscover;
+    /**
+     * Get tools available for a specific dot-ai operation, filtered by attachTo.
+     *
+     * Returns tools as AITool[] with namespaced names ({serverName}__{toolName}).
+     */
+    getToolsForOperation(operation: McpAttachableOperation): AITool[];
+    /**
+     * Get all discovered tools across all servers.
+     */
+    getAllDiscoveredTools(): AITool[];
+    /**
+     * Check if a tool name belongs to an MCP server (is namespaced).
+     */
+    isMcpTool(toolName: string): boolean;
+    /**
+     * Create a ToolExecutor that routes MCP tools to their servers.
+     *
+     * Returns a function compatible with toolLoop's toolExecutor parameter.
+     * MCP tools (namespaced) are routed to their MCP servers; non-MCP tools
+     * are routed to the optional fallback executor.
+     */
+    createToolExecutor(fallbackExecutor?: ToolExecutor): ToolExecutor;
+    /**
+     * Get statistics about MCP server connections.
+     */
+    getStats(): McpServerStats;
+    /**
+     * Get discovered server metadata.
+     */
+    getDiscoveredServers(): DiscoveredMcpServer[];
+    /**
+     * Close all MCP server connections.
+     */
+    close(): Promise<void>;
+    /**
+     * Convert an MCP tool definition to AITool format with namespaced name.
+     */
+    private convertToAITool;
+}
+//# sourceMappingURL=mcp-client-manager.d.ts.map

package/dist/core/mcp-client-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client-manager.d.ts","sourceRoot":"","sources":["../../src/core/mcp-client-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EACL,eAAe,EAEf,mBAAmB,EACnB,cAAc,EAEd,sBAAsB,EACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAW/D;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyD;IAEpF,sDAAsD;IACtD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA+C;IAEjF,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;gBAEnD,MAAM,EAAE,MAAM;IAI1B;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,IAAI,eAAe,EAAE;IA+DhD;;;;;OAKG;IACG,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCnE;;OAEG;YACW,kBAAkB;IAmGhC;;;;OAIG;IACH,oBAAoB,CAAC,SAAS,EAAE,sBAAsB,GAAG,MAAM,EAAE;IAoBjE;;OAEG;IACH,qBAAqB,IAAI,MAAM,EAAE;IAejC;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;;OAMG;IACH,kBAAkB,CAAC,gBAAgB,CAAC,EAAE,YAAY,GAAG,YAAY;IA6DjE;;OAEG;IACH,QAAQ,IAAI,cAAc;IAQ1B;;OAEG;IACH,oBAAoB,IAAI,mBAAmB,EAAE;IAI7C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B;;OAEG;IACH,OAAO,CAAC,eAAe;CAYxB"}

package/dist/core/mcp-client-manager.js

@@ -0,0 +1,362 @@
+"use strict";
+/**
+ * MCP Client Manager for dot-ai MCP Server Integration
+ *
+ * Connects to external MCP servers running in the cluster, discovers their tools,
+ * and makes them available to dot-ai operations (remediate, operate, query) via
+ * the attachTo routing mechanism.
+ *
+ * PRD #358: MCP Server Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClientManager = void 0;
+const node_fs_1 = require("node:fs");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const mcp_client_types_1 = require("./mcp-client-types");
+/** Path for MCP servers config file (mounted from ConfigMap in K8s) */
+const MCP_SERVERS_CONFIG_PATH = '/etc/dot-ai-mcp/mcp-servers.json';
+/** Separator used to namespace MCP tools: {serverName}__{toolName} */
+const TOOL_NAME_SEPARATOR = '__';
+/** Default timeout for MCP requests in milliseconds */
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Manages MCP server connections, tool discovery, and tool routing.
+ *
+ * Follows the same structural patterns as PluginManager but uses
+ * the MCP SDK (Client + StreamableHTTPClientTransport) instead of HTTP REST.
+ */
+class McpClientManager {
+    logger;
+    /** MCP SDK Client instances keyed by server name */
+    clients = new Map();
+    /** Transport instances keyed by server name (needed for cleanup) */
+    transports = new Map();
+    /** Discovered server metadata keyed by server name */
+    discoveredServers = new Map();
+    /** Maps namespaced tool name → server name for routing */
+    toolToServer = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Parse MCP server configuration from file.
+     *
+     * Reads from /etc/dot-ai-mcp/mcp-servers.json (mounted from ConfigMap in K8s).
+     * Returns empty array if file doesn't exist (MCP servers only work in-cluster).
+     * Throws on invalid JSON or malformed configuration.
+     */
+    static parseMcpServerConfig() {
+        if (!(0, node_fs_1.existsSync)(MCP_SERVERS_CONFIG_PATH)) {
+            return [];
+        }
+        let content;
+        try {
+            content = (0, node_fs_1.readFileSync)(MCP_SERVERS_CONFIG_PATH, 'utf-8');
+        }
+        catch (err) {
+            throw new Error(`Failed to read MCP server config at ${MCP_SERVERS_CONFIG_PATH}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`Invalid JSON in MCP server config at ${MCP_SERVERS_CONFIG_PATH}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error(`MCP server config at ${MCP_SERVERS_CONFIG_PATH} must be an array, got ${typeof parsed}`);
+        }
+        const validOperations = ['remediate', 'operate', 'query'];
+        return parsed.map((s, index) => {
+            if (!s || typeof s !== 'object') {
+                throw new Error(`MCP server at index ${index} must be an object`);
+            }
+            if (!s.endpoint || typeof s.endpoint !== 'string') {
+                throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) is missing required 'endpoint' field`);
+            }
+            if (!Array.isArray(s.attachTo) || s.attachTo.length === 0) {
+                throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) must have a non-empty 'attachTo' array`);
+            }
+            for (const op of s.attachTo) {
+                if (!validOperations.includes(op)) {
+                    throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) has invalid attachTo value '${op}'. Must be one of: ${validOperations.join(', ')}`);
+                }
+            }
+            return {
+                name: s.name || `mcp-server-${index}`,
+                endpoint: s.endpoint,
+                attachTo: s.attachTo,
+                timeout: s.timeout,
+            };
+        });
+    }
+    /**
+     * Discover all configured MCP servers.
+     *
+     * Connects to each server, performs MCP handshake, and discovers available tools.
+     * All servers must connect successfully — any failure throws McpDiscoveryError.
+     */
+    async discoverMcpServers(configs) {
+        if (configs.length === 0) {
+            this.logger.debug('No MCP servers configured for discovery');
+            return;
+        }
+        this.logger.info('Starting MCP server discovery', {
+            serverCount: configs.length,
+            servers: configs.map(c => c.name),
+        });
+        const results = await Promise.allSettled(configs.map(config => this.connectAndDiscover(config)));
+        const failed = [];
+        results.forEach((result, index) => {
+            const config = configs[index];
+            if (result.status === 'rejected') {
+                const error = result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason);
+                failed.push({ name: config.name, error });
+            }
+        });
+        if (failed.length > 0) {
+            throw new mcp_client_types_1.McpDiscoveryError(`MCP server discovery failed: ${failed.map(f => `${f.name} (${f.error})`).join(', ')}`, failed);
+        }
+        this.logger.info('MCP server discovery complete', {
+            discovered: this.discoveredServers.size,
+            totalTools: this.toolToServer.size,
+        });
+    }
+    /**
+     * Connect to a single MCP server and discover its tools.
+     */
+    async connectAndDiscover(config) {
+        const timeout = config.timeout || DEFAULT_TIMEOUT_MS;
+        this.logger.debug('Connecting to MCP server', {
+            name: config.name,
+            endpoint: config.endpoint,
+            attachTo: config.attachTo,
+        });
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(config.endpoint), {
+            reconnectionOptions: {
+                maxReconnectionDelay: 30_000,
+                initialReconnectionDelay: 1_000,
+                reconnectionDelayGrowFactor: 1.5,
+                maxRetries: 2,
+            },
+        });
+        const client = new index_js_1.Client({ name: 'dot-ai', version: '1.0.0' }, { capabilities: {} });
+        // Connect with timeout
+        const connectPromise = client.connect(transport);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Connection timed out after ${timeout}ms`)), timeout));
+        try {
+            await Promise.race([connectPromise, timeoutPromise]);
+        }
+        catch (err) {
+            // Clean up transport on failure
+            try {
+                await transport.close();
+            }
+            catch { /* ignore cleanup errors */ }
+            throw new Error(`Failed to connect to MCP server '${config.name}' at ${config.endpoint}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Discover tools
+        let tools;
+        try {
+            const result = await client.listTools();
+            tools = result.tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: {
+                    type: t.inputSchema.type,
+                    properties: t.inputSchema.properties,
+                    required: t.inputSchema.required,
+                },
+            }));
+        }
+        catch (err) {
+            try {
+                await transport.close();
+            }
+            catch { /* ignore cleanup errors */ }
+            throw new Error(`Failed to list tools from MCP server '${config.name}': ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Store client and transport
+        this.clients.set(config.name, client);
+        this.transports.set(config.name, transport);
+        // Store discovered server metadata
+        this.discoveredServers.set(config.name, {
+            name: config.name,
+            endpoint: config.endpoint,
+            attachTo: config.attachTo,
+            version: client.getServerVersion()?.version,
+            tools,
+            discoveredAt: new Date(),
+        });
+        // Map namespaced tools to server
+        for (const tool of tools) {
+            const namespacedName = `${config.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+            if (this.toolToServer.has(namespacedName)) {
+                this.logger.warn('Namespaced tool name conflict - overwriting', {
+                    tool: namespacedName,
+                    existingServer: this.toolToServer.get(namespacedName),
+                    newServer: config.name,
+                });
+            }
+            this.toolToServer.set(namespacedName, config.name);
+        }
+        this.logger.info('MCP server discovered', {
+            name: config.name,
+            version: client.getServerVersion()?.version,
+            tools: tools.map(t => t.name),
+            namespacedTools: tools.map(t => `${config.name}${TOOL_NAME_SEPARATOR}${t.name}`),
+        });
+    }
+    /**
+     * Get tools available for a specific dot-ai operation, filtered by attachTo.
+     *
+     * Returns tools as AITool[] with namespaced names ({serverName}__{toolName}).
+     */
+    getToolsForOperation(operation) {
+        const tools = [];
+        for (const server of this.discoveredServers.values()) {
+            if (!server.attachTo.includes(operation)) {
+                continue;
+            }
+            for (const tool of server.tools) {
+                const namespacedName = `${server.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+                // Only include if this server owns the routing
+                if (this.toolToServer.get(namespacedName) === server.name) {
+                    tools.push(this.convertToAITool(server.name, tool));
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Get all discovered tools across all servers.
+     */
+    getAllDiscoveredTools() {
+        const tools = [];
+        for (const server of this.discoveredServers.values()) {
+            for (const tool of server.tools) {
+                const namespacedName = `${server.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+                if (this.toolToServer.get(namespacedName) === server.name) {
+                    tools.push(this.convertToAITool(server.name, tool));
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Check if a tool name belongs to an MCP server (is namespaced).
+     */
+    isMcpTool(toolName) {
+        return this.toolToServer.has(toolName);
+    }
+    /**
+     * Create a ToolExecutor that routes MCP tools to their servers.
+     *
+     * Returns a function compatible with toolLoop's toolExecutor parameter.
+     * MCP tools (namespaced) are routed to their MCP servers; non-MCP tools
+     * are routed to the optional fallback executor.
+     */
+    createToolExecutor(fallbackExecutor) {
+        return async (toolName, input) => {
+            if (this.isMcpTool(toolName)) {
+                this.logger.debug('Routing tool to MCP server', {
+                    tool: toolName,
+                    server: this.toolToServer.get(toolName),
+                });
+                try {
+                    const serverName = this.toolToServer.get(toolName);
+                    const originalToolName = toolName.substring(serverName.length + TOOL_NAME_SEPARATOR.length);
+                    const client = this.clients.get(serverName);
+                    if (!client) {
+                        return `Error: MCP server '${serverName}' is not connected`;
+                    }
+                    const result = await client.callTool({
+                        name: originalToolName,
+                        arguments: input,
+                    });
+                    // Extract text content from MCP response
+                    const contentArray = result.content;
+                    if (result.isError) {
+                        const errorText = contentArray
+                            ?.filter(c => c.type === 'text')
+                            .map(c => c.text)
+                            .join('\n') || 'Unknown MCP tool error';
+                        return `Error: ${errorText}`;
+                    }
+                    // Return text content for AI consumption
+                    const textContent = contentArray
+                        ?.filter(c => c.type === 'text')
+                        .map(c => c.text)
+                        .join('\n');
+                    return textContent || '';
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.logger.error('MCP tool invocation failed', new Error(message), { tool: toolName, server: this.toolToServer.get(toolName) });
+                    return `Error: ${message}`;
+                }
+            }
+            // Fall back to provided executor for non-MCP tools
+            if (fallbackExecutor) {
+                return fallbackExecutor(toolName, input);
+            }
+            return `Error: Tool '${toolName}' not found in MCP servers or fallback executor`;
+        };
+    }
+    /**
+     * Get statistics about MCP server connections.
+     */
+    getStats() {
+        return {
+            serverCount: this.discoveredServers.size,
+            toolCount: this.toolToServer.size,
+            servers: Array.from(this.discoveredServers.keys()),
+        };
+    }
+    /**
+     * Get discovered server metadata.
+     */
+    getDiscoveredServers() {
+        return Array.from(this.discoveredServers.values());
+    }
+    /**
+     * Close all MCP server connections.
+     */
+    async close() {
+        for (const [name, transport] of this.transports.entries()) {
+            try {
+                await transport.close();
+                this.logger.debug('Closed MCP server connection', { name });
+            }
+            catch (err) {
+                this.logger.warn('Error closing MCP server connection', {
+                    name,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        this.clients.clear();
+        this.transports.clear();
+        this.discoveredServers.clear();
+        this.toolToServer.clear();
+    }
+    /**
+     * Convert an MCP tool definition to AITool format with namespaced name.
+     */
+    convertToAITool(serverName, tool) {
+        const namespacedName = `${serverName}${TOOL_NAME_SEPARATOR}${tool.name}`;
+        return {
+            name: namespacedName,
+            description: `[${serverName}] ${tool.description || tool.name}`,
+            inputSchema: {
+                type: 'object',
+                properties: tool.inputSchema.properties || {},
+                required: tool.inputSchema.required,
+            },
+        };
+    }
+}
+exports.McpClientManager = McpClientManager;

package/dist/core/mcp-client-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * MCP Client Registry - Unified MCP Server Tool Access
+ *
+ * PRD #358: Provides a single, consistent way to access MCP server tools
+ * from anywhere in the codebase (remediate, operate, query).
+ *
+ * Usage:
+ *   // At startup (src/mcp/server.ts):
+ *   initializeMcpClientRegistry(mcpClientManager);
+ *
+ *   // Anywhere in the codebase:
+ *   if (isMcpClientInitialized()) {
+ *     const tools = getMcpClientManager()!.getToolsForOperation('remediate');
+ *   }
+ */
+import type { McpClientManager } from './mcp-client-manager';
+/**
+ * Initialize the MCP client registry with a McpClientManager instance.
+ * Must be called once at startup after MCP servers are discovered.
+ */
+export declare function initializeMcpClientRegistry(manager: McpClientManager): void;
+/**
+ * Get the McpClientManager instance.
+ * Returns null if not initialized.
+ */
+export declare function getMcpClientManager(): McpClientManager | null;
+/**
+ * Check if the MCP client registry is initialized.
+ */
+export declare function isMcpClientInitialized(): boolean;
+/**
+ * Reset the MCP client registry (for testing only).
+ * @internal
+ */
+export declare function resetMcpClientRegistry(): void;
+//# sourceMappingURL=mcp-client-registry.d.ts.map

package/dist/core/mcp-client-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client-registry.d.ts","sourceRoot":"","sources":["../../src/core/mcp-client-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAO7D;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAE3E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/dist/core/mcp-client-registry.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * MCP Client Registry - Unified MCP Server Tool Access
+ *
+ * PRD #358: Provides a single, consistent way to access MCP server tools
+ * from anywhere in the codebase (remediate, operate, query).
+ *
+ * Usage:
+ *   // At startup (src/mcp/server.ts):
+ *   initializeMcpClientRegistry(mcpClientManager);
+ *
+ *   // Anywhere in the codebase:
+ *   if (isMcpClientInitialized()) {
+ *     const tools = getMcpClientManager()!.getToolsForOperation('remediate');
+ *   }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeMcpClientRegistry = initializeMcpClientRegistry;
+exports.getMcpClientManager = getMcpClientManager;
+exports.isMcpClientInitialized = isMcpClientInitialized;
+exports.resetMcpClientRegistry = resetMcpClientRegistry;
+/**
+ * Global MCP client manager instance (set once at startup)
+ */
+let mcpClientManager = null;
+/**
+ * Initialize the MCP client registry with a McpClientManager instance.
+ * Must be called once at startup after MCP servers are discovered.
+ */
+function initializeMcpClientRegistry(manager) {
+    mcpClientManager = manager;
+}
+/**
+ * Get the McpClientManager instance.
+ * Returns null if not initialized.
+ */
+function getMcpClientManager() {
+    return mcpClientManager;
+}
+/**
+ * Check if the MCP client registry is initialized.
+ */
+function isMcpClientInitialized() {
+    return mcpClientManager !== null;
+}
+/**
+ * Reset the MCP client registry (for testing only).
+ * @internal
+ */
+function resetMcpClientRegistry() {
+    mcpClientManager = null;
+}

package/dist/core/mcp-client-types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * MCP Client Types for dot-ai MCP Server Integration
+ *
+ * Defines the interface contract for connecting to external MCP servers.
+ * MCP servers provide additional tools (e.g., Prometheus metrics, tracing)
+ * that augment dot-ai's built-in kubectl/helm tools.
+ *
+ * PRD #358: MCP Server Integration
+ */
+/**
+ * Valid dot-ai operations that MCP servers can attach to
+ */
+export type McpAttachableOperation = 'remediate' | 'operate' | 'query';
+/**
+ * Configuration for an MCP server connection.
+ * Loaded from /etc/dot-ai-mcp/mcp-servers.json (mounted via Helm ConfigMap).
+ */
+export interface McpServerConfig {
+    /** Unique server name (e.g., "prometheus", "jaeger") */
+    name: string;
+    /** MCP server HTTP endpoint URL (e.g., "http://prometheus-mcp.monitoring.svc:3000") */
+    endpoint: string;
+    /** Which dot-ai operations this server's tools should be available to */
+    attachTo: McpAttachableOperation[];
+    /** Optional timeout in milliseconds for MCP requests (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Tool definition discovered from an MCP server via client.listTools()
+ */
+export interface McpToolDefinition {
+    /** Original tool name from MCP server */
+    name: string;
+    /** Tool description */
+    description?: string;
+    /** JSON Schema for tool input */
+    inputSchema: {
+        type: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * MCP server metadata after successful discovery
+ */
+export interface DiscoveredMcpServer {
+    /** Server name from config */
+    name: string;
+    /** Server endpoint URL */
+    endpoint: string;
+    /** Which operations this server is attached to */
+    attachTo: McpAttachableOperation[];
+    /** Server version from MCP protocol (if available) */
+    version?: string;
+    /** Tools provided by this server */
+    tools: McpToolDefinition[];
+    /** Discovery timestamp */
+    discoveredAt: Date;
+}
+/**
+ * Stats about MCP server connections
+ */
+export interface McpServerStats {
+    /** Number of connected servers */
+    serverCount: number;
+    /** Total number of discovered tools across all servers */
+    toolCount: number;
+    /** Names of connected servers */
+    servers: string[];
+}
+/**
+ * Error thrown when MCP server discovery fails
+ */
+export declare class McpDiscoveryError extends Error {
+    readonly failedServers: Array<{
+        name: string;
+        error: string;
+    }>;
+    constructor(message: string, failedServers: Array<{
+        name: string;
+        error: string;
+    }>);
+}
+//# sourceMappingURL=mcp-client-types.d.ts.map

package/dist/core/mcp-client-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client-types.d.ts","sourceRoot":"","sources":["../../src/core/mcp-client-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvE;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,0BAA0B;IAC1B,YAAY,EAAE,IAAI,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;gBADrE,OAAO,EAAE,MAAM,EACC,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAKxE"}

package/dist/core/mcp-client-types.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * MCP Client Types for dot-ai MCP Server Integration
+ *
+ * Defines the interface contract for connecting to external MCP servers.
+ * MCP servers provide additional tools (e.g., Prometheus metrics, tracing)
+ * that augment dot-ai's built-in kubectl/helm tools.
+ *
+ * PRD #358: MCP Server Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpDiscoveryError = void 0;
+/**
+ * Error thrown when MCP server discovery fails
+ */
+class McpDiscoveryError extends Error {
+    failedServers;
+    constructor(message, failedServers) {
+        super(message);
+        this.failedServers = failedServers;
+        this.name = 'McpDiscoveryError';
+    }
+}
+exports.McpDiscoveryError = McpDiscoveryError;