deflake 1.2.13 → 1.2.17

package/cli.js

@@ -2,8 +2,7 @@
 const yargs = require('yargs/yargs');
 const { hideBin } = require('yargs/helpers');
 const DeFlakeClient = require('./client');
-const Migrator = require('./lib/migrator');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const pkg = require('./package.json');
@@ -21,1060 +20,191 @@ const C = {
     WHITE: "\x1b[37m"
 };
 
-// --- DETERMINISTIC COMMAND INTERCEPTION ---
-// Check for diagnostic commands before yargs or main logic even starts
 const rawArgs = process.argv.slice(2);
-if (rawArgs.includes('doctor') || rawArgs.includes('--doctor')) {
-    // We run the doctor logic and force exit to prevent any wrapper loops
-    const doctorArgv = yargs(hideBin(process.argv)).argv;
-    runDoctor(doctorArgv).then(() => process.exit(0)).catch((err) => {
-        console.error(`${C.RED}Doctor failed:${C.RESET} ${err.message}`);
-        process.exit(1);
-    });
-    return; // Safety for some environments
+if (rawArgs.includes('doctor')) {
+    runDoctor().then(() => process.exit(0));
+} else {
+    main();
 }
-// ------------------------------------------
-
-const parser = yargs(hideBin(process.argv))
-    .option('log', {
-        alias: 'l',
-        type: 'string',
-        description: 'Path to the error log file',
-        demandOption: false
-    })
-    .option('html', {
-        alias: 'h',
-        type: 'string',
-        description: 'Path to the HTML snapshot',
-        demandOption: false
-    })
-    .option('api-url', {
-        type: 'string',
-        description: 'Override Default API URL',
-    })
-    .option('fix', {
-        type: 'boolean',
-        description: 'Automatically apply suggested fixes',
-        default: false
-    })
-    .option('doctor', {
-        type: 'boolean',
-        description: 'Diagnose your DeFlake installation',
-        default: false
-    })
-    .option('report', {
-        type: 'boolean',
-        description: 'Automatically open the HTML report after fixing',
-        default: true
-    })
-    .command('doctor', 'Diagnose your DeFlake installation', {}, (argv) => {
-        runDoctor(argv).then(() => process.exit(0));
-    })
-    .command('migrate', 'Migrate Cypress tests to Playwright', {
-        from: { type: 'string', default: 'cypress', description: 'Source framework' },
-        to: { type: 'string', default: 'playwright', description: 'Target framework' },
-        path: { type: 'string', demandOption: true, description: 'Path to Cypress tests' },
-        output: { type: 'string', description: 'Path to output Playwright tests' },
-        ai: { type: 'boolean', default: false, description: 'Enable AI-powered refinement' }
-    }, async (argv) => {
-        try {
-            const client = new DeFlakeClient(argv['api-url']);
-            const migrator = new Migrator({ ...argv, client });
-            await migrator.run();
-            process.exit(0);
-        } catch (err) {
-            console.error(`\x1b[31mMigration failed:\x1b[0m ${err.message}`);
-            process.exit(1);
-        }
-    })
-    .version(pkg.version)
-    .help();
-
-const argv = parser.argv;
-
-// If we reach this point, it means no diagnostic command (like 'doctor') was triggered.
-// We proceed with the main test wrapper logic.
-main();
-
-// Helper to auto-detect artifacts (Batch Mode)
-function detectAllArtifacts(providedLog, providedHtml) {
-    // If user provided explicit paths, use them as a single item list
-    if (providedHtml || providedLog) {
-        return [{
-            logPath: providedLog,
-            htmlPath: providedHtml,
-            id: 'manual-input',
-            name: 'Manual Input'
-        }];
-    }
-
-    const detected = [];
 
-    // 1. Scan test-results
-    if (fs.existsSync('test-results')) {
-        function findFiles(dir) {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const res = path.resolve(dir, entry.name);
-                if (entry.isDirectory()) {
-                    findFiles(res);
-                } else {
-                    // Unique ID for this test failure is the parent folder name
-                    const folderName = path.basename(path.dirname(res));
-
-                    // We only want ONE artifact per test folder.
-                    // Priority: error-context.md > index.html > trace.zip
-
-                    // But we can't easily dedup here without a map.
-                    // Let's just collect all candidates and filter later.
-                }
-            }
-        }
-
-        // Better approach: Iterate folders in test-results
-        const testFolders = fs.readdirSync('test-results', { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory())
-            .map(dirent => path.resolve('test-results', dirent.name));
-
-        for (const folder of testFolders) {
-            let artifact = null;
-            let type = '';
+async function main() {
+    const parser = yargs(hideBin(process.argv))
+        .option('fix', { type: 'boolean', default: false })
+        .option('report', { type: 'boolean', default: true })
+        .help();
+
+    const argv = parser.argv;
+    const commandToRun = argv._.join(' ');
+    
+    console.log(`🚑 DeFlake JS Client (Batch Mode) - ${C.CYAN}v${pkg.version}${C.RESET}`);
+    const client = new DeFlakeClient();
+    const fw = DeFlakeClient.detectFramework();
+    console.log(`🔍 Detected Framework: ${C.GREEN}${fw.toUpperCase()}${C.RESET}`);
 
-            const mdPath = path.join(folder, 'error-context.md');
-            const htmlPath = path.join(folder, 'trace.html'); // Some reporters use this
+    if (commandToRun) {
+        const { code } = await runNative(commandToRun);
 
-            // Check for error-context.md (High Quality)
-            if (fs.existsSync(mdPath)) {
-                artifact = mdPath;
-                type = 'md';
-            }
-            // Else check for any HTML that isn't trace viewer boilerplate
-            else {
-                // simple fallback
-            }
+        if (code !== 0) {
+            console.log(`\n🔴 Command failed with code ${code}. Activating DeFlake...`);
+            const artifacts = detectFailures();
+            const applied = await analyzeAndFix(artifacts, client, argv);
 
-            if (artifact) {
-                detected.push({
-                    logPath: null, // Log is usually embedded or passed via stdout
-                    htmlPath: artifact,
-                    id: path.basename(folder),
-                    name: path.basename(folder)
-                });
+            if (applied > 0 && argv.fix) {
+                console.log(`\n${C.BRIGHT}💉 Fixes applied. Re-running tests to verify...${C.RESET}`);
+                await runNative(commandToRun);
             }
         }
     }
 
-    // 2. Scan cypress/screenshots (Cypress default)
-    if (fs.existsSync('cypress/screenshots')) {
-        const screenshotFiles = fs.readdirSync('cypress/screenshots', { recursive: true })
-            .filter(f => f.endsWith('.png'))
-            .map(f => path.resolve('cypress/screenshots', f));
-
-        for (const screenshot of screenshotFiles) {
-            detected.push({
-                logPath: providedLog,
-                htmlPath: screenshot,
-                id: path.basename(screenshot),
-                name: path.basename(screenshot)
-            });
-        }
-    }
-
-    // Fallback: If no granular results, check global report
-    if (detected.length === 0) {
-        if (fs.existsSync('playwright-report/index.html')) {
-            detected.push({
-                logPath: providedLog,
-                htmlPath: 'playwright-report/index.html',
-                id: 'global-report',
-                name: 'Global Report'
-            });
-        }
-    }
-
-    return detected;
+    if (argv.report) showReport();
 }
 
-function stripAnsi(str) {
-    return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
-}
-
-function parsePlaywrightLogs(fullLog) {
-    const cleanLog = stripAnsi(fullLog);
-    const errorBlocks = [];
-    const errorHeaderRegex = /^\s*(\d+)\)\s+\[(.*?)\]\s+/gm;
-    let match;
-
-    const indices = [];
-    while ((match = errorHeaderRegex.exec(cleanLog)) !== null) {
-        indices.push({ index: match.index, name: match[0].trim() });
-    }
-
-    for (let i = 0; i < indices.length; i++) {
-        const start = indices[i].index;
-        const end = (i + 1 < indices.length) ? indices[i + 1].index : cleanLog.length;
-        errorBlocks.push({
-            name: indices[i].name,
-            content: cleanLog.slice(start, end)
-        });
-    }
-    return errorBlocks;
-}
-
-function parseCypressLogs(fullLog) {
-    const cleanLog = stripAnsi(fullLog);
-    const specBlocks = [];
-    const specHeaderRegex = /Running:\s+([^\s]+)\s+\(\d+\s+of\s+\d+\)/g;
-    let match;
-
-    const indices = [];
-    while ((match = specHeaderRegex.exec(cleanLog)) !== null) {
-        indices.push({ index: match.index, spec: match[1] });
-    }
-
-    for (let i = 0; i < indices.length; i++) {
-        const start = indices[i].index;
-        const end = (i + 1 < indices.length) ? indices[i + 1].index : cleanLog.length;
-        specBlocks.push({
-            spec: indices[i].spec,
-            content: cleanLog.slice(start, end)
-        });
-    }
-    return specBlocks;
-}
-
-function parsePytestLogs(fullLog) {
-    const cleanLog = stripAnsi(fullLog);
-    const errorBlocks = [];
-    const testHeaderRegex = /_{10,}\s+(.*?)\s+_{10,}/g;
-    let match;
-
-    const indices = [];
-    while ((match = testHeaderRegex.exec(cleanLog)) !== null) {
-        indices.push({ index: match.index, name: match[1] });
-    }
-
-    for (let i = 0; i < indices.length; i++) {
-        const start = indices[i].index;
-        const end = (i + 1 < indices.length) ? indices[i + 1].index : cleanLog.length;
-        errorBlocks.push({
-            name: indices[i].name,
-            content: cleanLog.slice(start, end)
-        });
-    }
-    return errorBlocks;
+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' });
+        child.on('close', (code) => resolve({ code }));
+    });
 }
 
-async function runHealer(logContent, htmlPath, apiUrl, testName, applyFix = false) {
-    // Check file size limit (Basic check to avoid 429s on huge files)
-    if (htmlPath && fs.existsSync(htmlPath)) {
-        const stats = fs.statSync(htmlPath);
-        if (stats.size > 5 * 1024 * 1024) { // 5MB limit warning
-            console.warn(`⚠️  Warning: Artifact for ${testName} is large (` + (stats.size / 1024 / 1024).toFixed(2) + "MB).");
-        }
-    }
-
-    const client = new DeFlakeClient(apiUrl);
-
-    // Pass log CONTENT (string) directly if it came from wrapper, or file path if from args
-    let finalLogPath = argv.log;
-    let effectiveLogContent = logContent;
-
-    // Robustness: If logContent is empty but we have an MD artifact, read it
-    if (!effectiveLogContent && htmlPath && htmlPath.endsWith('.md') && fs.existsSync(htmlPath)) {
-        try {
-            effectiveLogContent = fs.readFileSync(htmlPath, 'utf8');
-        } catch (e) { }
-    }
-
-    if (effectiveLogContent) {
-        // We have content (from stdio or artifact), write to temp file
-        finalLogPath = '.deflake-error.log';
-        fs.writeFileSync(finalLogPath, effectiveLogContent);
-    } else if (!finalLogPath && fs.existsSync('error.log')) {
-        // Fallback to auto-detected error.log if nothing else
-        finalLogPath = 'error.log';
-    }
-
-    // Validation before calling client
-    if (!finalLogPath) {
-        // Create a dummy log if we have HTML but absolutely no log, to prevent client crash
-        if (htmlPath) {
-            console.log("   (Creating temporary log from available context)");
-            finalLogPath = '.deflake-error.log';
-            fs.writeFileSync(finalLogPath, "Log missing. Refer to HTML/MD snapshot.");
-            effectiveLogContent = "Log missing.";
-        } else {
-            console.error(`❌ [${testName}] Error: No log file or content available.`);
-            return;
-        }
-    }
-
-    // 🧠 SMART CONTEXT: Extract the failing source code if possible
-    const failureLoc = extractFailureLocation(effectiveLogContent || fs.readFileSync(finalLogPath, 'utf8'));
-
-    let sourceCodeContent = null;
-    if (failureLoc && failureLoc.fullRootPath) {
+function detectFailures() {
+    const results = [];
+    ['test-results', 'playwright-report'].forEach(dir => {
+        if (!fs.existsSync(dir)) return;
         try {
-            if (fs.existsSync(failureLoc.fullRootPath)) {
-                sourceCodeContent = fs.readFileSync(failureLoc.fullRootPath, 'utf8');
-            }
-        } catch (e) { }
-    }
-
-    if (!failureLoc) {
-        // Silent warning for batch mode - don't clutter output
-    }
-
-    try {
-        const result = await client.heal(finalLogPath, htmlPath, failureLoc, sourceCodeContent, applyFix);
-
-        if (result && result.status === 'success') {
-            // Return structured object for grouping
-            return {
-                testName,
-                location: failureLoc,
-                sourceCode: sourceCodeContent,
-                fix: result.fix,
-                status: 'success'
-            };
-        }
-        // Return original result so main() can check for QUOTA_EXCEEDED
-        return result || { status: 'error', detail: 'UNKNOWN' };
-    } catch (error) {
-        return { status: 'error', detail: error.message };
-    }
-}
-
-// ... (extractFailureLocation and printDetailedFix remain mostly same, just slight tweaks for robustness) ...
-// Actually, I need to include them in the replace or user 'multi_replace' but this is 'replace_file' so I must provide full content or precise chunks.
-// To avoid massive token usage, I will use the existing helper functions but just update Main.
-
-// WAIT, I must provide the implementations of extractFailureLocation and printDetailedFix if I replace the whole file or large chunks.
-// The previous tool call view_file shows I have the whole content. I will rewrite the whole file to be safe and clean.
-
-function extractFailureLocation(logText) {
-    if (!logText) return null;
-    const loc = {
-        specFile: null,
-        testLine: null,
-        rootFile: null,
-        fullRootPath: null,
-        rootLine: null,
-        stepLine: null
-    };
-
-    const projectName = path.basename(process.cwd());
-
-    // Updated regex to be more flexible with arrows and spaces, and support .cy/.py files
-    const testMatch = logText.match(/^\s*\d+\)\s+\[.*?\]\s+.+?\s+(.*?\.(?:spec|cy|py)\.(?:ts|js|py)?):(\d+):(\d+)/m) ||
-        logText.match(/^(.*?\.py):(\d+):/m); // Pytest direct format
-
-    if (testMatch) {
-        loc.specFile = testMatch[1];
-        loc.testLine = testMatch[2];
-    }
-
-    // Stack Trace Regex - Modified to handle Cypress URLs, webpack paths, and Python "File" entries
-    const stackRegex = /at\s+(?:.*? \()?((?:https?:\/\/.*?\/|webpack:\/\/|[\/~\\]|\.?\.\/|[\w_\-]+\/).*?):(\d+):(\d+)\)?|File "(.+?)", line (\d+)/g;
-    let match;
-    let foundRoot = false;
-
-    while ((match = stackRegex.exec(logText)) !== null) {
-        let file = match[1] || match[4];
-        const line = match[2] || match[5];
-
-        if (!file) continue;
-
-        // Clean Cypress/Browser URLs to just the relative path if possible
-        if (file.includes('__cypress/runner')) continue;
-
-        if (file.includes('webpack:///')) {
-            file = file.split('webpack:///')[1];
-        } else if (file.includes('webpack://')) {
-            file = file.split('webpack://')[1];
-        }
-
-        // Strip project name if it's the first segment (common in Cypress/Webpack logs)
-        file = file.replace(/^\.\//, '');
-        if (file.startsWith(projectName + '/')) {
-            file = file.substring(projectName.length + 1);
-        }
-        file = file.replace(/^\.\//, '');
-
-        if (!foundRoot && !file.includes('node_modules') && !file.includes('cypress_runner') && !file.includes('python')) {
-            loc.rootFile = file.split(/[/\\\\]/).pop();
-            loc.fullRootPath = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file);
-            loc.rootLine = line;
-            foundRoot = true;
-        }
-
-        if (loc.specFile && file.endsWith(loc.specFile)) {
-            loc.stepLine = line;
-        }
-    }
-
-    // Fallback: If header regex failed but we found a root file that looks like a test
-    if (!loc.specFile && loc.rootFile && (loc.rootFile.includes('.spec.') || loc.rootFile.includes('.test.') || loc.rootFile.includes('.cy.') || loc.rootFile.endsWith('.py'))) {
-        loc.specFile = loc.rootFile;
-        loc.testLine = loc.rootLine;
-    }
-
-    if (loc.specFile || loc.rootFile) return loc;
-    return null;
-}
-
-// --- COLORS Moved to top ---
-
-function printDetailedFix(fixText, location, sourceCode = null, isApplied = false) {
-    let patches = [];
-    let explanation = null;
-
-    try {
-        // 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) {}
-        }
-
-        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) {
-        console.log(`${C.GREEN}${C.BRIGHT}✅ FIX APPLIED:${C.RESET}`);
-        if (location) {
-            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) {
-            console.log(`\n${C.BRIGHT}ℹ️  Reason:${C.RESET}  ${explanation}`);
-        }
-
-        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}`);
-        }
-    } else {
-        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()}`);
-        }
-    }
-}
-
-/**
- * Core analysis engine for batch mode.
- * Enforces tier limits and calculates deduplicated results.
- */
-async function runDoctor(argv) {
-    console.log(`\n${C.BRIGHT}👨‍⚕️ DeFlake Doctor - Diagnostic Tool${C.RESET}\n`);
-
-    // 1. Environment Info & Version Check
-    console.log(`${C.BRIGHT}Checking Environment:${C.RESET}`);
-    console.log(`  - DeFlake version: ${C.CYAN}${pkg.version}${C.RESET}`);
-
-    // Check for updates from npm
-    try {
-        const https = require('https');
-        const latestVersion = await new Promise((resolve, reject) => {
-            const req = https.get('https://registry.npmjs.org/deflake/latest', { timeout: 3000 }, (res) => {
-                let data = '';
-                res.on('data', chunk => data += chunk);
-                res.on('end', () => {
-                    try {
-                        resolve(JSON.parse(data).version);
-                    } catch (e) { resolve(null); }
-                });
+            const files = fs.readdirSync(dir, { recursive: true });
+            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 });
+                }
             });
-            req.on('error', () => resolve(null));
-            req.on('timeout', () => { req.destroy(); resolve(null); });
-        });
-
-        if (latestVersion && latestVersion !== pkg.version) {
-            // Compare versions
-            const current = pkg.version.split('.').map(Number);
-            const latest = latestVersion.split('.').map(Number);
-            const isOutdated = latest[0] > current[0] ||
-                (latest[0] === current[0] && latest[1] > current[1]) ||
-                (latest[0] === current[0] && latest[1] === current[1] && latest[2] > current[2]);
-
-            if (isOutdated) {
-                console.log(`  ⚠️  ${C.YELLOW}Update available: ${pkg.version} → ${latestVersion}${C.RESET}`);
-                console.log(`     ${C.GREEN}Run: npx deflake@${latestVersion} doctor${C.RESET}`);
-            }
-        }
-    } catch (e) {
-        // Silent failure - version check is optional
-    }
-
-    console.log(`  - Node.js version: ${C.CYAN}${process.version}${C.RESET}`);
-    console.log(`  - Platform:        ${C.CYAN}${process.platform}${C.RESET}\n`);
-
-    // 2. Framework Detection
-    console.log(`${C.BRIGHT}Detecting Frameworks:${C.RESET}`);
-    const activeFramework = DeFlakeClient.detectFramework();
+        } catch (e) {}
+    });
+    return results;
+}
 
