codecrucible-synth/dist/core/analytics/performance-optimizer.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

export interface PerformanceMetric {
    operation: string;
    count: number;
    totalDuration: number;
    successCount: number;
    averageDuration: number;
    successRate: number;
    lastExecuted: number;
    errorPatterns: Map<string, number>;
    performanceProfile: {
        fastest: number;
        slowest: number;
        median: number;
        percentile95: number;
    };
}
export interface OptimizationSuggestion {
    type: 'performance' | 'reliability' | 'efficiency' | 'user_experience';
    operation: string;
    issue: string;
    suggestion: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    estimatedImpact: number;
    confidence: number;
    implementationEffort: 'easy' | 'medium' | 'hard';
}
export interface LearningPattern {
    id: string;
    pattern: string;
    context: any;
    frequency: number;
    successRate: number;
    averagePerformance: number;
    lastSeen: number;
    confidence: number;
    metadata: {
        tags: string[];
        category: string;
        userBehavior?: string;
    };
}
export interface SessionAnalytics {
    sessionId: string;
    startTime: number;
    endTime?: number;
    totalOperations: number;
    successfulOperations: number;
    failedOperations: number;
    averageResponseTime: number;
    userSatisfactionScore?: number;
    voiceUsageStats: Record<string, number>;
    toolUsageStats: Record<string, number>;
    patterns: LearningPattern[];
    suggestions: OptimizationSuggestion[];
}
/**
 * Performance Optimizer and Analytics System
 *
 * Provides comprehensive performance monitoring, learning, and optimization
 * capabilities following the patterns from the Agentic CLI guide.
 */
export declare class PerformanceOptimizer {
    private metrics;
    private patterns;
    private suggestions;
    private currentSession;
    private persistencePath;
    private learningEnabled;
    private optimizationThresholds;
    constructor(persistencePath?: string);
    /**
     * Record a performance metric for an operation
     */
    recordMetric(operation: string, duration: number, success: boolean, errorMessage?: string, context?: any): void;
    /**
     * Get optimization suggestions based on collected metrics
     */
    getOptimizationSuggestions(): OptimizationSuggestion[];
    /**
     * Optimize model selection based on historical performance
     */
    optimizeModelSelection(taskType: string, context?: any): {
        recommendedModel: string;
        alternativeModels: string[];
        reasoning: string;
        confidence: number;
    };
    /**
     * Optimize tool selection based on success rates and performance
     */
    optimizeToolSelection(objective: string, context?: any): {
        recommendedTools: string[];
        alternativeApproaches: string[];
        reasoning: string;
        confidence: number;
    };
    /**
     * Learn patterns from successful executions
     */
    private learnFromExecution;
    /**
     * Generate comprehensive optimization suggestions
     */
    private generateOptimizationSuggestions;
    /**
     * Analyze individual operation performance
     */
    private analyzeOperationPerformance;
    /**
     * Analyze learned patterns for optimization opportunities
     */
    private analyzePatterns;
    /**
     * Analyze session-level optimization opportunities
     */
    private analyzeSessionOptimizations;
    /**
     * Helper methods for suggestion generation
     */
    private generatePerformanceSuggestion;
    private generateReliabilitySuggestion;
    private generateEfficiencySuggestion;
    private estimateImplementationEffort;
    /**
     * Pattern analysis and model/tool optimization
     */
    private findRelevantPatterns;
    private analyzeModelPerformance;
    private analyzeToolPerformance;
    private generateModelRecommendation;
    private generateToolRecommendation;
    /**
     * Utility methods
     */
    private extractPattern;
    private extractErrorPattern;
    private calculatePatternConfidence;
    private createEmptyMetric;
    private updatePerformanceProfile;
    private updateSessionAnalytics;
    private checkForOptimizationOpportunities;
    private createNewSession;
    private initializeAnalytics;
    /**
     * Public API methods
     */
    /**
     * Get current performance metrics
     */
    getMetrics(): PerformanceMetric[];
    /**
     * Get learned patterns
     */
    getPatterns(): LearningPattern[];
    /**
     * Get current session analytics
     */
    getSessionAnalytics(): SessionAnalytics;
    /**
     * Save analytics to persistent storage
     */
    saveAnalytics(): Promise<void>;
    /**
     * Load analytics from persistent storage
     */
    loadAnalytics(): Promise<void>;
    /**
     * Reset all analytics data
     */
    resetAnalytics(): void;
    /**
     * Enable or disable learning
     */
    setLearningEnabled(enabled: boolean): void;
    /**
     * Start a new session
     */
    startNewSession(): string;
}
//# sourceMappingURL=performance-optimizer.d.ts.map