deflake 1.2.21 → 1.2.27

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

@@ -18,8 +18,10 @@ const C = {
     BLUE: "\x1b[34m",
     MAGENTA: "\x1b[35m",
     GRAY: "\x1b[90m",
+    WHITE: "\x1b[37m",
     BG_BLUE: "\x1b[44m",
-    BG_GREEN: "\x1b[42m"
+    BG_GREEN: "\x1b[42m",
+    BG_RED: "\x1b[41m"
 };
 
 const rawArgs = process.argv.slice(2);
@@ -61,25 +63,39 @@ async function main() {
 async function runNative(fullCommand) {
     return new Promise((resolve) => {
         console.log(`🚀 Running command: ${C.CYAN}${fullCommand}${C.RESET}`);
-        const child = spawn(fullCommand, { shell: true, stdio: 'inherit' });
+        const child = spawn(fullCommand, {
+            shell: true,
+            stdio: 'inherit',
+            env: { ...process.env, PLAYWRIGHT_HTML_OPEN: 'never' }
+        });
         child.on('close', (code) => resolve({ code }));
     });
 }
 
 function detectFailures() {
     const results = [];
+    console.log(`\n${C.CYAN}📂 Scanning for failure artifacts...${C.RESET}`);
     ['test-results', 'playwright-report'].forEach(dir => {
-        if (!fs.existsSync(dir)) return;
+        if (!fs.existsSync(dir)) {
+            console.log(`   ${C.GRAY}├─ ${dir}/: not found (skipping)${C.RESET}`);
+            return;
+        }
         try {
             const files = fs.readdirSync(dir, { recursive: true });
+            let found = 0;
             files.forEach(f => {
                 const fullPath = path.join(dir, f);
                 if (f.endsWith('error-context.md')) {
                     results.push({ name: path.basename(path.dirname(fullPath)), htmlPath: fullPath });
+                    found++;
                 }
             });
-        } catch (e) {}
+            console.log(`   ${C.GRAY}├─ ${dir}/:${C.RESET} ${found > 0 ? C.GREEN + found + ' failure artifact(s)' : C.GRAY + 'no failures'}${C.RESET}`);
+        } catch (e) {
+            console.log(`   ${C.GRAY}├─ ${dir}/:${C.RESET} ${C.RED}SCAN ERROR — ${e.message}${C.RESET}`);
+        }
     });
+    console.log(`   ${C.GRAY}└─ Total:${C.RESET} ${C.BRIGHT}${results.length} artifact(s) to analyze${C.RESET}\n`);
     return results;
 }
 
