qa360 2.2.0 → 2.2.1

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",

package/cli/src/commands/run.ts

@@ -8,7 +8,7 @@
  */
 
 import { existsSync, readFileSync } from 'fs';
-import { join, resolve } from 'path';
+import { join, resolve, dirname } from 'path';
 import chalk from 'chalk';
 import { load } from 'js-yaml';
 import { Phase3Runner, PackLoaderV2, type Phase3RunResult, type GateResult, type PackConfigV1, type PackConfigV2 } from 'qa360-core';
@@ -183,13 +183,15 @@ export async function runCommand(
 
     // Step 4: Create and run Phase3Runner
     const workingDir = process.cwd();
-    const outputDir = options.output 
-      ? resolve(options.output) 
+    const packDir = dirname(packPath); // Directory containing the pack file
+    const outputDir = options.output
+      ? resolve(options.output)
       : join(workingDir, '.qa360', 'runs');
 
     const runner = new Phase3Runner({
       workingDir,
       pack,
+      packDir, // Pass pack directory for resolving fixtures
       outputDir,
     });
 

package/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360-core",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "QA360 Core Engine - Proof generation, signatures, and evidence vault",
   "type": "module",
   "main": "dist/index.js",

package/core/src/fixtures/loader.ts

@@ -84,9 +84,20 @@ export class FixtureLoader {
         );
       }
 
-      // Use the filename (without extension) as the fixture name key
+      // Merge fixture data into registry (keys become directly accessible)
+      // This allows $fixtures.environments.production.baseUrl instead of
+      // $fixtures.fixtures.environments.production.baseUrl
       const fixtureName = this.getFixtureName(fixturePath);
