@danielsimonjr/memory-mcp 9.8.3 → 9.9.0

package/dist/search/HybridSearchManager.js

@@ -0,0 +1,187 @@
+/**
+ * Hybrid Search Manager
+ *
+ * Phase 11: Orchestrates three-layer hybrid search combining
+ * semantic, lexical, and symbolic signals.
+ *
+ * @module search/HybridSearchManager
+ */
+import { SymbolicSearch } from './SymbolicSearch.js';
+import { SEMANTIC_SEARCH_LIMITS } from '../utils/constants.js';
+/**
+ * Default weights for hybrid search layers.
+ */
+export const DEFAULT_HYBRID_WEIGHTS = {
+    semantic: 0.5,
+    lexical: 0.3,
+    symbolic: 0.2,
+};
+/**
+ * Hybrid Search Manager
+ *
+ * Combines three search layers:
+ * 1. Semantic: Vector similarity via embeddings
+ * 2. Lexical: Keyword matching via TF-IDF/BM25
+ * 3. Symbolic: Structured metadata filtering
+ *
+ * @example
+ * ```typescript
+ * const hybrid = new HybridSearchManager(semanticSearch, rankedSearch);
+ * const results = await hybrid.search(graph, 'machine learning', {
+ *   semanticWeight: 0.5,
+ *   lexicalWeight: 0.3,
+ *   symbolicWeight: 0.2,
+ *   symbolic: { tags: ['ai'] }
+ * });
+ * ```
+ */
+export class HybridSearchManager {
+    semanticSearch;
+    rankedSearch;
+    symbolicSearch;
+    constructor(semanticSearch, rankedSearch) {
+        this.semanticSearch = semanticSearch;
+        this.rankedSearch = rankedSearch;
+        this.symbolicSearch = new SymbolicSearch();
+    }
+    /**
+     * Perform hybrid search combining all three layers.
+     *
+     * @param graph - Knowledge graph to search
+     * @param query - Search query text
+     * @param options - Hybrid search options with weights
+     * @returns Combined and ranked results
+     */
+    async search(graph, query, options = {}) {
+        const { semanticWeight = DEFAULT_HYBRID_WEIGHTS.semantic, lexicalWeight = DEFAULT_HYBRID_WEIGHTS.lexical, symbolicWeight = DEFAULT_HYBRID_WEIGHTS.symbolic, semantic = {}, lexical = {}, symbolic = {}, limit = SEMANTIC_SEARCH_LIMITS.DEFAULT_LIMIT, } = options;
+        // Normalize weights
+        const totalWeight = semanticWeight + lexicalWeight + symbolicWeight;
+        const normSemantic = semanticWeight / totalWeight;
+        const normLexical = lexicalWeight / totalWeight;
+        const normSymbolic = symbolicWeight / totalWeight;
+        // Execute searches in parallel
+        const [semanticResults, lexicalResults, symbolicResults] = await Promise.all([
+            this.executeSemanticSearch(graph, query, semantic, limit * 2),
+            this.executeLexicalSearch(query, lexical, limit * 2),
+            this.executeSymbolicSearch(graph.entities, symbolic),
+        ]);
+        // Merge results
+        const merged = this.mergeResults(graph.entities, semanticResults, lexicalResults, symbolicResults, { semantic: normSemantic, lexical: normLexical, symbolic: normSymbolic });
+        // Sort by combined score and limit
+        return merged
+            .sort((a, b) => b.scores.combined - a.scores.combined)
+            .slice(0, limit);
+    }
+    /**
+     * Execute semantic search layer.
+     */
+    async executeSemanticSearch(graph, query, options, limit) {
+        const results = new Map();
+        if (!this.semanticSearch) {
+            return results; // Semantic search not available
+        }
+        try {
+            const semanticResults = await this.semanticSearch.search(graph, query, options.topK ?? limit, options.minSimilarity ?? 0);
+            for (const result of semanticResults) {
+                results.set(result.entity.name, result.similarity);
+            }
+        }
+        catch {
+            // Semantic search may fail if not indexed
+        }
+        return results;
+    }
+    /**
+     * Execute lexical search layer (TF-IDF/BM25).
+     */
+    async executeLexicalSearch(query, _options, limit) {
+        const results = new Map();
+        try {
+            const lexicalResults = await this.rankedSearch.searchNodesRanked(query, undefined, // tags
+            undefined, // minImportance
+            undefined, // maxImportance
+            limit);
+            // Normalize scores to 0-1 range
+            const maxScore = Math.max(...lexicalResults.map(r => r.score), 1);
+            for (const result of lexicalResults) {
+                results.set(result.entity.name, result.score / maxScore);
+            }
+        }
+        catch {
+            // Lexical search may fail
+        }
+        return results;
+    }
+    /**
+     * Execute symbolic search layer.
+     */
+    executeSymbolicSearch(entities, filters) {
+        const results = new Map();
+        if (!filters || Object.keys(filters).length === 0) {
+            // No symbolic filters, give all entities base score
+            for (const entity of entities) {
+                results.set(entity.name, 0.5);
+            }
+            return results;
+        }
+        const symbolicResults = this.symbolicSearch.search(entities, filters);
+        for (const result of symbolicResults) {
+            results.set(result.entity.name, result.score);
+        }
+        return results;
+    }
+    /**
+     * Merge results from all three layers.
+     */
+    mergeResults(entities, semanticScores, lexicalScores, symbolicScores, weights) {
+        // Collect all unique entity names that have at least one non-zero score
+        const allNames = new Set([
+            ...semanticScores.keys(),
+            ...lexicalScores.keys(),
+            ...symbolicScores.keys(),
+        ]);
+        // Create entity lookup map
+        const entityMap = new Map(entities.map(e => [e.name, e]));
+        const results = [];
+        for (const name of allNames) {
+            const entity = entityMap.get(name);
+            if (!entity)
+                continue;
+            const semantic = semanticScores.get(name) ?? 0;
+            const lexical = lexicalScores.get(name) ?? 0;
+            const symbolic = symbolicScores.get(name) ?? 0;
+            const combined = semantic * weights.semantic +
+                lexical * weights.lexical +
+                symbolic * weights.symbolic;
+            const matchedLayers = [];
+            if (semantic > 0)
+                matchedLayers.push('semantic');
+            if (lexical > 0)
+                matchedLayers.push('lexical');
+            if (symbolic > 0)
+                matchedLayers.push('symbolic');
+            // Skip if no layers matched meaningfully
+            if (matchedLayers.length === 0)
+                continue;
+            results.push({
+                entity,
+                scores: { semantic, lexical, symbolic, combined },
+                matchedLayers,
+            });
+        }
+        return results;
+    }
+    /**
+     * Search with full entity resolution.
+     * Alias for search() since we now always resolve entities.
+     */
+    async searchWithEntities(graph, query, options = {}) {
+        return this.search(graph, query, options);
+    }
+    /**
+     * Get the symbolic search instance for direct access.
+     */
+    getSymbolicSearch() {
+        return this.symbolicSearch;
+    }
+}

