quality-intelligence-engine 2.2.0

package/dist/src/final-run.js

@@ -0,0 +1,130 @@
+"use strict";
+// src/final-run.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFinal = runFinal;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const runner_1 = require("./runner");
+const v2_intelligence_pipeline_1 = require("./v2/pipeline/v2-intelligence.pipeline");
+const issue_view_1 = require("./console/issue-view");
+function pickOneFailureFolder() {
+    const base = "playwright-results";
+    if (!fs_1.default.existsSync(base))
+        return null;
+    const entries = fs_1.default.readdirSync(base, { withFileTypes: true });
+    const folder = entries.find(e => e.isDirectory());
+    return folder ? path_1.default.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() {
+    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  */
+/* ===================================================== */
+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 (0, runner_1.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 (0, v2_intelligence_pipeline_1.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 = (0, issue_view_1.extractIssues)(v1.groupedCounts, v1.confidence);
+        const filtered = (0, issue_view_1.filterIssues)(issues, issueFilter);
+        (0, issue_view_1.printIssues)(filtered, failureFolder);
+    }
+    line();
+}
+/* ===================================================== */
+/* ✅ KEEP EXISTING BEHAVIOR WHEN RUN DIRECTLY            */
+/* ===================================================== */
+if (require.main === module) {
+    runFinal();
+}

package/dist/src/final-runner.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFinalOutput = runFinalOutput;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+async function runFinalOutput(options) {
+    const args = [];
+    if (options.showIssues) {
+        args.push("--issue");
+    }
+    // run existing final-run.ts via ts-node / node
+    const scriptPath = path_1.default.join(__dirname, "final-run.ts");
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.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/dist/src/fixtures/networkCollector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const test_1 = require("@playwright/test");
+exports.test = test_1.test.extend({
+    networkResponses: async ({ page }, use) => {
+        const responses = [];
+        page.on('response', async (response) => {
+            responses.push({
+                url: response.url(),
+                method: response.request().method(),
+                status: response.status(),
+                ok: response.ok()
+            });
+        });
+        await use(responses);
+    }
+});

package/dist/src/history/failure-history.store.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveFailureHistory = saveFailureHistory;
+exports.loadFailureHistory = loadFailureHistory;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const HISTORY_DIR = path_1.default.join(process.cwd(), "artifacts/failure-history");
+function saveFailureHistory(entry) {
+    if (!fs_1.default.existsSync(HISTORY_DIR)) {
+        fs_1.default.mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const filePath = path_1.default.join(HISTORY_DIR, `${entry.runId}.json`);
+    fs_1.default.writeFileSync(filePath, JSON.stringify(entry, null, 2));
+}
+function loadFailureHistory() {
+    if (!fs_1.default.existsSync(HISTORY_DIR))
+        return [];
+    return fs_1.default.readdirSync(HISTORY_DIR).map(file => {
+        const fullPath = path_1.default.join(HISTORY_DIR, file);
+        return JSON.parse(fs_1.default.readFileSync(fullPath, "utf-8"));
+    });
+}

package/dist/src/history/failure-history.types.js

@@ -0,0 +1,4 @@
+"use strict";
+// History layer is DECOUPLED from pipeline
+// No dependency on FailureType to avoid path issues
+Object.defineProperty(exports, "__esModule", { value: true });

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,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyFailure = classifyFailure;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const REGISTRY_PATH = path_1.default.resolve('data/failures/registry.json');
+const REGRESSION_GAP = 3;
+function classifyFailure(fingerprint, currentRun) {
+    const registry = JSON.parse(fs_1.default.readFileSync(REGISTRY_PATH, 'utf-8'));
+    const entry = registry[fingerprint];
+    if (!entry)
+        return 'NEW';
+    if (currentRun - entry.lastSeenRun > REGRESSION_GAP) {
+        return 'REGRESSED';
+    }
+    return 'KNOWN';
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFailure = recordFailure;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const BASE_PATH = path_1.default.resolve('data/failures');
+const REGISTRY_PATH = path_1.default.join(BASE_PATH, 'registry.json');
+const FP_DIR = path_1.default.join(BASE_PATH, 'fingerprints');
+function readRegistry() {
+    return JSON.parse(fs_1.default.readFileSync(REGISTRY_PATH, 'utf-8'));
+}
+function writeRegistry(data) {
+    fs_1.default.writeFileSync(REGISTRY_PATH, JSON.stringify(data, null, 2));
+}
+function recordFailure(fingerprint, runId, testName) {
+    const registry = readRegistry();
+    if (!registry[fingerprint]) {
+        registry[fingerprint] = {
+            firstSeenRun: runId,
+            lastSeenRun: runId,
+            totalOccurrences: 1
+        };
+    }
+    else {
+        registry[fingerprint].lastSeenRun = runId;
+        registry[fingerprint].totalOccurrences++;
+    }
+    writeRegistry(registry);
+    const fpPath = path_1.default.join(FP_DIR, `${fingerprint}.json`);
+    const history = fs_1.default.existsSync(fpPath)
+        ? JSON.parse(fs_1.default.readFileSync(fpPath, 'utf-8'))
+        : { runsSeen: [], affectedTests: [] };
+    history.runsSeen.push(runId);
+    history.affectedTests.push(testName);
+    fs_1.default.writeFileSync(fpPath, JSON.stringify(history, null, 2));
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFailure = trackFailure;
+const fingerprint_generator_1 = require("./fingerprint.generator");
+const failure_classifier_1 = require("./failure.classifier");
+const failure_store_1 = require("./failure.store");
+function trackFailure(input, runId, testName) {
+    const fingerprint = (0, fingerprint_generator_1.generateFailureFingerprint)(input);
+    const classification = (0, failure_classifier_1.classifyFailure)(fingerprint, runId);
+    (0, failure_store_1.recordFailure)(fingerprint, runId, testName);
+    return {
+        fingerprint,
+        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'
+    };
+}