cozo-memory 1.1.4 → 1.1.6

package/dist/temporal-pattern-detection.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemporalPatternDetectionService = exports.PatternType = void 0;
+const uuid_1 = require("uuid");
+var PatternType;
+(function (PatternType) {
+    PatternType["RECURRING_EVENT"] = "recurring_event";
+    PatternType["CYCLICAL_RELATIONSHIP"] = "cyclical_relationship";
+    PatternType["TEMPORAL_CORRELATION"] = "temporal_correlation";
+    PatternType["SEASONAL_TREND"] = "seasonal_trend";
+    PatternType["ANOMALY"] = "anomaly";
+})(PatternType || (exports.PatternType = PatternType = {}));
+class TemporalPatternDetectionService {
+    db;
+    embeddings;
+    config;
+    constructor(db, embeddings, config = {}) {
+        this.db = db;
+        this.embeddings = embeddings;
+        this.config = {
+            min_occurrences: config.min_occurrences ?? 3,
+            min_confidence: config.min_confidence ?? 0.6,
+            time_window_days: config.time_window_days ?? 365,
+            similarity_threshold: config.similarity_threshold ?? 0.75,
+            seasonal_buckets: config.seasonal_buckets ?? 12
+        };
+    }
+    async detectPatterns(entityId) {
+        const patterns = [];
+        // Get entity name (without time travel since test doesn't use Validity)
+        let entityName = 'Unknown';
+        try {
+            const entityResult = await this.db.run(`
+        ?[name] := *entity{id, name, @ "NOW"}, id = $entity_id
+      `, { entity_id: entityId });
+            entityName = entityResult.rows.length > 0 ? entityResult.rows[0][0] : 'Unknown';
+        }
+        catch (error) {
+            // Fallback if Validity is not used
+            const entityResult = await this.db.run(`
+        ?[name] := *entity{id, name}, id = $entity_id
+      `, { entity_id: entityId });
+            entityName = entityResult.rows.length > 0 ? entityResult.rows[0][0] : 'Unknown';
+        }
+        // 1. Detect recurring events
+        const recurringPatterns = await this.detectRecurringEvents(entityId, entityName);
+        patterns.push(...recurringPatterns);
+        // 2. Detect cyclical relationships
+        const cyclicalPatterns = await this.detectCyclicalRelationships(entityId, entityName);
+        patterns.push(...cyclicalPatterns);
+        // 3. Detect temporal correlations
+        const correlationPatterns = await this.detectTemporalCorrelations(entityId, entityName);
+        patterns.push(...correlationPatterns);
+        // 4. Detect seasonal trends
+        const seasonalPatterns = await this.detectSeasonalTrends(entityId, entityName);
+        patterns.push(...seasonalPatterns);
+        return patterns;
+    }
+    async detectRecurringEvents(entityId, entityName) {
+        const patterns = [];
+        const timeWindowMicros = this.config.time_window_days * 24 * 60 * 60 * 1000 * 1000;
+        const nowMicros = Date.now() * 1000;
+        const startTime = nowMicros - timeWindowMicros;
+        // Get all observations for this entity within time window
+        const obsResult = await this.db.run(`
+      ?[id, text, embedding, created_at] := 
+        *observation{id, entity_id, text, embedding, created_at},
+        entity_id = $entity_id,
+        to_int(created_at) >= $start_time
+    `, { entity_id: entityId, start_time: startTime });
+        if (obsResult.rows.length < this.config.min_occurrences) {
+            return patterns;
+        }
+        // Group similar observations using embeddings
+        const observations = obsResult.rows.map((row) => {
+            const createdAt = row[3];
+            const timestamp = Array.isArray(createdAt) ? createdAt[0] : createdAt;
+            return {
+                id: row[0],
+                text: row[1],
+                embedding: row[2],
+                timestamp
+            };
+        });
+        // Cluster similar observations
+        const clusters = this.clusterObservations(observations);
+        // Analyze each cluster for recurring patterns
+        for (const cluster of clusters) {
+            if (cluster.length < this.config.min_occurrences)
+                continue;
+            // Sort by timestamp
+            cluster.sort((a, b) => a.timestamp - b.timestamp);
+            // Calculate intervals between occurrences
+            const intervals = [];
+            for (let i = 1; i < cluster.length; i++) {
+                const intervalMs = (cluster[i].timestamp - cluster[i - 1].timestamp) / 1000;
+                const intervalDays = intervalMs / (24 * 60 * 60 * 1000);
+                intervals.push(intervalDays);
+            }
+            // Check if intervals are relatively consistent (recurring pattern)
+            const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+            const variance = intervals.reduce((sum, interval) => sum + Math.pow(interval - avgInterval, 2), 0) / intervals.length;
+            const stdDev = Math.sqrt(variance);
+            const coefficientOfVariation = stdDev / avgInterval;
+            // If coefficient of variation is low, it's a recurring pattern
+            if (coefficientOfVariation < 0.3) {
+                const confidence = Math.max(0, 1 - coefficientOfVariation);
+                if (confidence >= this.config.min_confidence) {
+                    patterns.push({
+                        id: (0, uuid_1.v4)(),
+                        pattern_type: PatternType.RECURRING_EVENT,
+                        entity_id: entityId,
+                        entity_name: entityName,
+                        description: `Recurring event: "${cluster[0].text}" occurs approximately every ${avgInterval.toFixed(0)} days`,
+                        frequency: cluster.length,
+                        confidence,
+                        first_occurrence: cluster[0].timestamp,
+                        last_occurrence: cluster[cluster.length - 1].timestamp,
+                        interval_days: avgInterval,
+                        occurrences: cluster.map(obs => ({
+                            timestamp: obs.timestamp,
+                            observation_id: obs.id,
+                            text: obs.text
+                        })),
+                        metadata: {
+                            avg_interval_days: avgInterval,
+                            std_dev_days: stdDev,
+                            coefficient_of_variation: coefficientOfVariation
+                        }
+                    });
+                }
+            }
+        }
+        return patterns;
+    }
+    async detectCyclicalRelationships(entityId, entityName) {
+        const patterns = [];
+        // Find cycles in the relationship graph starting from this entity
+        // A cycle is: A -> B -> ... -> A
+        const cycleResult = await this.db.run(`
+      cycle[from_id, to_id, path] := 
+        *relationship{from_id, to_id},
+        from_id = $entity_id,
+        path = [from_id, to_id]
+      
+      cycle[from_id, to_id, path] :=
+        cycle[from_id, mid, prev_path],
+        *relationship{from_id: mid, to_id},
+        to_id != from_id,
+        !is_in(to_id, prev_path),
+        length(prev_path) < 10,
+        path = append(prev_path, to_id)
+      
+      ?[from_id, to_id, path] :=
+        cycle[from_id, to_id, path],
+        to_id = $entity_id,
+        length(path) >= 3
+    `, { entity_id: entityId });
+        for (const row of cycleResult.rows) {
+            const path = row[2];
+            const cycleLength = path.length;
+            // Get relationship types in the cycle
+            const relationTypes = [];
+            for (let i = 0; i < path.length - 1; i++) {
+                const relResult = await this.db.run(`
+          ?[relation_type] := 
+            *relationship{from_id, to_id, relation_type},
+            from_id = $from_id,
+            to_id = $to_id
+        `, { from_id: path[i], to_id: path[i + 1] });
+                if (relResult.rows.length > 0) {
+                    relationTypes.push(relResult.rows[0][0]);
+                }
+            }
+            // Add closing relationship
+            const closingRelResult = await this.db.run(`
+        ?[relation_type] := 
+          *relationship{from_id, to_id, relation_type},
+          from_id = $from_id,
+          to_id = $to_id
+      `, { from_id: path[path.length - 1], to_id: path[0] });
+            if (closingRelResult.rows.length > 0) {
+                relationTypes.push(closingRelResult.rows[0][0]);
+            }
+            const confidence = Math.min(1.0, 0.7 + (0.1 * cycleLength));
+            if (confidence >= this.config.min_confidence) {
+                patterns.push({
+                    id: (0, uuid_1.v4)(),
+                    pattern_type: PatternType.CYCLICAL_RELATIONSHIP,
+                    entity_id: entityId,
+                    entity_name: entityName,
+                    description: `Cyclical relationship detected: ${relationTypes.join(' → ')}`,
+                    frequency: 1,
+                    confidence,
+                    first_occurrence: Date.now() * 1000,
+                    last_occurrence: Date.now() * 1000,
+                    occurrences: [],
+                    metadata: {
+                        cycle_path: path,
+                        cycle_length: cycleLength,
+                        relation_types: relationTypes
+                    }
+                });
+            }
+        }
+        return patterns;
+    }
+    async detectTemporalCorrelations(entityId, entityName) {
+        const patterns = [];
+        const timeWindowMicros = this.config.time_window_days * 24 * 60 * 60 * 1000 * 1000;
+        const nowMicros = Date.now() * 1000;
+        const startTime = nowMicros - timeWindowMicros;
+        // Get all observations
+        const obsResult = await this.db.run(`
+      ?[id, text, embedding, created_at] := 
+        *observation{id, entity_id, text, embedding, created_at},
+        entity_id = $entity_id,
+        to_int(created_at) >= $start_time
+    `, { entity_id: entityId, start_time: startTime });
+        if (obsResult.rows.length < this.config.min_occurrences * 2) {
+            return patterns;
+        }
+        const observations = obsResult.rows.map((row) => {
+            const createdAt = row[3];
+            const timestamp = Array.isArray(createdAt) ? createdAt[0] : createdAt;
+            return {
+                id: row[0],
+                text: row[1],
+                embedding: row[2],
+                timestamp
+            };
+        });
+        // Find pairs of different observation types that occur close together
+        const correlationWindow = 2 * 24 * 60 * 60 * 1000 * 1000; // 2 days in microseconds
+        const correlations = new Map();
+        for (let i = 0; i < observations.length; i++) {
+            for (let j = i + 1; j < observations.length; j++) {
+                const timeDiff = Math.abs(observations[j].timestamp - observations[i].timestamp);
+                if (timeDiff <= correlationWindow) {
+                    const similarity = this.cosineSimilarity(observations[i].embedding, observations[j].embedding);
+                    // Only correlate different types of events (low similarity)
+                    if (similarity < 0.5) {
+                        const key = [observations[i].text, observations[j].text].sort().join('|||');
+                        if (!correlations.has(key)) {
+                            correlations.set(key, []);
+                        }
+                        correlations.get(key).push({
+                            obs1: observations[i],
+                            obs2: observations[j]
+                        });
+                    }
+                }
+            }
+        }
+        // Analyze correlations
+        for (const [key, pairs] of correlations.entries()) {
+            if (pairs.length >= this.config.min_occurrences) {
+                const [text1, text2] = key.split('|||');
+                const confidence = Math.min(1.0, pairs.length / (this.config.min_occurrences * 2));
+                if (confidence >= this.config.min_confidence) {
+                    patterns.push({
+                        id: (0, uuid_1.v4)(),
+                        pattern_type: PatternType.TEMPORAL_CORRELATION,
+                        entity_id: entityId,
+                        entity_name: entityName,
+                        description: `Temporal correlation: "${text1}" often occurs near "${text2}"`,
+                        frequency: pairs.length,
+                        confidence,
+                        first_occurrence: Math.min(...pairs.map(p => Math.min(p.obs1.timestamp, p.obs2.timestamp))),
+                        last_occurrence: Math.max(...pairs.map(p => Math.max(p.obs1.timestamp, p.obs2.timestamp))),
+                        occurrences: pairs.flatMap(p => [
+                            { timestamp: p.obs1.timestamp, observation_id: p.obs1.id, text: p.obs1.text },
+                            { timestamp: p.obs2.timestamp, observation_id: p.obs2.id, text: p.obs2.text }
+                        ]),
+                        metadata: {
+                            event_pair: [text1, text2],
+                            correlation_window_days: correlationWindow / (24 * 60 * 60 * 1000 * 1000)
+                        }
+                    });
+                }
+            }
+        }
+        return patterns;
+    }
+    async detectSeasonalTrends(entityId, entityName) {
+        const patterns = [];
+        const timeWindowMicros = this.config.time_window_days * 24 * 60 * 60 * 1000 * 1000;
+        const nowMicros = Date.now() * 1000;
+        const startTime = nowMicros - timeWindowMicros;
+        // Get all observations
+        const obsResult = await this.db.run(`
+      ?[id, text, created_at] := 
+        *observation{id, entity_id, text, created_at},
+        entity_id = $entity_id,
+        to_int(created_at) >= $start_time
+    `, { entity_id: entityId, start_time: startTime });
+        if (obsResult.rows.length < this.config.min_occurrences) {
+            return patterns;
+        }
+        // Group observations by seasonal bucket (month or quarter)
+        const buckets = new Map();
+        for (const row of obsResult.rows) {
+            const createdAt = row[2];
+            // Handle both Validity tuple [timestamp, valid] and plain timestamp
+            const timestamp = Array.isArray(createdAt) ? createdAt[0] : createdAt;
+            const date = new Date(timestamp / 1000); // Convert microseconds to milliseconds
+            const bucket = date.getMonth(); // 0-11 for monthly buckets
+            if (!buckets.has(bucket)) {
+                buckets.set(bucket, []);
+            }
+            buckets.get(bucket).push({
+                id: row[0],
+                text: row[1],
+                timestamp
+            });
+        }
+        // Calculate average activity per bucket
+        const avgActivity = obsResult.rows.length / this.config.seasonal_buckets;
+        // Find buckets with significantly higher activity
+        for (const [bucket, observations] of buckets.entries()) {
+            const activityRatio = observations.length / avgActivity;
+            // If activity is 2x or more than average, it's a seasonal trend
+            if (activityRatio >= 2.0 && observations.length >= this.config.min_occurrences) {
+                const confidence = Math.min(1.0, activityRatio / 3);
+                if (confidence >= this.config.min_confidence) {
+                    const monthName = new Date(2024, bucket, 1).toLocaleString('default', { month: 'long' });
+                    patterns.push({
+                        id: (0, uuid_1.v4)(),
+                        pattern_type: PatternType.SEASONAL_TREND,
+                        entity_id: entityId,
+                        entity_name: entityName,
+                        description: `Seasonal trend: Increased activity in ${monthName} (${activityRatio.toFixed(1)}x average)`,
+                        frequency: observations.length,
+                        confidence,
+                        first_occurrence: Math.min(...observations.map(o => o.timestamp)),
+                        last_occurrence: Math.max(...observations.map(o => o.timestamp)),
+                        occurrences: observations.map(obs => ({
+                            timestamp: obs.timestamp,
+                            observation_id: obs.id,
+                            text: obs.text
+                        })),
+                        metadata: {
+                            seasonal_bucket: bucket,
+                            bucket_name: monthName,
+                            activity_ratio: activityRatio,
+                            avg_activity: avgActivity
+                        }
+                    });
+                }
+            }
+        }
+        return patterns;
+    }
+    clusterObservations(observations) {
+        const clusters = [];
+        const used = new Set();
+        for (let i = 0; i < observations.length; i++) {
+            if (used.has(i))
+                continue;
+            const cluster = [observations[i]];
+            used.add(i);
+            for (let j = i + 1; j < observations.length; j++) {
+                if (used.has(j))
+                    continue;
+                const similarity = this.cosineSimilarity(observations[i].embedding, observations[j].embedding);
+                if (similarity >= this.config.similarity_threshold) {
+                    cluster.push(observations[j]);
+                    used.add(j);
+                }
+            }
+            clusters.push(cluster);
+        }
+        return clusters;
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    async storePattern(pattern) {
+        // Create temporal_pattern relation if it doesn't exist (only once)
+        try {
+            await this.db.run(`
+        :create temporal_pattern {
+          id: String =>
+          pattern_type: String,
+          entity_id: String,
+          entity_name: String,
+          description: String,
+          frequency: Int,
+          confidence: Float,
+          first_occurrence: Int,
+          last_occurrence: Int,
+          interval_days: Float?,
+          metadata: Json
+        }
+      `);
+        }
+        catch (error) {
+            // Relation already exists, that's fine - continue with insert
+            if (!error.display?.includes('already exists') && !error.display?.includes('conflicts with an existing')) {
+                throw error;
+            }
+        }
+        await this.db.run(`
+      ?[id, pattern_type, entity_id, entity_name, description, frequency, confidence, first_occurrence, last_occurrence, interval_days, metadata] :=
+        id = $id,
+        pattern_type = $pattern_type,
+        entity_id = $entity_id,
+        entity_name = $entity_name,
+        description = $description,
+        frequency = $frequency,
+        confidence = $confidence,
+        first_occurrence = $first_occurrence,
+        last_occurrence = $last_occurrence,
+        interval_days = $interval_days,
+        metadata = $metadata
+      
+      :put temporal_pattern {
+        id => pattern_type, entity_id, entity_name, description, frequency, confidence, first_occurrence, last_occurrence, interval_days, metadata
+      }
+    `, {
+            id: pattern.id,
+            pattern_type: pattern.pattern_type,
+            entity_id: pattern.entity_id,
+            entity_name: pattern.entity_name,
+            description: pattern.description,
+            frequency: pattern.frequency,
+            confidence: pattern.confidence,
+            first_occurrence: pattern.first_occurrence,
+            last_occurrence: pattern.last_occurrence,
+            interval_days: pattern.interval_days ?? null,
+            metadata: pattern.metadata ?? {}
+        });
+    }
+    async getStoredPatterns(entityId, patternType) {
+        let query = `
+      ?[id, pattern_type, entity_id, entity_name, description, frequency, confidence, first_occurrence, last_occurrence, interval_days, metadata] :=
+        *temporal_pattern{id, pattern_type, entity_id, entity_name, description, frequency, confidence, first_occurrence, last_occurrence, interval_days, metadata}
+    `;
+        const params = {};
+        if (entityId) {
+            query += `, entity_id = $entity_id`;
+            params.entity_id = entityId;
+        }
+        if (patternType) {
+            query += `, pattern_type = $pattern_type`;
+            params.pattern_type = patternType;
+        }
+        const result = await this.db.run(query, params);
+        return result.rows.map((row) => ({
+            id: row[0],
+            pattern_type: row[1],
+            entity_id: row[2],
+            entity_name: row[3],
+            description: row[4],
+            frequency: row[5],
+            confidence: row[6],
+            first_occurrence: row[7],
+            last_occurrence: row[8],
+            interval_days: row[9],
+            occurrences: [],
+            metadata: row[10]
+        }));
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.TemporalPatternDetectionService = TemporalPatternDetectionService;

package/dist/test-adaptive-query-fusion.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Test: Adaptive Query Fusion with Dynamic Weights
+ *
+ * Tests query classification and adaptive weight selection
+ */
+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 });
+const cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const adaptive_query_fusion_1 = require("./adaptive-query-fusion");
+const fs = __importStar(require("fs"));
+const DB_PATH = 'test-adaptive-fusion.db';
+async function testAdaptiveQueryFusion() {
+    // Clean up old database
+    if (fs.existsSync(DB_PATH)) {
+        try {
+            fs.unlinkSync(DB_PATH);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb('sqlite', DB_PATH);
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    try {
+        console.log('=== Adaptive Query Fusion Tests ===\n');
+        const fusion = new adaptive_query_fusion_1.AdaptiveQueryFusion(db, embeddingService, {
+            enableLLM: false, // Disable LLM for testing (no Ollama required)
+            cacheClassifications: true,
+            maxCacheSize: 100
+        });
+        // Test cases with expected classifications
+        const testQueries = [
+            // FINDER queries (factual information seeking)
+            {
+                query: 'What is the capital of France?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.FINDER,
+                description: 'Simple factual question'
+            },
+            {
+                query: 'When was the first iPhone released?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.FINDER,
+                description: 'Factual query with temporal aspect'
+            },
+            {
+                query: 'Find me the latest news about AI developments',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.FINDER,
+                description: 'Information seeking with recency'
+            },
+            // EVALUATOR queries (comparison/evaluation)
+            {
+                query: 'Compare TypeScript vs JavaScript',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EVALUATOR,
+                description: 'Direct comparison'
+            },
+            {
+                query: 'What are the pros and cons of microservices?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EVALUATOR,
+                description: 'Evaluation query'
+            },
+            {
+                query: 'Which database is better for my use case?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EVALUATOR,
+                description: 'Comparative evaluation'
+            },
+            // EXPLAINER queries (concept understanding)
+            {
+                query: 'How does machine learning work?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EXPLAINER,
+                description: 'Concept explanation'
+            },
+            {
+                query: 'Explain the concept of blockchain',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EXPLAINER,
+                description: 'Direct explanation request'
+            },
+            {
+                query: 'Why is caching important in web development?',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.EXPLAINER,
+                description: 'Why question (explanation)'
+            },
+            // GENERATOR queries (content creation)
+            {
+                query: 'Write a Python function to calculate fibonacci',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.GENERATOR,
+                description: 'Code generation'
+            },
+            {
+                query: 'Create a marketing strategy for a startup',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.GENERATOR,
+                description: 'Content generation'
+            },
+            {
+                query: 'Suggest a project structure for a Node.js app',
+                expectedIntent: adaptive_query_fusion_1.QueryIntent.GENERATOR,
+                description: 'Suggestion/recommendation'
+            }
+        ];
+        console.log('--- Test 1: Query Classification ---\n');
+        for (const testCase of testQueries) {
+            const classification = await fusion.classifyQuery(testCase.query);
+            const match = classification.intent === testCase.expectedIntent ? '✓' : '✗';
+            console.log(`${match} "${testCase.query}"`);
+            console.log(`  Description: ${testCase.description}`);
+            console.log(`  Intent: ${classification.intent} (expected: ${testCase.expectedIntent})`);
+            console.log(`  Complexity: ${classification.complexity}`);
+            console.log(`  Confidence: ${(classification.confidence * 100).toFixed(0)}%`);
+            console.log(`  Method: ${classification.method}`);
+            console.log();
+        }
+        console.log('--- Test 2: Adaptive Weights ---\n');
+        const weightTestQueries = [
+            'What is TypeScript?', // FINDER + SIMPLE
+            'Compare React vs Vue', // EVALUATOR + MODERATE
+            'Explain how async/await works', // EXPLAINER + MODERATE
+            'Create a REST API' // GENERATOR + MODERATE
+        ];
+        for (const query of weightTestQueries) {
+            const weights = await fusion.getAdaptiveWeights(query);
+            const classification = await fusion.getClassificationDetails(query);
+            console.log(`Query: "${query}"`);
+            console.log(`Intent: ${classification.intent}, Complexity: ${classification.complexity}`);
+            console.log(`Weights:`);
+            console.log(`  Vector: ${(weights.vector * 100).toFixed(0)}%`);
+            console.log(`  Sparse: ${(weights.sparse * 100).toFixed(0)}%`);
+            console.log(`  FTS:    ${(weights.fts * 100).toFixed(0)}%`);
+            console.log(`  Graph:  ${(weights.graph * 100).toFixed(0)}%`);
+            console.log();
+        }
+        console.log('--- Test 3: Caching ---\n');
+        const cacheTestQuery = 'What is the meaning of life?';
+        // First call (not cached)
+        console.log(`First call: "${cacheTestQuery}"`);
+        const start1 = Date.now();
+        const result1 = await fusion.classifyQuery(cacheTestQuery);
+        const time1 = Date.now() - start1;
+        console.log(`Time: ${time1}ms`);
+        // Second call (cached)
+        console.log(`\nSecond call (should be cached): "${cacheTestQuery}"`);
+        const start2 = Date.now();
+        const result2 = await fusion.classifyQuery(cacheTestQuery);
+        const time2 = Date.now() - start2;
+        console.log(`Time: ${time2}ms`);
+        console.log(`Speedup: ${(time1 / time2).toFixed(1)}x faster`);
+        const cacheStats = fusion.getCacheStats();
+        console.log(`\nCache stats: ${cacheStats.size}/${cacheStats.maxSize} entries`);
+        console.log('\n--- Test 4: Complexity Classification ---\n');
+        const complexityTests = [
+            { query: 'What is AI?', expected: adaptive_query_fusion_1.QueryComplexity.SIMPLE },
+            { query: 'How does machine learning relate to AI?', expected: adaptive_query_fusion_1.QueryComplexity.MODERATE },
+            { query: 'Explain the relationship between neural networks, deep learning, and AI, and how they impact modern software development', expected: adaptive_query_fusion_1.QueryComplexity.COMPLEX },
+            { query: 'Tell me everything about cloud computing', expected: adaptive_query_fusion_1.QueryComplexity.EXPLORATORY }
+        ];
+        for (const test of complexityTests) {
+            const classification = await fusion.classifyQuery(test.query);
+            const match = classification.complexity === test.expected ? '✓' : '✗';
+            console.log(`${match} "${test.query}"`);
+            console.log(`  Complexity: ${classification.complexity} (expected: ${test.expected})`);
+            console.log();
+        }
+        console.log('=== All Tests Completed ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+    }
+    finally {
+        await db.close();
+        // Clean up
+        if (fs.existsSync(DB_PATH)) {
+            try {
+                fs.unlinkSync(DB_PATH);
+            }
+            catch (e) { }
+        }
+    }
+}
+testAdaptiveQueryFusion();