@vfarcic/dot-ai 0.48.0 → 0.50.0

package/README.md

@@ -12,7 +12,7 @@ DevOps AI Toolkit is an AI-powered development productivity platform that enhanc
 
 ### Kubernetes Deployment
 - **Developers**: Deploy applications without needing deep Kubernetes expertise
-- **Platform Engineers**: Create organizational deployment patterns that enhance AI recommendations with institutional knowledge and best practices
+- **Platform Engineers**: Create organizational deployment patterns that enhance AI recommendations with institutional knowledge and best practices, and scan cluster resources to enable semantic matching for dramatically improved recommendation accuracy
 
 ### Documentation Testing  
 - **Documentation Maintainers**: Automatically validate documentation accuracy and catch outdated content
@@ -31,10 +31,34 @@ DevOps AI Toolkit is an AI-powered development productivity platform that enhanc
 
 ### Kubernetes Deployment Intelligence
 🔍 **Smart Discovery**: Automatically finds all available resources and operators in your cluster  
-🤖 **AI Recommendations**: Get deployment suggestions tailored to your specific cluster setup  
+🧠 **Semantic Capability Management**: Discovers what each resource actually does for intelligent matching  
+🤖 **AI Recommendations**: Get deployment suggestions tailored to your specific cluster setup with enhanced semantic understanding  
 🔧 **Operator-Aware**: Leverages custom operators and CRDs when available  
 🚀 **Complete Workflow**: From discovery to deployment with automated Kubernetes integration
 
+#### Capability-Enhanced Recommendations
+Transform how AI understands your cluster by discovering semantic capabilities of each resource:
+
+**The Problem**: Traditional discovery sees `sqls.devopstoolkit.live` as a meaningless name among hundreds of resources.
+
+**The Solution**: Capability management teaches the system that `sqls.devopstoolkit.live` handles PostgreSQL databases with multi-cloud support.
+
+**Before Capability Management:**
+```
+User: "I need a PostgreSQL database"
+AI: Gets 400+ generic resource names → picks complex multi-resource solution
+Result: Misses optimal single-resource solutions
+```
+
+**After Capability Management:**
+```
+User: "I need a PostgreSQL database"  
+AI: Gets pre-filtered relevant resources with rich context
+Result: Finds sqls.devopstoolkit.live as perfect match ✨
+```
+
+**Get Started**: See the [Capability Management Guide](./docs/mcp-capability-management-guide.md) for complete workflows including cluster scanning, capability search, and recommendation enhancement.
+
 ### Documentation Testing & Validation
 📖 **Automated Testing**: Validates documentation by executing commands and testing examples  
 🔍 **Two-Phase Validation**: Tests both functionality (does it work?) and semantic accuracy (are descriptions truthful?)  
@@ -164,6 +188,29 @@ Agent: Perfect! Generating manifests and deploying now...
 Agent: ✅ Successfully deployed! Your application is running.
 ```
 
+**Example: Capability Management**
+```
+User: I want to scan my cluster for resource capabilities to improve recommendations
+
+Agent: I'll help you scan your cluster to discover semantic capabilities. This will dramatically improve recommendation accuracy.
+[Uses manageOrgData with capabilities scanning]
+
+Agent: Would you like to scan all cluster resources or specify a subset?
+Options: 1) All resources 2) Specific subset
+
+User: All resources in auto mode
+
+Agent: Starting comprehensive cluster capability scan...
+✅ Capability scan completed! Processed cluster resources successfully.
+
+User: Now I need a PostgreSQL database
+
+Agent: Let me get enhanced recommendations using your capability data.
+[Uses recommend tool with capability pre-filtering]
+
+Agent: Perfect! I found sqls.devopstoolkit.live as the top match - it's a managed database solution supporting PostgreSQL with multi-cloud capabilities and low complexity. Much better than the generic StatefulSet approach I would have suggested before!
+```
+
 **Example: Documentation Testing**
 ```
 User: I want to test my README.md file to make sure all the examples work

