@wix/mcp 1.0.82 → 1.0.84

package/build/bin-standalone.js

@@ -72384,6 +72384,32 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
 
     Call this when the user provides a specific template by \`metaSiteId\` or \`templateId\`. Use this only when the user gives a valid \`metaSiteId\` or \`templateId\` directly. To browse or choose a template first, call \`SearchSiteTemplates\`.
 
+  `,
+    SearchWixGraphQLOperations: dedent_default`
+    Discover Wix GraphQL operations by intent (ranked keyword search over the root fields). Wix exposes ONE GraphQL schema over all Wix public APIs (Developer Preview) at POST https://www.wixapis.com/graphql/alpha: about 100 query roots and 580 mutation roots named <app><Service><Version><Verb/Entity>, e.g. \`storesProductsV3V3Products\`, \`crmContactsV4Contacts\`, \`crmContactsV4CreateContact\`, \`ecomOrdersV1SearchOrders\`.
+
+    GraphQL flow (3 steps, keep to it): SearchWixGraphQLOperations (find the operation) -> InspectWixGraphQLSchema (read its exact input and return types) -> ExecuteWixGraphQL (run it). Never write an operation or field name you did not see in one of these results.
+
+    When to prefer GraphQL over the REST tools:
+    - Reading several related entities in ONE round-trip: related entities are resolved fields (product -> inventoryItems / collections, order -> fulfillments, booking -> contact), and independent root fields (products + contacts + orders) can share one request.
+    - Picking exactly the fields you need, so responses stay small.
+    - Answering "how many / list / show" questions: a query root plus \`pageInfo\` (\`hasNext\`, and \`total\` where the API provides it).
+    Prefer the REST tools when a recipe or code example already gives you the exact REST call, for uploads/media, or when the GraphQL schema has no matching operation.
+
+    Conventions: query roots take \`queryInput\`; list roots (plural names) take \`queryInput: { query: { paging | cursorPaging, filter, sort } }\` and return \`{ items, pageInfo }\`; singular roots take the entity id. \`filter\`/\`sort\` are a JSON scalar in REST filter syntax (e.g. {"info.name.first": {"$eq": "Ada"}}) — pass them as variables. Mutations take \`input\`; a few read operations (search/list) are exposed as mutations, so search kind "all" unless you are sure.
+    Results list \`kind name(arg: InputType): ReturnType\` plus a one-line description; pass the chosen name to InspectWixGraphQLSchema next.
+  `,
+    InspectWixGraphQLSchema: dedent_default`
+    Read the exact Wix GraphQL schema for an operation and its types, as compact SDL with field descriptions. Pass \`operation\` (a root query/mutation name from SearchWixGraphQLOperations) to get its arguments, input type and return type expanded \`depth\` levels (default 2). Types that were referenced but not expanded are listed at the end — pass the ones you need in \`typeNames\` (optionally together with \`operation\`) instead of raising depth for everything.
+    Use it before every ExecuteWixGraphQL call that introduces a new operation or new fields: read the INPUT type before writing a mutation or filter, and the RETURN type before writing the selection set. GraphQL rejects unknown fields and arguments, and every object-typed field needs its own selection set. \`JSON\` scalar fields (filter, sort, free-form data) accept any JSON — pass them as variables. Never guess a type or field name; if a validation error names a field, come back here.
+  `,
+    ExecuteWixGraphQL: dedent_default`
+    Execute a GraphQL query or mutation against the Wix GraphQL API (POST https://www.wixapis.com/graphql/alpha) with the user's credentials. Authentication is injected — never add Authorization or site/account headers.
+    Site targeting: site-level operations (anything that reads or writes inside a site: products, inventory, orders, contacts, bookings, CMS data, blog, members ...) require \`siteId\`; resolve it with GetSiteContext or ListWixSites first. Use \`scope: "account"\` only for account-level operations.
+    Grounding: every root field, argument and selected field must come from SearchWixGraphQLOperations / InspectWixGraphQLSchema results in this conversation — never from memory. If the response says "Cannot query field" or "Unknown argument", re-inspect the schema and fix the name; do not retry with another guess.
+    Compose: put independent reads in one document as several root fields, and use related-entity fields (e.g. \`inventoryItems\`, \`collections\`, \`fulfillments\`) instead of extra round-trips. Select only the fields you need; every object field needs a selection set. Variables: use them for \`JSON\` scalars (filter, sort) and plain scalars (String, Int, ID), declared in the document (e.g. \`query Q($f: JSON) { ... filter: $f ... }\`). Write mutation inputs and any object that contains an enum INLINE as GraphQL literals with enum values unquoted (e.g. \`input: { product: { name: "Mug", productType: PHYSICAL } }\`) — this endpoint fails with 503 when an enum value arrives inside an object-typed variable. For lists page with \`cursorPaging\` or \`paging\` exactly as the input type declares (never the other one), and request \`pageInfo { hasNext total }\`; \`total\` is only populated with offset \`paging\`, so for a cursor-paged list count by walking pages or use a count operation.
+    Results: each root field fails independently — \`errors[].path\` names the failing field and \`errors[].extensions.message\` the cause (e.g. PERMISSION_DENIED); \`data\` still holds the fields that succeeded. Mutations return the created/updated entity — read the IDs from it and do not re-query to verify. Large results are truncated: narrow the selection or page size instead of re-running.
+    Set \`hasMutations: true\` for any document containing a mutation root field.
   `,
     CreateWixBusinessGuide: dedent_default`
     Provides comprehensive documentation for creating a new Wix business (site, app, etc.).
@@ -73072,6 +73098,27 @@ var paramDescriptions = {
     mimeType: 'MIME type of the image (e.g. "image/jpeg", "image/png", "image/webp"). Required when imageBase64 does not include a data URL prefix.',
     displayName: "Optional display name for the file in Media Manager. If not provided, uses the original filename."
   },
+  SearchWixGraphQLOperations: {
+    query: 'Free-text intent or entity, e.g. "products with inventory", "create contact", "orders", "blog posts", "booking services". Operation names encode app + service + version + verb/entity (e.g. storesProductsV3V3Products, crmContactsV4CreateContact), so a noun plus a verb (query/get/create/update/delete) ranks best. You may also pass an exact operation name.',
+    kind: 'Restrict to "query" (reads), "mutation" (writes \u2014 note a few reads such as search/list calls are exposed as mutations), or "all" (default).',
+    maxResults: "Maximum number of operations to return (default 10, max 50).",
+    reason: "One sentence describing the original user request and why you are looking for a GraphQL operation."
+  },
+  InspectWixGraphQLSchema: {
+    operation: 'Exact root query or mutation name from SearchWixGraphQLOperations (e.g. "crmContactsV4Contacts"). Returns its arguments, input type and return type as compact SDL, expanded `depth` levels.',
+    typeNames: 'Type names to expand, e.g. ones listed as "Not expanded" in a previous result, or a nested input/object/enum type you need before writing the request. Can be combined with `operation`.',
+    depth: "How many levels of referenced types to expand (1-4, default 2). Level 1 is the given types, level 2 the types their fields reference, and so on. Keep it small and expand specific types with typeNames instead of dumping everything.",
+    reason: "One sentence describing the original user request and why you need this part of the GraphQL schema."
+  },
+  ExecuteWixGraphQL: {
+    query: "The GraphQL document (a query or a mutation). Every root field, argument and selected field MUST come from SearchWixGraphQLOperations / InspectWixGraphQLSchema results in this conversation, never from memory. Declare variables for filters, sort and large inputs, e.g. `query Q($f: JSON) { crmContactsV4Contacts(queryInput: { query: { filter: $f, paging: { limit: 50 } } }) { items { id } pageInfo { hasNext } } }`. Object-typed fields need a selection set. You can put several independent root fields in one document.",
+    variables: 'Variables object for the document, as a JSON object (not a string). Use it for JSON-scalar filters/sort (REST filter syntax, e.g. {"info.name.first": {"$eq": "Ada"}}) and plain scalars. Do NOT pass object inputs that contain enum values (product types, statuses, registration types ...) through variables \u2014 write those inline in the document with the enum unquoted; the endpoint returns 503 otherwise.',
+    operationName: "Operation to run when the document defines more than one named operation.",
+    siteId: "The Wix site to run against. Required for site-level operations (anything reading or writing inside a site \u2014 products, orders, contacts, bookings, CMS, blog, members ...). Resolve it with GetSiteContext or ListWixSites; never pass a guessed value.",
+    scope: '"site" (default when siteId is given) runs with a site-scoped credential; "account" runs account-level operations (sites, account settings) and ignores siteId.',
+    hasMutations: "Whether this document creates, updates, deletes or otherwise mutates Wix data. True for any mutation root field (in any operation of the document) even when the intent is inspection; false only for pure queries. This flag alone decides whether a transient server error may be retried, so never mark a document that writes as false.",
+    reason: "One sentence explaining the original user request and why you are running this GraphQL operation to complete it."
+  },
   RunWixCliCommand: {
     appPath: "The full path to the Wix CLI app to run the command on.",
     extensionType: "The type of extension to generate. You MUST provide this for commands that generate extensions.",
@@ -73306,7 +73353,16 @@ ${skillsContent}`
       ] : await Promise.all(
         baseDocs.filter((doc) => doc.url === RECIPES_INDEX_URL).map(fetchDoc)
       );
