qa360 2.2.1 → 2.2.7

package/cli/dist/commands/doctor.js

@@ -0,0 +1,513 @@
+/**
+ * QA360 Doctor Command - Environment diagnostic and auto-fix
+ */
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+export class QA360Doctor {
+    qa360Dir = process.env.QA360_HOME || join(process.cwd(), '.qa360');
+    keysDir = join(this.qa360Dir, 'keys');
+    runsDir = join(this.qa360Dir, 'runs');
+    async diagnose(options = {}) {
+        // In JSON mode, disable colors to avoid ANSI codes pollution
+        if (options.json) {
+            process.env.FORCE_COLOR = '0';
+        }
+        // Log QA360_HOME for debugging (verbose mode) - use stderr in JSON mode
+        if (process.env.DEBUG || process.env.VERBOSE) {
+            const logFn = options.json ? console.error : console.log;
+            logFn(`[DEBUG] Using QA360_HOME: ${this.qa360Dir}`);
+        }
+        // In JSON mode, spinner output goes to stderr to keep stdout clean
+        const spinner = options.json
+            ? ora({ text: '🔍 Diagnostic QA360 en cours...', stream: process.stderr }).start()
+            : ora('🔍 Diagnostic QA360 en cours...').start();
+        let fixedCount = 0;
+        try {
+            // Parse skip list from options or env
+            const skipList = options.skip || (process.env.QA360_SKIP_CHECKS ? process.env.QA360_SKIP_CHECKS.split(',').map(s => s.trim()) : []);
+            // Run initial checks
+            let checks = await this.runAllChecks();
+            // Filter out skipped checks
+            checks = checks.filter(c => !skipList.includes(c.id));
+            // Auto-fix if requested
+            if (options.fix) {
+                fixedCount = await this.performFixes(checks, { json: options.json });
+                // CRITICAL: Re-run ALL checks after fixes to get accurate final state
+                if (fixedCount > 0) {
+                    spinner.text = '🔄 Re-diagnostic après corrections...';
+                    checks = await this.runAllChecks();
+                    // Re-apply skip filter
+                    checks = checks.filter(c => !skipList.includes(c.id));
+                }
+            }
+            // If strict mode, always re-run checks to ensure fresh state
+            if (options.strict && fixedCount === 0) {
+                checks = await this.runAllChecks();
+                // Re-apply skip filter
+                checks = checks.filter(c => !skipList.includes(c.id));
+            }
+            spinner.stop();
+            return this.generateResult(checks, fixedCount, options);
+        }
+        catch (error) {
+            spinner.fail('Erreur lors du diagnostic');
+            throw error;
+        }
+    }
+    async runAllChecks() {
+        const checks = [];
+        // 1. Node.js version check
+        checks.push(await this.checkNodeVersion());
+        // 2. QA360 directories structure
+        checks.push(await this.checkDirectories());
+        // 3. Required tools availability
+        checks.push(...await this.checkTools());
+        // 4. Network connectivity
+        checks.push(await this.checkNetwork());
+        // 5. Secrets management
+        checks.push(await this.checkSecrets());
+        // 6. Crypto keys
+        checks.push(await this.checkCryptoKeys());
+        // 7. Proof System (Phase 2)
+        checks.push(await this.checkProofKeys());
+        checks.push(await this.checkProofRoundtrip());
+        return checks;
+    }
+    async checkNodeVersion() {
+        try {
+            const version = process.version;
+            const major = parseInt(version.slice(1).split('.')[0]);
+            if (major >= 18) {
+                return {
+                    id: 'node_js_version',
+                    name: 'Node.js Version',
+                    status: 'ok',
+                    message: `Node.js ${version} ✅`
+                };
+            }
+            else {
+                return {
+                    id: 'node_js_version',
+                    name: 'Node.js Version',
+                    status: 'error',
+                    message: `Node.js ${version} non supporté (requis: ≥18.0.0)`,
+                    code: 'QX001'
+                };
+            }
+        }
+        catch (error) {
+            return {
+                id: 'node_js_version',
+                name: 'Node.js Version',
+                status: 'error',
+                message: 'Impossible de détecter la version Node.js',
+                code: 'QX001'
+            };
+        }
+    }
+    async checkDirectories() {
+        // Only check essential directories - tools/ is deprecated
+        const dirs = [this.qa360Dir, this.keysDir, this.runsDir];
+        const missing = dirs.filter(dir => !existsSync(dir));
+        if (missing.length === 0) {
+            return {
+                id: 'structure_qa360',
+                name: 'Structure QA360',
+                status: 'ok',
+                message: 'Répertoires QA360 présents ✅'
+            };
+        }
+        return {
+            id: 'structure_qa360',
+            name: 'Structure QA360',
+            status: 'warning',
+            message: `Répertoires manquants: ${missing.map(d => d.split('/').pop()).join(', ')}`,
+            code: 'QX002',
+            fix: async () => {
+                missing.forEach(dir => mkdirSync(dir, { recursive: true }));
+            }
+        };
+    }
+    async checkTools() {
+        const tools = [
+            { id: 'playwright', name: 'Playwright', command: 'npx playwright --version', code: 'QX003' }
+        ];
+        const checks = [];
+        for (const tool of tools) {
+            try {
+                const output = execSync(tool.command, { encoding: 'utf8', stdio: 'pipe' });
+                checks.push({
+                    id: tool.id,
+                    name: tool.name,
+                    status: 'ok',
+                    message: `${tool.name} disponible (${output.trim()}) ✅`
+                });
+            }
+            catch (error) {
+                checks.push({
+                    id: tool.id,
+                    name: tool.name,
+                    status: 'warning',
+                    message: `${tool.name} non disponible`,
+                    code: tool.code,
+                    fix: async () => {
+                        if (tool.name === 'Playwright') {
+                            execSync('npx playwright install chromium', { stdio: 'inherit' });
+                        }
+                    }
+                });
+            }
+        }
+        return checks;
+    }
+    async checkNetwork() {
+        try {
+            // Use native fetch (Node 18+)
+            const response = await fetch('https://httpbin.org/status/200', {
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.ok) {
+                return {
+                    id: 'connectivity_network',
+                    name: 'Connectivité Réseau',
+                    status: 'ok',
+                    message: 'Accès Internet disponible ✅'
+                };
+            }
+            else {
+                throw new Error(`HTTP ${response.status}`);
+            }
+        }
+        catch (error) {
+            return {
+                id: 'connectivity_network',
+                name: 'Connectivité Réseau',
+                status: 'warning',
+                message: 'Accès Internet limité ou proxy détecté',
+                code: 'QX005'
+            };
+        }
+    }
+    async checkSecrets() {
+        const secretsFile = join(this.qa360Dir, 'secrets.enc');
+        const oldSecretsFile = join(this.qa360Dir, 'secrets.json');
+        // Secrets are optional - this is informational only
+        if (existsSync(secretsFile)) {
+            return {
+                id: 'gestion_secrets',
+                name: 'Gestion Secrets',
+                status: 'ok',
+                message: 'Fichier secrets configuré ✅'
+            };
+        }
+        // Old secrets file exists but not new one
+        if (existsSync(oldSecretsFile)) {
+            return {
+                id: 'gestion_secrets',
+                name: 'Gestion Secrets',
+                status: 'ok',
+                message: 'Fichier secrets (ancien format) configuré ℹ️'
+            };
+        }
+        // No secrets file is OK - secrets are optional
+        return {
+            id: 'gestion_secrets',
+            name: 'Gestion Secrets',
+            status: 'ok',
+            message: 'Aucun fichier secrets (optionnel) ℹ️'
+        };
+    }
+    async checkCryptoKeys() {
+        // Updated to use new key filenames (ed25519.key / ed25519.pub)
+        const privateKeyFile = join(this.keysDir, 'ed25519.key');
+        const publicKeyFile = join(this.keysDir, 'ed25519.pub');
+        // Also check for old filenames for backward compatibility
+        const oldPrivateKeyFile = join(this.keysDir, 'qa360.key');
+        const oldPublicKeyFile = join(this.keysDir, 'qa360.pub');
+        const hasNewKeys = existsSync(privateKeyFile) && existsSync(publicKeyFile);
+        const hasOldKeys = existsSync(oldPrivateKeyFile) && existsSync(oldPublicKeyFile);
+        if (hasNewKeys) {
+            return {
+                id: 'crypto_keys',
+                name: 'Clés Cryptographiques',
+                status: 'ok',
+                message: 'Paire de clés Ed25519 présente ✅'
+            };
+        }
+        if (hasOldKeys) {
+            return {
+                id: 'crypto_keys',
+                name: 'Clés Cryptographiques',
+                status: 'ok',
+                message: 'Paire de clés Ed25519 présente (ancien format) ℹ️'
+            };
+        }
+        // Note: Keys are auto-generated by ensureProofKeys, so this is just informational
+        return {
+            id: 'crypto_keys',
+            name: 'Clés Cryptographiques',
+            status: 'ok',
+            message: 'Clés Ed25519 seront générées automatiquement ℹ️'
+        };
+    }
+    async checkProofKeys() {
+        try {
+            const { ensureProofKeys } = await import('../core/index.js');
+            const result = await ensureProofKeys(this.qa360Dir);
+            // Validate result
+            if (!result) {
+                throw new Error('ensureProofKeys returned undefined');
+            }
+            if (result.created && !result.keys) {
+                throw new Error('Key generation failed (no keys returned)');
+            }
+            // Validate key sizes if keys were returned
+            if (result.keys) {
+                if (!result.keys.publicKey || result.keys.publicKey.length !== 32) {
+                    throw new Error(`Invalid public key size: ${result.keys.publicKey?.length || 0} (expected 32)`);
+                }
+                if (!result.keys.secretKey || result.keys.secretKey.length !== 64) {
+                    throw new Error(`Invalid secret key size: ${result.keys.secretKey?.length || 0} (expected 64)`);
+                }
+            }
+            if (result.created) {
+                return {
+                    id: 'proof_system_keys',
+                    name: 'Proof System Keys',
+                    status: 'ok',
+                    message: `Ed25519 keys generated (${result.paths.priv}) ✅`
+                };
+            }
+            return {
+                id: 'proof_system_keys',
+                name: 'Proof System Keys',
+                status: 'ok',
+                message: `Ed25519 keys ready (${result.paths.priv}) ✅`
+            };
+        }
+        catch (error) {
+            return {
+                id: 'proof_system_keys',
+                name: 'Proof System Keys',
+                status: 'error',
+                message: `Failed to ensure keys: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                code: 'D001'
+            };
+        }
+    }
+    async checkProofRoundtrip() {
+        try {
+            const coreModule = await import('../core/index.js');
+            const { generateKeys, createProofBundle, verifyProofBundle } = coreModule;
+            // Guard: Verify exports are functions
+            if (typeof generateKeys !== 'function') {
+                return {
+                    id: 'proof_roundtrip',
+                    name: 'Proof Roundtrip',
+                    status: 'error',
+                    message: 'Roundtrip test failed: generateKeys export not found',
+                    code: 'D003'
+                };
+            }
+            if (typeof createProofBundle !== 'function') {
+                return {
+                    id: 'proof_roundtrip',
+                    name: 'Proof Roundtrip',
+                    status: 'error',
+                    message: 'Roundtrip test failed: createProofBundle export not found',
+                    code: 'D003'
+                };
+            }
+            if (typeof verifyProofBundle !== 'function') {
+                return {
+                    id: 'proof_roundtrip',
+                    name: 'Proof Roundtrip',
+                    status: 'error',
+                    message: 'Roundtrip test failed: verifyProofBundle export not found',
+                    code: 'D003'
+                };
+            }
+            // Generate test keys
+            const keyPair = generateKeys();
+            // Create minimal proof bundle
+            const bundle = await createProofBundle({
+                startedAt: new Date(),
+                finishedAt: new Date(),
+                packHash: 'sha256-' + '0'.repeat(64),
+                artifacts: [],
+                trustScore: 100,
+                gates: [{ name: 'test', status: 'pass' }],
+                keyPair,
+            });
+            // Verify
+            const result = await verifyProofBundle(bundle, keyPair.publicKey);
+            if (result.valid) {
+                return {
+                    id: 'proof_roundtrip',
+                    name: 'Proof Roundtrip',
+                    status: 'ok',
+                    message: 'Sign/verify roundtrip OK ✅'
+                };
+            }
+            return {
+                id: 'proof_roundtrip',
+                name: 'Proof Roundtrip',
+                status: 'error',
+                message: 'Sign/verify roundtrip failed',
+                code: 'D003'
+            };
+        }
+        catch (error) {
+            return {
+                id: 'proof_roundtrip',
+                name: 'Proof Roundtrip',
+                status: 'error',
+                message: `Roundtrip test failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                code: 'D003'
+            };
+        }
+    }
+    async performFixes(checks, options = {}) {
+        const fixableChecks = checks.filter(check => check.fix && check.status !== 'ok');
+        // In JSON mode, all human logs go to stderr
+        const log = options.json ? console.error : console.log;
+        if (fixableChecks.length === 0) {
+            log(chalk.green('✅ Aucune correction nécessaire'));
+            return 0;
+        }
+        log(chalk.blue(`🔧 Application de ${fixableChecks.length} correction(s)...`));
+        let fixedCount = 0;
+        for (const check of fixableChecks) {
+            try {
+                // In JSON mode, spinner goes to stderr
+                const spinner = options.json
+                    ? ora({ text: `Correction: ${check.name}`, stream: process.stderr }).start()
+                    : ora(`Correction: ${check.name}`).start();
+                await check.fix();
+                spinner.succeed(`${check.name} corrigé`);
+                check.status = 'ok';
+                check.message = `${check.name} corrigé automatiquement ✅`;
+                delete check.code; // Remove error code after fix
+                fixedCount++;
+            }
+            catch (error) {
+                // Always use stderr for error messages
+                console.error(chalk.red(`❌ Échec correction ${check.name}: ${error}`));
+                // Keep status as error if fix failed
+            }
+        }
+        return fixedCount;
+    }
+    generateResult(checks, fixedCount, options = {}) {
+        // Calculate summary based on FINAL state (after re-diagnostic)
+        const summary = {
+            total: checks.length,
+            ok: checks.filter(c => c.status === 'ok').length,
+            warnings: checks.filter(c => c.status === 'warning').length,
+            errors: checks.filter(c => c.status === 'error').length,
+            fixed: fixedCount
+        };
+        // Exit code logic (clear and deterministic):
+        let exitCode;
+        let decision;
+        if (options.strict) {
+            // --strict: exit 0 only if errors=0 AND warnings=0
+            const okStrict = summary.errors === 0 && summary.warnings === 0;
+            exitCode = okStrict ? 0 : 1;
+            decision = okStrict ? 'ok' : 'fail_strict';
+        }
+        else if (options.fix) {
+            // --fix: exit 0 if errors=0 after fixes (warnings tolerated)
+            const okAfterFix = summary.errors === 0;
+            exitCode = okAfterFix ? 0 : 1;
+            decision = okAfterFix ? 'ok' : 'fail_after_fix';
+        }
+        else {
+            // default (info mode): always exit 0
+            exitCode = 0;
+            decision = 'info';
+        }
+        return { checks, summary, exitCode, decision };
+    }
+    displayResult(result, options = {}) {
+        // In JSON mode, this should never be called, but guard anyway
+        const log = options.json ? console.error : console.log;
+        log(chalk.bold('\n📋 Rapport de Diagnostic QA360\n'));
+        result.checks.forEach(check => {
+            const icon = check.status === 'ok' ? '✅' :
+                check.status === 'warning' ? '⚠️' : '❌';
+            log(`${icon} ${check.name}: ${check.message}`);
+            if (check.code) {
+                log(chalk.gray(`   Code: ${check.code} - Utilisez 'qa360 explain ${check.code}' pour plus d'infos`));
+            }
+        });
+        log(chalk.bold('\n📊 Résumé:'));
+        log(`   Total: ${result.summary.total}`);
+        log(chalk.green(`   ✅ OK: ${result.summary.ok}`));
+        if (result.summary.fixed > 0) {
+            log(chalk.blue(`   🔧 Corrigés: ${result.summary.fixed}`));
+        }
+        log(chalk.yellow(`   ⚠️  Avertissements: ${result.summary.warnings}`));
+        log(chalk.red(`   ❌ Erreurs: ${result.summary.errors}`));
+        // Show final decision
+        const decisionMsg = result.exitCode === 0
+            ? chalk.green(`\n✅ After fixes: errors=${result.summary.errors} warnings=${result.summary.warnings} → exit 0`)
+            : chalk.red(`\n❌ After fixes: errors=${result.summary.errors} warnings=${result.summary.warnings} → exit 1`);
+        log(decisionMsg);
+        if (result.summary.warnings > 0 || result.summary.errors > 0) {
+            log(chalk.blue('\n💡 Conseil: Utilisez "qa360 doctor --fix" pour corriger automatiquement les problèmes'));
+        }
+    }
+}
+export async function doctorCommand(options = {}) {
+    const doctor = new QA360Doctor();
+    try {
+        const result = await doctor.diagnose(options);
+        if (options.json) {
+            // JSON output (stable for CI) - stdout ONLY, single line
+            process.stdout.write(JSON.stringify({
+                ok: result.exitCode === 0,
+                fixed: result.summary.fixed,
+                errors: result.summary.errors,
+                warnings: result.summary.warnings,
+                qa360Home: process.env.QA360_HOME || join(process.cwd(), '.qa360'),
+                decision: result.decision,
+                checks: result.checks.map(c => ({
+                    id: c.id,
+                    name: c.name,
+                    status: c.status,
+                    message: c.message,
+                    code: c.code,
+                    fixed: c.message.includes('corrigé automatiquement')
+                })),
+                summary: result.summary,
+            }) + '\n');
+        }
+        else {
+            // Human-readable output
+            doctor.displayResult(result, options);
+        }
+        // Exit code handling
+        if (options.strict && result.exitCode !== 0) {
+            process.exit(1);
+        }
+        else {
+            process.exit(result.exitCode);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            }) + '\n');
+        }
+        else {
+            console.error(chalk.red('❌ Erreur lors du diagnostic:'), error);
+        }
+        process.exit(1);
+    }
+}

package/cli/dist/commands/examples.d.ts

@@ -0,0 +1,33 @@
+/**
+ * QA360 Examples Command - Manage example templates
+ *
+ * Usage:
+ *   qa360 examples list
+ *   qa360 examples copy api-basic
+ *   qa360 examples show fullstack
+ */
+/**
+ * CLI options for examples command
+ */
+export interface ExamplesOptions {
+    output?: string;
+    force?: boolean;
+}
+/**
+ * List available examples
+ */
+export declare function examplesListCommand(): Promise<void>;
+/**
+ * Show example content
+ */
+export declare function examplesShowCommand(templateName: string): Promise<void>;
+/**
+ * Copy example to current directory
+ */
+export declare function examplesCopyCommand(templateName: string, options?: ExamplesOptions): Promise<void>;
+declare const _default: {
+    list: typeof examplesListCommand;
+    show: typeof examplesShowCommand;
+    copy: typeof examplesCopyCommand;
+};
+export default _default;