-      this.registry[fixtureName] = fixtureData;
+      this.registry[fixtureName] = fixtureData; // Keep filename reference for debug
+
+      // Also merge top-level keys for direct access
+      for (const [key, value] of Object.entries(fixtureData)) {
+        // Skip if key already exists (first file wins)
+        // We need to cast because FixtureValue is broader than FixtureFile
+        if (!(key in this.registry)) {
+          (this.registry as Record<string, unknown>)[key] = value;
+        }
+      }
 
       return fixtureData;
     } catch (error) {

package/core/src/pack-v2/__tests__/validator.test.ts

@@ -569,7 +569,7 @@ describe('PackValidatorV2', () => {
       expect(result.valid).toBe(true);
     });
 
-    it('should reject fixture path with parent directory reference', async () => {
+    it('should warn about fixture path with parent directory reference', async () => {
       const pack: PackConfigV2 = {
         version: 2,
         name: 'test-pack',
@@ -577,8 +577,8 @@ describe('PackValidatorV2', () => {
         gates: { smoke: { adapter: 'playwright-api' } }
       };
       const result = await validator.validate(pack);
-      expect(result.valid).toBe(false);
-      expect(result.errors.some(e => e.code === 'QP2V038')).toBe(true);
+      expect(result.valid).toBe(true); // Changed from false to true - now just a warning
+      expect(result.warnings.some(e => e.code === 'QP2V038')).toBe(true); // Changed from errors to warnings
     });
 
     it('should warn about unknown file extension', async () => {

package/core/src/pack-v2/validator.ts

@@ -186,13 +186,14 @@ export class PackValidatorV2 {
         continue;
       }
 
-      // Check for invalid patterns
+      // Check for patterns that might cause issues
       if (fixturePath.includes('..')) {
-        errors.push({
+        // Changed from error to warning - parent directory references are sometimes needed
+        warnings.push({
           code: 'QP2V038',
-          message: 'Fixture path cannot contain parent directory reference ".."',
+          message: `Fixture path contains parent directory reference "..": ${fixturePath}`,
           path: `fixtures.${fixturePath}`,
-          suggestion: 'Use relative patterns without ..'
+          suggestion: 'Consider using absolute paths or placing fixtures in the same directory as the pack'
         });
       }
 
@@ -384,7 +385,11 @@ export class PackValidatorV2 {
       'semgrep-sast',
       'zap-dast',
       'gitleaks-secrets',
-      'osv-deps'
+      'osv-deps',
+      // v2.2.0 Unit Test Adapters
+      'vitest',
+      'jest',
+      'pytest'
     ];
 
     for (const [gateName, gate] of Object.entries(gates)) {

package/core/src/runner/phase3-runner.ts

@@ -5,7 +5,7 @@
  */
 
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { createHash } from 'crypto';
 import chalk from 'chalk';
 import { PackConfigV1 } from '../types/pack-v1.js';
@@ -15,6 +15,14 @@ import { PlaywrightNativeApiAdapter } from '../adapters/playwright-native-api.js
 import { PlaywrightUiAdapter } from '../adapters/playwright-ui.js';
 import { K6PerfAdapter } from '../adapters/k6-perf.js';
 import { SemgrepSastAdapter } from '../adapters/semgrep-sast.js';
+// v2.2.0 Unit Test Adapters
+import { VitestAdapter } from '../adapters/vitest-adapter.js';
+import { JestAdapter } from '../adapters/jest-adapter.js';
+import { PytestAdapter } from '../adapters/pytest-adapter.js';
+// v2.2.0 Data Fixtures
+import { FixtureLoader } from '../fixtures/loader.js';
+import { FixtureResolver } from '../fixtures/resolver.js';
+import { PageObjectLoader } from '../pom/loader.js';
 import { SecurityRedactor } from '../security/redactor.js';
 import { initializeKeys, sign, KeyPair } from '../proof/signer.js';
 import { canonicalize } from '../proof/canonicalize.js';
@@ -35,6 +43,7 @@ export type PackConfig = PackConfigV1 | PackConfigV2;
 export interface Phase3RunnerOptions {
   workingDir: string;
   pack: PackConfig;
+  packDir?: string; // Directory containing the pack file (for resolving fixtures)
   outputDir?: string;
   /** Enable flakiness detection (runs tests N times consecutively) */
   flakyDetect?: boolean;
@@ -80,6 +89,7 @@ export interface Phase3RunResult {
 export class Phase3Runner {
   private workingDir: string;
   private pack: PackConfig;
+  private packDir: string; // Directory containing the pack file
   private outputDir: string;
   private redactor: SecurityRedactor;
   private hooksRunner: HooksRunner;
@@ -90,10 +100,15 @@ export class Phase3Runner {
   private flakyDetect: boolean;
   private flakyRuns: number;
   private flakinessDetector: FlakinessDetector;
+  // v2.2.0 Data Fixtures & POM
+  private fixtureLoader?: FixtureLoader;
+  private fixtureResolver?: FixtureResolver;
+  private pageObjectLoader?: PageObjectLoader;
 
   constructor(options: Phase3RunnerOptions) {
     this.workingDir = options.workingDir;
     this.pack = options.pack;
+    this.packDir = options.packDir || options.workingDir;
     this.outputDir = options.outputDir || join(this.workingDir, '.qa360', 'runs');
     this.redactor = SecurityRedactor.forLogs();
     this.authManager = new AuthManager();
@@ -121,6 +136,101 @@ export class Phase3Runner {
     if (this.isPackV2(options.pack) && options.pack.auth?.profiles) {
       this.registerAuthProfiles(options.pack.auth.profiles);
     }
+
+    // Load data fixtures from pack v2
+    if (this.isPackV2(options.pack) && options.pack.fixtures && options.pack.fixtures.length > 0) {
+      this.initializeFixtures(options.pack.fixtures);
+    }
+
+    // Initialize Page Object Model from pack v2
+    if (this.isPackV2(options.pack) && options.pack.pageObjects) {
+      this.initializePageObjects(options.pack.pageObjects);
+    }
+  }
+
+  /**
+   * Initialize Page Object Model from the pack configuration
+   */
+  private initializePageObjects(config: { directory?: string; pattern?: string; baseUrl?: string }): void {
+    try {
+      const pomDir = config.directory ? resolve(this.packDir, config.directory) : this.packDir;
+      this.pageObjectLoader = new PageObjectLoader({ cwd: pomDir });
+      console.log(chalk.gray(`   📄 POM loader initialized for: ${pomDir}`));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Failed to initialize POM loader: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+
+  /**
+   * Load Page Objects before execution
+   */
+  private async loadPageObjects(): Promise<void> {
+    if (!this.pageObjectLoader || !this.isPackV2(this.pack) || !this.pack.pageObjects) {
+      return;
+    }
+
+    try {
+      const pattern = this.pack.pageObjects.pattern || '**/*.page.{ts,js}';
+      const result = await this.pageObjectLoader.loadFromDirectory(this.packDir, { pattern });
+      console.log(chalk.green(`   ✅ Page Objects loaded: ${result.pagesCount} pages`));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Failed to load page objects: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+
+  /**
+   * Initialize data fixtures from the pack configuration
+   */
+  private initializeFixtures(fixturePaths: string[]): void {
+    try {
+      this.fixtureLoader = new FixtureLoader(this.packDir);
+      // Load fixtures synchronously - they're already validated
+      // We'll load them before execution starts
+      this.fixtureResolver = new FixtureResolver(this.fixtureLoader, this.packDir);
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Failed to initialize fixtures: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+
+  /**
+   * Load fixtures before execution
+   */
+  private async loadFixtures(): Promise<void> {
+    if (!this.fixtureLoader || !this.isPackV2(this.pack) || !this.pack.fixtures) {
+      return;
+    }
+
+    try {
+      await this.fixtureLoader.load(this.pack.fixtures);
+      console.log(chalk.green(`   ✅ Fixtures loaded: ${this.fixtureLoader.getFixtureNames().join(', ')}`));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Failed to load fixtures: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+
+  /**
+   * Resolve fixture references in a configuration object
+   */
+  private resolveFixturesInConfig(config: any): any {
+    if (!this.fixtureResolver || !config) {
+      return config;
+    }
+
+    try {
+      const result = this.fixtureResolver.resolve(config, {
+        baseDir: this.workingDir,
+        keepUnresolved: false
+      });
+
+      if (result.hasFixtures) {
+        console.log(chalk.gray(`   🔧 Fixtures resolved in config`));
+      }
+
+      return result.value;
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Failed to resolve fixtures: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return config;
+    }
   }
 
   /**
@@ -269,11 +379,17 @@ export class Phase3Runner {
 
     console.log(chalk.bold.blue(`\n🚀 QA360 Phase 3 Runner - ${this.pack.name}`));
     console.log(chalk.gray(`Gates: ${gatesArray.join(', ')}`));
-    
+
     try {
       // Ensure output directory exists
       this.ensureOutputDir();
-      
+
+      // Load data fixtures if configured
+      await this.loadFixtures();
+
+      // Load page objects if configured
+      await this.loadPageObjects();
+
       // Initialize cryptographic keys
       console.log(chalk.blue('\n🔑 Initializing Ed25519 keys...'));
       this.keyPair = await initializeKeys();
@@ -548,6 +664,9 @@ export class Phase3Runner {
       throw new Error(`Gate '${gateName}' must specify an adapter`);
     }
 
+    // Resolve fixtures in gate configuration
+    const resolvedGateConfig = this.resolveFixturesInConfig(gateConfig);
+
     // Get auth credentials for this gate
     const credentials = await this.getCredentialsForGate(gateName);
 
@@ -555,21 +674,34 @@ export class Phase3Runner {
     let result: GateResult;
     switch (adapterType) {
       case 'playwright-api':
-        result = await this.executePlaywrightApiGate(gateName, gateConfig, credentials);
+        result = await this.executePlaywrightApiGate(gateName, resolvedGateConfig, credentials);
         break;
 
       case 'playwright-ui':
-        result = await this.executePlaywrightUiGate(gateName, gateConfig, credentials);
+        result = await this.executePlaywrightUiGate(gateName, resolvedGateConfig, credentials);
         break;
 
       case 'k6':
       case 'k6-perf':
-        result = await this.executeK6PerfGate(gateName, gateConfig);
+        result = await this.executeK6PerfGate(gateName, resolvedGateConfig);
         break;
 
       case 'semgrep':
       case 'sast':
-        result = await this.executeSemgrepSastGate(gateName, gateConfig);
+        result = await this.executeSemgrepSastGate(gateName, resolvedGateConfig);
+        break;
+
+      // v2.2.0 Unit Test Adapters
+      case 'vitest':
+        result = await this.executeVitestGate(gateName, resolvedGateConfig);
+        break;
+
+      case 'jest':
+        result = await this.executeJestGate(gateName, resolvedGateConfig);
+        break;
+
+      case 'pytest':
+        result = await this.executePytestGate(gateName, resolvedGateConfig);
         break;
 
       default:
@@ -731,6 +863,174 @@ export class Phase3Runner {
     };
   }
 
+  /**
+   * Execute Vitest unit tests gate (v2.2.0)
+   */
+  private async executeVitestGate(gateName: string, gateConfig: any): Promise<GateResult> {
+    const adapter = new VitestAdapter(this.workingDir);
+
+    const config: any = {
+      cwd: this.workingDir,
+      ...gateConfig.config
+    };
+
+    const result = await adapter.execute(config);
+
+    return {
+      gate: gateName,
+      success: result.success,
+      duration: result.duration,
+      adapter: 'vitest',
+      results: {
+        total: result.total,
+        passed: result.passed,
+        failed: result.failed,
+        skipped: result.skipped,
+        tests: result.tests.map(t => ({
+          name: t.name,
+          status: t.status,
+          duration: t.duration,
+          error: t.error
+        }))
+      },
+      junit: this.buildJunitFromVitest(result)
+    };
+  }
+
+  /**
+   * Execute Jest unit tests gate (v2.2.0)
+   */
+  private async executeJestGate(gateName: string, gateConfig: any): Promise<GateResult> {
+    const adapter = new JestAdapter(this.workingDir);
+
+    const config: any = {
+      cwd: this.workingDir,
+      ...gateConfig.config
+    };
+
+    const result = await adapter.execute(config);
+
+    return {
+      gate: gateName,
+      success: result.success,
+      duration: result.duration,
+      adapter: 'jest',
+      results: {
+        total: result.total,
+        passed: result.passed,
+        failed: result.failed,
+        skipped: result.skipped + result.pending,
+        tests: result.tests.map(t => ({
+          name: t.name,
+          status: t.status,
+          duration: t.duration,
+          error: t.error
+        }))
+      },
+      junit: this.buildJunitFromJest(result)
+    };
+  }
+
+  /**
+   * Execute Pytest unit tests gate (v2.2.0)
+   */
+  private async executePytestGate(gateName: string, gateConfig: any): Promise<GateResult> {
+    const adapter = new PytestAdapter(this.workingDir);
+
+    const config: any = {
+      cwd: this.workingDir,
+      ...gateConfig.config
+    };
+
+    const result = await adapter.execute(config);
+
+    return {
+      gate: gateName,
+      success: result.success,
+      duration: result.duration,
+      adapter: 'pytest',
+      results: {
+        total: result.total,
+        passed: result.passed,
+        failed: result.failed,
+        skipped: result.skipped,
+        tests: result.tests.map(t => ({
+          name: t.name,
+          status: t.status,
+          duration: t.duration,
+          error: t.error
+        }))
+      },
+      junit: this.buildJunitFromPytest(result)
+    };
+  }
+
+  /**
+   * Build JUnit format from Vitest results
+   */
+  private buildJunitFromVitest(result: any): any {
+    // Convert adapter result to JUnit-like format
+    return {
+      testsuites: [{
+        name: 'vitest',
+        tests: result.total,
+        failures: result.failed,
+        skipped: result.skipped,
+        time: result.duration / 1000,
+        testcases: result.tests.map((t: any) => ({
+          name: t.name,
+          classname: t.file,
+          time: t.duration / 1000,
+          failure: t.error ? { message: t.error } : undefined,
+          skipped: t.status === 'skipped' ? { message: 'Skipped' } : undefined
+        }))
+      }]
+    };
+  }
+
+  /**
+   * Build JUnit format from Jest results
+   */
+  private buildJunitFromJest(result: any): any {
+    return {
+      testsuites: [{
+        name: 'jest',
+        tests: result.total,
+        failures: result.failed,
+        skipped: result.pending,
+        time: result.duration / 1000,
+        testcases: result.tests.map((t: any) => ({
+          name: t.name,
+          time: t.duration / 1000,
+          failure: t.error ? { message: t.error } : undefined,
+          skipped: t.status === 'pending' || t.status === 'skipped' ? { message: 'Skipped' } : undefined
+        }))
+      }]
+    };
+  }
+
+  /**
+   * Build JUnit format from Pytest results
+   */
+  private buildJunitFromPytest(result: any): any {
+    return {
+      testsuites: [{
+        name: 'pytest',
+        tests: result.total,
+        failures: result.failed,
+        skipped: result.skipped,
+        time: result.duration / 1000,
+        testcases: result.tests.map((t: any) => ({
+          name: t.name,
+          classname: t.file,
+          time: t.duration / 1000,
+          failure: t.error ? { message: t.error } : undefined,
+          skipped: t.status === 'skipped' ? { message: 'Skipped' } : undefined
+        }))
+      }]
+    };
+  }
+
   /**
    * Run API smoke gate
    * Uses PlaywrightNativeApiAdapter for zero-overhead HTTP testing

package/core/src/types/pack-v2.ts

@@ -6,6 +6,26 @@
  * AI-generated code support and comprehensive authentication.
  */
 
+/**
+ * Page Object Model configuration
+ */
+export interface PageObjectConfigV2 {
+  /**
+   * Directory containing page object files
+   */
+  directory?: string;
+
+  /**
+   * Glob pattern for page object files
+   */
+  pattern?: string;
+
+  /**
+   * Base URL for page objects (can be overridden per page)
+   */
+  baseUrl?: string;
+}
+
 /**
  * Pack Configuration v2
  */
@@ -24,6 +44,10 @@ export interface PackConfigV2 {
    *   - ./fixtures/products.json
    */
   fixtures?: string[];
+  /**
+   * Page Object Model configuration
+   */
+  pageObjects?: PageObjectConfigV2;
   auth?: AuthConfigV2;
   gates: Record<string, GateConfigV2>;
   hooks?: HooksConfig;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "qa360",
-  "version": "2.2.0",
+  "version": "2.2.1",
+  "private": false,
   "description": "Transform software testing into verifiable, signed, and traceable proofs",
   "type": "module",
   "packageManager": "pnpm@9.12.2",

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360-mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "QA360 MCP - Zero-friction CLI + Full MCP Server (23 tools) for  integration with industrial DX compliance",
   "type": "module",
   "main": "dist/index.js",