deflake 1.0.1 → 1.0.4

package/cli.js

@@ -5,26 +5,57 @@ const DeFlakeClient = require('./client');
 const { spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const pkg = require('./package.json');
+
+// --- 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(() => process.exit(1));
+    return; // Safety for some environments
+}
+// ------------------------------------------
 
-const argv = yargs(hideBin(process.argv))
+const parser = yargs(hideBin(process.argv))
     .option('log', {
         alias: 'l',
         type: 'string',
         description: 'Path to the error log file',
-        demandOption: false // No longer strictly required if running in wrapper mode
+        demandOption: false
     })
     .option('html', {
         alias: 'h',
         type: 'string',
         description: 'Path to the HTML snapshot',
-        demandOption: false // No longer strictly required if auto-detected
+        demandOption: false
     })
     .option('api-url', {
         type: 'string',
         description: 'Override Default API URL',
     })
-    .help()
-    .argv;
+    .option('fix', {
+        type: 'boolean',
+        description: 'Automatically apply suggested fixes',
+        default: false
+    })
+    .option('doctor', {
+        type: 'boolean',
+        description: 'Diagnose your DeFlake installation',
+        default: false
+    })
+    .command('doctor', 'Diagnose your DeFlake installation', {}, (argv) => {
+        runDoctor(argv).then(() => process.exit(0));
+    })
+    .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) {
@@ -333,6 +364,200 @@ function printDetailedFix(fixText, location, sourceCode = null) {
  * Core analysis engine for batch mode.
  * Enforces tier limits and calculates deduplicated results.
  */
+async function runDoctor(argv) {
+    const C = {
+        RESET: "\x1b[0m",
+        BRIGHT: "\x1b[1m",
+        GREEN: "\x1b[32m",
+        YELLOW: "\x1b[33m",
+        RED: "\x1b[31m",
+        CYAN: "\x1b[36m",
+        GRAY: "\x1b[90m"
+    };
+
+    console.log(`\n${C.BRIGHT}👨‍⚕️ DeFlake Doctor - Diagnostic Tool${C.RESET}\n`);
+
+    // 1. Environment Info
+    console.log(`${C.BRIGHT}Checking Environment:${C.RESET}`);
+    console.log(`  - DeFlake version: ${C.CYAN}${pkg.version}${C.RESET}`);
+    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 frameworks = [];
+    if (fs.existsSync('playwright.config.ts') || fs.existsSync('playwright.config.js')) frameworks.push('Playwright');
+    if (fs.existsSync('cypress.config.ts') || fs.existsSync('cypress.config.js') || fs.existsSync('cypress.json')) frameworks.push('Cypress');
+    if (fs.existsSync('wdio.conf.ts') || fs.existsSync('wdio.conf.js')) frameworks.push('WebdriverIO');
+
+    if (frameworks.length > 0) {
+        console.log(`  ✅ Found: ${C.GREEN}${frameworks.join(', ')}${C.RESET}`);
+    } else {
+        console.log(`  ⚠️  ${C.YELLOW}No supported frameworks detected in the current directory.${C.RESET}`);
+        console.log(`     (Checked for Playwright, Cypress, WebdriverIO files)`);
+    }
+
+    // 2b. Deep Structure Detection
+    const structures = [];
+    const checkDir = (dirs) => dirs.find(d => fs.existsSync(d) && fs.statSync(d).isDirectory());
+
+    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')) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            const detectedDeps = [];
+            if (deps['@playwright/test']) detectedDeps.push('@playwright/test');
+            if (deps['cypress']) detectedDeps.push('cypress');
+            if (deps['webdriverio']) detectedDeps.push('webdriverio');
+
+            if (detectedDeps.length > 0) {
+                console.log(`  ✅ Installed: ${C.GREEN}${detectedDeps.join(', ')}${C.RESET}`);
+            }
+        } 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;
+            }
+        }
+
+        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);
+    // Debug: Show what the client is using
+    console.log(`  ${C.GRAY}(URL: ${client.apiUrl}, Key length: ${client.apiKey ? client.apiKey.length : 0})${C.RESET}`);
+    try {
+        process.stdout.write(`  ⏳ Pinging DeFlake API... `);
+        const usage = await client.getUsage();
+        if (usage) {
+            process.stdout.write(`\r  ✅ API Connected! (Tier: ${C.GREEN}${usage.tier.toUpperCase()}${C.RESET})                              \n`);
+        } else {
+            process.stdout.write(`\r  ❌ ${C.RED}API Connectivity Failed (Invalid Key or Server Timeout)${C.RESET}       \n`);
+        }
+    } 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 && frameworks.length > 0) {
+        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");
+}
+
+async function applySelfHealing(result) {
+    const C = {
+        RESET: "\x1b[0m",
+        GREEN: "\x1b[32m",
+        RED: "\x1b[31m",
+        GRAY: "\x1b[90m"
+    };
+
+    if (!result.location || !result.location.fullRootPath || !result.fix) return;
+
+    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 fixCode = result.fix;
+        try {
+            const parsed = JSON.parse(result.fix);
+            if (parsed.code) fixCode = parsed.code;
+        } catch (e) { }
+
+        const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+        const originalLineIndex = targetLine - 1;
+
+        if (originalLineIndex < 0 || originalLineIndex >= lines.length) {
+            console.error(`  ❌ [Self-Healing] Line ${targetLine} out of bounds in ${filePath}`);
+            return;
+        }
+
+        // Apply fix: Replace the entire line or the specific locator
+        // For robustness, we replace the whole line but keep indentation
+        const originalLine = lines[originalLineIndex];
+        const indentation = originalLine.match(/^\s*/)[0];
+        lines[originalLineIndex] = indentation + fixCode.trim();
+
+        fs.writeFileSync(filePath, lines.join('\n'));
+        console.log(`  ✅ ${C.GREEN}[Self-Healing] Successfully patched:${C.RESET} ${path.basename(filePath)}:${targetLine}`);
+    } catch (error) {
+        console.error(`  ❌ ${C.RED}[Self-Healing] Error patching file:${C.RESET} ${error.message}`);
+    }
+}
+
 async function analyzeFailures(artifacts, fullLog, client) {
     const C = {
         RESET: "\x1b[0m",
@@ -404,6 +629,11 @@ async function analyzeFailures(artifacts, fullLog, client) {
 
         if (result && result.status === 'success') {
             results.push(result);
+
+            // If --fix is enabled, apply it immediately for ALL tiers
+            if (argv.fix) {
+                await applySelfHealing(result);
+            }
         }
     }
     console.log("\r✅ Analysis complete.                        \n");
@@ -431,9 +661,13 @@ async function analyzeFailures(artifacts, fullLog, client) {
 }
 
 async function main() {
+    const command = argv._;
+
+    // If 'doctor' was called, don't proceed to wrapper logic
+    if (command.includes('doctor')) return;
+
     console.log("🚑 DeFlake JS Client (Batch Mode)");
     const client = new DeFlakeClient(argv.apiUrl);
-    const command = argv._;
 
     if (command.length > 0) {
         const cmd = command[0];
@@ -465,4 +699,4 @@ async function main() {
     }
 }
 
-main();
+// main() call is now handled by the check above

package/client.js

@@ -10,23 +10,51 @@ class DeFlakeClient {
         this.productionUrl = 'https://deflake-api.up.railway.app/api/deflake';
         this.apiUrl = apiUrl || process.env.DEFLAKE_API_URL || this.productionUrl;
         this.apiKey = apiKey || process.env.DEFLAKE_API_KEY;
+        this.projectName = this.detectProjectName();
 
         if (!this.apiKey) {
-            console.error("❌ DeFlake Error: DEFLAKE_API_KEY is missing.");
-            console.error("   To get a free key, visit: http://deflake.com/register");
-            console.error("   Or set it in your environment: export DEFLAKE_API_KEY=your_key");
-            process.exit(1);
+            // We no longer exit here to allow diagnostic tools (like 'doctor') to run.
+            // Validation will happen when an actual API call is attempted.
+        }
+    }
+
+    detectProjectName() {
+        try {
+            // 1. Try package.json
+            if (fs.existsSync('package.json')) {
+                const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+                if (pkg.name) return pkg.name;
+            }
+            // 2. Try git remote
+            const { execSync } = require('child_process');
+            try {
+                const remote = execSync('git remote get-url origin', { stdio: 'pipe' }).toString().trim();
+                const basename = path.basename(remote, '.git');
+                if (basename) return basename;
+            } catch (e) { }
+            // 3. Fallback to folder name
+            return path.basename(process.cwd());
+        } catch (e) {
+            return 'unknown-project';
         }
     }
 
     async getUsage() {
         try {
-            const usageUrl = this.apiUrl.replace('/deflake', '/user/usage');
+            // Replace /api/deflake with /api/user/usage to avoid matching domain name
+            const usageUrl = this.apiUrl.replace('/api/deflake', '/api/user/usage');
             const response = await axios.get(usageUrl, {
-                headers: { 'X-API-KEY': this.apiKey }
+                headers: {
+                    'X-API-KEY': this.apiKey,
+                    'X-Project-Name': this.projectName
+                }
             });
             return response.data;
         } catch (error) {
+            // Log error details for debugging (only in doctor mode, based on env var)
+            if (process.env.DEFLAKE_DEBUG) {
+                console.error('getUsage error:', error.response?.status, error.response?.data || error.message);
+            }
             return null; // Silent failure for usage check
         }
     }
@@ -50,7 +78,8 @@ class DeFlakeClient {
             const response = await axios.post(this.apiUrl, payload, {
                 headers: {
                     'Content-Type': 'application/json',
-                    'X-API-KEY': this.apiKey
+                    'X-API-KEY': this.apiKey,
+                    'X-Project-Name': this.projectName
                 }
             });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deflake",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "AI-powered self-healing tool for Playwright, Cypress, and WebdriverIO tests.",
   "main": "client.js",
   "bin": {
@@ -34,4 +34,4 @@
     "dotenv": "^17.2.3",
     "yargs": "^18.0.0"
   }
-}
+}