@simonecoelhosfo/optimizely-mcp-server/dist/analytics/robust-parser/RobustIntentParser.d.ts

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * RobustIntentParser - Advanced Natural Language Query Parser
 *
 * IMPLEMENTATION STATUS:
 * 🚧 IN PROGRESS: Core parser implementation
 * COMPLETE: Basic structure and main methods
 * TODO: Advanced features (fuzzy matching, context inference)
 *
 * Last Updated: July 3, 2025
 */
import { ParseResult, QueryIntent, UniversalQuery, ParserConfig } from './types/index.js';
export declare class RobustIntentParser {
    private config;
    private cache;
    private fuzzyMatcher;
    private contextInferrer;
    private confidenceScorer;
    private fieldMapper;
    private fieldResolutionAlgorithm;
    private queryDecomposer;
    private fieldResolver;
    private currentQueryIntent?;
    private currentParseResult;
    private currentQuery;
    /**
     * Adapter method to convert ViewOnlyFieldResolver response to legacy format
     */
    private adaptFieldResolution;
    constructor(config?: ParserConfig);
    /**
     * Main parse method with caching and advanced features - DAY 2 ENHANCED VERSION
     */
    parse(query: string): ParseResult;
    /**
     * Convert ParseResult to QueryIntent format
     */
    toQueryIntent(result: ParseResult): QueryIntent;
    /**
     * Convert ParseResult to UniversalQuery format
     */
    toUniversalQuery(result: ParseResult): UniversalQuery;
    /**
     * 🚧 Normalize query for parsing
     */
    private normalizeQuery;
    /**
     * Extract entities from query with fuzzy matching
     */
    private extractEntities;
    /**
     * Extract fields from query with proper table qualification using IntelligentFieldMapper
     */
    private extractFields;
    /**
     * Qualify field name with correct table using IntelligentFieldMapper
     */
    private qualifyFieldName;
    /**
     * Helper method to determine if current context is aggregation
     */
    private isAggregationContext;
    /**
     * Helper method to determine query type for field resolution
     */
    private determineQueryType;
    /**
     * Find field in related entities when not found in primary entity
     */
    private findFieldInRelatedEntities;
    /**
     * 🚧 Extract filters from query
     */
    private extractFilters;
    /**
     * Apply domain-specific knowledge to convert field matches into appropriate filters
     */
    private createDomainSpecificFilter;
    /**
     * PHASE 1 FIX: Extract filters with locality resolution and JOIN detection
     */
    private extractFiltersWithLocality;
    /**
     * Helper: Get table name for entity
     */
    private getTableName;
    /**
     * Helper: Get entity from table name
     */
    private getEntityFromTable;
    /**
     * 🚧 Extract groupBy fields
     */
    private extractGroupBy;
    /**
     * 🚧 Extract orderBy clauses
     */
    private extractOrderBy;
    /**
     * 🚧 Extract aggregations
     */
    private extractAggregations;
    /**
     * 🚧 Extract joins from related entities
     */
    private extractJoins;
    /**
     * Sort entities by JOIN dependency order
     */
    private sortEntitiesByJoinDependency;
    /**
     * Check if an entity can be joined given the currently joined entities
     */
    private canJoinEntity;
    /**
     * Get join info for an entity (mimics inferJoin logic)
     */
    private getJoinInfoForEntity;
    /**
     * Extract table names referenced in a JOIN condition
     */
    private extractTablesFromJoinCondition;
    /**
     * Infer join conditions between entities using IntelligentFieldMapper
     */
    private inferJoin;
    /**
     * CRITICAL: Handle multi-hop joins for complex relationships like audiences → environments
     */
    private getMultiHopJoin;
    /**
     * Parse join condition to extract left and right field references
     */
    private parseJoinCondition;
    /**
     * 🚧 Extract time range
     */
    private extractTimeRange;
    /**
     * 🚧 Extract limit
     */
    private extractLimit;
    /**
     * 🚧 Calculate overall confidence
     */
    private calculateConfidence;
    /**
     * 🚧 Extract metrics from result
     */
    private extractMetricsFromResult;
    /**
     * 🚧 Infer platform from entities
     */
    private inferPlatform;
    /**
     * Map query type to legacy action format
     */
    private mapQueryTypeToAction;
    /**
     * Extract entities with intent awareness - for COUNT queries, be more careful
     */
    private extractEntitiesWithIntent;
    /**
     * Extract fields with locality awareness - CRITICAL for avoiding JOINs
     */
    private extractFieldsWithLocality;
    /**
     * Extract GROUP BY with locality awareness - CRITICAL for COUNT queries
     */
    private extractGroupByWithLocality;
    /**
     * Normalize entity names for consistency
     */
    private normalizeEntityName;
    /**
     * Build aggregation context for query optimization
     */
    private buildAggregationContext;
    /**
     * Select the preferred strategy based on query characteristics
     */
    private selectPreferredStrategy;
    /**
     * Analyze JOIN necessity - CRITICAL for preventing COUNT inflation
     */
    private analyzeJoinNecessity;
    /**
     * Check if query can be answered from join tables only
     */
    private canAnswerFromJoinTable;
    /**
     * Determine if an entity is required for COUNT queries
     */
    private isRequiredForCount;
    /**
     * L7-11 FIX: Detect invalid cross-platform comparisons
     * Audiences and attributes are platform-specific and cannot be compared
     * between Web Experimentation and Feature Experimentation
     */
    private isInvalidCrossPlatformComparison;
}
//# sourceMappingURL=RobustIntentParser.d.ts.map