qa360 1.4.5 → 2.0.1

package/dist/core/vault/index.js

@@ -124,6 +124,201 @@ export class EvidenceVault {
         console.log(`[VAULT] FINDING_RECORDED: ${runId}/${finding.gate} (severity: ${finding.severity}, rule: ${finding.rule})`);
         return findingId;
     }
+    /**
+     * Record flakiness analysis result
+     */
+    async recordFlakiness(runId, flakiness) {
+        const flakinessRecord = {
+            run_id: runId,
+            created_at: Date.now(),
+            ...flakiness
+        };
+        const flakinessId = await this.insertFlakiness(flakinessRecord);
+        console.log(`[VAULT] FLAKINESS_RECORDED: ${runId}/${flakiness.test_name} (score: ${flakiness.score}, category: ${flakiness.category})`);
+        return flakinessId;
+    }
+    /**
+     * Record detected flakiness pattern
+     */
+    async recordFlakinessPattern(pattern) {
+        const now = Date.now();
+        // Check if pattern already exists for this test
+        const existing = await this.getFlakinessPattern(pattern.test_id, pattern.pattern_type);
+        if (existing) {
+            // Update existing pattern
+            await this.updateFlakinessPattern(existing.id, {
+                last_detected: now,
+                detection_count: (existing.detection_count || 0) + 1,
+                updated_at: now
+            });
+            console.log(`[VAULT] FLAKY_PATTERN_UPDATED: ${pattern.test_name} (${pattern.pattern_type})`);
+            return existing.id;
+        }
+        // Insert new pattern
+        const patternRecord = {
+            first_detected: now,
+            last_detected: now,
+            detection_count: 1,
+            created_at: now,
+            updated_at: now,
+            ...pattern
+        };
+        const patternId = await this.insertFlakinessPattern(patternRecord);
+        console.log(`[VAULT] FLAKY_PATTERN_DETECTED: ${pattern.test_name} (${pattern.pattern_type})`);
+        return patternId;
+    }
+    /**
+     * Add test to quarantine
+     */
+    async addToQuarantine(quarantine) {
+        const now = Date.now();
+        // Check if already in quarantine
+        const existing = await this.getQuarantine(quarantine.test_id);
+        if (existing && !existing.resolved_at) {
+            console.log(`[VAULT] ALREADY_IN_QUARANTINE: ${quarantine.test_name}`);
+            return existing.id;
+        }
+        const quarantineRecord = {
+            created_at: now,
+            updated_at: now,
+            ...quarantine
+        };
+        const quarantineId = await this.insertQuarantine(quarantineRecord);
+        console.log(`[VAULT] QUARANTINED: ${quarantine.test_name} (${quarantine.category})`);
+        return quarantineId;
+    }
+    /**
+     * Remove test from quarantine
+     */
+    async removeFromQuarantine(testId, resolvedBy, notes) {
+        await this.updateQuarantine(testId, {
+            resolved_at: Date.now(),
+            resolved_by: resolvedBy,
+            notes,
+            updated_at: Date.now()
+        });
+        console.log(`[VAULT] QUARANTINE_REMOVED: ${testId} (by: ${resolvedBy})`);
+    }
+    /**
+     * Get flakiness history for a test
+     */
+    async getFlakinessHistory(testId, limit = 50) {
+        return new Promise((resolve, reject) => {
+            this.db.all(`SELECT * FROM flakiness_history WHERE test_id = ? ORDER BY created_at DESC LIMIT ?`, [testId, limit], (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    /**
+     * Get flakiness history for a run
+     */
+    async getRunFlakiness(runId) {
+        return new Promise((resolve, reject) => {
+            this.db.all(`SELECT * FROM flakiness_history WHERE run_id = ? ORDER BY score ASC`, [runId], (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    /**
+     * Get all quarantined tests
+     */
+    async getQuarantinedTests(includeResolved = false) {
+        let query = 'SELECT * FROM flakiness_quarantine WHERE 1=1';
+        const params = [];
+        if (!includeResolved) {
+            query += ' AND resolved_at IS NULL';
+        }
+        query += ' ORDER BY quarantined_at DESC';
+        return new Promise((resolve, reject) => {
+            this.db.all(query, params, (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    /**
+     * Get quarantine record for a test
+     */
+    async getQuarantine(testId) {
+        return new Promise((resolve, reject) => {
+            this.db.get('SELECT * FROM flakiness_quarantine WHERE test_id = ? ORDER BY created_at DESC LIMIT 1', [testId], (err, row) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(row || null);
+            });
+        });
+    }
+    /**
+     * Get flakiness pattern for a test
+     */
+    async getFlakinessPattern(testId, patternType) {
+        return new Promise((resolve, reject) => {
+            this.db.get('SELECT * FROM flakiness_patterns WHERE test_id = ? AND pattern_type = ?', [testId, patternType], (err, row) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(row || null);
+            });
+        });
+    }
+    /**
+     * Get flakiness trends for a test
+     */
+    async getFlakinessTrends(testId, days = 30) {
+        const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
+        return new Promise((resolve, reject) => {
+            this.db.all(`SELECT created_at, score FROM flakiness_history WHERE test_id = ? AND created_at >= ? ORDER BY created_at ASC`, [testId, cutoff], (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    const rawPoints = rows;
+                    // Convert to expected format with 'date' property
+                    const dataPoints = rawPoints.map(p => ({ date: p.created_at, score: p.score }));
+                    if (dataPoints.length === 0) {
+                        resolve({
+                            testId,
+                            currentScore: 100,
+                            averageScore: 100,
+                            trend: 'stable',
+                            dataPoints: []
+                        });
+                        return;
+                    }
+                    const currentScore = dataPoints[dataPoints.length - 1].score;
+                    const averageScore = Math.round(dataPoints.reduce((sum, p) => sum + p.score, 0) / dataPoints.length);
+                    // Calculate trend
+                    let trend = 'stable';
+                    if (dataPoints.length >= 3) {
+                        const recent = dataPoints.slice(-3);
+                        const older = dataPoints.slice(0, -3);
+                        const recentAvg = recent.reduce((sum, p) => sum + p.score, 0) / recent.length;
+                        const olderAvg = older.reduce((sum, p) => sum + p.score, 0) / older.length;
+                        if (recentAvg > olderAvg + 5)
+                            trend = 'improving';
+                        else if (recentAvg < olderAvg - 5)
+                            trend = 'degrading';
+                    }
+                    resolve({
+                        testId,
+                        currentScore,
+                        averageScore,
+                        trend,
+                        dataPoints
+                    });
+                }
+            });
+        });
+    }
     /**
      * Store artifact in CAS and link to run
      */
@@ -433,6 +628,69 @@ export class EvidenceVault {
             });
         });
     }
+    async insertFlakiness(flakiness) {
+        const fields = Object.keys(flakiness).join(', ');
+        const placeholders = Object.keys(flakiness).map(() => '?').join(', ');
+        const values = Object.values(flakiness);
+        return new Promise((resolve, reject) => {
+            this.db.run(`INSERT INTO flakiness_history (${fields}) VALUES (${placeholders})`, values, function (err) {
+                if (err)
+                    reject(err);
+                else
+                    resolve(this.lastID);
+            });
+        });
+    }
+    async insertFlakinessPattern(pattern) {
+        const fields = Object.keys(pattern).join(', ');
+        const placeholders = Object.keys(pattern).map(() => '?').join(', ');
+        const values = Object.values(pattern);
+        return new Promise((resolve, reject) => {
+            this.db.run(`INSERT INTO flakiness_patterns (${fields}) VALUES (${placeholders})`, values, function (err) {
+                if (err)
+                    reject(err);
+                else
+                    resolve(this.lastID);
+            });
+        });
+    }
+    async updateFlakinessPattern(id, updates) {
+        const fields = Object.keys(updates).map(key => `${key} = ?`).join(', ');
+        const values = [...Object.values(updates), id];
+        return new Promise((resolve, reject) => {
+            this.db.run(`UPDATE flakiness_patterns SET ${fields} WHERE id = ?`, values, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    async insertQuarantine(quarantine) {
+        const fields = Object.keys(quarantine).join(', ');
+        const placeholders = Object.keys(quarantine).map(() => '?').join(', ');
+        const values = Object.values(quarantine);
+        return new Promise((resolve, reject) => {
+            this.db.run(`INSERT INTO flakiness_quarantine (${fields}) VALUES (${placeholders})`, values, function (err) {
+                if (err)
+                    reject(err);
+                else
+                    resolve(this.lastID);
+            });
+        });
+    }
+    async updateQuarantine(testId, updates) {
+        const fields = Object.keys(updates).map(key => `${key} = ?`).join(', ');
+        const values = [...Object.values(updates), testId];
+        return new Promise((resolve, reject) => {
+            this.db.run(`UPDATE flakiness_quarantine SET ${fields} WHERE test_id = ?`, values, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
     generateFindingFingerprint(finding) {
         const content = `${finding.gate}:${finding.rule}:${finding.location || ''}:${finding.message}`;
         return createHash('sha256').update(content).digest('hex').substring(0, 16);
@@ -525,6 +783,66 @@ CREATE TABLE IF NOT EXISTS run_artifacts (
     PRIMARY KEY (run_id, sha256, label)
 );
 
+-- Flakiness history table: tracks test reliability over time
+CREATE TABLE IF NOT EXISTS flakiness_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+    test_id TEXT NOT NULL,
+    test_name TEXT NOT NULL,
+    gate TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    score INTEGER NOT NULL CHECK (score >= 0 AND score <= 100),
+    category TEXT NOT NULL CHECK (category IN ('legendary', 'solid', 'good', 'shaky', 'unstable')),
+    total_runs INTEGER NOT NULL,
+    successful_runs INTEGER NOT NULL,
+    avg_duration_ms INTEGER NOT NULL,
+    pattern_type TEXT,
+    suggested_fix TEXT,
+    confidence REAL,
+    first_seen INTEGER NOT NULL,
+    last_seen INTEGER NOT NULL,
+    current_streak INTEGER,
+    streak_type TEXT CHECK (streak_type IN ('pass', 'fail')),
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+-- Flakiness patterns table: detected patterns for flaky tests
+CREATE TABLE IF NOT EXISTS flakiness_patterns (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    test_id TEXT NOT NULL,
+    test_name TEXT NOT NULL,
+    pattern_type TEXT NOT NULL CHECK (pattern_type IN ('timing', 'race_condition', 'external_dependency', 'environment_specific', 'selector_issue', 'unknown')),
+    description TEXT NOT NULL,
+    suggested_fix TEXT NOT NULL,
+    confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+    auto_fix_possible INTEGER NOT NULL DEFAULT 0,
+    first_detected INTEGER NOT NULL,
+    last_detected INTEGER NOT NULL,
+    detection_count INTEGER NOT NULL DEFAULT 1,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+    updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+    UNIQUE(test_id, pattern_type)
+);
+
+-- Flakiness quarantine table: tests quarantined for flakiness
+CREATE TABLE IF NOT EXISTS flakiness_quarantine (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    test_id TEXT NOT NULL UNIQUE,
+    test_name TEXT NOT NULL,
+    gate TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    score INTEGER NOT NULL CHECK (score >= 0 AND score <= 100),
+    category TEXT NOT NULL CHECK (category IN ('shaky', 'unstable')),
+    quarantined_at INTEGER NOT NULL,
+    quarantined_by TEXT NOT NULL,
+    resolved_at INTEGER,
+    resolved_by TEXT,
+    notes TEXT,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+    updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
 -- Vault metadata table: schema version and configuration
 CREATE TABLE IF NOT EXISTS vault_metadata (
     key TEXT PRIMARY KEY,
@@ -559,14 +877,30 @@ CREATE INDEX IF NOT EXISTS idx_run_artifacts_run_id ON run_artifacts(run_id);
 CREATE INDEX IF NOT EXISTS idx_run_artifacts_sha256 ON run_artifacts(sha256);
 CREATE INDEX IF NOT EXISTS idx_run_artifacts_label ON run_artifacts(label);
 
+-- Flakiness indexes
+CREATE INDEX IF NOT EXISTS idx_flakiness_run_id ON flakiness_history(run_id);
+CREATE INDEX IF NOT EXISTS idx_flakiness_test_id ON flakiness_history(test_id);
+CREATE INDEX IF NOT EXISTS idx_flakiness_score ON flakiness_history(score);
+CREATE INDEX IF NOT EXISTS idx_flakiness_category ON flakiness_history(category);
+CREATE INDEX IF NOT EXISTS idx_flakiness_created_at ON flakiness_history(created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_flaky_patterns_test_id ON flakiness_patterns(test_id);
+CREATE INDEX IF NOT EXISTS idx_flaky_patterns_pattern_type ON flakiness_patterns(pattern_type);
+CREATE INDEX IF NOT EXISTS idx_flaky_patterns_detection_count ON flakiness_patterns(detection_count DESC);
+
+CREATE INDEX IF NOT EXISTS idx_quarantine_test_id ON flakiness_quarantine(test_id);
+CREATE INDEX IF NOT EXISTS idx_quarantine_quarantined_at ON flakiness_quarantine(quarantined_at DESC);
+CREATE INDEX IF NOT EXISTS idx_quarantine_resolved_at ON flakiness_quarantine(resolved_at);
+CREATE INDEX IF NOT EXISTS idx_quarantine_category ON flakiness_quarantine(category);
+
 -- Insert initial metadata
-INSERT OR IGNORE INTO vault_metadata (key, value) VALUES 
-    ('schema_version', '1.0.0'),
+INSERT OR IGNORE INTO vault_metadata (key, value) VALUES
+    ('schema_version', '2.0.0'),
     ('created_at', strftime('%s', 'now') * 1000),
-    ('vault_format', 'qa360-evidence-vault-v1');
+    ('vault_format', 'qa360-evidence-vault-v2');
 
 -- Triggers for updated_at timestamps
-CREATE TRIGGER IF NOT EXISTS trigger_runs_updated_at 
+CREATE TRIGGER IF NOT EXISTS trigger_runs_updated_at
     AFTER UPDATE ON runs
     BEGIN
         UPDATE runs SET updated_at = strftime('%s', 'now') * 1000 WHERE id = NEW.id;
@@ -578,6 +912,18 @@ CREATE TRIGGER IF NOT EXISTS trigger_artifacts_last_accessed
         UPDATE artifacts SET last_accessed = strftime('%s', 'now') * 1000 WHERE sha256 = NEW.sha256;
     END;
 
+CREATE TRIGGER IF NOT EXISTS trigger_flakiness_patterns_updated_at
+    AFTER UPDATE ON flakiness_patterns
+    BEGIN
+        UPDATE flakiness_patterns SET updated_at = strftime('%s', 'now') * 1000 WHERE id = NEW.id;
+    END;
+
+CREATE TRIGGER IF NOT EXISTS trigger_quarantine_updated_at
+    AFTER UPDATE ON flakiness_quarantine
+    BEGIN
+        UPDATE flakiness_quarantine SET updated_at = strftime('%s', 'now') * 1000 WHERE id = NEW.id;
+    END;
+
 -- Views for common queries
 CREATE VIEW IF NOT EXISTS v_recent_runs AS
 SELECT 
@@ -600,7 +946,7 @@ GROUP BY r.id
 ORDER BY r.started_at DESC;
 
 CREATE VIEW IF NOT EXISTS v_gate_trends AS
-SELECT 
+SELECT
     g.name,
     g.status,
     r.started_at,
@@ -611,6 +957,55 @@ FROM gates g
 JOIN runs r ON g.run_id = r.id
 WHERE r.status IN ('passed', 'failed')
 ORDER BY r.started_at DESC;
+
+-- Flakiness summary view: aggregate flakiness stats by test
+CREATE VIEW IF NOT EXISTS v_flakiness_summary AS
+SELECT
+    test_id,
+    test_name,
+    gate,
+    file_path,
+    MAX(score) as latest_score,
+    MIN(score) as worst_score,
+    AVG(score) as avg_score,
+    COUNT(*) as total_analyses,
+    MAX(category) as latest_category,
+    MAX(last_seen) as last_analyzed,
+    MAX(first_seen) as first_seen
+FROM flakiness_history
+GROUP BY test_id, test_name, gate, file_path
+ORDER BY latest_score ASC;
+
+-- Flakiness trends view: time series analysis
+CREATE VIEW IF NOT EXISTS v_flakiness_trends AS
+SELECT
+    DATE(created_at / 1000, 'unixepoch') as analysis_date,
+    category,
+    COUNT(*) as test_count,
+    AVG(score) as avg_score
+FROM flakiness_history
+WHERE created_at >= strftime('%s', 'now', '-30 days') * 1000
+GROUP BY analysis_date, category
+ORDER BY analysis_date DESC, category DESC;
+
+-- Quarantined tests view
+CREATE VIEW IF NOT EXISTS v_quarantined_tests AS
+SELECT
+    q.*,
+    fh.score as current_score,
+    fh.category as current_category
+FROM flakiness_quarantine q
+LEFT JOIN (
+    SELECT test_id, score, category
+    FROM flakiness_history fh1
+    WHERE fh1.created_at = (
+        SELECT MAX(fh2.created_at)
+        FROM flakiness_history fh2
+        WHERE fh2.test_id = fh1.test_id
+    )
+) fh ON q.test_id = fh.test_id
+WHERE q.resolved_at IS NULL
+ORDER BY q.quarantined_at DESC;
 `;
         return new Promise((resolve, reject) => {
             this.db.exec(schema, (err) => {

package/dist/core/watch/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * QA360 Watch Module
+ *
+ * Continuous testing and benchmarking capabilities.
+ */
+export { WatchMode, createWatchMode } from './watch-mode.js';
+export type { WatchModeOptions, WatchRunResult, WatchStats, BenchmarkConfig, BenchmarkResult } from './watch-mode.js';

package/dist/core/watch/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Watch Module
+ *
+ * Continuous testing and benchmarking capabilities.
+ */
+export { WatchMode, createWatchMode } from './watch-mode.js';

package/dist/core/watch/watch-mode.d.ts

@@ -0,0 +1,213 @@
+/**
+ * QA360 Watch Mode
+ *
+ * Continuous testing mode that monitors file changes and re-runs tests.
+ * Features:
+ * - File watching with debounce
+ * - Smart test selection based on changed files
+ * - Benchmark mode for performance comparison
+ * - Statistics aggregation across runs
+ *
+ * @example
+ * ```typescript
+ * const watcher = new WatchMode({
+ *   workingDir: process.cwd(),
+ *   debounceMs: 300,
+ *   onRunStart: () => console.log('Running tests...'),
+ *   onRunComplete: (result) => console.log('Done:', result)
+ * });
+ *
+ * await watcher.start();
+ * ```
+ */
+import { type Phase3RunResult } from '../runner/phase3-runner.js';
+/**
+ * Watch mode configuration options
+ */
+export interface WatchModeOptions {
+    /** Working directory for tests */
+    workingDir: string;
+    /** Path to pack.yml file */
+    packPath?: string;
+    /** Debounce delay in milliseconds (default: 300) */
+    debounceMs?: number;
+    /** Patterns to ignore (default: node_modules, .git, dist) */
+    ignore?: string[];
+    /** Whether to run initial test on start (default: true) */
+    runOnStart?: boolean;
+    /** Whether to clear screen between runs (default: true) */
+    clearScreen?: boolean;
+    /** Callback when a run starts */
+    onRunStart?: (runNumber: number) => void;
+    /** Callback when a run completes */
+    onRunComplete?: (result: WatchRunResult) => void;
+    /** Callback when a file changes */
+    onFileChange?: (path: string) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result of a single watch run
+ */
+export interface WatchRunResult {
+    /** Run number (incrementing) */
+    runNumber: number;
+    /** Timestamp when run started */
+    startedAt: Date;
+    /** Timestamp when run completed */
+    completedAt: Date;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Phase3Runner result */
+    result: Phase3RunResult;
+    /** Files that triggered this run */
+    changedFiles: string[];
+    /** Whether this run was successful */
+    success: boolean;
+}
+/**
+ * Aggregated statistics across watch runs
+ */
+export interface WatchStats {
+    /** Total number of runs */
+    totalRuns: number;
+    /** Number of successful runs */
+    successfulRuns: number;
+    /** Number of failed runs */
+    failedRuns: number;
+    /** Average duration in milliseconds */
+    avgDuration: number;
+    /** Fastest run duration */
+    fastestRun: number;
+    /** Slowest run duration */
+    slowestRun: number;
+    /** Total duration of all runs */
+    totalDuration: number;
+    /** Trust score average */
+    avgTrustScore: number;
+    /** Total tests executed */
+    totalTests: number;
+    /** Total passed tests */
+    totalPassed: number;
+    /** Total failed tests */
+    totalFailed: number;
+}
+/**
+ * Benchmark configuration
+ */
+export interface BenchmarkConfig {
+    /** Number of iterations to run */
+    iterations: number;
+    /** Warm-up iterations (not counted in stats) */
+    warmupIterations: number;
+    /** Whether to run with cache enabled */
+    withCache: boolean;
+    /** Whether to run in parallel */
+    parallel?: boolean;
+}
+/**
+ * Benchmark result
+ */
+export interface BenchmarkResult {
+    /** Average duration across iterations */
+    avgDuration: number;
+    /** Minimum duration */
+    minDuration: number;
+    /** Maximum duration */
+    maxDuration: number;
+    /** Standard deviation */
+    stdDev: number;
+    /** Median duration */
+    median: number;
+    /** P95 duration */
+    p95: number;
+    /** P99 duration */
+    p99: number;
+    /** Number of successful runs */
+    successfulRuns: number;
+    /** Total iterations */
+    totalIterations: number;
+    /** Throughput (runs per second) */
+    throughput: number;
+}
+/**
+ * Watch Mode Manager
+ *
+ * Monitors file changes and runs tests automatically.
+ */
+export declare class WatchMode {
+    private options;
+    private watchers;
+    private runNumber;
+    private isRunning;
+    private debounceTimer?;
+    private pendingChanges;
+    private runResults;
+    private stats;
+    private packConfig?;
+    constructor(options: WatchModeOptions);
+    /**
+     * Start watching files and running tests
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching files
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current statistics
+     */
+    getStats(): WatchStats;
+    /**
+     * Get run history
+     */
+    getRunHistory(): WatchRunResult[];
+    /**
+     * Run benchmark tests
+     */
+    benchmark(config: BenchmarkConfig): Promise<BenchmarkResult>;
+    /**
+     * Load pack configuration
+     */
+    private loadPackConfig;
+    /**
+     * Setup file watcher using native Node.js fs.watch
+     */
+    private setupWatcher;
+    /**
+     * Check if a path should be ignored
+     */
+    private shouldIgnore;
+    /**
+     * Handle file change with debouncing
+     */
+    private handleFileChange;
+    /**
+     * Run tests and update statistics
+     */
+    private runTests;
+    /**
+     * Update aggregated statistics
+     */
+    private updateStats;
+    /**
+     * Calculate benchmark statistics
+     */
+    private calculateBenchmarkStats;
+    /**
+     * Log formatted run result
+     */
+    private logRunResult;
+    /**
+     * Format statistics for display
+     */
+    private formatStats;
+    /**
+     * Log message
+     */
+    private log;
+}
+/**
+ * Factory function to create a watch mode instance
+ */
+export declare function createWatchMode(options: WatchModeOptions): WatchMode;