qa360 2.1.2 → 2.1.4

package/dist/commands/doctor.js

@@ -1,513 +0,0 @@
-/**
- * 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/dist/commands/examples.d.ts

@@ -1,33 +0,0 @@
-/**
- * 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;