@vfarcic/dot-ai 0.47.0 → 0.49.0

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>;
+    /**
+     * 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;
+    /**
+     * Keyword-only search (fallback when embeddings not available)
+     */
+    private keywordOnlySearch;
+    /**
+     * 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;IA4BvC;;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,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;YACW,iBAAiB;IAsB/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;CA2C7B"}

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

@@ -0,0 +1,231 @@
+"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);
+        // Try to generate embedding if service is available
+        let embedding = null;
+        if (this.embeddingService.isAvailable()) {
+            try {
+                embedding = await this.embeddingService.generateEmbedding(searchText);
+            }
+            catch (error) {
+                // Log but don't fail - fall back to keyword-only storage
+                console.warn(`Failed to generate embedding for ${this.collectionName}, using keyword-only storage:`, error);
+            }
+        }
+        const document = {
+            id,
+            payload: {
+                ...this.createPayload(data),
+                searchText: searchText,
+                hasEmbedding: embedding !== null
+            },
+            vector: embedding || undefined
+        };
+        await this.vectorDB.upsertDocument(document);
+    }
+    /**
+     * Search for data using hybrid semantic + keyword matching
+     */
+    async searchData(query, options = {}) {
+        // 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.1;
+        // Try semantic search first if embeddings available
+        if (this.embeddingService.isAvailable()) {
+            try {
+                return await this.hybridSearch(query, queryKeywords, { limit, scoreThreshold });
+            }
+            catch (error) {
+                // Fall back to keyword-only search if semantic search fails
+                console.warn('Semantic search failed, falling back to keyword search:', error);
+            }
+        }
+        // Keyword-only search (fallback or when embeddings not available)
+        return await this.keywordOnlySearch(queryKeywords, { limit, scoreThreshold });
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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
+        const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+        if (!queryEmbedding) {
+            // Fall back to keyword search
+            return await this.keywordOnlySearch(queryKeywords, options);
+        }
+        // Semantic search using vector similarity
+        const semanticResults = await this.vectorDB.searchSimilar(queryEmbedding, {
+            limit: options.limit * 2, // Get more candidates for hybrid ranking
+            scoreThreshold: 0.5 // Lower threshold for semantic similarity
+        });
+        // 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);
+    }
+    /**
+     * Keyword-only search (fallback when embeddings not available)
+     */
+    async keywordOnlySearch(queryKeywords, options) {
+        const keywordResults = await this.vectorDB.searchByKeywords(queryKeywords, options);
+        return keywordResults
+            .map(result => {
+            const data = this.payloadToData(result.payload);
+            data.id = result.id;
+            return {
+                data,
+                score: result.score,
+                matchType: 'keyword'
+            };
+        })
+            .filter(result => result.score >= options.scoreThreshold); // Apply score filtering
+    }
+    /**
+     * 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/index.d.ts

@@ -44,6 +44,7 @@ export { validatePattern, createPattern, serializePattern, deserializePattern }
 export { PatternCreationStep, PatternCreationSession, PatternWorkflowStep } from './pattern-creation-types';
 export { PatternCreationSessionManager } from './pattern-creation-session';
 export { VectorDBService, VectorDBConfig, VectorDocument, SearchResult } from './vector-db-service';
+export { BaseVectorService, BaseSearchOptions, BaseSearchResult } from './base-vector-service';
 export { PatternVectorService, PatternSearchOptions, PatternSearchResult } from './pattern-vector-service';
 export { EmbeddingService, EmbeddingConfig, EmbeddingProvider, OpenAIEmbeddingProvider } from './embedding-service';
 export default DotAI;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEhF,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAkB;IAErC,SAAgB,SAAS,EAAE,mBAAmB,CAAC;IAC/C,SAAgB,MAAM,EAAE,YAAY,CAAC;IACrC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,MAAM,EAAE,iBAAiB,CAAC;IAC1C,SAAgB,MAAM,EAAE;QACtB,MAAM,EAAE,YAAY,CAAC;QACrB,SAAS,EAAE,iBAAiB,CAAC;QAC7B,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;QACnC,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QACtD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KACjD,CAAC;gBAEU,MAAM,GAAE,UAAe;IAoEnC,OAAO,CAAC,cAAc;IAMhB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAc3B,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAa/C,aAAa,IAAI,OAAO;IAIxB,UAAU,IAAI,MAAM;IAIpB,kBAAkB,IAAI,MAAM,GAAG,SAAS;CAGzC;AAGD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC5G,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC3G,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGpH,eAAe,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEhF,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAkB;IAErC,SAAgB,SAAS,EAAE,mBAAmB,CAAC;IAC/C,SAAgB,MAAM,EAAE,YAAY,CAAC;IACrC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,MAAM,EAAE,iBAAiB,CAAC;IAC1C,SAAgB,MAAM,EAAE;QACtB,MAAM,EAAE,YAAY,CAAC;QACrB,SAAS,EAAE,iBAAiB,CAAC;QAC7B,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;QACnC,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QACtD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KACjD,CAAC;gBAEU,MAAM,GAAE,UAAe;IAoEnC,OAAO,CAAC,cAAc;IAMhB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAc3B,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAa/C,aAAa,IAAI,OAAO;IAIxB,UAAU,IAAI,MAAM;IAIpB,kBAAkB,IAAI,MAAM,GAAG,SAAS;CAGzC;AAGD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC5G,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC3G,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGpH,eAAe,KAAK,CAAC"}

package/dist/core/index.js

@@ -5,7 +5,7 @@
  * Shared intelligence for both CLI and MCP interfaces
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIEmbeddingProvider = exports.EmbeddingService = exports.PatternVectorService = exports.VectorDBService = exports.PatternCreationSessionManager = exports.deserializePattern = exports.serializePattern = exports.createPattern = exports.validatePattern = exports.ResourceRecommender = exports.ManifestValidator = exports.SchemaParser = exports.ClaudeIntegration = exports.WorkflowEngine = exports.MemorySystem = exports.KubernetesDiscovery = exports.DotAI = void 0;
+exports.OpenAIEmbeddingProvider = exports.EmbeddingService = exports.PatternVectorService = exports.BaseVectorService = exports.VectorDBService = exports.PatternCreationSessionManager = exports.deserializePattern = exports.serializePattern = exports.createPattern = exports.validatePattern = exports.ResourceRecommender = exports.ManifestValidator = exports.SchemaParser = exports.ClaudeIntegration = exports.WorkflowEngine = exports.MemorySystem = exports.KubernetesDiscovery = exports.DotAI = void 0;
 const discovery_1 = require("./discovery");
 const memory_1 = require("./memory");
 const workflow_1 = require("./workflow");
@@ -140,6 +140,8 @@ var pattern_creation_session_1 = require("./pattern-creation-session");
 Object.defineProperty(exports, "PatternCreationSessionManager", { enumerable: true, get: function () { return pattern_creation_session_1.PatternCreationSessionManager; } });
 var vector_db_service_1 = require("./vector-db-service");
 Object.defineProperty(exports, "VectorDBService", { enumerable: true, get: function () { return vector_db_service_1.VectorDBService; } });
+var base_vector_service_1 = require("./base-vector-service");
+Object.defineProperty(exports, "BaseVectorService", { enumerable: true, get: function () { return base_vector_service_1.BaseVectorService; } });
 var pattern_vector_service_1 = require("./pattern-vector-service");
 Object.defineProperty(exports, "PatternVectorService", { enumerable: true, get: function () { return pattern_vector_service_1.PatternVectorService; } });
 var embedding_service_1 = require("./embedding-service");

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

@@ -1,97 +1,28 @@
 /**
  * Pattern Vector Service
  *
- * Handles pattern-specific Vector DB operations with keyword-based matching
+ * Handles pattern-specific Vector DB operations
+ * Extends BaseVectorService for organizational patterns
  */
 import { VectorDBService } from './vector-db-service';
 import { OrganizationalPattern } from './pattern-types';
 import { EmbeddingService } from './embedding-service';
