@hivetechs/hive-ai/dist/tools/analytics-engine.d.ts

Real-time streaming AI consensus platform with HTTP+SSE MCP integration for Claude Code, VS Code, Cursor, and Windsurf - powered by OpenRouter's unified API

/**
 * Professional Analytics Engine - Advanced business intelligence and reporting
 *
 * Provides comprehensive analytics, KPIs, business intelligence metrics,
 * and professional reporting capabilities for consensus pipeline analysis.
 */
export interface AnalyticsMetrics {
    timestamp: string;
    timeframe: string;
    businessKPIs: {
        totalQueries: number;
        successRate: number;
        averageQualityScore: number;
        costPerQuery: number;
        timeToFirstToken: number;
        customerSatisfactionIndex: number;
        consensusEffectivenessRatio: number;
        resourceUtilizationRate: number;
    };
    operational: {
        systemUptime: number;
        errorRate: number;
        throughputPerHour: number;
        averageResponseTime: number;
        peakConcurrentUsers: number;
        apiQuotaUtilization: number;
        memoryEfficiency: number;
        storageGrowthRate: number;
    };
    quality: {
        consensusVsSingleModelImprovement: number;
        hallucinationReductionRate: number;
        accuracyConsistencyScore: number;
        contextRetentionEffectiveness: number;
        expertiseRelevanceScore: number;
        outputCoherenceIndex: number;
        factualAccuracyRate: number;
        responseCompletenessScore: number;
    };
    cost: {
        totalSpend: number;
        budgetUtilization: number;
        costOptimizationOpportunities: number;
        modelEfficiencyRatio: number;
        pricePerformanceIndex: number;
        wasteReductionPotential: number;
        costTrendProjection: number;
        roiMeasurement: number;
    };
    userBehavior: {
        queryComplexityDistribution: Record<string, number>;
        popularQueryCategories: Record<string, number>;
        peakUsageHours: number[];
        averageSessionLength: number;
        repeatUsageRate: number;
        featureAdoptionRates: Record<string, number>;
        userRetentionMetrics: Record<string, number>;
        satisfactionTrendAnalysis: string;
    };
    technical: {
        modelReliabilityScores: Record<string, number>;
        apiLatencyBreakdown: Record<string, number>;
        errorClassification: Record<string, number>;
        systemBottleneckAnalysis: Record<string, any>;
        scalabilityMetrics: Record<string, number>;
        cacheHitRatio: number;
        networkEfficiency: number;
        dataProcessingSpeed: number;
    };
}
export interface AnalyticsReport {
    id: string;
    title: string;
    generatedAt: string;
    timeframe: string;
    reportType: 'executive' | 'operational' | 'technical' | 'financial' | 'quality';
    executiveSummary: {
        keyFindings: string[];
        criticalAlerts: string[];
        performanceHighlights: string[];
        improvementOpportunities: string[];
        budgetImpact: string;
        qualityTrend: string;
    };
    metrics: AnalyticsMetrics;
    charts: {
        performanceTrends: ChartData;
        costBreakdown: ChartData;
        qualityMetrics: ChartData;
        userBehavior: ChartData;
        systemHealth: ChartData;
    };
    recommendations: {
        immediate: RecommendationItem[];
        shortTerm: RecommendationItem[];
        longTerm: RecommendationItem[];
    };
    benchmarks: {
        industryStandards: Record<string, number>;
        previousPeriod: Record<string, number>;
        targetMetrics: Record<string, number>;
        competitiveAnalysis: Record<string, any>;
    };
}
export interface ChartData {
    type: 'line' | 'bar' | 'pie' | 'area' | 'scatter' | 'heatmap';
    title: string;
    data: any[];
    labels: string[];
    colors?: string[];
    options?: Record<string, any>;
}
export interface RecommendationItem {
    priority: 'critical' | 'high' | 'medium' | 'low';
    category: 'cost' | 'performance' | 'quality' | 'user_experience' | 'technical';
    title: string;
    description: string;
    expectedImpact: string;
    implementation: string;
    timeline: string;
    effort: string;
    roi: string;
}
export interface ExportOptions {
    format: 'json' | 'csv' | 'excel' | 'pdf' | 'html';
    includeCharts: boolean;
    includeRawData: boolean;
    timeframe?: string;
    sections?: string[];
    customFields?: string[];
}
export declare class AnalyticsEngine {
    private metricsCache;
    private reportsCache;
    private readonly CACHE_SIZE;
    private analyticsTimer;
    private isCollectionPaused;
    constructor();
    /**
     * Start continuous analytics collection
     */
    private startAnalyticsCollection;
    /**
     * Pause analytics collection during interactive sessions
     */
    pauseCollection(): void;
    /**
     * Resume analytics collection
     */
    resumeCollection(): void;
    /**
     * Stop analytics collection completely
     */
    stopCollection(): void;
    /**
     * Collect comprehensive analytics metrics
     */
    collectAnalyticsMetrics(timeframe?: string): Promise<AnalyticsMetrics>;
    /**
     * Generate comprehensive analytics report
     */
    generateAnalyticsReport(reportType: AnalyticsReport['reportType'], timeframe?: string, options?: Partial<ExportOptions>): Promise<AnalyticsReport>;
    /**
     * Export analytics data in various formats
     */
    exportAnalytics(reportId: string, options: ExportOptions): Promise<{
        content: string;
        filename: string;
        mimeType: string;
    }>;
    /**
     * Get business intelligence dashboard data
     */
    getBIDashboard(): Promise<{
        kpis: Record<string, any>;
        alerts: any[];
        trends: Record<string, any>;
        insights: string[];
    }>;
    /**
     * Private helper methods
     */
    private getPerformanceData;
    private getConversationData;
    private getCostData;
    private getQualityData;
    private calculateBusinessKPIs;
    private calculateOperationalMetrics;
    private calculateQualityMetrics;
    private calculateCostMetrics;
    private calculateUserBehaviorMetrics;
    private calculateTechnicalMetrics;
    private generateExecutiveSummary;
    private generateChartData;
    private generateRecommendations;
    private generateBenchmarks;
    private generateReportTitle;
    private generateAlerts;
    private analyzeTrends;
    private generateInsights;
    private exportAsJSON;
    private exportAsCSV;
    private exportAsExcel;
    private exportAsHTML;
    private exportAsPDF;
    private parseTimeframe;
    private addMetricsToCache;
    private addReportToCache;
    /**
     * Get cached metrics
     */
    getCachedMetrics(): AnalyticsMetrics[];
    /**
     * Get cached reports
     */
    getCachedReports(): AnalyticsReport[];
    /**
     * Clear caches
     */
    clearCaches(): void;
}
/**
 * Global analytics engine instance
 */
export declare const globalAnalyticsEngine: AnalyticsEngine;
//# sourceMappingURL=analytics-engine.d.ts.map