quality-intelligence-engine 2.2.0

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);
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+// src/pipeline/failure-grouping.pipeline.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupFailures = groupFailures;
+const failure_history_store_1 = require("../history/failure-history.store");
+const failure_trend_analyzer_1 = require("../history/failure-trend.analyzer");
+function groupFailures(results) {
+    const groupedCounts = {};
+    let flakyCount = 0;
+    for (const r of results) {
+        const key = r.classification ?? "UNKNOWN";
+        groupedCounts[key] = (groupedCounts[key] || 0) + 1;
+        if (key === "FLAKY") {
+            flakyCount++;
+        }
+    }
+    let dominantCategory = "UNKNOWN";
+    let dominantCount = 0;
+    for (const [category, count] of Object.entries(groupedCounts)) {
+        if (count > dominantCount) {
+            dominantCategory = category;
+            dominantCount = count;
+        }
+    }
+    const total = results.length || 1;
+    let confidence = dominantCount / total;
+    // 🔻 FLAKY PENALTY (KEY LOGIC)
+    if (flakyCount > 0) {
+        const penalty = Math.min(0.3, flakyCount / total);
+        confidence = Math.max(0, confidence - penalty);
+    }
+    const summary = {
+        dominantCategory,
+        groupedCounts,
+        confidence,
+        flakyCount
+    };
+    (0, failure_history_store_1.saveFailureHistory)({
+        runId: Date.now().toString(),
+        timestamp: new Date().toISOString(),
+        dominantCategory,
+        groupedCounts,
+        confidence
+    });
+    summary.trend = (0, failure_trend_analyzer_1.analyzeFailureTrends)((0, failure_history_store_1.loadFailureHistory)());
+    return summary;
+}

package/dist/src/reporter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSummaryAndWriteReports = printSummaryAndWriteReports;
+exports.printPassRisks = printPassRisks;
+const markdownWriter_1 = require("./markdownWriter");
+/**
+ * FAILURES: Print summary + write markdown reports
+ */
+function printSummaryAndWriteReports(grouped, run, config) {
+    let printed = 0;
+    grouped.forEach((items, key) => {
+        const sample = items[0];
+        // Respect confidence threshold
+        if (sample.confidence <
+            config.engine.confidenceThresholds.fail) {
+            return;
+        }
+        if (printed === 0) {
+            console.log(`❌ Failures Detected (${grouped.size} unique issues)\n`);
+        }
+        printed++;
+        console.log(`${printed}) ${sample.category} (${items.length} occurrences)`);
+        console.log(`   Location : ${sample.location.file}:${sample.location.line}`);
+        console.log(`   API      : ${sample.failedApi.endpoint} → ${sample.failedApi.status}`);
+        console.log(`   Cause    : ${sample.rootCause}`);
+        console.log(`   Details  : output/${run.runDir.split('/').pop()}/${key}/analysis.md\n`);
+        (0, markdownWriter_1.writeAnalysisMarkdown)(run.runDir, key, sample, items.length);
+    });
+    if (printed === 0) {
+        console.log('✅ No failures exceeded confidence threshold\n');
+    }
+}
+/**
+ * PASSES: Print non-blocking risk warnings
+ */
+function printPassRisks(risks, _run) {
+    if (risks.length === 0)
+        return;
+    console.log(`⚠️ Pass Risks Detected (${risks.length})\n`);
+    risks.forEach((risk, i) => {
+        console.log(`${i + 1}) ${risk.test} → ${risk.riskType}`);
+        console.log(`   Location : ${risk.location.file}`);
+        console.log(`   Reason   : ${risk.reason}`);
+        console.log(`   Fix      : ${risk.fix}\n`);
+    });
+}

package/dist/src/rules.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDummyResult = generateDummyResult;
+function generateDummyResult() {
+    return {
+        category: 'BACKEND_API_FAILURE',
+        confidence: 0.93,
+        location: {
+            file: 'AuthController.java',
+            line: 87
+        },
+        failedApi: {
+            method: 'GET',
+            endpoint: '/users/{id}',
+            status: 404,
+            response: 'User not found'
+        },
+        rootCause: 'The requested user ID does not exist in the database.',
+        retryGuidance: 'Automated CI retry is not advised (high confidence application failure).',
+        reproductionSteps: [
+            'Start backend service',
+            'Run: curl GET /users/{id}',
+            'Observe: 404 Not Found'
+        ],
+        expected: 'User details are returned successfully.',
+        actual: 'API returns 404 and request fails in AuthController.java:87',
+        suggestedActions: [
+            'Validate user existence before API call',
+            'Add graceful handling for missing user records'
+        ]
+    };
+}

