deflake 1.2.12 → 1.2.15

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);
 }
 
 /**
@@ -703,6 +681,43 @@ async function runDoctor(argv) {
     } catch (error) {
         process.stdout.write(`\r  ❌ ${C.RED}API Connectivity Error: ${error.message}${C.RESET}\n`);
     }
+    // 6. Artifact & Permission Check
+    console.log(`${C.BRIGHT}Checking Artifact Permissions:${C.RESET}`);
+    const criticalDirs = [
+        { path: 'test-results', label: 'Playwright Failures' },
+        { path: 'playwright-report', label: 'Playwright Report' },
+        { path: 'cypress/screenshots', label: 'Cypress Screenshots' },
+        { path: 'cypress/videos', label: 'Cypress Videos' }
+    ];
+
+    let permsIssue = false;
+    for (const dir of criticalDirs) {
+        if (fs.existsSync(dir.path)) {
+            try {
+                fs.accessSync(dir.path, fs.constants.R_OK | fs.constants.W_OK);
+                // Deep check: try readdir
+                fs.readdirSync(dir.path);
+                console.log(`  ✅ ${dir.label.padEnd(20)}: ${C.GREEN}Accessible${C.RESET}`);
+            } catch (e) {
+                console.log(`  ❌ ${dir.label.padEnd(20)}: ${C.RED}Access Denied${C.RESET}`);
+                console.log(`     ${C.GRAY}Path: ${dir.path}${C.RESET}`);
+                permsIssue = true;
+            }
+        }
+    }
+
+    if (permsIssue) {
+        console.log(`\n  ${C.YELLOW}⚠️  Permission bottleneck detected!${C.RESET}`);
+        if (process.platform === 'win32') {
+            console.log(`     ${C.BRIGHT}Windows Fix:${C.RESET} Run this in PowerShell as Admin:`);
+            console.log(`     ${C.CYAN}icacls . /grant \${env:USERNAME}:(OI)(CI)F /T${C.RESET}`);
+        } else {
+            console.log(`     ${C.BRIGHT}macOS/Linux Fix:${C.RESET} Run this command:`);
+            console.log(`     ${C.CYAN}sudo chown -R $(whoami) .${C.RESET}`);
+        }
+    } else {
+        console.log(`  ✅ All critical directories are accessible`);
+    }
     console.log("");
 
     console.log(`${C.BRIGHT}Summary:${C.RESET}`);
@@ -749,34 +764,74 @@ async function applySelfHealing(result) {
             }];
         }
 
-        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 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;
 
-            if (!fs.existsSync(pFile)) continue;
+                if (!fs.existsSync(pFile)) continue;
 
-            const lines = fs.readFileSync(pFile, 'utf8').split('\n');
-            const originalLineIndex = pLine - 1;
+                // Create backup if not already done
+                if (!backups.has(pFile)) {
+                    backups.set(pFile, fs.readFileSync(pFile, 'utf8'));
+                }
 
-            if (originalLineIndex < 0 || originalLineIndex >= lines.length) continue;
+                const currentLines = fs.readFileSync(pFile, 'utf8').split('\n');
+                const originalLineIndex = pLine - 1;
 
-            const originalLine = lines[originalLineIndex];
-            const indentation = originalLine.match(/^\s*/)[0];
+                if (originalLineIndex < 0 || originalLineIndex >= currentLines.length) continue;
 
-            if (pAction === 'INSERT_AFTER') {
-                lines.splice(pLine, 0, indentation + pNew.trim());
-                fs.writeFileSync(pFile, lines.join('\n'));
-                console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully inserted at:${C.RESET} ${path.basename(pFile)}:${pLine}`);
-            } else {
-                lines[originalLineIndex] = indentation + pNew.trim();
-                fs.writeFileSync(pFile, lines.join('\n'));
-                console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully patched:${C.RESET} ${path.basename(pFile)}:${pLine}`);
+                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;
+                }
+
+                const finalNewLine = indentation + pNew.trim();
+
+                // 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}`);
     }
 }
 

package/package.json

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