@skyramp/mcp 0.1.8 → 0.2.0-rc.2

package/node_modules/playwright/lib/dom-analyzer/possibleAssertions.test.js

@@ -0,0 +1,470 @@
+"use strict";
+var import_possibleAssertions = require("./possibleAssertions");
+const cases = [];
+function test(name, run) {
+  cases.push({ name, run });
+}
+function assertEqual(actual, expected, msg) {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  if (a !== e)
+    throw new Error(`${msg ?? "assertEqual"} \u2014 expected ${e}, got ${a}`);
+}
+test("Empty delta \u2192 empty array", () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0);
+});
+test("elementsAdded with a button \u2192 1 assertion, role-based locator, toBeVisible(), MEDIUM tier", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "save_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Save Changes",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].code, "await expect(page.getByRole('button', { name: 'Save Changes' })).toBeVisible();");
+  assertEqual(assertions[0].tier, "MEDIUM");
+  if (!assertions[0].rationale.includes("button"))
+    throw new Error("rationale should mention button role");
+});
+test("elementsRemoved with a textbox \u2192 .not.toBeVisible(), MEDIUM", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [
+      {
+        logicalName: "email_input",
+        sectionLogicalName: "form",
+        role: "textbox",
+        accessibleName: "Email"
+      }
+    ],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].code, "await expect(page.getByRole('textbox', { name: 'Email' })).not.toBeVisible();");
+  assertEqual(assertions[0].tier, "MEDIUM");
+  if (!assertions[0].rationale.includes("removed"))
+    throw new Error("rationale should mention removed");
+});
+test("repeatingCountChanges 12 \u2192 13 \u2192 toHaveCount(13), HIGH", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [
+      {
+        logicalName: "order_row_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleNameTemplate: "View details for order {orderId}",
+        before: 12,
+        after: 13,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("toHaveCount(13)"))
+    throw new Error("code should include toHaveCount(13)");
+  if (!assertions[0].code.includes("/^View details for order .+$/i"))
+    throw new Error("code should include regex pattern from template");
+  assertEqual(assertions[0].tier, "HIGH");
+  if (!assertions[0].rationale.includes("12") || !assertions[0].rationale.includes("13"))
+    throw new Error("rationale should mention before and after counts");
+});
+test('textChanges "Inbox (5)" \u2192 "Inbox (6)" \u2192 toHaveText(...), HIGH', () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "inbox_link",
+        sectionLogicalName: "sidebar",
+        role: "link",
+        accessibleName: "Inbox (6)",
+        before: "Inbox (5)",
+        after: "Inbox (6)"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("toHaveText('Inbox (6)')"))
+    throw new Error("code should include toHaveText with after value");
+  if (!assertions[0].code.includes("getByRole('link'"))
+    throw new Error("code should use role-based locator");
+  assertEqual(assertions[0].tier, "HIGH");
+  if (!assertions[0].rationale.includes("Inbox (5)") || !assertions[0].rationale.includes("Inbox (6)"))
+    throw new Error("rationale should mention before and after text");
+});
+test("elementsAdded with empty accessibleName + no testId + no stableId \u2192 skipped (zero output)", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "button_1",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip element with empty accessibleName");
+});
+test("Quote-escaping: accessibleName with quotes", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "greeting_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "He said 'hi'",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("\\'"))
+    throw new Error("code should escape single quotes");
+});
+test("textChanges with empty accessibleName \u2192 skipped", () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "icon_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "",
+        before: "",
+        after: "New Text"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip textChange with empty accessibleName");
+});
+test("repeatingCountChanges with empty accessibleNameTemplate \u2192 skipped", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [
+      {
+        logicalName: "item",
+        sectionLogicalName: "main",
+        role: "listitem",
+        accessibleNameTemplate: "",
+        before: 5,
+        after: 6,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip repeatingCountChange with empty accessibleNameTemplate");
+});
+test("Mixed delta with all four kinds \u2192 all four translations appear, ordered HIGH first then MEDIUM then LOW", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "save_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Save",
+        kind: "persistent"
+      },
+      {
+        logicalName: "notification_status",
+        sectionLogicalName: "main",
+        role: "status",
+        accessibleName: "Operation complete",
+        kind: "transient"
+      }
+    ],
+    elementsRemoved: [
+      {
+        logicalName: "cancel_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Cancel"
+      }
+    ],
+    repeatingCountChanges: [
+      {
+        logicalName: "order_row_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleNameTemplate: "View details for order {orderId}",
+        before: 12,
+        after: 13,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "inbox_link",
+        sectionLogicalName: "sidebar",
+        role: "link",
+        accessibleName: "Inbox (6)",
+        before: "Inbox (5)",
+        after: "Inbox (6)"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 5);
+  assertEqual(assertions[0].tier, "HIGH");
+  assertEqual(assertions[1].tier, "HIGH");
+  assertEqual(assertions[2].tier, "MEDIUM");
+  assertEqual(assertions[3].tier, "MEDIUM");
+  assertEqual(assertions[4].tier, "LOW");
+});
+function makeBlueprint(url, sections = []) {
+  return {
+    schemaVersion: 1,
+    url,
+    capturedAt: "2026-01-01T00:00:00Z",
+    pageHash: "0:0",
+    sections
+  };
+}
+test("Full capture with URL + heading \u2192 2 assertions, HIGH then LOW", () => {
+  const blueprint = makeBlueprint("http://localhost:8055/settings/schema", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "page_title",
+          role: "heading",
+          accessibleName: "Data Model",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[0].tier, "HIGH");
+  assertEqual(
+    assertions[0].code,
+    `await expect(page).toHaveURL('http://localhost:8055/settings/schema');`
+  );
+  assertEqual(assertions[1].tier, "LOW");
+  assertEqual(
+    assertions[1].code,
+    `await expect(page.getByRole('heading', { name: 'Data Model' })).toBeVisible();`
+  );
+});
+test("Full capture with URL only (no headings) \u2192 1 assertion", () => {
+  const blueprint = makeBlueprint("http://localhost:8055/applications", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "create_btn",
+          role: "button",
+          accessibleName: "Create new",
+          xpath: "//button",
+          mutability: "mutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].tier, "HIGH");
+});
+test("Full capture with empty URL \u2192 no assertions", () => {
+  const blueprint = makeBlueprint("", []);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 0);
+});
+test("Full capture skips heading with empty accessibleName", () => {
+  const blueprint = makeBlueprint("http://example.com/", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "unnamed_heading",
+          role: "heading",
+          accessibleName: "   ",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].tier, "HIGH");
+});
+test("Full capture finds first heading across multiple sections", () => {
+  const blueprint = makeBlueprint("http://example.com/page", [
+    {
+      name: "header",
+      landmark: "banner",
+      elements: [],
+      // no heading here
+      repeatingElements: []
+    },
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "main_heading",
+          role: "heading",
+          accessibleName: "Welcome",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[1].rationale, 'Heading visible on destination page: "Welcome"');
+});
+test("Full capture escapes single-quotes in URL and heading", () => {
+  const blueprint = makeBlueprint(`http://example.com/q?name='foo'`, [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "h1",
+          role: "heading",
+          accessibleName: `Bob's profile`,
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[0].code.includes(`\\'`), true);
+  assertEqual(assertions[1].code.includes(`\\'`), true);
+});
+let passed = 0;
+let failed = 0;
+const failures = [];
+for (const c of cases) {
+  try {
+    c.run();
+    passed++;
+  } catch (e) {
+    failed++;
+    failures.push({ name: c.name, error: e.message });
+  }
+}
+console.log(`${passed}/${cases.length} passed${failed ? `, ${failed} failed` : ""}`);
+for (const f of failures)
+  console.error(`  \u2717 ${f.name}: ${f.error}`);
+if (failed > 0) {
+  process.exit(1);
+}

package/node_modules/playwright/lib/dom-analyzer/sectionGrouper.js

@@ -0,0 +1,169 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sectionGrouper_exports = {};
+__export(sectionGrouper_exports, {
+  JUNK_SECTION_NAME_PATTERN: () => JUNK_SECTION_NAME_PATTERN,
+  resolveSections: () => resolveSections
+});
+module.exports = __toCommonJS(sectionGrouper_exports);
+var import_slug = require("./slug");
+const JUNK_SECTION_NAME_PATTERN = /^(content|section|untitled|main|overview|details)$/i;
+function isJunk(candidateSlug) {
+  return !candidateSlug || JUNK_SECTION_NAME_PATTERN.test(candidateSlug);
+}
+function resolveSections(inputs) {
+  const assignments = {};
+  const candidatesByAnchorKey = /* @__PURE__ */ new Map();
+  const elementsByAnchorKey = /* @__PURE__ */ new Map();
+  const headingAnchorChainByElement = /* @__PURE__ */ new Map();
+  for (const inp of inputs) {
+    const { landmarkAncestor, sectioningAncestor, headingAncestry } = inp.ancestry;
+    if (landmarkAncestor) {
+      const name = landmarkAncestor.nameHint;
+      assignments[inp.id] = name;
+      candidatesByAnchorKey.set(landmarkAncestor.anchorKey, {
+        name,
+        landmark: landmarkAncestor.landmark,
+        anchorKey: landmarkAncestor.anchorKey
+      });
+      const arr2 = elementsByAnchorKey.get(landmarkAncestor.anchorKey) ?? [];
+      arr2.push(inp.id);
+      elementsByAnchorKey.set(landmarkAncestor.anchorKey, arr2);
+      continue;
+    }
+    if (sectioningAncestor) {
+      const rawName = sectioningAncestor.accessibleName;
+      if (rawName) {
+        const candidateSlug = (0, import_slug.slug)(rawName);
+        if (!isJunk(candidateSlug)) {
+          assignments[inp.id] = candidateSlug;
+          candidatesByAnchorKey.set(sectioningAncestor.anchorKey, {
+            name: candidateSlug,
+            landmark: "other",
+            landmarkOther: sectioningAncestor.tagName,
+            anchorKey: sectioningAncestor.anchorKey
+          });
+          const arr2 = elementsByAnchorKey.get(sectioningAncestor.anchorKey) ?? [];
+          arr2.push(inp.id);
+          elementsByAnchorKey.set(sectioningAncestor.anchorKey, arr2);
+          continue;
+        }
+      }
+    }
+    let assignedFromHeading = false;
+    for (let i = headingAncestry.length - 1; i >= 0; i--) {
+      const h = headingAncestry[i];
+      const candidateSlug = (0, import_slug.slug)(h.text);
+      if (!isJunk(candidateSlug)) {
+        let finalName = candidateSlug;
+        let suffix = 2;
+        while ([...candidatesByAnchorKey.values()].some((c) => c.name === finalName && c.anchorKey !== h.anchorKey)) {
+          finalName = `${candidateSlug}_${suffix++}`;
+        }
+        assignments[inp.id] = finalName;
+        candidatesByAnchorKey.set(h.anchorKey, {
+          name: finalName,
+          landmark: "other",
+          landmarkOther: "heading",
+          anchorKey: h.anchorKey
+        });
+        const arr2 = elementsByAnchorKey.get(h.anchorKey) ?? [];
+        arr2.push(inp.id);
+        elementsByAnchorKey.set(h.anchorKey, arr2);
+        headingAnchorChainByElement.set(
+          inp.id,
+          headingAncestry.map((hh) => hh.anchorKey)
+        );
+        assignedFromHeading = true;
+        break;
+      }
+    }
+    if (assignedFromHeading) continue;
+    assignments[inp.id] = "page";
+    const pageAnchorKey = "page-fallback";
+    candidatesByAnchorKey.set(pageAnchorKey, { name: "page", landmark: "region", anchorKey: pageAnchorKey });
+    const arr = elementsByAnchorKey.get(pageAnchorKey) ?? [];
+    arr.push(inp.id);
+    elementsByAnchorKey.set(pageAnchorKey, arr);
+  }
+  const candidateAnchorKeysWithElements = new Set(
+    [...elementsByAnchorKey.entries()].filter(([, ids]) => ids.length > 0).map(([k]) => k)
+  );
+  const toDrop = /* @__PURE__ */ new Set();
+  for (const [anchorKey, info] of candidatesByAnchorKey.entries()) {
+    if (info.landmarkOther !== "heading") continue;
+    let isAncestor = false;
+    for (const [, chain] of headingAnchorChainByElement.entries()) {
+      const idx = chain.indexOf(anchorKey);
+      if (idx === -1) continue;
+      for (let j = idx + 1; j < chain.length; j++) {
+        const deeperKey = chain[j];
+        if (candidateAnchorKeysWithElements.has(deeperKey) && deeperKey !== anchorKey) {
+          isAncestor = true;
+          break;
+        }
+      }
+      if (isAncestor) break;
+    }
+    if (isAncestor) toDrop.add(anchorKey);
+  }
+  for (const droppedKey of toDrop) {
+    const affectedIds = elementsByAnchorKey.get(droppedKey) ?? [];
+    for (const id of affectedIds) {
+      const chain = headingAnchorChainByElement.get(id) ?? [];
+      let reassigned = null;
+      for (let i = chain.length - 1; i >= 0; i--) {
+        const k = chain[i];
+        if (k === droppedKey) continue;
+        if (toDrop.has(k)) continue;
+        const cand = candidatesByAnchorKey.get(k);
+        if (cand && cand.landmarkOther === "heading") {
+          reassigned = cand.name;
+          break;
+        }
+      }
+      assignments[id] = reassigned ?? "page";
+    }
+    candidatesByAnchorKey.delete(droppedKey);
+    elementsByAnchorKey.delete(droppedKey);
+  }
+  const sections = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const assignmentOrder = [];
+  for (const inp of inputs) {
+    const name = assignments[inp.id];
+    if (name && !assignmentOrder.includes(name)) assignmentOrder.push(name);
+  }
+  for (const name of assignmentOrder) {
+    if (seenNames.has(name)) continue;
+    seenNames.add(name);
+    const info = [...candidatesByAnchorKey.values()].find((c) => c.name === name);
+    if (info) {
+      sections.push({ name: info.name, landmark: info.landmark, landmarkOther: info.landmarkOther });
+    } else if (name === "page") {
+      sections.push({ name: "page", landmark: "region" });
+    }
+  }
+  return { assignments, sections };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JUNK_SECTION_NAME_PATTERN,
+  resolveSections
+});