qazen-cli 0.1.8 → 0.2.0

package/dist/commands/visionScout.js

@@ -114,8 +114,10 @@ export async function visionScoutCommand(options) {
         await uploadVisionDiscovery(config.apiUrl, config.cliToken, project.id, result);
         uploadSpinner.succeed(chalk.green("Discovery uploaded to QAZen"));
         console.log("\n" + chalk.hex("#6366F1").bold("  Vision Scout complete\n"));
+        const totalScenarios = result.pages.reduce((sum, p) => sum + (p.testScenariosFound?.length ?? 0), 0);
         console.log(chalk.gray(`  Pages explored:  ${chalk.white(result.pages.length)}`));
         console.log(chalk.gray(`  Elements found:  ${chalk.white(result.totalElements)}`));
+        console.log(chalk.gray(`  Test scenarios:  ${chalk.white(totalScenarios)}`));
         console.log(chalk.gray(`  Actions taken:   ${chalk.white(result.totalActions)}`));
         console.log(chalk.gray(`  Screenshots:     ${chalk.white(result.screenshots.length)}`));
         console.log(chalk.gray(`\n  View in QAZen: ${config.apiUrl}/discovery\n`));

package/dist/lib/api.js

@@ -49,6 +49,7 @@ export async function fetchProjectAuthSession(apiUrl, cliToken, projectId) {
     }
 }
 export async function uploadVisionDiscovery(apiUrl, cliToken, projectId, result) {
+    const totalTestScenarios = result.pages.reduce((sum, p) => sum + (p.testScenariosFound?.length ?? 0), 0);
     const appMap = {
         baseUrl: result.pages[0]?.url ?? "",
         pages: result.pages.map((p) => ({
@@ -66,11 +67,14 @@ export async function uploadVisionDiscovery(apiUrl, cliToken, projectId, result)
                 .map((e) => e.action),
             visualDescription: p.visualDescription,
             workflow: p.workflow,
+            pageType: p.pageType,
             actionsTaken: p.actions_taken,
+            testScenariosFound: p.testScenariosFound ?? [],
         })),
         api_endpoints: [],
         total_pages: result.pages.length,
         total_elements: result.totalElements,
+        totalTestScenarios,
         discoveryMethod: "vision",
         primaryWorkflows: result.primaryWorkflows,
         screenshots: result.screenshots.slice(0, 5),

package/dist/lib/visionNavigator.js

@@ -114,10 +114,13 @@ export class VisionNavigator {
                 return;
             }
             this.visitedUrls.add(normalizedFinal);
+            // Mark original URL as visited too — prevents re-queuing via redirect.
+            this.visitedUrls.add(normalizedUrl);
             const screenshot = await this.takeScreenshot(url);
             const analysis = await this.analyzeScreenshot(screenshot, url, context, onEvent);
             if (!analysis)
                 return;
+            const testScenariosFound = analysis.elements.flatMap((el) => el.testScenarios || []);
             const pageMap = {
                 url: currentUrl,
                 title: await this.page.title(),
@@ -125,12 +128,30 @@ export class VisionNavigator {
                 elements: analysis.elements,
                 screenshot,
                 ...(analysis.workflow ? { workflow: analysis.workflow } : {}),
+                ...(analysis.pageType ? { pageType: analysis.pageType } : {}),
                 actions_taken: [],
+                testScenariosFound,
             };
             onEvent({
                 type: "page_mapped",
                 message: `${analysis.pageDescription} — ${analysis.elements.length} elements found`,
             });
+            const scenarioCount = pageMap.testScenariosFound.length;
+            if (scenarioCount > 0) {
+                onEvent({
+                    type: "vision_analysis",
+                    message: `${scenarioCount} test scenarios identified across ${analysis.elements.length} interactive surfaces`,
+                });
+                const topSurfaces = analysis.elements
+                    .filter((e) => (e.testScenarios?.length ?? 0) > 2)
+                    .slice(0, 3);
+                for (const s of topSurfaces) {
+                    onEvent({
+                        type: "vision_analysis",
+                        message: `  · ${s.interactionType}: ${s.testScenarios.length} scenarios (e.g. "${s.testScenarios[0]}")`,
+                    });
+                }
+            }
             const highPriority = analysis.elements
                 .filter((e) => {
                 if (e.priority !== "high")
@@ -211,39 +232,110 @@ export class VisionNavigator {
                             },
                             {
                                 type: "text",
-                                text: `You are a QA engineer exploring a web application.
-Context: ${context}
+                                text: `You are a senior QA engineer with 15 years experience testing enterprise web applications.
+
 Current URL: ${url}
+Context: ${context}
+Already visited (do not prioritise these):
+${Array.from(this.visitedUrls).join("\n")}
+
+Analyse this screenshot carefully. For EVERY interactive element visible on screen, identify:
+1. What TYPE of interaction it represents
+2. What TEST SCENARIOS it generates for QA
+3. What INPUT DATA would properly exercise it
+
+Interactive surface types to identify:
+
+SEARCH — What can be searched? Generate scenarios:
+  empty search, partial match, exact match,
+  no results found, special characters,
+  maximum length input, leading/trailing spaces
+
+DATE PICKER / DATE RANGE — Generate scenarios:
+  single day, multi-day range, maximum range,
+  minimum range (same day), future dates,
+  past dates, fiscal year boundaries,
+  invalid date format, date ordering (end before start)
+
+DROPDOWN / SELECT — Generate scenarios:
+  each available option, default value,
+  does selecting one change another dropdown,
+  what happens with no selection
+
+FILTER PANEL — Generate scenarios:
+  single filter applied, multiple filters combined,
+  clear all filters, filter with no results,
+  filter persists across page navigation
+
+DATA TABLE — Generate scenarios:
+  sort each column ascending, sort descending,
+  default sort order, pagination if present,
+  rows per page selector, empty state,
+  export functionality
+
+EXPORT BUTTON — Generate scenarios:
+  each available format (CSV/Excel/PDF),
+  export with filters applied,
+  export with date range applied,
+  large dataset export
+
+CHART / GRAPH — Generate scenarios:
+  hover to see tooltip values,
+  click to drill down if interactive,
+  date range changes update chart,
+  empty data state, maximum data points
+
+TOGGLE / SWITCH — Generate scenarios:
+  enable the toggle, disable the toggle,
+  does state persist on page refresh,
+  does it affect other elements
+
+TAB BAR — Generate scenarios:
+  each tab loads correct content,
+  default active tab on page load,
+  tab state preserved on browser back navigation
+
+FORM — Generate scenarios:
+  all required fields missing,
+  individual required fields missing,
+  invalid format (email, phone, date),
+  maximum field length exceeded,
+  successful submission,
+  error message display
+
+MODAL / DIALOG — Generate scenarios:
+  open the modal, close with X button,
+  close with Escape key,
+  close by clicking outside (backdrop),
+  action confirmation inside modal
 
-Analyse this screenshot and return ONLY valid JSON:
+PAGINATION — Generate scenarios:
+  navigate to next page, previous page,
+  jump to last page, jump to first page,
+  rows per page selector
+
+Return ONLY valid JSON — no markdown, no explanation:
 {
-  "pageDescription": "One sentence describing what this page/section does",
-  "workflow": "The business workflow this page is part of (e.g. 'User Authentication', 'Product Catalog', 'Order Management')",
+  "pageDescription": "one sentence description",
+  "workflow": "business workflow name",
+  "pageType": "report|form|dashboard|list|detail|other",
   "elements": [
     {
-      "description": "Clear description of the element",
-      "elementType": "button|link|input|tab|menu|dropdown|other",
-      "action": "What clicking/interacting would do OR the href URL if it's a link",
+      "description": "specific description of this element",
+      "elementType": "one of the types listed above",
+      "interactionType": "e.g. date range selector, market dropdown",
+      "testScenarios": [
+        "specific test scenario 1",
+        "specific test scenario 2"
+      ],
+      "action": "what clicking/interacting does",
       "priority": "high|medium|low",
-      "visualLocation": "Brief description of where it is on screen"
+      "visualLocation": "where on screen",
+      "requiresInput": true or false,
+      "inputExamples": ["example1", "example2"]
     }
   ]
-}
-
-Already visited URLs — do NOT suggest clicking these as high priority:
-${Array.from(this.visitedUrls).join("\n")}
-
-If an element links to an already-visited URL, set its priority to 'low'.
-
-Focus on:
-- Navigation items and menu links (high priority)
-- Primary action buttons (high priority)
-- Tab bars and section switchers (high priority)
-- Form inputs (medium priority)
-- Secondary buttons (medium priority)
-
-Ignore: decorative elements, footer links, external links.
-Return ONLY the JSON object. No markdown, no explanation.`,
+}`,
                             },
                         ],
                     },
@@ -265,13 +357,9 @@ Return ONLY the JSON object. No markdown, no explanation.`,
             return null;
         }
     }
-    async clickElement(element, pageMap, onEvent) {
-        onEvent({
-            type: "action",
-            message: `Clicking "${element.description}" (${element.visualLocation || element.elementType})`,
-        });
-        const urlBefore = this.page.url();
+    async getElementCoordinates(description, visualLocation) {
         const screenshot = await this.takeScreenshot("click-target");
+        const hint = visualLocation ? ` (${visualLocation})` : "";
         const coordResponse = await this.anthropic.messages.create({
             model: MODEL,
             max_tokens: 200,
@@ -285,7 +373,7 @@ Return ONLY the JSON object. No markdown, no explanation.`,
                         },
                         {
                             type: "text",
-                            text: `Find "${element.description}" on screen.
+                            text: `Find "${description}"${hint} on screen.
 Return ONLY JSON: {"x": number, "y": number, "found": boolean}
 x and y are pixel coordinates (image is 1280x720).
 If not found, return {"x": 0, "y": 0, "found": false}`,
@@ -295,24 +383,50 @@ If not found, return {"x": 0, "y": 0, "found": false}`,
             ],
         });
         const coordText = firstTextBlock(coordResponse.content);
