@cutleryapp/agent 1.0.31 → 1.0.33

package/dist/mcp-executor.js

@@ -206,15 +206,53 @@ class TestExecutor {
                             handled = true;
                         }
                     }
-                    // 6. Select — dropdown
+                    // 6. Select — native dropdown, then React-select/autocomplete fallback
                     if (!handled && (lower.includes("select") || lower.includes("choose"))) {
-                        const selMatch = raw.match(/select\s+"?([^"]+?)"?\s+(?:from|in)\s+"?([^"]+?)"?\s*(?:dropdown|select|field)?$/i);
+                        const selMatch = raw.match(/(?:select|choose)\s+"?([^"]+?)"?\s+(?:from|in)\s+"?([^"]+?)"?\s*(?:dropdown|select|field)?$/i);
                         if (selMatch) {
+                            const optionValue = selMatch[1].trim();
+                            const fieldLabel = selMatch[2].trim();
+                            let selHandled = false;
+                            // Try native <select>
                             try {
-                                await page.selectOption(selMatch[2].trim(), { label: selMatch[1].trim() });
+                                const fieldLoc = page.getByLabel(new RegExp(fieldLabel, 'i')).first();
+                                await fieldLoc.selectOption({ label: optionValue });
+                                selHandled = true;
+                            }
+                            catch { /* not a native select */ }
+                            // Try React-select / autocomplete typeahead
+                            if (!selHandled) {
+                                selHandled = await tryAutocomplete(page, fieldLabel, optionValue);
+                            }
+                            // Try clicking a visible option in an already-open dropdown
+                            if (!selHandled) {
+                                try {
+                                    await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 3000 });
+                                    selHandled = true;
+                                }
+                                catch { /* fall to AI */ }
+                            }
+                            if (selHandled)
                                 handled = true;
+                        }
+                    }
+                    // 6b. Check/uncheck — checkbox or radio by label
+                    if (!handled && (lower.startsWith("check ") || lower.startsWith("tick ") || lower.startsWith("select ")) && !handled) {
+                        const cbMatch = raw.match(/(?:check|tick|select)\s+"?([^"]+?)"?\s*(?:checkbox|option|hobby|hobbies)?$/i);
+                        if (cbMatch) {
+                            const labelText = cbMatch[1].trim();
+                            try {
+                                // Try label click (works for hidden checkboxes with styled labels)
+                                await page.locator(`label:has-text("${labelText}")`).first().click({ timeout: 3000 });
+                                handled = true;
+                            }
+                            catch {
+                                try {
+                                    await page.getByLabel(new RegExp(labelText, 'i')).first().check({ timeout: 3000 });
+                                    handled = true;
+                                }
+                                catch { /* fall to AI */ }
                             }
-                            catch { /* fall to AI */ }
                         }
                     }
                     // 7. AI — single-shot for deterministic steps, full loop for intent steps
@@ -623,9 +661,14 @@ ${domElements}` + (stepAttachment ? `\n\nThe REFERENCE IMAGE (second image) show
                     const checked = await el.isChecked().catch(() => false);
                     if (!checked) {
                         let done = false;
+                        // Derive a label text from selector for label-based fallbacks
+                        const labelHint = act.label || act.selector.replace(/[#.\[\]"'=*^$]/g, ' ').trim();
                         for (const fn of [
-                            () => el.click({ timeout: 4000 }),
-                            () => page.locator(`label:has-text("${act.label || ''}")`).click({ timeout: 4000 }),
+                            () => el.click({ force: true, timeout: 4000 }), // force bypasses visibility
+                            () => el.check({ force: true, timeout: 4000 }),
+                            () => page.locator(`label[for="${act.selector.replace('#', '')}"]`).click({ timeout: 4000 }),
+                            () => page.locator(`label:has-text("${labelHint}")`).first().click({ timeout: 4000 }),
+                            () => page.locator(`label:has(${act.selector})`).click({ timeout: 4000 }),
                         ]) {
                             try {
                                 await fn();
@@ -705,6 +748,57 @@ async function tryAIClick(page, selector) {
     }
     return false;
 }
+/** Fill an autocomplete/typeahead input: type value, wait for dropdown, click first matching option */
+async function tryAutocomplete(page, labelOrSelector, value) {
+    const TIMEOUT = 4000;
+    const locators = [
+        page.getByLabel(new RegExp(labelOrSelector, 'i')),
+        page.getByPlaceholder(new RegExp(labelOrSelector, 'i')),
+        page.locator(labelOrSelector),
+    ];
+    for (const loc of locators) {
+        try {
+            const input = loc.first();
+            await input.waitFor({ state: 'visible', timeout: TIMEOUT });
+            await input.click({ timeout: TIMEOUT });
+            await input.fill('', { timeout: TIMEOUT });
+            // Type slowly so the autocomplete can react
+            await input.type(value, { delay: 80 });
+            // Wait for dropdown options to appear
+            await page.waitForTimeout(600);
+            // Try common dropdown option selectors
+            const optionSelectors = [
+                `[class*="option"]:has-text("${value}")`,
+                `[class*="suggestion"]:has-text("${value}")`,
+                `[class*="item"]:has-text("${value}")`,
+                `[role="option"]:has-text("${value}")`,
+                `[role="listbox"] [class*="option"]`,
+                `[class*="menu"] [class*="option"]`,
+                `[class*="dropdown"] li`,
+                `ul[class*="auto"] li`,
+                `.react-select__option`,
+                `.autocomplete-item`,
+            ];
+            for (const optSel of optionSelectors) {
+                try {
+                    const opt = page.locator(optSel).first();
+                    if (await opt.isVisible({ timeout: 800 })) {
+                        await opt.click({ timeout: TIMEOUT });
+                        console.log(`  ✓ Autocomplete: typed "${value}", clicked option via "${optSel}"`);
+                        return true;
+                    }
+                }
+                catch { /* try next */ }
+            }
+            // Fallback: press Enter if a highlighted option exists
+            await page.keyboard.press('Enter');
+            await page.waitForTimeout(300);
+            return true;
+        }
+        catch { /* try next locator */ }
+    }
+    return false;
+}
 /** Try filling with multiple selector strategies */
 async function tryAIFill(page, selector, value) {
     const TIMEOUT = 5000;
@@ -904,6 +998,10 @@ async function tryFill(page, label, value) {
             errors.push(e?.message?.split("\n")[0] || String(e));
         }
     }
+    // Autocomplete fallback — type + wait for dropdown + click option
+    const acSuccess = await tryAutocomplete(page, label, value);
+    if (acSuccess)
+        return;
     // AI vision fallback
     const aiSuccess = await aiFillFallback(page, label, value);
     if (aiSuccess)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cutleryapp/agent",
-    "version": "1.0.31",
+    "version": "1.0.33",
     "description": "Local agent that connects your machine to the Cutlery QA platform and runs UI tests via Playwright",
     "main": "dist/cli.js",
     "bin": {