qa360 2.2.1 → 2.2.13

package/cli/dist/core/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * QA360 Core Engine
+ *
+ * The heart of QA360 - handles proof generation, cryptographic signatures,
+ * and evidence vault for verifiable quality assurance.
+ */
+export interface Pack {
+    name: string;
+    version: string;
+    description?: string;
+    adapters: string[];
+    tests: TestSpec[];
+    hooks?: PackHooks;
+}
+export interface TestSpec {
+    name: string;
+    adapter: string;
+    config: Record<string, any>;
+}
+export interface PackHooks {
+    beforeAll?: string[];
+    afterAll?: string[];
+    beforeEach?: string[];
+    afterEach?: string[];
+}
+export interface Proof {
+    id: string;
+    pack: Pack;
+    results: TestResult[];
+    signature: string;
+    trustScore: number;
+    timestamp: string;
+    metadata: ProofMetadata;
+}
+export interface TestResult {
+    testName: string;
+    adapter: string;
+    status: 'passed' | 'failed' | 'skipped';
+    duration: number;
+    evidence: Evidence[];
+    error?: string;
+}
+export interface Evidence {
+    type: 'screenshot' | 'log' | 'metric' | 'artifact';
+    data: string | Buffer;
+    metadata: Record<string, any>;
+}
+export interface ProofMetadata {
+    environment: string;
+    platform: string;
+    qa360Version: string;
+    generatedBy: string;
+}
+export declare class QA360Core {
+    constructor();
+    generateProof(pack: Pack, results: TestResult[]): Promise<Proof>;
+    verifyProof(proof: Proof): Promise<boolean>;
+    calculateTrustScore(results: TestResult[]): Promise<number>;
+}
+export declare const VERSION = "0.9.0-core";
+export * from './proof/index.js';
+export { EvidenceVault } from './vault/index.js';
+export type { RunRecord, GateRecord, FindingRecord, FlakinessRecord, FlakinessPatternRecord, QuarantineRecord } from './vault/index.js';
+export { SecurityRedactor } from './security/redactor.js';
+export { SecretsManager } from './secrets/manager.js';
+export { SecretsCrypto } from './secrets/crypto.js';
+export { PackValidator } from './pack/validator.js';
+export { PackMigrator } from './pack/migrator.js';
+export type { PackConfigV1 } from './types/pack-v1.js';
+export * from './ai/index.js';
+export * from './discoverer/index.js';
+export * from './types/pack-v2.js';
+export type { PackConfigV2, AuthConfigV2, AuthProfile, AuthTypeV2, AuthCacheConfig, GateConfigV2, GateBudgets, GateOptions, HooksConfig, Hook, ExecutionConfigV2, ResourceLimits, SecurityBudgets, PerformanceTargets } from './types/pack-v2.js';
+export * from './pack-v2/index.js';
+export { PackLoaderV2, PackValidatorV2, PackLoadResult } from './pack-v2/index.js';
+export type { PackMigrationResultV2, ValidationError } from './pack-v2/index.js';
+export * from './auth/index.js';
+export * from './generation/index.js';
+export { QA360Server } from './serve/server.js';
+export type { ServeConfig } from './serve/server.js';
+export { Phase3Runner } from './runner/phase3-runner.js';
+export type { Phase3RunnerOptions, Phase3RunResult, GateResult } from './runner/phase3-runner.js';
+export { PlaywrightNativeApiAdapter, createPlaywrightNativeApiAdapter } from './adapters/playwright-native-api.js';
+export type { NativeApiTestConfig, NativeApiSmokeResult } from './adapters/playwright-native-api.js';
+export * from './repair/index.js';
+export * from './tui/index.js';
+export * from './dashboard/index.js';
+export * from './flakiness/index.js';
+export * from './retry/index.js';
+export * from './cache/index.js';
+export * from './watch/index.js';
+export * from './self-healing/index.js';
+export * from './coverage/index.js';
+export * from './slo/index.js';
+export * from './regression/index.js';
+export * from './crawler/index.js';
+export { AssertionsEngine, createAssertionsEngine, AssertionResult, AssertionGroupResult, AssertionRunOptions, AssertionError, SoftAssertionError, Assertion, AssertionOperator, AssertionSuite, } from './assertions/index.js';
+export type { AssertionType as UiAssertionType } from './assertions/types.js';
+export * from './artifacts/index.js';
+export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
+export type { ReportData, TestReport, StepReport, } from './reporting/index.js';
+export type { ScreenshotArtifact as ReportScreenshotArtifact, VideoArtifact as ReportVideoArtifact, TraceArtifact as ReportTraceArtifact, } from './reporting/index.js';
+export * from './parallel/index.js';
+export * from './visual/index.js';
+export * from './fixtures/index.js';
+export { VitestAdapter } from './adapters/vitest-adapter.js';
+export { JestAdapter } from './adapters/jest-adapter.js';
+export { PytestAdapter } from './adapters/pytest-adapter.js';
+export type { UnitTestConfig, UnitTestResult, UnitTestExecutionResult, CoverageThresholds, CoverageStats, } from './adapters/unit-test-types.js';
+export * from './pom/index.js';

package/cli/dist/core/index.js

