quality-intelligence-engine 2.2.3 → 2.2.4

package/src/console/issue-view.ts

@@ -0,0 +1,193 @@
+// src/console/issue-view.ts
+
+import fs from "fs";
+import path from "path";
+
+export interface Issue {
+  type: string;
+  occurrences: number;
+  confidence: number;
+}
+
+export interface IssueFilter {
+  topN?: number;
+  keyword?: string;
+}
+
+interface IssueDecision {
+  autoHeal: boolean;
+  reason: string;
+}
+
+interface IssueOwner {
+  team: "Backend" | "Frontend" | "QA";
+  reason: string;
+}
+
+interface IssueEvidence {
+  screenshot?: string;
+  trace?: string;
+}
+
+/* ---------------- Issue Core ---------------- */
+
+export function extractIssues(
+  groupedCounts: Record<string, number>,
+  confidence: number
+): Issue[] {
+  return Object.entries(groupedCounts).map(([type, count]) => ({
+    type,
+    occurrences: count,
+    confidence
+  }));
+}
+
+/* ---------------- Decision Logic ---------------- */
+
+function computeIssueDecision(issue: Issue): IssueDecision {
+  switch (issue.type) {
+    case "FLAKY":
+      return {
+        autoHeal: true,
+        reason: "Retry-based flaky behavior detected; stabilization is safe"
+      };
+
+    case "NUMERIC_MISMATCH":
+      return {
+        autoHeal: false,
+        reason: "Numeric mismatch likely backend or data-related"
+      };
+
+    default:
+      return {
+        autoHeal: false,
+        reason: "Insufficient signal to safely auto-heal"
+      };
+  }
+}
+
+/* ---------------- Owner Suggestion ---------------- */
+
+function computeIssueOwner(issue: Issue): IssueOwner {
+  switch (issue.type) {
+    case "NUMERIC_MISMATCH":
+      return {
+        team: "Backend",
+        reason: "Mismatch usually originates from API data or backend calculations"
+      };
+
+    case "FLAKY":
+      return {
+        team: "QA",
+        reason: "Flaky behavior typically caused by timing, waits, or test stability"
+      };
+
+    case "UNKNOWN":
+    default:
+      return {
+        team: "Frontend",
+        reason: "Failure source unclear; frontend investigation needed first"
+      };
+  }
+}
+
+/* ---------------- Evidence Picker ---------------- */
+
+function pickIssueEvidence(failureFolder: string): IssueEvidence {
+  if (!fs.existsSync(failureFolder)) return {};
+
+  const files = fs.readdirSync(failureFolder);
+
+  const screenshot = files.find(
+    f => f.startsWith("test-failed") && f.endsWith(".png")
+  );
+
+  const trace = files.includes("trace.zip") ? "trace.zip" : undefined;
+
+  return {
+    screenshot: screenshot
+      ? path.join(failureFolder, screenshot)
+      : undefined,
+    trace: trace
+      ? path.join(failureFolder, trace)
+      : undefined
+  };
+}
+
+/* ---------------- Filtering ---------------- */
+
+export function filterIssues(
+  issues: Issue[],
+  filter: IssueFilter
+): Issue[] {
+  let result = [...issues];
+
+  if (filter.keyword) {
+    const k = filter.keyword.toLowerCase();
+    result = result.filter(i =>
+      i.type.toLowerCase().includes(k)
+    );
+  }
+
+  result.sort(
+    (a, b) =>
+      b.occurrences * b.confidence -
+      a.occurrences * a.confidence
+  );
+
+  if (filter.topN !== undefined) {
+    result = result.slice(0, filter.topN);
+  }
+
+  return result;
+}
+
+/* ---------------- Console Output ---------------- */
+
+export function printIssues(
+  issues: Issue[],
+  failureFolder: string
+) {
+  if (issues.length === 0) {
+    console.log("No matching issues found.");
+    return;
+  }
+
+  const evidence = pickIssueEvidence(failureFolder);
+
+  issues.forEach((issue, index) => {
+    const decision = computeIssueDecision(issue);
+    const owner = computeIssueOwner(issue);
+
+    console.log(
+      `================ ISSUE #${index + 1} =================`
+    );
+    console.log(`Type        : ${issue.type}`);
+    console.log(`Occurrences : ${issue.occurrences}`);
+    console.log(`Confidence  : ${issue.confidence}`);
+
+    console.log("Decision:");
+    console.log(`  - Auto-heal: ${decision.autoHeal ? "YES" : "NO"}`);
+    console.log(`  - Reason   : ${decision.reason}`);
+
+    console.log("Owner:");
+    console.log(`  - Team     : ${owner.team}`);
+    console.log(`  - Why      : ${owner.reason}`);
+
+    if (evidence.screenshot || evidence.trace) {
+      console.log("\nEvidence:");
+      if (evidence.screenshot) {
+        console.log(`  Screenshot : ${evidence.screenshot}`);
+      }
+      if (evidence.trace) {
+        console.log(
+          `  Trace      : npx playwright show-trace ${evidence.trace}`
+        );
+      }
+    }
+
+    console.log(
+      "======================================================"
+    );
+  });
+}

