qa360 2.2.1 → 2.2.13

package/core/src/pack/migrator.ts

@@ -1,353 +0,0 @@
-/**
- * QA360 Pack Migrator
- * Migrates legacy pack configurations to v1 format
- */
-
-import { PackConfigV1, LegacyPackConfig, PackMigrationResult, PackMigrationChange, QualityGate } from '../types/pack-v1.js';
-
-export class PackMigrator {
-  
-  /**
-   * Migrate legacy pack to v1 format
-   */
-  migrate(legacyPack: LegacyPackConfig): PackMigrationResult {
-    const changes: PackMigrationChange[] = [];
-    const warnings: string[] = [];
-    
-    try {
-      const v1Pack: PackConfigV1 = {
-        version: 1,
-        name: this.migrateName(legacyPack.name, changes),
-        gates: this.migrateGates(legacyPack, changes, warnings),
-      };
-
-      // Optional fields
-      if (legacyPack.description) {
-        v1Pack.description = legacyPack.description;
-      }
-
-      // Migrate targets from adapters and tests
-      const targets = this.migrateTargets(legacyPack, changes, warnings);
-      if (Object.keys(targets).length > 0) {
-        v1Pack.targets = targets;
-      }
-
-      // Migrate environment
-      if (legacyPack.environment) {
-        v1Pack.environment = this.migrateEnvironment(legacyPack.environment, changes, warnings);
-      }
-
-      // Migrate hooks
-      if (legacyPack.hooks) {
-        v1Pack.hooks = this.migrateHooks(legacyPack.hooks, changes);
-      }
-
-      // Add default execution settings
-      v1Pack.execution = {
-        retry_on: ['ECONNRESET', '502'],
-        max_retries: 1,
-        fail_on_readiness: true,
-        timeout: 30000
-      };
-      changes.push({
-        type: 'added',
-        path: 'execution',
-        newValue: v1Pack.execution,
-        reason: 'Added default execution configuration for v1'
-      });
-
-      // Add default observability
-      v1Pack.observability = {
-        metrics: true,
-        trace: 'basic'
-      };
-      changes.push({
-        type: 'added',
-        path: 'observability',
-        newValue: v1Pack.observability,
-        reason: 'Added default observability configuration for v1'
-      });
-
-      return {
-        success: true,
-        fromVersion: legacyPack.version || '0.9.x',
-        toVersion: '1',
-        changes,
-        warnings
-      };
-
-    } catch (error) {
-      return {
-        success: false,
-        fromVersion: legacyPack.version || '0.9.x',
-        toVersion: '1',
-        changes,
-        warnings: [...warnings, `Migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`]
-      };
-    }
-  }
-
-  /**
-   * Migrate pack name to v1 format
-   */
-  private migrateName(name: string, changes: PackMigrationChange[]): string {
-    // Sanitize name for v1 requirements (alphanumeric, underscore, hyphen only)
-    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
-    
-    if (sanitized !== name) {
-      changes.push({
-        type: 'modified',
-        path: 'name',
-        oldValue: name,
-        newValue: sanitized,
-        reason: 'Sanitized name to match v1 pattern requirements'
-      });
-    }
-
-    return sanitized;
-  }
-
-  /**
-   * Migrate adapters and tests to quality gates
-   */
-  private migrateGates(legacyPack: LegacyPackConfig, changes: PackMigrationChange[], warnings: string[]): QualityGate[] {
-    const gates: Set<QualityGate> = new Set();
-
-    // Map adapters to gates
-    if (legacyPack.adapters) {
-      for (const adapter of legacyPack.adapters) {
-        const mappedGates = this.mapAdapterToGates(adapter);
-        mappedGates.forEach(gate => gates.add(gate));
-      }
-    }
-
-    // Map tests to gates
-    if (legacyPack.tests) {
-      for (const test of legacyPack.tests) {
-        const mappedGates = this.mapAdapterToGates(test.adapter);
-        mappedGates.forEach(gate => gates.add(gate));
-      }
-    }
-
-    // Default to api_smoke if no gates detected
-    if (gates.size === 0) {
-      gates.add('api_smoke');
-      warnings.push('No recognizable adapters found, defaulting to api_smoke gate');
-    }
-
-    const gateArray = Array.from(gates);
-    
-    changes.push({
-      type: 'added',
-      path: 'gates',
-      newValue: gateArray,
-      reason: `Mapped adapters [${legacyPack.adapters?.join(', ') || 'none'}] to quality gates`
-    });
-
-    return gateArray;
-  }
-
-  /**
-   * Map legacy adapter names to quality gates
-   */
-  private mapAdapterToGates(adapter: string): QualityGate[] {
-    const mapping: Record<string, QualityGate[]> = {
-      'playwright': ['api_smoke', 'ui'],
-      'k6': ['perf'],
-      'lighthouse': ['perf', 'a11y'],
-      'semgrep': ['sast'],
-      'zap': ['dast'],
-      'axe': ['a11y'],
-      'jest': ['api_smoke'],
-      'cypress': ['ui'],
-      'puppeteer': ['ui']
-    };
-
-    return mapping[adapter.toLowerCase()] || ['api_smoke'];
-  }
-
-  /**
-   * Migrate targets from legacy configuration
-   */
-  private migrateTargets(legacyPack: LegacyPackConfig, changes: PackMigrationChange[], warnings: string[]) {
-    const targets: any = {};
-
-    // Try to extract API target from environment or tests
-    const apiUrl = this.extractApiUrl(legacyPack);
-    if (apiUrl) {
-      targets.api = {
-        baseUrl: apiUrl,
-        smoke: ['GET /health -> 200'] // Default smoke test
-      };
-      
-      changes.push({
-        type: 'added',
-        path: 'targets.api',
-        newValue: targets.api,
-        reason: `Extracted API target from configuration`
-      });
-    }
-
-    // Try to extract Web target
-    const webUrl = this.extractWebUrl(legacyPack);
-    if (webUrl && webUrl !== apiUrl) {
-      targets.web = {
-        baseUrl: webUrl,
-        pages: ['/'] // Default to homepage
-      };
-      
-      changes.push({
-        type: 'added',
-        path: 'targets.web',
-        newValue: targets.web,
-        reason: `Extracted web target from configuration`
-      });
-    }
-
-    return targets;
-  }
-
-  /**
-   * Extract API URL from legacy configuration
-   */
-  private extractApiUrl(legacyPack: LegacyPackConfig): string | null {
-    // Check environment variables
-    if (legacyPack.environment) {
-      const candidates = ['API_URL', 'BASE_URL', 'TARGET_URL', 'SERVER_URL'];
-      for (const candidate of candidates) {
-        const url = legacyPack.environment[candidate];
-        if (url && this.isValidUrl(url)) {
-          return url;
-        }
-      }
-    }
-
-    // Check test configurations
-    if (legacyPack.tests) {
-      for (const test of legacyPack.tests) {
-        if (test.config?.baseURL && this.isValidUrl(test.config.baseURL)) {
-          return test.config.baseURL;
-        }
-        if (test.config?.url && this.isValidUrl(test.config.url)) {
-          return test.config.url;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Extract Web URL from legacy configuration
-   */
-  private extractWebUrl(legacyPack: LegacyPackConfig): string | null {
-    // Similar logic to API URL but looking for web-specific patterns
-    if (legacyPack.environment) {
-      const candidates = ['WEB_URL', 'FRONTEND_URL', 'UI_URL', 'APP_URL'];
-      for (const candidate of candidates) {
-        const url = legacyPack.environment[candidate];
-        if (url && this.isValidUrl(url)) {
-          return url;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Validate URL format
-   */
-  private isValidUrl(url: string): boolean {
-    try {
-      new URL(url);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Migrate environment variables
-   */
-  private migrateEnvironment(env: Record<string, string>, changes: PackMigrationChange[], warnings: string[]): Record<string, string> {
-    const migratedEnv: Record<string, string> = {};
-    
-    for (const [key, value] of Object.entries(env)) {
-      // Convert to uppercase with underscores (v1 requirement)
-      const normalizedKey = key.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
-      
-      if (normalizedKey !== key) {
-        changes.push({
-          type: 'renamed',
-          path: `environment.${key}`,
-          oldValue: key,
-          newValue: normalizedKey,
-          reason: 'Normalized environment variable name for v1 requirements'
-        });
-      }
-
-      // Check for potential secrets
-      if (this.looksLikeSecret(value)) {
-        warnings.push(`Environment variable ${normalizedKey} appears to contain a secret. Consider using: \${{ secrets.${normalizedKey} }}`);
-      }
-
-      migratedEnv[normalizedKey] = value;
-    }
-
-    return migratedEnv;
-  }
-
-  /**
-   * Migrate hooks from legacy format
-   */
-  private migrateHooks(hooks: any, changes: PackMigrationChange[]) {
-    const migratedHooks: any = {};
-
-    if (hooks.beforeAll) {
-      migratedHooks.beforeAll = hooks.beforeAll.map((cmd: string) => ({
-        run: cmd,
-        timeout: 30000
-      }));
-      
-      changes.push({
-        type: 'modified',
-        path: 'hooks.beforeAll',
-        oldValue: hooks.beforeAll,
-        newValue: migratedHooks.beforeAll,
-        reason: 'Converted string commands to v1 hook object format'
-      });
-    }
-
-    if (hooks.afterAll) {
-      migratedHooks.afterAll = hooks.afterAll.map((cmd: string) => ({
-        run: cmd,
-        timeout: 30000
-      }));
-      
-      changes.push({
-        type: 'modified',
-        path: 'hooks.afterAll',
-        oldValue: hooks.afterAll,
-        newValue: migratedHooks.afterAll,
-        reason: 'Converted string commands to v1 hook object format'
-      });
-    }
-
-    return migratedHooks;
-  }
-
-  /**
-   * Check if a value looks like a secret
-   */
-  private looksLikeSecret(value: string): boolean {
-    const secretPatterns = [
-      /^[A-Za-z0-9+/]{20,}={0,2}$/, // Base64-like
-      /^[a-f0-9]{32,}$/i,           // Hex tokens
-      /^sk-[a-zA-Z0-9]{32,}$/,      // API keys
-      /^ghp_[a-zA-Z0-9]{36}$/,      // GitHub tokens
-    ];
-
-    return secretPatterns.some(pattern => pattern.test(value));
-  }
-}

package/core/src/pack/validator.ts

@@ -1,359 +0,0 @@
-/**
- * QA360 Pack v1 Validator
- * Validates pack.yml files against the official schema
- */
-
-import Ajv, { JSONSchemaType } from 'ajv';
-import addFormats from 'ajv-formats';
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { PackConfigV1, PackValidationResult, PackValidationError, PackValidationWarning } from '../types/pack-v1.js';
-
-export class PackValidator {
-  private ajv: Ajv;
-  private schema: any;
-
-  constructor() {
-    this.ajv = new Ajv({
-      allErrors: true,
-      verbose: true,
-      strict: false
-    });
-    addFormats(this.ajv);
-
-    // Load schema (ES modules compatible)
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const schemaPath = join(__dirname, '../../schemas/pack.schema.json');
-    this.schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
-    this.ajv.addSchema(this.schema, 'pack-v1');
-  }
-
-  /**
-   * Validate a pack configuration
-   */
-  validate(pack: any): PackValidationResult {
-    const errors: PackValidationError[] = [];
-    const warnings: PackValidationWarning[] = [];
-
-    // Check version first to determine which schema to use
-    const version = pack.version;
-
-    if (version === 2) {
-      // Version 2 uses a different structure (object gates)
-      // For now, return a helpful message that v2 is not fully supported
-      errors.push({
-        code: 'QP200',
-        path: 'version',
-        message: 'Pack version 2 is not yet supported in this release',
-        suggestion: 'Use version: 1 with the v1 format. See docs for v1 format examples.'
-      });
-      return {
-        valid: false,
-        errors,
-        warnings
-      };
-    }
-
-    if (version > 2 || version < 1) {
-      errors.push({
-        code: 'QP201',
-        path: 'version',
-        message: `Unsupported pack version: ${version}`,
-        suggestion: 'Use version: 1 (current) or version: 2 (coming soon)'
-      });
-      return {
-        valid: false,
-        errors,
-        warnings
-      };
-    }
-
-    // Schema validation for v1
-    const valid = this.ajv.validate('pack-v1', pack);
-
-    if (!valid && this.ajv.errors) {
-      for (const error of this.ajv.errors) {
-        errors.push({
-          code: this.getErrorCode(error),
-          path: error.instancePath || error.schemaPath || 'root',
-          message: this.formatErrorMessage(error),
-          suggestion: this.getSuggestion(error)
-        });
-      }
-    }
-
-    // Custom business logic validation
-    if (valid) {
-      const businessRules = this.validateBusinessRules(pack as PackConfigV1);
-      errors.push(...businessRules.errors);
-      warnings.push(...businessRules.warnings);
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    };
-  }
-
-  /**
-   * Validate business rules beyond schema
-   */
-  private validateBusinessRules(pack: PackConfigV1): { errors: PackValidationError[]; warnings: PackValidationWarning[] } {
-    const errors: PackValidationError[] = [];
-    const warnings: PackValidationWarning[] = [];
-
-    // Check gate-target consistency (only for non-minimal packs)
-    if (pack.gates.includes('api_smoke') && !pack.targets?.api) {
-      // For minimal smoke packs, this is a warning, not an error
-      if (pack.gates.length === 1 && pack.gates[0] === 'api_smoke') {
-        warnings.push({
-          code: 'QP001',
-          path: 'targets.api',
-          message: 'API smoke gate without api target - using default configuration',
-          suggestion: 'Add targets.api with baseUrl for better control'
-        });
-      } else {
-        errors.push({
-          code: 'QP001',
-          path: 'targets.api',
-          message: 'API smoke gate requires api target configuration',
-          suggestion: 'Add targets.api with baseUrl'
-        });
-      }
-    }
-
-    if (pack.gates.includes('ui') && !pack.targets?.web) {
-      errors.push({
-        code: 'QP002',
-        path: 'targets.web',
-        message: 'UI gate requires web target configuration',
-        suggestion: 'Add targets.web with baseUrl'
-      });
-    }
-
-    // Check budget recommendations
-    if (pack.gates.includes('perf') && !pack.budgets?.perf_p95_ms) {
-      warnings.push({
-        code: 'QP003',
-        path: 'budgets.perf_p95_ms',
-        message: 'Performance gate without budget may not fail appropriately',
-        suggestion: 'Add budgets.perf_p95_ms (recommended: 800-2000ms)'
-      });
-    }
-
-    if (pack.gates.includes('a11y') && !pack.budgets?.a11y_min) {
-      warnings.push({
-        code: 'QP004',
-        path: 'budgets.a11y_min',
-        message: 'Accessibility gate without budget may not fail appropriately',
-        suggestion: 'Add budgets.a11y_min (recommended: 90-95%)'
-      });
-    }
-
-    // Check security configuration
-    if ((pack.gates.includes('sast') || pack.gates.includes('dast')) && !pack.security) {
-      warnings.push({
-        code: 'QP005',
-        path: 'security',
-        message: 'Security gates without security configuration',
-        suggestion: 'Add security section with sast_max_high and secrets_leak settings'
-      });
-    }
-
-    // Check for potential secrets in plain text (ignore secret references)
-    if (pack.environment) {
-      const SECRET_REF = /\$\{\{\s*secrets\.[A-Z0-9_]+\s*\}\}/g;
-      
-      for (const [key, value] of Object.entries(pack.environment)) {
-        if (typeof value === 'string' && !SECRET_REF.test(value) && this.looksLikeSecret(value)) {
-          errors.push({
-            code: 'QP006',
-            path: `environment.${key}`,
-            message: 'Potential secret detected in plain text',
-            suggestion: `Use secret reference: \${{ secrets.${key.toUpperCase()} }}`
-          });
-        }
-      }
-    }
-
-    // Check for dangerous hook commands
-    if (pack.hooks) {
-      const dangerousCommands = ['rm -rf', 'sudo rm', 'del /f', 'format', 'mkfs', 'dd if='];
-      
-      ['beforeAll', 'beforeEach', 'afterEach', 'afterAll'].forEach(hookType => {
-        const hooks = pack.hooks![hookType as keyof typeof pack.hooks];
-        if (hooks) {
-          hooks.forEach((hook, index) => {
-            const command = typeof hook === 'string' ? hook : 
-              ('run' in hook ? hook.run : 
-               'compose' in hook ? `compose ${hook.compose}` :
-               'wait_on' in hook ? `wait_on ${hook.wait_on}` : '');
-            if (command && dangerousCommands.some(dangerous => command.toLowerCase().includes(dangerous))) {
-              warnings.push({
-                code: 'QP007',
-                path: `hooks.${hookType}[${index}]`,
-                message: 'Potentially dangerous command detected',
-                suggestion: 'Review command for safety'
-              });
-            }
-          });
-        }
-      });
-    }
-
-    return { errors, warnings };
-  }
-
-  /**
-   * Check if a value looks like a secret
-   */
-  private looksLikeSecret(value: string): boolean {
-    const secretPatterns = [
-      /^[A-Za-z0-9+/]{20,}={0,2}$/, // Base64-like
-      /^[a-f0-9]{32,}$/i,           // Hex tokens
-      /^sk-[a-zA-Z0-9]{32,}$/,      // API keys
-      /^ghp_[a-zA-Z0-9]{36}$/,      // GitHub tokens
-      /^xoxb-[a-zA-Z0-9-]+$/,       // Slack tokens
-    ];
-
-    return secretPatterns.some(pattern => pattern.test(value));
-  }
-
-  /**
-   * Check if a value is a secret reference
-   */
-  private isSecretReference(value: string): boolean {
-    return /^\$\{\{\s*secrets\.[A-Z_][A-Z0-9_]*\s*\}\}$/.test(value);
-  }
-
-  /**
-   * Validate hook commands for security issues
-   */
-  private validateHookSecurity(hooks: any[], basePath: string, warnings: PackValidationWarning[]) {
-    for (let i = 0; i < hooks.length; i++) {
-      const hook = hooks[i];
-      if (typeof hook.run === 'string') {
-        // Check for dangerous commands
-        const dangerousPatterns = [
-          /rm\s+-rf\s+\//, // rm -rf /
-          /sudo\s+/,       // sudo commands
-          /curl.*\|\s*sh/, // curl | sh
-          /wget.*\|\s*sh/, // wget | sh
-        ];
-
-        for (const pattern of dangerousPatterns) {
-          if (pattern.test(hook.run)) {
-            warnings.push({
-              code: 'QP007',
-              path: `${basePath}[${i}].run`,
-              message: 'Potentially dangerous command detected',
-              suggestion: 'Review command for security implications'
-            });
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Get error code from AJV error
-   */
-  private getErrorCode(error: any): string {
-    const codeMap: Record<string, string> = {
-      'required': 'QP100',
-      'type': 'QP101',
-      'format': 'QP102',
-      'pattern': 'QP103',
-      'enum': 'QP104',
-      'const': 'QP105',
-      'minimum': 'QP106',
-      'maximum': 'QP107',
-      'minLength': 'QP108',
-      'maxLength': 'QP109',
-      'minItems': 'QP110',
-      'uniqueItems': 'QP111',
-      'additionalProperties': 'QP112'
-    };
-
-    return codeMap[error.keyword] || 'QP999';
-  }
-
-  /**
-   * Format error message for better UX
-   */
-  private formatErrorMessage(error: any): string {
-    const path = error.instancePath || 'root';
-    
-    switch (error.keyword) {
-      case 'required':
-        return `Missing required field: ${error.params.missingProperty}`;
-      case 'type':
-        return `Expected ${error.params.type}, got ${typeof error.data}`;
-      case 'format':
-        return `Invalid ${error.params.format} format`;
-      case 'pattern':
-        return `Value does not match required pattern`;
-      case 'enum':
-        return `Value must be one of: ${error.params.allowedValues.join(', ')}`;
-      case 'const':
-        return `Value must be exactly: ${error.params.allowedValue}`;
-      case 'minimum':
-        return `Value must be >= ${error.params.limit}`;
-      case 'maximum':
-        return `Value must be <= ${error.params.limit}`;
-      case 'minLength':
-        return `Value must be at least ${error.params.limit} characters`;
-      case 'maxLength':
-        return `Value must be at most ${error.params.limit} characters`;
-      case 'minItems':
-        return `Array must have at least ${error.params.limit} items`;
-      case 'uniqueItems':
-        return `Array items must be unique`;
-      case 'additionalProperties':
-        return `Unknown property: ${error.params.additionalProperty}`;
-      default:
-        return error.message || 'Validation error';
-    }
-  }
-
-  /**
-   * Get suggestion for fixing error
-   */
-  private getSuggestion(error: any): string | undefined {
-    switch (error.keyword) {
-      case 'required':
-        const field = error.params.missingProperty;
-        const suggestions: Record<string, string> = {
-          'version': 'Add: version: 1',
-          'name': 'Add: name: "my-pack"',
-          'gates': 'Add: gates: ["api_smoke"]',
-          'baseUrl': 'Add: baseUrl: "https://api.example.com"'
-        };
-        return suggestions[field];
-      
-      case 'enum':
-        return `Use one of: ${error.params.allowedValues.join(', ')}`;
-      
-      case 'format':
-        if (error.params.format === 'uri') {
-          return 'Use full URL with protocol: https://example.com';
-        }
-        break;
-      
-      case 'pattern':
-        if (error.instancePath.includes('name')) {
-          return 'Use only letters, numbers, underscore, and hyphen';
-        }
-        if (error.instancePath.includes('smoke')) {
-          return 'Format: "GET /path -> 200"';
-        }
-        break;
-    }
-    
-    return undefined;
-  }
-}