package/dist/src/runManager.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunContext = createRunContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function createRunContext() {
+    const now = new Date();
+    const runId = now
+        .toISOString()
+        .replace(/[:.]/g, '-')
+        .replace('T', '_')
+        .replace('Z', '');
+    const runDir = path_1.default.join(process.cwd(), 'output', `run-${runId}`);
+    fs_1.default.mkdirSync(runDir, { recursive: true });
+    return { runId, runDir };
+}

package/dist/src/runner.js

@@ -0,0 +1,13 @@
+"use strict";
+// src/runner.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQualityIntelligence = runQualityIntelligence;
+const failure_analysis_pipeline_1 = require("./pipeline/failure-analysis.pipeline");
+const failure_grouping_pipeline_1 = require("./pipeline/failure-grouping.pipeline");
+const intelligence_pipeline_1 = require("./intelligence/intelligence.pipeline");
+async function runQualityIntelligence(input) {
+    const analysisResults = await (0, failure_analysis_pipeline_1.runFailureAnalysisFromPlaywright)(input);
+    const summary = (0, failure_grouping_pipeline_1.groupFailures)(analysisResults);
+    const enriched = await (0, intelligence_pipeline_1.enrichWithIntelligence)(summary);
+    return enriched;
+}

package/dist/src/runtime/networkCollector.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachNetworkCollector = attachNetworkCollector;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function attachNetworkCollector(page, testId) {
+    const failures = [];
+    page.on('response', response => {
+        if (response.status() >= 400) {
+            failures.push({
+                method: response.request().method(),
+                url: new URL(response.url()).pathname,
+                status: response.status()
+            });
+        }
+    });
+    page.on('requestfailed', request => {
+        failures.push({
+            method: request.method(),
+            url: new URL(request.url()).pathname,
+            error: request.failure()?.errorText
+        });
+    });
+    process.on('exit', () => {
+        if (failures.length === 0)
+            return;
+        const dir = path_1.default.join('test-results', testId);
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'network.json'), JSON.stringify(failures, null, 2));
+    });
+}

package/dist/src/stackParser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStackTrace = parseStackTrace;
+function parseStackTrace(stack) {
+    if (!stack || stack.length === 0) {
+        return { file: 'Unknown', line: -1 };
+    }
+    // Supports formats like: Class.method(File.java:87)
+    const match = stack[0].match(/\((.*):(\d+)\)/);
+    if (!match) {
+        return { file: 'Unknown', line: -1 };
+    }
+    return {
+        file: match[1],
+        line: Number(match[2])
+    };
+}

package/dist/src/test-run.js

@@ -0,0 +1,48 @@
+"use strict";
+// src/test-run.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const runner_1 = require("./runner");
+function line(char = "=", count = 60) {
+    console.log(char.repeat(count));
+}
+async function main() {
+    const playwrightResultsDir = "playwright-results";
+    const result = await (0, runner_1.runQualityIntelligence)(playwrightResultsDir);
+    line();
+    console.log("QUALITY INTELLIGENCE – FINAL OUTPUT");
+    line();
+    console.log(`Primary Failure   : ${result.dominantCategory}`);
+    console.log(`Confidence Score  : ${result.confidence}`);
+    console.log(`Flaky Failures    : ${result.flakyCount}`);
+    console.log(`Trend Signal      : ${result.trend?.signal ?? "N/A"}`);
+    line("-");
+    console.log("Failure Breakdown:");
+    for (const [k, v] of Object.entries(result.groupedCounts)) {
+        console.log(`  - ${k}: ${v}`);
+    }
+    line("-");
+    console.log("Confidence Diagnosis:");
+    for (const lineText of result.intelligence.confidence.explanation) {
+        console.log(`  • ${lineText}`);
+    }
+    line("-");
+    console.log("AI Explanation:");
+    console.log(`  Summary: ${result.intelligence.explanation.summary}`);
+    if (result.intelligence.explanation.reasoning?.length) {
+        console.log("  Reasoning:");
+        for (const r of result.intelligence.explanation.reasoning) {
+            console.log(`    - ${r}`);
+        }
+    }
+    if (result.intelligence.explanation.recommendedAction?.length) {
+        console.log("  Recommended Actions:");
+        for (const a of result.intelligence.explanation.recommendedAction) {
+            console.log(`    - ${a}`);
+        }
+    }
+    line();
+}
+main().catch(err => {
+    console.error("QUALITY INTELLIGENCE FAILED");
+    console.error(err);
+});

package/dist/src/types/analysis-result.js

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

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