package/src/failure-analysis/failure-analyzer.ts

@@ -0,0 +1,43 @@
+// src/failure-analysis/failure-analyzer.ts
+
+export interface FailureAnalysisResult {
+  classification: string;
+  message?: string;
+}
+
+/**
+ * FailureAnalyzer
+ * ----------------
+ * Phase 1 core analyzer.
+ * This class is intentionally simple and stable.
+ * Do NOT add history, trends, or intelligence here.
+ */
+export class FailureAnalyzer {
+  analyze(input: any): FailureAnalysisResult[] {
+    if (!input || !Array.isArray(input)) {
+      return [];
+    }
+
+    return input.map((item: any) => {
+      // Minimal safe classification logic
+      if (item?.type === "NUMERIC_MISMATCH") {
+        return {
+          classification: "NUMERIC_MISMATCH",
+          message: item.message
+        };
+      }
+
+      if (item?.type === "API_BUG") {
+        return {
+          classification: "API_BUG",
+          message: item.message
+        };
+      }
+
+      return {
+        classification: "UNKNOWN",
+        message: item?.message
+      };
+    });
+  }
+}

package/src/final-run.ts

@@ -0,0 +1,174 @@
+// src/final-run.ts
+
+import fs from "fs";
+import path from "path";
+import { runQualityIntelligence } from "./runner";
+import { runV2Intelligence } from "./v2/pipeline/v2-intelligence.pipeline";
+import {
+  extractIssues,
+  filterIssues,
+  printIssues
+} from "./console/issue-view";
+
+function pickOneFailureFolder(): string | null {
+  const base = "playwright-results";
+  if (!fs.existsSync(base)) return null;
+
+  const entries = fs.readdirSync(base, { withFileTypes: true });
+  const folder = entries.find(e => e.isDirectory());
+  return folder ? path.join(base, folder.name) : null;
+}
+
+function line(char = "=", count = 70) {
+  console.log(char.repeat(count));
+}
+
+/**
+ * Parse --issues / --issue flags
+ *
+ * Supported:
+ * --issues
+ * --issues=top3
+ * --issues=login
+ * --issue
+ * --issue=top3
+ * --issue=login
+ */
+function parseIssueFilter(): {
+  enabled: boolean;
+  topN?: number;
+  keyword?: string;
+} {
+  const arg = process.argv.find(a =>
+    a === "--issues" ||
+    a === "--issue" ||
+    a.startsWith("--issues=") ||
+    a.startsWith("--issue=")
+  );
+
+  if (!arg) return { enabled: false };
+
+  if (arg === "--issues" || arg === "--issue") {
+    return { enabled: true };
+  }
+
+  const [, value] = arg.split("=");
+
+  if (value?.startsWith("top")) {
+    const n = Number(value.replace("top", ""));
+    return { enabled: true, topN: n };
+  }
+
+  return { enabled: true, keyword: value };
+}
+
+/* ===================================================== */
+/* ✅ EXPORTED FUNCTION – SAME LOGIC, NO BEHAVIOR CHANGE  */
+/* ===================================================== */
+export async function runFinal() {
+  const playwrightResultsDir = "playwright-results";
+  const failureFolder = pickOneFailureFolder();
+  const issueFilter = parseIssueFilter();
+
+  if (!failureFolder) {
+    console.error("No Playwright failure folders found.");
+    return;
+  }
+
+  /* ---------------- V1 + Phase 3 ---------------- */
+  const v1 = await runQualityIntelligence(playwrightResultsDir);
+
+  line();
+  console.log("QUALITY INTELLIGENCE – FINAL PROJECT OUTPUT");
+  line();
+
+  console.log(`Primary Failure   : ${v1.dominantCategory}`);
+  console.log(`Confidence Score  : ${v1.confidence}`);
+  console.log(`Flaky Failures    : ${v1.flakyCount}`);
+  console.log(`Trend Signal      : ${v1.trend?.signal ?? "N/A"}`);
+
+  line("-");
+  console.log("Failure Breakdown:");
+  Object.entries(v1.groupedCounts).forEach(([k, v]) => {
+    console.log(`  - ${k}: ${v}`);
+  });
+
+  line("-");
+  console.log("Confidence Diagnosis:");
+  v1.intelligence.confidence.explanation.forEach(e =>
+    console.log(`  • ${e}`)
+  );
+
+  line("-");
+  console.log("AI Explanation:");
+  console.log(`  Summary: ${v1.intelligence.explanation.summary}`);
+  v1.intelligence.explanation.reasoning.forEach(r =>
+    console.log(`    - ${r}`)
+  );
+
+  /* ---------------- V2 ---------------- */
+  const v2 = await runV2Intelligence(
+    failureFolder,
+    v1.dominantCategory,
+    "Derived from Playwright failure artifacts"
+  );
+
+  line("-");
+  console.log("TRACE & SELF-HEALING INTELLIGENCE");
+
+  console.log("\nEvidence:");
+  if (v2.trace.screenshots.length) {
+    v2.trace.screenshots.forEach(s =>
+      console.log(`  Screenshot: ${s}`)
+    );
+  } else {
+    console.log("  No screenshots found");
+  }
+
+  if (v2.trace.traceFile) {
+    console.log(`  Trace File : ${v2.trace.traceFile}`);
+    console.log(`  Open Trace : npx playwright show-trace ${v2.trace.traceFile}`);
+  }
+
+  line("-");
+  console.log("Self-Healing Decision:");
+  if (v2.healing) {
+    console.log(`  Allowed     : YES`);
+    console.log(`  Reason      : ${v2.healing.reason}`);
+    console.log(`  Fix         : ${v2.healing.suggestedFix}`);
+    console.log(`  Confidence  : ${v2.healing.confidence}`);
+  } else {
+    console.log(`  Allowed     : NO (manual fix required)`);
+  }
+
+  line("-");
+  console.log("LLM Advisory:");
+  console.log(`  ${v2.llm.summary}`);
+  v2.llm.fixRecommendation.forEach(r =>
+    console.log(`    - ${r}`)
+  );
+
+  /* ---------------- ISSUE VIEW (OPTIONAL) ---------------- */
+  if (issueFilter.enabled) {
+    line();
+    console.log("ISSUE ANALYSIS");
+    line();
+
+    const issues = extractIssues(
+      v1.groupedCounts,
+      v1.confidence
+    );
+
+    const filtered = filterIssues(issues, issueFilter);
+    printIssues(filtered, failureFolder);
+  }
+
+  line();
+}
+
+/* ===================================================== */
+/* ✅ KEEP EXISTING BEHAVIOR WHEN RUN DIRECTLY            */
+/* ===================================================== */
+if (require.main === module) {
+  runFinal();
+}

