qa360 1.4.5 → 2.0.1

package/dist/core/watch/watch-mode.js

@@ -0,0 +1,389 @@
+/**
+ * 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 { watch } from 'fs';
+import { relative, join } from 'path';
+import { Phase3Runner } from '../runner/phase3-runner.js';
+import { readFile } from 'fs/promises';
+/**
+ * Watch Mode Manager
+ *
+ * Monitors file changes and runs tests automatically.
+ */
+export class WatchMode {
+    options;
+    watchers = [];
+    runNumber = 0;
+    isRunning = false;
+    debounceTimer;
+    pendingChanges = new Set();
+    runResults = [];
+    stats = {
+        totalRuns: 0,
+        successfulRuns: 0,
+        failedRuns: 0,
+        avgDuration: 0,
+        fastestRun: Infinity,
+        slowestRun: 0,
+        totalDuration: 0,
+        avgTrustScore: 0,
+        totalTests: 0,
+        totalPassed: 0,
+        totalFailed: 0
+    };
+    packConfig;
+    constructor(options) {
+        this.options = {
+            workingDir: options.workingDir,
+            packPath: options.packPath ?? join(options.workingDir, 'pack.yml'),
+            debounceMs: options.debounceMs ?? 300,
+            ignore: options.ignore ?? ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/.qa360/**', '**/build/**'],
+            runOnStart: options.runOnStart ?? true,
+            clearScreen: options.clearScreen ?? true,
+            onRunStart: options.onRunStart ?? (() => { }),
+            onRunComplete: options.onRunComplete ?? (() => { }),
+            onFileChange: options.onFileChange ?? (() => { }),
+            onError: options.onError ?? ((err) => console.error('Watch error:', err))
+        };
+    }
+    /**
+     * Start watching files and running tests
+     */
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Watch mode is already running');
+        }
+        this.isRunning = true;
+        try {
+            // Load pack configuration
+            await this.loadPackConfig();
+            // Setup file watcher
+            this.setupWatcher();
+            // Run initial test if configured
+            if (this.options.runOnStart) {
+                await this.runTests([]);
+            }
+            this.log('Watch mode started. Press Ctrl+C to stop.');
+        }
+        catch (error) {
+            this.isRunning = false;
+            throw error;
+        }
+    }
+    /**
+     * Stop watching files
+     */
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Close all file watchers
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.watchers = [];
+        this.log('Watch mode stopped.');
+        this.log(this.formatStats());
+    }
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get run history
+     */
+    getRunHistory() {
+        return [...this.runResults];
+    }
+    /**
+     * Run benchmark tests
+     */
+    async benchmark(config) {
+        this.log(`Starting benchmark: ${config.iterations} iterations (${config.warmupIterations} warmup)`);
+        const durations = [];
+        let successful = 0;
+        // Warmup runs
+        this.log('Warming up...');
+        for (let i = 0; i < config.warmupIterations; i++) {
+            await this.runTests([], { silent: true });
+        }
+        // Benchmark runs
+        this.log('Running benchmark...');
+        for (let i = 0; i < config.iterations; i++) {
+            const result = await this.runTests([], { silent: true });
+            durations.push(result.duration);
+            if (result.success) {
+                successful++;
+            }
+            // Progress indicator
+            if ((i + 1) % Math.max(1, Math.floor(config.iterations / 10)) === 0) {
+                this.log(`  Progress: ${i + 1}/${config.iterations}`);
+            }
+        }
+        return this.calculateBenchmarkStats(durations, successful, config.iterations);
+    }
+    /**
+     * Load pack configuration
+     */
+    async loadPackConfig() {
+        try {
+            const content = await readFile(this.options.packPath, 'utf-8');
+            // Parse YAML (simple version, assumes YAML is preprocessed or uses JSON-compatible format)
+            // For full YAML support, you'd need a YAML parser
+            this.packConfig = JSON.parse(content);
+        }
+        catch (error) {
+            // If YAML parsing fails, try to use a simple config
+            this.packConfig = {
+                version: 2,
+                name: 'watch-tests',
+                gates: {},
+                execution: { on_failure: 'continue' }
+            };
+        }
+    }
+    /**
+     * Setup file watcher using native Node.js fs.watch
+     */
+    setupWatcher() {
+        const watchPath = this.options.workingDir;
+        try {
+            const watcher = watch(watchPath, { recursive: true }, (eventType, filename) => {
+                if (filename) {
+                    this.handleFileChange(join(watchPath, filename));
+                }
+            });
+            watcher.on('error', (error) => this.options.onError(error));
+            this.watchers.push(watcher);
+        }
+        catch (error) {
+            this.options.onError(error);
+        }
+    }
+    /**
+     * Check if a path should be ignored
+     */
+    shouldIgnore(path) {
+        const normalizedPath = path.replace(/\\/g, '/');
+        for (const pattern of this.options.ignore) {
+            const regexPattern = pattern
+                .replace(/\*\*/g, '.*')
+                .replace(/\*/g, '[^/]*')
+                .replace(/\//g, '\\/');
+            try {
+                const regex = new RegExp(regexPattern);
+                if (regex.test(normalizedPath)) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid regex pattern, skip
+            }
+        }
+        return false;
+    }
+    /**
+     * Handle file change with debouncing
+     */
+    handleFileChange(path) {
+        if (this.shouldIgnore(path)) {
+            return;
+        }
+        this.pendingChanges.add(path);
+        this.options.onFileChange(path);
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            const changes = Array.from(this.pendingChanges);
+            this.pendingChanges.clear();
+            this.runTests(changes);
+        }, this.options.debounceMs);
+    }
+    /**
+     * Run tests and update statistics
+     */
+    async runTests(changedFiles, options = {}) {
+        const runNumber = ++this.runNumber;
+        const startedAt = new Date();
+        if (!options.silent) {
+            if (this.options.clearScreen) {
+                console.clear();
+            }
+            this.options.onRunStart(runNumber);
+        }
+        let result;
+        try {
+            const runner = new Phase3Runner({
+                workingDir: this.options.workingDir,
+                pack: this.packConfig
+            });
+            const phase3Result = await runner.run();
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            const success = phase3Result.success;
+            result = {
+                runNumber,
+                startedAt,
+                completedAt,
+                duration,
+                result: phase3Result,
+                changedFiles,
+                success
+            };
+            this.runResults.push(result);
+            this.updateStats(result);
+            if (!options.silent) {
+                this.logRunResult(result);
+            }
+        }
+        catch (error) {
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            result = {
+                runNumber,
+                startedAt,
+                completedAt,
+                duration,
+                result: {
+                    success: false,
+                    pack: this.packConfig,
+                    duration: 0,
+                    gates: [],
+                    hooks: { beforeAll: [], beforeEach: [], afterEach: [], afterAll: [] },
+                    summary: { total: 0, passed: 0, failed: 1, trustScore: 0 },
+                    error: error instanceof Error ? error.message : String(error)
+                },
+                changedFiles,
+                success: false
+            };
+            this.runResults.push(result);
+            this.updateStats(result);
+        }
+        this.options.onRunComplete(result);
+        return result;
+    }
+    /**
+     * Update aggregated statistics
+     */
+    updateStats(result) {
+        this.stats.totalRuns++;
+        this.stats.totalDuration += result.duration;
+        if (result.success) {
+            this.stats.successfulRuns++;
+            this.stats.avgTrustScore = ((this.stats.avgTrustScore * (this.stats.successfulRuns - 1) + result.result.summary.trustScore) /
+                this.stats.successfulRuns);
+        }
+        else {
+            this.stats.failedRuns++;
+        }
+        this.stats.avgDuration = this.stats.totalDuration / this.stats.totalRuns;
+        this.stats.fastestRun = Math.min(this.stats.fastestRun, result.duration);
+        this.stats.slowestRun = Math.max(this.stats.slowestRun, result.duration);
+        this.stats.totalTests += result.result.summary.total;
+        this.stats.totalPassed += result.result.summary.passed;
+        this.stats.totalFailed += result.result.summary.failed;
+    }
+    /**
+     * Calculate benchmark statistics
+     */
+    calculateBenchmarkStats(durations, successful, total) {
+        const sorted = [...durations].sort((a, b) => a - b);
+        const sum = durations.reduce((a, b) => a + b, 0);
+        const avg = sum / durations.length;
+        const variance = durations.reduce((acc, val) => acc + Math.pow(val - avg, 2), 0) / durations.length;
+        const stdDev = Math.sqrt(variance);
+        return {
+            avgDuration: avg,
+            minDuration: sorted[0] ?? 0,
+            maxDuration: sorted[sorted.length - 1] ?? 0,
+            stdDev,
+            median: sorted[Math.floor(sorted.length / 2)] ?? 0,
+            p95: sorted[Math.floor(sorted.length * 0.95)] ?? 0,
+            p99: sorted[Math.floor(sorted.length * 0.99)] ?? 0,
+            successfulRuns: successful,
+            totalIterations: total,
+            throughput: 1000 / avg // runs per second
+        };
+    }
+    /**
+     * Log formatted run result
+     */
+    logRunResult(result) {
+        const { result: r, changedFiles, duration } = result;
+        console.log(`\n${result.success ? '✅' : '❌'} Run #${result.runNumber} (${duration}ms)`);
+        if (changedFiles.length > 0) {
+            console.log(`   Changed files:`);
+            for (const file of changedFiles) {
+                console.log(`     - ${relative(this.options.workingDir, file)}`);
+            }
+        }
+        console.log(`   Tests: ${r.summary.passed}/${r.summary.total} passed`);
+        console.log(`   Trust Score: ${r.summary.trustScore}`);
+        console.log(`   Gates: ${r.gates.length}`);
+        if (r.gates.length > 0) {
+            for (const gate of r.gates) {
+                console.log(`     ${gate.success ? '✅' : '❌'} ${gate.gate}`);
+            }
+        }
+        console.log(`\n${this.formatStats()}`);
+    }
+    /**
+     * Format statistics for display
+     */
+    formatStats() {
+        const s = this.stats;
+        if (s.totalRuns === 0) {
+            return 'No runs yet';
+        }
+        const successRate = ((s.successfulRuns / s.totalRuns) * 100).toFixed(1);
+        return [
+            '',
+            '📊 Statistics:',
+            `  Runs: ${s.totalRuns} (${s.successfulRuns} passed, ${s.failedRuns} failed)`,
+            `  Success Rate: ${successRate}%`,
+            `  Avg Duration: ${Math.round(s.avgDuration)}ms`,
+            `  Fastest: ${s.fastestRun === Infinity ? 0 : s.fastestRun}ms | Slowest: ${s.slowestRun}ms`,
+            `  Avg Trust Score: ${Math.round(s.avgTrustScore)}`,
+            `  Total Tests: ${s.totalTests} (${s.totalPassed} passed, ${s.totalFailed} failed)`,
+            ''
+        ].join('\n');
+    }
+    /**
+     * Log message
+     */
+    log(message) {
+        console.log(`[Watch] ${message}`);
+    }
+}
+/**
+ * Factory function to create a watch mode instance
+ */
+export function createWatchMode(options) {
+    return new WatchMode(options);
+}

