centient 2.20.0

package/dist/utils/PatternIndexer.js

@@ -0,0 +1,730 @@
+import { QdrantClient } from "@qdrant/js-client-rest";
+import * as fs from "fs/promises";
+import OpenAI from "openai";
+import * as crypto from "crypto";
+import { GoogleGenAI } from "@google/genai";
+import { homedir } from "os";
+import { join } from "path";
+import { withExternalSpan } from "../telemetry/index.js";
+import { getCostTracker } from "./CostTracker.js";
+import { ServiceCircuitBreakers } from "./CircuitBreaker.js";
+import { ServiceRateLimiters } from "./RateLimiter.js";
+function patternIdToUuid(patternId) {
+    const NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    const hash = crypto.createHash("sha1");
+    hash.update(Buffer.from(NAMESPACE.replace(/-/g, ""), "hex"));
+    hash.update(patternId);
+    const digest = hash.digest();
+    const byte6 = digest[6];
+    const byte8 = digest[8];
+    if (byte6 !== undefined && byte8 !== undefined) {
+        digest[6] = (byte6 & 0x0f) | 0x50;
+        digest[8] = (byte8 & 0x3f) | 0x80;
+    }
+    const hex = digest.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+export class PatternIndexer {
+    qdrant = null;
+    openai = null;
+    googleAI = null;
+    collectionName = "shared_patterns";
+    googleFSConfigPath;
+    googleFSConfig = null;
+    qdrantAvailable = null;
+    static QDRANT_TIMEOUT_MS = 5000;
+    constructor() {
+        const qdrantUrl = process.env.QDRANT_URL || "http://localhost:6333";
+        try {
+            this.qdrant = new QdrantClient({
+                url: qdrantUrl,
+                apiKey: process.env.QDRANT_API_KEY,
+                timeout: PatternIndexer.QDRANT_TIMEOUT_MS,
+            });
+        }
+        catch (error) {
+            console.error(`[PatternIndexer] Failed to create Qdrant client: ${error}`);
+            this.qdrant = null;
+        }
+        const openaiApiKey = process.env.OPENAI_API_KEY;
+        if (openaiApiKey) {
+            this.openai = new OpenAI({ apiKey: openaiApiKey });
+        }
+        else {
+            console.error("[PatternIndexer] OPENAI_API_KEY not set - vector search disabled, using filesystem fallback");
+        }
+        const geminiApiKey = process.env.GEMINI_API_KEY;
+        if (geminiApiKey) {
+            this.googleAI = new GoogleGenAI({ apiKey: geminiApiKey });
+        }
+        this.googleFSConfigPath = join(homedir(), "Dev", ".shared-patterns", ".gemini-config.json");
+    }
+    async withQdrantCircuitBreaker(operation) {
+        const rateLimiter = ServiceRateLimiters.qdrant();
+        await rateLimiter.acquire(1);
+        const qdrantBreaker = ServiceCircuitBreakers.qdrant();
+        return qdrantBreaker.execute(operation);
+    }
+    async withOpenAICircuitBreaker(operation) {
+        const rateLimiter = ServiceRateLimiters.openaiEmbeddings();
+        await rateLimiter.acquire(1);
+        const openaiBreaker = ServiceCircuitBreakers.openai();
+        return openaiBreaker.execute(operation);
+    }
+    async isQdrantAvailable() {
+        if (this.qdrantAvailable !== null) {
+            return this.qdrantAvailable;
+        }
+        if (!this.qdrant) {
+            this.qdrantAvailable = false;
+            return false;
+        }
+        try {
+            const healthCheck = this.qdrant.getCollections();
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Qdrant connection timeout")), PatternIndexer.QDRANT_TIMEOUT_MS));
+            await Promise.race([healthCheck, timeout]);
+            this.qdrantAvailable = true;
+            console.error("[PatternIndexer] Qdrant connection verified");
+            return true;
+        }
+        catch (error) {
+            console.error(`[PatternIndexer] Qdrant unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            this.qdrantAvailable = false;
+            return false;
+        }
+    }
+    async loadGoogleFSConfig() {
+        if (this.googleFSConfig) {
+            return this.googleFSConfig;
+        }
+        try {
+            const content = await fs.readFile(this.googleFSConfigPath, "utf-8");
+            this.googleFSConfig = JSON.parse(content);
+            return this.googleFSConfig;
+        }
+        catch {
+            this.googleFSConfig = {
+                enabled: !!this.googleAI,
+                store_name: "shared-patterns-library",
+                stats: {
+                    total_files_indexed: 0,
+                    total_tokens_indexed: 0,
+                    total_cost_usd: 0,
+                },
+            };
+            return this.googleFSConfig;
+        }
+    }
+    async saveGoogleFSConfig() {
+        if (this.googleFSConfig) {
+            await fs.writeFile(this.googleFSConfigPath, JSON.stringify(this.googleFSConfig, null, 2));
+        }
+    }
+    async initializeQdrantCollection() {
+        const available = await this.isQdrantAvailable();
+        if (!available || !this.qdrant) {
+            console.error("[PatternIndexer] Skipping Qdrant initialization - service unavailable");
+            return false;
+        }
+        try {
+            const collections = await this.qdrant.getCollections();
+            const exists = collections.collections.some((c) => c.name === this.collectionName);
+            if (!exists) {
+                await this.qdrant.createCollection(this.collectionName, {
+                    vectors: {
+                        size: 1536,
+                        distance: "Cosine",
+                    },
+                });
+                await this.qdrant.createPayloadIndex(this.collectionName, {
+                    field_name: "category",
+                    field_schema: "keyword",
+                });
+                await this.qdrant.createPayloadIndex(this.collectionName, {
+                    field_name: "verified",
+                    field_schema: "bool",
+                });
+                await this.qdrant.createPayloadIndex(this.collectionName, {
+                    field_name: "usage_count",
+                    field_schema: "integer",
+                });
+                console.error("[PatternIndexer] Created Qdrant collection: shared_patterns");
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`[PatternIndexer] Failed to initialize Qdrant collection: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async generateEmbedding(text) {
+        if (!this.openai) {
+            return null;
+        }
+        const MODEL = "text-embedding-3-small";
+        return this.withOpenAICircuitBreaker(async () => {
+            return withExternalSpan("openai", {
+                operation: "embedding",
+                model: MODEL,
+            }, async (span) => {
+                const response = await this.openai.embeddings.create({
+                    model: MODEL,
+                    input: text,
+                });
+                const embedding = response.data[0]?.embedding;
+                if (!embedding) {
+                    throw new Error("Failed to generate embedding");
+                }
+                span.setAttribute("service.input_chars", text.length);
+                span.setAttribute("service.dimensions", embedding.length);
+                const inputTokens = Math.ceil(text.length / 4);
+                getCostTracker().recordCost({
+                    service: "openai",
+                    operation: "embedding",
+                    model: MODEL,
+                    inputTokens,
+                    outputTokens: 0,
+                    cached: false,
+                    duration: 0,
+                    module: "patterns",
+                });
+                return embedding;
+            });
+        });
+    }
+    async indexToQdrant(pattern, content) {
+        const available = await this.isQdrantAvailable();
+        if (!available || !this.qdrant || !this.openai) {
+            console.error(`[PatternIndexer] Skipping Qdrant indexing for ${pattern.id} - services unavailable`);
+            return false;
+        }
+        try {
+            const embeddingText = `${pattern.name}\n${pattern.description}\n${content}`;
+            const embedding = await this.generateEmbedding(embeddingText);
+            if (!embedding) {
+                console.error(`[PatternIndexer] Failed to generate embedding for ${pattern.id}`);
+                return false;
+            }
+            const qdrantId = patternIdToUuid(pattern.id);
+            await withExternalSpan("qdrant", {
+                operation: "upsert",
+                collection: this.collectionName,
+            }, async (span) => {
+                span.setAttribute("service.pattern_id", pattern.id);
+                span.setAttribute("service.pattern_category", pattern.category);
+                await this.qdrant.upsert(this.collectionName, {
+                    points: [
+                        {
+                            id: qdrantId,
+                            vector: embedding,
+                            payload: {
+                                pattern_id: pattern.id,
+                                name: pattern.name,
+                                category: pattern.category,
+                                quality: pattern.quality,
+                                usage_count: pattern.usageCount,
+                                last_used: pattern.lastUsed,
+                                created: pattern.created,
+                                tags: pattern.tags,
+                                description: pattern.description,
+                                file_path: pattern.filePath,
+                                verified: pattern.verified || false,
+                                version: pattern.version || "1.0.0",
+                                has_version_history: pattern.hasVersionHistory || false,
+                                deprecated_versions: pattern.deprecatedVersions || [],
+                            },
+                        },
+                    ],
+                });
+            });
+            return true;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to index pattern ${pattern.id} to Qdrant:`, errorMsg);
+            this.lastIndexError = errorMsg;
+            return false;
+        }
+    }
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async getOrCreateGoogleFSStore() {
+        if (!this.googleAI) {
+            throw new Error("Google AI not initialized - GEMINI_API_KEY not set");
+        }
+        const config = await this.loadGoogleFSConfig();
+        const storesResponse = await this.googleAI.fileSearchStores.list();
+        const stores = [];
+        for await (const store of storesResponse) {
+            stores.push(store);
+        }
+        let store = stores.find((s) => s.displayName === config.store_name);
+        if (!store) {
+            store = await this.googleAI.fileSearchStores.create({
+                config: { displayName: config.store_name },
+            });
+            config.store_id = store.name;
+            await this.saveGoogleFSConfig();
+        }
+        return store;
+    }
+    async indexToGoogleFS(pattern, content) {
+        if (!this.googleAI) {
+            return true;
+        }
+        try {
+            const config = await this.loadGoogleFSConfig();
+            if (!config.enabled) {
+                return true;
+            }
+            const store = await this.getOrCreateGoogleFSStore();
+            const truncate = (str, maxLen = 256) => str.length > maxLen ? str.substring(0, maxLen - 3) + "..." : str;
+            const customMetadata = [
+                { key: "pattern_id", stringValue: truncate(pattern.id) },
+                { key: "category", stringValue: truncate(pattern.category) },
+                { key: "quality", stringValue: String(pattern.quality || 0) },
+                { key: "verified", stringValue: String(pattern.verified || false) },
+            ];
+            if (pattern.tags && pattern.tags.length > 0) {
+                customMetadata.push({
+                    key: "tags",
+                    stringValue: truncate(pattern.tags.join(", ")),
+                });
+            }
+            const indexContent = `# ${pattern.name}
+
+**Category:** ${pattern.category}
+**Quality:** ${pattern.quality || "N/A"}/10
+**ID:** ${pattern.id}
+
+${content}`;
+            let op = await this.googleAI.fileSearchStores.uploadToFileSearchStore({
+                file: new Blob([indexContent], { type: "text/markdown" }),
+                fileSearchStoreName: store.name,
+                config: {
+                    displayName: `${pattern.id.replace("/", "-")}.md`,
+                    customMetadata,
+                    mimeType: "text/markdown",
+                },
+            });
+            while (!op.done) {
+                await this.delay(2000);
+                op = await this.googleAI.operations.get({ operation: op });
+            }
+            const tokens = Math.ceil(indexContent.length / 4);
+            const cost = (tokens / 1_000_000) * 0.15;
+            config.stats.total_files_indexed++;
+            config.stats.total_tokens_indexed += tokens;
+            config.stats.total_cost_usd += cost;
+            config.stats.last_indexed = new Date().toISOString();
+            await this.saveGoogleFSConfig();
+            getCostTracker().recordCost({
+                service: "google",
+                operation: "file-search",
+                model: "file-search",
+                inputTokens: tokens,
+                outputTokens: 0,
+                costUsd: cost,
+                cached: false,
+                duration: 0,
+                module: "patterns",
+            });
+            return true;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to index pattern ${pattern.id} to Google FS:`, errorMsg);
+            return false;
+        }
+    }
+    async indexPattern(pattern) {
+        const startTime = Date.now();
+        try {
+            const content = await fs.readFile(pattern.filePath, "utf-8");
+            const [qdrantResult, googleFsResult] = await Promise.all([
+                this.indexToQdrant(pattern, content),
+                this.indexToGoogleFS(pattern, content),
+            ]);
+            const duration = Date.now() - startTime;
+            return {
+                success: qdrantResult && googleFsResult,
+                qdrantIndexed: qdrantResult,
+                googleFsIndexed: googleFsResult,
+                duration,
+                error: !qdrantResult ? this.lastIndexError : undefined,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return {
+                success: false,
+                qdrantIndexed: false,
+                googleFsIndexed: false,
+                duration,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async searchFast(query, options) {
+        const available = await this.isQdrantAvailable();
+        if (!available || !this.qdrant || !this.openai) {
+            console.error("[PatternIndexer] Qdrant/OpenAI unavailable - using filesystem fallback");
+            return this.searchFilesystem(query, options);
+        }
+        try {
+            const embedding = await this.generateEmbedding(query);
+            if (!embedding) {
+                console.error("[PatternIndexer] Failed to generate embedding - using filesystem fallback");
+                return this.searchFilesystem(query, options);
+            }
+            const filter = {};
+            if (options?.category) {
+                filter.category = options.category;
+            }
+            if (options?.minQuality !== undefined) {
+                filter.quality = { $gte: options.minQuality };
+            }
+            if (options?.verifiedOnly) {
+                filter.verified = true;
+            }
+            const results = await withExternalSpan("qdrant", {
+                operation: "search",
+                collection: this.collectionName,
+            }, async (span) => {
+                const searchResults = await this.withQdrantCircuitBreaker(() => this.qdrant.search(this.collectionName, {
+                    vector: embedding,
+                    filter: Object.keys(filter).length > 0
+                        ? { must: [{ key: "payload", match: filter }] }
+                        : undefined,
+                    limit: options?.limit || 10,
+                }));
+                span.setAttribute("service.result_count", searchResults.length);
+                return searchResults;
+            });
+            return results.map((result) => ({
+                id: result.payload?.pattern_id || result.id,
+                name: result.payload?.name,
+                category: result.payload?.category,
+                quality: result.payload?.quality,
+                usageCount: result.payload?.usage_count,
+                lastUsed: result.payload?.last_used,
+                created: result.payload?.created,
+                tags: result.payload?.tags,
+                description: result.payload?.description,
+                filePath: result.payload?.file_path,
+                verified: result.payload?.verified,
+                version: result.payload?.version,
+                hasVersionHistory: result.payload?.has_version_history,
+                deprecatedVersions: result.payload?.deprecated_versions,
+            }));
+        }
+        catch (error) {
+            console.error("[PatternIndexer] Fast search failed, using filesystem fallback:", error);
+            return this.searchFilesystem(query, options);
+        }
+    }
+    async searchFilesystem(query, options) {
+        const patternsDir = join(homedir(), "Dev", ".shared-patterns", "patterns");
+        const results = [];
+        const limit = options?.limit || 10;
+        const queryLower = query.toLowerCase();
+        const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 2);
+        try {
+            const files = await fs.readdir(patternsDir);
+            for (const file of files) {
+                if (!file.endsWith(".md"))
+                    continue;
+                const match = file.match(/^([a-z-]+)-(\d{3})-(.+)\.md$/);
+                if (!match)
+                    continue;
+                const [, category, , namePart] = match;
+                if (options?.category && category !== options.category)
+                    continue;
+                const filePath = join(patternsDir, file);
+                let content = "";
+                try {
+                    content = await fs.readFile(filePath, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+                const contentLower = content.toLowerCase();
+                const filenameLower = file.toLowerCase();
+                let score = 0;
+                for (const word of queryWords) {
+                    if (contentLower.includes(word))
+                        score += 1;
+                    if (filenameLower.includes(word))
+                        score += 2;
+                }
+                if (score === 0)
+                    continue;
+                const descMatch = content.match(/^#[^\n]+\n+([^\n#]+)/);
+                const description = descMatch?.[1]?.trim().slice(0, 200) || "No description";
+                results.push({
+                    id: `${category}/${file.replace(".md", "")}`,
+                    name: namePart || file.replace(".md", ""),
+                    category: category || "unknown",
+                    quality: 0,
+                    usageCount: 0,
+                    created: new Date().toISOString(),
+                    tags: [],
+                    description,
+                    filePath,
+                    verified: false,
+                });
+                if (results.length >= limit)
+                    break;
+            }
+            return results.slice(0, limit);
+        }
+        catch (error) {
+            console.error("[PatternIndexer] Filesystem search failed:", error);
+            return [];
+        }
+    }
+    async searchComprehensive(query, options) {
+        if (!this.googleAI) {
+            console.error("Google AI not available - falling back to Qdrant search");
+            return this.searchFast(query, options);
+        }
+        try {
+            const config = await this.loadGoogleFSConfig();
+            if (!config.enabled || !config.store_id) {
+                return this.searchFast(query, options);
+            }
+            const filterParts = [];
+            if (options?.category) {
+                filterParts.push(`category: ${options.category}`);
+            }
+            if (options?.minQuality !== undefined) {
+                filterParts.push(`quality >= ${options.minQuality}`);
+            }
+            if (options?.verifiedOnly) {
+                filterParts.push(`verified: true`);
+            }
+            const enhancedQuery = filterParts.length > 0
+                ? `${query} (Filter: ${filterParts.join(", ")})`
+                : query;
+            const model = this.googleAI.models.generateContent({
+                model: "gemini-2.0-flash",
+                contents: enhancedQuery,
+                config: {
+                    tools: [
+                        {
+                            fileSearch: {
+                                fileSearchStoreNames: [config.store_id],
+                            },
+                        },
+                    ],
+                },
+            });
+            const response = await model;
+            const patternIds = [];
+            if (response.candidates && response.candidates[0]) {
+                const candidate = response.candidates[0];
+                if (candidate.groundingMetadata?.groundingChunks) {
+                    for (const chunk of candidate.groundingMetadata.groundingChunks) {
+                        if (chunk.retrievedContext?.uri) {
+                            const uri = chunk.retrievedContext.uri;
+                            const match = uri.match(/([^/]+)\.md$/);
+                            if (match && match[1]) {
+                                const patternId = match[1].replace("-", "/");
+                                if (!patternIds.includes(patternId)) {
+                                    patternIds.push(patternId);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const patterns = [];
+            const limit = options?.limit || 10;
+            for (const patternId of patternIds.slice(0, limit)) {
+                try {
+                    if (!this.qdrant)
+                        continue;
+                    const qdrantId = patternIdToUuid(patternId);
+                    const result = await this.qdrant.retrieve(this.collectionName, {
+                        ids: [qdrantId],
+                    });
+                    if (result.length > 0 && result[0]) {
+                        const p = result[0];
+                        patterns.push({
+                            id: p.payload?.pattern_id || patternId,
+                            name: p.payload?.name,
+                            category: p.payload?.category,
+                            quality: p.payload?.quality,
+                            usageCount: p.payload?.usage_count,
+                            lastUsed: p.payload?.last_used,
+                            created: p.payload?.created,
+                            tags: p.payload?.tags,
+                            description: p.payload?.description,
+                            filePath: p.payload?.file_path,
+                            verified: p.payload?.verified,
+                            version: p.payload?.version,
+                            hasVersionHistory: p.payload?.has_version_history,
+                            deprecatedVersions: p.payload?.deprecated_versions,
+                        });
+                    }
+                }
+                catch {
+                }
+            }
+            return patterns;
+        }
+        catch (error) {
+            console.error("Comprehensive search failed:", error);
+            return this.searchFast(query, options);
+        }
+    }
+    async trackUsage(patternId) {
+        await this.trackUsageWithOutcome(patternId);
+    }
+    async trackUsageWithOutcome(patternId, outcome, outcomeNotes) {
+        const defaultResult = {
+            justPromoted: false,
+            successCount: 0,
+            failureCount: 0,
+            successRate: 0,
+        };
+        const available = await this.isQdrantAvailable();
+        if (!available || !this.qdrant) {
+            console.error(`[PatternIndexer] Cannot track usage for ${patternId} - Qdrant unavailable`);
+            return defaultResult;
+        }
+        try {
+            const qdrantId = patternIdToUuid(patternId);
+            const result = await this.qdrant.retrieve(this.collectionName, {
+                ids: [qdrantId],
+            });
+            if (result.length === 0) {
+                throw new Error(`Pattern ${patternId} not found`);
+            }
+            const pattern = result[0];
+            if (!pattern || !pattern.payload) {
+                throw new Error(`Pattern ${patternId} has no payload`);
+            }
+            const currentUsageCount = pattern.payload.usage_count || 0;
+            const currentSuccessCount = pattern.payload.success_count || 0;
+            const currentFailureCount = pattern.payload.failure_count || 0;
+            const isPromoted = pattern.payload.promoted || false;
+            const isVerified = pattern.payload.verified || false;
+            const newUsageCount = currentUsageCount + 1;
+            let newSuccessCount = currentSuccessCount;
+            let newFailureCount = currentFailureCount;
+            if (outcome === "success") {
+                newSuccessCount++;
+            }
+            else if (outcome === "failure") {
+                newFailureCount++;
+            }
+            const totalOutcomes = newSuccessCount + newFailureCount;
+            const successRate = totalOutcomes > 0 ? newSuccessCount / totalOutcomes : 0;
+            const payloadUpdate = {
+                usage_count: newUsageCount,
+                last_used: new Date().toISOString(),
+                success_count: newSuccessCount,
+                failure_count: newFailureCount,
+                success_rate: successRate,
+            };
+            let justPromoted = false;
+            if (newUsageCount >= 2 && !isPromoted) {
+                payloadUpdate.promoted = true;
+                justPromoted = true;
+                console.error(`[PatternIndexer] Pattern ${patternId} promoted to PROMOTED (usage_count >= 2)`);
+            }
+            if (newUsageCount >= 3 && !isVerified) {
+                payloadUpdate.verified = true;
+                justPromoted = true;
+                console.error(`[PatternIndexer] Pattern ${patternId} promoted to VERIFIED (usage_count >= 3)`);
+            }
+            if (outcome) {
+                const outcomes = pattern.payload.outcomes || [];
+                outcomes.push({
+                    timestamp: new Date().toISOString(),
+                    result: outcome,
+                    notes: outcomeNotes,
+                });
+                payloadUpdate.outcomes = outcomes;
+            }
+            await this.qdrant.setPayload(this.collectionName, {
+                points: [qdrantId],
+                payload: payloadUpdate,
+            });
+            return {
+                justPromoted,
+                successCount: newSuccessCount,
+                failureCount: newFailureCount,
+                successRate,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to track usage for pattern ${patternId}:`, error);
+            return defaultResult;
+        }
+    }
+    async promotePattern(patternId) {
+        if (!this.qdrant) {
+            console.error(`[PatternIndexer] Cannot promote pattern ${patternId} - Qdrant unavailable`);
+            return;
+        }
+        try {
+            const qdrantId = patternIdToUuid(patternId);
+            await this.qdrant.setPayload(this.collectionName, {
+                points: [qdrantId],
+                payload: {
+                    verified: true,
+                },
+            });
+            console.error(`[PatternIndexer] Pattern ${patternId} promoted to VERIFIED (usage_count >= 3)`);
+        }
+        catch (error) {
+            console.error(`Failed to promote pattern ${patternId}:`, error);
+        }
+    }
+    async getStats() {
+        const available = await this.isQdrantAvailable();
+        if (!available || !this.qdrant) {
+            console.error("[PatternIndexer] Cannot get stats - Qdrant unavailable");
+            return {
+                totalPatterns: 0,
+                verifiedPatterns: 0,
+                categoryCounts: {},
+                averageQuality: 0,
+            };
+        }
+        try {
+            const scroll = await this.qdrant.scroll(this.collectionName, {
+                limit: 1000,
+            });
+            const patterns = scroll.points;
+            const totalPatterns = patterns.length;
+            const verifiedPatterns = patterns.filter((p) => p.payload?.verified).length;
+            const categoryCounts = {};
+            let qualitySum = 0;
+            for (const pattern of patterns) {
+                const category = pattern.payload?.category;
+                categoryCounts[category] = (categoryCounts[category] || 0) + 1;
+                qualitySum += pattern.payload?.quality || 0;
+            }
+            return {
+                totalPatterns,
+                verifiedPatterns,
+                categoryCounts,
+                averageQuality: totalPatterns > 0 ? qualitySum / totalPatterns : 0,
+            };
+        }
+        catch (error) {
+            console.error("Failed to get stats:", error);
+            return {
+                totalPatterns: 0,
+                verifiedPatterns: 0,
+                categoryCounts: {},
+                averageQuality: 0,
+            };
+        }
+    }
+}
+//# sourceMappingURL=PatternIndexer.js.map