qa360 1.4.5 → 2.0.1

package/dist/core/index.js

@@ -33,7 +33,46 @@ export { SecretsCrypto } from './secrets/crypto.js';
 // Pack Validation & Migration
 export { PackValidator } from './pack/validator.js';
 export { PackMigrator } from './pack/migrator.js';
+// AI Module (Ollama integration)
+export * from './ai/index.js';
+// Test Discoverer
+export * from './discoverer/index.js';
+// Pack v2 Types
+export * from './types/pack-v2.js';
+// Pack v2 Module (Validation, Migration, Loading)
+export * from './pack-v2/index.js';
+// Explicit exports for TypeScript resolution
+export { PackLoaderV2, PackValidatorV2 } from './pack-v2/index.js';
+// Authentication Module
+export * from './auth/index.js';
+// Generation Module (Phase 4 - AI Test Generation)
+export * from './generation/index.js';
 // Server & Observability
 export { QA360Server } from './serve/server.js';
 // Runner
 export { Phase3Runner } from './runner/phase3-runner.js';
+// Adapters
+export { PlaywrightNativeApiAdapter, createPlaywrightNativeApiAdapter } from './adapters/playwright-native-api.js';
+// Note: PlaywrightApiAdapter was replaced by PlaywrightNativeApiAdapter (zero overhead)
+// Auto-Repair Module (Phase 7)
+export * from './repair/index.js';
+// TUI Module (Phase 8 - Terminal UI)
+export * from './tui/index.js';
+// Dashboard Module (Phase 8 - Web Dashboard)
+export * from './dashboard/index.js';
+// Flakiness Detection Engine (Vision 2.0 - Phase 1)
+export * from './flakiness/index.js';
+// Smart Retry Module (Vision 2.0 - Phase 2 - F8)
+export * from './retry/index.js';
+// Cache Module (Phase 2 - LRU Cache for HTTP responses)
+export * from './cache/index.js';
+// Watch Module (Phase 3 - Continuous testing and benchmarking)
+export * from './watch/index.js';
+// Self-Healing Module (Vision 2.0 - Phase 2 - F7)
+export * from './self-healing/index.js';
+// Coverage Analytics Module (Vision 2.0 - Phase 2 - F11)
+export * from './coverage/index.js';
+// SLO/SLI Management Module (Vision 2.0 - Phase 2)
+export * from './slo/index.js';
+// Regression Detection Module (Vision 2.0 - Phase 2 - F12)
+export * from './regression/index.js';

package/dist/core/pack/validator.js