package/src/final-runner.ts

@@ -0,0 +1,31 @@
+import { spawn } from "child_process";
+import path from "path";
+
+export async function runFinalOutput(options: {
+  playwrightResultsDir: string;
+  showIssues?: boolean;
+}) {
+  const args: string[] = [];
+
+  if (options.showIssues) {
+    args.push("--issue");
+  }
+
+  // run existing final-run.ts via ts-node / node
+  const scriptPath = path.join(__dirname, "final-run.ts");
+
+  return new Promise<void>((resolve, reject) => {
+    const proc = spawn(
+      "node",
+      ["--loader", "ts-node/esm", scriptPath, ...args],
+      {
+        stdio: "inherit"
+      }
+    );
+
+    proc.on("close", code => {
+      if (code === 0) resolve();
+      else reject(new Error(`final-run exited with ${code}`));
+    });
+  });
+}

package/src/fixtures/networkCollector.ts

@@ -0,0 +1,27 @@
+import { test as base, Page } from '@playwright/test';
+
+export type NetworkResponseRecord = {
+  url: string;
+  method: string;
+  status: number;
+  ok: boolean;
+};
+
+export const test = base.extend<{
+  networkResponses: NetworkResponseRecord[];
+}>({
+  networkResponses: async ({ page }, use) => {
+    const responses: NetworkResponseRecord[] = [];
+
+    page.on('response', async response => {
+      responses.push({
+        url: response.url(),
+        method: response.request().method(),
+        status: response.status(),
+        ok: response.ok()
+      });
+    });
+
+    await use(responses);
+  }
+});

