@vfarcic/dot-ai 0.44.0 → 0.46.0

package/dist/tools/version.js

@@ -2,22 +2,145 @@
 /**
  * Version tool for MCP server
  *
- * Provides version information for debugging and validation
+ * Provides comprehensive system status including version information,
+ * Vector DB connection status, and embedding service capabilities
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION_TOOL_INPUT_SCHEMA = exports.VERSION_TOOL_DESCRIPTION = exports.VERSION_TOOL_NAME = void 0;
 exports.getVersionInfo = getVersionInfo;
 exports.handleVersionTool = handleVersionTool;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const index_1 = require("../core/index");
 exports.VERSION_TOOL_NAME = 'version';
-exports.VERSION_TOOL_DESCRIPTION = 'Get version information for the DevOps AI Toolkit MCP server';
+exports.VERSION_TOOL_DESCRIPTION = 'Get comprehensive system status including version information, Vector DB connection status, embedding service capabilities, Anthropic API connectivity, and pattern management health check';
 exports.VERSION_TOOL_INPUT_SCHEMA = {
     type: 'object',
     properties: {},
     required: [],
     additionalProperties: false
 };
+/**
+ * Test Vector DB connectivity and get status
+ */
+async function getVectorDBStatus() {
+    const vectorDB = new index_1.VectorDBService();
+    const config = vectorDB.getConfig();
+    try {
+        const isHealthy = await vectorDB.healthCheck();
+        if (!isHealthy) {
+            return {
+                connected: false,
+                url: config.url || 'unknown',
+                collectionName: config.collectionName || 'patterns',
+                error: 'Health check failed - Vector DB not responding'
+            };
+        }
+        // Try to get patterns count to verify collection access
+        const embeddingService = new index_1.EmbeddingService();
+        const patternService = new index_1.PatternVectorService(vectorDB, embeddingService);
+        let patternsCount;
+        try {
+            patternsCount = await patternService.getPatternsCount();
+        }
+        catch (error) {
+            // Collection might not exist yet - that's okay
+            patternsCount = 0;
+        }
+        return {
+            connected: true,
+            url: config.url || 'unknown',
+            collectionName: config.collectionName || 'patterns',
+            patternsCount
+        };
+    }
+    catch (error) {
+        return {
+            connected: false,
+            url: config.url || 'unknown',
+            collectionName: config.collectionName || 'patterns',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Test embedding service status
+ */
+async function getEmbeddingStatus() {
+    const embeddingService = new index_1.EmbeddingService();
+    const status = embeddingService.getStatus();
+    return {
+        available: status.available,
+        provider: status.provider,
+        model: status.model,
+        dimensions: status.dimensions,
+        reason: status.reason
+    };
+}
+/**
+ * Test Anthropic API connectivity
+ */
+async function getAnthropicStatus() {
+    const keyConfigured = !!process.env.ANTHROPIC_API_KEY;
+    if (!keyConfigured) {
+        return {
+            connected: false,
+            keyConfigured: false,
+            error: 'ANTHROPIC_API_KEY environment variable not set'
+        };
+    }
+    try {
+        // Import Claude integration and test a simple connection
+        const { ClaudeIntegration } = await Promise.resolve().then(() => __importStar(require('../core/claude')));
+        const claude = new ClaudeIntegration(process.env.ANTHROPIC_API_KEY);
+        // Test with a minimal request to check connectivity
+        await claude.sendMessage('test');
+        return {
+            connected: true,
+            keyConfigured: true
+        };
+    }
+    catch (error) {
+        return {
+            connected: false,
+            keyConfigured: true,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
 /**
  * Get version information from package.json
  */
@@ -43,19 +166,49 @@ function getVersionInfo() {
     };
 }
 /**
- * Handle version tool request
+ * Handle version tool request with comprehensive system diagnostics
  */
 async function handleVersionTool(args, logger, requestId) {
     try {
-        logger.info('Processing version tool request', { requestId });
-        const versionInfo = getVersionInfo();
-        logger.info('Version tool request completed', { requestId, version: versionInfo.version });
+        logger.info('Processing version tool request with system diagnostics', { requestId });
+        // Get version info
+        const version = getVersionInfo();
+        // Run all diagnostics in parallel for better performance
+        logger.info('Running system diagnostics...', { requestId });
+        const [vectorDBStatus, embeddingStatus, anthropicStatus] = await Promise.all([
+            getVectorDBStatus(),
+            getEmbeddingStatus(),
+            getAnthropicStatus()
+        ]);
+        const systemStatus = {
+            version,
+            vectorDB: vectorDBStatus,
+            embedding: embeddingStatus,
+            anthropic: anthropicStatus
+        };
+        // Log summary of system health
+        logger.info('System diagnostics completed', {
+            requestId,
+            version: version.version,
+            vectorDBConnected: vectorDBStatus.connected,
+            embeddingAvailable: embeddingStatus.available,
+            anthropicConnected: anthropicStatus.connected
+        });
         return {
             content: [{
                     type: 'text',
                     text: JSON.stringify({
                         status: 'success',
-                        versionInfo,
+                        system: systemStatus,
+                        summary: {
+                            overall: vectorDBStatus.connected && anthropicStatus.connected ? 'healthy' : 'degraded',
+                            patternSearch: embeddingStatus.available ? 'semantic+keyword' : 'keyword-only',
+                            capabilities: [
+                                vectorDBStatus.connected ? 'pattern-management' : null,
+                                embeddingStatus.available ? 'semantic-search' : null,
+                                anthropicStatus.connected ? 'ai-recommendations' : null
+                            ].filter(Boolean)
+                        },
                         timestamp: new Date().toISOString()
                     }, null, 2)
                 }]
@@ -63,7 +216,7 @@ async function handleVersionTool(args, logger, requestId) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error('Version tool request failed', error);
+        logger.error('Version tool request failed', error, { requestId });
         return {
             content: [{
                     type: 'text',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "description": "Universal Kubernetes application deployment agent with CLI and MCP interfaces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -86,10 +86,12 @@
     "@anthropic-ai/sdk": "^0.27.0",
     "@kubernetes/client-node": "^1.3.0",
     "@modelcontextprotocol/sdk": "^1.13.2",
+    "@qdrant/js-client-rest": "^1.15.0",
     "@vfarcic/dot-ai": "^0.34.0",
     "cli-table3": "^0.6.5",
     "commander": "^11.1.0",
     "glob": "^11.0.3",
+    "openai": "^5.11.0",
     "yaml": "^2.8.0"
   },
   "jest": {

package/prompts/concept-extraction.md

@@ -0,0 +1,91 @@
+# Concept Extraction for Pattern Matching
+
+You are a Kubernetes deployment expert. Extract multiple deployment concepts from user intent to enable comprehensive pattern matching.
+
+## User Intent
+{intent}
+
+## Instructions
+
+Analyze the user intent and extract all relevant deployment concepts. Consider these categories:
+
+### **Application Architecture**
+- Application types: web application, API service, microservice, monolith, frontend, backend
+- Architectural patterns: stateless, stateful, serverless, event-driven, batch processing
+- Service types: REST API, GraphQL API, gRPC service, websocket service, message consumer
+
+### **Infrastructure & Integration**  
+- Data storage: database, cache, persistent storage, file storage, object storage
+- Connectivity: external database, message queue, third-party API, service mesh
+- Networking: public access, internal service, load balancing, ingress
+
+### **Operational Requirements**
+- Scaling: auto-scaling, high availability, load balancing, horizontal scaling
+- Data management: schema management, database migrations, backup, monitoring
+- Security: authentication, authorization, network policies, secrets management
+- Deployment: CI/CD, blue-green deployment, canary deployment, rolling updates
+
+### **Technology Stack**
+- Programming languages: golang, java, python, nodejs, react, angular
+- Frameworks: spring boot, express, flask, django, rails
+- Databases: postgresql, mysql, mongodb, redis, elasticsearch
+
+## Response Format
+
+Extract 3-8 specific concepts that organizational patterns might address. Focus on concepts that would have dedicated deployment patterns.
+
+```json
+{
+  "concepts": [
+    {
+      "category": "application_architecture|infrastructure|operational|technology",
+      "concept": "specific concept name",
+      "importance": "high|medium|low",
+      "keywords": ["keyword1", "keyword2", "keyword3"]
+    }
+  ]
+}
+```
+
+## Examples
+
+**Input**: "deploy a stateless golang API that connects to PostgreSQL with auto-scaling"
+**Output**:
+```json
+{
+  "concepts": [
+    {
+      "category": "application_architecture", 
+      "concept": "stateless application",
+      "importance": "high",
+      "keywords": ["stateless", "stateless app", "stateless service", "stateless workload"]
+    },
+    {
+      "category": "application_architecture",
+      "concept": "REST API service", 
+      "importance": "high",
+      "keywords": ["api", "rest api", "api service", "web service", "http service"]
+    },
+    {
+      "category": "technology",
+      "concept": "golang application",
+      "importance": "medium", 
+      "keywords": ["golang", "go", "golang app", "go application", "go service"]
+    },
+    {
+      "category": "infrastructure",
+      "concept": "database connection",
+      "importance": "high",
+      "keywords": ["database", "postgresql", "db connection", "external database"]
+    },
+    {
+      "category": "operational", 
+      "concept": "auto-scaling",
+      "importance": "medium",
+      "keywords": ["auto-scaling", "horizontal scaling", "scaling", "hpa"]
+    }
+  ]
+}
+```
+
+**IMPORTANT**: Return ONLY the JSON object, nothing else.