package/dist/core/base-vector-service.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Base Vector Service
+ *
+ * Generic vector operations that can be extended for different data types
+ * (patterns, capabilities, dependencies, etc.)
+ */
+import { VectorDBService } from './vector-db-service';
+import { EmbeddingService } from './embedding-service';
+export interface BaseSearchOptions {
+    limit?: number;
+    scoreThreshold?: number;
+    keywordWeight?: number;
+}
+export interface BaseSearchResult<T> {
+    data: T;
+    score: number;
+    matchType: 'keyword' | 'semantic' | 'hybrid';
+}
+export interface SearchMode {
+    semantic: boolean;
+    provider?: string;
+    reason?: string;
+}
+/**
+ * Abstract base class for vector-based data services
+ */
+export declare abstract class BaseVectorService<T> {
+    protected vectorDB: VectorDBService;
+    protected embeddingService: EmbeddingService;
+    protected collectionName: string;
+    constructor(collectionName: string, vectorDB?: VectorDBService, embeddingService?: EmbeddingService);
+    /**
+     * Initialize the collection
+     */
+    initialize(): Promise<void>;
+    /**
+     * Health check for Vector DB connection
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Store data in Vector DB with optional semantic embedding
+     */
+    storeData(data: T): Promise<void>;
+    /**
+     * Search for data using hybrid semantic + keyword matching
+     */
+    searchData(query: string, options?: BaseSearchOptions): Promise<BaseSearchResult<T>[]>;
+    /**
+     * Get data by ID
+     */
+    getData(id: string): Promise<T | null>;
+    /**
+     * Delete data by ID
+     */
+    deleteData(id: string): Promise<void>;
+    /**
+     * Delete all data (recreate collection)
+     */
+    deleteAllData(): Promise<void>;
+    /**
+     * Get all data (limited)
+     */
+    getAllData(limit?: number): Promise<T[]>;
+    /**
+     * Get total count of data items
+     */
+    getDataCount(): Promise<number>;
+    /**
+     * Get current search mode (semantic vs keyword-only)
+     */
+    getSearchMode(): SearchMode;
+    protected abstract createSearchText(data: T): string;
+    protected abstract extractId(data: T): string;
+    protected abstract createPayload(data: T): Record<string, any>;
+    protected abstract payloadToData(payload: Record<string, any>): T;
+    protected extractKeywords(query: string): string[];
+    /**
+     * Hybrid search combining semantic and keyword matching
+     */
+    private hybridSearch;
+    /**
+     * Combine semantic and keyword results with hybrid ranking
+     */
+    private combineHybridResults;
+}
+//# sourceMappingURL=base-vector-service.d.ts.map

package/dist/core/base-vector-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-vector-service.d.ts","sourceRoot":"","sources":["../../src/core/base-vector-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAkB,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;CAC9C;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,8BAAsB,iBAAiB,CAAC,CAAC;IACvC,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC;IACpC,SAAS,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC7C,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC;gBAErB,cAAc,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,eAAe,EAAE,gBAAgB,CAAC,EAAE,gBAAgB;IAMnG;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BvC;;OAEG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IAyBjC;;OAEG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAW5C;;OAEG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAIpC;;OAEG;IACG,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAS9C;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAWrC;;OAEG;IACH,aAAa,IAAI,UAAU;IAU3B,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM;IACpD,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM;IAC7C,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC9D,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC;IAGjE,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAIlD;;OAEG;YACW,YAAY;IAkC1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;CA2C7B"}

