@swmansion/argent 0.15.1-next.5 → 0.15.1-next.6

package/dist/tool-server.cjs

@@ -133168,7 +133168,7 @@ async function describeVega(_serial) {
 
 // ../tool-server/src/utils/ui-tree-match.ts
 init_zod();
-var selectorSchema = external_exports.object({
+var selectorFieldsSchema = external_exports.object({
   text: external_exports.string().min(1).optional().describe("Case-insensitive substring of the element's visible label or value."),
   identifier: external_exports.string().min(1).optional().describe(
     "The element's identifier (accessibilityIdentifier / resource-id / testid), matched case-insensitively as the exact identifier or the unqualified resource-id name ('submit' matches 'com.example.app:id/submit')."
@@ -133176,9 +133176,13 @@ var selectorSchema = external_exports.object({
   role: external_exports.string().min(1).optional().describe(
     "Case-insensitive substring of the element's role (e.g. AXButton, button, TextView)."
   )
-}).refine((s) => Boolean(s.text || s.identifier || s.role), {
-  message: "selector needs at least one of text, identifier, or role"
-});
+}).strict();
+var selectorSchema = selectorFieldsSchema.refine(
+  (s) => Boolean(s.text || s.identifier || s.role),
+  {
+    message: "selector needs at least one of text, identifier, or role"
+  }
+);
 function nodeText(node) {
   return [node.label, node.value].filter(Boolean).join(" ");
 }
@@ -133195,15 +133199,32 @@ function identifierMatches(actual, needle) {
   if (!actual) return false;
   return equalsCI(actual, needle) || actual.toLowerCase().endsWith(`:id/${needle.toLowerCase()}`);
 }
+var uiTreeMatchInternals = {
+  createRegExp(pattern) {
+    return new RegExp(pattern);
+  }
+};
+function regexMatchesNonEmpty(regex, actual) {
+  if (!actual) return false;
+  return regex.test(actual);
+}
 function textMatches(actual, expected, mode) {
+  if (mode === "matches") {
+    return regexMatchesNonEmpty(uiTreeMatchInternals.createRegExp(expected), actual);
+  }
   return mode === "equals" ? equalsCI(actual, expected) : includesCI(actual, expected);
 }
-function matchNode(node, selector) {
+function matchNodeWithRegex(node, selector, textRegex) {
   if (selector.text !== void 0) {
     if (!includesCI(node.label, selector.text) && !includesCI(node.value, selector.text)) {
       return false;
     }
   }
+  if (textRegex !== void 0) {
+    if (!regexMatchesNonEmpty(textRegex, node.label) && !regexMatchesNonEmpty(textRegex, node.value)) {
+      return false;
+    }
+  }
   if (selector.identifier !== void 0 && !identifierMatches(node.identifier, selector.identifier)) {
     return false;
   }
@@ -133212,13 +133233,17 @@ function matchNode(node, selector) {
   }
   return true;
 }
-function collectMatches(node, selector, acc) {
-  if (matchNode(node, selector)) acc.push(node);
-  for (const child of node.children) collectMatches(child, selector, acc);
+function selectorTextRegex(selector) {
+  return selector.textMatches === void 0 ? void 0 : uiTreeMatchInternals.createRegExp(selector.textMatches);
+}
+function collectMatches(node, selector, textRegex, acc) {
+  if (matchNodeWithRegex(node, selector, textRegex)) acc.push(node);
+  for (const child of node.children) collectMatches(child, selector, textRegex, acc);
 }
 function findAll(root2, selector) {
   const acc = [];
-  for (const child of root2.children) collectMatches(child, selector, acc);
+  const textRegex = selectorTextRegex(selector);
+  for (const child of root2.children) collectMatches(child, selector, textRegex, acc);
   return acc;
 }
 function isVisible(node) {
@@ -133282,21 +133307,29 @@ function nodeAtPoint(root2, point) {
   for (const child of root2.children) walk(child);
   return best;
 }
-function exactFieldCount(node, selector) {
+function fullConsumptionRegex(selector) {
+  return selector.textMatches === void 0 ? void 0 : uiTreeMatchInternals.createRegExp(`^(?:${selector.textMatches})$`);
+}
+function exactFieldCount(node, selector, fullTextRegex) {
   let count = 0;
   if (selector.text !== void 0 && (equalsCI(node.label, selector.text) || equalsCI(node.value, selector.text))) {
     count++;
   }
+  if (fullTextRegex !== void 0 && (regexMatchesNonEmpty(fullTextRegex, node.label) || regexMatchesNonEmpty(fullTextRegex, node.value))) {
+    count++;
+  }
   if (selector.identifier !== void 0 && equalsCI(node.identifier, selector.identifier)) count++;
   if (selector.role !== void 0 && equalsCI(node.role, selector.role)) count++;
   return count;
 }
 function selectorToFrame(root2, selector) {
   const visible = findAll(root2, selector).filter(isVisible);
+  if (visible.length === 0) return void 0;
+  const fullTextRegex = fullConsumptionRegex(selector);
   let best;
   let bestExact = -1;
   for (const n of visible) {
-    const exact = exactFieldCount(n, selector);
+    const exact = exactFieldCount(n, selector, fullTextRegex);
     if (best === void 0 || exact !== bestExact) {
       if (exact > bestExact) {
         best = n;
@@ -144519,14 +144552,67 @@ function chromiumLaunchSpec(launch) {
   return typeof c === "string" ? { path: c } : { path: c.path, args: c.args };
 }
 function selectorToYaml(sel) {
+  if (sel.text !== void 0 && sel.textMatches !== void 0) {
+    throw new Error(
+      'Cannot serialize flow selector without losing constraints: both `text` and `textMatches` are set, but flow YAML can represent only one `text` constraint (a literal string or `{ matches: "<regex>" }`). Use either literal or regex text matching.'
+    );
+  }
+  if (sel.loose && sel.text !== void 0 && (typeof sel.text !== "string" || sel.text.length === 0)) {
+    throw new Error(
+      "Cannot serialize loose flow selector: `text` must be a non-empty string so bare-string YAML can round-trip through selector validation."
+    );
+  }
+  if (sel.loose && (sel.text === void 0 || sel.textMatches !== void 0 || sel.identifier !== void 0 || sel.role !== void 0)) {
+    const incompatible = [
+      sel.textMatches !== void 0 ? "textMatches" : void 0,
+      sel.identifier !== void 0 ? "identifier" : void 0,
+      sel.role !== void 0 ? "role" : void 0
+    ].filter((field) => field !== void 0);
+    throw new Error(
+      "Cannot serialize loose flow selector without changing its meaning: bare-string YAML can represent only a loose text-only selector" + (incompatible.length > 0 ? `; incompatible fields: ${incompatible.join(", ")}` : "") + "."
+    );
+  }
   if (sel.loose && sel.text !== void 0 && sel.identifier === void 0 && sel.role === void 0) {
     return sel.text;
   }
-  const { loose: _loose, identifier, ...rest } = sel;
-  return identifier === void 0 ? { ...rest } : { ...rest, id: identifier };
+  const { loose: _loose, identifier, textMatches: textMatches2, ...rest } = sel;
+  const out = { ...rest };
+  if (textMatches2 !== void 0) out.text = { matches: textMatches2 };
+  if (identifier !== void 0) out.id = identifier;
+  return out;
 }
 function describeSelector(s) {
-  return Object.entries(s).filter(([k]) => k !== "loose").map(([k, v]) => `${k === "identifier" ? "id" : k}="${v}"`).join(" ");
+  return Object.entries(s).filter(([k]) => k !== "loose").map(
+    ([k, v]) => k === "textMatches" ? `text=/${v}/` : `${k === "identifier" ? "id" : k}="${v}"`
+  ).join(" ");
+}
+function describeTextExpectation(expectedText, textMatch, verbForm = "mode") {
+  const expected = expectedText ?? "";
+  const mode = textMatch ?? "contains";
+  switch (mode) {
+    case "contains":
+      return `${verbForm === "infinitive" ? "contain" : mode} ${JSON.stringify(expected)}`;
+    case "equals":
+      return `${verbForm === "infinitive" ? "equal" : mode} ${JSON.stringify(expected)}`;
+    case "matches":
+      return `${verbForm === "infinitive" ? "match" : mode} /${expected}/`;
+  }
+}
+function textWaitToYaml(selector, expectedText, textMatch) {
+  const expected = expectedText ?? "";
+  const mode = textMatch ?? "contains";
+  switch (mode) {
+    case "contains":
+      return { text: { in: selector, contains: expected } };
+    case "equals":
+      return { text: { in: selector, equals: expected } };
+    case "matches":
+      return { text: { in: selector, matches: expected } };
+    default: {
+      const exhaustive = mode;
+      throw new Error(`Unsupported text match mode: ${exhaustive}`);
+    }
+  }
 }
 function waitToYaml(condition, selector, expectedText, textMatch, timeoutMs) {
   const sel = selectorToYaml(selector);
@@ -144542,7 +144628,7 @@ function waitToYaml(condition, selector, expectedText, textMatch, timeoutMs) {
       body = { hidden: sel };
       break;
     case "text":
-      body = textMatch === "equals" ? { text: { in: sel, equals: expectedText ?? "" } } : { text: { in: sel, contains: expectedText ?? "" } };
+      body = textWaitToYaml(sel, expectedText, textMatch);
       break;
   }
   if (timeoutMs !== void 0) body.timeout = timeoutMs;
@@ -144635,6 +144721,16 @@ function badEntry(raw, detail) {
     error_kind: "validation"
   });
 }
+function validatePattern(raw, pattern, where) {
+  try {
+    new RegExp(pattern);
+  } catch (err) {
+    badEntry(
+      raw,
+      `${where} \`matches\` is not a valid regular expression: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 function editDistance(a, b) {
   let prevPrev = new Array(b.length + 1);
   let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
@@ -144698,11 +144794,46 @@ function parseSelector(raw, where) {
     }
     normalized = { ...rest, identifier: id };
   }
+  if (normalized !== null && typeof normalized === "object") {
+    const { text, ...rest } = normalized;
+    if (text !== null && typeof text === "object") {
+      const keys = Object.keys(text);
+      if (!Array.isArray(text)) {
+        rejectUnknownKeys(
+          raw,
+          text,
+          ["matches"],
+          `${where}: text matcher`
+        );
+      }
+      const pattern = text.matches;
+      if (keys.length !== 1 || keys[0] !== "matches") {
+        badEntry(
+          raw,
+          `${where}: a text matcher takes exactly { matches: '<regex>' } \u2014 for a substring, use the plain-string form (text: "\u2026")`
+        );
+      }
+      if (typeof pattern !== "string" || pattern.length === 0) {
+        badEntry(raw, `${where}: text matcher needs a non-empty \`matches\` pattern`);
+      }
+      validatePattern(raw, pattern, `${where}: text`);
+      const fields = selectorFieldsSchema.safeParse(rest);
+      if (!fields.success) {
+        badEntry(raw, `${where}: ${fields.error.issues[0]?.message ?? "invalid selector"}`);
+      }
+      return { ...fields.data, textMatches: pattern };
+    }
+  }
   const r = selectorSchema.safeParse(normalized);
   if (!r.success) badEntry(raw, `${where}: ${r.error.issues[0]?.message ?? "invalid selector"}`);
   return r.data;
 }
 var WAIT_CONDITIONS = ["exists", "visible", "hidden", "text"];
+var TEXT_MATCH_MODES = Object.keys({
+  contains: true,
+  equals: true,
+  matches: true
+});
 var SCROLL_DIRECTIONS = ["up", "down", "left", "right"];
 function parseWaitFields(raw, kind) {
   if (raw === null || typeof raw !== "object") {
@@ -144742,22 +144873,30 @@ function parseWaitFields(raw, kind) {
   if (condition === "text") {
     const t = b.text;
     if (t === null || typeof t !== "object") {
-      badEntry({ [kind]: b }, `${kind} text needs { in: <selector>, contains|equals: <string> }`);
+      badEntry(
+        { [kind]: b },
+        `${kind} text needs { in: <selector>, contains|equals|matches: <string> }`
+      );
     }
     const tb = t;
     if (!Array.isArray(tb)) {
-      rejectUnknownKeys({ [kind]: b }, tb, ["in", "contains", "equals"], `${kind}.text`);
+      rejectUnknownKeys({ [kind]: b }, tb, ["in", ...TEXT_MATCH_MODES], `${kind}.text`);
     }
-    const hasContains = "contains" in tb;
-    const hasEquals = "equals" in tb;
-    if (hasContains === hasEquals) {
-      badEntry({ [kind]: b }, `${kind} text needs exactly one of \`contains\` or \`equals\``);
+    const comparators = TEXT_MATCH_MODES.filter((mode) => mode in tb);
+    if (comparators.length !== 1) {
+      badEntry(
+        { [kind]: b },
+        `${kind} text needs exactly one of \`contains\`, \`equals\`, or \`matches\``
+      );
     }
-    const textMatch = hasEquals ? "equals" : "contains";
-    const expected = hasEquals ? tb.equals : tb.contains;
+    const textMatch = comparators[0];
+    const expected = tb[textMatch];
     if (typeof expected !== "string" || expected.length === 0) {
       badEntry({ [kind]: b }, `${kind} text needs a non-empty \`${textMatch}\``);
     }
+    if (textMatch === "matches") {
+      validatePattern({ [kind]: b }, expected, `${kind} text`);
+    }
     return {
       condition: "text",
       selector: parseSelector(tb.in, `${kind}.text.in`),
@@ -145869,7 +146008,14 @@ You can still edit the .yaml file directly afterwards to remove or reorder steps
           return `${n}. type: ${selectorLabel(step.into)} \u2190 "${step.text}"`;
         case "await":
         case "assert": {
-          const tail = step.condition === "text" ? `text ${selectorLabel(step.selector)} == "${step.expectedText ?? ""}"` : `${step.condition} ${selectorLabel(step.selector)}`;
+          let tail;
+          if (step.condition !== "text") {
+            tail = `${step.condition} ${selectorLabel(step.selector)}`;
+          } else {
+            const selector = selectorLabel(step.selector);
+            const expected = step.expectedText ?? "";
+            tail = step.textMatch === "matches" ? `text ${selector} matches /${expected}/` : step.textMatch === "equals" ? `text ${selector} == ${JSON.stringify(expected)}` : `text ${selector} contains ${JSON.stringify(expected)}`;
+          }
           return `${n}. ${step.kind}: ${tail}`;
         }
         case "wait":
@@ -146263,11 +146409,11 @@ function assertReason(condition, selector, expectedText, textMatch, matches2) {
     case "text": {
       const first = firstInReadingOrder(matches2.filter(isVisible)) ?? firstInReadingOrder(matches2);
       if (!first) return `no element matched selector ${sel}`;
-      const wanted = textMatch === "equals" ? "equal" : "contain";
+      const wanted = describeTextExpectation(expectedText, textMatch, "infinitive");
       const shown = assertText(first);
       const own = nodeText(first);
       const ownNote = own && own !== shown ? ` (own text "${own}")` : "";
-      return `element matched ${sel} but its text was "${shown}"${ownNote} (wanted to ${wanted} "${expectedText}")`;
+      return `element matched ${sel} but its text was "${shown}"${ownNote} (wanted to ${wanted})`;
     }
     default:
       return `assertion failed for selector ${sel}`;
@@ -148763,6 +148909,7 @@ function pushReport(state3, report) {
 function selectorLabel2(sel) {
   const parts = [];
   if (sel.text !== void 0) parts.push(`"${sel.text}"`);
+  if (sel.textMatches !== void 0) parts.push(`/${sel.textMatches}/`);
   if (sel.identifier) parts.push(`id=${sel.identifier}`);
   if (sel.role) parts.push(`role=${sel.role}`);
   return parts.join(" ");
@@ -148781,7 +148928,7 @@ function stepTarget(step) {
     case "assert": {
       const sel = selectorLabel2(step.selector);
       if (step.condition === "text") {
-        return `${sel} ${step.textMatch ?? "contains"} "${step.expectedText ?? ""}"`;
+        return `${sel} ${describeTextExpectation(step.expectedText, step.textMatch)}`;
       }
       return `${step.condition} ${sel}`;
     }
@@ -149682,7 +149829,7 @@ function normLabel(s) {
   return (s || "").toLowerCase().replace(/-/g, "").replace(/[\s,]+/g, " ").trim();
 }
 var MAX_FRAME_AREA = 0.85;
-function matchNode2(n, match, needle) {
+function matchNode(n, match, needle) {
   const label = normLabel(n.label);
   const ident = normLabel(n.identifier);
   const value = normLabel(n.value);
@@ -149709,7 +149856,7 @@ function findElementMatch(tree, match) {
   const candidates = [];
   const walk = (n) => {
     if (!n || typeof n !== "object") return;
-    const m = matchNode2(n, match, needle);
+    const m = matchNode(n, match, needle);
     if (m && n.frame) {
       const f = n.frame;
       const cx = f.x + f.width / 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.15.1-next.5",
+  "version": "0.15.1-next.6",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {

package/skills/argent-create-flow/SKILL.md

@@ -37,7 +37,9 @@ Beyond raw `tool:` steps and `echo:`, flows support declarative directives inter
 
 A **selector** is `{ text?, id?, role? }` (all-must-match; `text`/`role` are case-insensitive substrings, `id` matches the element's testID / accessibilityIdentifier / resource-id exactly, case-insensitive, also accepting the unqualified Android resource-id name — `submit` matches `com.example.app:id/submit`) — the same semantics `await-ui-element` uses, though that tool spells the `id` field `identifier` (flow YAML also accepts `identifier` as an alias for `id`, but `id` is the canonical spelling and what the recorder writes). A bare string is a _loose_ selector: it resolves **identifier-first, then falls back to text** (label/value), so `tap: Login` matches a `testID="Login"` or, failing that, visible text "Login" — no need to know which. Loose fallback applies uniformly to every selector slot (`tap`, `type.into`, `await`, `assert`, `scroll-to`). Use the map form to be strict: `{ id: submit-btn }` (identifier only) or `{ text: Login }` (text only, no fallback).
 
-Selectors resolve against the **full native hierarchy** (iOS: the UIView tree; Android: the complete accessibility hierarchy including not-important views) — strictly more than `describe` or the raw `await-ui-element` tool see (both use the trimmed tree), with complete `testID`/`resource-id` coverage. So an `id` selector works even when `describe` collapses or omits the element — don't fall back to coordinate taps just because a testID isn't visible in `describe` output. And when several elements match — a container aggregates its descendants' text, so `text: "Inner"` matches the wrapping containers too — the action directives (`tap`, `type`, `scroll-to`) pick the **most specific** match: an exact text/identifier match beats a substring hit, then the smallest frame wins.
+`text` also takes a **regex matcher map** — `{ text: { matches: '^Order #\d+$' } }`, in any selector slot — for dynamic text no literal can pin. It tests each node's native **own** label/value (not the adapter-hoisted `subtreeText`), though on iOS a container's own label may itself aggregate descendant text, so a wrapper and its leaf can both match. Same regex rules as `text.in`'s `matches` (see _`await` and `assert`_): unanchored, **case-sensitive**, single-quoted, invalid pattern fails at parse. So `assert: { visible: { text: { matches: '^Taps: \d+$' } } }` asserts a counter is on screen with no locator at all, and `tap: { text: { matches: '^Order #\d+$' } }` taps a dynamic row — though a stable `id` stays the more robust action target.
+
+Selectors resolve against the **full native hierarchy** (iOS: the UIView tree; Android: the complete accessibility hierarchy including not-important views) — strictly more than `describe` or the raw `await-ui-element` tool see (both use the trimmed tree), with complete `testID`/`resource-id` coverage. So an `id` selector works even when `describe` collapses or omits the element — don't fall back to coordinate taps just because a testID isn't visible in `describe` output. And when several elements match — including wrappers whose native text aggregates descendant content — the action directives (`tap`, `type`, `scroll-to`) pick the **most specific** match: an exact text/identifier match beats a substring hit (for a regex matcher, a pattern consuming the element's whole text counts as exact), then the smallest frame wins.
 
 **Quote strings YAML would mangle.** An unquoted `#` starts a YAML comment — `tap: Order #1234` silently parses as `tap: Order` — and bare `yes`/`no`/`on`/`off`/numbers coerce to non-strings. When a selector or typed text contains `#`, `:`, quotes, or could read as a boolean/number, wrap it: `tap: "Order #1234"`.
 
@@ -47,6 +49,7 @@ The **condition is the key**, and its value is the selector:
 
 - `{ visible: Home }`, `{ exists: { id: row } }`, `{ hidden: spinner }`
 - `{ text: { in: <selector>, contains: "Taps:" } }` or `{ text: { in: <selector>, equals: "Taps: 0" } }` — `text` locates an element (`in`) and checks its rendered content against exactly one of `contains` (case-insensitive substring) or `equals` (case-insensitive exact match — use it when boundaries matter: `contains: "Taps: 3"` is also satisfied by "Taps: 30"). Reach for `text` only when the locator is an identifier/role; to assert a string is simply on screen, prefer `{ visible: "Taps: 0" }`.
+- `{ text: { in: total, matches: 'Total: \$\d+\.\d{2}' } }` — the third comparator: a JS regex for dynamic content (counters, prices, dates) that neither literal mode can pin. Unanchored like `contains` (anchor with `^…$` for the `equals` analog) and — unlike the literal modes — **case-sensitive**: the pattern carries its own semantics. An invalid pattern fails at parse time. **Quote the pattern in single quotes**: single-quoted and plain YAML scalars keep backslashes; double quotes would need `\\d`. To assert a dynamic string is simply on screen with no locator, prefer a regex **selector** — `{ visible: { text: { matches: '^Taps: \d+$' } } }` (see Selectors); `text.in` + `matches` is for checking a specific element's aggregated text.
 - A container's text aggregates its descendants' text (space-joined), so `text` can assert what a testID wrapper visibly shows even when the string lives in a child node. That also means `equals` against a wrapper must match _everything_ it shows or exactly the wrapper's own label/value — targeting the leaf holding exactly the value (or using `contains`) stays the clearer spelling.
 
 This condition-as-key form is the only spelling. `await` also accepts an optional `timeout` sibling key in milliseconds — `- await: { visible: Home, timeout: 15000 }` — for a transition that legitimately needs longer than the default budget. **Omit `timeout` by default**: the default budget covers normal transitions, and a habitual generous override just delays failure reporting on every broken step. Add one only after a step demonstrably needs it — it timed out at the default and the wait is legitimately slow (a cold start, a network round-trip, a long animation). `assert` has no timeout override: a check that needs seconds to become true is a wait — spell it `await`.