quality-intelligence-engine 2.2.2 → 2.2.4

package/playwright-results/saucedemo-numeric-mismatch-f085e-E-unauthorized-access-FAIL--webkit/error-context.md

@@ -0,0 +1,31 @@
+# Page snapshot
+
+```yaml
+- generic [ref=e3]:
+  - generic [ref=e4]: Swag Labs
+  - generic [ref=e5]:
+    - generic [ref=e9]:
+      - generic [ref=e10]:
+        - textbox "Username" [ref=e11]: locked_out_user
+        - img [ref=e12]
+      - generic [ref=e14]:
+        - textbox "Password" [ref=e15]: secret_sauce
+        - img [ref=e16]
+      - 'heading "Epic sadface: Sorry, this user has been locked out." [level=3] [ref=e19]':
+        - button [ref=e20] [cursor=pointer]:
+          - img [ref=e21]
+        - text: "Epic sadface: Sorry, this user has been locked out."
+      - button "Login" [ref=e23] [cursor=pointer]
+    - generic [ref=e25]:
+      - generic [ref=e26]:
+        - heading "Accepted usernames are:" [level=4] [ref=e27]
+        - text: standard_user
+        - text: locked_out_user
+        - text: problem_user
+        - text: performance_glitch_user
+        - text: error_user
+        - text: visual_user
+      - generic [ref=e28]:
+        - heading "Password for all users:" [level=4] [ref=e29]
+        - text: secret_sauce
+```

package/playwright-results/saucedemo-numeric-mismatch-f085e-E-unauthorized-access-FAIL--webkit-retry1/error-context.md

@@ -0,0 +1,31 @@
+# Page snapshot
+
+```yaml
+- generic [ref=e3]:
+  - generic [ref=e4]: Swag Labs
+  - generic [ref=e5]:
+    - generic [ref=e9]:
+      - generic [ref=e10]:
+        - textbox "Username" [ref=e11]: locked_out_user
+        - img [ref=e12]
+      - generic [ref=e14]:
+        - textbox "Password" [ref=e15]: secret_sauce
+        - img [ref=e16]
+      - 'heading "Epic sadface: Sorry, this user has been locked out." [level=3] [ref=e19]':
+        - button [ref=e20] [cursor=pointer]:
+          - img [ref=e21]
+        - text: "Epic sadface: Sorry, this user has been locked out."
+      - button "Login" [ref=e23] [cursor=pointer]
+    - generic [ref=e25]:
+      - generic [ref=e26]:
+        - heading "Accepted usernames are:" [level=4] [ref=e27]
+        - text: standard_user
+        - text: locked_out_user
+        - text: problem_user
+        - text: performance_glitch_user
+        - text: error_user
+        - text: visual_user
+      - generic [ref=e28]:
+        - heading "Password for all users:" [level=4] [ref=e29]
+        - text: secret_sauce
+```

package/playwright.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  
+  // Retry logic
+  retries: process.env.CI ? 2 : 1,
+  
+  // Timeout settings
+  timeout: 30000,
+  
+  // Reporter configuration
+  reporter: [
+    ['json', { outputFile: 'playwright-report/report.json' }],
+    ['./src/reporters/qi-reporter.js'],
+    // Add GitHub Actions reporter in CI
+    ...(process.env.CI ? [['github' as const]] : [])
+  ],
+
+  use: {
+    // Base URL configuration
+    baseURL: process.env.BASE_URL || 'https://www.saucedemo.com',
+    
+    // Action timeout
+    actionTimeout: 10000,
+    
+    // Screenshots, videos, and traces
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    trace: 'retain-on-failure',
+    
+    // Headless mode - false for local dev, true for CI
+    headless: process.env.CI ? true : false,
+  },
+
+  // Browser projects
+  projects: [
+    { name: 'chromium', use: { browserName: 'chromium' } },
+    { name: 'firefox', use: { browserName: 'firefox' } },
+    { name: 'webkit', use: { browserName: 'webkit' } }
+  ]
+});