-      const contents = [...baseContents, ...recipesContents];
+      const recipeNotes = !skillsContent?.includes("Dashboard Navigation") ? [] : [
+        await fetchDoc({
+          action: "text",
+          title: "Recipe Notes",
+          content: dedent_default`
+                - **Navigation recipes** (the *Dashboard Navigation* family) build direct manage.wix.com URLs. If your environment provides dedicated navigation tools, use those to perform the actual navigation — opening a recipe-built URL forces a full page refresh. Use the recipe URLs for composing a link to hand the user, or for navigating when no dedicated tool exists.
+              `
+        })
+      ];
+      const contents = [...baseContents, ...recipesContents, ...recipeNotes];
       const dynamicContext = await dynamicContextPromise;
       const parts = [
         ...contents.filter(
@@ -86592,6 +86648,775 @@ function createAccountFileAuthStrategy({
   };
 }
 
+// src/code-mode/truncate-response.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_MAX_TOKENS = 6e3;
+var DEFAULT_MAX_CHARS = DEFAULT_MAX_TOKENS * CHARS_PER_TOKEN;
+function truncateResponse(content, maxChars = DEFAULT_MAX_CHARS) {
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  const effectiveMax = Math.min(maxChars, MAX_ALLOWED_RESPONSE_CHARS);
+  if (!text || text.length <= effectiveMax) {
+    return text ?? "";
+  }
+  const truncated = text.slice(0, effectiveMax);
+  const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+  const limitTokens = Math.ceil(effectiveMax / CHARS_PER_TOKEN);
+  return `${truncated}
+
+--- TRUNCATED ---
+Response was ~${estimatedTokens.toLocaleString()} tokens (limit: ${limitTokens.toLocaleString()}). Refine your code to return less data.`;
+}
+
+// src/graphql/constants.ts
+var WIX_GRAPHQL_ENDPOINT = "https://www.wixapis.com/graphql/alpha";
+var SEARCH_GRAPHQL_TOOL_NAME = "SearchWixGraphQLOperations";
+var INSPECT_GRAPHQL_TOOL_NAME = "InspectWixGraphQLSchema";
+var EXECUTE_GRAPHQL_TOOL_NAME = "ExecuteWixGraphQL";
+
+// src/graphql/introspection.ts
+var TYPE_REF_FRAGMENT = `
+fragment TR on __Type { kind name ofType { kind name ofType { kind name ofType { kind name } } } }`;
+var ROOT_OPERATIONS_QUERY = `{
+  __schema {
+    queryType { fields { name description args { name type { ...TR } } type { ...TR } } }
+    mutationType { fields { name description args { name type { ...TR } } type { ...TR } } }
+  }
+}${TYPE_REF_FRAGMENT}`;
+var TYPE_DETAILS_FRAGMENT = `
+fragment TD on __Type {
+  kind name description
+  fields { name description type { ...TR } args { name type { ...TR } } }
+  inputFields { name description type { ...TR } defaultValue }
+  enumValues { name description }
+  possibleTypes { name }
+}`;
+var ROOT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+var rootCache;
+var typeCache = /* @__PURE__ */ new Map();
+var RETRY_DELAYS_MS = [800, 2e3, 4e3];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function fetchWithRetry(fetchImpl, url, init2, delays = RETRY_DELAYS_MS) {
+  let attempt = 0;
+  for (; ; ) {
+    const resp = await fetchImpl(url, init2);
+    if (resp.status < 500 || attempt >= delays.length) return resp;
+    await sleep(delays[attempt++]);
+  }
+}
+async function postIntrospection(query, options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const endpoint = options.endpoint ?? WIX_GRAPHQL_ENDPOINT;
+  const resp = await fetchWithRetry(
+    fetchImpl,
+    endpoint,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({ query })
+    },
+    options.retryDelaysMs
+  );
+  const text = await resp.text();
+  if (!resp.ok) {
+    const body = /^\s*<(!doctype|html)/i.test(text) ? "(HTML error page \u2014 the endpoint is temporarily unavailable; try again in a moment)" : text.slice(0, 500);
+    throw new Error(
+      `GraphQL introspection failed (${resp.status} ${resp.statusText}): ${body}`
+    );
+  }
+  const json = JSON.parse(text);
+  if (json.errors?.length && !json.data) {
+    throw new Error(
+      `GraphQL introspection returned errors: ${JSON.stringify(json.errors).slice(0, 500)}`
+    );
+  }
+  return json.data;
+}
+function getRootOperations(options = {}) {
+  const now = Date.now();
+  if (rootCache && now - rootCache.fetchedAt < ROOT_CACHE_TTL_MS) {
+    return rootCache.promise;
+  }
+  const promise = postIntrospection(ROOT_OPERATIONS_QUERY, options).then(
+    (data) => {
+      const toOps = (fields, kind) => (fields ?? []).map((f) => ({
+        kind,
+        name: f.name,
+        description: f.description ?? "",
+        args: f.args ?? [],
+        type: f.type
+      }));
+      return [
+        ...toOps(data?.__schema?.queryType?.fields, "query"),
+        ...toOps(data?.__schema?.mutationType?.fields, "mutation")
+      ];
+    }
+  );
+  promise.catch(() => {
+    if (rootCache?.promise === promise) rootCache = void 0;
+  });
+  rootCache = { promise, fetchedAt: now };
+  return promise;
+}
+var GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
+var TYPE_BATCH_SIZE = 10;
+async function getTypes(names, options = {}) {
+  const unique = [...new Set(names)].filter((n2) => GRAPHQL_NAME.test(n2));
+  const missing = unique.filter((n2) => !typeCache.has(n2));
+  for (let start = 0; start < missing.length; start += TYPE_BATCH_SIZE) {
+    const chunk = missing.slice(start, start + TYPE_BATCH_SIZE);
+    const selections = chunk.map((n2, i2) => `t${i2}: __type(name: "${n2}") { ...TD }`).join("\n");
+    const query = `{
+${selections}
+}${TYPE_DETAILS_FRAGMENT}${TYPE_REF_FRAGMENT}`;
+    const batch = postIntrospection(query, options);
+    chunk.forEach((n2, i2) => {
+      const p = batch.then(
+        (data) => data?.[`t${i2}`] ?? null
+      );
+      p.catch(() => {
+        if (typeCache.get(n2) === p) typeCache.delete(n2);
+      });
+      typeCache.set(n2, p);
+    });
+    await batch.catch(() => void 0);
+  }
+  const result = /* @__PURE__ */ new Map();
+  await Promise.all(
+    unique.map(async (n2) => {
+      result.set(n2, await typeCache.get(n2));
+    })
+  );
+  return result;
+}
+function renderTypeRef(ref) {
+  if (!ref) return "Unknown";
+  if (ref.kind === "NON_NULL") return `${renderTypeRef(ref.ofType)}!`;
+  if (ref.kind === "LIST") return `[${renderTypeRef(ref.ofType)}]`;
+  return ref.name ?? "Unknown";
+}
+function namedType(ref) {
+  let cur = ref;
+  while (cur && (cur.kind === "NON_NULL" || cur.kind === "LIST")) {
+    cur = cur.ofType ?? null;
+  }
+  return cur?.name ?? null;
+}
+var BUILTIN_SCALARS = /* @__PURE__ */ new Set([
+  "String",
+  "Int",
+  "Float",
+  "Boolean",
+  "ID",
+  "JSON"
+]);
+function isBuiltinScalar(name) {
+  return !!name && BUILTIN_SCALARS.has(name);
+}
+function oneLine(text, max) {
+  if (!text) return "";
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function renderField(field, isInput) {
+  const args = !isInput && field.args?.length ? `(${field.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ")})` : "";
+  const def = isInput && field.defaultValue != null ? ` = ${field.defaultValue}` : "";
+  const comment = field.description ? `  # ${oneLine(field.description, 140)}` : "";
+  return `  ${field.name}${args}: ${renderTypeRef(field.type)}${def}${comment}`;
+}
+function renderType(type) {
+  const references = /* @__PURE__ */ new Set();
+  const collect = (ref) => {
+    const n2 = namedType(ref);
+    if (n2 && !isBuiltinScalar(n2) && n2 !== type.name) references.add(n2);
+  };
+  const header = type.description ? `# ${oneLine(type.description, 200)}
+` : "";
+  let body;
+  switch (type.kind) {
+    case "ENUM":
+      body = `enum ${type.name} {
+${(type.enumValues ?? []).map(
+        (v) => `  ${v.name}${v.description ? `  # ${oneLine(v.description, 100)}` : ""}`
+      ).join("\n")}
+}`;
+      break;
+    case "INPUT_OBJECT":
+      (type.inputFields ?? []).forEach((f) => collect(f.type));
+      body = `input ${type.name} {
+${(type.inputFields ?? []).map((f) => renderField(f, true)).join("\n")}
+}`;
+      break;
+    case "UNION":
+      (type.possibleTypes ?? []).forEach((p) => references.add(p.name));
+      body = `union ${type.name} = ${(type.possibleTypes ?? []).map((p) => p.name).join(" | ")}`;
+      break;
+    case "SCALAR":
+      body = `scalar ${type.name}`;
+      break;
+    default: {
+      (type.fields ?? []).forEach((f) => {
+        collect(f.type);
+        f.args?.forEach((a2) => collect(a2.type));
+      });
+      const keyword = type.kind === "INTERFACE" ? "interface" : "type";
+      body = `${keyword} ${type.name} {
+${(type.fields ?? []).map((f) => renderField(f, false)).join("\n")}
+}`;
+    }
+  }
+  return { text: header + body, references: [...references] };
+}
+function renderOperationSignature(op) {
+  const args = op.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ");
+  return `${op.kind === "query" ? "Query" : "Mutation"}.${op.name}(${args}): ${renderTypeRef(op.type)}`;
+}
+async function expandTypes(rootTypeNames, options = {}) {
+  const depth = Math.max(1, Math.min(options.depth ?? 2, 5));
+  const maxTypes = options.maxTypes ?? 40;
+  const rendered = [];
+  const unknown2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  let frontier = [...new Set(rootTypeNames)].filter((n2) => !isBuiltinScalar(n2));
+  let level = 1;
+  let overflow = [];
+  while (frontier.length > 0 && level <= depth) {
+    const room = maxTypes - seen.size;
+    if (room <= 0) {
+      overflow = frontier;
+      break;
+    }
+    const batch = frontier.slice(0, room);
+    overflow = frontier.slice(room);
+    batch.forEach((n2) => seen.add(n2));
+    const types = await getTypes(batch, options);
+    const next = /* @__PURE__ */ new Set();
+    for (const name of batch) {
+      const type = types.get(name);
+      if (!type) {
+        unknown2.push(name);
+        continue;
+      }
+      const { text, references } = renderType(type);
+      rendered.push(text);
+      references.forEach((r) => {
+        if (!seen.has(r)) next.add(r);
+      });
+    }
+    frontier = [...next];
+    level++;
+  }
+  const unexpanded = [.../* @__PURE__ */ new Set([...overflow, ...frontier])].filter(
+    (n2) => !seen.has(n2) && !isBuiltinScalar(n2)
+  );
+  return { rendered, unexpanded, unknown: unknown2 };
+}
+
+// src/graphql/search.ts
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-zA-Z])([0-9])/g, "$1 $2").replace(/([0-9])([a-zA-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "of",
+  "for",
+  "to",
+  "in",
+  "on",
+  "with",
+  "and",
+  "or",
+  "by",
+  "all",
+  "my",
+  "me",
+  "i",
+  "from",
+  "is",
+  "are",
+  "be",
+  "it",
+  "this",
+  "that",
+  "wix",
+  "api",
+  "graphql"
+]);
+function stem(token) {
+  if (token.length > 4 && token.endsWith("ies"))
+    return `${token.slice(0, -3)}y`;
+  if (token.length > 3 && token.endsWith("es") && !token.endsWith("ses"))
+    return token.slice(0, -1);
+  if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss"))
+    return token.slice(0, -1);
+  return token;
+}
+var VERB_SYNONYMS = {
+  list: ["query", "list", "search"],
+  find: ["query", "search", "get"],
+  fetch: ["get", "query"],
+  read: ["get", "query"],
+  show: ["get", "query"],
+  count: ["count", "query"],
+  add: ["create", "add"],
+  new: ["create"],
+  insert: ["create"],
+  edit: ["update"],
+  change: ["update"],
+  modify: ["update"],
+  set: ["update"],
+  remove: ["delete", "remove"],
+  destroy: ["delete"],
+  cancel: ["cancel", "delete"],
+  customer: ["contact", "member"],
+  client: ["contact", "member"],
+  item: ["product", "item"],
+  inventory: ["inventory", "stock"],
+  stock: ["inventory", "stock"],
+  post: ["post", "blog"],
+  article: ["post", "blog"],
+  appointment: ["booking", "session"],
+  collection: ["collection", "category", "data"],
+  cms: ["data", "collection"],
+  store: ["stores", "store"]
+};
+function expandQueryTokens(tokens) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of tokens) {
+    if (STOP_WORDS.has(raw)) continue;
+    const s = stem(raw);
+    out.add(s);
+    for (const syn of VERB_SYNONYMS[raw] ?? VERB_SYNONYMS[s] ?? []) {
+      out.add(stem(syn));
+    }
+  }
+  return out;
+}
+var READ_VERBS = /* @__PURE__ */ new Set([
+  "list",
+  "get",
+  "query",
+  "find",
+  "fetch",
+  "read",
+  "show",
+  "retrieve",
+  "search",
+  "count",
+  "view",
+  "see"
+]);
+var WRITE_VERBS = /* @__PURE__ */ new Set([
+  "create",
+  "add",
+  "new",
+  "insert",
+  "update",
+  "edit",
+  "change",
+  "modify",
+  "set",
+  "delete",
+  "remove",
+  "destroy",
+  "cancel",
+  "bulk",
+  "merge",
+  "publish",
+  "send"
+]);
+var isVersionToken = (t) => t === "v" || /^\d+$/.test(t);
+function stripMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[`*_]/g, "");
+}
+function firstSentence(text, max = 220) {
+  const flat = stripMarkdown(text).replace(/\s+/g, " ").trim();
+  const cut = flat.search(/(?<=[.!?])\s/);
+  const sentence = cut > 0 ? flat.slice(0, cut) : flat;
+  return sentence.length > max ? `${sentence.slice(0, max - 1)}\u2026` : sentence;
+}
+var indexCache = /* @__PURE__ */ new WeakMap();
+function indexOperations(ops) {
+  let indexed = indexCache.get(ops);
+  if (!indexed) {
+    indexed = ops.map((op) => ({
+      op,
+      nameTokens: new Set(tokenize(op.name).map(stem)),
+      descTokens: new Set(tokenize(op.description.slice(0, 600)).map(stem))
+    }));
+    indexCache.set(ops, indexed);
+  }
+  return indexed;
+}
+function searchOperations(ops, query, options = {}) {
+  const { kind = "all", maxResults = 10 } = options;
+  const rawTokens = tokenize(query);
+  const terms = expandQueryTokens(rawTokens);
+  const originalTerms = new Set(
+    rawTokens.filter((t) => !STOP_WORDS.has(t)).map(stem)
+  );
+  const exactName = query.trim();
+  const hasWriteVerb = rawTokens.some((t) => WRITE_VERBS.has(t));
+  const nounTokens = rawTokens.filter(
+    (t) => !STOP_WORDS.has(t) && !READ_VERBS.has(t) && !WRITE_VERBS.has(t)
+  );
+  const pluralIntent = nounTokens.length > 0 && nounTokens.some((t) => stem(t) !== t);
+  const readIntent = !hasWriteVerb;
+  const matches = [];
+  for (const { op, nameTokens, descTokens } of indexOperations(ops)) {
+    if (kind !== "all" && op.kind !== kind) continue;
+    let score = 0;
+    let originalHits = 0;
+    const matchedNameTokens = /* @__PURE__ */ new Set();
+    for (const term of terms) {
+      const isOriginal = originalTerms.has(term);
+      if (op.kind === "query" && readIntent && READ_VERBS.has(term)) {
+        score += isOriginal ? 4 : 2;
+        if (isOriginal) originalHits++;
+        if (nameTokens.has(term)) matchedNameTokens.add(term);
+        continue;
+      }
+      if (nameTokens.has(term)) {
+        matchedNameTokens.add(term);
+        score += isOriginal ? 4 : 2;
+        if (isOriginal) originalHits++;
+        continue;
+      }
+      let prefixHit = false;
+      for (const nt of nameTokens) {
+        if (term.length >= 3 && (nt.startsWith(term) || term.startsWith(nt))) {
+          prefixHit = true;
+          matchedNameTokens.add(nt);
+          break;
+        }
+      }
+      if (prefixHit) {
+        score += isOriginal ? 2 : 1;
+        if (isOriginal) originalHits++;
+        continue;
+      }
+      if (descTokens.has(term)) {
+        score += 1;
+        if (isOriginal) originalHits++;
+      }
+    }
+    if (score <= 0 && op.name !== exactName) continue;
+    if (op.name === exactName) score += 100;
+    if (originalTerms.size > 0 && originalHits === originalTerms.size) {
+      score += 3;
+    }
+    const lastToken = tokenize(op.name).filter((t) => !isVersionToken(t)).pop();
+    if (lastToken && nounTokens.length > 0) {
+      const pluralOp = stem(lastToken) !== lastToken;
+      score += pluralOp === pluralIntent ? 0.5 : -0.5;
+    }
+    if (/DoNotCall/i.test(op.name)) score -= 2;
+    for (const nt of nameTokens) {
+      if (!isVersionToken(nt) && !matchedNameTokens.has(nt)) score -= 0.3;
+    }
+    if (readIntent && op.kind === "mutation" && [...nameTokens].some((t) => WRITE_VERBS.has(t))) {
+      score -= 6;
+    }
+    if (op.kind === "query" && readIntent) score += 1;
+    const version3 = op.name.match(/V(\d+)/);
+    if (version3) score += Math.min(Number(version3[1]), 5) * 0.1;
+    if (!op.description) score -= 0.5;
+    score -= op.name.length / 200;
+    if (score <= 0) continue;
+    matches.push({
+      operation: op.name,
+      kind: op.kind,
+      signature: `${op.name}(${op.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ")}): ${renderTypeRef(op.type)}`,
+      description: firstSentence(op.description),
+      inputType: op.args[0] ? namedType(op.args[0].type) : null,
+      returnType: namedType(op.type),
+      score: Math.round(score * 100) / 100
+    });
+  }
+  matches.sort(
+    (a2, b) => b.score - a2.score || a2.operation.localeCompare(b.operation)
+  );
+  return matches.slice(0, Math.max(1, Math.min(maxResults, 50)));
+}
+
+// src/graphql/index.ts
+var textResult = (text) => ({
+  content: [{ type: "text", text }]
+});
+var errorResult = (text) => ({
+  isError: true,
+  content: [{ type: "text", text }]
+});
+var SCHEMA_MAX_RESPONSE_CHARS = 48e3;
+function addGraphqlTools(server2, options = {}) {
+  const { authStrategy, disableTools = [], toolDescriptions } = options;
+  const getDescription = (name) => toolDescriptions?.[name] ?? defaultToolDescriptions[name];
+  if (!disableTools.includes(SEARCH_GRAPHQL_TOOL_NAME)) {
+    addSearchGraphqlTool(
+      server2,
+      getDescription(SEARCH_GRAPHQL_TOOL_NAME),
+      options
+    );
+  }
+  if (!disableTools.includes(INSPECT_GRAPHQL_TOOL_NAME)) {
+    addInspectGraphqlTool(
+      server2,
+      getDescription(INSPECT_GRAPHQL_TOOL_NAME),
+      options
+    );
+  }
+  if (authStrategy && !disableTools.includes(EXECUTE_GRAPHQL_TOOL_NAME)) {
+    addExecuteGraphqlTool(
+      server2,
+      getDescription(EXECUTE_GRAPHQL_TOOL_NAME),
+      authStrategy,
+      options
+    );
+  }
+}
+function introspectionOptions(options) {
+  return {
+    endpoint: options.endpoint,
+    fetchImpl: options.fetchImpl,
+    retryDelaysMs: options.retryDelaysMs
+  };
+}
+function addSearchGraphqlTool(server2, description, options) {
+  const d = desc("SearchWixGraphQLOperations");
+  server2.tool(
+    SEARCH_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      query: external_exports.string().describe(d.query),
+      kind: external_exports.enum(["query", "mutation", "all"]).optional().describe(d.kind),
+      maxResults: external_exports.number().int().min(1).max(50).optional().describe(d.maxResults),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ query, kind, maxResults, reason }) => {
+      logger2.log(
+        `[${SEARCH_GRAPHQL_TOOL_NAME}] query="${query}" kind=${kind ?? "all"} reason="${reason}"`
+      );
+      try {
+        const ops = await getRootOperations(introspectionOptions(options));
+        const matches = searchOperations(ops, query, {
+          kind: kind ?? "all",
+          maxResults: maxResults ?? 10
+        });
+        if (matches.length === 0) {
+          return textResult(
+            `No GraphQL operations matched "${query}". Try other words for the entity (e.g. "contact" instead of "customer", "product" instead of "item") or the verb (query/get/create/update/delete), or search a single noun.`
+          );
+        }
+        const lines = matches.map(
+          (m, i2) => `${i2 + 1}. ${m.kind} ${m.signature}
+   ${m.description || "(no description)"}`
+        );
+        const text = [
+          `Top ${matches.length} of ${ops.length} Wix GraphQL root operations for "${query}":`,
+          "",
+          ...lines,
+          "",
+          `Next: call ${INSPECT_GRAPHQL_TOOL_NAME} with \`operation\` set to the chosen name to read its exact input type and return type before writing the request.`
+        ].join("\n");
+        return textResult(text);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${SEARCH_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`GraphQL schema search error: ${message}`);
+      }
+    }
+  );
+}
+function addInspectGraphqlTool(server2, description, options) {
+  const d = desc("InspectWixGraphQLSchema");
+  const maxChars = options.maxResponseSize ?? SCHEMA_MAX_RESPONSE_CHARS;
+  server2.tool(
+    INSPECT_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      operation: external_exports.string().optional().describe(d.operation),
+      typeNames: external_exports.array(external_exports.string()).optional().describe(d.typeNames),
+      depth: external_exports.number().int().min(1).max(4).optional().describe(d.depth),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ operation, typeNames, depth, reason }) => {
+      logger2.log(
+        `[${INSPECT_GRAPHQL_TOOL_NAME}] operation=${operation ?? "-"} typeNames=${JSON.stringify(typeNames ?? [])} depth=${depth ?? 2} reason="${reason}"`
+      );
+      if (!operation && !(typeNames && typeNames.length > 0)) {
+        return errorResult(
+          "Pass `operation` (a root query/mutation name from SearchWixGraphQLOperations) and/or `typeNames` (type names to expand)."
+        );
+      }
+      try {
+        const io = introspectionOptions(options);
+        const sections = [];
+        const roots = [];
+        if (operation) {
+          const ops = await getRootOperations(io);
+          const op = ops.find((o2) => o2.name === operation);
+          if (!op) {
+            const suggestions = searchOperations(ops, operation, {
+              maxResults: 5
+            });
+            return errorResult(
+              `No root operation named "${operation}". ${suggestions.length ? `Did you mean: ${suggestions.map((s) => `${s.kind} ${s.operation}`).join(", ")}? Use SearchWixGraphQLOperations to discover the exact name.` : "Use SearchWixGraphQLOperations to discover the exact name."}`
+            );
+          }
+          sections.push(
+            `# ${renderOperationSignature(op)}`,
+            op.description ? op.description.trim().split("\n").map((l) => `# ${l}`).join("\n") : "# (no description)"
+          );
+          op.args.forEach((a2) => {
+            const n2 = namedType(a2.type);
+            if (n2) roots.push(n2);
+          });
+          const ret = namedType(op.type);
+          if (ret) roots.push(ret);
+        }
+        if (typeNames?.length) roots.push(...typeNames);
+        const { rendered, unexpanded, unknown: unknown2 } = await expandTypes(roots, {
+          ...io,
+          depth: depth ?? 2
+        });
+        sections.push(...rendered);
+        if (unknown2.length) {
+          sections.push(
+            `# Unknown type names (not in the schema): ${unknown2.join(", ")}`
+          );
+        }
+        if (unexpanded.length) {
+          sections.push(
+            `# Not expanded (pass any of these in \`typeNames\` to read them): ${unexpanded.join(", ")}`
+          );
+        }
+        sections.push(
+          "# Notes: `JSON` scalar fields (filter, sort, free-form data) take any JSON \u2014 pass them as variables. Every object-typed field in a selection needs its own { ... } selection set. Only fields listed above exist. Paging: use exactly the paging style the input type declares \u2014 `paging` (offset) or `cursorPaging` (cursor) \u2014 never the other one. `pageInfo.total` is only populated with offset paging; with cursor paging, count by walking pages (`pageInfo.hasNext` + cursor) or use a dedicated count operation if one exists."
+        );
+        return textResult(truncateResponse(sections.join("\n\n"), maxChars));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${INSPECT_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`GraphQL schema inspection error: ${message}`);
+      }
+    }
+  );
+}
+function addExecuteGraphqlTool(server2, description, authStrategy, options) {
+  const d = desc("ExecuteWixGraphQL");
+  const endpoint = options.endpoint ?? WIX_GRAPHQL_ENDPOINT;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  server2.tool(
+    EXECUTE_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      query: external_exports.string().describe(d.query),
+      variables: external_exports.record(external_exports.unknown()).optional().describe(d.variables),
+      operationName: external_exports.string().optional().describe(d.operationName),
+      siteId: external_exports.string().optional().describe(d.siteId),
+      scope: external_exports.enum(["site", "account"]).optional().describe(d.scope),
+      hasMutations: external_exports.boolean().describe(d.hasMutations),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+    async ({ query, variables, operationName, siteId, scope, hasMutations, reason }, extra) => {
+      const effectiveScope = scope ?? (siteId ? "site" : "account");
+      logger2.log(
+        `[${EXECUTE_GRAPHQL_TOOL_NAME}] scope=${effectiveScope} siteId=${siteId ?? "none"} hasMutations=${hasMutations} operationName=${operationName ?? "-"} reason="${reason}"`
+      );
+      if (effectiveScope === "site" && !siteId) {
+        return errorResult(
+          'A `siteId` is required for site-level GraphQL operations (anything that reads or writes inside a site). Resolve it with GetSiteContext or ListWixSites, or set scope: "account" for account-level operations.'
+        );
+      }
+      if (!query.trim()) {
+        return errorResult("`query` must be a non-empty GraphQL document.");
+      }
+      const authHeaders = effectiveScope === "site" ? await authStrategy.getSiteAuthHeaders(siteId) : await authStrategy.getAccountAuthHeaders();
+      try {
+        const init2 = {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...authHeaders
+          },
+          body: JSON.stringify({
+            query,
+            ...variables ? { variables } : {},
+            ...operationName ? { operationName } : {}
+          })
+        };
+        const resp = hasMutations ? await fetchImpl(endpoint, init2) : await fetchWithRetry(
+          fetchImpl,
+          endpoint,
+          init2,
+          options.retryDelaysMs
+        );
+        const requestId = resp.headers?.get("x-wix-request-id") ?? void 0;
+        extra?.setToolBiParams?.({ siteId, requestId });
+        const text = await resp.text();
+        if (!resp.ok) {
+          await authStrategy.enforceValidWixToken?.({
+            status: resp.status,
+            response: { status: resp.status }
+          });
+          const body2 = /^\s*<(!doctype|html)/i.test(text) ? "(HTML error page)" : text.slice(0, 2e3);
+          const hasObjectVariables = !!variables && Object.values(variables).some(
+            (v) => v !== null && typeof v === "object"
+          );
+          const hint = resp.status >= 500 ? hasObjectVariables ? ` The Wix GraphQL endpoint (Developer Preview) returns 503 when an object-typed variable carries an enum value. Rewrite the document with the input INLINE as a GraphQL literal (enum values unquoted, e.g. productType: PHYSICAL), keep variables only for JSON scalars and plain scalars, and retry once. If it still fails and REST tools (ExecuteWixAPI / CallWixSiteAPI) are available, use the equivalent REST method.` : ` The Wix GraphQL endpoint (Developer Preview) failed for this operation. Do not retry the same document more than once. If REST tools (ExecuteWixAPI / CallWixSiteAPI) are available, complete the task through the equivalent REST method instead; otherwise report the failure with the request id.` : "";
+          return errorResult(
+            `Wix GraphQL request failed: ${resp.status} ${resp.statusText}.${requestId ? ` request id: ${requestId}.` : ""}${hint}
+${body2}`
+          );
+        }
+        let json;
+        try {
+          json = JSON.parse(text);
+        } catch {
+          return errorResult(
+            `Wix GraphQL returned a non-JSON body:
+${text.slice(0, 2e3)}`
+          );
+        }
+        const hasData = json.data != null && Object.values(json.data).some((v) => v !== null && v !== void 0);
+        const errors = json.errors ?? [];
+        if (!hasData && errors.length > 0) {
+          const permissionDenied = errors.some(
+            (e) => e.extensions?.message === "PERMISSION_DENIED"
+          );
+          return errorResult(
+            [
+              `Wix GraphQL returned errors and no data${requestId ? ` (request id: ${requestId})` : ""}:`,
+              JSON.stringify(errors, null, 2).slice(0, 4e3),
+              permissionDenied ? "PERMISSION_DENIED usually means the operation is site-level and was called without the right `siteId`, the app behind it is not installed on the site, or the credential lacks that permission scope." : 'Validation errors ("Cannot query field ...", "Unknown argument ...") mean a name was guessed \u2014 re-read the exact fields with InspectWixGraphQLSchema and retry.'
+            ].join("\n")
+          );
+        }
+        const body = { data: json.data };
+        if (errors.length > 0) {
+          body.errors = errors;
+          body.note = "Partial result: some root fields failed (see errors[].path). Fields present in data succeeded.";
+        }
+        return textResult(truncateResponse(body, options.maxResponseSize));
+      } catch (err) {
+        rethrowIfUnauthorized(err);
+        await authStrategy.enforceValidWixToken?.(err);
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${EXECUTE_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`Wix GraphQL execution error: ${message}`);
+      }
+    }
+  );
+}
+
 // src/bin.ts
 var PUBLIC_TOOLS = [...VALID_DOCS_TOOLS];
 var EXPERIMENTAL_TOOLS = [
@@ -86600,7 +87425,8 @@ var EXPERIMENTAL_TOOLS = [
   "GET_TO_KNOW_WIX",
   "CREATE_WIX_BUSINESS_GUIDE",
   "VELO_README",
-  "WIX_API_THROUGH_FS"
+  "WIX_API_THROUGH_FS",
+  "GRAPHQL"
 ];
 var DEFAULT_TOOLS = [...VALID_DOCS_TOOLS];
 var parsedArgs = (0, import_minimist.default)(process.argv.slice(2));
@@ -86727,6 +87553,7 @@ if (cliTools.length > 0) {
     }
   }
 }
+var cliAccountAuthStrategy;
 if (isWixCliAuth) {
   const accountFile = path9.join(homedir3(), ".wix", "auth", "account.json");
   if (!existsSync3(accountFile)) {
@@ -86739,6 +87566,13 @@ if (isWixCliAuth) {
   const tokens = new TokenStore({ accountFile });
   const accountAuthStrategy = createAccountFileAuthStrategy({ tokens });
   addApiCallTool(server, accountAuthStrategy);
+  cliAccountAuthStrategy = accountAuthStrategy;
+}
+if (activeTools.includes("GRAPHQL")) {
+  logger2.log("Adding GraphQL tools", {
+    execute: Boolean(cliAccountAuthStrategy)
+  });
+  addGraphqlTools(server, { authStrategy: cliAccountAuthStrategy });
 }
 try {
   const portals = parsedArgs["portals"]?.split(",") || [];