@re-shell/cli/dist/quality/performance-profiler.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';
import * as os from 'os';
export interface PerformanceProfileConfig {
    profileDuration?: number;
    sampleInterval?: number;
    includeMemoryProfile?: boolean;
    includeCpuProfile?: boolean;
    includeIOProfile?: boolean;
    includeNetworkProfile?: boolean;
    outputPath?: string;
    generateReport?: boolean;
    optimization?: OptimizationConfig;
    benchmarks?: BenchmarkConfig[];
    thresholds?: PerformanceThresholds;
}
export interface OptimizationConfig {
    analyzeBundleSize?: boolean;
    analyzeDependencies?: boolean;
    analyzeStartupTime?: boolean;
    analyzeMemoryUsage?: boolean;
    analyzeBuildTime?: boolean;
    generateRecommendations?: boolean;
}
export interface BenchmarkConfig {
    name: string;
    command: string;
    iterations?: number;
    warmupIterations?: number;
    timeout?: number;
    env?: Record<string, string>;
}
export interface PerformanceThresholds {
    cpuUsage: number;
    memoryUsage: number;
    startupTime: number;
    buildTime: number;
    bundleSize: number;
    networkLatency: number;
}
export interface PerformanceMetrics {
    timestamp: Date;
    duration: number;
    cpu: CpuMetrics;
    memory: MemoryMetrics;
    io: IOMetrics;
    network?: NetworkMetrics;
    process: ProcessMetrics;
    system: SystemMetrics;
}
export interface CpuMetrics {
    usage: number;
    userTime: number;
    systemTime: number;
    idleTime: number;
    loadAverage: number[];
    cores: number;
}
export interface MemoryMetrics {
    used: number;
    total: number;
    heap: HeapMetrics;
    external: number;
    rss: number;
    arrayBuffers: number;
}
export interface HeapMetrics {
    used: number;
    total: number;
    limit: number;
    available: number;
}
export interface IOMetrics {
    read: IOOperation;
    write: IOOperation;
    total: IOSummary;
}
export interface IOOperation {
    bytes: number;
    operations: number;
    time: number;
    throughput: number;
}
export interface IOSummary {
    bytes: number;
    operations: number;
    time: number;
    efficiency: number;
}
export interface NetworkMetrics {
    requests: number;
    totalBytes: number;
    averageLatency: number;
    errors: number;
    connections: number;
}
export interface ProcessMetrics {
    pid: number;
    ppid: number;
    startTime: Date;
    uptime: number;
    threads: number;
    handles: number;
}
export interface SystemMetrics {
    platform: string;
    arch: string;
    nodeVersion: string;
    v8Version: string;
    totalMemory: number;
    freeMemory: number;
    uptime: number;
    loadAverage: number[];
}
export interface PerformanceProfile {
    config: PerformanceProfileConfig;
    startTime: Date;
    endTime: Date;
    duration: number;
    metrics: PerformanceMetrics[];
    benchmarks: BenchmarkResult[];
    analysis: PerformanceAnalysis;
    optimizations: OptimizationRecommendation[];
    summary: PerformanceSummary;
}
export interface BenchmarkResult {
    name: string;
    command: string;
    iterations: number;
    results: BenchmarkIteration[];
    statistics: BenchmarkStatistics;
    baseline?: BenchmarkBaseline;
    regression?: RegressionAnalysis;
}
export interface BenchmarkIteration {
    iteration: number;
    duration: number;
    exitCode: number;
    memory: MemorySnapshot;
    cpu: number;
    success: boolean;
    error?: string;
}
export interface BenchmarkStatistics {
    mean: number;
    median: number;
    min: number;
    max: number;
    stdDev: number;
    variance: number;
    percentiles: Record<number, number>;
    successRate: number;
    throughput: number;
}
export interface BenchmarkBaseline {
    version: string;
    date: Date;
    mean: number;
    environment: string;
}
export interface RegressionAnalysis {
    significant: boolean;
    change: number;
    confidence: number;
    trend: 'improving' | 'degrading' | 'stable';
    pValue: number;
}
export interface MemorySnapshot {
    timestamp: Date;
    heap: HeapMetrics;
    rss: number;
    external: number;
    total: number;
}
export interface PerformanceAnalysis {
    bottlenecks: PerformanceBottleneck[];
    patterns: PerformancePattern[];
    trends: PerformanceTrend[];
    anomalies: PerformanceAnomaly[];
    efficiency: EfficiencyMetrics;
}
export interface PerformanceBottleneck {
    type: 'cpu' | 'memory' | 'io' | 'network' | 'startup' | 'build';
    severity: 'critical' | 'high' | 'medium' | 'low';
    description: string;
    impact: string;
    location?: string;
    metrics: Record<string, number>;
    recommendations: string[];
}
export interface PerformancePattern {
    name: string;
    frequency: number;
    impact: 'positive' | 'negative' | 'neutral';
    description: string;
    occurrences: PatternOccurrence[];
}
export interface PatternOccurrence {
    timestamp: Date;
    duration: number;
    context: string;
    metrics: Record<string, number>;
}
export interface PerformanceTrend {
    metric: string;
    direction: 'increasing' | 'decreasing' | 'stable';
    rate: number;
    confidence: number;
    significance: boolean;
    prediction?: TrendPrediction;
}
export interface TrendPrediction {
    timeframe: number;
    expectedValue: number;
    confidence: number;
    range: {
        min: number;
        max: number;
    };
}
export interface PerformanceAnomaly {
    timestamp: Date;
    type: 'spike' | 'drop' | 'outlier' | 'pattern_break';
    metric: string;
    value: number;
    expectedValue: number;
    deviation: number;
    severity: 'critical' | 'high' | 'medium' | 'low';
    description: string;
    possibleCauses: string[];
}
export interface EfficiencyMetrics {
    overall: number;
    cpu: number;
    memory: number;
    io: number;
    network?: number;
    improvement: number;
}
export interface OptimizationRecommendation {
    id: string;
    type: 'startup' | 'memory' | 'cpu' | 'io' | 'bundle' | 'dependency' | 'build' | 'network';
    priority: 'critical' | 'high' | 'medium' | 'low';
    title: string;
    description: string;
    impact: OptimizationImpact;
    effort: 'low' | 'medium' | 'high';
    implementation: OptimizationImplementation;
    benefits: string[];
    risks: string[];
    metrics: OptimizationMetrics;
}
export interface OptimizationImpact {
    performance: number;
    memory: number;
    size: number;
    speed: number;
}
export interface OptimizationImplementation {
    steps: string[];
    code?: string;
    config?: Record<string, any>;
    dependencies?: string[];
    automatizable: boolean;
    timeEstimate: string;
}
export interface OptimizationMetrics {
    before: Record<string, number>;
    after: Record<string, number>;
    improvement: Record<string, number>;
}
export interface PerformanceSummary {
    overall: PerformanceScore;
    categories: Record<string, PerformanceScore>;
    improvements: SummaryImprovement[];
    warnings: SummaryWarning[];
    achievements: SummaryAchievement[];
}
export interface PerformanceScore {
    score: number;
    grade: 'A' | 'B' | 'C' | 'D' | 'F';
    trend: 'improving' | 'degrading' | 'stable';
    change: number;
}
export interface SummaryImprovement {
    area: string;
    potential: number;
    effort: 'low' | 'medium' | 'high';
    impact: 'high' | 'medium' | 'low';
}
export interface SummaryWarning {
    severity: 'critical' | 'high' | 'medium' | 'low';
    message: string;
    metric: string;
    threshold: number;
    current: number;
}
export interface SummaryAchievement {
    title: string;
    description: string;
    metric: string;
    value: number;
}
export interface PerformanceReport {
    profile: PerformanceProfile;
    executive: ExecutiveSummary;
    technical: TechnicalDetails;
    actionPlan: ActionPlan;
    appendices: ReportAppendices;
    timestamp: Date;
}
export interface ExecutiveSummary {
    overallScore: number;
    keyFindings: string[];
    criticalIssues: number;
    potentialSavings: PotentialSavings;
    recommendations: ExecutiveRecommendation[];
}
export interface PotentialSavings {
    timeReduction: number;
    memoryReduction: number;
    costSavings: number;
    efficiencyGain: number;
}
export interface ExecutiveRecommendation {
    priority: 'critical' | 'high' | 'medium' | 'low';
    category: string;
    impact: string;
    effort: string;
    timeline: string;
    roi: number;
}
export interface TechnicalDetails {
    methodology: string;
    environment: EnvironmentInfo;
    dataCollection: DataCollectionInfo;
    analysis: AnalysisMethodology;
    limitations: string[];
}
export interface EnvironmentInfo {
    platform: string;
    nodeVersion: string;
    cpuInfo: os.CpuInfo[];
    memory: number;
    timestamp: Date;
}
export interface DataCollectionInfo {
    duration: number;
    sampleCount: number;
    sampleRate: number;
    metrics: string[];
}
export interface AnalysisMethodology {
    algorithms: string[];
    thresholds: PerformanceThresholds;
    statisticalMethods: string[];
    confidence: number;
}
export interface ActionPlan {
    immediate: ActionItem[];
    shortTerm: ActionItem[];
    longTerm: ActionItem[];
    monitoring: MonitoringPlan;
}
export interface ActionItem {
    id: string;
    title: string;
    description: string;
    priority: 'critical' | 'high' | 'medium' | 'low';
    effort: string;
    timeline: string;
    owner: string;
    dependencies: string[];
    success: SuccessCriteria;
}
export interface SuccessCriteria {
    metrics: string[];
    targets: Record<string, number>;
    validation: string[];
}
export interface MonitoringPlan {
    frequency: string;
    metrics: string[];
    alerts: AlertConfiguration[];
    reporting: ReportingSchedule;
}
export interface AlertConfiguration {
    metric: string;
    threshold: number;
    severity: 'critical' | 'high' | 'medium' | 'low';
    action: string;
}
export interface ReportingSchedule {
    frequency: 'daily' | 'weekly' | 'monthly' | 'quarterly';
    format: 'summary' | 'detailed' | 'executive';
    recipients: string[];
}
export interface ReportAppendices {
    rawData: PerformanceMetrics[];
    benchmarkData: BenchmarkResult[];
    statisticalAnalysis: StatisticalSummary;
    methodologyDetails: string;
}
export interface StatisticalSummary {
    sampleSize: number;
    confidence: number;
    margin: number;
    significance: number;
    correlations: CorrelationMatrix;
}
export interface CorrelationMatrix {
    [metric: string]: Record<string, number>;
}
export declare class PerformanceProfiler extends EventEmitter {
    private config;
    private startTime;
    private endTime;
    private metrics;
    private intervalId?;
    constructor(config?: PerformanceProfileConfig);
    profile(projectPath: string): Promise<PerformanceProfile>;
    private startMetricsCollection;
    private stopMetricsCollection;
    private collectMetrics;
    private collectCpuMetrics;
    private calculateCpuUsage;
    private collectMemoryMetrics;
    private getHeapLimit;
    private collectIOMetrics;
    private collectNetworkMetrics;
    private collectProcessMetrics;
    private collectSystemMetrics;
    private runBenchmarks;
    private runBenchmark;
    private executeBenchmarkIteration;
    private calculateBenchmarkStatistics;
    private loadBenchmarkBaseline;
    private analyzeRegression;
    private analyzePerformance;
    private identifyBottlenecks;
    private identifyPatterns;
    private analyzeMemoryGrowth;
    private analyzeTrends;
    private calculateTrend;
    private detectAnomalies;
    private calculateEfficiency;
    private generateOptimizations;
    private analyzeStartupOptimizations;
    private analyzeMemoryOptimizations;
    private analyzeBundleOptimizations;
    private analyzeDependencyOptimizations;
    private analyzeBuildOptimizations;
    private generateSummary;
    private calculateOverallScore;
    private calculateCategoryScore;
    private scoreToGrade;
    private generateImprovements;
    private generateWarnings;
    private getThresholdForType;
    private generateAchievements;
    generateReport(profile: PerformanceProfile): Promise<PerformanceReport>;
    private generateExecutiveSummary;
    private generateTechnicalDetails;
    private generateActionPlan;
    private optimizationToActionItem;
    private generateAppendices;
    private saveReport;
    private generateHtmlReport;
}
export declare function profilePerformance(projectPath: string, config?: Partial<PerformanceProfileConfig>): Promise<PerformanceReport>;
export declare function createBenchmark(name: string, command: string, options?: Partial<BenchmarkConfig>): BenchmarkConfig;