deflake 1.0.8 → 1.0.12

package/README.md

@@ -12,24 +12,47 @@ npm install deflake --save-dev
 ## 🔧 Usage
 
 ### Wrapper Mode (Zero Config)
-Simply prepend `npx deflake` to your test run command:
+Simply prepend `npx deflake` to your test run command. DeFlake will automatically wrap the execution and analyze failures.
 
 ```bash
 # Playwright
-export DEFLAKE_API_KEY="your-api-key"
 npx deflake npx playwright test
 
 # Cypress
 npx deflake npx cypress run
 ```
 
+### 🚑 Diagnostics (Doctor Mode)
+Validate your environment, API key, and quota without running tests:
+
+```bash
+npx deflake doctor
+```
+
 ### Manual Mode
-Analyze an existing error log and HTML snapshot:
+Analyze an existing error log and HTML/Image snapshot:
+
+```bash
+npx deflake --log error.log --html cypress/screenshots/my-test-failure.png
+```
+
+## 🌲 Cypress Integration Tips
+
+For the best experience with Cypress, we recommend adding a standardized script to your `package.json`:
 
+```json
+"scripts": {
+  "test:deflake": "deflake npx cypress run"
+}
+```
+
+Then run it using:
 ```bash
-npx deflake --log error.log --html playwright-report/index.html
+npm run test:deflake
 ```
 
+DeFlake automatically scans `cypress/screenshots` to find failure artifacts (images) for analysis.
+
 ## 📄 Support & Documentation
 
 For issues, feature requests, or to get your API key, please visit our [Official Portal](https://deflake-api.up.railway.app).

package/cli.js

@@ -125,6 +125,22 @@ function detectAllArtifacts(providedLog, providedHtml) {
         }
     }
 
+    // 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')) {
@@ -272,33 +288,56 @@ function extractFailureLocation(logText) {
         stepLine: null
     };
 
-    // Updated regex to be more flexible with arrows and spaces
-    const testMatch = logText.match(/^\s*\d+\)\s+\[.*?\]\s+.+?\s+(.*?.spec.ts):(\d+):(\d+)/m);
+    const projectName = path.basename(process.cwd());
+
+    // Updated regex to be more flexible with arrows and spaces, and support .cy files
+    const testMatch = logText.match(/^\s*\d+\)\s+\[.*?\]\s+.+?\s+(.*?\.(?:spec|cy)\.(?:ts|js)):(\d+):(\d+)/m);
     if (testMatch) {
         loc.specFile = testMatch[1];
         loc.testLine = testMatch[2];
     }
 