-    if (activeFramework !== 'generic') {
-        const capitalized = activeFramework.charAt(0).toUpperCase() + activeFramework.slice(1);
-        console.log(`  ✅ Active:    ${C.GREEN}${C.BRIGHT}${capitalized}${C.RESET}`);
-    } else {
-        console.log(`  ⚠️  ${C.YELLOW}No supported frameworks detected in the current directory.${C.RESET}`);
-        console.log(`     (Checked for Playwright, Cypress, WebdriverIO, and Selenium Python files)`);
+async function analyzeAndFix(artifacts, client, argv) {
+    if (artifacts.length === 0) {
+        console.log(`  ${C.YELLOW}⚠️  No failure artifacts detected. Run 'npx deflake doctor' to check permissions.${C.RESET}`);
+        return 0;
     }
 
-    // 2b. Deep Structure Detection
-    const structures = [];
-    const checkDir = (dirs) => dirs.find(d => fs.existsSync(d) && fs.statSync(d).isDirectory());
+    console.log(`🔍 Analyzing ${artifacts.length} failure(s)...`);
+    let count = 0;
 
-    const pomDir = checkDir(['pages', 'page-objects', 'po']);
-    if (pomDir) structures.push(`${C.CYAN}POM${C.RESET} (${pomDir}/)`);
-
-    const utilsDir = checkDir(['utils', 'helpers', 'support/utils', 'tests/utils']);
-    if (utilsDir) structures.push(`${C.CYAN}Utils/Helpers${C.RESET} (${utilsDir}/)`);
-
-    const fixturesDir = checkDir(['fixtures', 'data', 'tests/fixtures', 'cypress/fixtures']);
-    if (fixturesDir) structures.push(`${C.CYAN}Fixtures${C.RESET} (${fixturesDir}/)`);
-
-    if (structures.length > 0) {
-        console.log(`  🔍 Structure: ${structures.join(', ')}`);
-        console.log(`     ${C.GRAY}(DeFlake will prioritize analyzing these folders for robust locator fixes)${C.RESET}`);
-    } else {
-        console.log(`  ⚠️  ${C.YELLOW}No standard PageObject or Utils folders detected.${C.RESET}`);
-        console.log(`     ${C.GRAY}(DeFlake works best when it can find your reusable locators in POM or Utils)${C.RESET}`);
-    }
-
-    if (fs.existsSync('package.json')) {
+    for (const art of artifacts) {
+        process.stdout.write(`⏳ Analyzing ${art.name}...`);
         try {
-            const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-            const detectedDeps = [];
-
-            // Core frameworks
-            if (deps['@playwright/test']) detectedDeps.push(`${C.CYAN}@playwright/test${C.RESET}`);
-            if (deps['cypress']) detectedDeps.push(`${C.CYAN}cypress${C.RESET}`);
-            if (deps['webdriverio'] || deps['@wdio/cli']) detectedDeps.push(`${C.CYAN}webdriverio${C.RESET}`);
-
-            // Common plugins
-            if (deps['dotenv']) detectedDeps.push('dotenv');
-            if (deps['typescript']) detectedDeps.push('typescript');
-
-            if (detectedDeps.length > 0) {
-                console.log(`  📦 Installed: ${detectedDeps.join(', ')}`);
+            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++;
+                }
+                process.stdout.write(`\r✅ Analysis complete for ${art.name}\n`);
+                printFix(res.fix, loc);
             }
         } catch (e) {
-            console.log(`  ❌ ${C.RED}Error reading package.json${C.RESET}`);
-        }
-    }
-    console.log("");
-
-    // 3. .env File Format Validation
-    console.log(`${C.BRIGHT}Checking .env Configuration:${C.RESET}`);
-    if (fs.existsSync('.env')) {
-        const envContent = fs.readFileSync('.env', 'utf8');
-        const lines = envContent.split('\n');
-        let hasIssues = false;
-
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) continue;
-
-            // Check for 'export' prefix (shell syntax, not .env syntax)
-            if (trimmed.startsWith('export ')) {
-                console.log(`  ❌ ${C.RED}Invalid format: 'export' prefix detected${C.RESET}`);
-                console.log(`     ${C.GRAY}Found:${C.RESET} ${trimmed.substring(0, 50)}...`);
-                console.log(`     ${C.GREEN}Fix:${C.RESET} Remove 'export ' - .env files use: KEY=value`);
-                hasIssues = true;
-            }
-
-            // Check for quoted values (can cause issues with some parsers)
-            if (trimmed.match(/^[A-Z_]+=["'].*["']$/)) {
-                console.log(`  ⚠️  ${C.YELLOW}Quotes detected in value (may cause issues)${C.RESET}`);
-                console.log(`     ${C.GRAY}Found:${C.RESET} ${trimmed.substring(0, 50)}...`);
-                console.log(`     ${C.GREEN}Tip:${C.RESET} Try without quotes: KEY=value`);
-                hasIssues = true;
-            }
+            console.log(`\n  ❌ ${C.RED}Error: ${e.message}${C.RESET}`);
         }
-
-        if (!hasIssues) {
-            console.log(`  ✅ .env file format looks correct`);
-        }
-    } else {
-        console.log(`  ⚠️  ${C.YELLOW}No .env file found in current directory${C.RESET}`);
-        console.log(`     Create one with: echo 'DEFLAKE_API_KEY=your_key' > .env`);
-    }
-    console.log("");
-
-    // 4. API Key Validation
-    console.log(`${C.BRIGHT}Validating API Key:${C.RESET}`);
-    const apiKey = process.env.DEFLAKE_API_KEY;
-    if (apiKey) {
-        const maskedKey = apiKey.substring(0, 4) + '*'.repeat(Math.max(0, apiKey.length - 8)) + apiKey.substring(apiKey.length - 4);
-        console.log(`  ✅ DEFLAKE_API_KEY found: ${C.GREEN}${maskedKey}${C.RESET}`);
-    } else {
-        console.log(`  ❌ ${C.RED}DEFLAKE_API_KEY is missing from your environment.${C.RESET}`);
-        console.log(`     Fix: Run 'export DEFLAKE_API_KEY=your_key' or add it to your .env file.`);
-    }
-    console.log("");
-
-    // 5. API Connectivity
-    console.log(`${C.BRIGHT}Checking Connectivity:${C.RESET}`);
-    const client = new DeFlakeClient(argv.apiUrl, apiKey);
-
-    try {
-        process.stdout.write(`  ⏳ Pinging DeFlake API... `);
-        const result = await client.getUsage();
-
-        if (result.status === 'success') {
-            const usage = result.data;
-            process.stdout.write(`\r  ✅ API Connected! (Tier: ${C.GREEN}${usage.tier.toUpperCase()}${C.RESET})                              \n`);
-            const u = usage;
-            const remaining = u.limit - u.usage;
-            console.log(`     Fix Quota:  ${C.GREEN}${remaining}/${u.limit} remaining${C.RESET}`);
-            console.log(`     Analysis:   ${C.GREEN}FREE${C.RESET} (Pay-per-fix model enabled)`);
-        } else {
-            process.stdout.write(`\r  ❌ ${C.RED}API Connectivity Failed${C.RESET}       \n`);
-            if (result.code === 401 || result.code === 403) {
-                console.log(`     Reason: API Key is invalid (Status ${result.code}).`);
-            } else {
-                console.log(`     Reason: ${result.message} (Code: ${result.code || 'UNKNOWN'})`);
-            }
-            console.log(`     API URL: ${client.apiUrl}`);
-        }
-    } catch (error) {
-        process.stdout.write(`\r  ❌ ${C.RED}API Connectivity Error: ${error.message}${C.RESET}\n`);
     }
-    console.log("");
-
-    console.log(`${C.BRIGHT}Summary:${C.RESET}`);
-    if (apiKey && activeFramework !== 'generic') {
-        console.log(`  ✨ ${C.GREEN}${C.BRIGHT}You are ready to use DeFlake!${C.RESET}`);
-    } else {
-        console.log(`  ⚠️  ${C.YELLOW}Please address the issues above to ensure DeFlake works correctly.${C.RESET}`);
-    }
-    console.log("\n" + C.GRAY + "─".repeat(50) + C.RESET + "\n");
+    return count;
 }
 
-async function applySelfHealing(result) {
-    if (!result.location || !result.location.fullRootPath || !result.fix) return;
-
+async function applyFix(res, loc) {
+    if (!loc?.path) return false;
     try {
-        const filePath = result.location.fullRootPath;
-        const targetLine = parseInt(result.location.rootLine);
-
-        if (!fs.existsSync(filePath)) {
-            console.error(`  ❌ [Self-Healing] File not found: ${filePath}`);
-            return;
-        }
-
-        let patches = [];
-        try {
-            const parsed = JSON.parse(result.fix);
-            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();
+        const patches = JSON.parse(res.fix).patches || [];
+        const original = fs.readFileSync(loc.path, 'utf8');
+        let content = original;
         
-        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;
-
-                // Create backup if not already done
-                if (!backups.has(pFile)) {
-                    backups.set(pFile, fs.readFileSync(pFile, 'utf8'));
+        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;
                 }
 
-                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;
-                }
-
-                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));
-                    }
+                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');
                 }
             }
