quality-intelligence-engine 2.2.17 → 2.2.22

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

@@ -0,0 +1,59 @@
+"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;
+        }
+    }
+    /* ===============================
+       🔒 FALLBACK ENFORCEMENT (CRITICAL)
+       =============================== */
+    if (results.length === 0) {
+        groupedCounts["UNCLASSIFIED_FAILURE"] = 1;
+        dominantCategory = "UNCLASSIFIED_FAILURE";
+        dominantCount = 1;
+    }
+    const total = Math.max(1, results.length || dominantCount);
+    let confidence = dominantCount / total;
+    // Ensure non-zero confidence for real failures
+    if (dominantCategory === "UNCLASSIFIED_FAILURE" && confidence <= 0) {
+        confidence = 0.25;
+    }
+    // 🔻 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/playwright/qi.reporter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const failure_tracker_1 = require("../intelligence/failure-fingerprinting/failure.tracker");
+class QIReporter {
+    onTestEnd(test, result) {
+        if (result.status !== "failed")
+            return;
+        const errorText = result.error?.message ||
+            result.error?.stack ||
+            "unknown error";
+        (0, failure_tracker_1.trackFailure)({
+            error: errorText,
+            testName: test.title
+        }, process.env.QI_RUN_ID ?? "local-run");
+    }
+}
+exports.default = QIReporter;

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

