qa360 1.4.5 → 2.0.1

package/dist/commands/pack.js

@@ -1,29 +1,32 @@
 /**
  * QA360 Pack Commands
+ *
  * Implements pack validate, lint, and migrate commands
+ * Supports both v1 and v2 pack formats
  */
 import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { resolve } from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import * as yaml from 'js-yaml';
-import { PackValidator, PackMigrator } from '../core/index.js';
+import { PackValidator, PackMigrator as PackMigratorV1 } from '../core/index.js';
+import { PackValidatorV2, PackMigrator, PackLoaderV2 } from '../core/index.js';
 export class QA360Pack {
-    qa360Dir = join(process.cwd(), '.qa360');
-    packPath = join(this.qa360Dir, 'pack.yml');
-    validator = new PackValidator();
-    migrator = new PackMigrator();
+    qa360Dir = resolve(process.cwd(), '.qa360');
+    packPath = resolve(this.qa360Dir, 'pack.yml');
+    validatorV1 = new PackValidator();
+    migratorV1 = new PackMigratorV1();
     /**
-     * Validate pack.yml against v1 schema
+     * Validate pack.yml (auto-detects v1 or v2)
      */
-    async validate(packPath) {
-        const spinner = ora('🔍 Validation du pack...').start();
+    async validate(packPath, options) {
+        const spinner = ora('🔍 Validating pack...').start();
         try {
             const targetPath = packPath || this.packPath;
             if (!existsSync(targetPath)) {
-                spinner.fail(chalk.red('❌ Pack non trouvé'));
-                console.log(chalk.yellow(`📁 Chemin: ${targetPath}`));
-                console.log(chalk.blue('💡 Utilisez: qa360 ask "..." pour créer un pack'));
+                spinner.fail(chalk.red('❌ Pack not found'));
+                console.log(chalk.yellow(`📁 Path: ${targetPath}`));
+                console.log(chalk.blue('💡 Use: qa360 init to create a pack'));
                 return { valid: false, exitCode: 1 };
             }
             // Load and parse pack
@@ -33,46 +36,94 @@ export class QA360Pack {
                 pack = yaml.load(packContent);
             }
             catch (parseError) {
-                spinner.fail(chalk.red('❌ Erreur de parsing YAML'));
-                console.log(chalk.red(`\n🔍 Erreur: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
+                spinner.fail(chalk.red('❌ YAML parse error'));
+                console.log(chalk.red(`\n🔍 Error: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
                 return { valid: false, exitCode: 1 };
             }
-            // Validate
-            const result = this.validator.validate(pack);
-            if (result.valid) {
-                spinner.succeed(chalk.green('✅ Pack valide'));
-                // Show warnings if any
-                if (result.warnings.length > 0) {
-                    console.log(chalk.yellow('\n⚠️  Avertissements:'));
-                    for (const warning of result.warnings) {
-                        console.log(chalk.yellow(`  • ${warning.code}: ${warning.message}`));
-                        if (warning.suggestion) {
-                            console.log(chalk.blue(`    💡 ${warning.suggestion}`));
-                        }
+            // Detect version
+            const loader = new PackLoaderV2();
+            const detectedVersion = this.detectPackVersion(pack);
+            if (detectedVersion === 2) {
+                return await this.validateV2(targetPath, pack, spinner, options?.checkFiles);
+            }
+            else {
+                return await this.validateV1(pack, spinner);
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red('❌ Validation error'));
+            console.log(chalk.red(`\n🔍 Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+            return { valid: false, exitCode: 1 };
+        }
+    }
+    /**
+     * Validate v1 pack
+     */
+    async validateV1(pack, spinner) {
+        const result = this.validatorV1.validate(pack);
+        if (result.valid) {
+            spinner.succeed(chalk.green('✅ Pack v1 is valid'));
+            if (result.warnings.length > 0) {
+                console.log(chalk.yellow('\n⚠️  Warnings:'));
+                for (const warning of result.warnings) {
+                    console.log(chalk.yellow(`  • ${warning.code}: ${warning.message}`));
+                    if (warning.suggestion) {
+                        console.log(chalk.blue(`    💡 ${warning.suggestion}`));
                     }
                 }
-                // Show pack summary
-                this.showPackSummary(pack);
-                return { valid: true, exitCode: 0 };
             }
-            else {
-                spinner.fail(chalk.red('❌ Pack invalide'));
-                console.log(chalk.red('\n🔍 Erreurs détectées:'));
-                for (const error of result.errors) {
-                    console.log(chalk.red(`  • ${error.code}: ${error.message}`));
-                    console.log(chalk.gray(`    📍 Chemin: ${error.path}`));
-                    if (error.suggestion) {
-                        console.log(chalk.blue(`    💡 ${error.suggestion}`));
+            this.showPackSummary(pack);
+            return { valid: true, exitCode: 0 };
+        }
+        else {
+            spinner.fail(chalk.red('❌ Pack v1 validation failed'));
+            console.log(chalk.red('\n🔍 Errors found:'));
+            for (const error of result.errors) {
+                console.log(chalk.red(`  • ${error.code}: ${error.message}`));
+                console.log(chalk.gray(`    📍 Path: ${error.path}`));
+                if (error.suggestion) {
+                    console.log(chalk.blue(`    💡 ${error.suggestion}`));
+                }
+            }
+            console.log(chalk.blue('\n💡 Tip: Use qa360 pack migrate to upgrade to v2'));
+            return { valid: false, exitCode: 1 };
+        }
+    }
+    /**
+     * Validate v2 pack
+     */
+    async validateV2(packPath, pack, spinner, checkFiles) {
+        const validator = new PackValidatorV2(packPath);
+        const result = await validator.validate(pack, { checkFilesExist: checkFiles });
+        if (result.valid) {
+            spinner.succeed(chalk.green('✅ Pack v2 is valid'));
+            if (result.warnings.length > 0) {
+                console.log(chalk.yellow('\n⚠️  Warnings:'));
+                for (const warning of result.warnings.slice(0, 10)) {
+                    console.log(chalk.yellow(`  • ${warning.code}: ${warning.message}`));
+                    if (warning.path) {
+                        console.log(chalk.gray(`    📍 ${warning.path}`));
                     }
                 }
-                console.log(chalk.blue('\n📚 Documentation: https://qa360.dev/docs/pack-v1'));
-                console.log(chalk.blue('🔧 Auto-correction: qa360 pack lint'));
-                return { valid: false, exitCode: 1 };
+                if (result.warnings.length > 10) {
+                    console.log(chalk.gray(`  ... and ${result.warnings.length - 10} more warnings`));
+                }
             }
+            this.showPackV2Summary(pack, result);
+            return { valid: true, exitCode: 0 };
         }
-        catch (error) {
-            spinner.fail(chalk.red('❌ Erreur de validation'));
-            console.log(chalk.red(`\n🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        else {
+            spinner.fail(chalk.red('❌ Pack v2 validation failed'));
+            console.log(chalk.red('\n🔍 Errors found:'));
+            for (const error of result.errors.slice(0, 10)) {
+                console.log(chalk.red(`  • ${error.code}: ${error.message}`));
+                if (error.path) {
+                    console.log(chalk.gray(`    📍 ${error.path}`));
+                }
+            }
+            if (result.errors.length > 10) {
+                console.log(chalk.gray(`  ... and ${result.errors.length - 10} more errors`));
+            }
             return { valid: false, exitCode: 1 };
         }
     }
@@ -80,12 +131,12 @@ export class QA360Pack {
      * Lint and auto-fix pack.yml
      */
     async lint(packPath) {
-        const spinner = ora('🔧 Correction automatique du pack...').start();
+        const spinner = ora('🔧 Auto-fixing pack...').start();
         try {
             const targetPath = packPath || this.packPath;
             if (!existsSync(targetPath)) {
-                spinner.fail(chalk.red('❌ Pack non trouvé'));
-                console.log(chalk.yellow(`📁 Chemin: ${targetPath}`));
+                spinner.fail(chalk.red('❌ Pack not found'));
+                console.log(chalk.yellow(`📁 Path: ${targetPath}`));
                 return { success: false, exitCode: 1 };
             }
             // Load pack
@@ -95,19 +146,29 @@ export class QA360Pack {
                 pack = yaml.load(packContent);
             }
             catch (parseError) {
-                spinner.fail(chalk.red('❌ Erreur de parsing YAML'));
-                console.log(chalk.red(`\n🔍 Erreur: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
+                spinner.fail(chalk.red('❌ YAML parse error'));
+                console.log(chalk.red(`\n🔍 Error: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
                 return { success: false, exitCode: 1 };
             }
             // Apply auto-fixes
             const fixes = this.applyAutoFixes(pack);
             if (fixes.length === 0) {
-                spinner.succeed(chalk.green('✅ Pack déjà conforme'));
+                spinner.succeed(chalk.green('✅ Pack already valid'));
                 return { success: true, exitCode: 0 };
             }
             // Validate after fixes
-            const result = this.validator.validate(pack);
-            if (result.valid || result.errors.length < 5) { // Allow some remaining errors
+            const detectedVersion = this.detectPackVersion(pack);
+            let valid = false;
+            if (detectedVersion === 2) {
+                const validator = new PackValidatorV2(targetPath);
+                const result = await validator.validate(pack);
+                valid = result.valid || result.errors.length < 5;
+            }
+            else {
+                const result = this.validatorV1.validate(pack);
+                valid = result.valid || result.errors.length < 5;
+            }
+            if (valid) {
                 // Save fixed pack
                 const fixedYaml = yaml.dump(pack, {
                     indent: 2,
@@ -115,112 +176,132 @@ export class QA360Pack {
                     noRefs: true
                 });
                 writeFileSync(targetPath, fixedYaml, 'utf8');
-                spinner.succeed(chalk.green('✅ Pack corrigé et sauvegardé'));
-                console.log(chalk.blue('\n🔧 Corrections appliquées:'));
+                spinner.succeed(chalk.green('✅ Pack fixed and saved'));
+                console.log(chalk.blue('\n🔧 Fixes applied:'));
                 for (const fix of fixes) {
                     console.log(chalk.green(`  • ${fix}`));
                 }
-                // Show remaining issues
-                if (result.errors.length > 0) {
-                    console.log(chalk.yellow('\n⚠️  Corrections manuelles requises:'));
-                    for (const error of result.errors.slice(0, 3)) { // Show max 3
-                        console.log(chalk.yellow(`  • ${error.message}`));
-                        if (error.suggestion) {
-                            console.log(chalk.blue(`    💡 ${error.suggestion}`));
-                        }
-                    }
-                }
                 return { success: true, exitCode: 0 };
             }
             else {
-                spinner.fail(chalk.red('❌ Corrections automatiques insuffisantes'));
-                console.log(chalk.red('\n🔍 Erreurs restantes nécessitent une correction manuelle'));
+                spinner.fail(chalk.red('❌ Auto-fix insufficient'));
+                console.log(chalk.red('\n🔍 Manual fixes required'));
                 return { success: false, exitCode: 1 };
             }
         }
         catch (error) {
-            spinner.fail(chalk.red('❌ Erreur lors de la correction'));
-            console.log(chalk.red(`\n🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+            spinner.fail(chalk.red('❌ Lint error'));
+            console.log(chalk.red(`\n🔍 Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
             return { success: false, exitCode: 1 };
         }
     }
     /**
-     * Migrate legacy pack to v1
+     * Migrate pack to v2
      */
-    async migrate(packPath) {
-        const spinner = ora('🔄 Migration du pack vers v1...').start();
+    async migrate(packPath, options) {
+        const spinner = ora('🔄 Migrating pack to v2...').start();
         try {
             const targetPath = packPath || this.packPath;
             if (!existsSync(targetPath)) {
-                spinner.fail(chalk.red('❌ Pack non trouvé'));
-                console.log(chalk.yellow(`📁 Chemin: ${targetPath}`));
+                spinner.fail(chalk.red('❌ Pack not found'));
+                console.log(chalk.yellow(`📁 Path: ${targetPath}`));
                 return { success: false, exitCode: 1 };
             }
-            // Load legacy pack
+            // Load pack
             const packContent = readFileSync(targetPath, 'utf8');
-            let legacyPack;
+            let pack;
             try {
-                legacyPack = yaml.load(packContent);
+                pack = yaml.load(packContent);
             }
             catch (parseError) {
-                spinner.fail(chalk.red('❌ Erreur de parsing YAML'));
-                console.log(chalk.red(`\n🔍 Erreur: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
+                spinner.fail(chalk.red('❌ YAML parse error'));
+                console.log(chalk.red(`\n🔍 Error: ${parseError instanceof Error ? parseError.message : 'Parse error'}`));
                 return { success: false, exitCode: 1 };
             }
-            // Check if already v1
-            if (legacyPack.version === 1) {
-                spinner.succeed(chalk.green('✅ Pack déjà en version 1'));
+            // Check current version
+            const detectedVersion = this.detectPackVersion(pack);
+            if (detectedVersion === 2) {
+                spinner.succeed(chalk.green('✅ Pack already in v2 format'));
                 return { success: true, exitCode: 0 };
             }
-            // Migrate
-            const migrationResult = this.migrator.migrate(legacyPack);
+            if (detectedVersion !== 1) {
+                spinner.fail(chalk.yellow('⚠️  Unknown pack format'));
+                console.log(chalk.yellow(`Version detected: ${pack.version || 'unknown'}`));
+                return { success: false, exitCode: 1 };
+            }
+            // Migrate v1 to v2
+            const migrator = new PackMigrator();
+            const migrationResult = migrator.migrate(pack);
             if (!migrationResult.success) {
-                spinner.fail(chalk.red('❌ Échec de la migration'));
-                console.log(chalk.red('\n🔍 Erreurs:'));
+                spinner.fail(chalk.red('❌ Migration failed'));
+                console.log(chalk.red('\n🔍 Errors:'));
                 for (const warning of migrationResult.warnings) {
                     console.log(chalk.red(`  • ${warning}`));
                 }
                 return { success: false, exitCode: 1 };
             }
-            // Create backup
-            const backupPath = `${targetPath}.backup`;
-            writeFileSync(backupPath, packContent, 'utf8');
-            // Save migrated pack
-            const migratedYaml = yaml.dump(migrationResult, {
-                indent: 2,
-                lineWidth: 120,
-                noRefs: true
-            });
-            writeFileSync(targetPath, migratedYaml, 'utf8');
-            spinner.succeed(chalk.green('✅ Migration réussie'));
-            console.log(chalk.blue(`\n🔄 Migration ${migrationResult.fromVersion} → ${migrationResult.toVersion}`));
-            console.log(chalk.gray(`📁 Sauvegarde: ${backupPath}`));
-            console.log(chalk.blue('\n🔧 Modifications appliquées:'));
-            for (const change of migrationResult.changes.slice(0, 5)) { // Show max 5
-                const icon = change.type === 'added' ? '➕' :
-                    change.type === 'modified' ? '🔧' :
-                        change.type === 'removed' ? '➖' : '🔄';
-                console.log(chalk.green(`  ${icon} ${change.path}: ${change.reason}`));
-            }
-            if (migrationResult.changes.length > 5) {
-                console.log(chalk.gray(`  ... et ${migrationResult.changes.length - 5} autres modifications`));
-            }
-            // Show warnings
+            const outputPath = options?.output || targetPath;
+            if (!options?.dryRun) {
+                // Create backup
+                const backupPath = `${outputPath}.backup`;
+                writeFileSync(backupPath, packContent, 'utf8');
+                // Save migrated pack
+                const migratedYaml = yaml.dump(migrationResult.migrated, {
+                    indent: 2,
+                    lineWidth: 120,
+                    noRefs: true
+                });
+                writeFileSync(outputPath, migratedYaml, 'utf8');
+            }
+            spinner.succeed(chalk.green('✅ Migration successful'));
+            console.log(chalk.blue(`\n🔄 Migration v1 → v2`));
+            if (options?.dryRun) {
+                console.log(chalk.yellow('  ⚠️  Dry run mode - no files written'));
+            }
+            else {
+                console.log(chalk.gray(`📁 Output: ${outputPath}`));
+                console.log(chalk.gray(`📁 Backup: ${outputPath}.backup`));
+            }
+            console.log(chalk.blue('\n🔧 Changes applied:'));
+            for (const change of migrationResult.changes.slice(0, 10)) {
+                console.log(chalk.green(`  • ${change}`));
+            }
+            if (migrationResult.changes.length > 10) {
+                console.log(chalk.gray(`  ... and ${migrationResult.changes.length - 10} more changes`));
+            }
             if (migrationResult.warnings.length > 0) {
-                console.log(chalk.yellow('\n⚠️  Avertissements:'));
+                console.log(chalk.yellow('\n⚠️  Warnings:'));
                 for (const warning of migrationResult.warnings) {
                     console.log(chalk.yellow(`  • ${warning}`));
                 }
             }
-            console.log(chalk.blue('\n🔍 Validation recommandée: qa360 pack validate'));
+            console.log(chalk.blue('\n💡 Next: qa360 pack validate'));
             return { success: true, exitCode: 0 };
         }
         catch (error) {
-            spinner.fail(chalk.red('❌ Erreur de migration'));
-            console.log(chalk.red(`\n🔍 Erreur: ${error instanceof Error ? error.message : 'Unknown error'}`));
+            spinner.fail(chalk.red('❌ Migration error'));
+            console.log(chalk.red(`\n🔍 Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
             return { success: false, exitCode: 1 };
         }
     }
+    /**
+     * Detect pack version
+     */
+    detectPackVersion(pack) {
+        if (pack.version === 2)
+            return 2;
+        if (pack.version === 1)
+            return 1;
+        // Heuristic detection
+        if (pack.gates && Array.isArray(pack.gates))
+            return 1;
+        if (pack.gates && typeof pack.gates === 'object' && !Array.isArray(pack.gates)) {
+            const firstGate = Object.values(pack.gates)[0];
+            if (firstGate?.test_files || firstGate?.adapter)
+                return 2;
+        }
+        return 'unknown';
+    }
     /**
      * Apply automatic fixes to pack
      */
@@ -228,51 +309,42 @@ export class QA360Pack {
         const fixes = [];
         // Add version if missing
         if (!pack.version) {
-            pack.version = 1;
-            fixes.push('Ajout version: 1');
+            pack.version = 2; // Default to v2 now
+            fixes.push('Added version: 2');
         }
         // Add default execution if missing
-        if (!pack.execution) {
+        if (!pack.execution && pack.version === 1) {
             pack.execution = {
                 retry_on: ['ECONNRESET', '502'],
                 max_retries: 1,
                 fail_on_readiness: true,
                 timeout: 30000
             };
-            fixes.push('Ajout configuration execution par défaut');
+            fixes.push('Added default execution configuration');
         }
-        // Add default observability if missing
-        if (!pack.observability) {
-            pack.observability = {
-                metrics: true,
-                trace: 'basic'
+        // Add default execution for v2
+        if (!pack.execution && pack.version === 2) {
+            pack.execution = {
+                on_failure: 'stop',
+                default_timeout: 30000,
+                default_retries: 1
             };
-            fixes.push('Ajout configuration observability par défaut');
+            fixes.push('Added default execution configuration (v2)');
         }
         // Fix name pattern if needed
         if (pack.name && !/^[a-zA-Z0-9_-]+$/.test(pack.name)) {
             const oldName = pack.name;
             pack.name = pack.name.replace(/[^a-zA-Z0-9_-]/g, '_');
-            fixes.push(`Correction nom: "${oldName}" → "${pack.name}"`);
-        }
-        // Add default gates if missing
-        if (!pack.gates || pack.gates.length === 0) {
-            pack.gates = ['api_smoke'];
-            fixes.push('Ajout gate par défaut: api_smoke');
-        }
-        // Add security.secrets_leak if security section exists
-        if (pack.security && pack.security.secrets_leak === undefined) {
-            pack.security.secrets_leak = 0;
-            fixes.push('Ajout security.secrets_leak: 0');
+            fixes.push(`Fixed name: "${oldName}" → "${pack.name}"`);
         }
         return fixes;
     }
     /**
-     * Show pack summary
+     * Show v1 pack summary
      */
     showPackSummary(pack) {
-        console.log(chalk.blue('\n📋 Résumé du pack:'));
-        console.log(chalk.gray(`  📦 Nom: ${pack.name}`));
+        console.log(chalk.blue('\n📋 Pack summary:'));
+        console.log(chalk.gray(`  📦 Name: ${pack.name}`));
         console.log(chalk.gray(`  🎯 Gates: ${pack.gates.join(', ')}`));
         if (pack.targets?.api) {
             console.log(chalk.gray(`  🌐 API: ${pack.targets.api.baseUrl}`));
@@ -292,14 +364,41 @@ export class QA360Pack {
         }
         if (pack.environment) {
             const envCount = Object.keys(pack.environment).length;
-            console.log(chalk.gray(`  🔧 Variables: ${envCount} définies`));
+            console.log(chalk.gray(`  🔧 Variables: ${envCount} defined`));
+        }
+    }
+    /**
+     * Show v2 pack summary
+     */
+    showPackV2Summary(pack, validation) {
+        console.log(chalk.blue('\n📋 Pack v2 summary:'));
+        console.log(chalk.gray(`  📦 Name: ${pack.name}`));
+        console.log(chalk.gray(`  🎯 Gates: ${Object.keys(pack.gates).join(', ')}`));
+        if (validation?.info) {
+            const { info } = validation;
+            if (info.totalTests !== undefined) {
+                console.log(chalk.gray(`  🧪 Tests: ${info.totalTests} found`));
+            }
+            if (info.frameworks && info.frameworks.length > 0) {
+                console.log(chalk.gray(`  🔧 Frameworks: ${info.frameworks.join(', ')}`));
+            }
+        }
+        if (pack.auth?.profiles) {
+            const profileNames = Object.keys(pack.auth.profiles);
+            if (profileNames.length > 0) {
+                console.log(chalk.gray(`  🔐 Auth profiles: ${profileNames.join(', ')}`));
+            }
+        }
+        if (pack.variables) {
+            const varCount = Object.keys(pack.variables).length;
+            console.log(chalk.gray(`  🔧 Variables: ${varCount} defined`));
         }
     }
 }
 // Command handlers
-export async function packValidateCommand(packPath) {
+export async function packValidateCommand(packPath, options) {
     const pack = new QA360Pack();
-    const result = await pack.validate(packPath);
+    const result = await pack.validate(packPath, options);
     process.exit(result.exitCode);
 }
 export async function packLintCommand(packPath) {
@@ -307,8 +406,8 @@ export async function packLintCommand(packPath) {
     const result = await pack.lint(packPath);
     process.exit(result.exitCode);
 }
-export async function packMigrateCommand(packPath) {
+export async function packMigrateCommand(packPath, options) {
     const pack = new QA360Pack();
-    const result = await pack.migrate(packPath);
+    const result = await pack.migrate(packPath, options);
     process.exit(result.exitCode);
 }

package/dist/commands/regression.d.ts

@@ -0,0 +1,8 @@
+/**
+ * QA360 Regression Command
+ *
+ * CLI command for regression detection and analysis.
+ */
+import { Command } from 'commander';
+export declare const regressionCommand: Command;
+export default regressionCommand;