-export interface PatternSearchOptions {
-    limit?: number;
-    scoreThreshold?: number;
-    keywordWeight?: number;
+import { BaseVectorService, BaseSearchOptions, BaseSearchResult } from './base-vector-service';
+export interface PatternSearchOptions extends BaseSearchOptions {
 }
-export interface PatternSearchResult {
-    pattern: OrganizationalPattern;
-    score: number;
-    matchType: 'keyword' | 'semantic' | 'hybrid';
+export interface PatternSearchResult extends BaseSearchResult<OrganizationalPattern> {
 }
-export declare class PatternVectorService {
-    private vectorDB;
-    private embeddingService;
-    private collectionName;
-    constructor(vectorDB: VectorDBService, embeddingService?: EmbeddingService);
-    /**
-     * Initialize the patterns collection
-     */
-    initialize(): Promise<void>;
-    /**
-     * Store a pattern in Vector DB with optional semantic embedding
-     */
+export declare class PatternVectorService extends BaseVectorService<OrganizationalPattern> {
+    constructor(vectorDB?: VectorDBService, embeddingService?: EmbeddingService);
+    protected createSearchText(pattern: OrganizationalPattern): string;
+    protected extractId(pattern: OrganizationalPattern): string;
+    protected createPayload(pattern: OrganizationalPattern): Record<string, any>;
+    protected payloadToData(payload: Record<string, any>): OrganizationalPattern;
     storePattern(pattern: OrganizationalPattern): Promise<void>;
-    /**
-     * Search for patterns using hybrid semantic + keyword matching
-     */
     searchPatterns(query: string, options?: PatternSearchOptions): Promise<PatternSearchResult[]>;
-    /**
-     * Hybrid search combining semantic and keyword matching
-     */
-    private hybridSearch;
-    /**
-     * Keyword-only search (fallback when embeddings not available)
-     */
-    private keywordOnlySearch;
-    /**
-     * Combine semantic and keyword search results with hybrid ranking
-     */
-    private combineHybridResults;
-    /**
-     * Get search mode information for debugging
-     */
-    getSearchMode(): {
-        semantic: boolean;
-        provider: string | null;
-        reason?: string;
-    };
-    /**
-     * Get pattern by ID
-     */
     getPattern(id: string): Promise<OrganizationalPattern | null>;
-    /**
-     * Get all patterns
-     */
     getAllPatterns(): Promise<OrganizationalPattern[]>;
-    /**
-     * Delete pattern by ID
-     */
     deletePattern(id: string): Promise<void>;
-    /**
-     * Get patterns count
-     */
     getPatternsCount(): Promise<number>;
-    /**
-     * Health check for pattern storage
-     */
-    healthCheck(): Promise<boolean>;
-    /**
-     * Extract keywords from query text
-     */
-    private extractKeywords;
-    /**
-     * Simple stop words list
-     */
-    private isStopWord;
-    /**
-     * Calculate keyword match score
-     */
-    private calculateKeywordScore;
-    /**
-     * Create searchable text from pattern
-     */
-    private createSearchText;
-    /**
-     * Convert Vector DB payload back to OrganizationalPattern
-     */
-    private payloadToPattern;
 }
 //# sourceMappingURL=pattern-vector-service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pattern-vector-service.d.ts","sourceRoot":"","sources":["../../src/core/pattern-vector-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAkB,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;CAC9C;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,cAAc,CAAc;gBAExB,QAAQ,EAAE,eAAe,EAAE,gBAAgB,CAAC,EAAE,gBAAgB;IAK1E;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCjE;;OAEG;IACG,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAyBjC;;OAEG;YACW,YAAY;IAkC1B;;OAEG;YACW,iBAAiB;IAqB/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAmD5B;;OAEG;IACH,aAAa,IAAI;QACf,QAAQ,EAAE,OAAO,CAAC;QAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IASD;;OAEG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;IAQnE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAKxD;;OAEG;IACG,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAWzC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAYlB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}
+{"version":3,"file":"pattern-vector-service.d.ts","sourceRoot":"","sources":["../../src/core/pattern-vector-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/F,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;CAAG;AAClE,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB,CAAC,qBAAqB,CAAC;CAAG;AAEvF,qBAAa,oBAAqB,SAAQ,iBAAiB,CAAC,qBAAqB,CAAC;gBACpE,QAAQ,CAAC,EAAE,eAAe,EAAE,gBAAgB,CAAC,EAAE,gBAAgB;IAK3E,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM;IAOlE,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM;IAI3D,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAW5E,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,qBAAqB;IAatE,YAAY,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3D,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAIjG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;IAI7D,cAAc,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAIlD,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;CAG1C"}

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

@@ -2,301 +2,64 @@
 /**
  * Pattern Vector Service
  *
- * Handles pattern-specific Vector DB operations with keyword-based matching
+ * Handles pattern-specific Vector DB operations
+ * Extends BaseVectorService for organizational patterns
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PatternVectorService = void 0;
-const embedding_service_1 = require("./embedding-service");
-class PatternVectorService {
-    vectorDB;
-    embeddingService;
-    collectionName = 'patterns';
+const base_vector_service_1 = require("./base-vector-service");
+class PatternVectorService extends base_vector_service_1.BaseVectorService {
     constructor(vectorDB, embeddingService) {
-        this.vectorDB = vectorDB;
-        this.embeddingService = embeddingService || new embedding_service_1.EmbeddingService();
+        super('patterns', vectorDB, embeddingService);
     }
-    /**
-     * Initialize the patterns 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);
-    }
-    /**
-     * Store a pattern in Vector DB with optional semantic embedding
-     */
-    async storePattern(pattern) {
-        const searchText = this.createSearchText(pattern);
-        // Try to generate embedding if service is available
-        let embedding = null;
-        if (this.embeddingService.isAvailable()) {
-            try {
-                embedding = await this.embeddingService.generateEmbedding(searchText);
-            }
-            catch (error) {
-                // Log but don't fail - fall back to keyword-only storage
-                console.warn('Failed to generate embedding for pattern, using keyword-only storage:', error);
-            }
-        }
-        const document = {
-            id: pattern.id,
-            payload: {
-                description: pattern.description,
-                triggers: pattern.triggers.map(t => t.toLowerCase()), // Store lowercase for matching
-                suggestedResources: pattern.suggestedResources,
-                rationale: pattern.rationale,
-                createdAt: pattern.createdAt,
-                createdBy: pattern.createdBy,
-                searchText: searchText,
-                // Store embedding status for debugging
-                hasEmbedding: embedding !== null
-            },
-            vector: embedding || undefined // Use real embedding or let VectorDB use zero vector
-        };
-        await this.vectorDB.upsertDocument(document);
-    }
-    /**
-     * Search for patterns using hybrid semantic + keyword matching
-     */
-    async searchPatterns(query, options = {}) {
-        // 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.1;
-        // Try semantic search first if embeddings available
-        if (this.embeddingService.isAvailable()) {
-            try {
-                return await this.hybridSearch(query, queryKeywords, { limit, scoreThreshold });
-            }
-            catch (error) {
-                // Fall back to keyword-only search if semantic search fails
-                console.warn('Semantic search failed, falling back to keyword search:', error);
-            }
-        }
-        // Keyword-only search (fallback or when embeddings not available)
-        return await this.keywordOnlySearch(queryKeywords, { limit, scoreThreshold });
-    }
-    /**
-     * Hybrid search combining semantic and keyword matching
-     */
-    async hybridSearch(query, queryKeywords, options) {
-        // Generate query embedding
-        const queryEmbedding = await this.embeddingService.generateEmbedding(query);
-        if (!queryEmbedding) {
-            // Fall back to keyword search
-            return await this.keywordOnlySearch(queryKeywords, options);
-        }
-        // Semantic search using vector similarity
-        const semanticResults = await this.vectorDB.searchSimilar(queryEmbedding, {
-            limit: options.limit * 2, // Get more candidates for hybrid ranking
-            scoreThreshold: 0.5 // Lower threshold for semantic similarity
-        });
-        // 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);
+    // Implement abstract methods from BaseVectorService
+    createSearchText(pattern) {
+        const triggerText = pattern.triggers.join(' ');
+        const resourceText = pattern.suggestedResources.join(' ');
+        return `${pattern.description} ${triggerText} ${resourceText} ${pattern.rationale}`.toLowerCase();
     }
-    /**
-     * Keyword-only search (fallback when embeddings not available)
-     */
-    async keywordOnlySearch(queryKeywords, options) {
-        const keywordResults = await this.vectorDB.searchByKeywords(queryKeywords, {
-            limit: options.limit,
-            scoreThreshold: options.scoreThreshold
-        });
-        return keywordResults.map(result => ({
-            pattern: this.payloadToPattern(result.payload, result.id),
-            score: this.calculateKeywordScore(queryKeywords, result.payload.triggers || []),
-            matchType: 'keyword'
-        }))
-            .filter(result => result.score > options.scoreThreshold)
-            .sort((a, b) => b.score - a.score);
+    extractId(pattern) {
+        return pattern.id;
     }
-    /**
-     * Combine semantic and keyword search results with hybrid ranking
-     */
-    combineHybridResults(semanticResults, keywordResults, queryKeywords, options) {
-        // Create map to avoid duplicates and combine scores
-        const resultMap = new Map();
-        // Process semantic results
-        semanticResults.forEach(result => {
-            const pattern = this.payloadToPattern(result.payload, result.id);
-            const semanticScore = result.score; // Cosine similarity from Vector DB
-            resultMap.set(result.id, {
-                pattern,
-                score: semanticScore * 0.7, // Weight semantic score at 70%
-                matchType: 'semantic'
-            });
-        });
-        // Process keyword results and combine with semantic
-        keywordResults.forEach(result => {
-            const pattern = this.payloadToPattern(result.payload, result.id);
-            const keywordScore = this.calculateKeywordScore(queryKeywords, result.payload.triggers || []);
-            if (resultMap.has(result.id)) {
-                // Combine scores for hybrid result
-                const existing = resultMap.get(result.id);
-                resultMap.set(result.id, {
-                    pattern,
-                    score: existing.score + (keywordScore * 0.3), // Add 30% keyword weight
-                    matchType: 'hybrid'
-                });
-            }
-            else {
-                // Keyword-only result - give fair weight, don't penalize
-                resultMap.set(result.id, {
-                    pattern,
-                    score: keywordScore, // Use full keyword score for keyword-only results
-                    matchType: 'keyword'
-                });
-            }
-        });
-        // Convert to array, filter, and sort
-        return Array.from(resultMap.values())
-            .filter(result => result.score > options.scoreThreshold)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, options.limit);
+    createPayload(pattern) {
+        return {
+            description: pattern.description,
+            triggers: pattern.triggers.map(t => t.toLowerCase()),
+            suggestedResources: pattern.suggestedResources,
+            rationale: pattern.rationale,
+            createdAt: pattern.createdAt,
+            createdBy: pattern.createdBy
+        };
     }
-    /**
-     * Get search mode information for debugging
-     */
-    getSearchMode() {
-        const status = this.embeddingService.getStatus();
+    payloadToData(payload) {
         return {
-            semantic: status.available,
-            provider: status.provider,
-            reason: status.reason
+            id: '', // Will be set from document ID in base class
+            description: payload.description,
+            triggers: payload.triggers,
+            suggestedResources: payload.suggestedResources,
+            rationale: payload.rationale,
+            createdAt: payload.createdAt,
+            createdBy: payload.createdBy
         };
     }
-    /**
-     * Get pattern by ID
-     */
+    // Public API methods - delegate to base class with appropriate names
+    async storePattern(pattern) {
+        await this.storeData(pattern);
+    }
+    async searchPatterns(query, options = {}) {
+        return await this.searchData(query, options);
+    }
     async getPattern(id) {
-        const document = await this.vectorDB.getDocument(id);
-        if (!document) {
-            return null;
-        }
-        return this.payloadToPattern(document.payload, document.id);
+        return await this.getData(id);
     }
-    /**
-     * Get all patterns
-     */
     async getAllPatterns() {
-        const documents = await this.vectorDB.getAllDocuments();
-        return documents.map(doc => this.payloadToPattern(doc.payload, doc.id));
+        return await this.getAllData();
     }
-    /**
-     * Delete pattern by ID
-     */
     async deletePattern(id) {
-        await this.vectorDB.deleteDocument(id);
+        await this.deleteData(id);
     }
-    /**
-     * Get patterns count
-     */
     async getPatternsCount() {
-        try {
-            const info = await this.vectorDB.getCollectionInfo();
-            return info.points_count || 0;
-        }
-        catch (error) {
-            // Fallback: get all and count
-            const patterns = await this.getAllPatterns();
-            return patterns.length;
-        }
-    }
-    /**
-     * Health check for pattern storage
-     */
-    async healthCheck() {
-        return await this.vectorDB.healthCheck();
-    }
-    /**
-     * Extract keywords from query text
-     */
-    extractKeywords(query) {
-        // Simple keyword extraction - split on whitespace and punctuation
-        return query
-            .toLowerCase()
-            .replace(/[^\w\s]/g, ' ') // Replace punctuation with spaces
-            .split(/\s+/)
-            .filter(word => word.length > 2) // Filter out very short words
-            .filter(word => !this.isStopWord(word)); // Filter out stop words
-    }
-    /**
-     * Simple stop words list
-     */
-    isStopWord(word) {
-        const stopWords = new Set([
-            'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
-            'by', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had',
-            'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might',
-            'can', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it',
-            'we', 'they', 'me', 'him', 'her', 'us', 'them', 'my', 'your', 'his',
-            'our', 'their', 'a', 'an'
-        ]);
-        return stopWords.has(word);
-    }
-    /**
-     * Calculate keyword match score
-     */
-    calculateKeywordScore(queryKeywords, patternTriggers) {
-        if (queryKeywords.length === 0 || patternTriggers.length === 0) {
-            return 0;
-        }
-        const lowerTriggers = patternTriggers.map(t => t.toLowerCase());
-        let matchCount = 0;
-        let exactMatches = 0;
-        for (const keyword of queryKeywords) {
-            // Check for exact matches
-            if (lowerTriggers.includes(keyword)) {
-                exactMatches++;
-                matchCount++;
-                continue;
-            }
-            // Check for partial matches (keyword contains trigger or vice versa)
-            const hasPartialMatch = lowerTriggers.some(trigger => keyword.includes(trigger) || trigger.includes(keyword));
-            if (hasPartialMatch) {
-                matchCount++;
-            }
-        }
-        // Calculate score: exact matches worth more than partial matches
-        const exactScore = (exactMatches / queryKeywords.length) * 1.0;
-        const partialScore = ((matchCount - exactMatches) / queryKeywords.length) * 0.5;
-        return Math.min(exactScore + partialScore, 1.0);
-    }
-    /**
-     * Create searchable text from pattern
-     */
-    createSearchText(pattern) {
-        return [
-            pattern.description,
-            ...pattern.triggers,
-            ...pattern.suggestedResources,
-            pattern.rationale
-        ].join(' ').toLowerCase();
-    }
-    /**
-     * Convert Vector DB payload back to OrganizationalPattern
-     */
-    payloadToPattern(payload, id) {
-        return {
-            id: id || payload.id || '',
-            description: payload.description || '',
-            triggers: payload.triggers || [],
-            suggestedResources: payload.suggestedResources || [],
-            rationale: payload.rationale || '',
-            createdAt: payload.createdAt || new Date().toISOString(),
-            createdBy: payload.createdBy || 'unknown'
-        };
+        return await this.getDataCount();
     }
 }
 exports.PatternVectorService = PatternVectorService;

package/dist/core/schema.js

@@ -315,7 +315,7 @@ class ResourceRecommender {
             if (concepts.length === 0) {
                 console.warn('⚠️ No concepts extracted, falling back to simple pattern search');
                 const fallbackResults = await this.patternService.searchPatterns(intent, { limit: 5 });
-                return fallbackResults.map(result => result.pattern);
+                return fallbackResults.map(result => result.data);
             }
             // Step 2: Find patterns for each concept
             const allPatternMatches = [];
@@ -326,7 +326,7 @@ class ResourceRecommender {
                     const searchResults = await this.patternService.searchPatterns(conceptKeywords, { limit: 10 });
                     // Convert to PatternMatch with concept context
                     const matches = searchResults.map(result => ({
-                        pattern: result.pattern,
+                        pattern: result.data,
                         score: result.score * this.getConceptImportanceWeight(concept.importance),
                         matchedConcept: concept,
                         matchType: result.matchType

package/dist/tools/organizational-data.d.ts

@@ -11,14 +11,27 @@ import { z } from 'zod';
 import { DotAI } from '../core/index';
 import { Logger } from '../core/error-handling';
 export declare const ORGANIZATIONAL_DATA_TOOL_NAME = "manageOrgData";
-export declare const ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = "Manage organizational deployment patterns, templates, standards, and best practices for AI recommendations. Use this tool when user wants to save, create, add, or manage deployment patterns, templates, resource configurations, organizational standards, best practices, or reusable deployment guidelines. This tool uses a step-by-step workflow for creation. IMPORTANT: When user wants to create something, call this tool with operation=create (no other parameters). The tool will return a workflow step with a \"prompt\" field - you must execute that prompt immediately and wait for user response before calling again.";
+export declare const ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = "Unified tool for managing cluster data: organizational patterns (available now), resource capabilities (PRD #48), and resource dependencies (PRD #49). For patterns: supports step-by-step creation workflow. For capabilities/dependencies: returns implementation status. Use dataType parameter to specify what to manage: \"pattern\" for organizational patterns, \"capabilities\" for resource capabilities, \"dependencies\" for resource dependencies.";
 export declare const ORGANIZATIONAL_DATA_TOOL_INPUT_SCHEMA: {
-    dataType: z.ZodEnum<["pattern"]>;
-    operation: z.ZodEnum<["create", "list", "get", "delete"]>;
+    dataType: z.ZodEnum<["pattern", "capabilities", "dependencies"]>;
+    operation: z.ZodEnum<["create", "list", "get", "delete", "scan", "analyze"]>;
     sessionId: z.ZodOptional<z.ZodString>;
     response: z.ZodOptional<z.ZodString>;
     id: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
+    resource: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        group: z.ZodString;
+        apiVersion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: string;
+        group: string;
+        apiVersion: string;
+    }, {
+        kind: string;
+        group: string;
+        apiVersion: string;
+    }>>;
 };
 /**
  * Main tool handler - routes to appropriate data type handler

package/dist/tools/organizational-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"organizational-data.d.ts","sourceRoot":"","sources":["../../src/tools/organizational-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAShD,eAAO,MAAM,6BAA6B,kBAAkB,CAAC;AAC7D,eAAO,MAAM,oCAAoC,8mBAA4mB,CAAC;AAG9pB,eAAO,MAAM,qCAAqC;;;;;;;CAajD,CAAC;AA0XF;;GAEG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,KAAK,GAAG,IAAI,EACpB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CA0Hd"}
+{"version":3,"file":"organizational-data.d.ts","sourceRoot":"","sources":["../../src/tools/organizational-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAShD,eAAO,MAAM,6BAA6B,kBAAkB,CAAC;AAC7D,eAAO,MAAM,oCAAoC,mcAA6b,CAAC;AAG/e,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;CAoBjD,CAAC;AA6fF;;GAEG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,KAAK,GAAG,IAAI,EACpB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CA0Hd"}

package/dist/tools/organizational-data.js

@@ -54,18 +54,24 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // Tool metadata for MCP registration
 exports.ORGANIZATIONAL_DATA_TOOL_NAME = 'manageOrgData';
-exports.ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = 'Manage organizational deployment patterns, templates, standards, and best practices for AI recommendations. Use this tool when user wants to save, create, add, or manage deployment patterns, templates, resource configurations, organizational standards, best practices, or reusable deployment guidelines. This tool uses a step-by-step workflow for creation. IMPORTANT: When user wants to create something, call this tool with operation=create (no other parameters). The tool will return a workflow step with a "prompt" field - you must execute that prompt immediately and wait for user response before calling again.';
-// Extensible schema - ready for future data types
+exports.ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = 'Unified tool for managing cluster data: organizational patterns (available now), resource capabilities (PRD #48), and resource dependencies (PRD #49). For patterns: supports step-by-step creation workflow. For capabilities/dependencies: returns implementation status. Use dataType parameter to specify what to manage: "pattern" for organizational patterns, "capabilities" for resource capabilities, "dependencies" for resource dependencies.';
+// Extensible schema - supports patterns, capabilities, and dependencies
 exports.ORGANIZATIONAL_DATA_TOOL_INPUT_SCHEMA = {
-    dataType: zod_1.z.enum(['pattern']).describe('Type of organizational data to manage (currently only "pattern" supported)'),
-    operation: zod_1.z.enum(['create', 'list', 'get', 'delete']).describe('Operation to perform on the organizational data'),
+    dataType: zod_1.z.enum(['pattern', 'capabilities', 'dependencies']).describe('Type of cluster data to manage: pattern (organizational patterns), capabilities (resource capabilities), dependencies (resource dependencies)'),
+    operation: zod_1.z.enum(['create', 'list', 'get', 'delete', 'scan', 'analyze']).describe('Operation to perform on the cluster data'),
     // Workflow fields for step-by-step pattern creation
     sessionId: zod_1.z.string().optional().describe('Pattern creation session ID (for continuing multi-step workflow)'),
     response: zod_1.z.string().optional().describe('User response to previous workflow step question'),
     // Generic fields for get/delete operations
     id: zod_1.z.string().optional().describe('Data item ID (required for get/delete operations)'),
     // Generic fields for list operations
-    limit: zod_1.z.number().optional().describe('Maximum number of items to return (default: 10)')
+    limit: zod_1.z.number().optional().describe('Maximum number of items to return (default: 10)'),
+    // Resource-specific fields (for capabilities and dependencies)
+    resource: zod_1.z.object({
+        kind: zod_1.z.string(),
+        group: zod_1.z.string(),
+        apiVersion: zod_1.z.string()
+    }).optional().describe('Kubernetes resource reference (for capabilities/dependencies operations)')
 };
 /**
  * Get Vector DB-based pattern service with optional embedding support
@@ -120,6 +126,48 @@ async function validateVectorDBConnection(patternService, logger, requestId) {
     }
     return { success: true };
 }
+/**
+ * Validate embedding service configuration and fail if unavailable
+ */
+async function validateEmbeddingService(logger, requestId) {
+    const { EmbeddingService } = await Promise.resolve().then(() => __importStar(require('../core/embedding-service')));
+    const embeddingService = new EmbeddingService();
+    const status = embeddingService.getStatus();
+    if (!status.available) {
+        logger.warn('Embedding service required but not available', {
+            requestId,
+            reason: status.reason
+        });
+        return {
+            success: false,
+            error: {
+                message: 'OpenAI API key required for pattern management',
+                details: 'Pattern management requires OpenAI embeddings for semantic search and storage. The system cannot proceed without proper configuration.',
+                reason: status.reason,
+                setup: {
+                    required: 'export OPENAI_API_KEY=your-openai-api-key',
+                    optional: [
+                        'export OPENAI_MODEL=text-embedding-3-small (default)',
+                        'export OPENAI_DIMENSIONS=1536 (default)'
+                    ],
+                    docs: 'Get API key from https://platform.openai.com/api-keys'
+                },
+                currentConfig: {
+                    OPENAI_API_KEY: process.env.OPENAI_API_KEY ? 'set' : 'not set',
+                    QDRANT_URL: process.env.QDRANT_URL || 'http://localhost:6333',
+                    status: 'embedding service unavailable'
+                }
+            }
+        };
+    }
+    logger.info('Embedding service available', {
+        requestId,
+        provider: status.provider,
+        model: status.model,
+        dimensions: status.dimensions
+    });
+    return { success: true };
+}
 /**
  * Handle pattern operations with workflow support
  */
@@ -136,6 +184,17 @@ async function handlePatternOperation(operation, args, logger, requestId) {
             message: 'Vector DB connection required for pattern management'
         };
     }
+    // Validate embedding service and fail if unavailable
+    const embeddingCheck = await validateEmbeddingService(logger, requestId);
+    if (!embeddingCheck.success) {
+        return {
+            success: false,
+            operation,
+            dataType: 'pattern',
+            error: embeddingCheck.error,
+            message: 'OpenAI API key required for pattern management'
+        };
+    }
     const sessionManager = new pattern_creation_session_1.PatternCreationSessionManager();
     switch (operation) {
         case 'create': {
@@ -366,6 +425,60 @@ async function handlePatternOperation(operation, args, logger, requestId) {
             });
     }
 }
+/**
+ * Handle capabilities operations (placeholder for PRD #48)
+ */
+async function handleCapabilitiesOperation(operation, args, logger, requestId) {
+    logger.info('Capabilities operation requested', { requestId, operation });
+    return {
+        success: false,
+        operation,
+        dataType: 'capabilities',
+        error: {
+            message: 'Resource capabilities management not yet implemented',
+            details: 'This feature is planned for PRD #48 - Resource Capabilities Discovery & Integration',
+            status: 'coming-soon',
+            implementationPlan: {
+                prd: 'PRD #48',
+                description: 'Kubernetes resource capability discovery and semantic matching',
+                expectedFeatures: [
+                    'Cluster resource scanning',
+                    'Capability inference from schemas',
+                    'Semantic resource matching',
+                    'Vector DB storage and search'
+                ]
+            }
+        },
+        message: 'Capabilities management will be available after PRD #48 implementation'
+    };
+}
+/**
+ * Handle dependencies operations (placeholder for PRD #49)
+ */
+async function handleDependenciesOperation(operation, args, logger, requestId) {
+    logger.info('Dependencies operation requested', { requestId, operation });
+    return {
+        success: false,
+        operation,
+        dataType: 'dependencies',
+        error: {
+            message: 'Resource dependencies management not yet implemented',
+            details: 'This feature is planned for PRD #49 - Resource Dependencies Discovery & Integration',
+            status: 'coming-soon',
+            implementationPlan: {
+                prd: 'PRD #49',
+                description: 'Resource dependency discovery and complete solution assembly',
+                expectedFeatures: [
+                    'Dependency relationship discovery',
+                    'Complete solution assembly',
+                    'Deployment order optimization',
+                    'Vector DB storage and search'
+                ]
+            }
+        },
+        message: 'Dependencies management will be available after PRD #49 implementation'
+    };
+}
 /**
  * Main tool handler - routes to appropriate data type handler
  */
@@ -399,19 +512,18 @@ async function handleOrganizationalDataTool(args, _dotAI, logger, requestId) {
             case 'pattern':
                 result = await handlePatternOperation(args.operation, args, logger, requestId);
                 break;
-            // Future data types will be added here:
-            // case 'policy':
-            //   result = await handlePolicyOperation(args.operation, args, logger, requestId);
-            //   break;
-            // case 'memory':
-            //   result = await handleMemoryOperation(args.operation, args, logger, requestId);
-            //   break;
+            case 'capabilities':
+                result = await handleCapabilitiesOperation(args.operation, args, logger, requestId);
+                break;
+            case 'dependencies':
+                result = await handleDependenciesOperation(args.operation, args, logger, requestId);
+                break;
             default:
-                throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Unsupported data type: ${args.dataType}. Currently supported: pattern`, {
+                throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Unsupported data type: ${args.dataType}. Currently supported: pattern, capabilities, dependencies`, {
                     operation: 'data_type_validation',
                     component: 'OrganizationalDataTool',
                     requestId,
-                    input: { dataType: args.dataType, supportedTypes: ['pattern'] }
+                    input: { dataType: args.dataType, supportedTypes: ['pattern', 'capabilities', 'dependencies'] }
                 });
         }
         logger.info('Organizational-data tool request completed successfully', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.47.0",
+  "version": "0.49.0",
   "description": "Universal Kubernetes application deployment agent with CLI and MCP interfaces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/shared-prompts/prd-done.md

@@ -30,10 +30,11 @@ Complete the PRD implementation workflow including branch management, pull reque
 - [ ] **Request reviews**: Assign appropriate team members for code review
 
 ### 4. Review and Merge Process
-- [ ] **Check PR status**: Use `gh pr view [pr-number]` to check for any ongoing reviews or processes
-- [ ] **Wait for completion**: Do NOT merge if PR comments indicate reviews, checks, or processes are still in progress
-- [ ] **Address review feedback**: Make any required changes from code review
-- [ ] **Verify all checks pass**: Ensure all CI/CD, tests, and automated processes are complete and passing
+- [ ] **Check ongoing processes**: Use `gh pr checks [pr-number]` to check for any ongoing CI/CD, security analysis, or automated reviews (CodeRabbit, CodeQL, etc.)
+- [ ] **Check PR details**: Use `gh pr view [pr-number]` to check for human review comments and PR metadata
+- [ ] **Wait for completion**: Do NOT merge if checks show pending processes or PR comments indicate reviews still in progress
+- [ ] **Address review feedback**: Make any required changes from code review (both automated and human)
+- [ ] **Verify all checks pass**: Ensure all CI/CD, tests, security analysis, and automated processes are complete and passing
 - [ ] **Merge to main**: Complete the pull request merge only after all feedback addressed and processes complete
 - [ ] **Verify deployment**: Ensure feature works in production environment
 - [ ] **Monitor for issues**: Watch for any post-deployment problems