deflake 1.2.32 → 1.2.34

package/cli.js

@@ -117,7 +117,7 @@ async function analyzeAndFix(artifacts, client, argv, capturedOutput = '') {
     }
     
     // Strip ANSI escape codes from captured output — they break regex matching
-    const cleanOutput = capturedOutput.replace(/\x1b\[[0-9;]*m/g, '');
+    const cleanOutput = capturedOutput.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
     
     console.log(`${C.BRIGHT}🔍 Analyzing ${artifacts.length} failure(s)...${C.RESET}\n`);
     let count = 0;
@@ -261,13 +261,9 @@ async function applyFix(res, loc) {
 }
 
 function extractRelevantOutput(fullOutput, artifactName) {
-    // SMART: Use Playwright's "Error Context:" line to find the EXACT error block for this artifact.
-    // Each Playwright failure ends with: "Error Context: test-results/<artifact-name>/error-context.md"
-    // We find that line, then walk backwards to capture the full error + stack trace.
-    
+    // Find the Error Context line for this artifact, then grab 30 lines before it
     const lines = fullOutput.split('\n');
     
-    // Find the Error Context line that matches this artifact
     let anchorIdx = -1;
     for (let i = 0; i < lines.length; i++) {
         if (lines[i].includes('Error Context:') && lines[i].includes(artifactName)) {
@@ -277,7 +273,7 @@ function extractRelevantOutput(fullOutput, artifactName) {
     }
     
     if (anchorIdx === -1) {
-        // Fallback: try partial match on artifact name parts
+        // Fallback: partial match on artifact name parts
         const nameParts = artifactName.split('-').filter(p => p.length > 3);
         for (let i = 0; i < lines.length; i++) {
             if (lines[i].includes('Error Context:') && nameParts.some(part => lines[i].includes(part))) {
@@ -289,16 +285,8 @@ function extractRelevantOutput(fullOutput, artifactName) {
     
     if (anchorIdx === -1) return '';
     
-    // Walk backwards from anchor to find the start of this error block
-    // Error blocks in Playwright start with "N) [chromium] › tests/..."
-    let startIdx = anchorIdx;
-    for (let i = anchorIdx; i >= 0; i--) {
-        if (lines[i].match(/^\s*\d+\)\s+\[/)) {
-            startIdx = i;
-            break;
-        }
-    }
-    
+    // Grab 30 lines before the anchor — guaranteed to include the full stack trace
+    const startIdx = Math.max(0, anchorIdx - 30);
     return lines.slice(startIdx, anchorIdx + 1).join('\n');
 }
 
@@ -306,36 +294,35 @@ function extractLoc(text) {
     if (!text) return null;
     
     // === MULTI-FRAMEWORK LOCATION EXTRACTION ===
-    // Supports: Playwright, Cypress, WebdriverIO, Jest, Mocha
-    
-    // Strategy 1: Absolute path inside parentheses (most precise)
-    // Format: at FunctionName (/absolute/path/file.ts:75:35)
-    let m = text.match(/\(([^()]*?[\\/][^()]+\.(?:ts|js|tsx|jsx|mjs|cjs)):(\d+)(?::(\d+))?\)/);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
+    // Returns the LAST match (closest to the Error Context anchor)
+    // to avoid picking up stack traces from previous error blocks.
     
-    // Strategy 2: Absolute path after "at" keyword (no parens)
-    // Format: at /absolute/path/file.ts:75:35
-    m = text.match(/at\s+(\/[^\s]+\.(?:ts|js|tsx|jsx)):(\d+)(?::(\d+))?/);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
-    
-    // Strategy 3: Relative path after "at" keyword
-    // Format: at ../pages/file.ts:75
-    m = text.match(/at\s+(\.\.?\/[^\s]+\.(?:ts|js|tsx|jsx)):(\d+)(?::(\d+))?/);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
+    const patterns = [
+        // Strategy 1: Absolute path in parens — at Func (/path/file.ts:75:35)
+        /\(([^()]*?[\\/][^()]+\.(?:ts|js|tsx|jsx|mjs|cjs)):(\d+)(?::(\d+))?\)/g,
+        // Strategy 2: Absolute path — at /path/file.ts:75:35
+        /at\s+(\/[^\s]+\.(?:ts|js|tsx|jsx)):(\d+)(?::(\d+))?/g,
+        // Strategy 3: Relative path — at ../pages/file.ts:75
+        /at\s+(\.\.?\/[^\s]+\.(?:ts|js|tsx|jsx)):(\d+)(?::(\d+))?/g,
+    ];
     
-    // Strategy 4: Playwright "at file:line" in stack (single line match)
-    m = text.match(/^\s+at\s+(.*?\.(?:ts|js)):(\d+)$/m);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
-
-    // Strategy 5: Cypress — at Context.<anonymous> (path)
-    m = text.match(/Context\.<anonymous>\s*\(([^)]+\.(?:ts|js|cy\.ts|cy\.js)):(\d+):(\d+)\)/);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
+    let lastMatch = null;
+    for (const pattern of patterns) {
+        let m;
+        while ((m = pattern.exec(text)) !== null) {
+            lastMatch = { path: path.resolve(m[1]), line: parseInt(m[2]) };
+        }
+        if (lastMatch) return lastMatch;
+    }
     
-    // Strategy 6: Generic — any path-like string with /dir/file.ts:line
-    m = text.match(/((?:[\w@.-]+\/)+[\w.-]+\.(?:ts|js|tsx|jsx)):(\d+)/);
-    if (m) return { path: path.resolve(m[1]), line: parseInt(m[2]) };
+    // Strategy 4: Generic — any path-like /dir/file.ts:line
+    const generic = /((?:[\w@.-]+\/)+[\w.-]+\.(?:ts|js|tsx|jsx)):(\d+)/g;
+    let m;
+    while ((m = generic.exec(text)) !== null) {
+        lastMatch = { path: path.resolve(m[1]), line: parseInt(m[2]) };
+    }
     
-    return null;
+    return lastMatch;
 }
 
 async function runDoctor() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deflake",
-  "version": "1.2.32",
+  "version": "1.2.34",
   "description": "AI-powered self-healing tool for Playwright, Cypress, and WebdriverIO tests.",
   "main": "client.js",
   "bin": {