@@ -30,7 +30,37 @@ export class PackValidator {
     validate(pack) {
         const errors = [];
         const warnings = [];
-        // Schema validation
+        // 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) {

package/dist/core/pack-v2/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * QA360 Pack v2 Module
+ *
+ * Provides validation, migration, and loading for Pack v2 configurations.
+ */
+export { PackValidatorV2 } from './validator.js';
+export { PackMigrator } from './migrator.js';
+export { PackLoaderV2, PackLoadResult } from './loader.js';
+export type { PackConfigV2, AuthConfigV2, AuthProfile, AuthTypeV2, AuthCacheConfig, GateConfigV2, GateBudgets, GateOptions, HooksConfig, Hook, ExecutionConfigV2, ResourceLimits, SecurityBudgets, PerformanceTargets, JWTAuthProfileV2, OAuth2AuthProfileV2, UILoginAuthProfileV2, GCPADCProfileV2, AWSIamProfileV2, TargetConfig, ApiTarget, WebTarget, ApiRequest, WebPage, PageAction, PackValidationResultV2, ValidationError, PackMigrationResultV2 } from '../types/pack-v2.js';

package/dist/core/pack-v2/index.js

@@ -0,0 +1,8 @@
+/**
+ * QA360 Pack v2 Module
+ *
+ * Provides validation, migration, and loading for Pack v2 configurations.
+ */
+export { PackValidatorV2 } from './validator.js';
+export { PackMigrator } from './migrator.js';
+export { PackLoaderV2 } from './loader.js';

package/dist/core/pack-v2/loader.d.ts

@@ -0,0 +1,62 @@
+/**
+ * QA360 Pack v2 Loader
+ *
+ * Loads and parses pack.yml v2 files from the filesystem.
+ */
+import { PackConfigV2, PackValidationResultV2, ValidationError } from '../types/pack-v2.js';
+export interface PackLoadResult {
+    success: boolean;
+    pack?: PackConfigV2 | any;
+    validation?: PackValidationResultV2;
+    valid?: boolean;
+    error?: Error;
+    sourcePath?: string;
+    format?: 'v1' | 'v2' | 'unknown';
+    migrated?: boolean;
+    changes?: string[];
+    warnings?: string[];
+    foundFiles?: string[];
+    missingFiles?: string[];
+    validationErrors?: ValidationError[];
+}
+export declare class PackLoaderV2 {
+    private cache;
+    /**
+     * Load a pack configuration from a file path
+     */
+    load(packPath: string, options?: {
+        validate?: boolean;
+        checkFilesExist?: boolean;
+        useCache?: boolean;
+        migrate?: boolean;
+    }): Promise<PackLoadResult>;
+    /**
+     * Load and validate in one step
+     */
+    loadAndValidate(packPath: string, options?: {
+        checkFilesExist?: boolean;
+    }): Promise<PackLoadResult>;
+    /**
+     * Load multiple packs from a directory
+     */
+    loadFromDir(dirPath: string, options?: {
+        pattern?: string;
+        validate?: boolean;
+        checkFilesExist?: boolean;
+    }): Promise<PackLoadResult[]>;
+    /**
+     * Load from a YAML string (useful for testing or dynamic configs)
+     */
+    loadFromString(yamlContent: string, options?: {
+        validate?: boolean;
+        filename?: string;
+    }): Promise<PackLoadResult>;
+    /**
+     * Clear the cache
+     */
+    clearCache(path?: string): void;
+    /**
+     * Get cache size
+     */
+    getCacheSize(): number;
+}

package/dist/core/pack-v2/loader.js

@@ -0,0 +1,231 @@
+/**
+ * QA360 Pack v2 Loader
+ *
+ * Loads and parses pack.yml v2 files from the filesystem.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import * as yaml from 'js-yaml';
+import { PackValidatorV2 } from './validator.js';
+import { PackMigrator } from './migrator.js';
+export class PackLoaderV2 {
+    cache = new Map();
+    /**
+     * Load a pack configuration from a file path
+     */
+    async load(packPath, options) {
+        try {
+            // Resolve absolute path
+            const resolvedPath = resolve(packPath);
+            // Check if file exists
+            if (!existsSync(resolvedPath)) {
+                return {
+                    success: false,
+                    error: new Error(`Pack file not found: ${resolvedPath}`),
+                    sourcePath: resolvedPath,
+                    format: 'unknown'
+                };
+            }
+            // Read file
+            const content = readFileSync(resolvedPath, 'utf-8');
+            // Parse YAML
+            const parsed = yaml.load(content);
+            // Detect version
+            const migrator = new PackMigrator();
+            const detectedVersion = migrator.detectVersion(parsed);
+            // Set format
+            const format = detectedVersion === 1 ? 'v1' : detectedVersion === 2 ? 'v2' : 'unknown';
+            // For v1 without migration
+            if (detectedVersion === 1 && options?.migrate === false) {
+                return {
+                    success: true,
+                    pack: parsed,
+                    format: 'v1',
+                    migrated: false,
+                    sourcePath: resolvedPath
+                };
+            }
+            let pack;
+            let migrated = false;
+            let changes = [];
+            let migrationWarnings = [];
+            if (detectedVersion === 1) {
+                // Migrate v1 to v2
+                const migrationResult = migrator.migrate(parsed);
+                if (!migrationResult.success) {
+                    return {
+                        success: false,
+                        error: new Error(`Migration failed: ${migrationResult.warnings.join(', ')}`),
+                        sourcePath: resolvedPath,
+                        format: 'v1'
+                    };
+                }
+                pack = migrationResult.migrated;
+                migrated = true;
+                changes = migrationResult.changes;
+                migrationWarnings = migrationResult.warnings;
+            }
+            else if (detectedVersion === 2) {
+                pack = parsed;
+            }
+            else {
+                return {
+                    success: false,
+                    error: new Error(`Unknown pack format. Version: ${parsed.version}`),
+                    sourcePath: resolvedPath,
+                    format: 'unknown'
+                };
+            }
+            // Cache the pack
+            if (options?.useCache !== false) {
+                this.cache.set(resolvedPath, pack);
+            }
+            // Validate if requested (or by default)
+            const shouldValidate = options?.validate !== false;
+            if (shouldValidate) {
+                const validator = new PackValidatorV2(resolvedPath);
+                const validation = await validator.validate(pack, { checkFilesExist: options?.checkFilesExist });
+                return {
+                    success: validation.valid,
+                    pack,
+                    valid: validation.valid,
+                    validation,
+                    validationErrors: validation.errors,
+                    sourcePath: resolvedPath,
+                    format: 'v2',
+                    migrated,
+                    changes,
+                    warnings: migrationWarnings,
+                    foundFiles: validation.info?.totalTests ? [`found ${validation.info.totalTests} tests`] : undefined
+                };
+            }
+            return {
+                success: true,
+                pack,
+                valid: true,
+                sourcePath: resolvedPath,
+                format: 'v2',
+                migrated,
+                changes,
+                warnings: migrationWarnings
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+                sourcePath: packPath,
+                format: 'unknown'
+            };
+        }
+    }
+    /**
+     * Load and validate in one step
+     */
+    async loadAndValidate(packPath, options) {
+        return this.load(packPath, {
+            validate: true,
+            checkFilesExist: options?.checkFilesExist,
+            useCache: false
+        });
+    }
+    /**
+     * Load multiple packs from a directory
+     */
+    async loadFromDir(dirPath, options) {
+        const { glob } = await import('glob');
+        const pattern = options?.pattern || '**/*.yml';
+        const results = [];
+        try {
+            const files = await glob(pattern, {
+                cwd: dirPath,
+                absolute: true,
+                ignore: ['**/node_modules/**']
+            });
+            for (const file of files) {
+                const result = await this.load(file, options);
+                results.push(result);
+            }
+            return results;
+        }
+        catch (error) {
+            return [{
+                    success: false,
+                    error: new Error(`Failed to scan directory: ${error.message}`)
+                }];
+        }
+    }
+    /**
+     * Load from a YAML string (useful for testing or dynamic configs)
+     */
+    async loadFromString(yamlContent, options) {
+        try {
+            const parsed = yaml.load(yamlContent);
+            // Detect version and migrate if needed
+            const migrator = new PackMigrator();
+            const detectedVersion = migrator.detectVersion(parsed);
+            let pack;
+            let migrated = false;
+            if (detectedVersion === 1) {
+                const migrationResult = migrator.migrate(parsed);
+                if (!migrationResult.success) {
+                    return {
+                        success: false,
+                        error: new Error(`Migration failed: ${migrationResult.warnings.join(', ')}`)
+                    };
+                }
+                pack = migrationResult.migrated;
+                migrated = true;
+            }
+            else if (detectedVersion === 2) {
+                pack = parsed;
+            }
+            else {
+                return {
+                    success: false,
+                    error: new Error(`Unknown pack format. Version: ${parsed.version}`)
+                };
+            }
+            // Validate if requested
+            if (options?.validate !== false) {
+                const fakePath = options?.filename || 'pack.yml';
+                const validator = new PackValidatorV2(fakePath);
+                const validation = await validator.validate(pack);
+                return {
+                    success: validation.valid,
+                    pack,
+                    validation,
+                    migrated
+                };
+            }
+            return {
+                success: true,
+                pack,
+                migrated
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new Error(`Failed to parse YAML: ${error.message}`)
+            };
+        }
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache(path) {
+        if (path) {
+            this.cache.delete(resolve(path));
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Get cache size
+     */
+    getCacheSize() {
+        return this.cache.size;
+    }
+}

package/dist/core/pack-v2/migrator.d.ts

@@ -0,0 +1,56 @@
+/**
+ * QA360 Pack v1 to v2 Migrator
+ *
+ * Migrates Pack v1 configurations to Pack v2 format.
+ */
+import { PackConfigV1 } from '../types/pack-v1.js';
+import { PackMigrationResultV2 } from '../types/pack-v2.js';
+/**
+ * Migrate Pack v1 to v2
+ */
+export declare class PackMigrator {
+    /**
+     * Migrate a v1 pack to v2 format
+     */
+    migrate(v1Pack: PackConfigV1): PackMigrationResultV2;
+    /**
+     * Migrate gates from v1 to v2
+     */
+    private migrateGates;
+    /**
+     * Migrate authentication from v1 to v2
+     */
+    private migrateAuth;
+    /**
+     * Migrate hooks from v1 to v2
+     */
+    private migrateHooks;
+    /**
+     * Migrate execution config from v1 to v2
+     */
+    private migrateExecution;
+    /**
+     * Migrate budgets to individual gates
+     */
+    private migrateBudgetsToGates;
+    /**
+     * Migrate security config to individual gates
+     */
+    private migrateSecurityToGates;
+    /**
+     * Migrate targets to gate configs
+     */
+    private migrateTargetsToGates;
+    /**
+     * Find a secret in environment variables by trying common names
+     */
+    private findSecretInEnv;
+    /**
+     * Sanitize gate name for v2 format
+     */
+    private sanitizeGateName;
+    /**
+     * Detect pack version
+     */
+    detectVersion(pack: any): 1 | 2 | 'unknown';
+}