package/dist/index.js

@@ -21,9 +21,21 @@ import { examplesListCommand, examplesCopyCommand, examplesShowCommand } from '.
 import { runCommand } from './commands/run.js';
 import { reportCommand } from './commands/report.js';
 import { verifyCommand } from './commands/verify.js';
-import { packValidateCommand, packLintCommand, packMigrateCommand } from './commands/pack.js';
+import { explainCommand } from './commands/explain.js';
+// import { packValidateCommand, packLintCommand, packMigrateCommand } from './commands/pack.js'; // TODO: fix pack v2 imports
 import { secretsAddCommand, secretsListCommand, secretsRemoveCommand, secretsDoctorCommand, secretsExportCommand } from './commands/secrets.js';
 import { createHistoryCommands } from './commands/history.js';
+import { createAICommands } from './commands/ai.js';
+import { createFlakinessCommands } from './commands/flakiness.js';
+import { createDashboardCommand } from './commands/monitor.js';
+import { coverageCommand } from './commands/coverage.js';
+import { sloCommand } from './commands/slo.js';
+import { regressionCommand } from './commands/regression.js';
+import { createRetryCommands } from './commands/retry.js';
+// import { createMonitorCommands } from './commands/monitor.js'; // TODO: Re-enable monitor imports
+// import { createOllamaCommands } from './commands/ollama.js'; // TODO: Re-enable when Ollama exports from core are fixed
+// import { createGenerateCommands } from './commands/generate.js'; // TODO: fix generation imports
+// import { createRepairCommand } from './commands/repair.js'; // TODO: fix repair imports
 const program = new Command();
 program
     .name('qa360')
