@vfarcic/dot-ai 0.5.0 → 0.5.1

package/src/interfaces/mcp.ts

@@ -0,0 +1,183 @@
+/**
+ * Model Context Protocol (MCP) Interface for DevOps AI Toolkit
+ * 
+ * Provides MCP server capabilities that expose DevOps AI Toolkit functionality
+ * to AI assistants like Claude through standardized protocol
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { DotAI } from '../core/index';
+import { 
+  ConsoleLogger,
+  Logger 
+} from '../core/error-handling';
+import { 
+  RECOMMEND_TOOL_NAME, 
+  RECOMMEND_TOOL_DESCRIPTION, 
+  RECOMMEND_TOOL_INPUT_SCHEMA,
+  handleRecommendTool 
+} from '../tools/recommend';
+import { 
+  CHOOSESOLUTION_TOOL_NAME, 
+  CHOOSESOLUTION_TOOL_DESCRIPTION, 
+  CHOOSESOLUTION_TOOL_INPUT_SCHEMA,
+  handleChooseSolutionTool 
+} from '../tools/choose-solution';
+import { 
+  ANSWERQUESTION_TOOL_NAME, 
+  ANSWERQUESTION_TOOL_DESCRIPTION, 
+  ANSWERQUESTION_TOOL_INPUT_SCHEMA,
+  handleAnswerQuestionTool 
+} from '../tools/answer-question';
+import { 
+  GENERATEMANIFESTS_TOOL_NAME, 
+  GENERATEMANIFESTS_TOOL_DESCRIPTION, 
+  GENERATEMANIFESTS_TOOL_INPUT_SCHEMA,
+  handleGenerateManifestsTool 
+} from '../tools/generate-manifests';
+import { 
+  DEPLOYMANIFESTS_TOOL_NAME, 
+  DEPLOYMANIFESTS_TOOL_DESCRIPTION, 
+  DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA,
+  handleDeployManifestsTool 
+} from '../tools/deploy-manifests';
+
+export interface MCPServerConfig {
+  name: string;
+  version: string;
+  description: string;
+  author?: string;
+}
+
+export class MCPServer {
+  private server: McpServer;
+  private dotAI: DotAI;
+  private initialized: boolean = false;
+  private logger: Logger;
+  private requestIdCounter: number = 0;
+
+  constructor(dotAI: DotAI, config: MCPServerConfig) {
+    this.dotAI = dotAI;
+    this.logger = new ConsoleLogger('MCPServer');
+    
+    // Create McpServer instance
+    this.server = new McpServer(
+      {
+        name: config.name,
+        version: config.version
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+
+    this.logger.info('Initializing MCP Server', {
+      name: config.name,
+      version: config.version,
+      author: config.author
+    });
+
+    // Register all tools directly with McpServer
+    this.registerTools();
+  }
+
+  /**
+   * Register all tools with McpServer
+   */
+  private registerTools(): void {
+    // Register recommend tool
+    this.server.tool(
+      RECOMMEND_TOOL_NAME,
+      RECOMMEND_TOOL_DESCRIPTION,
+      RECOMMEND_TOOL_INPUT_SCHEMA,
+      async (args: any) => {
+        const requestId = this.generateRequestId();
+        this.logger.info(`Processing ${RECOMMEND_TOOL_NAME} tool request`, { requestId });
+        return await handleRecommendTool(args, this.dotAI, this.logger, requestId);
+      }
+    );
+
+    // Register chooseSolution tool
+    this.server.tool(
+      CHOOSESOLUTION_TOOL_NAME,
+      CHOOSESOLUTION_TOOL_DESCRIPTION,
+      CHOOSESOLUTION_TOOL_INPUT_SCHEMA,
+      async (args: any) => {
+        const requestId = this.generateRequestId();
+        this.logger.info(`Processing ${CHOOSESOLUTION_TOOL_NAME} tool request`, { requestId });
+        return await handleChooseSolutionTool(args, this.dotAI, this.logger, requestId);
+      }
+    );
+
+    // Register answerQuestion tool
+    this.server.tool(
+      ANSWERQUESTION_TOOL_NAME,
+      ANSWERQUESTION_TOOL_DESCRIPTION,
+      ANSWERQUESTION_TOOL_INPUT_SCHEMA,
+      async (args: any) => {
+        const requestId = this.generateRequestId();
+        this.logger.info(`Processing ${ANSWERQUESTION_TOOL_NAME} tool request`, { requestId });
+        return await handleAnswerQuestionTool(args, this.dotAI, this.logger, requestId);
+      }
+    );
+
+    // Register generateManifests tool
+    this.server.tool(
+      GENERATEMANIFESTS_TOOL_NAME,
+      GENERATEMANIFESTS_TOOL_DESCRIPTION,
+      GENERATEMANIFESTS_TOOL_INPUT_SCHEMA,
+      async (args: any) => {
+        const requestId = this.generateRequestId();
+        this.logger.info(`Processing ${GENERATEMANIFESTS_TOOL_NAME} tool request`, { requestId });
+        return await handleGenerateManifestsTool(args, this.dotAI, this.logger, requestId);
+      }
+    );
+
+    // Register deployManifests tool
+    this.server.tool(
+      DEPLOYMANIFESTS_TOOL_NAME,
+      DEPLOYMANIFESTS_TOOL_DESCRIPTION,
+      DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA,
+      async (args: any) => {
+        const requestId = this.generateRequestId();
+        this.logger.info(`Processing ${DEPLOYMANIFESTS_TOOL_NAME} tool request`, { requestId });
+        return await handleDeployManifestsTool(args, this.dotAI, this.logger, requestId);
+      }
+    );
+    
+    this.logger.info('Registered all tools with McpServer', { 
+      tools: [
+        RECOMMEND_TOOL_NAME,
+        CHOOSESOLUTION_TOOL_NAME,
+        ANSWERQUESTION_TOOL_NAME,
+        GENERATEMANIFESTS_TOOL_NAME,
+        DEPLOYMANIFESTS_TOOL_NAME
+      ],
+      totalTools: 5
+    });
+  }
+
+  private generateRequestId(): string {
+    return `mcp_${Date.now()}_${++this.requestIdCounter}`;
+  }
+
+
+  async start(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    this.initialized = true;
+  }
+
+  async stop(): Promise<void> {
+    await this.server.close();
+    this.initialized = false;
+  }
+
+
+  isReady(): boolean {
+    return this.initialized;
+  }
+} 