-        let coords;
         try {
-            coords = JSON.parse(stripCodeFences(coordText));
+            return JSON.parse(stripCodeFences(coordText));
         }
         catch {
             return null;
         }
-        if (!coords.found)
+    }
+    async clickElement(element, pageMap, onEvent) {
+        onEvent({
+            type: "action",
+            message: `Clicking "${element.description}"`,
+        });
+        const coords = await this.getElementCoordinates(element.description, element.visualLocation);
+        if (!coords?.found)
             return null;
+        // Set up navigation listener BEFORE clicking so we catch the redirect.
+        let navigationUrl = null;
+        const navigationPromise = this.page.waitForNavigation({
+            timeout: 3000,
+            waitUntil: "domcontentloaded",
+        })
+            .then(() => {
+            navigationUrl = this.page.url();
+        })
+            .catch(() => {
+            /* no navigation — fine */
+        });
         await this.page.mouse.click(coords.x, coords.y);
         this.totalActions++;
-        pageMap.actions_taken.push(`Clicked "${element.description}" at (${coords.x}, ${coords.y})`);
-        await this.page.waitForTimeout(2000);
-        const urlAfter = this.page.url();
-        if (urlAfter !== urlBefore) {
-            const newScreenshot = await this.takeScreenshot(urlAfter);
-            this.screenshots.push(newScreenshot);
-            return urlAfter;
+        await Promise.race([navigationPromise, this.page.waitForTimeout(2000)]);
+        if (navigationUrl) {
+            const normalizedNew = this.normalizeUrl(navigationUrl);
+            // If we landed on an already-mapped page, go back and skip.
+            if (this.visitedUrls.has(normalizedNew)) {
+                onEvent({
+                    type: "vision_analysis",
+                    message: `Skipping ${normalizedNew} — already mapped`,
+                });
+                await this.page.goBack({ waitUntil: "domcontentloaded", timeout: 10000 }).catch(() => { });
+                await this.page.waitForTimeout(1000);
+                return null;
+            }
+            pageMap.actions_taken.push(`Navigated to ${navigationUrl}`);
+            return navigationUrl;
         }
         return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qazen-cli",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "QAZen CLI — capture authenticated browser sessions for enterprise SSO testing",
   "license": "MIT",
   "author": "QAZen",