@@ -46,6 +58,7 @@ program
     .option('--output <file>', 'Output file path', 'qa360.yml')
     .option('--force', 'Overwrite existing file')
     .option('-y, --yes', 'Skip prompts and use defaults')
+    .option('--beginner', 'Guided mode for first-time users with step-by-step explanations')
     .action(async (options) => {
     await initCommand(options);
 });
@@ -114,80 +127,47 @@ program
     await verifyCommand(proof, options);
 });
 program
-    .command('explain <code>')
-    .description('Explain error code and provide solutions')
-    .action(async (code) => {
-    console.log(chalk.blue(`🔍 QA360 Explain - Code ${code}`));
-    const explanations = {
-        'QX001': {
-            title: 'Node.js Version Incompatible',
-            cause: 'QA360 Core requires Node.js 18.0.0 or higher',
-            solution: 'Update Node.js: https://nodejs.org/ or use nvm/fnm'
-        },
-        'QX002': {
-            title: 'QA360 Directory Structure Missing',
-            cause: 'Required .qa360 directories not found',
-            solution: 'Run "qa360 doctor --fix" to create missing directories'
-        },
-        'QX003': {
-            title: 'Playwright Not Available',
-            cause: 'Playwright is not installed or not in PATH',
-            solution: 'Install: "npx playwright install" or use --docker flag'
-        },
-        'QX004': {
-            title: 'Puppeteer Not Available',
-            cause: 'Puppeteer is not installed (required for PDF generation)',
-            solution: 'Install: "npm install puppeteer" or check dependencies'
-        },
-        'QX005': {
-            title: 'Network Connectivity Issues',
-            cause: 'Cannot reach external services (proxy/firewall)',
-            solution: 'Check network settings, configure proxy, or use offline mode'
-        },
-        'QX006': {
-            title: 'Secrets Configuration Missing',
-            cause: 'No secrets.json file configured',
-            solution: 'Run "qa360 doctor --fix" to create default secrets file'
-        },
-        'QX007': {
-            title: 'Cryptographic Keys Missing',
-            cause: 'Ed25519 key pair not found for signing',
-            solution: 'Run "qa360 doctor --fix" to generate new key pair'
-        }
-    };
-    const explanation = explanations[code];
-    if (explanation) {
-        console.log(chalk.red(`\n❌ ${explanation.title}`));
-        console.log(chalk.yellow(`\n🔍 Cause: ${explanation.cause}`));
-        console.log(chalk.green(`\n💡 Solution: ${explanation.solution}`));
-    }
-    else {
-        console.log(chalk.red(`\n❌ Code d'erreur inconnu: ${code}`));
-        console.log(chalk.blue('\n📚 Codes disponibles: QX001-QX007'));
-    }
+    .command('explain [input]')
+    .description('Explain errors, failures, and test results with AI')
+    .option('--ai', 'Use AI-powered explanation')
+    .option('-P, --provider <provider>', 'AI provider to use (deepseek, ollama, openai, anthropic)')
+    .option('--run <id>', 'Explain a specific test run')
+    .option('--gate <name>', 'Explain gate-specific failures')
+    .option('--json', 'Output as JSON')
+    .action(async (input, options) => {
+    await explainCommand(input, options);
 });
 // Pack commands (Phase 2)
+/*
+// TODO: Re-enable after fixing pack v2 imports
 const packCommand = program
-    .command('pack')
-    .description('Pack configuration management');
+  .command('pack')
+  .description('Pack configuration management');
+
 packCommand
-    .command('validate [pack]')
-    .description('Validate pack.yml against v1 schema')
-    .action(async (pack) => {
-    await packValidateCommand(pack);
-});
+  .command('validate [pack]')
+  .description('Validate pack.yml (auto-detects v1 or v2)')
+  .option('--check-files', 'Verify that referenced test files exist')
+  .action(async (pack, options) => {
+    await packValidateCommand(pack, options);
+  });
+
 packCommand
-    .command('lint [pack]')
-    .description('Auto-fix pack.yml formatting and structure')
-    .action(async (pack) => {
+  .command('lint [pack]')
+  .description('Auto-fix pack.yml formatting and structure')
+  .action(async (pack) => {
     await packLintCommand(pack);
-});
+  });
+
 packCommand
-    .command('migrate [pack]')
-    .description('Migrate legacy pack to v1 format')
-    .action(async (pack) => {
-    await packMigrateCommand(pack);
-});
+  .command('migrate [pack]')
+  .description('Migrate pack v1 to v2 format')
+  .option('--output <file>', 'Output file path')
+  .option('--dry-run', 'Preview changes without writing files')
+  .action(async (pack, options) => {
+    await packMigrateCommand(pack, options);
+  });
+*/
 // Secrets commands (Phase 2)
 const secretsCommand = program
     .command('secrets')
@@ -232,6 +212,26 @@ program
 });
 // History commands (Evidence Vault)
 program.addCommand(createHistoryCommands());
