qa360 1.0.4 → 1.1.1

package/dist/core/index.js

@@ -0,0 +1,39 @@
+/**
+ * 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';
+// Server & Observability
+export { QA360Server } from './serve/server.js';
+// Runner
+export { Phase3Runner } from './runner/phase3-runner.js';

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

@@ -0,0 +1,52 @@
+/**
+ * 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;
+}
+//# sourceMappingURL=migrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../../../src/core/pack/migrator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAgB,gBAAgB,EAAE,mBAAmB,EAAoC,MAAM,qBAAqB,CAAC;AAE5H,qBAAa,YAAY;IAEvB;;OAEG;IACH,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,mBAAmB;IA6E1D;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACH,OAAO,CAAC,YAAY;IAqCpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAsCtB;;OAEG;IACH,OAAO,CAAC,aAAa;IA2BrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAerB;;OAEG;IACH,OAAO,CAAC,UAAU;IASlB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAoCpB;;OAEG;IACH,OAAO,CAAC,eAAe;CAUxB"}

package/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/dist/core/pack/validator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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;
+}
+//# sourceMappingURL=validator.d.ts.map

package/dist/core/pack/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/core/pack/validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAgB,oBAAoB,EAA8C,MAAM,qBAAqB,CAAC;AAErH,qBAAa,aAAa;IACxB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAAM;;IAkBpB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,oBAAoB;IAgCzC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA0G7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA2B5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmC1B;;OAEG;IACH,OAAO,CAAC,aAAa;CAiCtB"}