package/sanity.test.ts

@@ -0,0 +1,33 @@
+import { trackFailure } from './src/intelligence/failure-fingerprinting/failure.tracker'
+import { trackFlakiness } from './src/intelligence/flakiness-intelligence/flakiness.tracker'
+
+// ---- SIMULATE RUN ID ----
+const runId = Number(process.argv[2]) || 1
+
+console.log(`\n🚀 SANITY RUN: ${runId}\n`)
+
+// ---- DAY 7: FAILURE INTELLIGENCE ----
+const failureResult = trackFailure(
+  {
+    failureType: 'assertion',
+    pageRoute: '/checkout',
+    primaryLocator: '#total',
+    assertionIntent: 'total price matches sum',
+    errorClass: 'expect'
+  },
+  runId,
+  'checkout.spec.ts'
+)
+
+console.log('Day 7 → Failure Result:', failureResult)
+
+// ---- DAY 8: FLAKINESS INTELLIGENCE ----
+const outcome = runId % 2 === 0 ? 'PASS' : 'FAIL'
+
+const flakinessResult = trackFlakiness(
+  'checkout.spec.ts',
+  '/checkout',
+  outcome
+)
+
+console.log('Day 8 → Flakiness Result:', flakinessResult)

package/src/adapters/playwright-folder.adapter.ts

@@ -0,0 +1,85 @@
+// src/adapters/playwright-folder.adapter.ts
+
+import fs from "fs";
+import path from "path";
+import { FailureAnalysisResult } from "../types/failure.types";
+
+/**
+ * Improved Playwright failure folder parser
+ * Focus: reduce UNKNOWN classifications
+ */
+export function parsePlaywrightFailureFolders(
+  resultsDir: string
+): FailureAnalysisResult[] {
+  const fullDir = path.resolve(resultsDir);
+
+  if (!fs.existsSync(fullDir)) {
+    throw new Error(`Playwright results directory not found: ${fullDir}`);
+  }
+
+  const entries = fs.readdirSync(fullDir, { withFileTypes: true });
+  const failures: FailureAnalysisResult[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const name = entry.name;
+    if (!name.includes("FAIL")) continue;
+
+    const lower = name.toLowerCase();
+    let classification = "UNKNOWN";
+
+    // 🔢 Numeric / data mismatches
+    if (
+      lower.includes("numeric-mismatch") ||
+      lower.includes("count") ||
+      lower.includes("total") ||
+      lower.includes("sum") ||
+      lower.includes("price")
+    ) {
+      classification = "NUMERIC_MISMATCH";
+    }
+
+    // 🔐 Auth / permission issues
+    else if (
+      lower.includes("unauthorized") ||
+      lower.includes("forbidden") ||
+      lower.includes("permission")
+    ) {
+      classification = "AUTH_BUG";
+    }
+
+    // ⏱ Timeouts / waits
+    else if (
+      lower.includes("timeout") ||
+      lower.includes("timed-out") ||
+      lower.includes("wait")
+    ) {
+      classification = "TIMEOUT";
+    }
+
+    // 🧭 UI / locator issues
+    else if (
+      lower.includes("locator") ||
+      lower.includes("not-visible") ||
+      lower.includes("hidden") ||
+      lower.includes("detached")
+    ) {
+      classification = "UI_STATE";
+    }
+
+    // 🔁 Retry / flaky signal
+    else if (lower.includes("retry")) {
+      classification = "FLAKY";
+    }
+
+    failures.push({
+      testName: name,
+      classification,
+      failureType: classification,
+      message: `Derived from Playwright folder name: ${name}`
+    });
+  }
+
+  return failures;
+}

package/src/adapters/playwright-json.adapter.ts