package/dist/core/base-vector-service.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Base Vector Service
+ *
+ * Generic vector operations that can be extended for different data types
+ * (patterns, capabilities, dependencies, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseVectorService = void 0;
+const vector_db_service_1 = require("./vector-db-service");
+const embedding_service_1 = require("./embedding-service");
+/**
+ * Abstract base class for vector-based data services
+ */
+class BaseVectorService {
+    vectorDB;
+    embeddingService;
+    collectionName;
+    constructor(collectionName, vectorDB, embeddingService) {
+        this.collectionName = collectionName;
+        this.vectorDB = vectorDB || new vector_db_service_1.VectorDBService({ collectionName });
+        this.embeddingService = embeddingService || new embedding_service_1.EmbeddingService();
+    }
+    /**
+     * Initialize the collection
+     */
+    async initialize() {
+        // Use embedding dimensions if available, otherwise default to 1536 (OpenAI default)
+        const dimensions = this.embeddingService.isAvailable() ?
+            this.embeddingService.getDimensions() :
+            1536;
+        await this.vectorDB.initializeCollection(dimensions);
+    }
+    /**
+     * Health check for Vector DB connection
+     */
+    async healthCheck() {
+        return await this.vectorDB.healthCheck();
+    }
+    /**
+     * Store data in Vector DB with optional semantic embedding
+     */
+    async storeData(data) {
+        const searchText = this.createSearchText(data);
+        const id = this.extractId(data);
+        // Generate embedding - required for vector storage
+        let embedding;
+        if (this.embeddingService.isAvailable()) {
+            try {
+                embedding = await this.embeddingService.generateEmbedding(searchText);
+            }
+            catch (error) {
+                // Fail immediately with clear error about embedding generation
+                throw new Error(`Embedding generation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            // Embedding service not available - fail with clear error
+            throw new Error('Embedding service not available - cannot store data in vector collection');
+        }
+        const document = {
+            id,
+            payload: {
+                ...this.createPayload(data),
+                searchText: searchText,
+                hasEmbedding: true
+            },
+            vector: embedding
+        };
+        await this.vectorDB.upsertDocument(document);
+    }
+    /**
+     * Search for data using hybrid semantic + keyword matching
+     */
+    async searchData(query, options = {}) {
+        // Fail immediately if embedding service not available - no graceful fallback
+        if (!this.embeddingService.isAvailable()) {
+            throw new Error('Embedding service not available - cannot perform semantic search');
+        }
+        // Extract keywords for keyword search
+        const queryKeywords = this.extractKeywords(query);
+        if (queryKeywords.length === 0) {
+            return [];
+        }
+        const limit = options.limit || 10;
+        const scoreThreshold = options.scoreThreshold || 0.01;
+        // Perform hybrid search (semantic + keyword)
+        try {
+            return await this.hybridSearch(query, queryKeywords, { limit, scoreThreshold });
+        }
+        catch (error) {
+            // Fail immediately - no fallback to keyword-only search
+            throw new Error(`Semantic search failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get data by ID
+     */
+    async getData(id) {
+        const document = await this.vectorDB.getDocument(id);
+        if (!document) {
+            return null;
+        }
+        const data = this.payloadToData(document.payload);
+        // Set the ID from the document
+        data.id = document.id;
+        return data;
+    }
+    /**
+     * Delete data by ID
+     */
+    async deleteData(id) {
+        await this.vectorDB.deleteDocument(id);
+    }
+    /**
+     * Delete all data (recreate collection)
+     */
+    async deleteAllData() {
+        await this.vectorDB.deleteAllDocuments();
+    }
+    /**
+     * Get all data (limited)
+     */
+    async getAllData(limit) {
+        const documents = await this.vectorDB.getAllDocuments(limit);
+        return documents.map(doc => {
+            const data = this.payloadToData(doc.payload);
+            data.id = doc.id;
+            return data;
+        });
+    }
+    /**
+     * Get total count of data items
+     */
+    async getDataCount() {
+        try {
+            const info = await this.vectorDB.getCollectionInfo();
+            return info.points_count || 0;
+        }
+        catch (error) {
+            // Fallback: get all and count
+            const data = await this.getAllData();
+            return data.length;
+        }
+    }
+    /**
+     * Get current search mode (semantic vs keyword-only)
+     */
+    getSearchMode() {
+        const status = this.embeddingService.getStatus();
+        return {
+            semantic: status.available,
+            provider: status.provider || undefined,
+            reason: status.reason || (status.available ? 'Embedding service available' : undefined)
+        };
+    }
+    // Virtual methods that can be overridden by subclasses
+    extractKeywords(query) {
+        return query.toLowerCase().split(/\s+/).filter(word => word.length > 2);
+    }
+    /**
+     * Hybrid search combining semantic and keyword matching
+     */
+    async hybridSearch(query, queryKeywords, options) {
+        // Generate query embedding - required for semantic search
+        const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+        if (!queryEmbedding) {
+            throw new Error('Failed to generate query embedding for semantic search');
+        }
+        // Semantic search using vector similarity
+        const semanticResults = await this.vectorDB.searchSimilar(queryEmbedding, {
+            limit: options.limit * 2, // Get more candidates for hybrid ranking
+            scoreThreshold: 0.1 // Very permissive threshold for single-word queries
+        });
+        // Keyword search
+        const keywordResults = await this.vectorDB.searchByKeywords(queryKeywords, {
+            limit: options.limit * 2,
+            scoreThreshold: 0.1
+        });
+        // Combine and rank results
+        return this.combineHybridResults(semanticResults, keywordResults, queryKeywords, options);
+    }
+    /**
+     * Combine semantic and keyword results with hybrid ranking
+     */
+    combineHybridResults(semanticResults, keywordResults, queryKeywords, options) {
+        const combinedResults = new Map();
+        // Add semantic results
+        for (const result of semanticResults) {
+            const data = this.payloadToData(result.payload);
+            data.id = result.id;
+            combinedResults.set(result.id, {
+                data,
+                score: result.score * 0.7, // Weight semantic similarity
+                matchType: 'semantic'
+            });
+        }
+        // Add or boost keyword results
+        for (const result of keywordResults) {
+            const existing = combinedResults.get(result.id);
+            if (existing) {
+                // Boost score for hybrid match
+                existing.score = Math.max(existing.score, result.score * 0.8);
+                existing.matchType = 'hybrid';
+            }
+            else {
+                const data = this.payloadToData(result.payload);
+                data.id = result.id;
+                combinedResults.set(result.id, {
+                    data,
+                    score: result.score * 0.6, // Weight keyword matching
+                    matchType: 'keyword'
+                });
+            }
+        }
+        // Sort by score and apply limits
+        return Array.from(combinedResults.values())
+            .filter(result => result.score >= options.scoreThreshold)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, options.limit);
+    }
+}
+exports.BaseVectorService = BaseVectorService;

package/dist/core/capabilities.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Resource Capability Discovery & Inference Engine
+ *
+ * PRD #48: Resource Capabilities Discovery & Integration
+ *
+ * This module provides capability inference for Kubernetes resources through
+ * AI-powered analysis of schemas and metadata.
+ */
+import { Logger } from './error-handling';
+import { ClaudeIntegration } from './claude';
+/**
+ * Complete resource capability data structure for Vector DB storage
+ */
+export interface ResourceCapability {
+    resourceName: string;
+    capabilities: string[];
+    providers: string[];
+    abstractions: string[];
+    complexity: 'low' | 'medium' | 'high';
+    description: string;
+    useCase: string;
+    embedding?: number[];
+    analyzedAt: string;
+    confidence: number;
+}
+/**
+ * Generic Capability Inference Engine
+ *
+ * Analyzes any Kubernetes CRD using AI to extract semantic capabilities
+ * for improved AI recommendations and resource matching.
+ */
+export declare class CapabilityInferenceEngine {
+    private logger;
+    private claudeIntegration;
+    constructor(claudeIntegration: ClaudeIntegration, logger: Logger);
+    /**
+     * Main entry point: analyze resource to infer complete capabilities
+     *
+     * @param resourceName - Full resource name (e.g., "resourcegroups.azure.upbound.io")
+     * @throws Error if capability inference fails for any reason
+     */
+    inferCapabilities(resourceName: string, schema?: string, metadata?: any): Promise<ResourceCapability>;
+    /**
+     * Use AI to infer capabilities from all available resource context
+     *
+     * @throws Error if AI inference fails
+     */
+    private inferWithAI;
+    /**
+     * Build AI inference prompt using standard prompt loading pattern
+     *
+     * @throws Error if prompt template cannot be loaded
+     */
+    private buildInferencePrompt;
+    /**
+     * Parse AI response into structured capability data
+     *
+     * @throws Error if AI response cannot be parsed or is invalid
+     */
+    private parseCapabilitiesFromAI;
+    /**
+     * Build final ResourceCapability from AI analysis result
+     */
+    private buildResourceCapability;
+    /**
+     * Generate Vector DB ID for capability storage
+     * Creates deterministic UUID from resource name for Qdrant compatibility
+     */
+    static generateCapabilityId(resourceName: string): string;
+}
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/core/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/core/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAK7C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAEjC,YAAY,EAAE,MAAM,CAAC;IAGrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAGtC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAGhB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAGrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,iBAAiB,CAAoB;gBAEjC,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;IAKhE;;;;;OAKG;IACG,iBAAiB,CACrB,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,GAAG,GACb,OAAO,CAAC,kBAAkB,CAAC;IA4B9B;;;;OAIG;YACW,WAAW;IA2BzB;;;;OAIG;YACW,oBAAoB;IAkClC;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAwD/B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;;OAGG;IACH,MAAM,CAAC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;CAQ1D"}

package/dist/core/capabilities.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Resource Capability Discovery & Inference Engine
+ *
+ * PRD #48: Resource Capabilities Discovery & Integration
+ *
+ * This module provides capability inference for Kubernetes resources through
+ * AI-powered analysis of schemas and metadata.
+ */
+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.CapabilityInferenceEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Generic Capability Inference Engine
+ *
+ * Analyzes any Kubernetes CRD using AI to extract semantic capabilities
+ * for improved AI recommendations and resource matching.
+ */
+class CapabilityInferenceEngine {
+    logger;
+    claudeIntegration;
+    constructor(claudeIntegration, logger) {
+        this.claudeIntegration = claudeIntegration;
+        this.logger = logger;
+    }
+    /**
+     * Main entry point: analyze resource to infer complete capabilities
+     *
+     * @param resourceName - Full resource name (e.g., "resourcegroups.azure.upbound.io")
+     * @throws Error if capability inference fails for any reason
+     */
+    async inferCapabilities(resourceName, schema, metadata) {
+        const requestId = `capability-inference-${Date.now()}`;
+        this.logger.info('Starting capability inference', {
+            requestId,
+            resource: resourceName,
+            hasSchema: !!schema,
+            hasMetadata: !!metadata
+        });
+        // Use AI to analyze all available information
+        const aiResult = await this.inferWithAI(resourceName, schema, metadata, requestId);
+        // Convert AI result to final capability structure
+        const finalCapability = this.buildResourceCapability(resourceName, aiResult);
+        this.logger.info('Capability inference completed', {
+            requestId,
+            resource: resourceName,
+            capabilitiesFound: finalCapability.capabilities.length,
+            providersFound: finalCapability.providers.length,
+            complexity: finalCapability.complexity,
+            confidence: finalCapability.confidence
+        });
+        return finalCapability;
+    }
+    /**
+     * Use AI to infer capabilities from all available resource context
+     *
+     * @throws Error if AI inference fails
+     */
+    async inferWithAI(resourceName, schema, metadata, requestId) {
+        try {
+            const prompt = await this.buildInferencePrompt(resourceName, schema, metadata);
+            const response = await this.claudeIntegration.sendMessage(prompt);
+            return this.parseCapabilitiesFromAI(response.content);
+        }
+        catch (error) {
+            this.logger.error('AI capability inference failed', error, {
+                requestId,
+                resource: resourceName
+            });
+            throw error; // Re-throw to maintain fail-fast behavior
+        }
+    }
+    /**
+     * Build AI inference prompt using standard prompt loading pattern
+     *
+     * @throws Error if prompt template cannot be loaded
+     */
+    async buildInferencePrompt(resourceName, schema, metadata) {
+        // Load prompt template using standard pattern from existing codebase
+        const promptPath = path.join(__dirname, '..', '..', 'prompts', 'capability-inference.md');
+        if (!fs.existsSync(promptPath)) {
+            throw new Error(`Capability inference prompt template not found: ${promptPath}`);
+        }
+        let template;
+        try {
+            template = fs.readFileSync(promptPath, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to read capability inference prompt: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Replace template variables using standard pattern
+        const analysisContext = schema && metadata ?
+            'Schema and metadata available' :
+            schema ? 'Schema only' :
+                metadata ? 'Metadata only' : 'Limited context';
+        const finalPrompt = template
+            .replace(/\{resourceName\}/g, resourceName)
+            .replace(/\{analysisContext\}/g, analysisContext)
+            .replace(/\{schema\}/g, schema || 'No schema provided')
+            .replace(/\{metadata\}/g, metadata ? JSON.stringify(metadata, null, 2) : 'No metadata provided');
+        return finalPrompt;
+    }
+    /**
+     * Parse AI response into structured capability data
+     *
+     * @throws Error if AI response cannot be parsed or is invalid
+     */
+    parseCapabilitiesFromAI(response) {
+        // Look for JSON in the response using standard pattern
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error(`No JSON found in AI response. Response: ${response.substring(0, 200)}...`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonMatch[0]);
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in AI response: ${parseError instanceof Error ? parseError.message : String(parseError)}. JSON: ${jsonMatch[0].substring(0, 200)}...`);
+        }
+        // Validate required fields with detailed error messages
+        if (!Array.isArray(parsed.capabilities)) {
+            throw new Error(`AI response missing or invalid capabilities array. Got: ${typeof parsed.capabilities}`);
+        }
+        if (!Array.isArray(parsed.providers)) {
+            throw new Error(`AI response missing or invalid providers array. Got: ${typeof parsed.providers}`);
+        }
+        if (!Array.isArray(parsed.abstractions)) {
+            throw new Error(`AI response missing or invalid abstractions array. Got: ${typeof parsed.abstractions}`);
+        }
+        if (!['low', 'medium', 'high'].includes(parsed.complexity)) {
+            throw new Error(`AI response invalid complexity: ${parsed.complexity}. Must be low, medium, or high`);
+        }
+        if (typeof parsed.description !== 'string' || parsed.description.trim() === '') {
+            throw new Error(`AI response missing or invalid description. Got: ${typeof parsed.description}`);
+        }
+        if (typeof parsed.useCase !== 'string' || parsed.useCase.trim() === '') {
+            throw new Error(`AI response missing or invalid useCase. Got: ${typeof parsed.useCase}`);
+        }
+        if (typeof parsed.confidence !== 'number' || parsed.confidence < 0 || parsed.confidence > 1) {
+            throw new Error(`AI response invalid confidence score: ${parsed.confidence}. Must be number between 0-1`);
+        }
+        return {
+            capabilities: parsed.capabilities,
+            providers: parsed.providers,
+            abstractions: parsed.abstractions,
+            complexity: parsed.complexity,
+            description: parsed.description.trim(),
+            useCase: parsed.useCase.trim(),
+            confidence: parsed.confidence
+        };
+    }
+    /**
+     * Build final ResourceCapability from AI analysis result
+     */
+    buildResourceCapability(resourceName, aiResult) {
+        return {
+            resourceName,
+            capabilities: aiResult.capabilities,
+            providers: aiResult.providers,
+            abstractions: aiResult.abstractions,
+            complexity: aiResult.complexity,
+            description: aiResult.description,
+            useCase: aiResult.useCase,
+            confidence: aiResult.confidence,
+            analyzedAt: new Date().toISOString()
+        };
+    }
+    /**
+     * Generate Vector DB ID for capability storage
+     * Creates deterministic UUID from resource name for Qdrant compatibility
+     */
+    static generateCapabilityId(resourceName) {
+        // Create deterministic UUID from resource name hash
+        const crypto = require('crypto');
+        const hash = crypto.createHash('sha256').update(`capability-${resourceName}`).digest('hex');
+        // Convert to UUID format: 8-4-4-4-12
+        return `${hash.substring(0, 8)}-${hash.substring(8, 12)}-${hash.substring(12, 16)}-${hash.substring(16, 20)}-${hash.substring(20, 32)}`;
+    }
+}
+exports.CapabilityInferenceEngine = CapabilityInferenceEngine;