@@ -0,0 +1,99 @@
+/**
+ * QA360 Core Engine
+ *
+ * The heart of QA360 - handles proof generation, cryptographic signatures,
+ * and evidence vault for verifiable quality assurance.
+ */
+// Core classes (Phase 1+ implementation)
+export class QA360Core {
+    constructor() {
+        // Phase 1 implementation coming soon
+    }
+    async generateProof(pack, results) {
+        throw new Error('Phase 1 implementation coming soon');
+    }
+    async verifyProof(proof) {
+        throw new Error('Phase 1 implementation coming soon');
+    }
+    async calculateTrustScore(results) {
+        throw new Error('Phase 1 implementation coming soon');
+    }
+}
+// Export version
+export const VERSION = '0.9.0-core';
+// Proof Bundle System (Phase 2)
+export * from './proof/index.js';
+// Vault & Evidence System
+export { EvidenceVault } from './vault/index.js';
+// Security & Redaction
+export { SecurityRedactor } from './security/redactor.js';
+// Secrets Management
+export { SecretsManager } from './secrets/manager.js';
+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';
+// Crawler Module (Vision 2.0 - UI Testing 100%)
+export * from './crawler/index.js';
+// Assertions Engine (Vision 2.0 - UI Testing 100%)
+export { AssertionsEngine, createAssertionsEngine, AssertionError, SoftAssertionError, } from './assertions/index.js';
+// Artifacts Module (Vision 2.0 - UI Testing Artifacts)
+export * from './artifacts/index.js';
+// Reporting Module (Vision 2.0 - HTML Reports)
+// Note: Using selective exports to avoid naming conflicts with artifacts module
+export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
+// Parallel Module (Vision 2.0 - Parallel Test Execution)
+export * from './parallel/index.js';
+// Visual Regression Module (Vision 2.0 - Visual Testing)
+export * from './visual/index.js';
+// Data Fixtures System (v2.2 - Playwright/NFLS best practice)
+export * from './fixtures/index.js';
+// Unit Test Adapters (v2.2 - Vitest/Jest/Pytest Ingestion)
+export { VitestAdapter } from './adapters/vitest-adapter.js';
+export { JestAdapter } from './adapters/jest-adapter.js';
+export { PytestAdapter } from './adapters/pytest-adapter.js';
+// Page Object Model (v2.2 - POM Import from TS/JS files)
+export * from './pom/index.js';

package/cli/dist/core/pack/migrator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * QA360 Pack Migrator
+ * Migrates legacy pack configurations to v1 format
+ */
+import { LegacyPackConfig, PackMigrationResult } from '../types/pack-v1.js';
+export declare class PackMigrator {
+    /**
+     * Migrate legacy pack to v1 format
+     */
+    migrate(legacyPack: LegacyPackConfig): PackMigrationResult;
+    /**
+     * Migrate pack name to v1 format
+     */
+    private migrateName;
+    /**
+     * Migrate adapters and tests to quality gates
+     */
+    private migrateGates;
+    /**
+     * Map legacy adapter names to quality gates
+     */
+    private mapAdapterToGates;
+    /**
+     * Migrate targets from legacy configuration
+     */
+    private migrateTargets;
+    /**
+     * Extract API URL from legacy configuration
+     */
+    private extractApiUrl;
+    /**
+     * Extract Web URL from legacy configuration
+     */
+    private extractWebUrl;
+    /**
+     * Validate URL format
+     */
+    private isValidUrl;
+    /**
+     * Migrate environment variables
+     */
+    private migrateEnvironment;
+    /**
+     * Migrate hooks from legacy format
+     */
+    private migrateHooks;
+    /**
+     * Check if a value looks like a secret
+     */
+    private looksLikeSecret;
+}

package/cli/dist/core/pack/migrator.js

@@ -0,0 +1,304 @@
+/**
+ * QA360 Pack Migrator
+ * Migrates legacy pack configurations to v1 format
+ */
+export class PackMigrator {
+    /**
+     * Migrate legacy pack to v1 format
+     */
+    migrate(legacyPack) {
+        const changes = [];
+        const warnings = [];
+        try {
+            const v1Pack = {
+                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
+     */
+    migrateName(name, changes) {
+        // 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
+     */
+    migrateGates(legacyPack, changes, warnings) {
+        const gates = 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
+     */
+    mapAdapterToGates(adapter) {
+        const mapping = {
+            '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
+     */
+    migrateTargets(legacyPack, changes, warnings) {
+        const targets = {};
+        // 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
+     */
+    extractApiUrl(legacyPack) {
+        // 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
+     */
+    extractWebUrl(legacyPack) {
+        // 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
+     */
+    isValidUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Migrate environment variables
+     */
+    migrateEnvironment(env, changes, warnings) {
+        const migratedEnv = {};
+        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
+     */
+    migrateHooks(hooks, changes) {
+        const migratedHooks = {};
+        if (hooks.beforeAll) {
+            migratedHooks.beforeAll = hooks.beforeAll.map((cmd) => ({
+                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) => ({
+                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
+     */
+    looksLikeSecret(value) {
+        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/cli/dist/core/pack/validator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * QA360 Pack v1 Validator
+ * Validates pack.yml files against the official schema
+ */
+import { PackValidationResult } from '../types/pack-v1.js';
+export declare class PackValidator {
+    private ajv;
+    private schema;
+    constructor();
+    /**
+     * Validate a pack configuration
+     */
+    validate(pack: any): PackValidationResult;
+    /**
+     * Validate business rules beyond schema
+     */
+    private validateBusinessRules;
+    /**
+     * Check if a value looks like a secret
+     */
+    private looksLikeSecret;
+    /**
+     * Check if a value is a secret reference
+     */
+    private isSecretReference;
+    /**
+     * Validate hook commands for security issues
+     */
+    private validateHookSecurity;
+    /**
+     * Get error code from AJV error
+     */
+    private getErrorCode;
+    /**
+     * Format error message for better UX
+     */
+    private formatErrorMessage;
+    /**
+     * Get suggestion for fixing error
+     */
+    private getSuggestion;
+}