deflake 1.0.8 → 1.0.10

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,44 @@ 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);
+    // 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; // Skip internal runner files
+        if (file.includes('webpack:///')) {
+            file = file.split('webpack:///')[1].replace(/^\.\//, '');
+        } else if (file.includes('webpack://')) {
+            file = file.split('webpack://')[1].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;
     }
@@ -577,15 +604,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`);
@@ -661,11 +696,12 @@ async function analyzeFailures(artifacts, fullLog, client) {
     }
 
     // 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;
@@ -736,20 +772,24 @@ 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📊 DeFlake Summary:`);
+    console.log(`  - Failures analyzed: ${batchArtifacts.length}`);
+    console.log(`  - Fixes suggested:   ${results.length}`);
+
+    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}`);
+        }
     }
 }
 

package/client.js

@@ -41,21 +41,24 @@ class DeFlakeClient {
 
     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 };
         }
     }
 

package/package.json

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