@danielsimonjr/memoryjs 1.0.0

package/dist/search/QueryCostEstimator.js

@@ -0,0 +1,653 @@
+/**
+ * Query Cost Estimator
+ *
+ * Phase 10 Sprint 4: Estimates the cost of different search methods
+ * and recommends the optimal method based on query characteristics
+ * and graph size.
+ *
+ * Phase 12 Sprint 4: Enhanced with adaptive depth calculation,
+ * layer recommendations, and token estimation.
+ *
+ * @module search/QueryCostEstimator
+ */
+/**
+ * Default options for the QueryCostEstimator.
+ */
+const DEFAULT_OPTIONS = {
+    basicTimePerEntity: 0.01,
+    rankedTimePerEntity: 0.05,
+    booleanTimePerEntity: 0.02,
+    fuzzyTimePerEntity: 0.1,
+    semanticTimePerEntity: 0.5,
+    lowComplexityThreshold: 100,
+    highComplexityThreshold: 1000,
+};
+/**
+ * Default adaptive depth configuration.
+ */
+const DEFAULT_ADAPTIVE_DEPTH = {
+    kBase: 10,
+    delta: 0.5,
+    maxDepth: 100,
+};
+/**
+ * Default token estimation options.
+ */
+const DEFAULT_TOKEN_ESTIMATION = {
+    charsPerToken: 4,
+    includeEntityCount: true,
+};
+/**
+ * Phase 10 Sprint 4: Estimates search query costs and recommends optimal methods.
+ *
+ * Analyzes query characteristics and graph size to estimate execution time
+ * and recommend the most appropriate search method.
+ *
+ * @example
+ * ```typescript
+ * const estimator = new QueryCostEstimator();
+ *
+ * // Get estimate for a specific method
+ * const estimate = estimator.estimateMethod('ranked', 'test query', 1000);
+ *
+ * // Get the recommended method for a query
+ * const recommendation = estimator.recommendMethod('test query', 1000);
+ *
+ * // Get estimates for all methods
+ * const allEstimates = estimator.estimateAllMethods('test query', 1000);
+ * ```
+ */
+export class QueryCostEstimator {
+    options;
+    adaptiveDepthConfig;
+    tokenEstimationConfig;
+    /**
+     * Create a new QueryCostEstimator instance.
+     *
+     * @param options - Optional configuration overrides
+     * @param adaptiveDepthConfig - Optional adaptive depth configuration
+     * @param tokenEstimationConfig - Optional token estimation configuration
+     */
+    constructor(options, adaptiveDepthConfig, tokenEstimationConfig) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.adaptiveDepthConfig = { ...DEFAULT_ADAPTIVE_DEPTH, ...adaptiveDepthConfig };
+        this.tokenEstimationConfig = { ...DEFAULT_TOKEN_ESTIMATION, ...tokenEstimationConfig };
+    }
+    /**
+     * Estimate the cost of a specific search method.
+     *
+     * @param method - The search method to estimate
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @returns Cost estimate for the method
+     */
+    estimateMethod(method, query, entityCount) {
+        // Get the recommended method first to determine isRecommended
+        const recommendedMethod = this.getRecommendedMethodOnly(query, entityCount);
+        return this.estimateMethodInternal(method, query, entityCount, method === recommendedMethod);
+    }
+    /**
+     * Internal method to estimate without triggering recursion.
+     * @private
+     */
+    estimateMethodInternal(method, query, entityCount, isRecommended) {
+        const baseTime = this.getBaseTimeForMethod(method);
+        const queryComplexityFactor = this.getQueryComplexityFactor(query, method);
+        const estimatedTimeMs = baseTime * entityCount * queryComplexityFactor;
+        const complexity = this.getComplexity(entityCount);
+        const recommendation = this.getRecommendation(method, query, entityCount, complexity);
+        return {
+            method,
+            estimatedTimeMs: Math.round(estimatedTimeMs * 100) / 100,
+            complexity,
+            entityCount,
+            recommendation,
+            isRecommended,
+        };
+    }
+    /**
+     * Get just the recommended method without full estimate (avoids recursion).
+     * @private
+     */
+    getRecommendedMethodOnly(query, entityCount, preferredMethods) {
+        const methods = preferredMethods ?? ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        // Score each method and find the best
+        let bestMethod = methods[0];
+        let bestScore = this.scoreMethod(methods[0], query, entityCount);
+        for (let i = 1; i < methods.length; i++) {
+            const score = this.scoreMethod(methods[i], query, entityCount);
+            if (score > bestScore) {
+                bestScore = score;
+                bestMethod = methods[i];
+            }
+        }
+        return bestMethod;
+    }
+    /**
+     * Get estimates for all available search methods.
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @returns Array of estimates for all methods
+     */
+    estimateAllMethods(query, entityCount) {
+        const methods = ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        const recommendedMethod = this.getRecommendedMethodOnly(query, entityCount);
+        return methods.map(method => this.estimateMethodInternal(method, query, entityCount, method === recommendedMethod));
+    }
+    /**
+     * Recommend the best search method for a query.
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @param preferredMethods - Optional array of methods to consider (default: all)
+     * @returns The recommended method and reason
+     */
+    recommendMethod(query, entityCount, preferredMethods) {
+        const methods = preferredMethods ?? ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        // Score each method based on query characteristics and cost
+        const scores = methods.map(method => ({
+            method,
+            score: this.scoreMethod(method, query, entityCount),
+            estimate: this.estimateMethod(method, query, entityCount),
+        }));
+        // Sort by score (higher is better)
+        scores.sort((a, b) => b.score - a.score);
+        const best = scores[0];
+        const reason = this.getSelectionReason(best.method, query, entityCount);
+        return {
+            method: best.method,
+            reason,
+            estimate: best.estimate,
+        };
+    }
+    /**
+     * Get the base time per entity for a search method.
+     * @private
+     */
+    getBaseTimeForMethod(method) {
+        switch (method) {
+            case 'basic':
+                return this.options.basicTimePerEntity;
+            case 'ranked':
+                return this.options.rankedTimePerEntity;
+            case 'boolean':
+                return this.options.booleanTimePerEntity;
+            case 'fuzzy':
+                return this.options.fuzzyTimePerEntity;
+            case 'semantic':
+                return this.options.semanticTimePerEntity;
+        }
+    }
+    /**
+     * Calculate a complexity factor based on query characteristics.
+     * @private
+     */
+    getQueryComplexityFactor(query, method) {
+        const words = query.trim().split(/\s+/).length;
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const hasQuotes = query.includes('"');
+        let factor = 1.0;
+        // More words = slightly more complex
+        factor += (words - 1) * 0.1;
+        // Boolean operators increase boolean search cost, decrease others
+        if (hasOperators) {
+            if (method === 'boolean') {
+                factor *= 0.8; // Boolean search is optimized for operators
+            }
+            else {
+                factor *= 1.5; // Other methods struggle with operators
+            }
+        }
+        // Wildcards increase fuzzy search efficiency
+        if (hasWildcard) {
+            if (method === 'fuzzy') {
+                factor *= 0.9;
+            }
+            else {
+                factor *= 1.3;
+            }
+        }
+        // Quoted phrases benefit ranked search
+        if (hasQuotes) {
+            if (method === 'ranked') {
+                factor *= 0.9;
+            }
+            else {
+                factor *= 1.1;
+            }
+        }
+        return Math.max(0.5, Math.min(factor, 3.0)); // Clamp between 0.5 and 3.0
+    }
+    /**
+     * Get the complexity level based on entity count.
+     * @private
+     */
+    getComplexity(entityCount) {
+        if (entityCount <= this.options.lowComplexityThreshold) {
+            return 'low';
+        }
+        if (entityCount >= this.options.highComplexityThreshold) {
+            return 'high';
+        }
+        return 'medium';
+    }
+    /**
+     * Generate a human-readable recommendation.
+     * @private
+     */
+    getRecommendation(method, _query, _entityCount, complexity) {
+        const recommendations = {
+            basic: 'Fast substring matching, best for simple queries',
+            ranked: 'TF-IDF relevance ranking, best for finding most relevant results',
+            boolean: 'Boolean operators (AND/OR/NOT), best for precise filtering',
+            fuzzy: 'Tolerant of typos and misspellings, best for uncertain queries',
+            semantic: 'Meaning-based search using embeddings, best for conceptual queries',
+        };
+        let recommendation = recommendations[method];
+        if (complexity === 'high' && method === 'semantic') {
+            recommendation += ' - may be slow for large graphs';
+        }
+        if (complexity === 'low') {
+            recommendation += ' - fast for small graphs';
+        }
+        return recommendation;
+    }
+    /**
+     * Score a method based on query characteristics and graph size.
+     * Higher score = better fit.
+     * @private
+     */
+    scoreMethod(method, query, entityCount) {
+        let score = 50; // Base score
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const hasQuotes = query.includes('"');
+        const words = query.trim().split(/\s+/).length;
+        const isShortQuery = words <= 2;
+        const isLongQuery = words >= 5;
+        const complexity = this.getComplexity(entityCount);
+        switch (method) {
+            case 'basic':
+                // Basic is good for simple, short queries on any size graph
+                if (isShortQuery && !hasOperators && !hasWildcard) {
+                    score += 30;
+                }
+                if (complexity === 'low') {
+                    score += 20;
+                }
+                // Basic is fastest, give bonus for speed
+                score += 10;
+                break;
+            case 'ranked':
+                // Ranked is good for relevance-focused queries
+                if (words >= 2) {
+                    score += 25; // Better for multi-word queries
+                }
+                if (hasQuotes) {
+                    score += 15; // Good for phrase matching
+                }
+                if (!hasOperators) {
+                    score += 10; // Not optimized for boolean
+                }
+                // Good balance of speed and quality
+                score += 15;
+                break;
+            case 'boolean':
+                // Boolean is best for queries with operators
+                if (hasOperators) {
+                    score += 40;
+                }
+                if (!hasOperators) {
+                    score -= 20; // Not useful without operators
+                }
+                // Fast for filtering
+                score += 10;
+                break;
+            case 'fuzzy':
+                // Fuzzy is good for typo-tolerant search
+                if (hasWildcard) {
+                    score += 25;
+                }
+                if (isShortQuery) {
+                    score += 15; // Works best on shorter queries
+                }
+                if (isLongQuery) {
+                    score -= 15; // Slow on long queries
+                }
+                if (complexity === 'high') {
+                    score -= 20; // Slow on large graphs
+                }
+                break;
+            case 'semantic':
+                // Semantic is good for conceptual/meaning-based queries
+                if (isLongQuery) {
+                    score += 30; // Better for longer, more descriptive queries
+                }
+                if (!hasOperators && !hasWildcard) {
+                    score += 15; // Natural language queries
+                }
+                // Penalize for large graphs (slow)
+                if (complexity === 'high') {
+                    score -= 30;
+                }
+                if (complexity === 'medium') {
+                    score -= 10;
+                }
+                break;
+        }
+        return score;
+    }
+    /**
+     * Get a human-readable reason for why a method was selected.
+     * @private
+     */
+    getSelectionReason(method, query, entityCount) {
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const words = query.trim().split(/\s+/).length;
+        const complexity = this.getComplexity(entityCount);
+        switch (method) {
+            case 'basic':
+                if (complexity === 'low') {
+                    return 'Basic search selected for small graph size - fast and efficient';
+                }
+                return 'Basic search selected for simple query pattern';
+            case 'ranked':
+                if (words >= 2) {
+                    return 'Ranked search selected for multi-word query - provides relevance ordering';
+                }
+                return 'Ranked search selected for best balance of speed and relevance';
+            case 'boolean':
+                if (hasOperators) {
+                    return 'Boolean search selected - query contains logical operators (AND/OR/NOT)';
+                }
+                return 'Boolean search selected for precise filtering';
+            case 'fuzzy':
+                if (hasWildcard) {
+                    return 'Fuzzy search selected - query contains wildcard patterns';
+                }
+                return 'Fuzzy search selected for typo-tolerant matching';
+            case 'semantic':
+                if (words >= 5) {
+                    return 'Semantic search selected - longer natural language query benefits from meaning-based matching';
+                }
+                return 'Semantic search selected for conceptual/meaning-based matching';
+        }
+    }
+    // ==================== Phase 12 Sprint 4: Enhanced Features ====================
+    /**
+     * Calculate adaptive depth (k_dyn) based on query complexity.
+     *
+     * Formula: k_dyn = k_base × (1 + δ × C_q)
+     * where:
+     *   - k_base: base number of results
+     *   - δ (delta): complexity scaling factor
+     *   - C_q: query complexity score (0-1)
+     *
+     * @param query - The search query
+     * @param analysis - Optional query analysis for more accurate complexity
+     * @returns Adaptive depth value
+     */
+    calculateAdaptiveDepth(query, analysis) {
+        const { kBase, delta, maxDepth } = this.adaptiveDepthConfig;
+        // Calculate complexity score (0-1)
+        const complexityScore = this.calculateComplexityScore(query, analysis);
+        // Apply formula: k_dyn = k_base × (1 + δ × C_q)
+        const kDyn = kBase * (1 + delta * complexityScore);
+        // Round and cap at maxDepth
+        return Math.min(Math.round(kDyn), maxDepth);
+    }
+    /**
+     * Calculate query complexity score (0-1).
+     * @private
+     */
+    calculateComplexityScore(query, analysis) {
+        let score = 0;
+        // Use analysis if provided
+        if (analysis) {
+            switch (analysis.complexity) {
+                case 'low':
+                    score = 0.2;
+                    break;
+                case 'medium':
+                    score = 0.5;
+                    break;
+                case 'high':
+                    score = 0.8;
+                    break;
+            }
+            // Adjust for sub-queries
+            if (analysis.subQueries && analysis.subQueries.length > 1) {
+                score += 0.1 * (analysis.subQueries.length - 1);
+            }
+            // Adjust for temporal range (adds complexity)
+            if (analysis.temporalRange) {
+                score += 0.1;
+            }
+            // Adjust for entities (more entities = more complex)
+            if (analysis.entities.length > 0) {
+                score += 0.05 * Math.min(analysis.entities.length, 3);
+            }
+        }
+        else {
+            // Fallback to query-based estimation
+            const words = query.trim().split(/\s+/).length;
+            const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+            const hasMultipleClauses = /[,;]/.test(query);
+            const hasConjunctions = /\b(and|or|but|then|therefore)\b/i.test(query);
+            score = Math.min(words / 20, 0.5); // Base score from length
+            if (hasOperators)
+                score += 0.2;
+            if (hasMultipleClauses)
+                score += 0.15;
+            if (hasConjunctions)
+                score += 0.1;
+        }
+        // Clamp to 0-1
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Estimate tokens for query and expected results.
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @param expectedResults - Expected number of results (default: 10)
+     * @returns Estimated token count
+     */
+    estimateTokens(query, entityCount, expectedResults = 10) {
+        const { charsPerToken, includeEntityCount } = this.tokenEstimationConfig;
+        // Query tokens
+        const queryTokens = Math.ceil(query.length / charsPerToken);
+        // Result tokens (approximate average entity text size)
+        const avgEntityTextSize = 200; // Conservative estimate
+        const resultTokens = Math.ceil((avgEntityTextSize * expectedResults) / charsPerToken);
+        // Add overhead for entity count if enabled
+        let totalTokens = queryTokens + resultTokens;
+        if (includeEntityCount) {
+            // More entities = slightly more processing/context
+            const entityOverhead = Math.ceil(Math.log10(entityCount + 1) * 10);
+            totalTokens += entityOverhead;
+        }
+        return totalTokens;
+    }
+    /**
+     * Recommend search layers based on query characteristics.
+     *
+     * @param query - The search query
+     * @param options - Layer recommendation options
+     * @returns Ordered array of recommended layers (fastest first)
+     */
+    recommendLayers(query, options = {}) {
+        const { analysis, semanticAvailable = true, maxLayers = 3, } = options;
+        const layers = [];
+        // Score lexical layer
+        const lexicalScore = this.scoreLexicalLayer(query, analysis);
+        layers.push({
+            layer: 'lexical',
+            score: lexicalScore,
+            cost: this.estimateLayerCost('lexical', query),
+        });
+        // Score symbolic layer
+        const symbolicScore = this.scoreSymbolicLayer(query, analysis);
+        layers.push({
+            layer: 'symbolic',
+            score: symbolicScore,
+            cost: this.estimateLayerCost('symbolic', query),
+        });
+        // Score semantic layer (if available)
+        if (semanticAvailable) {
+            const semanticScore = this.scoreSemanticLayer(query, analysis);
+            layers.push({
+                layer: 'semantic',
+                score: semanticScore,
+                cost: this.estimateLayerCost('semantic', query),
+            });
+        }
+        // Sort by score (higher is better), then by cost (lower is better)
+        layers.sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            return a.cost - b.cost;
+        });
+        // Return up to maxLayers
+        return layers.slice(0, maxLayers).map(l => l.layer);
+    }
+    /**
+     * Estimate cost for a specific layer.
+     * @private
+     */
+    estimateLayerCost(layer, query) {
+        const words = query.trim().split(/\s+/).length;
+        switch (layer) {
+            case 'lexical':
+                return 1 + words * 0.1; // Fast, scales with words
+            case 'symbolic':
+                return 0.5; // Very fast, constant time
+            case 'semantic':
+                return 5 + words * 0.5; // Slow, embedding computation
+        }
+    }
+    /**
+     * Score lexical layer for query.
+     * @private
+     */
+    scoreLexicalLayer(query, analysis) {
+        let score = 50;
+        const words = query.trim().split(/\s+/).length;
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        // Good for keyword queries
+        if (words >= 2 && words <= 5)
+            score += 20;
+        if (!hasOperators)
+            score += 10;
+        // Check analysis for factual questions
+        if (analysis?.questionType === 'factual')
+            score += 15;
+        if (analysis?.questionType === 'aggregation')
+            score += 10;
+        return score;
+    }
+    /**
+     * Score symbolic layer for query.
+     * @private
+     */
+    scoreSymbolicLayer(query, analysis) {
+        let score = 40;
+        // Good for temporal queries
+        if (analysis?.temporalRange)
+            score += 30;
+        if (analysis?.questionType === 'temporal')
+            score += 25;
+        // Good for structured filtering
+        const hasFilterKeywords = /\b(type|tag|importance|date|created|modified)\b/i.test(query);
+        if (hasFilterKeywords)
+            score += 20;
+        // If analysis detected entities, might benefit from symbolic
+        if (analysis?.entities && analysis.entities.length > 0)
+            score += 10;
+        return score;
+    }
+    /**
+     * Score semantic layer for query.
+     * @private
+     */
+    scoreSemanticLayer(query, analysis) {
+        let score = 45;
+        const words = query.trim().split(/\s+/).length;
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        // Good for longer, natural language queries
+        if (words >= 5)
+            score += 25;
+        if (!hasOperators)
+            score += 10;
+        // Good for conceptual questions
+        if (analysis?.questionType === 'conceptual')
+            score += 30;
+        if (analysis?.questionType === 'comparative')
+            score += 20;
+        // High complexity benefits from semantic understanding
+        if (analysis?.complexity === 'high')
+            score += 15;
+        return score;
+    }
+    /**
+     * Get extended cost estimate with all Phase 12 features.
+     *
+     * @param method - The search method
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @param analysis - Optional query analysis
+     * @returns Extended cost estimate
+     */
+    estimateExtended(method, query, entityCount, analysis) {
+        const base = this.estimateMethod(method, query, entityCount);
+        const adaptiveDepth = this.calculateAdaptiveDepth(query, analysis);
+        const estimatedTokens = this.estimateTokens(query, entityCount, adaptiveDepth);
+        const recommendedLayers = this.recommendLayers(query, {
+            analysis,
+            semanticAvailable: method === 'semantic' || true, // Assume available
+        });
+        const layerCosts = {
+            semantic: this.estimateLayerCost('semantic', query) * entityCount * 0.001,
+            lexical: this.estimateLayerCost('lexical', query) * entityCount * 0.001,
+            symbolic: this.estimateLayerCost('symbolic', query) * entityCount * 0.001,
+        };
+        return {
+            ...base,
+            recommendedLayers,
+            estimatedTokens,
+            adaptiveDepth,
+            layerCosts,
+        };
+    }
+    /**
+     * Get layers sorted by estimated cost (fastest first).
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities
+     * @param semanticAvailable - Whether semantic search is available
+     * @returns Layers sorted by cost
+     */
+    getLayersByCost(query, entityCount, semanticAvailable = true) {
+        const layers = [
+            {
+                layer: 'symbolic',
+                estimatedMs: this.estimateLayerCost('symbolic', query) * Math.log10(entityCount + 1),
+            },
+            {
+                layer: 'lexical',
+                estimatedMs: this.estimateLayerCost('lexical', query) * Math.sqrt(entityCount),
+            },
+        ];
+        if (semanticAvailable) {
+            layers.push({
+                layer: 'semantic',
+                estimatedMs: this.estimateLayerCost('semantic', query) * entityCount * 0.1,
+            });
+        }
+        return layers.sort((a, b) => a.estimatedMs - b.estimatedMs);
+    }
+}
+//# sourceMappingURL=QueryCostEstimator.js.map

package/dist/search/QueryCostEstimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryCostEstimator.js","sourceRoot":"","sources":["../../src/search/QueryCostEstimator.ts"],"names":[],"mappings":"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"}