package/dist/src/utils/file-utils.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileOperationError = void 0;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.fileExists = fileExists;
+exports.ensureDirectory = ensureDirectory;
+exports.resolvePath = resolvePath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Custom error class for file operations
+ */
+class FileOperationError extends Error {
+    constructor(message, filePath, operation, originalError) {
+        super(message);
+        this.filePath = filePath;
+        this.operation = operation;
+        this.originalError = originalError;
+        this.name = 'FileOperationError';
+    }
+}
+exports.FileOperationError = FileOperationError;
+/**
+ * Safely read and parse a JSON file with proper error handling
+ * @param filePath - Absolute or relative path to the JSON file
+ * @returns Parsed JSON object
+ * @throws FileOperationError if file cannot be read or parsed
+ */
+function readJsonFile(filePath) {
+    try {
+        // Check if file exists
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new FileOperationError(`File not found: ${filePath}`, filePath, 'read');
+        }
+        // Read file content
+        let content;
+        try {
+            content = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            throw new FileOperationError(`Failed to read file: ${filePath}`, filePath, 'read', error);
+        }
+        // Parse JSON
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new FileOperationError(`Invalid JSON in file: ${filePath}`, filePath, 'parse', error);
+        }
+    }
+    catch (error) {
+        if (error instanceof FileOperationError) {
+            throw error;
+        }
+        throw new FileOperationError(`Unexpected error reading ${filePath}: ${error.message}`, filePath, 'read', error);
+    }
+}
+/**
+ * Safely write JSON to a file with proper error handling
+ * @param filePath - Absolute or relative path to the JSON file
+ * @param data - Data to write (will be JSON.stringified)
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ */
+function writeJsonFile(filePath, data, pretty = true) {
+    try {
+        // Ensure directory exists
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Stringify data
+        const content = pretty
+            ? JSON.stringify(data, null, 2)
+            : JSON.stringify(data);
+        // Write to file
+        try {
+            fs_1.default.writeFileSync(filePath, content, 'utf-8');
+        }
+        catch (error) {
+            throw new FileOperationError(`Failed to write file: ${filePath}`, filePath, 'write', error);
+        }
+    }
+    catch (error) {
+        if (error instanceof FileOperationError) {
+            throw error;
+        }
+        throw new FileOperationError(`Unexpected error writing ${filePath}: ${error.message}`, filePath, 'write', error);
+    }
+}
+/**
+ * Check if a file exists
+ * @param filePath - Path to check
+ * @returns true if file exists
+ */
+function fileExists(filePath) {
+    return fs_1.default.existsSync(filePath);
+}
+/**
+ * Ensure a directory exists, creating it if necessary
+ * @param dirPath - Directory path to ensure
+ */
+function ensureDirectory(dirPath) {
+    if (!fs_1.default.existsSync(dirPath)) {
+        fs_1.default.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Resolve a path relative to the project root
+ * @param relativePath - Path relative to project root
+ * @returns Absolute path
+ */
+function resolvePath(...segments) {
+    return path_1.default.join(process.cwd(), ...segments);
+}

package/dist/src/v2/llm/llm-advisor.js

@@ -0,0 +1,17 @@
+"use strict";
+// src/v2/llm/llm-advisor.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLLMAdvice = getLLMAdvice;
+/**
+ * Stub for ChatGPT / Azure / Local LLM
+ */
+async function getLLMAdvice(failureSummary) {
+    return {
+        summary: `AI analysis of failure: ${failureSummary}`,
+        fixRecommendation: [
+            "Check backend API response",
+            "Validate UI rendering timing",
+            "Review recent code changes"
+        ]
+    };
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+// src/v2/pipeline/v2-intelligence.pipeline.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runV2Intelligence = runV2Intelligence;
+const trace_analyzer_1 = require("../trace-intelligence/trace-analyzer");
+const self_healer_1 = require("../self-healing/self-healer");
+const llm_advisor_1 = require("../llm/llm-advisor");
+async function runV2Intelligence(failureFolder, failureType, errorMessage) {
+    const trace = (0, trace_analyzer_1.analyzeTrace)(failureFolder);
+    const healing = (0, self_healer_1.attemptSelfHeal)(failureType, errorMessage);
+    const llm = await (0, llm_advisor_1.getLLMAdvice)(failureType);
+    return {
+        trace,
+        healing,
+        llm
+    };
+}

package/dist/src/v2/self-healing/self-healer.js

@@ -0,0 +1,44 @@
+"use strict";
+// src/v2/self-healing/self-healer.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attemptSelfHeal = attemptSelfHeal;
+/**
+ * Self-Healing Decision Engine (V2)
+ * Decides WHAT can be auto-fixed and WHAT should not
+ */
+function attemptSelfHeal(failureType, errorMessage) {
+    const msg = errorMessage.toLowerCase();
+    // 🔁 Flaky tests
+    if (failureType === "FLAKY") {
+        return {
+            reason: "Intermittent retry-based failure detected",
+            suggestedFix: "Add proper waits or retry assertions",
+            confidence: 0.6
+        };
+    }
+    // 🧭 UI / Locator issues
+    if (failureType === "UI_STATE" || failureType === "LOCATOR_CHANGED") {
+        return {
+            reason: "UI element state or locator changed",
+            suggestedFix: "Re-locate element using role/text-based selectors",
+            confidence: 0.7
+        };
+    }
+    // 🔢 Numeric mismatch — CONDITIONAL healing
+    if (failureType === "NUMERIC_MISMATCH") {
+        // UI-level numeric problems (healable)
+        if (msg.includes("count") ||
+            msg.includes("items") ||
+            msg.includes("length") ||
+            msg.includes("round")) {
+            return {
+                reason: "UI count or rounding issue detected",
+                suggestedFix: "Update assertion logic or normalize UI values",
+                confidence: 0.55
+            };
+        }
+        // Backend/API numeric issues (DO NOT HEAL)
+        return null;
+    }
+    return null;
+}

package/dist/src/v2/trace-intelligence/trace-analyzer.js

@@ -0,0 +1,33 @@
+"use strict";
+// src/v2/trace-intelligence/trace-analyzer.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTrace = analyzeTrace;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function analyzeTrace(failureFolder) {
+    const fullPath = path_1.default.resolve(failureFolder);
+    if (!fs_1.default.existsSync(fullPath)) {
+        return {
+            page: "UNKNOWN",
+            failureStep: "Trace folder not found",
+            screenshots: [],
+            note: `Missing folder: ${failureFolder}`
+        };
+    }
+    const files = fs_1.default.readdirSync(fullPath);
+    const screenshots = files
+        .filter(f => f.endsWith(".png") || f.endsWith(".jpg"))
+        .map(f => path_1.default.join(fullPath, f));
+    const traceFile = files.includes("trace.zip")
+        ? path_1.default.join(fullPath, "trace.zip")
+        : undefined;
+    return {
+        page: "UNKNOWN_PAGE",
+        failureStep: "Action before failure",
+        screenshots,
+        traceFile
+    };
+}