qa360 2.2.1 → 2.2.13

package/cli/src/commands/doctor.ts

@@ -1,610 +0,0 @@
-/**
- * QA360 Doctor Command - Environment diagnostic and auto-fix
- */
-
-import { execSync } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-
-export interface DoctorCheck {
-  id: string;
-  name: string;
-  status: 'ok' | 'warning' | 'error';
-  message: string;
-  code?: string;
-  fix?: () => Promise<void>;
-}
-
-export interface DoctorResult {
-  checks: DoctorCheck[];
-  summary: {
-    total: number;
-    ok: number;
-    warnings: number;
-    errors: number;
-    fixed: number;
-  };
-  exitCode: 0 | 1;
-  decision: 'ok' | 'fail_after_fix' | 'fail_strict' | 'info';
-}
-
-export class QA360Doctor {
-  private qa360Dir = process.env.QA360_HOME || join(process.cwd(), '.qa360');
-  private keysDir = join(this.qa360Dir, 'keys');
-  private runsDir = join(this.qa360Dir, 'runs');
-
-  async diagnose(options: { fix?: boolean; strict?: boolean; json?: boolean; skip?: string[] } = {}): Promise<DoctorResult> {
-    // 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;
-    }
-  }
-
-  private async runAllChecks(): Promise<DoctorCheck[]> {
-    const checks: DoctorCheck[] = [];
-    
-    // 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;
-  }
-
-  private async checkNodeVersion(): Promise<DoctorCheck> {
-    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'
-      };
-    }
-  }
-
-  private async checkDirectories(): Promise<DoctorCheck> {
-    // 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 }));
-      }
-    };
-  }
-
-  private async checkTools(): Promise<DoctorCheck[]> {
-    const tools = [
-      { id: 'playwright', name: 'Playwright', command: 'npx playwright --version', code: 'QX003' }
-    ];
-
-    const checks: DoctorCheck[] = [];
-
-    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;
-  }
-
-  private async checkNetwork(): Promise<DoctorCheck> {
-    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'
-      };
-    }
-  }
-
-  private async checkSecrets(): Promise<DoctorCheck> {
-    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) ℹ️'
-    };
-  }
-
-  private async checkCryptoKeys(): Promise<DoctorCheck> {
-    // 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 ℹ️'
-    };
-  }
-
-  private async checkProofKeys(): Promise<DoctorCheck> {
-    try {
-      const { ensureProofKeys } = await import('qa360-core');
-      
-      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'
-      };
-    }
-  }
-
-  private async checkProofRoundtrip(): Promise<DoctorCheck> {
-    try {
-      const coreModule = await import('qa360-core');
-      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'
-      };
-    }
-  }
-
-  private async performFixes(checks: DoctorCheck[], options: { json?: boolean } = {}): Promise<number> {
-    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;
-  }
-
-  private generateResult(checks: DoctorCheck[], fixedCount: number, options: { fix?: boolean; strict?: boolean } = {}): DoctorResult {
-    // 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: 0 | 1;
-    let decision: 'ok' | 'fail_after_fix' | 'fail_strict' | 'info';
-    
-    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: DoctorResult, options: { json?: boolean } = {}): void {
-    // 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: { 
-  fix?: boolean;
-  json?: boolean;
-  strict?: boolean;
-  skip?: string[];
-} = {}): Promise<void> {
-  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);
-  }
-}