qazen-cli 0.1.9 → 0.2.1

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

@@ -10,6 +10,76 @@ function firstTextBlock(content) {
     const block = content[0];
     return block && block.type === "text" ? block.text : "";
 }
+function salvageJson(text) {
+    const cleaned = stripCodeFences(text);
+    // First try clean parse
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch {
+        // Fall through to salvage
+    }
+    // Salvage truncated JSON: extract metadata + every complete {...} element block.
+    try {
+        const descMatch = cleaned.match(/"pageDescription"\s*:\s*"([^"]+)"/);
+        const workflowMatch = cleaned.match(/"workflow"\s*:\s*"([^"]+)"/);
+        const pageTypeMatch = cleaned.match(/"pageType"\s*:\s*"([^"]+)"/);
+        const elements = [];
+        let depth = 0;
+        let start = -1;
+        let inString = false;
+        let escape = false;
+        for (let i = 0; i < cleaned.length; i++) {
+            const ch = cleaned[i];
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (ch === "{") {
+                if (depth === 0)
+                    start = i;
+                depth++;
+            }
+            else if (ch === "}") {
+                depth--;
+                if (depth === 0 && start !== -1) {
+                    try {
+                        const obj = JSON.parse(cleaned.substring(start, i + 1));
+                        if (typeof obj.description === "string" &&
+                            typeof obj.elementType === "string") {
+                            elements.push(obj);
+                        }
+                    }
+                    catch {
+                        // skip incomplete object
+                    }
+                    start = -1;
+                }
+            }
+        }
+        if (elements.length === 0)
+            return null;
+        return {
+            pageDescription: descMatch?.[1] ?? "Page analysis (partial)",
+            workflow: workflowMatch?.[1] ?? "Unknown",
+            pageType: pageTypeMatch?.[1] ?? "other",
+            elements,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export class VisionNavigator {
     anthropic;
     baseUrl;
@@ -120,6 +190,7 @@ export class VisionNavigator {
             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(),
@@ -127,12 +198,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")
@@ -202,7 +291,7 @@ export class VisionNavigator {
         try {
             const response = await this.anthropic.messages.create({
                 model: MODEL,
-                max_tokens: 2000,
+                max_tokens: 4000,
                 messages: [
                     {
                         role: "user",
@@ -213,46 +302,124 @@ 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
 
-Analyse this screenshot and return ONLY valid JSON:
+MODAL / DIALOG — Generate scenarios:
+  open the modal, close with X button,
+  close with Escape key,
+  close by clicking outside (backdrop),
+  action confirmation inside modal
+
+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.`,
+}`,
                             },
                         ],
                     },
                 ],
             });
             const text = firstTextBlock(response.content);
-            const parsed = JSON.parse(stripCodeFences(text));
+            const parsed = salvageJson(text);
+            if (!parsed) {
+                onEvent({
+                    type: "error",
+                    message: "Vision analysis failed: could not parse or salvage JSON response",
+                });
+                return null;
+            }
             onEvent({
                 type: "vision_analysis",
                 message: parsed.pageDescription + (parsed.workflow ? ` (${parsed.workflow})` : ""),

package/package.json

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