@re-shell/cli/dist/testing/coverage-tracking.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 CoverageTrackingConfig {
    projects: ProjectConfig[];
    thresholds: CoverageThresholds;
    reports: ReportConfig[];
    history?: HistoryConfig;
    notifications?: NotificationConfig;
    integrations?: IntegrationConfig[];
    aggregation?: AggregationConfig;
    badges?: BadgeConfig;
}
export interface ProjectConfig {
    name: string;
    path: string;
    type: 'unit' | 'integration' | 'e2e' | 'all';
    testCommand?: string;
    coverageCommand?: string;
    include?: string[];
    exclude?: string[];
    thresholds?: Partial<CoverageThresholds>;
    weight?: number;
}
export interface CoverageThresholds {
    statements: number;
    branches: number;
    functions: number;
    lines: number;
    overall: number;
}
export interface ReportConfig {
    format: 'html' | 'json' | 'lcov' | 'text' | 'cobertura' | 'teamcity' | 'clover';
    output: string;
    template?: string;
    options?: any;
}
export interface HistoryConfig {
    enabled: boolean;
    maxEntries?: number;
    storage: 'file' | 'database' | 'cloud';
    path?: string;
    retention?: number;
}
export interface NotificationConfig {
    thresholdViolations: boolean;
    improvements: boolean;
    regressions: boolean;
    channels: NotificationChannel[];
}
export interface NotificationChannel {
    type: 'email' | 'slack' | 'webhook' | 'github' | 'custom';
    config: any;
    events: string[];
}
export interface IntegrationConfig {
    type: 'sonarqube' | 'codecov' | 'coveralls' | 'codeclimate' | 'custom';
    config: any;
    enabled: boolean;
}
export interface AggregationConfig {
    strategy: 'weighted' | 'average' | 'minimum' | 'custom';
    weights?: Record<string, number>;
    customFunction?: string;
}
export interface BadgeConfig {
    enabled: boolean;
    path: string;
    style: 'flat' | 'flat-square' | 'plastic' | 'for-the-badge' | 'social';
    template?: string;
}
export interface CoverageResult {
    project: string;
    timestamp: Date;
    coverage: CoverageMetrics;
    files: FileCoverage[];
    summary: CoverageSummary;
    deltas?: CoverageDeltas;
    violations?: ThresholdViolation[];
    trends?: CoverageTrend[];
}
export interface CoverageMetrics {
    statements: CoverageMetric;
    branches: CoverageMetric;
    functions: CoverageMetric;
    lines: CoverageMetric;
    overall: number;
}
export interface CoverageMetric {
    total: number;
    covered: number;
    percentage: number;
    uncovered?: UncoveredItem[];
}
export interface UncoveredItem {
    file: string;
    line?: number;
    function?: string;
    branch?: string;
    reason?: string;
}
export interface FileCoverage {
    path: string;
    coverage: CoverageMetrics;
    size: number;
    complexity?: number;
    hotspots?: Hotspot[];
    status: 'excellent' | 'good' | 'fair' | 'poor';
}
export interface Hotspot {
    type: 'uncovered' | 'complex' | 'critical';
    location: string;
    severity: 'low' | 'medium' | 'high';
    description: string;
    suggestion: string;
}
export interface CoverageSummary {
    totalFiles: number;
    coveredFiles: number;
    totalLines: number;
    coveredLines: number;
    testDuration: number;
    testCount: number;
    performance: PerformanceMetrics;
}
export interface PerformanceMetrics {
    slowestTests: Array<{
        name: string;
        duration: number;
    }>;
    memoryUsage: number;
    cpuUsage: number;
    cacheHitRate?: number;
}
export interface CoverageDeltas {
    statements: number;
    branches: number;
    functions: number;
    lines: number;
    overall: number;
    files: FileDelta[];
}
export interface FileDelta {
    path: string;
    added: boolean;
    removed: boolean;
    coverageChange: number;
    status: 'improved' | 'degraded' | 'unchanged' | 'new' | 'removed';
}
export interface ThresholdViolation {
    metric: string;
    actual: number;
    expected: number;
    difference: number;
    severity: 'warning' | 'error' | 'critical';
    project?: string;
    file?: string;
}
export interface CoverageTrend {
    metric: string;
    direction: 'up' | 'down' | 'stable';
    rate: number;
    period: number;
    projection?: number;
}
export interface CoverageReport {
    summary: CoverageReportSummary;
    projects: CoverageResult[];
    aggregated: CoverageMetrics;
    trends: TrendAnalysis;
    insights: CoverageInsight[];
    recommendations: string[];
    badges: GeneratedBadge[];
    timestamp: Date;
}
export interface CoverageReportSummary {
    totalProjects: number;
    overallCoverage: number;
    trend: 'improving' | 'declining' | 'stable';
    violations: number;
    criticalIssues: number;
    lastUpdate: Date;
    duration: number;
}
export interface TrendAnalysis {
    historical: HistoricalTrend[];
    predictions: CoveragePrediction[];
    seasonality?: SeasonalPattern[];
    anomalies?: CoverageAnomaly[];
}
export interface HistoricalTrend {
    date: Date;
    coverage: number;
    tests: number;
    files: number;
    commit?: string;
    version?: string;
}
export interface CoveragePrediction {
    date: Date;
    predictedCoverage: number;
    confidence: number;
    factors: string[];
}
export interface SeasonalPattern {
    pattern: 'weekly' | 'monthly' | 'quarterly';
    impact: number;
    description: string;
}
export interface CoverageAnomaly {
    date: Date;
    type: 'spike' | 'drop' | 'outlier';
    magnitude: number;
    possibleCause?: string;
}
export interface CoverageInsight {
    type: 'improvement' | 'regression' | 'pattern' | 'recommendation';
    priority: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    data?: any;
    actionable: boolean;
    impact?: string;
}
export interface GeneratedBadge {
    type: 'coverage' | 'trend' | 'quality' | 'tests';
    url: string;
    markdown: string;
    html: string;
    svg: string;
}
export declare class CoverageTracking extends EventEmitter {
    private config;
    private results;
    private history;
    constructor(config: CoverageTrackingConfig);
    track(): Promise<CoverageReport>;
    private trackProject;
    private runCoverage;
    private getDefaultCoverageCommand;
    private findCoverageFiles;
    private parseCoverageData;
    private parseMetric;
    private extractUncovered;
    private parseFileCoverage;
    private getFileSize;
    private calculateComplexity;
    private identifyHotspots;
    private getCoverageStatus;
    private generateSummary;
    private calculateDeltas;
    private calculateFileDeltas;
    private getLastResult;
    private checkThresholds;
    private analyzeTrends;
    private calculateTrendDirection;
    private generateReport;
    private aggregateCoverage;
    private weightedAggregation;
    private averageAggregation;
    private minimumAggregation;
    private getOverallTrend;
    private countCriticalIssues;
    private generateInsights;
    private generateRecommendations;
    private generatePredictions;
    private detectAnomalies;
    private loadHistory;
    private updateHistory;
    private getCurrentCommit;
    private getCurrentVersion;
    private saveReports;
    private saveReport;
    private generateHtmlReport;
    private getCoverageClass;
    private generateTextReport;
    private sendNotifications;
    private sendNotification;
    private updateIntegrations;
    private updateIntegration;
    private generateBadges;
    private createCoverageBadge;
    private createTrendBadge;
    private calculateOverall;
    private createEmptyMetrics;
    private createEmptySummary;
}
export declare function createProjectConfig(name: string, path: string, options?: Partial<ProjectConfig>): ProjectConfig;
export declare function trackCoverage(config: CoverageTrackingConfig): Promise<CoverageReport>;