@@ -0,0 +1,49 @@
+// src/adapters/playwright-json.adapter.ts
+
+import fs from "fs";
+import path from "path";
+import { FailureAnalysisResult } from "../types/failure.types";
+
+/**
+ * Converts Playwright JSON report → FailureAnalysisResult[]
+ */
+export function parsePlaywrightJsonReport(
+  reportPath: string
+): FailureAnalysisResult[] {
+  const fullPath = path.resolve(reportPath);
+  const raw = fs.readFileSync(fullPath, "utf-8");
+  const report = JSON.parse(raw);
+
+  const failures: FailureAnalysisResult[] = [];
+
+  for (const suite of report.suites ?? []) {
+    for (const spec of suite.specs ?? []) {
+      for (const test of spec.tests ?? []) {
+        for (const result of test.results ?? []) {
+          if (result.status === "failed") {
+            const error = result.error?.message ?? "";
+
+            let classification = "UNKNOWN";
+
+            if (error.includes("toHaveCount")) {
+              classification = "NUMERIC_MISMATCH";
+            } else if (error.includes("timeout")) {
+              classification = "TIMEOUT";
+            } else if (error.includes("locator")) {
+              classification = "LOCATOR_CHANGED";
+            }
+
+            failures.push({
+              testName: test.title,
+              classification,
+              failureType: classification,
+              message: error
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return failures;
+}

package/src/adapters/playwright.adapter.ts

@@ -0,0 +1,44 @@
+import fs from 'fs'
+import path from 'path'
+import { PlaywrightFailure } from '../types/playwright-failure'
+
+export function readPlaywrightFailures(reportDir: string): PlaywrightFailure[] {
+  const reportFile = path.join(reportDir, 'report.json')
+
+  if (!fs.existsSync(reportFile)) {
+    throw new Error(
+      `Playwright JSON report not found.\nExpected at: ${reportFile}`
+    )
+  }
+
+  const raw = JSON.parse(fs.readFileSync(reportFile, 'utf-8'))
+  const failures: PlaywrightFailure[] = []
+
+  for (const suite of raw.suites ?? []) {
+    for (const spec of suite.specs ?? []) {
+      for (const test of spec.tests ?? []) {
+        const failedResults = test.results?.filter(
+          (r: any) => r.status === 'failed'
+        )
+
+        if (!failedResults || failedResults.length === 0) continue
+
+        const firstFailure = failedResults[0]
+        const error = firstFailure.error
+
+        failures.push({
+          testName: spec.title,
+          errorMessage: error?.message ?? 'Unknown error',
+          stack: error?.stack,
+
+          filePath: error?.location?.file ?? spec.file,
+          lineNumber: error?.location?.line ?? spec.line ?? 0,
+
+          retryCount: failedResults.length - 1
+        })
+      }
+    }
+  }
+
+  return failures
+}

package/src/cli/qi-test.ts

@@ -0,0 +1,20 @@
+import { spawn } from 'child_process';
+
+export function runQiTest(args: string[]) {
+  const playwrightArgs = [
+    'playwright',
+    'test',
+    '--config',
+    'playwright.config.ts',
+    ...args
+  ];
+
+  const child = spawn('npx', playwrightArgs, {
+    stdio: 'inherit',
+    shell: true
+  });
+
+  child.on('exit', code => {
+    process.exit(code ?? 0);
+  });
+}

package/src/cli/qi.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// src/cli/qi.ts
+
+import { runQualityIntelligence } from "../runner";
+import { FailureAnalysisResult } from "../types/failure.types";
+
+/**
+ * Core CLI runner (reusable)
+ */
+export async function runQiCli(input: string) {
+  const results = await runQualityIntelligence(input);
+
+  if (!Array.isArray(results) || results.length === 0) {
+    console.log("No failures detected.");
+    return;
+  }
+
+  for (const f of results as FailureAnalysisResult[]) {
+    const testName = f.testName ?? "UNKNOWN_TEST";
+    const isExpected = testName.includes("EXPECTED");
+
+    console.log("=================================");
+    console.log(`Test Name     : ${testName}${isExpected ? " (EXPECTED)" : ""}`);
+    console.log(`Failure Type  : ${f.failureType ?? f.classification}`);
+    console.log(`Confidence    : ${f.confidence ?? "N/A"}\n`);
+
+    if (f.rootCause?.length) {
+      console.log("Root Cause:");
+      for (const line of f.rootCause) {
+        console.log(` - ${line}`);
+      }
+      console.log();
+    }
+
+    if (f.evidence?.length) {
+      console.log("Evidence:");
+      for (const line of f.evidence) {
+        console.log(` - ${line}`);
+      }
+      console.log();
+    }
+
+    if (f.diagnosis?.length) {
+      console.log("Diagnosis:");
+      for (const line of f.diagnosis) {
+        console.log(` - ${line}`);
+      }
+      console.log();
+    }
+  }
+}
+
+/**
+ * CLI ENTRY POINT
+ * Allows: npx qi <path>
+ */
+async function main() {
+  const input = process.argv[2] ?? "playwright-results";
+  await runQiCli(input);
+}
+
+if (process.argv[1]?.includes("qi")) {
+  main().catch(err => {
+    console.error("QI CLI failed:", err);
+    process.exit(1);
+  });
+}

package/src/cli/ui/divider.ts

@@ -0,0 +1,9 @@
+export function divider(title?: string, width = 60): string {
+  const line = '━'.repeat(width)
+
+  if (!title) {
+    return `\n${line}\n`
+  }
+
+  return `\n${line}\n${title}\n${line}\n`
+}

package/src/cli/ui/failureLogger.ts

@@ -0,0 +1,33 @@
+type FailureLogInput = {
+  testName: string
+  failureType: string
+  confidence: number
+  file: string
+  line: number
+  rootCause: string
+  severity: string
+  priority: string
+}
+
+export function logFailure(input: FailureLogInput) {
+  const confidencePercent = Math.round(input.confidence * 100)
+
+  console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❌ Automation Test Failure
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Test Name     : ${input.testName}
+Failure Type  : ${input.failureType}
+Severity      : ${input.severity}
+Priority      : ${input.priority}
+Confidence    : ${confidencePercent}%
+
+Failure Location:
+- Test File   : ${input.file}
+- Line Number : ${input.line}
+
+Root Cause:
+- ${input.rootCause}
+`)
+}

package/src/configLoader.ts

@@ -0,0 +1,70 @@
+import { QIConfig } from './types';
+import { readJsonFile, resolvePath } from './utils/file-utils';
+
+/**
+ * Validate configuration object structure
+ */
+function validateConfig(config: unknown): config is QIConfig {
+  if (typeof config !== 'object' || config === null) {
+    return false;
+  }
+
+  const cfg = config as Record<string, unknown>;
+
+  // Validate engine section
+  if (
+    typeof cfg.engine !== 'object' ||
+    cfg.engine === null
+  ) {
+    return false;
+  }
+
+  const engine = cfg.engine as Record<string, unknown>;
+  if (
+    typeof engine.mode !== 'string' ||
+    typeof engine.confidenceThresholds !== 'object'
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Load and validate configuration
+ */
+export function loadConfig(): QIConfig {
+  try {
+    const configPath = resolvePath('config', 'agent.config.json');
+    const config = readJsonFile<unknown>(configPath);
+
+    if (!validateConfig(config)) {
+      throw new Error('Invalid configuration structure');
+    }
+
+    return config;
+  } catch (error) {
+    console.error('❌ Failed to load configuration:', error);
+    console.error('\n💡 Using default configuration');
+
+    // Return safe defaults
+    return {
+      engine: {
+        mode: 'standard',
+        confidenceThresholds: {
+          fail: 0.85,
+          passRisk: 0.6
+        }
+      },
+      output: {
+        writeMarkdown: true,
+        maxHistoryRuns: 10
+      },
+      passAnalysis: {
+        enable: true,
+        reportFlakyPass: true,
+        reportApiWarnings: true
+      }
+    };
+  }
+}