package/dist/search/QueryAnalyzer.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Query Analyzer
+ *
+ * Phase 11: Extracts structured information from natural language queries
+ * to enable intelligent search planning.
+ *
+ * @module search/QueryAnalyzer
+ */
+import type { QueryAnalysis } from '../types/index.js';
+/**
+ * Query Analyzer extracts structured information from queries.
+ *
+ * Uses rule-based heuristics for reliable extraction of:
+ * - Person names
+ * - Location names
+ * - Organization names
+ * - Temporal references
+ * - Question type
+ * - Query complexity
+ *
+ * @example
+ * ```typescript
+ * const analyzer = new QueryAnalyzer();
+ * const analysis = analyzer.analyze(
+ *   'What projects did Alice work on last month?'
+ * );
+ * // { query: '...', entities: [...], persons: ['Alice'], temporalRange: { relative: 'last month' }, ... }
+ * ```
+ */
+export declare class QueryAnalyzer {
+    private personIndicators;
+    private temporalKeywords;
+    private questionKeywords;
+    /**
+     * Analyze a query using rule-based heuristics.
+     * Main entry point - returns full QueryAnalysis.
+     */
+    analyze(query: string): QueryAnalysis;
+    /**
+     * Calculate confidence score for the analysis.
+     */
+    private calculateConfidence;
+    /**
+     * Extract person names from query.
+     */
+    private extractPersons;
+    /**
+     * Extract location names from query.
+     */
+    private extractLocations;
+    /**
+     * Extract organization names from query.
+     */
+    private extractOrganizations;
+    /**
+     * Extract temporal range from query.
+     */
+    private extractTemporalRange;
+    /**
+     * Detect the type of question.
+     */
+    private detectQuestionType;
+    /**
+     * Estimate query complexity.
+     */
+    private estimateComplexity;
+    /**
+     * Detect what types of information are being requested.
+     */
+    private detectRequiredInfoTypes;
+    /**
+     * Decompose complex queries into sub-queries.
+     */
+    private decomposeQuery;
+}
+//# sourceMappingURL=QueryAnalyzer.d.ts.map

