qa360 2.1.7 → 2.2.0

package/cli/src/commands/pack.ts

@@ -0,0 +1,497 @@
+/**
+ * QA360 Pack Commands
+ *
+ * Implements pack validate, lint, and migrate commands
+ * Supports both v1 and v2 pack formats
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as yaml from 'js-yaml';
+import { PackValidator, PackMigrator as PackMigratorV1, PackConfigV1 } from 'qa360-core';
+import { PackValidatorV2, PackMigrator, PackLoaderV2, PackConfigV2, PackMigrationResultV2 } from 'qa360-core';
+
+// Legacy types for v1 migration
+interface LegacyPackConfig {
+  name: string;
+  version?: string;
+  description?: string;
+  adapters?: string[];
+  tests?: Array<{
+    name: string;
+    adapter: string;
+    config: any;
+  }>;
+  environment?: Record<string, string>;
+  hooks?: {
+    beforeAll?: string[];
+    afterAll?: string[];
+  };
+}
+
+export class QA360Pack {
+  private qa360Dir = resolve(process.cwd(), '.qa360');
+  private packPath = resolve(this.qa360Dir, 'pack.yml');
+  private validatorV1 = new PackValidator();
+  private migratorV1 = new PackMigratorV1();
+
+  /**
+   * Validate pack.yml (auto-detects v1 or v2)
+   */
+  async validate(packPath?: string, options?: { checkFiles?: boolean }): Promise<{ valid: boolean; exitCode: number }> {
+    const spinner = ora('🔍 Validating pack...').start();
+
+    try {
+      const targetPath = packPath || this.packPath;
+
+      if (!existsSync(targetPath)) {
+        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
+      const packContent = readFileSync(targetPath, 'utf8');
+      let pack: any;
+
+      try {
+        pack = yaml.load(packContent);
+      } catch (parseError) {
+        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 };
+      }
+
+      // 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
+   */
+  private async validateV1(pack: any, spinner: any): Promise<{ valid: boolean; exitCode: number }> {
+    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}`));
+          }
+        }
+      }
+
+      this.showPackSummary(pack as PackConfigV1);
+
+      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
+   */
+  private async validateV2(
+    packPath: string,
+    pack: any,
+    spinner: any,
+    checkFiles?: boolean
+  ): Promise<{ valid: boolean; exitCode: number }> {
+    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}`));
+          }
+        }
+        if (result.warnings.length > 10) {
+          console.log(chalk.gray(`  ... and ${result.warnings.length - 10} more warnings`));
+        }
+      }
+
+      this.showPackV2Summary(pack as PackConfigV2, result);
+
+      return { valid: true, exitCode: 0 };
+    } 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 };
+    }
+  }
+
+  /**
+   * Lint and auto-fix pack.yml
+   */
+  async lint(packPath?: string): Promise<{ success: boolean; exitCode: number }> {
+    const spinner = ora('🔧 Auto-fixing pack...').start();
+
+    try {
+      const targetPath = packPath || this.packPath;
+
+      if (!existsSync(targetPath)) {
+        spinner.fail(chalk.red('❌ Pack not found'));
+        console.log(chalk.yellow(`📁 Path: ${targetPath}`));
+        return { success: false, exitCode: 1 };
+      }
+
+      // Load pack
+      const packContent = readFileSync(targetPath, 'utf8');
+      let pack: any;
+
+      try {
+        pack = yaml.load(packContent);
+      } catch (parseError) {
+        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 already valid'));
+        return { success: true, exitCode: 0 };
+      }
+
+      // Validate after fixes
+      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,
+          lineWidth: 120,
+          noRefs: true
+        });
+        writeFileSync(targetPath, fixedYaml, 'utf8');
+
+        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}`));
+        }
+
+        return { success: true, exitCode: 0 };
+      } else {
+        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('❌ Lint error'));
+      console.log(chalk.red(`\n🔍 Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return { success: false, exitCode: 1 };
+    }
+  }
+
+  /**
+   * Migrate pack to v2
+   */
+  async migrate(packPath?: string, options?: { output?: string; dryRun?: boolean }): Promise<{ success: boolean; exitCode: number }> {
+    const spinner = ora('🔄 Migrating pack to v2...').start();
+
+    try {
+      const targetPath = packPath || this.packPath;
+
+      if (!existsSync(targetPath)) {
+        spinner.fail(chalk.red('❌ Pack not found'));
+        console.log(chalk.yellow(`📁 Path: ${targetPath}`));
+        return { success: false, exitCode: 1 };
+      }
+
+      // Load pack
+      const packContent = readFileSync(targetPath, 'utf8');
+      let pack: any;
+
+      try {
+        pack = yaml.load(packContent);
+      } catch (parseError) {
+        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 current version
+      const detectedVersion = this.detectPackVersion(pack);
+
+      if (detectedVersion === 2) {
+        spinner.succeed(chalk.green('✅ Pack already in v2 format'));
+        return { success: true, exitCode: 0 };
+      }
+
+      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 as any) as unknown as PackMigrationResultV2;
+
+      if (!migrationResult.success) {
+        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 };
+      }
+
+      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⚠️  Warnings:'));
+        for (const warning of migrationResult.warnings) {
+          console.log(chalk.yellow(`  • ${warning}`));
+        }
+      }
+
+      console.log(chalk.blue('\n💡 Next: qa360 pack validate'));
+
+      return { success: true, exitCode: 0 };
+
+    } catch (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
+   */
+  private detectPackVersion(pack: any): 1 | 2 | 'unknown' {
+    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] as any;
+      if (firstGate?.test_files || firstGate?.adapter) return 2;
+    }
+
+    return 'unknown';
+  }
+
+  /**
+   * Apply automatic fixes to pack
+   */
+  private applyAutoFixes(pack: any): string[] {
+    const fixes: string[] = [];
+
+    // Add version if missing
+    if (!pack.version) {
+      pack.version = 2; // Default to v2 now
+      fixes.push('Added version: 2');
+    }
+
+    // Add default execution if missing
+    if (!pack.execution && pack.version === 1) {
+      pack.execution = {
+        retry_on: ['ECONNRESET', '502'],
+        max_retries: 1,
+        fail_on_readiness: true,
+        timeout: 30000
+      };
+      fixes.push('Added default execution configuration');
+    }
+
+    // Add default execution for v2
+    if (!pack.execution && pack.version === 2) {
+      pack.execution = {
+        on_failure: 'stop',
+        default_timeout: 30000,
+        default_retries: 1
+      };
+      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(`Fixed name: "${oldName}" → "${pack.name}"`);
+    }
+
+    return fixes;
+  }
+
+  /**
+   * Show v1 pack summary
+   */
+  private showPackSummary(pack: PackConfigV1) {
+    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}`));
+    }
+    if (pack.targets?.web) {
+      console.log(chalk.gray(`  🖥️  Web: ${pack.targets.web.baseUrl}`));
+    }
+
+    if (pack.budgets) {
+      const budgets = [];
+      if (pack.budgets.perf_p95_ms) budgets.push(`Perf: ${pack.budgets.perf_p95_ms}ms`);
+      if (pack.budgets.a11y_min) budgets.push(`A11y: ${pack.budgets.a11y_min}%`);
+      if (budgets.length > 0) {
+        console.log(chalk.gray(`  📊 Budgets: ${budgets.join(', ')}`));
+      }
+    }
+
+    if (pack.environment) {
+      const envCount = Object.keys(pack.environment).length;
+      console.log(chalk.gray(`  🔧 Variables: ${envCount} defined`));
+    }
+  }
+
+  /**
+   * Show v2 pack summary
+   */
+  private showPackV2Summary(pack: PackConfigV2, validation?: any) {
+    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?: string, options?: { checkFiles?: boolean }) {
+  const pack = new QA360Pack();
+  const result = await pack.validate(packPath, options);
+  process.exit(result.exitCode);
+}
+
+export async function packLintCommand(packPath?: string) {
+  const pack = new QA360Pack();
+  const result = await pack.lint(packPath);
+  process.exit(result.exitCode);
+}
+
+export async function packMigrateCommand(packPath?: string, options?: { output?: string; dryRun?: boolean }) {
+  const pack = new QA360Pack();
+  const result = await pack.migrate(packPath, options);
+  process.exit(result.exitCode);
+}