package/src/mcp/server.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server Entry Point for DevOps AI Toolkit
+ * 
+ * This server exposes DevOps AI Toolkit functionality through the Model Context Protocol,
+ * enabling AI assistants like Claude Code to interact with Kubernetes deployment capabilities.
+ */
+
+import { MCPServer } from '../interfaces/mcp.js';
+import { DotAI } from '../core/index.js';
+
+async function main() {
+  try {
+    // Validate required environment variables
+    process.stderr.write('Validating MCP server configuration...\n');
+    
+    // Check session directory configuration
+    const sessionDir = process.env.DOT_AI_SESSION_DIR;
+    if (!sessionDir) {
+      process.stderr.write('FATAL: DOT_AI_SESSION_DIR environment variable is required\n');
+      process.stderr.write('Configuration:\n');
+      process.stderr.write('- Set DOT_AI_SESSION_DIR in .mcp.json env section\n');
+      process.stderr.write('- Example: "DOT_AI_SESSION_DIR": "/tmp/dot-ai-sessions"\n');
+      process.stderr.write('- Ensure the directory exists and is writable\n');
+      process.exit(1);
+    }
+    
+    // Validate session directory exists and is writable
+    try {
+      const fs = await import('fs');
+      const path = await import('path');
+      
+      // Check if directory exists
+      if (!fs.existsSync(sessionDir)) {
+        process.stderr.write(`FATAL: Session directory does not exist: ${sessionDir}\n`);
+        process.stderr.write('Solution: Create the directory or update DOT_AI_SESSION_DIR\n');
+        process.exit(1);
+      }
+      
+      // Check if it's actually a directory
+      const stat = fs.statSync(sessionDir);
+      if (!stat.isDirectory()) {
+        process.stderr.write(`FATAL: Session directory path is not a directory: ${sessionDir}\n`);
+        process.stderr.write('Solution: Use a valid directory path in DOT_AI_SESSION_DIR\n');
+        process.exit(1);
+      }
+      
+      // Test write permissions
+      const testFile = path.join(sessionDir, '.mcp-test-write');
+      try {
+        fs.writeFileSync(testFile, 'test');
+        fs.unlinkSync(testFile);
+        process.stderr.write(`Session directory validated: ${sessionDir}\n`);
+      } catch (writeError) {
+        process.stderr.write(`FATAL: Session directory is not writable: ${sessionDir}\n`);
+        process.stderr.write('Solution: Fix directory permissions or use a different directory\n');
+        process.exit(1);
+      }
+      
+    } catch (error) {
+      process.stderr.write(`FATAL: Session directory validation failed: ${error}\n`);
+      process.exit(1);
+    }
+
+    // Initialize DotAI - it will read KUBECONFIG and ANTHROPIC_API_KEY from environment
+    const dotAI = new DotAI();
+
+    // Test cluster connectivity immediately on startup
+    process.stderr.write('Testing cluster connectivity...\n');
+    try {
+      await dotAI.initialize();
+      await dotAI.discovery.connect();
+      process.stderr.write('Cluster connectivity verified successfully\n');
+    } catch (connectError) {
+      process.stderr.write(`FATAL: Failed to connect to Kubernetes cluster: ${connectError}\n`);
+      process.stderr.write('Troubleshooting:\n');
+      process.stderr.write('- Check KUBECONFIG environment variable\n');
+      process.stderr.write('- Verify cluster is running: kubectl cluster-info\n');
+      process.stderr.write('- Test kubectl connectivity: kubectl get nodes\n');
+      process.exit(1);
+    }
+
+    // Create and configure MCP server
+    const mcpServer = new MCPServer(dotAI, {
+      name: 'dot-ai',
+      version: '0.1.0',
+      description: 'Universal Kubernetes application deployment agent with AI-powered orchestration',
+      author: 'Viktor Farcic'
+    });
+
+    // Start the MCP server
+    process.stderr.write('Starting DevOps AI Toolkit MCP server...\n');
+    await mcpServer.start();
+    process.stderr.write('DevOps AI Toolkit MCP server started successfully\n');
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      process.stderr.write('Shutting down DevOps AI Toolkit MCP server...\n');
+      await mcpServer.stop();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      process.stderr.write('Shutting down DevOps AI Toolkit MCP server...\n');
+      await mcpServer.stop();
+      process.exit(0);
+    });
+
+  } catch (error) {
+    process.stderr.write(`Failed to start DevOps AI Toolkit MCP server: ${error}\n`);
+    process.exit(1);
+  }
+}
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+  process.stderr.write(`Uncaught exception in MCP server: ${error}\n`);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  process.stderr.write(`Unhandled rejection in MCP server: ${reason}\n`);
+  process.exit(1);
+});
+
+// Start the server
+main().catch((error) => {
+  process.stderr.write(`Fatal error starting MCP server: ${error}\n`);
+  process.exit(1);
+});