@@ -0,0 +1,3 @@
+"use strict";
+// src/types/failure.types.ts
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/src/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// =====================
+// RAW INPUT TYPES
+// =====================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/artifact.locator.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locatePlaywrightArtifacts = locatePlaywrightArtifacts;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function locatePlaywrightArtifacts() {
+    const resultsDir = path_1.default.resolve('test-results');
+    const screenshots = [];
+    let trace;
+    if (!fs_1.default.existsSync(resultsDir)) {
+        return { screenshots, trace };
+    }
+    const runDirs = fs_1.default.readdirSync(resultsDir);
+    for (const dir of runDirs) {
+        const fullDir = path_1.default.join(resultsDir, dir);
+        if (!fs_1.default.statSync(fullDir).isDirectory())
+            continue;
+        const files = fs_1.default.readdirSync(fullDir);
+        for (const file of files) {
+            const fullPath = path_1.default.join(fullDir, file);
+            // 🎥 Trace ZIP (take the latest retry if exists)
+            if (file === 'trace.zip') {
+                trace = fullPath;
+            }
+            // 📸 Screenshots
+            if (file.endsWith('.png')) {
+                screenshots.push(fullPath);
+            }
+        }
+    }
+    return { trace, screenshots };
+}

package/dist/src/utils/confidence-constants.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Confidence Calculation Constants
+ *
+ * These constants define the base confidence levels and adjustments
+ * used throughout the quality intelligence engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAXONOMY_BASE_CONFIDENCE = exports.CONFIDENCE_THRESHOLDS = exports.CONFIDENCE_BOUNDS = exports.CONFIDENCE_ADJUSTMENTS = exports.BASE_CONFIDENCE = void 0;
+exports.clampConfidence = clampConfidence;
+exports.formatConfidence = formatConfidence;
+/**
+ * Base confidence levels for different error types
+ */
+exports.BASE_CONFIDENCE = {
+    /** Strong backend failure signal (5xx errors) */
+    BACKEND_SERVER_ERROR: 0.95,
+    /** Backend API failure (any API error) */
+    BACKEND_API_ERROR: 0.9,
+    /** Test or automation failure */
+    TEST_ERROR: 0.75,
+    /** Unknown or weak signal */
+    UNKNOWN: 0.6,
+};
+/**
+ * Confidence adjustments based on test context and signals
+ */
+exports.CONFIDENCE_ADJUSTMENTS = {
+    /** UI successfully rendered and reached assertion */
+    UI_RENDERED: 0.05,
+    /** Test involves authentication or login flow */
+    AUTH_FLOW_DETECTED: 0.05,
+    /** Explicit authentication failure detected */
+    EXPLICIT_AUTH_FAILURE: 0.1,
+    /** Test involves inventory or data operations */
+    DATA_OPERATION_DETECTED: 0.05,
+    /** Numeric mismatch detected in assertions */
+    NUMERIC_MISMATCH: 0.05,
+};
+/**
+ * Maximum and minimum confidence bounds
+ */
+exports.CONFIDENCE_BOUNDS = {
+    /** Maximum confidence score (never 100% certain) */
+    MAX: 0.95,
+    /** Minimum confidence score for reporting */
+    MIN: 0.5,
+};
+/**
+ * Confidence thresholds for decision making
+ */
+exports.CONFIDENCE_THRESHOLDS = {
+    /** Threshold for blocking CI/CD (high confidence failure) */
+    FAIL: 0.85,
+    /** Threshold for reporting pass risks */
+    PASS_RISK: 0.6,
+    /** Threshold for investigating (medium confidence) */
+    INVESTIGATE: 0.7,
+    /** Threshold for shipping (high confidence in safety) */
+    SHIP: 0.85,
+};
+/**
+ * Taxonomy rule base confidence levels
+ */
+exports.TAXONOMY_BASE_CONFIDENCE = {
+    /** Numeric data mismatch */
+    NUMERIC_MISMATCH: 0.6,
+    /** Authentication failure */
+    AUTH_FAILURE: 0.7,
+    /** UI visibility issue */
+    VISIBILITY: 0.7,
+    /** Network timeout */
+    TIMEOUT: 0.65,
+    /** Element not found */
+    ELEMENT_NOT_FOUND: 0.7,
+    /** Default fallback */
+    DEFAULT: 0.7,
+};
+/**
+ * Helper function to clamp confidence within bounds
+ */
+function clampConfidence(value) {
+    return Math.max(exports.CONFIDENCE_BOUNDS.MIN, Math.min(exports.CONFIDENCE_BOUNDS.MAX, value));
+}
+/**
+ * Helper function to format confidence as percentage string
+ */
+function formatConfidence(value) {
+    return `${(value * 100).toFixed(1)}%`;
+}