package/src/history/failure-history.store.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+import path from "path";
+import { FailureHistoryEntry } from "./failure-history.types";
+
+const HISTORY_DIR = path.join(process.cwd(), "artifacts/failure-history");
+
+export function saveFailureHistory(entry: FailureHistoryEntry): void {
+  if (!fs.existsSync(HISTORY_DIR)) {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+
+  const filePath = path.join(HISTORY_DIR, `${entry.runId}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(entry, null, 2));
+}
+
+export function loadFailureHistory(): FailureHistoryEntry[] {
+  if (!fs.existsSync(HISTORY_DIR)) return [];
+
+  return fs.readdirSync(HISTORY_DIR).map(file => {
+    const fullPath = path.join(HISTORY_DIR, file);
+    return JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+  });
+}

package/src/history/failure-history.types.ts

@@ -0,0 +1,12 @@
+// History layer is DECOUPLED from pipeline
+// No dependency on FailureType to avoid path issues
+
+export type FailureType = string;
+
+export interface FailureHistoryEntry {
+  runId: string;
+  timestamp: string;
+  dominantCategory: FailureType;
+  groupedCounts: Record<FailureType, number>;
+  confidence: number; // 0–1
+}

package/src/history/failure-trend.analyzer.ts

@@ -0,0 +1,49 @@
+import { FailureHistoryEntry } from "./failure-history.types";
+
+export interface FailureTrendResult {
+  recurring: boolean;
+  dominantCategory: string;
+  occurrences: number;
+  confidenceTrend: "increasing" | "decreasing" | "stable";
+  signal: "ESCALATING" | "STABLE" | "NOISY";
+}
+
+export function analyzeFailureTrends(
+  history: FailureHistoryEntry[]
+): FailureTrendResult | null {
+  if (history.length < 2) return null;
+
+  const recent = history.slice(-5);
+  const categoryCount: Record<string, number> = {};
+
+  for (const h of recent) {
+    categoryCount[h.dominantCategory] =
+      (categoryCount[h.dominantCategory] || 0) + 1;
+  }
+
+  const [dominantCategory, occurrences] =
+    Object.entries(categoryCount).sort((a, b) => b[1] - a[1])[0];
+
+  const first = recent[0].confidence;
+  const last = recent[recent.length - 1].confidence;
+
+  const confidenceTrend =
+    last > first ? "increasing" :
+    last < first ? "decreasing" :
+    "stable";
+
+  const signal =
+    occurrences >= 3 && confidenceTrend === "increasing"
+      ? "ESCALATING"
+      : occurrences >= 3
+      ? "STABLE"
+      : "NOISY";
+
+  return {
+    recurring: occurrences >= 2,
+    dominantCategory,
+    occurrences,
+    confidenceTrend,
+    signal
+  };
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { groupFailures } from "./pipeline/failure-grouping.pipeline";
+
+const fakeRun = [
+  { classification: "NUMERIC_MISMATCH", message: "price mismatch" },
+  { classification: "NUMERIC_MISMATCH", message: "tax mismatch" },
+  { classification: "API_BUG", message: "500 error" }
+];
+
+const result = groupFailures(fakeRun);
+console.log(JSON.stringify(result, null, 2));

package/src/integrations/ci/ci-annotator.ts

@@ -0,0 +1,42 @@
+type AnnotationInput = {
+  testName: string
+  file: string
+  line: number
+  message: string
+  confidence: number
+  rootCause: string
+}
+
+export function emitCIAnnotation(input: AnnotationInput) {
+  // -----------------------------
+  // GitHub Actions annotation
+  // -----------------------------
+  if (process.env.GITHUB_ACTIONS) {
+    console.log(
+      `::error file=${input.file},line=${input.line},title=${sanitize(
+        input.testName
+      )}::${sanitize(
+        `${input.rootCause} (confidence ${(input.confidence / 100).toFixed(
+          2
+        )})`
+      )}`
+    )
+  }
+
+  // -----------------------------
+  // GitLab CI annotation (job log)
+  // -----------------------------
+  if (process.env.GITLAB_CI) {
+    console.log(`
+❌ CI Failure Annotation
+Test       : ${input.testName}
+File       : ${input.file}:${input.line}
+Root Cause : ${input.rootCause}
+Confidence : ${(input.confidence / 100).toFixed(2)}
+`)
+  }
+}
+
+function sanitize(value: string): string {
+  return value.replace(/[\n\r]/g, ' ')
+}

package/src/intelligence/confidence-calibration.engine.ts

@@ -0,0 +1,41 @@
+// src/intelligence/confidence-calibration.engine.ts
+
+import { FailureGroupSummary } from "../pipeline/failure-grouping.pipeline";
+
+export interface ConfidenceExplanation {
+  score: number;
+  explanation: string[];
+}
+
+export function explainConfidence(
+  summary: FailureGroupSummary
+): ConfidenceExplanation {
+  const explanation: string[] = [];
+
+  explanation.push(
+    "Base confidence calculated from dominant failure frequency"
+  );
+
+  if (summary.flakyCount > 0) {
+    explanation.push(
+      `${summary.flakyCount} flaky (retry-based) failures detected, reducing confidence`
+    );
+  }
+
+  if (summary.trend?.signal === "NOISY") {
+    explanation.push(
+      "Multiple failure categories reduce certainty"
+    );
+  }
+
+  if (summary.trend?.signal === "STABLE") {
+    explanation.push(
+      "Failure pattern is consistent but not escalating"
+    );
+  }
+
+  return {
+    score: summary.confidence,
+    explanation
+  };
+}

package/src/intelligence/decision-intelligence/confidence.engine.ts

@@ -0,0 +1,18 @@
+import { DecisionContext } from './decision.types'
+import { DECISION_CONFIG } from './decision.config'
+
+export function computeConfidence(ctx: DecisionContext): number {
+  let confidence = ctx.baseConfidence
+
+  for (const f of ctx.failures) {
+    confidence -= DECISION_CONFIG.impacts.failure[f.type]
+  }
+
+  for (const fl of ctx.flakiness) {
+    if (fl.severity) {
+      confidence -= DECISION_CONFIG.impacts.flakiness[fl.severity]
+    }
+  }
+
+  return Math.max(0, Math.min(100, confidence))
+}

package/src/intelligence/decision-intelligence/decision.config.ts

@@ -0,0 +1,18 @@
+export const DECISION_CONFIG = {
+  impacts: {
+    failure: {
+      NEW: 15,
+      KNOWN: 5,
+      REGRESSED: 25
+    },
+    flakiness: {
+      LOW: 5,
+      MEDIUM: 10,
+      HIGH: 20
+    }
+  },
+  thresholds: {
+    SHIP: 80,
+    INVESTIGATE: 60
+  }
+}