deflake 1.2.9 → 1.2.13

package/cli.js

@@ -427,99 +427,77 @@ function extractFailureLocation(logText) {
 // --- COLORS Moved to top ---
 
 function printDetailedFix(fixText, location, sourceCode = null, isApplied = false) {
-
-    let fixCode = fixText;
+    let patches = [];
     let explanation = null;
 
     try {
-        const parsed = JSON.parse(fixText);
-        if (parsed.code) {
-            fixCode = parsed.code;
-            explanation = parsed.reason;
+        // Strip markdown if present
+        const cleaned = fixText.replace(/```json\n?/, '').replace(/```/, '').trim();
+        const parsed = JSON.parse(cleaned);
+        explanation = parsed.explanation || parsed.reason;
+        if (parsed.patches && Array.isArray(parsed.patches)) {
+            patches = parsed.patches;
+        } else if (parsed.code) {
+            patches = [{
+                file: location ? (location.specFile || location.rootFile) : 'unknown',
+                line: location ? (location.testLine || location.rootLine) : 0,
+                action: 'REPLACE',
+                new_line: parsed.code
+            }];
+        }
+    } catch (e) {
+        // If it looks like JSON but couldn't be parsed, try harder or fallback
+        if (fixText.trim().startsWith('{')) {
+             try {
+                 const match = fixText.match(/\{[\s\S]*\}/);
+                 if (match) {
+                     const parsed = JSON.parse(match[0]);
+                     explanation = parsed.explanation || parsed.reason;
+                     patches = parsed.patches || (parsed.code ? [{ file: 'target', line: 0, action: 'REPLACE', new_line: parsed.code }] : []);
+                 }
+             } catch (e2) {}
         }
-    } catch (e) { }
+
+        if (patches.length === 0) {
+            patches = [{
+                file: location ? (location.specFile || location.rootFile) : 'unknown',
+                line: location ? (location.testLine || location.rootLine) : 0,
+                action: 'REPLACE',
+                new_line: fixText
+            }];
+        }
+    }
 
     console.log("\n" + C.GRAY + "─".repeat(50) + C.RESET);
 
     if (isApplied) {
-        // --- APPLIED VIEW ---
         console.log(`${C.GREEN}${C.BRIGHT}✅ FIX APPLIED:${C.RESET}`);
         if (location) {
-            // Label is default color, Value is colored
             const fileLabel = location.specFile || location.rootFile;
             let lineLabel = location.testLine || location.rootLine;
-
             if (fileLabel) {
                 console.log(`${C.BRIGHT}📄 File:${C.RESET}   ${fileLabel}:${lineLabel}`);
             }
         }
 
-        if (explanation) { // Highlight the reason as requested by user
+        if (explanation) {
             console.log(`\n${C.BRIGHT}ℹ️  Reason:${C.RESET}  ${explanation}`);
         }
 
-        console.log(C.GRAY + "─".repeat(20) + C.RESET);
-
-        // --- OLD CODE (Context) ---
-        if (sourceCode && location && location.rootLine) {
-            console.log(`${C.RED}🔴 OLD:${C.RESET}`);
-            try {
-                const lines = sourceCode.split('\n');
-                const centerIdx = parseInt(location.rootLine) - 1;
-                // Show a small window around the error
-                const start = Math.max(0, centerIdx - 2);
-                const end = Math.min(lines.length - 1, centerIdx + 2);
-
-                for (let i = start; i <= end; i++) {
-                    let prefix = (i === centerIdx) ? "> " : "  ";
-                    let line = lines[i];
-                    if (i === centerIdx) line = `${C.RED}${line}${C.RESET}`;
-                    else line = `${C.GRAY}${line}${C.RESET}`;
-                    console.log(prefix + line);
-                }
-            } catch (e) { }
+        for (const patch of patches) {
+            console.log(C.GRAY + "─".repeat(20) + C.RESET);
+            console.log(`${C.BRIGHT}📄 File:${C.RESET}   ${path.basename(patch.file)}:${patch.line} [${patch.action}]`);
+            console.log(`\n${C.GREEN}${C.BRIGHT}🟢 NEW:${C.RESET}\n  ${C.GREEN}${patch.new_line.trim()}${C.RESET}`);
         }
-
-        // --- NEW CODE ---
-        console.log(`\n${C.GREEN}🟢 NEW:${C.RESET}`);
-        fixCode.split('\n').forEach(line => {
-            let colored = line
-                .replace(/(\/\/.*)/g, `${C.GRAY}$1${C.RESET}`)
-                .replace(/\b(const|let|var|await|async|function|return)\b/g, `${C.YELLOW}$1${C.RESET}`)
-                .replace(/('.*?')|(".*?")|(`.*?`)/g, `${C.GREEN}$1${C.RESET}`)
-                .replace(/(\.click|\.fill|\.locator)/g, `${C.CYAN}$1${C.RESET}`);
-            console.log("  " + colored);
-        });
-
     } else {
-        // --- SUGGESTION VIEW (Default) ---
-        if (location) {
-            if (location.rootFile && location.rootLine) {
-                console.log(`💥 Runtime Error:  ${C.RED}${location.rootFile}:${location.rootLine}${C.RESET}`);
-            }
-            if (location.specFile) {
-                let targetLabel = location.specFile;
-                if (location.testLine) targetLabel += `:${location.testLine}`;
-                console.log(`🎯 Fix Target:    ${C.CYAN}${targetLabel} (Definition)${C.RESET}`);
-            }
+        console.log(`${C.CYAN}${C.BRIGHT}💡 SUGGESTED FIX:${C.RESET}`);
+        if (explanation) {
+            console.log(`\n${C.BRIGHT}ℹ️  Reason:${C.RESET}  ${explanation}`);
+        }
+        for (const patch of patches) {
+            console.log(`   - ${C.CYAN}${path.basename(patch.file)}:${patch.line}${C.RESET}: ${patch.new_line.trim()}`);
         }
-        console.log(C.GRAY + "─".repeat(50) + C.RESET);
-
-        console.log(`${C.GREEN}${C.BRIGHT}✨ DEFLAKE SUGGESTION:${C.RESET}`);
-        if (explanation) console.log(`${C.GRAY}// ${explanation}${C.RESET}`);
-
-        // Print code with simple coloring
-        fixCode.split('\n').forEach(line => {
-            let colored = line
-                .replace(/(\/\/.*)/g, `${C.GRAY}$1${C.RESET}`)
-                .replace(/\b(const|let|var|await|async|function|return)\b/g, `${C.YELLOW}$1${C.RESET}`)
-                .replace(/('.*?')|(".*?")|(`.*?`)/g, `${C.GREEN}$1${C.RESET}`)
-                .replace(/(\.click|\.fill|\.locator)/g, `${C.CYAN}$1${C.RESET}`);
-            console.log("  " + colored);
-        });
     }
-
-    console.log(C.GRAY + "─".repeat(50) + C.RESET);
 }
 
 /**
@@ -715,7 +693,6 @@ async function runDoctor(argv) {
 }
 
 async function applySelfHealing(result) {
-
     if (!result.location || !result.location.fullRootPath || !result.fix) return;
 
     try {
@@ -727,30 +704,97 @@ async function applySelfHealing(result) {
             return;
         }
 
-        let fixCode = result.fix;
+        let patches = [];
         try {
             const parsed = JSON.parse(result.fix);
-            if (parsed.code) fixCode = parsed.code;
-        } catch (e) { }
+            if (parsed.patches && Array.isArray(parsed.patches)) {
+                patches = parsed.patches;
+            } else if (parsed.code) {
+                patches = [{
+                    file: filePath,
+                    line: targetLine,
+                    action: 'REPLACE',
+                    new_line: parsed.code
+                }];
+            }
+        } catch (e) {
+            // Fallback for raw string fixes
+            patches = [{
+                file: filePath,
+                line: targetLine,
+                action: 'REPLACE',
+                new_line: result.fix
+            }];
+        }
+
+        const backups = new Map();
+        
+        try {
+            for (const patch of patches) {
+                const pFile = patch.file || filePath;
+                const pLine = parseInt(patch.line || targetLine);
+                const pAction = patch.action || 'REPLACE';
+                let pNew = patch.new_line;
 
-        const lines = fs.readFileSync(filePath, 'utf8').split('\n');
-        const originalLineIndex = targetLine - 1;
+                if (!fs.existsSync(pFile)) continue;
 
-        if (originalLineIndex < 0 || originalLineIndex >= lines.length) {
-            console.error(`  ❌ [Self-Healing] Line ${targetLine} out of bounds in ${filePath}`);
-            return;
-        }
+                // Create backup if not already done
+                if (!backups.has(pFile)) {
+                    backups.set(pFile, fs.readFileSync(pFile, 'utf8'));
+                }
+
+                const currentLines = fs.readFileSync(pFile, 'utf8').split('\n');
+                const originalLineIndex = pLine - 1;
+
+                if (originalLineIndex < 0 || originalLineIndex >= currentLines.length) continue;
+
+                const originalLine = currentLines[originalLineIndex];
+                const indentation = originalLine.match(/^\s*/)[0];
+                
+                // CRITICAL: Prevent injecting JSON metadata into the code
+                if (pNew.trim().startsWith('{') && pNew.includes('"patches"') && pNew.includes(':')) {
+                    console.log(`  ❌ ${C.RED}[Self-Healing] Detected attempted JSON injection. Aborting patch for ${path.basename(pFile)}.${C.RESET}`);
+                    continue;
+                }
 
-        // Apply fix: Replace the entire line or the specific locator
-        // For robustness, we replace the whole line but keep indentation
-        const originalLine = lines[originalLineIndex];
-        const indentation = originalLine.match(/^\s*/)[0];
-        lines[originalLineIndex] = indentation + fixCode.trim();
+                const finalNewLine = indentation + pNew.trim();
 
-        fs.writeFileSync(filePath, lines.join('\n'));
-        console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully patched:${C.RESET} ${path.basename(filePath)}:${targetLine}`);
+                // DUPLICATE PROTECTION: Don't insert/replace if code already exists
+                if (currentLines.some(l => l.trim() === pNew.trim())) {
+                    console.log(`  ℹ️  ${C.GRAY}[Self-Healing] Skipping duplicate patch for:${C.RESET} ${path.basename(pFile)}`);
+                    continue;
+                }
+
+                if (pAction === 'INSERT_AFTER') {
+                    currentLines.splice(pLine, 0, finalNewLine);
+                    fs.writeFileSync(pFile, currentLines.join('\n'));
+                    console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully inserted at:${C.RESET} ${path.basename(pFile)}:${pLine}`);
+                } else {
+                    currentLines[originalLineIndex] = finalNewLine;
+                    fs.writeFileSync(pFile, currentLines.join('\n'));
+                    console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully patched:${C.RESET} ${path.basename(pFile)}:${pLine}`);
+                }
+
+                // SYNTAX VALIDATION: Rollback if syntax is broken
+                if (pFile.endsWith('.ts') || pFile.endsWith('.js')) {
+                    try {
+                        const { execSync } = require('child_process');
+                        execSync(`node --check "${pFile}"`, { stdio: 'ignore' });
+                    } catch (err) {
+                        console.log(`  ⚠️  ${C.YELLOW}[Self-Healing] Patch broke syntax in ${path.basename(pFile)}. Rolling back...${C.RESET}`);
+                        fs.writeFileSync(pFile, backups.get(pFile));
+                    }
+                }
+            }
+        } catch (patchError) {
+             console.error(`  ❌ ${C.RED}[Self-Healing] Error applying patches: ${patchError.message}${C.RESET}`);
+             // Emergency rollback for all involved files
+             for (const [file, content] of backups) {
+                 fs.writeFileSync(file, content);
+             }
+        }
     } catch (error) {
-        console.error(`  ❌ ${C.RED}[Self-Healing] Error patching file:${C.RESET} ${error.message}`);
+        console.error(`  ❌ ${C.RED}[Self-Healing] Error in self-healing logic:${C.RESET} ${error.message}`);
     }
 }
 
@@ -981,6 +1025,7 @@ async function runCommand(cmd, args) {
 
 async function main() {
     const command = argv._ || [];
+    let finalExitCode = 0;
 
     // If 'doctor' or 'migrate' was called, don't proceed to wrapper logic
     if (command.includes('doctor') || command.includes('migrate')) return;
@@ -1001,20 +1046,22 @@ async function main() {
             const artifacts = detectAllArtifacts(null, argv.html);
             const fixesApplied = await analyzeFailures(artifacts, output, client);
 
+            let outcomeCode = code;
             // AUTO-VERIFICATION
             if (fixesApplied > 0 && argv.fix) {
                 console.log(`\n${C.BRIGHT}💉 Fixes applied. Re-running tests to verify...${C.RESET}`);
                 const secondRun = await runCommand(cmd, args);
+                outcomeCode = secondRun.code;
                 if (secondRun.code === 0) {
                     console.log(`\n${C.GREEN}${C.BRIGHT}✅ All tests passed after DeFlake healing!${C.RESET}`);
                 } else {
                     console.log(`\n${C.YELLOW}⚠️  Some tests still failing after fixes. Check the report for details.${C.RESET}`);
                 }
             }
-            process.exit(code);
+            finalExitCode = outcomeCode;
         } else {
             console.log("\n🟢 Command passed successfully.");
-            process.exit(0);
+            finalExitCode = 0;
         }
     } else {
         const artifacts = detectAllArtifacts(argv.log, argv.html);
@@ -1023,10 +1070,11 @@ async function main() {
     }
 
     // FINAL REPORT TRIGGER
-    // We wait until the very end so verification runs (if any) are reflected
     if (argv.report) {
         showFrameworkReport();
     }
+
+    process.exit(finalExitCode);
 }
 
 // main() call is now handled by the check above

package/package.json

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