-    const stackRegex = /at\s+(?:.*? \()?((?:[a-zA-Z]:\\|[\/~]|\.?\.\/|[\w_\-]+\/).*?):(\d+):(\d+)\)?/g;
+    // Stack Trace Regex - Modified to handle Cypress URLs and webpack paths
+    const stackRegex = /at\s+(?:.*? \()?((?:https?:\/\/.*?\/|webpack:\/\/|[\/~\\]|\.?\.\/|[\w_\-]+\/).*?):(\d+):(\d+)\)?/g;
     let match;
     let foundRoot = false;
 
     while ((match = stackRegex.exec(logText)) !== null) {
-        const file = match[1];
+        let file = match[1];
         const line = match[2];
-        if (!foundRoot && !file.includes('node_modules')) {
-            loc.rootFile = file.split('/').pop();
-            loc.fullRootPath = path.resolve(process.cwd(), file);
+
+        // 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)
+        // e.g. "cypress-poc/cypress/e2e/api/auth.api.cy.ts" -> "cypress/e2e/api/auth.api.cy.ts"
+        // Also handle "./" prefix before project name
+        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')) {
+            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.'))) {
+    if (!loc.specFile && loc.rootFile && (loc.rootFile.includes('.spec.') || loc.rootFile.includes('.test.') || loc.rootFile.includes('.cy.'))) {
         loc.specFile = loc.rootFile;
         loc.testLine = loc.rootLine;
     }
@@ -307,18 +346,20 @@ function extractFailureLocation(logText) {
     return null;
 }
 
+// --- COLORS ---
+const C = {
+    RESET: "\x1b[0m",
+    BRIGHT: "\x1b[1m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+    CYAN: "\x1b[36m",
+    BLUE: "\x1b[34m",
+    GRAY: "\x1b[90m",
+    WHITE: "\x1b[37m"
+};
+
 function printDetailedFix(fixText, location, sourceCode = null, isApplied = false) {
-    const C = {
-        RESET: "\x1b[0m",
-        BRIGHT: "\x1b[1m",
-        RED: "\x1b[31m",
-        GREEN: "\x1b[32m",
-        YELLOW: "\x1b[33m",
-        CYAN: "\x1b[36m",
-        BLUE: "\x1b[34m",
-        GRAY: "\x1b[90m",
-        WHITE: "\x1b[37m"
-    };
 
     let fixCode = fixText;
     let explanation = null;
@@ -419,16 +460,6 @@ function printDetailedFix(fixText, location, sourceCode = null, isApplied = fals
  * 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 & Version Check
@@ -577,15 +608,23 @@ async function runDoctor(argv) {
     // 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) {
+        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`);
+            console.log(`     Quota: ${usage.usage}/${usage.limit}`);
         } else {
-            process.stdout.write(`\r  ❌ ${C.RED}API Connectivity Failed (Invalid Key or Server Timeout)${C.RESET}       \n`);
+            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`);
@@ -648,24 +687,18 @@ async function applySelfHealing(result) {
 }
 
 async function analyzeFailures(artifacts, fullLog, client) {
-    const C = {
-        RESET: "\x1b[0m",
-        YELLOW: "\x1b[33m",
-        RED: "\x1b[31m",
-        GRAY: "\x1b[90m"
-    };
-
     if (artifacts.length === 0) {
         console.log("⚠️  No error artifacts found.");
         return;
     }
 
     // 1. Check Quota / Tier
-    const usage = await client.getUsage();
+    const result = await client.getUsage();
     let limit = 100; // Default safety cap
     let tier = 'unknown';
 
-    if (usage) {
+    if (result.status === 'success') {
+        const usage = result.data;
         tier = usage.tier || 'free';
         if (tier === 'free') limit = 5;
         else if (tier === 'pro') limit = 50;
@@ -708,21 +741,27 @@ async function analyzeFailures(artifacts, fullLog, client) {
             }
         }
 
-        process.stdout.write(`\r⏳ Analyzing ${art.name}...        `);
-        const result = await runHealer(specificLog, art.htmlPath, argv.apiUrl, art.name);
+        const displayName = (art.name || 'Unknown Artifact').substring(0, 40);
+        process.stdout.write(`\r⏳ Analyzing ${displayName}...          `);
 
-        if (result && result.status === 'success') {
-            results.push(result);
+        try {
+            const result = await runHealer(specificLog, art.htmlPath, argv.apiUrl, art.name);
+
+            if (result && result.status === 'success') {
+                results.push(result);
 
-            // If --fix is enabled, apply it immediately for ALL tiers
-            if (argv.fix) {
-                await applySelfHealing(result);
+                // If --fix is enabled, apply it immediately for ALL tiers
+                if (argv.fix) {
+                    await applySelfHealing(result);
+                }
+            } else {
+                console.log(`\n  ${C.RED}❌ Analysis failed for ${displayName}:${C.RESET} ${result?.detail || 'Check server status'}`);
             }
-        } else {
-            console.log(`\n  ${C.RED}❌ Analysis failed for ${art.name}:${C.RESET} ${result?.detail || 'Check server status'}`);
+        } catch (err) {
+            console.log(`\n  ${C.RED}❌ Error analyzing ${displayName}:${C.RESET} ${err.message}`);
         }
     }
-    process.stdout.write("\r✅ Analysis complete.                        \n");
+    console.log("\r✅ Analysis complete.                        ");
 
     // GROUPING & PRINTING
     const groups = {};
@@ -736,20 +775,38 @@ async function analyzeFailures(artifacts, fullLog, client) {
         groups[key].tests.push(res.testName);
     }
 
-    const sortedKeys = Object.keys(groups).sort((a, b) => {
-        const lineA = parseInt(groups[a].location?.rootLine) || 0;
-        const lineB = parseInt(groups[b].location?.rootLine) || 0;
-        return lineA - lineB;
-    });
+    const sortedKeys = Object.keys(groups);
 
-    for (const key of sortedKeys) {
-        printDetailedFix(groups[key].fix, groups[key].location, groups[key].sourceCode, argv.fix);
+    if (sortedKeys.length > 0) {
+        for (const key of sortedKeys) {
+            printDetailedFix(groups[key].fix, groups[key].location, groups[key].sourceCode, argv.fix);
+        }
     }
 
-    if (results.length > 0 && sortedKeys.length === 0) {
-        console.log(`${C.YELLOW}⚠️  Note: Some suggestions were found but could not be grouped for display.${C.RESET}`);
-    } else if (results.length === 0) {
+    // 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(`  - Quota remaining:   ${C.GREEN}${remaining}/${u.limit}${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}`);
     }
 }
 

package/client.js

@@ -11,6 +11,7 @@ class DeFlakeClient {
         this.apiUrl = apiUrl || process.env.DEFLAKE_API_URL || this.productionUrl;
         this.apiKey = apiKey || process.env.DEFLAKE_API_KEY;
         this.projectName = this.detectProjectName();
+        this.framework = this.detectFramework();
 
         if (!this.apiKey) {
             // We no longer exit here to allow diagnostic tools (like 'doctor') to run.
@@ -39,23 +40,37 @@ class DeFlakeClient {
         }
     }
 
+    detectFramework() {
+        // 1. Manual override via environment variable
+        if (process.env.DEFLAKE_FRAMEWORK) return process.env.DEFLAKE_FRAMEWORK.toLowerCase();
+
+        // 2. Automated detection via configuration files
+        if (fs.existsSync('cypress.config.js') || fs.existsSync('cypress.config.ts') || fs.existsSync('cypress')) return 'cypress';
+        if (fs.existsSync('playwright.config.js') || fs.existsSync('playwright.config.ts')) return 'playwright';
+        if (fs.existsSync('wdio.conf.js') || fs.existsSync('wdio.conf.ts')) return 'webdriverio';
+        return 'generic';
+    }
+
     async getUsage() {
         try {
-            // Replace /api/deflake with /api/user/usage to avoid matching domain name
-            const usageUrl = this.apiUrl.replace('/api/deflake', '/api/user/usage');
+            // Robust replacement to avoid mangling host or protocol
+            const usageUrl = this.apiUrl.replace(/\/deflake$/, '/user/usage');
             const response = await axios.get(usageUrl, {
                 headers: {
                     'X-API-KEY': this.apiKey,
                     'X-Project-Name': this.projectName
                 }
             });
-            return response.data;
+            return { status: 'success', data: 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);
+            let message = error.message;
+            let code = error.code;
+            if (error.response) {
+                code = error.response.status;
+                message = error.response.data?.detail || error.response.statusText;
+                if (typeof message === 'object') message = JSON.stringify(message);
             }
-            return null; // Silent failure for usage check
+            return { status: 'error', message, code };
         }
     }
 
@@ -66,13 +81,25 @@ class DeFlakeClient {
             if (!fs.existsSync(htmlPath)) throw new Error(`HTML file not found: ${htmlPath}`);
 
             const logContent = fs.readFileSync(logPath, 'utf8');
-            const htmlContent = fs.readFileSync(htmlPath, 'utf8');
+
+            // Handle binary artifacts (Screenshots) vs Text artifacts (HTML/MD)
+            const isImage = htmlPath.toLowerCase().endsWith('.png');
+            let htmlContent = '';
+
+            if (isImage) {
+                // Read as base64 for screenshots
+                htmlContent = fs.readFileSync(htmlPath, 'base64');
+            } else {
+                // Read as utf-8 for HTML/MD
+                htmlContent = fs.readFileSync(htmlPath, 'utf8');
+            }
 
             const payload = {
                 error_log: logContent || "",
                 html_snapshot: htmlContent || "",
                 failing_line: failureLocation ? `Line ${failureLocation.rootLine}` : "",
-                source_code: sourceCode || ""
+                source_code: sourceCode || "",
+                framework: this.framework
             };
 
             const response = await axios.post(this.apiUrl, payload, {

package/package.json

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

package/test_location_parser.js

@@ -0,0 +1,132 @@
+const path = require('path');
+const fs = require('fs');
+
+// Mocking dependencies to test the function in isolation
+const process_cwd = () => '/Users/hugo/Documents/cypress-poc';
+const path_resolve = (...args) => path.join(...args);
+const path_isAbsolute = (p) => path.isAbsolute(p);
+
+// Import the function from cli.js
+// Since it's a script with side effects, we'll extract just the function or require it carefully.
+// To keep it simple, I'll copy the function here for unit test, but use the real dependencies.
+
+function extractFailureLocation(logText, cwd = '/Users/hugo/Documents/cypress-poc') {
+    if (!logText) return null;
+    const loc = {
+        specFile: null,
+        testLine: null,
+        rootFile: null,
+        fullRootPath: null,
+        rootLine: null,
+        stepLine: null
+    };
+
+    const projectName = path.basename(cwd);
+
+    // Updated regex to be more flexible with arrows and spaces, and support .cy files
+    const testMatch = logText.match(/^\s*\d+\)\s+\[.*?\]\s+.+?\s+(.*?\.(?:spec|cy)\.(?:ts|js)):(\d+):(\d+)/m);
+    if (testMatch) {
+        loc.specFile = testMatch[1];
+        loc.testLine = testMatch[2];
+    }
+
+    // Stack Trace Regex - Modified to handle Cypress URLs and webpack paths
+    const stackRegex = /at\s+(?:.*? \()?((?:https?:\/\/.*?\/|webpack:\/\/\/|[\/~\\]|\.?\.\/|[\w_\-]+\/).*?):(\d+):(\d+)\)?/g;
+    let match;
+    let foundRoot = false;
+
+    while ((match = stackRegex.exec(logText)) !== null) {
+        let file = match[1];
+        const line = match[2];
+
+        // 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)
+        if (file.startsWith(projectName + '/')) {
+            file = file.substring(projectName.length + 1);
+        } else if (file.startsWith('./' + projectName + '/')) {
+            file = file.substring(projectName.length + 3);
+        }
+
+        file = file.replace(/^\.\//, '');
+
+        if (!foundRoot && !file.includes('node_modules') && !file.includes('cypress_runner')) {
+            loc.rootFile = file.split(/[/\\]/).pop();
+            loc.fullRootPath = path.isAbsolute(file) ? file : path.resolve(cwd, file);
+            loc.rootLine = line;
+            foundRoot = true;
+        }
+
+        if (loc.specFile && (file.endsWith(loc.specFile) || file === 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.specFile = loc.rootFile;
+        loc.testLine = loc.rootLine;
+    }
+
+    if (loc.specFile || loc.rootFile) return loc;
+    return null;
+}
+
+// TEST CASES
+const testLogs = [
+    {
+        name: "Cypress Webpack Trace",
+        log: `API - Reqres
+    1) authenticates and returns token
+  From Your Spec Code:
+      at AuthClient.login (webpack://cypress-poc/./api/clients/AuthClient.ts:17:14)
+      at Context.eval (webpack://cypress-poc/./cypress/e2e/api/auth.api.cy.ts:12:15)`,
+        expected: {
+            rootFile: 'AuthClient.ts',
+            fullRootPath: '/Users/hugo/Documents/cypress-poc/api/clients/AuthClient.ts',
+            rootLine: '17'
+        }
+    },
+    {
+        name: "Cypress Negative Scenario",
+        log: `  1) API - Reqres negative scenarios
+       returns 400 when password is missing:
+
+      AssertionError: expected 403 to equal 400
+      at Context.eval (webpack://cypress-poc/./cypress/e2e/api/auth.negative.api.cy.ts:11:33)`,
+        expected: {
+            rootFile: 'auth.negative.api.cy.ts',
+            fullRootPath: '/Users/hugo/Documents/cypress-poc/cypress/e2e/api/auth.negative.api.cy.ts',
+            rootLine: '11'
+        }
+    }
+];
+
+console.log("🧪 Running DeFlake Path Parsing Tests...\n");
+let passed = 0;
+testLogs.forEach(t => {
+    const result = extractFailureLocation(t.log);
+    console.log(`Test: ${t.name}`);
+    let success = true;
+    for (const key in t.expected) {
+        if (result[key] !== t.expected[key]) {
+            console.log(`  ❌ FAIL: ${key} expected "${t.expected[key]}", got "${result[key]}"`);
+            success = false;
+        }
+    }
+    if (success) {
+        console.log(`  ✅ PASS`);
+        passed++;
+    }
+    console.log("");
+});
+
+console.log(`Summary: ${passed}/${testLogs.length} tests passed.`);
+if (passed < testLogs.length) process.exit(1);