-        } 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 in self-healing logic:${C.RESET} ${error.message}`);
-    }
-}
-
-/**
- * Automagically opens the framework's native HTML report.
- */
-function showFrameworkReport() {
-    const framework = DeFlakeClient.detectFramework();
-    console.log(`\n${C.CYAN}📊 Opening HTML Report for ${framework.toUpperCase()}...${C.RESET}`);
-
-    let command = '';
-    const opener = process.platform === 'win32' ? 'start' : 'open';
-
-    if (framework === 'playwright') {
-        // Playwright default report port is 9323. Try to close previous instance if on Mac/Linux
+        
+        fs.writeFileSync(loc.path, content);
+        
+        // 🧪 SMARTER SYNTAX CHECK
         try {
-            if (process.platform !== 'win32') {
-                const pid = require('child_process').execSync('lsof -t -i:9323').toString().trim();
-                if (pid) {
-                    require('child_process').execSync(`kill ${pid}`);
-                }
+            // 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");
             }
-        } catch (e) {}
-        command = 'npx playwright show-report';
-    } else if (framework === 'cypress') {
-        // Broad search for common Cypress HTML reports
-        const candidates = [
-            'cypress/reports/html/index.html',
-            'cypress/reports/index.html',
-            'mochawesome-report/mochawesome.html',
-            'reports/index.html'
-        ];
-
-        const found = candidates.find(p => fs.existsSync(p));
-        if (found) {
-            command = `${opener} ${found}`;
-        } else {
-            console.log(`${C.GRAY}ℹ️  Cypress HTML report not found. Verify your reporter configuration (e.g. mochawesome).${C.RESET}`);
-            console.log(`   ${C.GRAY}Looked in: ${candidates.join(', ')}${C.RESET}`);
-            return;
+            return true;
+        } catch(e) {
+            fs.writeFileSync(loc.path, original);
+            return false;
         }
-    } else if (framework === 'webdriverio') {
-        // WDIO usually uses Allure or spec-reporter
-        if (fs.existsSync('allure-results')) {
-            console.log(`   ${C.GRAY}Allure results detected. Attempting to serve...${C.RESET}`);
-            command = 'npx allure serve allure-results';
-        } else if (fs.existsSync('reports/html/index.html')) {
-            command = `${opener} reports/html/index.html`;
-        } else {
-            console.log(`${C.GRAY}ℹ️  WebdriverIO HTML report not found. If you use Allure, ensure allure-results folder exists.${C.RESET}`);
-            return;
-        }
-    }
-
-    if (command) {
-        // Use inherit if it's a server (like allure serve) or a long-running process
-        const isServer = command.includes('serve') || command.includes('show-report');
-        spawn(command, { shell: true, stdio: isServer ? 'inherit' : 'ignore' });
-    }
+    } catch(e) { return false; }
 }
 
-async function analyzeFailures(artifacts, fullLog, client) {
-    if (artifacts.length === 0) {
-        console.log("⚠️  No error artifacts found.");
-        return;
-    }
-
-    // 1. Check Quota / Tier
-    const result = await client.getUsage();
-    let limit = 100; // Default safety cap
-    let tier = 'unknown';
-
-    if (result.status === 'success') {
-        const usage = result.data;
-        tier = usage.tier || 'free';
-        if (tier === 'free') limit = 10;
-        else if (tier === 'pro') limit = 50;
-        else if (tier === 'master' || tier === 'byok') limit = 100;
-
-        console.log(`🎫 Subscription: ${tier.toUpperCase()} | Monthly Usage: ${usage.usage}/${usage.limit}`);
-    }
-
-    if (artifacts.length > limit) {
-        console.log(`${C.YELLOW}⚠️  Detected ${artifacts.length} failures, but your ${tier} plan limits batch analysis to ${limit} unique fixes.${C.RESET}`);
-        console.log(`   (Processing the first ${limit}...)\n`);
-    }
-
-    const framework = DeFlakeClient.detectFramework();
-    const results = [];
-    const processLimit = Math.min(artifacts.length, limit);
-    const batchArtifacts = artifacts.slice(0, processLimit);
-
-    console.log(`🔍 Analyzing ${batchArtifacts.length} failure(s)...`);
-
-    const playwrightBlocks = (framework === 'playwright') ? parsePlaywrightLogs(fullLog || "") : [];
-    const cypressBlocks = (framework === 'cypress') ? parseCypressLogs(fullLog || "") : [];
-    const pytestBlocks = (framework === 'selenium-python') ? parsePytestLogs(fullLog || "") : [];
-
-    for (const art of batchArtifacts) {
-        let specificLog = fullLog;
-
-        if (framework === 'cypress' && cypressBlocks.length > 0) {
-            const match = cypressBlocks.find(b => art.htmlPath && art.htmlPath.includes(b.spec));
-            if (match) specificLog = match.content;
-        } else if (framework === 'playwright' && playwrightBlocks.length > 0) {
-            // Heuristic matching for Playwright error blocks
-            let bestMatch = null;
-            let bestScore = -1;
-            const artifactTokens = art.name.toLowerCase().replace(/[-_]/g, ' ').split(' ').filter(w => w.length > 3);
-
-            for (const block of playwrightBlocks) {
-                let score = 0;
-                const blockLower = block.content.toLowerCase();
-                for (const token of artifactTokens) { if (blockLower.includes(token)) score++; }
-                if (score > bestScore) { bestScore = score; bestMatch = block; }
-            }
-            if (bestMatch && bestScore > 0) {
-                specificLog = bestMatch.content;
-            }
-        } else if (framework === 'selenium-python' && pytestBlocks.length > 0) {
-            // Match pytest block by test name heuristic
-            const match = pytestBlocks.find(b => art.name && b.name.includes(art.name.replace('.png', '')));
-            if (match) specificLog = match.content;
-        }
-
-        const displayName = (art.name || 'Unknown Artifact').substring(0, 40);
-        process.stdout.write(`\r⏳ Analyzing ${displayName}...          `);
-
-        try {
-            const result = await runHealer(specificLog, art.htmlPath, argv.apiUrl, art.name, argv.fix);
-
-            if (result && result.status === 'success') {
-                results.push(result);
-            } else {
-                console.log(`\n  ${C.RED}❌ Analysis failed for ${displayName}:${C.RESET} ${result?.detail || 'Check server status'}`);
-            }
-        } catch (err) {
-            console.log(`\n  ${C.RED}❌ Error analyzing ${displayName}:${C.RESET} ${err.message}`);
-        }
-    }
-    console.log("\r✅ Analysis complete.                        ");
-
-    // GROUPING & PRINTING
-    const groups = {};
-    for (const res of results) {
-        let fixCode = res.fix;
-        try {
-            const p = JSON.parse(res.fix);
-            if (p.code) fixCode = p.code;
-        } catch (e) { }
-
-        const locId = res.location ? `${res.location.rootFile}:${res.location.rootLine}` : `unknown-${res.testName}`;
-        const key = `${locId}|${fixCode.trim()}`;
-
-        if (!groups[key]) {
-            groups[key] = { ...res, count: 0, locations: [] };
-        }
-        groups[key].count++;
-        if (res.location) {
-            groups[key].locations.push(res.location);
-        }
-    }
-
-    const finalGroups = Object.values(groups);
-    for (const group of finalGroups) {
-        if (group.count > 1) {
-            console.log(`${C.GRAY}ℹ️  Suggested for ${group.count} similar failures:${C.RESET}`);
-        }
-
-        // APPLY FIX (To all instances in the group)
-        if (argv.fix) {
-            for (const loc of group.locations) {
-                await applySelfHealing({ ...group, location: loc });
-            }
-        }
-
-        printDetailedFix(group.fix, group.location, group.source_code, argv.fix);
-    }
-
-    // SUMMARY
-    console.log(`\n${C.BRIGHT}📊 DeFlake Summary:${C.RESET}`);
-    console.log(`  - Failures analyzed: ${batchArtifacts.length}`);
-    console.log(`  - Fixes suggested:   ${results.length}`);
-
-    try {
-        // Fetch updated usage for clearer reporting
-        const updatedUsage = await client.getUsage();
-        if (updatedUsage.status === 'success') {
-            const u = updatedUsage.data;
-            const remaining = u.limit - u.usage;
-            console.log(`  - Fix Quota:         ${C.GREEN}${remaining}/${u.limit} remaining (Analysis is FREE)${C.RESET}`);
-        }
-    } catch (e) {
-        // usage fetch failed is non-critical
-    }
-
-    if (results.length === 0) {
-        console.log(`${C.GRAY}ℹ️  DeFlake analyzed the logs but couldn't find a confident fix for these errors.${C.RESET}`);
-        if (!fullLog) {
-            console.log(`${C.YELLOW}⚠️  Tip: Ensure your test runner output is being captured correctly.${C.RESET}`);
-        }
-    } else if (!argv.fix) {
-        console.log(`\n${C.BRIGHT}💡 Tip: Use ${C.CYAN}--fix${C.RESET}${C.BRIGHT} to automatically apply these suggested fixes next time.${C.RESET}`);
-    }
-
-
-    return results.length;
+function extractLoc(text) {
+    const m = text.match(/at\s+(.*?\.ts):(\d+):(\d+)/);
+    return m ? { path: path.resolve(m[1]), line: m[2] } : null;
 }
 