+// Flakiness commands (Test reliability tracking)
+program.addCommand(createFlakinessCommands());
+// AI commands (DeepSeek, Ollama, OpenAI, Anthropic)
+program.addCommand(createAICommands());
+// program.addCommand(createOllamaCommands()); // TODO: Re-enable when Ollama exports from core are fixed
+// Generate AI commands (Phase 4)
+// program.addCommand(createGenerateCommands()); // TODO: Re-enable after fixing imports
+// Repair Commands (Phase 7 - Auto-Repair)
+// program.addCommand(createRepairCommand()); // TODO: Re-enable after fixing imports
+// Monitor Commands (Phase 8 - TUI & Dashboard)
+// program.addCommand(createMonitorCommands()); // TODO: Re-enable after fixing imports
+program.addCommand(createDashboardCommand());
+// Coverage Commands (Vision 2.0 - Phase 2 - F11)
+program.addCommand(coverageCommand);
+// SLO/SLI Commands (Vision 2.0 - Phase 2)
+program.addCommand(sloCommand);
+// Regression Commands (Vision 2.0 - Phase 2 - F12)
+program.addCommand(regressionCommand);
+// Retry Commands (Vision 2.0 - Phase 2 - F8 Smart Retry)
+program.addCommand(createRetryCommands());
 // Show banner
 console.log(chalk.bold.blue('QA360 Core v' + version));
 console.log(chalk.gray('Transform software testing into verifiable, signed, and traceable proofs\n'));

package/dist/utils/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Config loader utilities for CLI commands
+ */
+import { PackConfigV1, type PackConfigV2 } from 'qa360-core';
+export declare function loadPackConfig(packPath: string): Promise<PackConfigV1 | PackConfigV2>;