deflake 1.2.36 → 1.2.38

package/cli.js

@@ -46,15 +46,63 @@ async function main() {
     console.log(`🔍 Detected Framework: ${C.GREEN}${fw.toUpperCase()}${C.RESET}`);
 
     if (commandToRun) {
-        const { code, output } = await runNative(commandToRun);
-        if (code !== 0) {
+        const MAX_ATTEMPTS = 5;
+        let { code, output } = await runNative(commandToRun);
+        
+        if (code !== 0 && argv.fix) {
             console.log(`\n🔴 Command failed with code ${code}. Activating DeFlake...`);
-            const artifacts = detectFailures();
-            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);
+            
+            // Save backups of all source files before any modifications
+            const backups = new Map(); // path -> original content
+            let prevFailCount = Infinity;
+            
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                console.log(`\n${C.BRIGHT}${C.CYAN}🔄 Fix attempt ${attempt}/${MAX_ATTEMPTS}${C.RESET}`);
+                
+                const artifacts = detectFailures();
+                const currentFailCount = artifacts.length;
+                
+                if (currentFailCount === 0) {
+                    console.log(`${C.GREEN}🎉 All tests passing! No failures detected.${C.RESET}`);
+                    break;
+                }
+                
+                // If failures INCREASED since last attempt, rollback all changes
+                if (attempt > 1 && currentFailCount > prevFailCount) {
+                    console.log(`${C.RED}⚠️  Failures increased (${prevFailCount} → ${currentFailCount}). Rolling back all changes...${C.RESET}`);
+                    for (const [filePath, originalContent] of backups) {
+                        fs.writeFileSync(filePath, originalContent);
+                        console.log(`   ${C.YELLOW}↩️  Restored: ${path.basename(filePath)}${C.RESET}`);
+                    }
+                    break;
+                }
+                prevFailCount = currentFailCount;
+                
+                const applied = await analyzeAndFix(artifacts, client, argv, output, backups);
+                
+                if (applied === 0) {
+                    console.log(`${C.YELLOW}⚠️  No fixes could be applied. Stopping retry loop.${C.RESET}`);
+                    break;
+                }
+                
+                
+                console.log(`\n${C.BRIGHT}💉 ${applied} fix(es) applied. Re-running tests to verify (attempt ${attempt})...${C.RESET}`);
+                const rerun = await runNative(commandToRun);
+                output = rerun.output; // Use new output for next iteration's AI context
+                
+                if (rerun.code === 0) {
+                    console.log(`\n${C.GREEN}${C.BRIGHT}🎉 All tests passing after attempt ${attempt}!${C.RESET}`);
+                    break;
+                }
+                
+                if (attempt === MAX_ATTEMPTS) {
+                    console.log(`\n${C.YELLOW}⚠️  Max attempts (${MAX_ATTEMPTS}) reached. Some failures may persist.${C.RESET}`);
+                }
             }
+        } else if (code !== 0) {
+            console.log(`\n🔴 Command failed with code ${code}. Activating DeFlake...`);
+            const artifacts = detectFailures();
+            await analyzeAndFix(artifacts, client, argv, output, new Map());
         }
     }
     if (argv.report) showReport();
@@ -110,7 +158,7 @@ function detectFailures() {
     return results;
 }
 
-async function analyzeAndFix(artifacts, client, argv, capturedOutput = '') {
+async function analyzeAndFix(artifacts, client, argv, capturedOutput = '', backups = new Map()) {
     if (artifacts.length === 0) {
         console.log(`  ${C.YELLOW}⚠️  No failure artifacts detected. Run 'npx deflake doctor' to check permissions.${C.RESET}`);
         return 0;
@@ -186,7 +234,7 @@ async function analyzeAndFix(artifacts, client, argv, capturedOutput = '') {
                             }
                             if (fixLoc) {
                                 console.log(`   ${C.BRIGHT}💉 Applying patches...${C.RESET}`);
-                                if (await applyFix(res, fixLoc)) {
+                                if (await applyFix(res, fixLoc, backups)) {
                                    count++;
                                    console.log(`   ${C.GREEN}${C.BRIGHT}✅ Fix applied to ${path.basename(fixLoc.path)}:${fixLoc.line}${C.RESET}`);
                                 } else {
@@ -216,10 +264,30 @@ async function analyzeAndFix(artifacts, client, argv, capturedOutput = '') {
     }
     console.log(`${C.BRIGHT}━━━ DeFlake Summary: ${count}/${artifacts.length} fix(es) applied ━━━${C.RESET}\n`);
     return count;
+}
 
+function checkBalance(code) {
+    const pairs = { '(': ')', '{': '}', '[': ']' };
+    const stack = [];
+    // Skip strings and comments for accuracy
+    let inString = false, stringChar = '', escaped = false;
+    for (const ch of code) {
+        if (escaped) { escaped = false; continue; }
+        if (ch === '\\') { escaped = true; continue; }
+        if (inString) { if (ch === stringChar) inString = false; continue; }
+        if (ch === '"' || ch === "'" || ch === '`') { inString = true; stringChar = ch; continue; }
+        if (pairs[ch]) stack.push(pairs[ch]);
+        else if (ch === ')' || ch === '}' || ch === ']') {
+            if (stack.length === 0 || stack.pop() !== ch) {
+                return { balanced: false, detail: `unexpected '${ch}'` };
+            }
+        }
+    }
+    if (stack.length > 0) return { balanced: false, detail: `unclosed '${stack[stack.length - 1] === ')' ? '(' : stack[stack.length - 1] === '}' ? '{' : '['}'` };
+    return { balanced: true, detail: 'ok' };
 }
 
-async function applyFix(res, loc) {
+async function applyFix(res, loc, backups = new Map()) {
     if (!loc?.path) {
         console.log(`   ${C.YELLOW}⚠️  Cannot apply fix: failure location not detected.${C.RESET}`);
         return false;
@@ -231,6 +299,10 @@ async function applyFix(res, loc) {
             return false;
         }
         const original = fs.readFileSync(loc.path, 'utf8');
+        // Save backup before first modification
+        if (!backups.has(loc.path)) {
+            backups.set(loc.path, original);
+        }
         let content = original;
         let appliedCount = 0;
         for (const p of patches) {
@@ -270,6 +342,13 @@ async function applyFix(res, loc) {
             }
         }
         if (appliedCount > 0) {
+            // SAFETY: Bracket balance check — rollback if patches broke syntax
+            const originalBalance = checkBalance(original);
+            const patchedBalance = checkBalance(content);
+            if (originalBalance.balanced && !patchedBalance.balanced) {
+                console.log(`   ${C.YELLOW}⏭️  Rollback: patches broke bracket balance (${patchedBalance.detail}). Reverting file.${C.RESET}`);
+                return false;
+            }
             fs.writeFileSync(loc.path, content);
             return true;
         }

package/package.json

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