-/**
- * Helper to run a shell command and capture output.
- */
-async function runCommand(cmd, args) {
-    return new Promise((resolve) => {
-        console.log(`🚀 Running command: ${cmd} ${args.join(' ')}`);
-        const child = spawn(cmd, args, { shell: true, stdio: 'pipe' });
-        let stdout = '';
-        let stderr = '';
-
-        child.stdout.on('data', (data) => { process.stdout.write(data); stdout += data.toString(); });
-        child.stderr.on('data', (data) => { process.stderr.write(data); stderr += data.toString(); });
-
-        child.on('close', (code) => {
-            resolve({ code, output: stdout + "\n" + stderr });
-        });
-    });
+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) {}
 }
 
-async function main() {
-    const command = argv._ || [];
-    let finalExitCode = 0;
+async function runDoctor() {
+    console.log(`\n👨‍⚕️  ${C.BRIGHT}DeFlake Doctor - Diagnostic Tool${C.RESET}\n`);
+    const dirs = ['test-results', 'playwright-report'];
+    let error = false;
 
-    // If 'doctor' or 'migrate' was called, don't proceed to wrapper logic
-    if (command.includes('doctor') || command.includes('migrate')) return;
-
-    console.log(`🚑 DeFlake JS Client (Batch Mode) - ${C.CYAN}v${pkg.version}${C.RESET}`);
-    const client = new DeFlakeClient(argv.apiUrl);
-    const fw = client.framework.charAt(0).toUpperCase() + client.framework.slice(1);
-    console.log(`🔍 Detected Framework: ${C.GREEN}${fw}${C.RESET}`);
-
-    if (command.length > 0) {
-        const cmd = command[0];
-        const args = command.slice(1);
-        
-        let { code, output } = await runCommand(cmd, args);
-
-        if (code !== 0) {
-            console.log(`\n🔴 Command failed with code ${code}. Activating DeFlake...`);
-            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}`);
+    for (const d of dirs) {
+        if (!fs.existsSync(d)) continue;
+        process.stdout.write(`  Checking ${d.padEnd(20)}... `);
+        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)));
                 }
-            }
-            finalExitCode = outcomeCode;
-        } else {
-            console.log("\n🟢 Command passed successfully.");
-            finalExitCode = 0;
+            };
+            checkDeep(d);
+            console.log(`${C.GREEN}Healthy${C.RESET}`);
+        } catch (e) {
+            console.log(`${C.RED}Access Denied${C.RESET}`);
+            error = true;
         }
-    } else {
-        const artifacts = detectAllArtifacts(argv.log, argv.html);
-        const fullLog = argv.log && fs.existsSync(argv.log) ? fs.readFileSync(argv.log, 'utf8') : null;
-        await analyzeFailures(artifacts, fullLog, client);
     }
 
-    // FINAL REPORT TRIGGER
-    if (argv.report) {
-        showFrameworkReport();
+    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}`);
+    } else {
+        console.log(`\n  ✨ ${C.GREEN}All checks passed. System is ready.${C.RESET}`);
     }
-
-    process.exit(finalExitCode);
 }
 
-// main() call is now handled by the check above
+function showReport() {
+    spawn('npx playwright show-report', { shell: true, stdio: 'inherit' }).on('error', () => {});
+}

package/package.json

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