quality-intelligence-engine 2.2.18 → 2.2.22

package/dist/src/history/failure-trend.analyzer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFailureTrends = analyzeFailureTrends;
+function analyzeFailureTrends(history) {
+    if (history.length < 2)
+        return null;
+    const recent = history.slice(-5);
+    const categoryCount = {};
+    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/dist/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const failure_grouping_pipeline_1 = require("./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 = (0, failure_grouping_pipeline_1.groupFailures)(fakeRun);
+console.log(JSON.stringify(result, null, 2));

package/dist/src/integrations/ci/ci-annotator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitCIAnnotation = emitCIAnnotation;
+function emitCIAnnotation(input) {
+    // -----------------------------
+    // 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) {
+    return value.replace(/[\n\r]/g, ' ');
+}

package/dist/src/intelligence/confidence-calibration.engine.js

@@ -0,0 +1,21 @@
+"use strict";
+// src/intelligence/confidence-calibration.engine.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explainConfidence = explainConfidence;
+function explainConfidence(summary) {
+    const explanation = [];
+    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/dist/src/intelligence/decision-intelligence/confidence.engine.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeConfidence = computeConfidence;
+const decision_config_1 = require("./decision.config");
+function computeConfidence(ctx) {
+    let confidence = ctx.baseConfidence;
+    for (const f of ctx.failures) {
+        confidence -= decision_config_1.DECISION_CONFIG.impacts.failure[f.type];
+    }
+    for (const fl of ctx.flakiness) {
+        if (fl.severity) {
+            confidence -= decision_config_1.DECISION_CONFIG.impacts.flakiness[fl.severity];
+        }
+    }
+    return Math.max(0, Math.min(100, confidence));
+}

package/dist/src/intelligence/decision-intelligence/decision.config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DECISION_CONFIG = void 0;
+exports.DECISION_CONFIG = {
+    impacts: {
+        failure: {
+            NEW: 15,
+            KNOWN: 5,
+            REGRESSED: 25
+        },
+        flakiness: {
+            LOW: 5,
+            MEDIUM: 10,
+            HIGH: 20
+        }
+    },
+    thresholds: {
+        SHIP: 80,
+        INVESTIGATE: 60
+    }
+};

package/dist/src/intelligence/decision-intelligence/decision.engine.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decide = decide;
+const decision_config_1 = require("./decision.config");
+const confidence_engine_1 = require("./confidence.engine");
+function decide(ctx) {
+    const confidence = (0, confidence_engine_1.computeConfidence)(ctx);
+    const reasoning = [];
+    if (confidence < decision_config_1.DECISION_CONFIG.thresholds.INVESTIGATE) {
+        reasoning.push('Confidence below investigate threshold');
+    }
+    if (confidence < decision_config_1.DECISION_CONFIG.thresholds.SHIP) {
+        reasoning.push('Confidence below ship threshold');
+    }
+    let decision = 'SHIP';
+    if (confidence < decision_config_1.DECISION_CONFIG.thresholds.INVESTIGATE) {
+        decision = 'HOLD';
+    }
+    else if (confidence < decision_config_1.DECISION_CONFIG.thresholds.SHIP) {
+        decision = 'INVESTIGATE';
+    }
+    return { confidence, decision, reasoning };
+}

package/dist/src/intelligence/decision-intelligence/decision.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/intelligence/failure-fingerprinting/failure.classifier.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyFailure = classifyFailure;
+/* --------- IMPLEMENTATION --------- */
+function classifyFailure(input, _runId, _history) {
+    const haystack = JSON.stringify(input).toLowerCase();
+    /* ---------------- NUMERIC ---------------- */
+    if (haystack.includes("numeric") ||
+        haystack.includes("count") ||
+        haystack.includes("mismatch") ||
+        haystack.includes("total")) {
+        return "NUMERIC_MISMATCH";
+    }
+    /* ---------------- AUTH / LOGIN ---------------- */
+    if (haystack.includes("login") ||
+        haystack.includes("username") ||
+        haystack.includes("password") ||
+        haystack.includes("credential") ||
+        haystack.includes("locked") ||
+        haystack.includes("required") ||
+        haystack.includes("do not match")) {
+        return "AUTH_FAILURE";
+    }
+    /* ---------------- SECURITY ---------------- */
+    if (haystack.includes("sql") ||
+        haystack.includes("injection") ||
+        haystack.includes("unauthorized") ||
+        haystack.includes("forbidden")) {
+        return "SECURITY";
+    }
+    return "UNKNOWN";
+}

package/dist/src/intelligence/failure-fingerprinting/failure.store.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFailure = recordFailure;
+/* ---------- IMPLEMENTATION ---------- */
+function recordFailure(arg1, arg2, arg3) {
+    if (typeof arg1 === "object") {
+        const { classification, runId, testName } = arg1;
+        // 🔒 internal canonical call
+        recordFailure(classification, Number(runId), testName ?? "unknown");
+        return;
+    }
+    const fingerprint = arg1;
+    const runId = arg2;
+    const testName = arg3;
+    // 👉 existing storage logic stays EXACTLY as-is below
+    // saveFailure(fingerprint, runId, testName);
+}

package/dist/src/intelligence/failure-fingerprinting/failure.tracker.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFailure = trackFailure;
+const failure_classifier_1 = require("./failure.classifier");
+const failure_store_1 = require("./failure.store");
+function trackFailure(rawFailure, runId) {
+    /**
+     * Treat fingerprint input as OPAQUE.
+     * Do NOT assume fields. This avoids regressions.
+     */
+    const fingerprintInput = rawFailure;
+    // Backward + forward compatible call
+    const classification = (0, failure_classifier_1.classifyFailure)(fingerprintInput, runId, undefined);
+    (0, failure_store_1.recordFailure)({
+        runId,
+        classification
+    });
+    return classification;
+}

package/dist/src/intelligence/failure-fingerprinting/fingerprint.generator.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFailureFingerprint = generateFailureFingerprint;
+const crypto_1 = __importDefault(require("crypto"));
+function normalize(value) {
+    return value
+        .toLowerCase()
+        .replace(/\d+/g, '') // remove dynamic numbers
+        .replace(/\s+/g, ' ') // normalize whitespace
+        .trim();
+}
+function generateFailureFingerprint(input) {
+    const canonical = JSON.stringify({
+        failureType: input.failureType,
+        pageRoute: normalize(input.pageRoute),
+        primaryLocator: normalize(input.primaryLocator),
+        assertionIntent: normalize(input.assertionIntent),
+        errorClass: normalize(input.errorClass)
+    });
+    return crypto_1.default
+        .createHash('sha1')
+        .update(canonical)
+        .digest('hex')
+        .slice(0, 8);
+}

package/dist/src/intelligence/failure-fingerprinting/fingerprint.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/intelligence/flakiness-intelligence/flakiness.analyzer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFlakiness = analyzeFlakiness;
+function analyzeFlakiness(outcomes) {
+    if (outcomes.length < 4)
+        return null;
+    let oscillations = 0;
+    for (let i = 1; i < outcomes.length; i++) {
+        if (outcomes[i] !== outcomes[i - 1]) {
+            oscillations++;
+        }
+    }
+    const rate = oscillations / (outcomes.length - 1);
+    if (rate > 0.6)
+        return 'HIGH';
+    if (rate > 0.3)
+        return 'MEDIUM';
+    if (rate > 0.1)
+        return 'LOW';
+    return null;
+}

package/dist/src/intelligence/flakiness-intelligence/flakiness.fingerprint.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFlakinessFingerprint = generateFlakinessFingerprint;
+const crypto_1 = __importDefault(require("crypto"));
+function normalize(value) {
+    if (!value)
+        return 'unknown';
+    return value.toLowerCase().trim();
+}
+function generateFlakinessFingerprint(testName, pageRoute) {
+    const key = `${normalize(testName)}::${normalize(pageRoute)}`;
+    return crypto_1.default.createHash('md5').update(key).digest('hex');
+}

package/dist/src/intelligence/flakiness-intelligence/flakiness.store.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFlakinessHistory = readFlakinessHistory;
+exports.writeFlakinessHistory = writeFlakinessHistory;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const HISTORY_PATH = path_1.default.resolve('data/flakiness/history.json');
+function readFlakinessHistory() {
+    if (!fs_1.default.existsSync(HISTORY_PATH)) {
+        return {};
+    }
+    const raw = fs_1.default.readFileSync(HISTORY_PATH, 'utf-8').trim();
+    if (!raw) {
+        return {};
+    }
+    return JSON.parse(raw);
+}
+function writeFlakinessHistory(history) {
+    fs_1.default.mkdirSync(path_1.default.dirname(HISTORY_PATH), { recursive: true });
+    fs_1.default.writeFileSync(HISTORY_PATH, JSON.stringify(history, null, 2));
+}

package/dist/src/intelligence/flakiness-intelligence/flakiness.tracker.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFlakiness = trackFlakiness;
+const flakiness_fingerprint_1 = require("./flakiness.fingerprint");
+const flakiness_store_1 = require("./flakiness.store");
+function trackFlakiness(testName, pageRoute, outcome) {
+    const fingerprint = (0, flakiness_fingerprint_1.generateFlakinessFingerprint)(testName, pageRoute);
+    const history = (0, flakiness_store_1.readFlakinessHistory)();
+    if (!history[fingerprint]) {
+        history[fingerprint] = [];
+    }
+    history[fingerprint].push(outcome);
+    (0, flakiness_store_1.writeFlakinessHistory)(history);
+    const recent = history[fingerprint].slice(-6);
+    const oscillations = recent.filter((value, index, arr) => index > 0 && value !== arr[index - 1]).length;
+    let severity = null;
+    if (oscillations >= 3)
+        severity = 'HIGH';
+    else if (oscillations === 2)
+        severity = 'MEDIUM';
+    else if (oscillations === 1)
+        severity = 'LOW';
+    return {
+        fingerprint,
+        history: recent,
+        severity
+    };
+}

package/dist/src/intelligence/flakiness-intelligence/flakiness.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/intelligence/intelligence.pipeline.js

@@ -0,0 +1,17 @@
+"use strict";
+// src/intelligence/intelligence.pipeline.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichWithIntelligence = enrichWithIntelligence;
+const llm_explainer_1 = require("./llm-explainer");
+const confidence_calibration_engine_1 = require("./confidence-calibration.engine");
+async function enrichWithIntelligence(summary) {
+    const confidence = (0, confidence_calibration_engine_1.explainConfidence)(summary);
+    const explanation = await (0, llm_explainer_1.explainFailureWithLLM)(summary);
+    return {
+        ...summary,
+        intelligence: {
+            confidence,
+            explanation
+        }
+    };
+}

package/dist/src/intelligence/llm-explainer.js

@@ -0,0 +1,19 @@
+"use strict";
+// src/intelligence/llm-explainer.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explainFailureWithLLM = explainFailureWithLLM;
+async function explainFailureWithLLM(summary) {
+    const dominantCount = summary.groupedCounts[summary.dominantCategory] ?? 0;
+    return {
+        summary: `Primary failure detected: ${summary.dominantCategory}`,
+        reasoning: [
+            `Failure occurred ${dominantCount} times`,
+            `Confidence is ${summary.confidence}`
+        ],
+        recommendedAction: [
+            "Inspect backend API response",
+            "Verify numeric calculations",
+            "Check recent code changes"
+        ]
+    };
+}

package/dist/src/intelligence/root-cause/rootcause.engine.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeRootCause = analyzeRootCause;
+function analyzeRootCause(input) {
+    const { retryCount, isAssertionError, hasHistory } = input;
+    // 🔴 App bug: not assertion + no retries
+    if (!isAssertionError && retryCount === 0) {
+        return {
+            type: 'APPLICATION_BUG',
+            reason: 'Failure without retries → application issue likely'
+        };
+    }
+    // 🟡 Flaky: retries + history
+    if (retryCount > 0 && hasHistory) {
+        return {
+            type: 'FLAKY',
+            reason: 'Failure resolved on retry → flaky behavior detected'
+        };
+    }
+    // 🟢 Default: test bug
+    return {
+        type: 'TEST_BUG',
+        reason: 'Assertion failure with stable history → test logic issue'
+    };
+}

package/dist/src/intelligence/trend-intelligence/trend.engine.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTrend = analyzeTrend;
+function analyzeTrend(history, windowSize = 10) {
+    const recent = history.slice(-windowSize);
+    const totalRuns = recent.length;
+    const passCount = recent.filter(r => r === 'PASS').length;
+    const failCount = recent.filter(r => r === 'FAIL').length;
+    const passRate = totalRuns ? passCount / totalRuns : 0;
+    const failRate = totalRuns ? failCount / totalRuns : 0;
+    const oscillations = recent.filter((v, i, arr) => i > 0 && v !== arr[i - 1]).length;
+    let flakiness = 'LOW';
+    if (oscillations >= 4)
+        flakiness = 'HIGH';
+    else if (oscillations >= 2)
+        flakiness = 'MEDIUM';
+    const stability = flakiness === 'HIGH' || failRate > 0.4 ? 'UNSTABLE' : 'STABLE';
+    return {
+        totalRuns,
+        passRate,
+        failRate,
+        flakiness,
+        stability
+    };
+}

package/dist/src/markdownWriter.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAnalysisMarkdown = writeAnalysisMarkdown;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function writeAnalysisMarkdown(baseDir, issueId, result, occurrences) {
+    const issueDir = path_1.default.join(baseDir, issueId);
+    fs_1.default.mkdirSync(issueDir, { recursive: true });
+    const mdPath = path_1.default.join(issueDir, 'analysis.md');
+    const content = `
+# ❌ ${result.category}
+
+**Occurrences** : ${occurrences}  
+**Confidence**  : ${result.confidence}
+
+---
+
+## 📍 Failure Location
+- **File** : ${result.location.file}
+- **Line** : ${result.location.line}
+
+---
+
+## 🌐 Failed API Call
+- **Method**   : ${result.failedApi.method}
+- **Endpoint** : ${result.failedApi.endpoint}
+- **Status**   : ${result.failedApi.status}
+- **Response** : ${result.failedApi.response ?? '-'}
+
+---
+
+## 🧠 Root Cause
+${result.rootCause}
+
+---
+
+## 🔁 Retry Guidance
+${result.retryGuidance}
+
+---
+
+## ▶️ Reproduction Steps
+${result.reproductionSteps.map((s, i) => `${i + 1}. ${s}`).join('\n')}
+
+---
+
+## ✅ Expected Result
+${result.expected}
+
+---
+
+## ❌ Actual Result
+${result.actual}
+
+---
+
+## 🛠 Suggested Actions
+${result.suggestedActions.map(a => `- ${a}`).join('\n')}
+`.trim();
+    fs_1.default.writeFileSync(mdPath, content, 'utf-8');
+}

package/dist/src/normalizer.js

@@ -0,0 +1,17 @@
+"use strict";
+/* src/normalizer.ts */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRawInput = normalizeRawInput;
+/**
+ * Public normalizer API
+ */
+function normalizeRawInput(items) {
+    return items.map((item) => {
+        const safeItem = item;
+        return {
+            rootCause: safeItem.message,
+            actual: safeItem.message,
+            response: safeItem.api?.response
+        };
+    });
+}

package/dist/src/passAnalyzer.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePasses = analyzePasses;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function analyzePasses() {
+    const passPath = path_1.default.join(process.cwd(), 'input/raw-pass.json');
+    const items = JSON.parse(fs_1.default.readFileSync(passPath, 'utf-8'));
+    const risks = [];
+    items.forEach((item) => {
+        // Flaky pass
+        if (item.retries > 0) {
+            risks.push({
+                test: item.test,
+                riskType: 'FLAKY_PASS',
+                location: { file: item.test, line: -1 },
+                reason: 'Test passed after retry',
+                fix: 'Stabilize locator or add explicit waits'
+            });
+        }
+        // API warnings during pass
+        item.apiEvents?.forEach((api) => {
+            if (api.status >= 400 && api.recovered) {
+                risks.push({
+                    test: item.test,
+                    riskType: 'API_WARNING',
+                    location: { file: item.test, line: -1 },
+                    reason: `${api.method} ${api.endpoint} failed with ${api.status} but recovered`,
+                    fix: 'Investigate backend instability or add retry with backoff'
+                });
+            }
+        });
+    });
+    return risks;
+}

package/dist/src/pipeline/ai.summarizer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeWithAI = summarizeWithAI;
+async function summarizeWithAI(input) {
+    // 🔒 Safety first — AI is OPTIONAL
+    if (!process.env.AI_ENABLED) {
+        return deterministicFallback(input);
+    }
+    try {
+        // 🔹 Placeholder for real LLM call
+        // 🔹 Intentionally simple & replaceable
+        return `
+This failure occurred in the test "${input.testName}".
+Based on the observed error and system heuristics, the root cause is classified as:
+"${input.rootCause}"
+
+The confidence score (${(input.confidence / 100).toFixed(2)}) indicates a stable and repeatable issue.
+Recommended action is to follow the suggested remediation rather than retrying the test.
+`.trim();
+    }
+    catch {
+        // 🔒 Never crash pipeline because of AI
+        return deterministicFallback(input);
+    }
+}
+function deterministicFallback(input) {
+    return `
+Failure in "${input.testName}" was analyzed deterministically.
+Root cause identified as: ${input.rootCause}.
+Confidence level: ${(input.confidence / 100).toFixed(2)}.
+`.trim();
+}

package/dist/src/pipeline/failure-analysis.pipeline.js

@@ -0,0 +1,11 @@
+"use strict";
+// src/pipeline/failure-analysis.pipeline.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFailureAnalysisFromPlaywright = runFailureAnalysisFromPlaywright;
+const playwright_folder_adapter_1 = require("../adapters/playwright-folder.adapter");
+/**
+ * Phase 1 – Playwright Failure Intake (Folder-based)
+ */
+async function runFailureAnalysisFromPlaywright(playwrightResultsDir) {
+    return (0, playwright_folder_adapter_1.parsePlaywrightFailureFolders)(playwrightResultsDir);
+}