@re-shell/cli/dist/quality/ux-metrics-collector.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
export interface UXMetricsConfig {
    enableCollection?: boolean;
    anonymizeData?: boolean;
    collectionInterval?: number;
    storageLocation?: string;
    uploadEndpoint?: string;
    maxStorageSize?: number;
    retentionDays?: number;
    enableFeedback?: boolean;
    feedbackPrompts?: FeedbackPromptConfig[];
    analytics?: AnalyticsConfig;
}
export interface FeedbackPromptConfig {
    trigger: 'command_completion' | 'error_occurrence' | 'session_end' | 'periodic';
    frequency: number;
    conditions?: FeedbackCondition[];
    questions: FeedbackQuestion[];
}
export interface FeedbackCondition {
    type: 'command_count' | 'error_count' | 'session_duration' | 'user_segment';
    operator: 'gt' | 'lt' | 'eq' | 'gte' | 'lte';
    value: number | string;
}
export interface FeedbackQuestion {
    id: string;
    type: 'rating' | 'text' | 'multiple_choice' | 'boolean';
    question: string;
    options?: string[];
    required?: boolean;
    scale?: {
        min: number;
        max: number;
        labels?: string[];
    };
}
export interface AnalyticsConfig {
    trackCommands?: boolean;
    trackErrors?: boolean;
    trackPerformance?: boolean;
    trackFeatureUsage?: boolean;
    trackUserJourney?: boolean;
    customEvents?: string[];
}
export interface UserSession {
    sessionId: string;
    userId: string;
    startTime: Date;
    endTime?: Date;
    duration?: number;
    platform: string;
    nodeVersion: string;
    cliVersion: string;
    commands: CommandMetric[];
    errors: ErrorMetric[];
    performance: SessionPerformance;
    userAgent: UserAgent;
    context: SessionContext;
}
export interface CommandMetric {
    commandId: string;
    command: string;
    args: string[];
    flags: Record<string, any>;
    startTime: Date;
    endTime: Date;
    duration: number;
    success: boolean;
    exitCode: number;
    error?: string;
    performance: CommandPerformance;
    context: CommandContext;
}
export interface ErrorMetric {
    errorId: string;
    timestamp: Date;
    type: 'command_error' | 'system_error' | 'validation_error' | 'network_error';
    command?: string;
    message: string;
    stack?: string;
    context: ErrorContext;
    severity: 'low' | 'medium' | 'high' | 'critical';
    recoverable: boolean;
    userAction?: string;
}
export interface SessionPerformance {
    startupTime: number;
    memoryUsage: MemoryMetric[];
    cpuUsage: number[];
    commandLatencies: number[];
    averageResponseTime: number;
    peakMemoryUsage: number;
    totalCommands: number;
    errorRate: number;
}
export interface MemoryMetric {
    timestamp: Date;
    heapUsed: number;
    heapTotal: number;
    external: number;
    rss: number;
}
export interface CommandPerformance {
    executionTime: number;
    memoryDelta: number;
    cpuTime: number;
    ioOperations: number;
    networkRequests: number;
    cacheHits: number;
    cacheMisses: number;
}
export interface UserAgent {
    terminal: string;
    shell: string;
    terminalSize: {
        width: number;
        height: number;
    };
    colorSupport: boolean;
    interactiveMode: boolean;
    ciEnvironment?: string;
}
export interface SessionContext {
    workspaceType: 'monorepo' | 'single_project' | 'empty';
    projectSize: 'small' | 'medium' | 'large';
    packageManager: 'npm' | 'yarn' | 'pnpm' | 'bun' | 'unknown';
    gitRepository: boolean;
    hasConfigFile: boolean;
    workspaceCount: number;
    dependencyCount: number;
}
export interface CommandContext {
    workingDirectory: string;
    argumentCount: number;
    flagCount: number;
    isHelp: boolean;
    isVersion: boolean;
    hasOutput: boolean;
    outputLength: number;
    interactive: boolean;
}
export interface ErrorContext {
    workingDirectory: string;
    lastCommand?: string;
    userInput: string;
    systemState: SystemState;
    retryAttempts: number;
}
export interface SystemState {
    availableMemory: number;
    diskSpace: number;
    networkConnectivity: boolean;
    permissions: string[];
}
export interface UserFeedback {
    feedbackId: string;
    sessionId: string;
    userId: string;
    timestamp: Date;
    trigger: string;
    responses: FeedbackResponse[];
    context: FeedbackContext;
    sentiment: 'positive' | 'negative' | 'neutral';
    nps?: number;
    satisfaction?: number;
}
export interface FeedbackResponse {
    questionId: string;
    value: any;
    type: string;
}
export interface FeedbackContext {
    commandsExecuted: number;
    errorsEncountered: number;
    sessionDuration: number;
    userSegment: string;
    featureUsed: string[];
}
export interface UXAnalytics {
    timeframe: {
        start: Date;
        end: Date;
    };
    userMetrics: UserMetrics;
    commandMetrics: CommandAnalytics;
    errorMetrics: ErrorAnalytics;
    performanceMetrics: PerformanceAnalytics;
    feedbackMetrics: FeedbackAnalytics;
    usabilityMetrics: UsabilityMetrics;
    retentionMetrics: RetentionMetrics;
    satisfactionMetrics: SatisfactionMetrics;
}
export interface UserMetrics {
    totalUsers: number;
    activeUsers: number;
    newUsers: number;
    returningUsers: number;
    userSegments: UserSegment[];
    geographicDistribution: GeographicData[];
    platformDistribution: PlatformData[];
}
export interface UserSegment {
    segment: string;
    count: number;
    characteristics: Record<string, any>;
    behavior: SegmentBehavior;
}
export interface SegmentBehavior {
    averageSessionDuration: number;
    commandsPerSession: number;
    errorRate: number;
    featureAdoption: Record<string, number>;
    satisfaction: number;
}
export interface GeographicData {
    region: string;
    count: number;
    averagePerformance: number;
    topCommands: string[];
}
export interface PlatformData {
    platform: string;
    count: number;
    performance: PlatformPerformance;
    errorRate: number;
}
export interface PlatformPerformance {
    averageStartupTime: number;
    averageCommandTime: number;
    memoryEfficiency: number;
}
export interface CommandAnalytics {
    totalCommands: number;
    uniqueCommands: number;
    commandFrequency: CommandFrequency[];
    commandSuccess: CommandSuccessMetrics;
    commandPerformance: CommandPerformanceMetrics;
    commandSequences: CommandSequence[];
    abandonmentPoints: AbandonmentPoint[];
}
export interface CommandFrequency {
    command: string;
    count: number;
    percentage: number;
    trend: 'increasing' | 'decreasing' | 'stable';
}
export interface CommandSuccessMetrics {
    overallSuccessRate: number;
    commandSuccessRates: Record<string, number>;
    failureReasons: FailureReason[];
    retryPatterns: RetryPattern[];
}
export interface FailureReason {
    reason: string;
    count: number;
    commands: string[];
    impact: 'high' | 'medium' | 'low';
}
export interface RetryPattern {
    command: string;
    averageRetries: number;
    successAfterRetry: number;
    commonFixes: string[];
}
export interface CommandPerformanceMetrics {
    averageExecutionTime: Record<string, number>;
    performanceTrends: PerformanceTrend[];
    performanceIssues: PerformanceIssue[];
}
export interface PerformanceTrend {
    command: string;
    trend: 'improving' | 'degrading' | 'stable';
    change: number;
    timeframe: string;
}
export interface PerformanceIssue {
    command: string;
    issue: string;
    frequency: number;
    impact: string;
    recommendation: string;
}
export interface CommandSequence {
    sequence: string[];
    frequency: number;
    successRate: number;
    averageDuration: number;
    commonOutcomes: string[];
}
export interface AbandonmentPoint {
    step: string;
    abandonmentRate: number;
    reasons: string[];
    improvements: string[];
}
export interface ErrorAnalytics {
    totalErrors: number;
    errorRate: number;
    errorTypes: ErrorTypeMetrics[];
    errorTrends: ErrorTrend[];
    errorImpact: ErrorImpact;
    resolutionMetrics: ResolutionMetrics;
}
export interface ErrorTypeMetrics {
    type: string;
    count: number;
    percentage: number;
    averageResolutionTime: number;
    userImpact: string;
}
export interface ErrorTrend {
    type: string;
    trend: 'increasing' | 'decreasing' | 'stable';
    change: number;
    period: string;
}
export interface ErrorImpact {
    blockedUsers: number;
    lostSessions: number;
    supportTickets: number;
    productivityLoss: number;
}
export interface ResolutionMetrics {
    averageResolutionTime: number;
    selfServiceRate: number;
    escalationRate: number;
    resolutionMethods: ResolutionMethod[];
}
export interface ResolutionMethod {
    method: string;
    successRate: number;
    averageTime: number;
    userSatisfaction: number;
}
export interface PerformanceAnalytics {
    averageStartupTime: number;
    averageCommandTime: number;
    memoryEfficiency: number;
    performanceScores: PerformanceScore[];
    bottlenecks: PerformanceBottleneck[];
    improvements: PerformanceImprovement[];
}
export interface PerformanceScore {
    metric: string;
    score: number;
    benchmark: number;
    trend: 'improving' | 'degrading' | 'stable';
}
export interface PerformanceBottleneck {
    area: string;
    severity: 'high' | 'medium' | 'low';
    impact: string;
    frequency: number;
    recommendation: string;
}
export interface PerformanceImprovement {
    area: string;
    improvement: number;
    timeframe: string;
    impact: string;
}
export interface FeedbackAnalytics {
    responseRate: number;
    averageSatisfaction: number;
    npsScore: number;
    sentimentDistribution: SentimentDistribution;
    feedbackCategories: FeedbackCategory[];
    improvementSuggestions: ImprovementSuggestion[];
}
export interface SentimentDistribution {
    positive: number;
    negative: number;
    neutral: number;
}
export interface FeedbackCategory {
    category: string;
    frequency: number;
    averageSentiment: number;
    keyInsights: string[];
}
export interface ImprovementSuggestion {
    suggestion: string;
    frequency: number;
    priority: 'high' | 'medium' | 'low';
    feasibility: 'easy' | 'moderate' | 'difficult';
    impact: 'high' | 'medium' | 'low';
}
export interface UsabilityMetrics {
    easeOfUse: number;
    learnability: number;
    efficiency: number;
    memorability: number;
    errorPrevention: number;
    accessibility: AccessibilityMetrics;
    taskCompletion: TaskCompletionMetrics;
}
export interface AccessibilityMetrics {
    screenReaderCompatibility: number;
    colorBlindnessSupport: number;
    keyboardNavigation: number;
    textScaling: number;
    contrastRatio: number;
}
export interface TaskCompletionMetrics {
    overallCompletionRate: number;
    taskCompletionRates: Record<string, number>;
    averageTaskTime: Record<string, number>;
    taskDifficulty: Record<string, number>;
}
export interface RetentionMetrics {
    dailyActiveUsers: number;
    weeklyActiveUsers: number;
    monthlyActiveUsers: number;
    retentionRates: RetentionRate[];
    churnAnalysis: ChurnAnalysis;
    cohortAnalysis: CohortAnalysis[];
}
export interface RetentionRate {
    period: string;
    rate: number;
    trend: 'improving' | 'degrading' | 'stable';
}
export interface ChurnAnalysis {
    churnRate: number;
    churnReasons: ChurnReason[];
    riskFactors: RiskFactor[];
    preventionStrategies: string[];
}
export interface ChurnReason {
    reason: string;
    frequency: number;
    impact: string;
}
export interface RiskFactor {
    factor: string;
    riskScore: number;
    prevalence: number;
}
export interface CohortAnalysis {
    cohort: string;
    size: number;
    retentionByWeek: number[];
    characteristics: Record<string, any>;
}
export interface SatisfactionMetrics {
    overallSatisfaction: number;
    featureSatisfaction: Record<string, number>;
    satisfactionTrends: SatisfactionTrend[];
    satisfactionDrivers: SatisfactionDriver[];
    detractors: Detractor[];
}
export interface SatisfactionTrend {
    period: string;
    satisfaction: number;
    change: number;
    factors: string[];
}
export interface SatisfactionDriver {
    factor: string;
    impact: number;
    importance: number;
    currentPerformance: number;
}
export interface Detractor {
    issue: string;
    impact: number;
    frequency: number;
    userSegments: string[];
    solutions: string[];
}
export interface UXReport {
    summary: UXSummary;
    analytics: UXAnalytics;
    insights: UXInsights;
    recommendations: UXRecommendation[];
    actionPlan: UXActionPlan;
    timestamp: Date;
}
export interface UXSummary {
    timeframe: string;
    totalUsers: number;
    satisfaction: number;
    npsScore: number;
    errorRate: number;
    keyMetrics: KeyMetric[];
    highlights: string[];
    concerns: string[];
}
export interface KeyMetric {
    name: string;
    value: number;
    change: number;
    trend: 'up' | 'down' | 'stable';
    status: 'good' | 'warning' | 'critical';
}
export interface UXInsights {
    userBehavior: BehaviorInsight[];
    performanceInsights: PerformanceInsight[];
    usabilityInsights: UsabilityInsight[];
    satisfactionInsights: SatisfactionInsight[];
    opportunityAreas: OpportunityArea[];
}
export interface BehaviorInsight {
    insight: string;
    evidence: string[];
    impact: 'high' | 'medium' | 'low';
    userSegments: string[];
}
export interface PerformanceInsight {
    area: string;
    finding: string;
    impact: string;
    recommendation: string;
}
export interface UsabilityInsight {
    component: string;
    issue: string;
    userFriction: string;
    solution: string;
}
export interface SatisfactionInsight {
    driver: string;
    currentState: string;
    targetState: string;
    gap: string;
}
export interface OpportunityArea {
    area: string;
    opportunity: string;
    potentialImpact: string;
    effort: 'low' | 'medium' | 'high';
    priority: 'high' | 'medium' | 'low';
}
export interface UXRecommendation {
    id: string;
    category: 'usability' | 'performance' | 'accessibility' | 'engagement' | 'retention';
    priority: 'critical' | 'high' | 'medium' | 'low';
    title: string;
    description: string;
    rationale: string;
    expectedImpact: ExpectedImpact;
    implementation: ImplementationGuide;
    metrics: string[];
    successCriteria: string[];
}
export interface ExpectedImpact {
    satisfaction: number;
    efficiency: number;
    errorReduction: number;
    retention: number;
    adoption: number;
}
export interface ImplementationGuide {
    effort: 'low' | 'medium' | 'high';
    timeline: string;
    resources: string[];
    dependencies: string[];
    risks: string[];
    steps: ImplementationStep[];
}
export interface ImplementationStep {
    step: number;
    description: string;
    deliverable: string;
    timeline: string;
    owner: string;
}
export interface UXActionPlan {
    immediate: UXAction[];
    shortTerm: UXAction[];
    longTerm: UXAction[];
    monitoring: UXMonitoring;
}
export interface UXAction {
    id: string;
    title: string;
    description: string;
    owner: string;
    timeline: string;
    success: string[];
    dependencies: string[];
}
export interface UXMonitoring {
    metrics: string[];
    frequency: string;
    alerts: UXAlert[];
    reports: UXReportSchedule[];
}
export interface UXAlert {
    metric: string;
    threshold: number;
    severity: 'critical' | 'high' | 'medium';
    action: string;
}
export interface UXReportSchedule {
    type: string;
    frequency: string;
    recipients: string[];
    format: string;
}
export declare class UXMetricsCollector extends EventEmitter {
    private config;
    private currentSession;
    private storageLocation;
    private userId;
    constructor(config?: UXMetricsConfig);
    private generateUserId;
    private initializeStorage;
    private cleanupOldData;
    startSession(): Promise<UserSession>;
    endSession(): Promise<void>;
    trackCommand(command: string, args?: string[], flags?: Record<string, any>): Promise<string>;
    trackCommandCompletion(commandId: string, success: boolean, exitCode?: number, error?: string): Promise<void>;
    trackError(error: Error, command?: string, severity?: 'low' | 'medium' | 'high' | 'critical'): Promise<void>;
    collectFeedback(responses: FeedbackResponse[], trigger: string): Promise<void>;
    generateAnalytics(startDate: Date, endDate: Date): Promise<UXAnalytics>;
    generateReport(startDate: Date, endDate: Date): Promise<UXReport>;
    private createMockSession;
    private generateSessionId;
    private generateCommandId;
    private generateErrorId;
    private generateFeedbackId;
    private getCLIVersion;
    private collectUserAgent;
    private detectCIEnvironment;
    private collectSessionContext;
    private startPerformanceMonitoring;
    private calculateSessionPerformance;
    private classifyError;
    private isRecoverableError;
    private collectSystemState;
    private checkFeedbackPrompts;
    private shouldShowFeedbackPrompt;
    private evaluateCondition;
    private getUserSegment;
    private getUsedFeatures;
    private analyzeSentiment;
    private extractNPS;
    private extractSatisfaction;
    private saveSessionData;
    private saveFeedbackData;
    private loadSessionData;
    private loadFeedbackData;
    private analyzeUserMetrics;
    private analyzeCommandMetrics;
    private analyzeErrorMetrics;
    private analyzePerformanceMetrics;
    private analyzeFeedbackMetrics;
    private analyzeUsabilityMetrics;
    private analyzeRetentionMetrics;
    private analyzeSatisfactionMetrics;
    private generateInsights;
    private generateRecommendations;
    private generateActionPlan;
    private recommendationToAction;
    private generateSummary;
    private saveReport;
    private generateHtmlReport;
}
export declare function collectUXMetrics(config?: Partial<UXMetricsConfig>): Promise<UXMetricsCollector>;
export declare function generateUXReport(startDate: Date, endDate: Date, config?: Partial<UXMetricsConfig>): Promise<UXReport>;