package/dist/search/QueryAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryAnalyzer.d.ts","sourceRoot":"","sources":["../../src/search/QueryAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAkC,MAAM,mBAAmB,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,gBAAgB,CAA0C;IAClE,OAAO,CAAC,gBAAgB,CAKtB;IACF,OAAO,CAAC,gBAAgB,CAOtB;IAEF;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa;IAiCrC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAqBtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,cAAc;CAYvB"}

package/dist/search/QueryAnalyzer.js

@@ -0,0 +1,227 @@
+/**
+ * Query Analyzer
+ *
+ * Phase 11: Extracts structured information from natural language queries
+ * to enable intelligent search planning.
+ *
+ * @module search/QueryAnalyzer
+ */
+/**
+ * Query Analyzer extracts structured information from queries.
+ *
+ * Uses rule-based heuristics for reliable extraction of:
+ * - Person names
+ * - Location names
+ * - Organization names
+ * - Temporal references
+ * - Question type
+ * - Query complexity
+ *
+ * @example
+ * ```typescript
+ * const analyzer = new QueryAnalyzer();
+ * const analysis = analyzer.analyze(
+ *   'What projects did Alice work on last month?'
+ * );
+ * // { query: '...', entities: [...], persons: ['Alice'], temporalRange: { relative: 'last month' }, ... }
+ * ```
+ */
+export class QueryAnalyzer {
+    personIndicators = ['Mr.', 'Mrs.', 'Ms.', 'Dr.', 'Prof.'];
+    temporalKeywords = [
+        'yesterday', 'today', 'tomorrow',
+        'last week', 'last month', 'last year',
+        'this week', 'this month', 'this year',
+        'next week', 'next month', 'next year',
+    ];
+    questionKeywords = {
+        factual: ['what', 'who', 'where', 'which'],
+        temporal: ['when', 'how long', 'since', 'until'],
+        comparative: ['compare', 'difference', 'vs', 'versus', 'better', 'worse'],
+        aggregation: ['how many', 'count', 'total', 'sum', 'average'],
+        'multi-hop': ['and then', 'which means', 'therefore', 'related to'],
+        conceptual: ['explain', 'why', 'how does', 'what is the meaning', 'understand'],
+    };
+    /**
+     * Analyze a query using rule-based heuristics.
+     * Main entry point - returns full QueryAnalysis.
+     */
+    analyze(query) {
+        const lowerQuery = query.toLowerCase();
+        const persons = this.extractPersons(query);
+        const locations = this.extractLocations(query);
+        const organizations = this.extractOrganizations(query);
+        const questionType = this.detectQuestionType(lowerQuery);
+        const complexity = this.estimateComplexity(query);
+        // Build entities array from extracted names
+        const entities = [
+            ...persons.map(name => ({ name, type: 'person' })),
+            ...locations.map(name => ({ name, type: 'location' })),
+            ...organizations.map(name => ({ name, type: 'organization' })),
+        ];
+        // Calculate confidence based on extraction quality
+        const confidence = this.calculateConfidence(entities, complexity, questionType);
+        return {
+            query,
+            entities,
+            persons,
+            locations,
+            organizations,
+            temporalRange: this.extractTemporalRange(query) ?? null,
+            questionType,
+            complexity,
+            confidence,
+            requiredInfoTypes: this.detectRequiredInfoTypes(lowerQuery),
+            subQueries: this.decomposeQuery(query),
+        };
+    }
+    /**
+     * Calculate confidence score for the analysis.
+     */
+    calculateConfidence(entities, complexity, questionType) {
+        let confidence = 0.5;
+        // Higher confidence for simple queries
+        if (complexity === 'low')
+            confidence += 0.3;
+        else if (complexity === 'medium')
+            confidence += 0.1;
+        // Higher confidence when entities are detected
+        if (entities.length > 0)
+            confidence += 0.1;
+        // Lower confidence for conceptual queries (harder to satisfy)
+        if (questionType === 'conceptual')
+            confidence -= 0.2;
+        return Math.max(0, Math.min(1, confidence));
+    }
+    /**
+     * Extract person names from query.
+     */
+    extractPersons(query) {
+        const persons = [];
+        const words = query.split(/\s+/);
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i];
+            // Check for titles followed by names
+            if (this.personIndicators.some(ind => word.startsWith(ind))) {
+                if (i + 1 < words.length) {
+                    persons.push(words[i + 1].replace(/[^a-zA-Z]/g, ''));
+                }
+            }
+            // Check for capitalized words that might be names
+            if (/^[A-Z][a-z]+$/.test(word) && i > 0 && !/^[A-Z]/.test(words[i - 1])) {
+                persons.push(word);
+            }
+        }
+        return [...new Set(persons)];
+    }
+    /**
+     * Extract location names from query.
+     */
+    extractLocations(query) {
+        const locationIndicators = ['in', 'at', 'from', 'to', 'near'];
+        const locations = [];
+        const words = query.split(/\s+/);
+        for (let i = 0; i < words.length; i++) {
+            if (locationIndicators.includes(words[i].toLowerCase())) {
+                if (i + 1 < words.length && /^[A-Z]/.test(words[i + 1])) {
+                    locations.push(words[i + 1].replace(/[^a-zA-Z]/g, ''));
+                }
+            }
+        }
+        return [...new Set(locations)];
+    }
+    /**
+     * Extract organization names from query.
+     */
+    extractOrganizations(query) {
+        const orgIndicators = ['Inc.', 'Corp.', 'LLC', 'Ltd.', 'Company', 'Co.'];
+        const organizations = [];
+        for (const indicator of orgIndicators) {
+            const regex = new RegExp(`([A-Z][a-zA-Z]*)\\s*${indicator.replace('.', '\\.')}`, 'g');
+            const matches = query.match(regex);
+            if (matches) {
+                organizations.push(...matches);
+            }
+        }
+        return [...new Set(organizations)];
+    }
+    /**
+     * Extract temporal range from query.
+     */
+    extractTemporalRange(query) {
+        const lowerQuery = query.toLowerCase();
+        for (const keyword of this.temporalKeywords) {
+            if (lowerQuery.includes(keyword)) {
+                return { relative: keyword };
+            }
+        }
+        // Check for date patterns
+        const datePattern = /\d{4}-\d{2}-\d{2}/g;
+        const dates = query.match(datePattern);
+        if (dates && dates.length >= 1) {
+            return {
+                start: dates[0],
+                end: dates.length > 1 ? dates[1] : undefined,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Detect the type of question.
+     */
+    detectQuestionType(query) {
+        for (const [type, keywords] of Object.entries(this.questionKeywords)) {
+            if (keywords.some(kw => query.includes(kw))) {
+                return type;
+            }
+        }
+        return 'factual';
+    }
+    /**
+     * Estimate query complexity.
+     */
+    estimateComplexity(query) {
+        const wordCount = query.split(/\s+/).length;
+        const hasConjunctions = /\b(and|or|but|then|therefore)\b/i.test(query);
+        const hasMultipleClauses = /[,;]/.test(query);
+        if (wordCount > 20 || (hasConjunctions && hasMultipleClauses)) {
+            return 'high';
+        }
+        if (wordCount > 10 || hasConjunctions || hasMultipleClauses) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Detect what types of information are being requested.
+     */
+    detectRequiredInfoTypes(query) {
+        const infoTypes = [];
+        if (/\b(who|person|people|name)\b/.test(query))
+            infoTypes.push('person');
+        if (/\b(where|location|place|city)\b/.test(query))
+            infoTypes.push('location');
+        if (/\b(when|date|time|year|month)\b/.test(query))
+            infoTypes.push('temporal');
+        if (/\b(how many|count|number|total)\b/.test(query))
+            infoTypes.push('quantity');
+        if (/\b(why|reason|because)\b/.test(query))
+            infoTypes.push('reason');
+        if (/\b(what|which|project|task)\b/.test(query))
+            infoTypes.push('entity');
+        return infoTypes;
+    }
+    /**
+     * Decompose complex queries into sub-queries.
+     */
+    decomposeQuery(query) {
+        // Split on conjunctions
+        const parts = query.split(/\b(and then|and|but|or)\b/i)
+            .map(p => p.trim())
+            .filter(p => p && !/^(and then|and|but|or)$/i.test(p));
+        if (parts.length > 1) {
+            return parts;
+        }
+        return undefined;
+    }
+}

package/dist/search/QueryPlanner.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Query Planner
+ *
+ * Phase 11: Generates execution plans for queries based on analysis.
+ *
+ * @module search/QueryPlanner
+ */
+import type { QueryAnalysis, QueryPlan } from '../types/index.js';
+/**
+ * Query Planner generates execution plans from query analysis.
+ *
+ * Creates optimized plans that:
+ * - Select appropriate search layers
+ * - Determine execution strategy (parallel/sequential)
+ * - Set up query dependencies
+ * - Configure merge strategies
+ *
+ * @example
+ * ```typescript
+ * const analyzer = new QueryAnalyzer();
+ * const planner = new QueryPlanner();
+ *
+ * const analysis = analyzer.analyze('Find projects by Alice');
+ * const plan = planner.createPlan('Find projects by Alice', analysis);
+ * // { originalQuery: '...', subQueries: [...], executionStrategy: 'iterative', ... }
+ * ```
+ */
+export declare class QueryPlanner {
+    /**
+     * Create an execution plan from query analysis.
+     */
+    createPlan(query: string, analysis: QueryAnalysis): QueryPlan;
+    /**
+     * Create sub-queries from analysis.
+     */
+    private createSubQueries;
+    /**
+     * Select the most appropriate search layer.
+     */
+    private selectLayer;
+    /**
+     * Select execution strategy based on sub-queries.
+     */
+    private selectExecutionStrategy;
+    /**
+     * Select merge strategy based on question type.
+     */
+    private selectMergeStrategy;
+    /**
+     * Build symbolic filters from analysis.
+     */
+    private buildFilters;
+    /**
+     * Calculate plan complexity score.
+     */
+    private calculateComplexity;
+}
+//# sourceMappingURL=QueryPlanner.d.ts.map

package/dist/search/QueryPlanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryPlanner.d.ts","sourceRoot":"","sources":["../../src/search/QueryPlanner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAA6B,MAAM,mBAAmB,CAAC;AAE7F;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,SAAS;IAc7D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAanB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAQ5B"}

package/dist/search/QueryPlanner.js

@@ -0,0 +1,137 @@
+/**
+ * Query Planner
+ *
+ * Phase 11: Generates execution plans for queries based on analysis.
+ *
+ * @module search/QueryPlanner
+ */
+/**
+ * Query Planner generates execution plans from query analysis.
+ *
+ * Creates optimized plans that:
+ * - Select appropriate search layers
+ * - Determine execution strategy (parallel/sequential)
+ * - Set up query dependencies
+ * - Configure merge strategies
+ *
+ * @example
+ * ```typescript
+ * const analyzer = new QueryAnalyzer();
+ * const planner = new QueryPlanner();
+ *
+ * const analysis = analyzer.analyze('Find projects by Alice');
+ * const plan = planner.createPlan('Find projects by Alice', analysis);
+ * // { originalQuery: '...', subQueries: [...], executionStrategy: 'iterative', ... }
+ * ```
+ */
+export class QueryPlanner {
+    /**
+     * Create an execution plan from query analysis.
+     */
+    createPlan(query, analysis) {
+        const subQueries = this.createSubQueries(query, analysis);
+        const executionStrategy = this.selectExecutionStrategy(subQueries);
+        const mergeStrategy = this.selectMergeStrategy(analysis);
+        return {
+            originalQuery: query,
+            subQueries,
+            executionStrategy,
+            mergeStrategy,
+            estimatedComplexity: this.calculateComplexity(subQueries),
+        };
+    }
+    /**
+     * Create sub-queries from analysis.
+     */
+    createSubQueries(query, analysis) {
+        const subQueries = [];
+        let id = 0;
+        // If query was decomposed, create sub-query for each part
+        if (analysis.subQueries && analysis.subQueries.length > 1) {
+            for (const sq of analysis.subQueries) {
+                subQueries.push({
+                    id: `sq_${id++}`,
+                    query: sq,
+                    targetLayer: this.selectLayer(analysis),
+                    priority: id === 1 ? 1 : 2,
+                    dependsOn: id > 1 ? [`sq_${id - 2}`] : undefined,
+                });
+            }
+        }
+        else {
+            // Single query
+            subQueries.push({
+                id: `sq_${id}`,
+                query,
+                targetLayer: this.selectLayer(analysis),
+                priority: 1,
+                filters: this.buildFilters(analysis),
+            });
+        }
+        return subQueries;
+    }
+    /**
+     * Select the most appropriate search layer.
+     */
+    selectLayer(analysis) {
+        // Use symbolic for tag/type/date filtered queries
+        if (analysis.temporalRange || analysis.requiredInfoTypes.includes('temporal')) {
+            return 'symbolic';
+        }
+        // Use semantic for complex concept queries
+        if (analysis.complexity === 'high' || analysis.questionType === 'comparative') {
+            return 'semantic';
+        }
+        // Use hybrid for balanced approach
+        return 'hybrid';
+    }
+    /**
+     * Select execution strategy based on sub-queries.
+     */
+    selectExecutionStrategy(subQueries) {
+        const hasDependencies = subQueries.some(sq => sq.dependsOn && sq.dependsOn.length > 0);
+        if (hasDependencies)
+            return 'sequential';
+        if (subQueries.length > 1)
+            return 'parallel';
+        return 'iterative';
+    }
+    /**
+     * Select merge strategy based on question type.
+     */
+    selectMergeStrategy(analysis) {
+        switch (analysis.questionType) {
+            case 'aggregation': return 'union';
+            case 'comparative': return 'intersection';
+            default: return 'weighted';
+        }
+    }
+    /**
+     * Build symbolic filters from analysis.
+     */
+    buildFilters(analysis) {
+        const filters = {};
+        let hasFilters = false;
+        if (analysis.temporalRange) {
+            filters.dateRange = {
+                start: analysis.temporalRange.start || '',
+                end: analysis.temporalRange.end || '',
+            };
+            hasFilters = true;
+        }
+        return hasFilters ? filters : undefined;
+    }
+    /**
+     * Calculate plan complexity score.
+     */
+    calculateComplexity(subQueries) {
+        let complexity = subQueries.length;
+        for (const sq of subQueries) {
+            if (sq.dependsOn)
+                complexity += sq.dependsOn.length * 0.5;
+            if (sq.filters)
+                complexity += 0.5;
+        }
+        return Math.min(complexity, 10);
+    }
+}