deflake 1.2.33 → 1.2.35

package/cli.js

@@ -238,6 +238,18 @@ async function applyFix(res, loc) {
                     continue;
                 }
                 if (p.action === 'INSERT_AFTER') {
+                    // SAFETY: Detect if we'd insert at class scope (outside any method)
+                    // Pattern: line is '}' (end of constructor/method) and next non-blank line starts a new method
+                    const targetLine = lines[idx].trim();
+                    const nextMeaningful = lines.slice(p.line).find(l => l.trim() !== '');
+                    const isClassScope = targetLine === '}' && nextMeaningful && 
+                        /^\s*(async\s+)?\w+\s*\(|^\s*(private|public|protected|static|readonly|get |set )|^\s*}/.test(nextMeaningful);
+                    
+                    if (isClassScope && /await |return |const |let |var /.test(p.new_line)) {
+                        console.log(`   ${C.YELLOW}⏭️  Blocked: would insert executable code at class scope (after ${targetLine})${C.RESET}`);
+                        continue;
+                    }
+                    
                     lines.splice(p.line, 0, cleanLine);
                     console.log(`   ${C.GREEN}+  Line ${p.line + 1}: ${cleanLine.trim()}${C.RESET}`);
                 } else {
@@ -294,36 +306,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.33",
+  "version": "1.2.35",
   "description": "AI-powered self-healing tool for Playwright, Cypress, and WebdriverIO tests.",
   "main": "client.js",
   "bin": {