deflake 1.2.28 → 1.2.30

package/cli.js

@@ -46,11 +46,11 @@ async function main() {
     console.log(`🔍 Detected Framework: ${C.GREEN}${fw.toUpperCase()}${C.RESET}`);
 
     if (commandToRun) {
-        const { code } = await runNative(commandToRun);
+        const { code, output } = await runNative(commandToRun);
         if (code !== 0) {
             console.log(`\n🔴 Command failed with code ${code}. Activating DeFlake...`);
             const artifacts = detectFailures();
-            const applied = await analyzeAndFix(artifacts, client, argv);
+            const applied = await analyzeAndFix(artifacts, client, argv, output);
             if (applied > 0 && argv.fix) {
                 console.log(`\n${C.BRIGHT}💉 Fixes applied. Re-running tests to verify...${C.RESET}`);
                 await runNative(commandToRun);
@@ -63,12 +63,23 @@ async function main() {
 async function runNative(fullCommand) {
     return new Promise((resolve) => {
         console.log(`🚀 Running command: ${C.CYAN}${fullCommand}${C.RESET}`);
+        let capturedOutput = '';
         const child = spawn(fullCommand, {
             shell: true,
-            stdio: 'inherit',
+            stdio: ['inherit', 'pipe', 'pipe'],
             env: { ...process.env, PLAYWRIGHT_HTML_OPEN: 'never' }
         });
-        child.on('close', (code) => resolve({ code }));
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            process.stdout.write(text);
+            capturedOutput += text;
+        });
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            process.stderr.write(text);
+            capturedOutput += text;
+        });
+        child.on('close', (code) => resolve({ code, output: capturedOutput }));
     });
 }
 
@@ -99,7 +110,7 @@ function detectFailures() {
     return results;
 }
 
-async function analyzeAndFix(artifacts, client, argv) {
+async function analyzeAndFix(artifacts, client, argv, capturedOutput = '') {
     if (artifacts.length === 0) {
         console.log(`  ${C.YELLOW}⚠️  No failure artifacts detected. Run 'npx deflake doctor' to check permissions.${C.RESET}`);
         return 0;
@@ -111,20 +122,30 @@ async function analyzeAndFix(artifacts, client, argv) {
         console.log(`${C.CYAN}━━━ [${i+1}/${artifacts.length}] ${art.name} ━━━${C.RESET}`);
         try {
             const content = fs.readFileSync(art.htmlPath, 'utf8');
-            const loc = extractLoc(content);
+            
+            // SMART Location Extraction: try multiple sources
+            let loc = extractLoc(content);
+            let locSource = 'error-context.md';
+            
+            if (!loc && capturedOutput) {
+                // Extract the relevant section from captured output for this artifact
+                const relevantOutput = extractRelevantOutput(capturedOutput, art.name);
+                loc = extractLoc(relevantOutput || capturedOutput);
+                locSource = 'console output';
+            }
             
             // Step 1: Location extraction
             if (loc) {
-                console.log(`   ${C.GRAY}📍 Location:${C.RESET} ${path.basename(loc.path)}:${loc.line}`);
+                console.log(`   ${C.GRAY}📍 Location:${C.RESET} ${path.basename(loc.path)}:${loc.line} ${C.GRAY}(from ${locSource})${C.RESET}`);
             } else {
-                console.log(`   ${C.YELLOW}📍 Location: Could not extract (regex mismatch)${C.RESET}`);
+                console.log(`   ${C.YELLOW}📍 Location: Could not extract from any source${C.RESET}`);
             }
             
             // Step 2: Source code reading
             const source = loc && fs.existsSync(loc.path) ? fs.readFileSync(loc.path, 'utf8') : null;
             console.log(`   ${C.GRAY}📄 Source:${C.RESET} ${source ? 'Loaded (' + source.split('\n').length + ' lines)' : C.YELLOW + 'Not available' + C.RESET}`);
             
-            // Step 3: API call
+            // Step 3: API call — send BOTH error-context AND console output for richer diagnosis
             console.log(`   ${C.GRAY}🌐 Calling DeFlake API...${C.RESET}`);
             const res = await client.heal(null, art.htmlPath, loc, source, argv.fix);
             
@@ -141,12 +162,25 @@ async function analyzeAndFix(artifacts, client, argv) {
                             console.log(`      ${C.GRAY}→ ${p.action} at line ${p.line}: ${p.new_line?.substring(0, 70)}${C.RESET}`);
                         }
                         if (argv.fix) {
-                            console.log(`   ${C.BRIGHT}💉 Applying patches...${C.RESET}`);
-                            if (await applyFix(res, loc)) {
-                               count++;
-                               console.log(`   ${C.GREEN}${C.BRIGHT}✅ Fix applied to ${path.basename(loc.path)}:${loc.line}${C.RESET}`);
+                            // Use loc from patches if our extraction failed
+                            let fixLoc = loc;
+                            if (!fixLoc && parsed.patches[0]?.file) {
+                                const patchFile = path.resolve(parsed.patches[0].file);
+                                if (fs.existsSync(patchFile)) {
+                                    fixLoc = { path: patchFile, line: parsed.patches[0].line };
+                                    console.log(`   ${C.GRAY}📍 Using patch target:${C.RESET} ${path.basename(patchFile)}`);
+                                }
+                            }
+                            if (fixLoc) {
+                                console.log(`   ${C.BRIGHT}💉 Applying patches...${C.RESET}`);
+                                if (await applyFix(res, fixLoc)) {
+                                   count++;
+                                   console.log(`   ${C.GREEN}${C.BRIGHT}✅ Fix applied to ${path.basename(fixLoc.path)}:${fixLoc.line}${C.RESET}`);
+                                } else {
+                                   console.log(`   ${C.YELLOW}⚠️  Patches could not be applied (see details above)${C.RESET}`);
+                                }
                             } else {
-                               console.log(`   ${C.YELLOW}⚠️  Patches could not be applied (see details above)${C.RESET}`);
+                                console.log(`   ${C.YELLOW}⚠️  Cannot apply: no target file detected${C.RESET}`);
                             }
                         } else {
                             console.log(`   ${C.YELLOW}ℹ️  Use --fix flag to auto-apply these patches${C.RESET}`);
@@ -221,17 +255,79 @@ 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.
+    
+    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)) {
+            anchorIdx = i;
+            break;
+        }
+    }
+    
+    if (anchorIdx === -1) {
+        // Fallback: try 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))) {
+                anchorIdx = i;
+                break;
+            }
+        }
+    }
+    
+    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;
+        }
+    }
+    
+    return lines.slice(startIdx, anchorIdx + 1).join('\n');
+}
+
 function extractLoc(text) {
-    // Strategy 1: Absolute path inside parentheses — at Function (/absolute/path/file.ts:75:35)
-    let m = text.match(/\(([^()]+\.(?:ts|js)):(\d+)(?::(\d+))?\)/);
+    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]) };
+    
+    // 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 2: Absolute or relative path after "at" — at /path/file.ts:75:35 or at ../pages/file.ts:75
-    m = text.match(/at\s+([^\s(]+\.(?:ts|js)):(\d+)(?::(\d+))?/);
+    // 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]) };
+    
+    // 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]) };
     
-    // Strategy 3: Any path ending in .ts/.js with a line number (broadest match)
-    m = text.match(/([\w.\/\\-]+\.(?:ts|js)):(\d+)(?::(\d+))?/);
+    // 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]) };
     
     return null;

package/package.json

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