aiwg/dist/agentic/code/frameworks/sdlc-complete/src/testing/performance-profiler.d.ts

Deployment tool and support utility for AI context. Copies agents, skills, commands, rules, and behaviors into the paths each AI platform reads (Claude Code, Codex, Copilot, Cursor, Warp, OpenClaw, and 6 more) so one source of truth works across 10 platfo

/**
 * PerformanceProfiler - NFR performance measurement with statistical rigor
 *
 * Provides high-precision performance measurement, statistical analysis,
 * and memory profiling for validating NFR performance targets.
 *
 * Features:
 * - Sub-millisecond precision timing using performance.now()
 * - Statistical analysis (95th percentile, 95% confidence intervals)
 * - Outlier detection and filtering (IQR method)
 * - Memory profiling support
 * - Async operation support
 * - Comprehensive reporting
 *
 * @module testing/performance-profiler
 */
/**
 * Performance measurement result with statistical analysis
 */
export interface PerformanceResult {
    /** Arithmetic mean of all samples */
    mean: number;
    /** Median (50th percentile) of all samples */
    median: number;
    /** 95th percentile latency */
    p95: number;
    /** 99th percentile latency */
    p99: number;
    /** Minimum observed value */
    min: number;
    /** Maximum observed value */
    max: number;
    /** Standard deviation */
    stddev: number;
    /** 95% confidence interval [lower, upper] bounds */
    confidenceInterval: [number, number];
    /** Raw sample measurements (milliseconds) */
    samples: number[];
    /** Number of iterations performed */
    iterations: number;
    /** Number of outliers removed (if filtering enabled) */
    outliersRemoved?: number;
}
/**
 * Memory usage measurement result
 */
export interface MemoryResult {
    /** Heap memory used (bytes) */
    heapUsed: number;
    /** Total heap memory allocated (bytes) */
    heapTotal: number;
    /** External memory used (bytes) */
    external: number;
    /** ArrayBuffer memory used (bytes) */
    arrayBuffers: number;
}
/**
 * Configuration options for performance measurements
 */
export interface ProfilerOptions {
    /** Number of warmup iterations before measurement (default: 10) */
    warmupIterations?: number;
    /** Whether to filter outliers using IQR method (default: false) */
    filterOutliers?: boolean;
    /** Confidence level for confidence interval (default: 0.95) */
    confidenceLevel?: number;
}
/**
 * PerformanceProfiler - Measure and validate NFR performance targets
 *
 * @example
 * ```typescript
 * const profiler = new PerformanceProfiler();
 *
 * // Measure synchronous operation
 * const result = profiler.measureSync(() => {
 *   // Operation to measure
 * }, 1000);
 *
 * console.log(`P95 latency: ${result.p95.toFixed(3)}ms`);
 * console.log(`95% CI: [${result.confidenceInterval[0].toFixed(3)}, ${result.confidenceInterval[1].toFixed(3)}]ms`);
 * ```
 */
export declare class PerformanceProfiler {
    private options;
    constructor(options?: ProfilerOptions);
    /**
     * Measure synchronous operation performance
     *
     * @param fn - Function to measure
     * @param iterations - Number of measurement iterations
     * @returns Performance measurement results with statistics
     */
    measureSync(fn: () => void, iterations: number): PerformanceResult;
    /**
     * Measure asynchronous operation performance
     *
     * @param fn - Async function to measure
     * @param iterations - Number of measurement iterations
     * @returns Performance measurement results with statistics
     */
    measureAsync(fn: () => Promise<void>, iterations: number): Promise<PerformanceResult>;
    /**
     * Calculate specific percentile from samples
     *
     * @param samples - Array of measurements
     * @param percentile - Percentile to calculate (0-100)
     * @returns Percentile value
     */
    calculatePercentile(samples: number[], percentile: number): number;
    /**
     * Calculate confidence interval using t-distribution
     *
     * @param samples - Array of measurements
     * @param confidence - Confidence level (0-1)
     * @returns Confidence interval [lower, upper] bounds
     */
    calculateConfidenceInterval(samples: number[], confidence: number): [number, number];
    /**
     * Measure memory usage of an operation
     *
     * @param fn - Function to measure memory usage
     * @returns Memory usage statistics
     */
    measureMemory(fn: () => void): MemoryResult;
    /**
     * Generate formatted performance report
     *
     * @param results - Array of performance results to report
     * @returns Formatted report string
     */
    generateReport(results: PerformanceResult[]): string;
    /**
     * Analyze raw samples and compute statistics
     *
     * @private
     */
    private analyzeResults;
    /**
     * Filter outliers using IQR (Interquartile Range) method
     *
     * @private
     */
    private filterOutliers;
    /**
     * Calculate arithmetic mean
     *
     * @private
     */
    private calculateMean;
    /**
     * Calculate standard deviation
     *
     * @private
     */
    private calculateStdDev;
    /**
     * Get critical t-value for confidence interval
     * Uses approximation for large sample sizes
     *
     * @private
     */
    private getTCriticalValue;
}
//# sourceMappingURL=performance-profiler.d.ts.map