optivise/dist/services/learning-service.d.ts

Optivise - The Ultimate Optimizely Development Assistant with AI-powered features, zero-config setup, and comprehensive development support

/**
 * Intelligent Prompt Learning and Adaptation Service
 * Learns from user interactions to improve response quality and personalization
 */
import { EventEmitter } from 'events';
import type { Logger, OptimizelyProduct } from '../types/index.js';
export interface LearningPattern {
    id: string;
    pattern: RegExp | string;
    intent: string;
    confidence: number;
    usage: number;
    successRate: number;
    lastUsed: number;
    metadata: {
        products: OptimizelyProduct[];
        keywords: string[];
        context: string;
    };
}
export interface UserPreference {
    userId: string;
    preferences: {
        favoriteProducts: OptimizelyProduct[];
        preferredResponseStyle: 'detailed' | 'concise' | 'technical' | 'beginner';
        commonTasks: string[];
        feedbackHistory: Array<{
            query: string;
            rating: number;
            timestamp: number;
            improvements?: string;
        }>;
    };
    learningData: {
        queryPatterns: string[];
        successfulResponses: string[];
        averageRating: number;
        totalInteractions: number;
    };
}
export interface AdaptationSuggestion {
    type: 'pattern' | 'response' | 'workflow';
    suggestion: string;
    confidence: number;
    impact: 'low' | 'medium' | 'high';
    evidence: Array<{
        query: string;
        outcome: string;
        timestamp: number;
    }>;
}
export interface LearningReport {
    timeframe: {
        start: number;
        end: number;
    };
    patterns: {
        discovered: number;
        improved: number;
        deprecated: number;
    };
    users: {
        activeUsers: number;
        averageSatisfaction: number;
        topQueries: Array<{
            query: string;
            frequency: number;
        }>;
    };
    adaptations: {
        suggested: number;
        implemented: number;
        successRate: number;
    };
    insights: string[];
}
export declare class LearningService extends EventEmitter {
    private patterns;
    private userPreferences;
    private logger;
    private adaptationThreshold;
    private maxPatterns;
    private cleanupInterval?;
    constructor(logger: Logger);
    /**
     * Record user interaction for learning
     */
    recordInteraction(data: {
        userId?: string;
        query: string;
        response: string;
        detectedProducts: OptimizelyProduct[];
        relevanceScore: number;
        responseTime: number;
        userRating?: number;
        feedback?: string;
    }): void;
    /**
     * Get personalized suggestions for a user
     */
    getPersonalizedSuggestions(userId: string, query: string): {
        suggestedProducts: OptimizelyProduct[];
        responseStyle: string;
        contextualHints: string[];
    };
    /**
     * Analyze query and suggest improvements based on learned patterns
     */
    analyzeQuery(query: string): {
        detectedPatterns: LearningPattern[];
        suggestions: AdaptationSuggestion[];
        confidenceScore: number;
    };
    /**
     * Get adaptation suggestions for improving the system
     */
    getAdaptationSuggestions(): AdaptationSuggestion[];
    /**
     * Generate learning report
     */
    generateLearningReport(timeframeHours?: number): LearningReport;
    /**
     * Export learning data for backup or analysis
     */
    exportLearningData(): {
        patterns: LearningPattern[];
        userPreferences: UserPreference[];
        exportTime: number;
    };
    /**
     * Import learning data from backup
     */
    importLearningData(data: {
        patterns: LearningPattern[];
        userPreferences: UserPreference[];
    }): boolean;
    /**
     * Initialize base patterns from common Optimizely queries
     */
    private initializeBasePatterns;
    /**
     * Extract and update patterns from user interactions
     */
    private extractAndUpdatePatterns;
    /**
     * Update user preferences based on interaction
     */
    private updateUserPreferences;
    /**
     * Generate contextual hints for user
     */
    private generateContextualHints;
    /**
     * Extract significant phrases from query
     */
    private extractSignificantPhrases;
    /**
     * Check if phrase is significant enough to be a pattern
     */
    private isSignificantPhrase;
    /**
     * Infer intent from query
     */
    private inferIntent;
    /**
     * Infer context from query and products
     */
    private inferContext;
    /**
     * Cleanup low-value patterns to stay under max limit
     */
    private cleanupLowValuePatterns;
    /**
     * Calculate pattern value for cleanup decisions
     */
    private calculatePatternValue;
    /**
     * Get recent feedback for analysis
     */
    private getRecentFeedback;
    /**
     * Get all feedback for analysis
     */
    private getAllFeedback;
    /**
     * Start cleanup timer for old data
     */
    private startCleanupTimer;
    /**
     * Cleanup old learning data
     */
    private cleanupOldData;
    /**
     * Cleanup resources
     */
    destroy(): void;
}
export declare const learningService: (logger: Logger) => LearningService;
//# sourceMappingURL=learning-service.d.ts.map