@@ -88,82 +104,140 @@ 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)...`);
+    console.log(`${C.BRIGHT}🔍 Analyzing ${artifacts.length} failure(s)...${C.RESET}\n`);
     let count = 0;
-    for (const art of artifacts) {
-        process.stdout.write(`⏳ Analyzing ${art.name}...`);
+    for (let i = 0; i < artifacts.length; i++) {
+        const art = artifacts[i];
+        console.log(`${C.CYAN}━━━ [${i+1}/${artifacts.length}] ${art.name} ━━━${C.RESET}`);
         try {
             const content = fs.readFileSync(art.htmlPath, 'utf8');
             const loc = extractLoc(content);
+            
+            // Step 1: Location extraction
+            if (loc) {
+                console.log(`   ${C.GRAY}📍 Location:${C.RESET} ${path.basename(loc.path)}:${loc.line}`);
+            } else {
+                console.log(`   ${C.YELLOW}📍 Location: Could not extract (regex mismatch)${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
+            console.log(`   ${C.GRAY}🌐 Calling DeFlake API...${C.RESET}`);
             const res = await client.heal(null, art.htmlPath, loc, source, argv.fix);
-            if (res?.status === 'success') {
-                if (argv.fix && await applyFix(res, loc)) count++;
-                process.stdout.write(`\r✅ Analysis complete for ${art.name}\n`);
-                printFix(res.fix, loc);
+            
+            if (res && res.status === 'success') {
+                console.log(`   ${C.GREEN}✅ API Response: SUCCESS${C.RESET}`);
+                try {
+                    const parsed = JSON.parse(res.fix);
+                    if (parsed.explanation) {
+                        console.log(`   ${C.CYAN}🧠 Insight:${C.RESET} ${C.GRAY}${parsed.explanation}${C.RESET}`);
+                    }
+                    if (parsed.patches && parsed.patches.length > 0) {
+                        console.log(`   ${C.GRAY}🩹 Patches:${C.RESET} ${parsed.patches.length} patch(es) suggested`);
+                        for (const p of parsed.patches) {
+                            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}`);
+                            } else {
+                               console.log(`   ${C.YELLOW}⚠️  Patches could not be applied (see details above)${C.RESET}`);
+                            }
+                        } else {
+                            console.log(`   ${C.YELLOW}ℹ️  Use --fix flag to auto-apply these patches${C.RESET}`);
+                        }
+                    } else {
+                        console.log(`   ${C.YELLOW}⚠️  API returned no patches${C.RESET}`);
+                    }
+                } catch (e) {
+                   console.log(`   ${C.CYAN}🧠 Insight:${C.RESET} ${res.fix}`);
+                }
+            } else if (res && res.detail === 'QUOTA_EXCEEDED') {
+                console.log(`   ${C.RED}🚫 QUOTA EXCEEDED — No more fixes available this month${C.RESET}`);
+            } else {
+                console.log(`   ${C.RED}❌ API Response: ${res?.status || 'null'} — ${res?.message || res?.detail || 'Unknown error'}${C.RESET}`);
             }
         } catch (e) {
-            console.log(`\n  ❌ ${C.RED}Error: ${e.message}${C.RESET}`);
+            console.log(`   ${C.RED}❌ Error: ${e.message}${C.RESET}`);
         }
+        console.log('');
     }
+    console.log(`${C.BRIGHT}━━━ DeFlake Summary: ${count}/${artifacts.length} fix(es) applied ━━━${C.RESET}\n`);
     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 originalLine = lines[idx];
+                const indent = originalLine.match(/^\s*/)[0];
                 const cleanLine = indent + p.new_line.trim();
-                if (cleanLine.includes('await') && !content.includes('async')) 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);
+                    console.log(`   ${C.GREEN}+  Line ${p.line + 1}: ${cleanLine.trim()}${C.RESET}`);
+                } else {
+                    lines[idx] = cleanLine;
+                    console.log(`   ${C.RED}-  Line ${p.line}: ${originalLine.trim()}${C.RESET}`);
+                    console.log(`   ${C.GREEN}+  Line ${p.line}: ${cleanLine.trim()}${C.RESET}`);
+                }
+                content = lines.join('\n');
+                appliedCount++;
             }
         }
-        fs.writeFileSync(loc.path, content);
-        try {
-            if (content.match(/class\s+\w+\s+\{[\s\S]*?await\s+/)) throw new Error("Illegal await");
+        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.BG_BLUE}${C.WHITE}${C.BRIGHT}  DEFLAKE MISSION CONTROL - DIAGNOSTIC CENTER  ${C.RESET}\n`);
+    console.log(`\n${C.BG_BLUE}${C.WHITE}${C.BRIGHT}  DEFLAKE MISSION CONTROL - DEEP DIAGNOSTIC  ${C.RESET}\n`);
     
-    // 1. SYSTEM HUB
+    // 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 (Discovery Phase)
-    console.log(`${C.CYAN}2. PROJECT DISCOVERY & VALIDATION${C.RESET}`);
+    // 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}`);
     
@@ -175,95 +249,85 @@ async function runDoctor() {
             files.forEach(f => allFiles.push({ name: f, full: path.join(d, f) }));
         }
     });
-
-    if (allFiles.length > 0) {
-        console.log(`   ${C.GRAY}├─ Discovery:  ${C.RESET}${C.GREEN}${allFiles.length} files detected${C.RESET}`);
-        allFiles.slice(0, 8).forEach(file => {
-            process.stdout.write(`   ${C.GRAY}│  ├─ ${path.basename(file.name).padEnd(25)}${C.RESET} `);
-            try {
-                execSync(`node --check "${file.full}"`, { stdio: 'ignore' });
-                console.log(`${C.GREEN}✓ Syntax OK${C.RESET}`);
-            } catch (e) {
-                console.log(`${C.RED}❗ SYNTAX ERROR${C.RESET}`);
-            }
-        });
-        if (allFiles.length > 8) console.log(`   ${C.GRAY}│  └─ ... and ${allFiles.length - 8} more files validated.${C.RESET}`);
-        else console.log(`   ${C.GRAY}│  └─ All source files validated.${C.RESET}`);
-    } else {
-        console.log(`   ${C.GRAY}└─ Discovery:  ${C.RED}No test/page files found!${C.RESET}`);
-    }
+    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("");
 
-    // 3. API & SUBSCRIPTION HUB
-    console.log(`${C.CYAN}3. API & CLOUD HUB${C.RESET}`);
+    // 3. API CONNECTIVITY
+    console.log(`${C.CYAN}3. API CONNECTIVITY${C.RESET}`);
     const apiKey = process.env.DEFLAKE_API_KEY || "NOT_SET";
-    const masked = apiKey === "NOT_SET" ? apiKey : (apiKey.substring(0, 4) + "****" + apiKey.substring(apiKey.length - 4));
-    console.log(`   ${C.GRAY}├─ API Key:    ${C.RESET}${apiKey === "NOT_SET" ? C.RED : C.GREEN}${masked}${C.RESET}`);
-    
     if (apiKey !== "NOT_SET") {
         try {
-            process.stdout.write(`   ${C.GRAY}├─ Gateway:    ${C.RESET}📡 Pinging...`);
             const client = new DeFlakeClient();
-            const start = Date.now();
             const usage = await client.getUsage();
-            const latency = Date.now() - start;
             if (usage?.status === 'success') {
-                process.stdout.write(`\r   ${C.GRAY}├─ Gateway:    ${C.RESET}${C.GREEN}ONLINE (${latency}ms)${C.RESET}   \n`);
-                console.log(`   ${C.GRAY}└─ Quota:      ${C.RESET}${C.MAGENTA}${usage.data.usage}/${usage.data.limit} fixes used${C.RESET}`);
+                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 {
-                process.stdout.write(`\r   ${C.GRAY}├─ Gateway:    ${C.RESET}${C.RED}Connection Failed (${usage?.message || 'Unauthorized'})${C.RESET}   \n`);
+                console.log(`   ${C.GRAY}└─ Connection: ${C.RESET}${C.RED}OFFLINE (Unauthorized)${C.RESET}`);
             }
         } catch (e) {
-            process.stdout.write(`\r   ${C.GRAY}├─ Gateway:    ${C.RESET}${C.RED}Link Down (${e.message})${C.RESET}   \n`);
+            console.log(`   ${C.GRAY}└─ Connection: ${C.RESET}${C.RED}OFFLINE (${e.message})${C.RESET}`);
         }
     } else {
-        console.log(`   ${C.GRAY}└─ Status:     ${C.RED}Awaiting credentials...${C.RESET}`);
+        console.log(`   ${C.GRAY}└─ API Key:    ${C.RED}MISSING${C.RESET}`);
     }
     console.log("");
 
-    // 4. THE LIBERATION AUDIT (Permission Status)
-    console.log(`${C.CYAN}4. LIBERATION AUDIT (Permission Status)${C.RESET}`);
+    // 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 allLiberated = true;
-    let totalItems = 0;
+    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}🔍 Checking...`);
-            let dItems = 0;
+            process.stdout.write(`   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}🔍 Scanning Deep...`);
             try {
-                const scan = (p) => {
-                    dItems++;
-                    totalItems++;
-                    fs.accessSync(p, fs.constants.R_OK | fs.constants.W_OK);
-                    if (fs.statSync(p).isDirectory()) fs.readdirSync(p).forEach(f => scan(path.join(p, f)));
-                };
-                scan(d.path);
-                process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.GREEN}${C.BRIGHT}[LIBERADOS]${C.RESET}${C.GREEN} (${dItems} ítems accesibles)${C.RESET}   \n`);
+                // 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) {
-                process.stdout.write(`\r   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.RED}${C.BRIGHT}[BLOQUEADOS]${C.RESET}${C.RED} (Error en: ${path.basename(e.path)})${C.RESET}   \n`);
-                allLiberated = false;
+                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}Sin carpeta (Aún no hay resultados)${C.RESET}`);
+            console.log(`   ${C.GRAY}├─ ${d.label.padEnd(16)}: ${C.RESET}${C.GRAY}No detectada${C.RESET}`);
         }
     }
 
-    if (!allLiberated) {
-        console.log(`\n   ${C.BG_BLUE}${C.WHITE}${C.BRIGHT}  ACCIÓN REQUERIDA: LIBERAR PERMISOS  ${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 esto en tu terminal: ${C.CYAN}${fix}${C.RESET}`);
+        console.log(`   Ejecuta: ${C.CYAN}${fix}${C.RESET}`);
     } else {
-        console.log(`   ${C.GRAY}└─ Auditoría:     ${C.RESET}${C.GREEN}${totalItems} archivos verificados con éxito.${C.RESET}`);
-        console.log(`\n${C.BG_GREEN}${C.WHITE}${C.BRIGHT}  ESTADO DEL SISTEMA: LIBERADO Y OPERATIVO  ${C.RESET}`);
-        console.log(`   Ya puedes correr: ${C.CYAN}npx deflake --fix --report npx playwright test${C.RESET}`);
+        console.log(`\n${C.BG_GREEN}${C.WHITE}${C.BRIGHT}  SISTEMA SALUDABLE Y LIBERADO  ${C.RESET}`);
     }
-    console.log("\n" + C.GRAY + "─".repeat(50) + C.RESET + "\n");
+    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.21",
+  "version": "1.2.27",
   "description": "AI-powered self-healing tool for Playwright, Cypress, and WebdriverIO tests.",
   "main": "client.js",
   "bin": {