deflake 1.2.17 → 1.2.25

package/README.md

@@ -22,13 +22,16 @@ npx deflake npx playwright test
 npx deflake npx cypress run
 ```
 
-### 🚑 Diagnostics (Doctor Mode)
-Validate your environment, API key, and quota without running tests:
-
 ```bash
 npx deflake doctor
 ```
 
+### 🍎 macOS Permission Requirements
+On macOS, if your project folder is located in **Documents** or **Desktop**, DeFlake may be blocked from reading test results.
+
+*   **Move Project**: Move your folder out of Documents (e.g., to `/Users/hugo/code/`).
+*   **Full Disk Access**: Grant "Full Disk Access" to your Terminal/iTerm in *System Settings > Privacy & Security*.
+
 ### Manual Mode
 Analyze an existing error log and HTML/Image snapshot:
 

package/cli.js

@@ -7,7 +7,7 @@ const fs = require('fs');
 const path = require('path');
 const pkg = require('./package.json');
 
-// --- COLORS ---
+// --- PREMIUM COLORS ---
 const C = {
     RESET: "\x1b[0m",
     BRIGHT: "\x1b[1m",
@@ -16,8 +16,12 @@ const C = {
     YELLOW: "\x1b[33m",
     CYAN: "\x1b[36m",
     BLUE: "\x1b[34m",
+    MAGENTA: "\x1b[35m",
     GRAY: "\x1b[90m",
-    WHITE: "\x1b[37m"
+    WHITE: "\x1b[37m",
+    BG_BLUE: "\x1b[44m",
+    BG_GREEN: "\x1b[42m",
+    BG_RED: "\x1b[41m"
 };
 
 const rawArgs = process.argv.slice(2);
@@ -43,19 +47,16 @@ async function main() {
 
     if (commandToRun) {
         const { code } = 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);
-
             if (applied > 0 && argv.fix) {
                 console.log(`\n${C.BRIGHT}💉 Fixes applied. Re-running tests to verify...${C.RESET}`);
                 await runNative(commandToRun);
             }
         }
     }
-
     if (argv.report) showReport();
 }
 
@@ -79,7 +80,9 @@ function detectFailures() {
                     results.push({ name: path.basename(path.dirname(fullPath)), htmlPath: fullPath });
                 }
             });
-        } catch (e) {}
+        } catch (e) {
+            console.log(`\n⚠️  Scan Error in ${dir}: ${C.RED}${e.message}${C.RESET}`);
+        }
     });
     return results;
 }
@@ -89,122 +92,189 @@ async function analyzeAndFix(artifacts, client, argv) {
         console.log(`  ${C.YELLOW}⚠️  No failure artifacts detected. Run 'npx deflake doctor' to check permissions.${C.RESET}`);
         return 0;
     }
-
     console.log(`🔍 Analyzing ${artifacts.length} failure(s)...`);
     let count = 0;
-
     for (const art of artifacts) {
         process.stdout.write(`⏳ Analyzing ${art.name}...`);
         try {
             const content = fs.readFileSync(art.htmlPath, 'utf8');
             const loc = extractLoc(content);
             const source = loc && fs.existsSync(loc.path) ? fs.readFileSync(loc.path, 'utf8') : null;
-            
             const res = await client.heal(null, art.htmlPath, loc, source, argv.fix);
-            if (res?.status === 'success') {
-                if (argv.fix) {
-                    if (await applyFix(res, loc)) count++;
-                }
+            
+            if (res && res.status === 'success') {
                 process.stdout.write(`\r✅ Analysis complete for ${art.name}\n`);
-                printFix(res.fix, loc);
+                try {
+                    const parsed = JSON.parse(res.fix);
+                    if (parsed.explanation) console.log(`   ${C.CYAN}${C.BRIGHT}🧠 Insight:${C.RESET} ${C.GRAY}${parsed.explanation}${C.RESET}`);
+                    if (argv.fix && parsed.patches && parsed.patches.length > 0) {
+                        if (await applyFix(res, loc)) {
+                           count++;
+                           console.log(`   ${C.GREEN}💉 Fix applied to ${path.basename(loc.path)}:${loc.line}${C.RESET}`);
+                        }
+                    }
+                } catch (e) {
+                   console.log(`   ${C.CYAN}${C.BRIGHT}🧠 Insight:${C.RESET} ${res.fix}`);
+                }
+            } else {
+                process.stdout.write(`\r❌ Analysis incomplete for ${art.name}: ${res?.message || 'Check logs'}\n`);
             }
         } catch (e) {
-            console.log(`\n  ❌ ${C.RED}Error: ${e.message}${C.RESET}`);
+            console.log(`\n   ❌ ${C.RED}Error: ${e.message}${C.RESET}`);
         }
     }
     return count;
 }
 
 async function applyFix(res, loc) {
-    if (!loc?.path) return false;
+    if (!loc?.path) {
+        console.log(`   ${C.YELLOW}⚠️  Cannot apply fix: failure location not detected.${C.RESET}`);
+        return false;
+    }
     try {
         const patches = JSON.parse(res.fix).patches || [];
+        if (patches.length === 0) {
+            console.log(`   ${C.YELLOW}⚠️  No patches provided by AI.${C.RESET}`);
+            return false;
+        }
         const original = fs.readFileSync(loc.path, 'utf8');
         let content = original;
-        
+        let appliedCount = 0;
         for (const p of patches) {
             const lines = content.split('\n');
             const idx = p.line - 1;
             if (idx >= 0 && idx < lines.length) {
                 const indent = lines[idx].match(/^\s*/)[0];
                 const cleanLine = indent + p.new_line.trim();
-
-                // 🛑 SAFETY GUARD: Prevent top-level await in class bodies
-                if (cleanLine.includes('await') && !content.includes('async')) {
-                   console.log(`  ⚠️  Blocked illegal await in non-async scope: ${path.basename(loc.path)}`);
-                   continue;
-                }
-
-                if (!content.includes(p.new_line.trim())) {
-                    if (p.action === 'INSERT_AFTER') lines.splice(p.line, 0, cleanLine);
-                    else lines[idx] = cleanLine;
-                    content = lines.join('\n');
+                // Safety: skip if the new line is already present (dedup)
+                if (content.includes(p.new_line.trim())) {
+                    console.log(`   ${C.GRAY}⏭️  Skipped (already present): ${p.new_line.trim().substring(0, 60)}...${C.RESET}`);
+                    continue;
                 }
+                if (p.action === 'INSERT_AFTER') lines.splice(p.line, 0, cleanLine);
+                else lines[idx] = cleanLine;
+                content = lines.join('\n');
+                appliedCount++;
             }
         }
-        
-        fs.writeFileSync(loc.path, content);
-        
-        // 🧪 SMARTER SYNTAX CHECK
-        try {
-            // Check for obvious syntax errors in TS (top level await in CommonJS/Class)
-            if (content.match(/class\s+\w+\s+\{[\s\S]*?await\s+/)) {
-                throw new Error("Illegal await in class body");
-            }
+        if (appliedCount > 0) {
+            fs.writeFileSync(loc.path, content);
             return true;
-        } catch(e) {
-            fs.writeFileSync(loc.path, original);
-            return false;
         }
-    } catch(e) { return false; }
+        return false;
+    } catch(e) {
+        console.log(`   ${C.RED}❌ Patch error: ${e.message}${C.RESET}`);
+        return false;
+    }
 }
 
 function extractLoc(text) {
-    const m = text.match(/at\s+(.*?\.ts):(\d+):(\d+)/);
-    return m ? { path: path.resolve(m[1]), line: m[2] } : null;
-}
-
-function printFix(fix, loc) {
-    try {
-        const p = JSON.parse(fix);
-        console.log(`\n${C.CYAN}${C.BRIGHT}💡 SUGGESTED FIX:${C.RESET}`);
-        console.log(`  ${C.BRIGHT}Reason:${C.RESET} ${p.explanation}`);
-    } catch(e) {}
+    // Support .ts, .js, .cy.ts, .cy.js, .spec.ts, .spec.js
+    const m = text.match(/at\s+(.*?\.(?:cy\.)?(?:spec\.)?(?:ts|js)):(\d+):(\d+)/);
+    return m ? { path: path.resolve(m[1]), line: parseInt(m[2]) } : null;
 }
 
 async function runDoctor() {
-    console.log(`\n👨‍⚕️  ${C.BRIGHT}DeFlake Doctor - Diagnostic Tool${C.RESET}\n`);
-    const dirs = ['test-results', 'playwright-report'];
-    let error = false;
+    console.log(`\n${C.BG_BLUE}${C.WHITE}${C.BRIGHT}  DEFLAKE MISSION CONTROL - DEEP DIAGNOSTIC  ${C.RESET}\n`);
+    
+    // 1. SYSTEM CORE
+    console.log(`${C.CYAN}1. SYSTEM CORE${C.RESET}`);
+    console.log(`   ${C.GRAY}├─ Version:    ${C.RESET}${C.BRIGHT}v${pkg.version}${C.RESET}`);
+    console.log(`   ${C.GRAY}├─ Platform:   ${C.RESET}${process.platform} (${process.arch})`);
+    console.log(`   ${C.GRAY}└─ Project:    ${C.RESET}${path.basename(process.cwd())}\n`);
+
+    // 2. PROJECT AUDIT
+    console.log(`${C.CYAN}2. PROJECT AUDIT${C.RESET}`);
+    const fw = DeFlakeClient.detectFramework();
+    console.log(`   ${C.GRAY}├─ Framework:  ${C.RESET}${C.GREEN}${fw.toUpperCase()}${C.RESET}`);
+    
+    const testDirs = ['tests', 'cypress/e2e', 'test', 'pages'];
+    let allFiles = [];
+    testDirs.forEach(d => {
+        if (fs.existsSync(d)) {
+            const files = fs.readdirSync(d, { recursive: true }).filter(f => f.endsWith('.ts') || f.endsWith('.js') || f.endsWith('.cy.js'));
+            files.forEach(f => allFiles.push({ name: f, full: path.join(d, f) }));
+        }
+    });
+    console.log(`   ${C.GRAY}├─ Discovery:  ${C.RESET}${C.GREEN}${allFiles.length} files matched${C.RESET}`);
+    if (allFiles.length === 0) console.log(`   ${C.GRAY}└─ ${C.RED}Warning: No test files found in expected directories.${C.RESET}`);
+    else console.log(`   ${C.GRAY}└─ All source folders are accessible.${C.RESET}`);
+    console.log("");
 
-    for (const d of dirs) {
-        if (!fs.existsSync(d)) continue;
-        process.stdout.write(`  Checking ${d.padEnd(20)}... `);
+    // 3. API CONNECTIVITY
+    console.log(`${C.CYAN}3. API CONNECTIVITY${C.RESET}`);
+    const apiKey = process.env.DEFLAKE_API_KEY || "NOT_SET";
+    if (apiKey !== "NOT_SET") {
         try {
-            fs.accessSync(d, fs.constants.R_OK);
-            const checkDeep = (p) => {
-                fs.accessSync(p, fs.constants.R_OK);
-                if (fs.statSync(p).isDirectory()) {
-                    fs.readdirSync(p).forEach(f => checkDeep(path.join(p, f)));
-                }
-            };
-            checkDeep(d);
-            console.log(`${C.GREEN}Healthy${C.RESET}`);
+            const client = new DeFlakeClient();
+            const usage = await client.getUsage();
+            if (usage?.status === 'success') {
+                console.log(`   ${C.GRAY}├─ Connection: ${C.RESET}${C.GREEN}ONLINE${C.RESET}`);
+                console.log(`   ${C.GRAY}└─ Quota:      ${C.RESET}${C.MAGENTA}${usage.data.usage}/${usage.data.limit} monthly fixes used${C.RESET}`);
+            } else {
+                console.log(`   ${C.GRAY}└─ Connection: ${C.RESET}${C.RED}OFFLINE (Unauthorized)${C.RESET}`);
+            }
         } catch (e) {
-            console.log(`${C.RED}Access Denied${C.RESET}`);
-            error = true;
+            console.log(`   ${C.GRAY}└─ Connection: ${C.RESET}${C.RED}OFFLINE (${e.message})${C.RESET}`);
+        }
+    } else {
+        console.log(`   ${C.GRAY}└─ API Key:    ${C.RED}MISSING${C.RESET}`);
+    }
+    console.log("");
+
+    // 4. DEEP ACCESS AUDIT (The Truth Teller)
+    console.log(`${C.CYAN}4. DEEP ACCESS AUDIT (The Truth Teller)${C.RESET}`);
+    const artDirs = [
+        { path: 'test-results', label: 'Test Results' },
+        { path: 'playwright-report', label: 'HTML Report' }
+    ];
+    let allPristine = true;
+    let sandboxed = false;
+
+    for (const d of artDirs) {
+        if (fs.existsSync(d.path)) {
+            process.stdout.write(`   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}🔍 Scanning Deep...`);
+            try {
+                // A shallow accessSync is NOT enough for Mac Sandbox. Must list and stat.
+                const items = fs.readdirSync(d.path);
+                if (items.length > 0) {
+                    process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.GREEN}${C.BRIGHT}[LIBERADOS]${C.RESET}${C.GREEN} (${items.length} top-level objects)${C.RESET}   \n`);
+                } else {
+                    process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.GRAY}Vacia (No hay resultados)${C.RESET}   \n`);
+                }
+            } catch (e) {
+                if (e.code === 'EPERM' || e.message.includes('Operation not permitted')) {
+                    process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.BG_RED}${C.WHITE} BLOQUEADO POR MAC PRIVACY ${C.RESET}   \n`);
+                    sandboxed = true;
+                } else {
+                    process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.RED}[ERROR] (${e.code})${C.RESET}   \n`);
+                }
+                allPristine = false;
+            }
+        } else {
+            console.log(`   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.GRAY}No detectada${C.RESET}`);
         }
     }
 
-    if (error) {
-        console.log(`\n  ${C.YELLOW}⚠️  Files are locked!${C.RESET}`);
-        const cmd = process.platform === 'win32' ? `icacls . /grant \${env:USERNAME}:(OI)(CI)F /T` : `sudo chown -R $(whoami) .`;
-        console.log(`     ${C.BRIGHT}Fix:${C.RESET} ${C.CYAN}${cmd}${C.RESET}`);
+    if (sandboxed) {
+        console.log(`\n   ${C.BG_RED}${C.WHITE}${C.BRIGHT}  ALERTA: MAC SANDBOX DETECTADO  ${C.RESET}`);
+        console.log(`   ${C.BRIGHT}Tu proyecto está en Documents/Desktop y Mac bloquea el acceso profundo.${C.RESET}`);
+        console.log(`   ${C.CYAN}SOLUCIÓN 1:${C.RESET} Dale "Full Disk Access" a tu Terminal en Settings > Privacy.`);
+        console.log(`   ${C.CYAN}SOLUCIÓN 2:${C.RESET} Mueve el proyecto fuera de Documents (ej: /Users/hugo/code/...)`);
+    } else if (!allPristine) {
+        console.log(`\n   ${C.YELLOW}⚠️  PERMISOS DE ARCHIVO REQUERIDOS:${C.RESET}`);
+        const fix = process.platform === 'win32' ? 'icacls . /grant ${env:USERNAME}:(OI)(CI)F /T' : 'sudo chown -R $(whoami) .';
+        console.log(`   Ejecuta: ${C.CYAN}${fix}${C.RESET}`);
     } else {
-        console.log(`\n  ✨ ${C.GREEN}All checks passed. System is ready.${C.RESET}`);
+        console.log(`\n${C.BG_GREEN}${C.WHITE}${C.BRIGHT}  SISTEMA SALUDABLE Y LIBERADO  ${C.RESET}`);
     }
+    console.log("\n" + C.GRAY + "─".repeat(55) + C.RESET + "\n");
 }
 
 function showReport() {
+    // Kill any existing report server to prevent EADDRINUSE
+    try {
+        execSync('lsof -ti:9323 | xargs kill -9 2>/dev/null', { stdio: 'ignore' });
+    } catch (e) { /* no process to kill, that's fine */ }
     spawn('npx playwright show-report', { shell: true, stdio: 'inherit' }).on('error', () => {});
 }

package/client.js

@@ -105,11 +105,13 @@ class DeFlakeClient {
 
     async heal(logPath, htmlPath, failureLocation = null, sourceCode = null, applyFix = false) {
         try {
-            // ... (rest of the check logic) ...
-            if (!fs.existsSync(logPath)) throw new Error(`Log file not found: ${logPath}`);
             if (!fs.existsSync(htmlPath)) throw new Error(`HTML file not found: ${htmlPath}`);
 
-            const logContent = fs.readFileSync(logPath, 'utf8');
+            // logPath is optional — when null, we use htmlPath as the primary error context
+            let logContent = '';
+            if (logPath && fs.existsSync(logPath)) {
+                logContent = fs.readFileSync(logPath, 'utf8');
+            }
 
             // Handle binary artifacts (Screenshots) vs Text artifacts (HTML/MD)
             const isImage = htmlPath.toLowerCase().endsWith('.png');

package/package.json

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