quality-intelligence-engine 2.2.0

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

@@ -0,0 +1,121 @@
+"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 {
+    filePath;
+    operation;
+    originalError;
+    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
+    };
+}

package/dist/src/v2-test-run.js

@@ -0,0 +1,59 @@
+"use strict";
+// src/v2-test-run.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const v2_intelligence_pipeline_1 = require("./v2/pipeline/v2-intelligence.pipeline");
+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;
+}
+async function run() {
+    const failureFolder = pickOneFailureFolder();
+    if (!failureFolder) {
+        console.error("No Playwright failure folders found.");
+        return;
+    }
+    const result = await (0, v2_intelligence_pipeline_1.runV2Intelligence)(failureFolder, "NUMERIC_MISMATCH", "Expected 10, received 6");
+    console.log("==================================================");
+    console.log("V2 TRACE INTELLIGENCE OUTPUT");
+    console.log("==================================================");
+    console.log(`Failure Folder : ${failureFolder}`);
+    console.log(`Failure Type   : NUMERIC_MISMATCH`);
+    console.log("\nEvidence:");
+    if (result.trace.screenshots.length > 0) {
+        console.log("  Screenshots:");
+        result.trace.screenshots.forEach(s => console.log(`    - ${s}`));
+    }
+    else {
+        console.log("  Screenshots: none");
+    }
+    if (result.trace.traceFile) {
+        console.log(`  Trace File  : ${result.trace.traceFile}`);
+        console.log(`  Open with   : npx playwright show-trace ${result.trace.traceFile}`);
+    }
+    else {
+        console.log("  Trace File  : none");
+    }
+    console.log("\nSelf-Healing:");
+    if (result.healing) {
+        console.log(`  Reason       : ${result.healing.reason}`);
+        console.log(`  SuggestedFix : ${result.healing.suggestedFix}`);
+        console.log(`  Confidence   : ${result.healing.confidence}`);
+    }
+    else {
+        console.log("  Not safe to auto-heal");
+    }
+    console.log("\nAI Advice:");
+    console.log(`  Summary: ${result.llm.summary}`);
+    result.llm.fixRecommendation.forEach(r => console.log(`    - ${r}`));
+    console.log("==================================================");
+}
+run();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "quality-intelligence-engine",
+  "version": "2.2.0",
+  "description": "AI-powered failure intelligence for Playwright test runs",
+  "bin": {
+    "qi": "dist/bin/qi.js"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}