@tooluminati/testing 0.1.0

package/dist/index.cjs

@@ -0,0 +1,473 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+
+// src/browser-helpers.ts
+var browser_helpers_exports = {};
+__export(browser_helpers_exports, {
+  expectWebMcpTool: () => expectWebMcpTool,
+  invokeWebMcpTool: () => invokeWebMcpTool
+});
+async function expectWebMcpTool(page, name) {
+  const exists = await page.evaluate(async (toolName) => {
+    const context = document.modelContext;
+    const tools = await context?.getTools?.() ?? [];
+    return tools.some((tool) => tool.name === toolName);
+  }, name);
+  if (!exists) {
+    throw new Error(`Expected WebMCP tool "${name}" to be registered.`);
+  }
+}
+async function invokeWebMcpTool(page, name, args) {
+  return page.evaluate(
+    async ({ toolName, input }) => {
+      const context = document.modelContext;
+      const tools = await context?.getTools?.() ?? [];
+      const tool = tools.find((candidate) => candidate.name === toolName);
+      if (!tool || !context?.executeTool) {
+        throw new Error(`WebMCP tool "${toolName}" cannot be invoked.`);
+      }
+      return context.executeTool(tool, JSON.stringify(input));
+    },
+    { toolName: name, input: args }
+  );
+}
+var init_browser_helpers = __esm({
+  "src/browser-helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/dom-only-inspection.ts
+function pushUnique(target, value) {
+  const trimmed = value?.trim();
+  if (!trimmed || target.includes(trimmed)) {
+    return;
+  }
+  target.push(trimmed);
+}
+function collectDisabledActionReasonsFromDom(root, buttonLabel) {
+  const buttons = [...root.querySelectorAll("button")];
+  const button = buttons.find(
+    (candidate) => candidate.textContent?.includes(buttonLabel)
+  );
+  if (!button) {
+    return {
+      label: buttonLabel,
+      disabled: false,
+      visibleBlockerReasons: []
+    };
+  }
+  const visibleBlockerReasons = [];
+  pushUnique(visibleBlockerReasons, button.getAttribute("title"));
+  pushUnique(
+    visibleBlockerReasons,
+    button.getAttribute("aria-label")?.includes("because") ? button.getAttribute("aria-label") : null
+  );
+  const describedBy = button.getAttribute("aria-describedby");
+  if (describedBy) {
+    for (const id of describedBy.split(/\s+/)) {
+      pushUnique(
+        visibleBlockerReasons,
+        root.getElementById(id)?.textContent
+      );
+    }
+  }
+  const fieldset = button.closest("fieldset");
+  if (fieldset) {
+    pushUnique(
+      visibleBlockerReasons,
+      fieldset.querySelector("legend")?.textContent
+    );
+  }
+  const row = button.closest('[data-testid="checkout-row"]');
+  if (row) {
+    pushUnique(
+      visibleBlockerReasons,
+      row.querySelector("[data-dom-blocker-hint]")?.textContent
+    );
+  }
+  return {
+    label: buttonLabel,
+    disabled: button.disabled,
+    visibleBlockerReasons
+  };
+}
+async function inspectDisabledActionFromDom(page, buttonLabel) {
+  return page.evaluate((label) => {
+    const buttons = [...document.querySelectorAll("button")];
+    const button = buttons.find(
+      (candidate) => candidate.textContent?.includes(label)
+    );
+    if (!button) {
+      return {
+        label,
+        disabled: false,
+        visibleBlockerReasons: []
+      };
+    }
+    const visibleBlockerReasons = [];
+    const push = (value) => {
+      const trimmed = value?.trim();
+      if (trimmed && !visibleBlockerReasons.includes(trimmed)) {
+        visibleBlockerReasons.push(trimmed);
+      }
+    };
+    push(button.getAttribute("title"));
+    const ariaLabel = button.getAttribute("aria-label");
+    if (ariaLabel?.includes("because")) {
+      push(ariaLabel);
+    }
+    const describedBy = button.getAttribute("aria-describedby");
+    if (describedBy) {
+      for (const id of describedBy.split(/\s+/)) {
+        push(document.getElementById(id)?.textContent);
+      }
+    }
+    const fieldset = button.closest("fieldset");
+    if (fieldset) {
+      push(fieldset.querySelector("legend")?.textContent);
+    }
+    const row = button.closest('[data-testid="checkout-row"]');
+    if (row) {
+      push(row.querySelector("[data-dom-blocker-hint]")?.textContent);
+    }
+    return {
+      label,
+      disabled: button.disabled,
+      visibleBlockerReasons
+    };
+  }, buttonLabel);
+}
+var init_dom_only_inspection = __esm({
+  "src/dom-only-inspection.ts"() {
+    "use strict";
+  }
+});
+
+// src/comparative-proof.ts
+var comparative_proof_exports = {};
+__export(comparative_proof_exports, {
+  diagnoseCheckoutBlockerFromDomOnly: () => diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp: () => diagnoseCheckoutBlockerFromWebMcp,
+  runComparativeProof: () => runComparativeProof
+});
+async function diagnoseCheckoutBlockerFromDomOnly(page, buttonLabel) {
+  return inspectDisabledActionFromDom(page, buttonLabel);
+}
+async function diagnoseCheckoutBlockerFromWebMcp(page, actionId, toolName = "why_is_action_unavailable") {
+  const result = await invokeWebMcpTool(page, toolName, { actionId });
+  return {
+    actionId: result.actionId,
+    available: result.available,
+    reasons: result.reasons ?? []
+  };
+}
+async function runComparativeProof(page, options) {
+  const domOnly = await diagnoseCheckoutBlockerFromDomOnly(
+    page,
+    options.buttonLabel
+  );
+  const webMcp = await diagnoseCheckoutBlockerFromWebMcp(
+    page,
+    options.actionId,
+    options.toolName
+  );
+  const domBlockerCount = domOnly.visibleBlockerReasons.length;
+  const webMcpBlockerCount = webMcp.reasons.length;
+  return {
+    domOnly,
+    webMcp,
+    domBlockerCount,
+    webMcpBlockerCount,
+    webMcpIsStrictlyMoreInformative: domOnly.disabled && domBlockerCount === 0 && webMcpBlockerCount > 0 && !webMcp.available
+  };
+}
+var init_comparative_proof = __esm({
+  "src/comparative-proof.ts"() {
+    "use strict";
+    init_browser_helpers();
+    init_dom_only_inspection();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MODEL_CONTEXT_MOCK_INIT_SCRIPT: () => MODEL_CONTEXT_MOCK_INIT_SCRIPT,
+  MockModelContext: () => MockModelContext,
+  assertToolSchemaBudgets: () => assertToolSchemaBudgets,
+  collectDisabledActionReasonsFromDom: () => collectDisabledActionReasonsFromDom,
+  createToolCallEvalFixture: () => createToolCallEvalFixture,
+  diagnoseCheckoutBlockerFromDomOnly: () => diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp: () => diagnoseCheckoutBlockerFromWebMcp,
+  executeWebMcpTool: () => executeWebMcpTool,
+  expectWebMcpTool: () => expectWebMcpTool,
+  inspectDisabledActionFromDom: () => inspectDisabledActionFromDom,
+  installModelContextMock: () => installModelContextMock,
+  invokeWebMcpTool: () => invokeWebMcpTool,
+  listWebMcpTools: () => listWebMcpTools,
+  runComparativeProof: () => runComparativeProof,
+  runTimelineComparativeProof: () => runTimelineComparativeProof,
+  runToolSelectionSmokeTest: () => runToolSelectionSmokeTest,
+  snapshotRegisteredTools: () => snapshotRegisteredTools
+});
+module.exports = __toCommonJS(index_exports);
+init_browser_helpers();
+init_comparative_proof();
+
+// src/devtools-mcp-helper.ts
+function getModelContext(host = document) {
+  return host.modelContext;
+}
+async function listWebMcpTools(host = document) {
+  const context = getModelContext(host);
+  if (!context?.getTools) {
+    return [];
+  }
+  const tools = await context.getTools();
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description
+  }));
+}
+async function executeWebMcpTool(name, args = {}, host = document) {
+  const context = getModelContext(host);
+  if (!context?.getTools || !context.executeTool) {
+    throw new Error(
+      "WebMCP model context is unavailable. Use installModelContextMock() in tests."
+    );
+  }
+  const tools = await context.getTools();
+  const tool = tools.find((candidate) => candidate.name === name);
+  if (!tool) {
+    throw new Error(`WebMCP tool not found: ${name}`);
+  }
+  return context.executeTool(tool, JSON.stringify(args));
+}
+
+// src/index.ts
+init_dom_only_inspection();
+
+// src/mock-model-context.ts
+var MockModelContext = class extends EventTarget {
+  tools = /* @__PURE__ */ new Map();
+  invocations = [];
+  registerTool(tool, options = {}) {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`Tool already registered: ${tool.name}`);
+    }
+    if (options.signal?.aborted) {
+      return;
+    }
+    this.tools.set(tool.name, tool);
+    this.dispatchEvent(new Event("toolchange"));
+    options.signal?.addEventListener(
+      "abort",
+      () => {
+        this.tools.delete(tool.name);
+        this.dispatchEvent(new Event("toolchange"));
+      },
+      { once: true }
+    );
+  }
+  async getTools() {
+    return [...this.tools.values()];
+  }
+  async executeTool(toolOrName, argsJson = "{}") {
+    const name = typeof toolOrName === "string" ? toolOrName : toolOrName.name;
+    if (!name) {
+      throw new Error("Tool name is required.");
+    }
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    const args = JSON.parse(argsJson);
+    try {
+      const result = await tool.execute(args, {
+        signal: new AbortController().signal
+      });
+      this.invocations.push({ name, args, result });
+      return result;
+    } catch (error) {
+      this.invocations.push({ name, args, error });
+      throw error;
+    }
+  }
+};
+
+// src/install-model-context-mock.ts
+function installModelContextMock(target = "document") {
+  const mock = new MockModelContext();
+  const host = target === "document" ? document : navigator;
+  Object.defineProperty(host, "modelContext", {
+    configurable: true,
+    value: mock
+  });
+  return mock;
+}
+
+// src/model-context-mock-script.ts
+var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
+(() => {
+  const tools = new Map();
+
+  Object.defineProperty(document, 'modelContext', {
+    configurable: true,
+    value: {
+      registerTool(tool, options = {}) {
+        if (options.signal?.aborted) {
+          return;
+        }
+
+        tools.set(tool.name, tool);
+        options.signal?.addEventListener(
+          'abort',
+          () => {
+            tools.delete(tool.name);
+          },
+          { once: true },
+        );
+      },
+      async getTools() {
+        return [...tools.values()];
+      },
+      async executeTool(toolOrName, argsJson = '{}') {
+        const name =
+          typeof toolOrName === 'string'
+            ? toolOrName
+            : toolOrName?.name;
+        const tool = name ? tools.get(name) : undefined;
+        if (!tool) {
+          throw new Error('Tool not found: ' + name);
+        }
+
+        return tool.execute(JSON.parse(argsJson));
+      },
+    },
+  });
+})();
+`;
+
+// src/webmcp-evals.ts
+var BUDGETS = {
+  name: 30,
+  paramName: 30,
+  paramDescription: 150,
+  description: 500,
+  output: 1500
+};
+function walkSchemaProperties(schema, visit) {
+  if (!schema || typeof schema !== "object") {
+    return;
+  }
+  const node = schema;
+  const properties = node.properties;
+  if (properties && typeof properties === "object") {
+    for (const [name, child] of Object.entries(properties)) {
+      if (child && typeof child === "object") {
+        visit(name, child);
+      }
+    }
+  }
+}
+async function snapshotRegisteredTools(page) {
+  return page.evaluate(() => {
+    const context = document.modelContext;
+    if (!context?.getTools) {
+      return [];
+    }
+    return context.getTools().then(
+      (tools) => tools.map((tool) => ({
+        name: String(tool.name ?? ""),
+        description: String(tool.description ?? ""),
+        inputSchema: tool.inputSchema,
+        ...tool.annotations ? { annotations: tool.annotations } : {}
+      }))
+    );
+  });
+}
+function createToolCallEvalFixture(tools, cases) {
+  return { tools, cases };
+}
+function assertToolSchemaBudgets(tools) {
+  const violations = [];
+  for (const tool of tools) {
+    if (tool.name.length > BUDGETS.name) {
+      violations.push(`Tool name too long: ${tool.name}`);
+    }
+    if (tool.description.length > BUDGETS.description) {
+      violations.push(`Description too long: ${tool.name}`);
+    }
+    walkSchemaProperties(tool.inputSchema, (name, node) => {
+      if (name.length > BUDGETS.paramName) {
+        violations.push(`Param name too long on ${tool.name}: ${name}`);
+      }
+      const description = node.description;
+      if (typeof description === "string" && description.length > BUDGETS.paramDescription) {
+        violations.push(`Param description too long on ${tool.name}.${name}`);
+      }
+    });
+  }
+  return violations;
+}
+function runToolSelectionSmokeTest(tools, prompt, expected) {
+  const haystack = `${prompt} ${tools.map((t) => t.description).join(" ")}`.toLowerCase();
+  return haystack.includes(expected.toLowerCase()) || tools.some((t) => t.name === expected);
+}
+async function runTimelineComparativeProof(page, options) {
+  const { runComparativeProof: runComparativeProof2 } = await Promise.resolve().then(() => (init_comparative_proof(), comparative_proof_exports));
+  const { invokeWebMcpTool: invokeWebMcpTool2 } = await Promise.resolve().then(() => (init_browser_helpers(), browser_helpers_exports));
+  const proof = await runComparativeProof2(page, {
+    buttonLabel: options.buttonLabel,
+    actionId: options.actionId
+  });
+  const timeline = await invokeWebMcpTool2(
+    page,
+    options.timelineTool ?? "get_troubleshooting_timeline",
+    {}
+  );
+  return {
+    domBlockerCount: proof.domBlockerCount,
+    timelineEventCount: timeline.events?.length ?? 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODEL_CONTEXT_MOCK_INIT_SCRIPT,
+  MockModelContext,
+  assertToolSchemaBudgets,
+  collectDisabledActionReasonsFromDom,
+  createToolCallEvalFixture,
+  diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp,
+  executeWebMcpTool,
+  expectWebMcpTool,
+  inspectDisabledActionFromDom,
+  installModelContextMock,
+  invokeWebMcpTool,
+  listWebMcpTools,
+  runComparativeProof,
+  runTimelineComparativeProof,
+  runToolSelectionSmokeTest,
+  snapshotRegisteredTools
+});

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @experimental Tooluminati testing utilities — public APIs may change.
+ */
+export * from './browser-helpers';
+export * from './comparative-proof';
+export * from './devtools-mcp-helper';
+export * from './dom-only-inspection';
+export * from './install-model-context-mock';
+export * from './mock-model-context';
+export * from './model-context-mock-script';
+export * from './webmcp-evals';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC"}