@wix/mcp 1.0.82 → 1.0.84

package/build/dts/graphql/introspection.js

@@ -0,0 +1,282 @@
+/**
+ * Introspection client for the Wix GraphQL schema.
+ *
+ * The full schema is ~4MB (about 4,100 types), far too large to hand to an
+ * agent, so the tools disclose it progressively: the root operations (queries
+ * and mutations with their descriptions) are fetched once and cached
+ * in-process for ranking, and individual types are fetched on demand by name.
+ * Introspection needs no auth, so this works for anonymous sessions too.
+ */
+import { WIX_GRAPHQL_ENDPOINT } from './constants.js';
+const TYPE_REF_FRAGMENT = `
+fragment TR on __Type { kind name ofType { kind name ofType { kind name ofType { kind name } } } }`;
+const 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}`;
+const 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 }
+}`;
+const ROOT_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+let rootCache;
+const typeCache = new Map();
+/** Test hook: forget every cached introspection result. */
+export function resetGraphqlSchemaCache() {
+    rootCache = undefined;
+    typeCache.clear();
+}
+/**
+ * The endpoint answers bursts with transient 503s (an HTML page). Retry a few
+ * times with backoff; introspection is idempotent so this is always safe.
+ */
+export const RETRY_DELAYS_MS = [800, 2000, 4000];
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function fetchWithRetry(fetchImpl, url, init, delays = RETRY_DELAYS_MS) {
+    let attempt = 0;
+    for (;;) {
+        const resp = await fetchImpl(url, init);
+        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 — 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;
+}
+/** All root query + mutation fields, cached in-process. */
+export 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')
+        ];
+    });
+    // Don't pin a failed fetch for the TTL.
+    promise.catch(() => {
+        if (rootCache?.promise === promise)
+            rootCache = undefined;
+    });
+    rootCache = { promise, fetchedAt: now };
+    return promise;
+}
+const GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
+/** Aliases per introspection document — the server rejects more than 15. */
+const TYPE_BATCH_SIZE = 10;
+/**
+ * Fetch several named types in one round-trip (aliased `__type` lookups).
+ * Unknown names resolve to null. Results are cached per name.
+ */
+export async function getTypes(names, options = {}) {
+    const unique = [...new Set(names)].filter((n) => GRAPHQL_NAME.test(n));
+    const missing = unique.filter((n) => !typeCache.has(n));
+    // The endpoint caps aliases per document (15) and answers bursts with
+    // 503s, so look types up in small chunks, one chunk at a time.
+    for (let start = 0; start < missing.length; start += TYPE_BATCH_SIZE) {
+        const chunk = missing.slice(start, start + TYPE_BATCH_SIZE);
+        const selections = chunk
+            .map((n, i) => `t${i}: __type(name: "${n}") { ...TD }`)
+            .join('\n');
+        const query = `{\n${selections}\n}${TYPE_DETAILS_FRAGMENT}${TYPE_REF_FRAGMENT}`;
+        const batch = postIntrospection(query, options);
+        chunk.forEach((n, i) => {
+            const p = batch.then((data) => (data?.[`t${i}`] ?? null));
+            // A failed batch must not poison the cache for later calls.
+            p.catch(() => {
+                if (typeCache.get(n) === p)
+                    typeCache.delete(n);
+            });
+            typeCache.set(n, p);
+        });
+        // Sequential on purpose (see above); a failure surfaces via the cached
+        // promise when the caller awaits it.
+        await batch.catch(() => undefined);
+    }
+    const result = new Map();
+    await Promise.all(unique.map(async (n) => {
+        result.set(n, await typeCache.get(n));
+    }));
+    return result;
+}
+/** `[Foo!]!` style rendering of a (possibly wrapped) type ref. */
+export 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';
+}
+/** The named type at the bottom of LIST/NON_NULL wrappers. */
+export function namedType(ref) {
+    let cur = ref;
+    while (cur && (cur.kind === 'NON_NULL' || cur.kind === 'LIST')) {
+        cur = cur.ofType ?? null;
+    }
+    return cur?.name ?? null;
+}
+const BUILTIN_SCALARS = new Set([
+    'String',
+    'Int',
+    'Float',
+    'Boolean',
+    'ID',
+    'JSON'
+]);
+export 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)}…` : flat;
+}
+function renderField(field, isInput) {
+    const args = !isInput && field.args?.length
+        ? `(${field.args.map((a) => `${a.name}: ${renderTypeRef(a.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}`;
+}
+/**
+ * Compact SDL for one type. Returns the text and the named types it references
+ * (so callers can expand the next level).
+ */
+export function renderType(type) {
+    const references = new Set();
+    const collect = (ref) => {
+        const n = namedType(ref);
+        if (n && !isBuiltinScalar(n) && n !== type.name)
+            references.add(n);
+    };
+    const header = type.description
+        ? `# ${oneLine(type.description, 200)}\n`
+        : '';
+    let body;
+    switch (type.kind) {
+        case 'ENUM':
+            body = `enum ${type.name} {\n${(type.enumValues ?? [])
+                .map((v) => `  ${v.name}${v.description ? `  # ${oneLine(v.description, 100)}` : ''}`)
+                .join('\n')}\n}`;
+            break;
+        case 'INPUT_OBJECT':
+            (type.inputFields ?? []).forEach((f) => collect(f.type));
+            body = `input ${type.name} {\n${(type.inputFields ?? [])
+                .map((f) => renderField(f, true))
+                .join('\n')}\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((a) => collect(a.type));
+            });
+            const keyword = type.kind === 'INTERFACE' ? 'interface' : 'type';
+            body = `${keyword} ${type.name} {\n${(type.fields ?? [])
+                .map((f) => renderField(f, false))
+                .join('\n')}\n}`;
+        }
+    }
+    return { text: header + body, references: [...references] };
+}
+/** One-line signature of a root operation. */
+export function renderOperationSignature(op) {
+    const args = op.args
+        .map((a) => `${a.name}: ${renderTypeRef(a.type)}`)
+        .join(', ');
+    return `${op.kind === 'query' ? 'Query' : 'Mutation'}.${op.name}(${args}): ${renderTypeRef(op.type)}`;
+}
+/**
+ * Breadth-first expansion of `rootTypeNames`. Level 1 is the given names,
+ * level 2 the types they reference, and so on up to `depth`. Anything
+ * referenced but not expanded is returned as `unexpanded` for a follow-up.
+ */
+export async function expandTypes(rootTypeNames, options = {}) {
+    const depth = Math.max(1, Math.min(options.depth ?? 2, 5));
+    const maxTypes = options.maxTypes ?? 40;
+    const rendered = [];
+    const unknown = [];
+    const seen = new Set();
+    let frontier = [...new Set(rootTypeNames)].filter((n) => !isBuiltinScalar(n));
+    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((n) => seen.add(n));
+        const types = await getTypes(batch, options);
+        const next = new Set();
+        for (const name of batch) {
+            const type = types.get(name);
+            if (!type) {
+                unknown.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 = [...new Set([...overflow, ...frontier])].filter((n) => !seen.has(n) && !isBuiltinScalar(n));
+    return { rendered, unexpanded, unknown };
+}
+//# sourceMappingURL=introspection.js.map

package/build/dts/graphql/search.d.ts

@@ -0,0 +1,25 @@
+import { type RootOperation } from './introspection.js';
+export interface OperationMatch {
+    operation: string;
+    kind: 'query' | 'mutation';
+    /** `name(arg: Type): ReturnType` */
+    signature: string;
+    description: string;
+    inputType: string | null;
+    returnType: string | null;
+    score: number;
+}
+/** Split camelCase / digits / punctuation into lowercase tokens. */
+export declare function tokenize(text: string): string[];
+/** Crude singularisation so "products" matches "product" and vice versa. */
+export declare function stem(token: string): string;
+/**
+ * Rank root operations for a free-text intent. Name-token matches weigh most
+ * (the operation name encodes app, service, version, verb and entity), then
+ * description matches; exact full-name matches win outright.
+ */
+export declare function searchOperations(ops: RootOperation[], query: string, options?: {
+    kind?: 'query' | 'mutation' | 'all';
+    maxResults?: number;
+}): OperationMatch[];
+//# sourceMappingURL=search.d.ts.map

package/build/dts/graphql/search.js

@@ -0,0 +1,277 @@
+import { namedType, renderTypeRef } from './introspection.js';
+/** Split camelCase / digits / punctuation into lowercase tokens. */
+export 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);
+}
+const STOP_WORDS = 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'
+]);
+/** Crude singularisation so "products" matches "product" and vice versa. */
+export 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;
+}
+/** Common intent verbs → the verbs Wix operation names use. */
+const 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 = 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;
+}
+const READ_VERBS = new Set([
+    'list',
+    'get',
+    'query',
+    'find',
+    'fetch',
+    'read',
+    'show',
+    'retrieve',
+    'search',
+    'count',
+    'view',
+    'see'
+]);
+const WRITE_VERBS = new Set([
+    'create',
+    'add',
+    'new',
+    'insert',
+    'update',
+    'edit',
+    'change',
+    'modify',
+    'set',
+    'delete',
+    'remove',
+    'destroy',
+    'cancel',
+    'bulk',
+    'merge',
+    'publish',
+    'send'
+]);
+/** Version tokens ("v", "3") carry no intent and are never penalised. */
+const isVersionToken = (t) => t === 'v' || /^\d+$/.test(t);
+/** Markdown links → their text, so descriptions read as plain prose. */
+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)}…` : sentence;
+}
+const indexCache = 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;
+}
+/**
+ * Rank root operations for a free-text intent. Name-token matches weigh most
+ * (the operation name encodes app, service, version, verb and entity), then
+ * description matches; exact full-name matches win outright.
+ */
+export 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));
+    // "contacts" wants the list root, "contact" the single-entity root.
+    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);
+    // A read intent (or no verb at all) prefers query roots: in this schema a
+    // query root IS the read verb, so "list/get/find" are satisfied by the kind.
+    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 = new Set();
+        for (const term of terms) {
+            const isOriginal = originalTerms.has(term);
+            if (op.kind === 'query' && readIntent && READ_VERBS.has(term)) {
+                // The query root itself is the "list/get" — count the verb as matched.
+                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++;
+            }
+        }
+        // Nothing matched: biases below must not surface unrelated operations.
+        if (score <= 0 && op.name !== exactName)
+            continue;
+        if (op.name === exactName)
+            score += 100;
+        if (originalTerms.size > 0 && originalHits === originalTerms.size) {
+            score += 3;
+        }
+        // Plural intent ↔ list root (plural last token); singular ↔ get-one root.
+        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;
+        }
+        // Deprecated/internal duplicates ("DoNotCall") rank below their twins.
+        if (/DoNotCall/i.test(op.name))
+            score -= 2;
+        // Name tokens the intent never mentioned dilute the match (a "Facets" or
+        // "Labels" op is not what "contacts" asked for). App prefixes count too,
+        // equally for every op, so they don't reorder siblings.
+        for (const nt of nameTokens) {
+            if (!isVersionToken(nt) && !matchedNameTokens.has(nt))
+                score -= 0.3;
+        }
+        // A read intent almost never wants a create/update/delete mutation even
+        // when its name shares the nouns ("products with inventory" is not
+        // CreateProductWithInventory).
+        if (readIntent &&
+            op.kind === 'mutation' &&
+            [...nameTokens].some((t) => WRITE_VERBS.has(t))) {
+            score -= 6;
+        }
+        // Read intents lean to query roots; newer API versions and documented
+        // operations edge out older/undocumented twins with the same tokens.
+        if (op.kind === 'query' && readIntent)
+            score += 1;
+        const version = op.name.match(/V(\d+)/);
+        if (version)
+            score += Math.min(Number(version[1]), 5) * 0.1;
+        if (!op.description)
+            score -= 0.5;
+        // Shorter names are the canonical entry for a family of similar ops.
+        score -= op.name.length / 200;
+        if (score <= 0)
+            continue;
+        matches.push({
+            operation: op.name,
+            kind: op.kind,
+            signature: `${op.name}(${op.args
+                .map((a) => `${a.name}: ${renderTypeRef(a.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((a, b) => b.score - a.score || a.operation.localeCompare(b.operation));
+    return matches.slice(0, Math.max(1, Math.min(maxResults, 50)));
+}
+//# sourceMappingURL=search.js.map

package/build/dts/index.d.ts

@@ -6,7 +6,7 @@ export { handleWixAPIResponse } from './tool-utils.js';
 export { addDocsResources } from './resources/docs.js';
 export { addSupportTool } from './support/index.js';
 export { addGetProfileTool } from './account-tools/get-profile-tool.js';
-export { addCreateSiteWidgetTool, addEditSiteWidgetTool, addPullSiteJobTool, addClaimSiteTool, addSiteCreationWidgetTools, addWixSiteCreationTool, addSearchSiteTemplatesTool, addCreateSiteFromTemplateTool, type SiteWidgetToolOptions } from './site-widget-tools/index.js';
+export { addCreateSiteWidgetTool, addEditSiteWidgetTool, addPullSiteJobTool, addClaimSiteTool, addSuggestedDomainTool, addSiteCreationWidgetTools, addWixSiteCreationTool, addSearchSiteTemplatesTool, addCreateSiteFromTemplateTool, type SiteWidgetToolOptions } from './site-widget-tools/index.js';
 export * from './wixel/index.js';
 export { addImportClaudeDesignTool, type ImportClaudeDesignToolOptions } from './import-claude-design-tool/index.js';
 export { IMPORT_CLAUDE_DESIGN_TOOL_NAME } from './import-claude-design-tool/constants.js';
@@ -23,6 +23,7 @@ export { fetchRecipesIndex, fetchArticle, RECIPES_INDEX_URL } from './docs/fetch
 export { generateDocsNavigationTree, fetchMenuContent, MENU_CONTENT_THRESHOLD, normalizeMenuContent, summarizeLargeMenu, parseDirectChildren } from './docs/normalize-menu-content.js';
 export { addCodeModeTools, addExecuteCodeModeTool, addSearchCodeModeTool, type CodeModeOptions } from './code-mode/index.js';
 export { validateExecuteCode, EXECUTE_FUNCTION_EXPRESSION_HINT, type CodeValidationResult } from './code-mode/validation.js';
+export { addGraphqlTools, resetGraphqlSchemaCache, GRAPHQL_TOOL_NAMES, SEARCH_GRAPHQL_TOOL_NAME, INSPECT_GRAPHQL_TOOL_NAME, EXECUTE_GRAPHQL_TOOL_NAME, WIX_GRAPHQL_ENDPOINT, type GraphqlToolsOptions, type GraphqlToolName } from './graphql/index.js';
 export { defaultConfig, defaultToolDescriptions, defaultReadmeDocs, widgetSiteCreationConfig, SITE_CREATION_COPY, toWidget, executeCodeModeToolDescriptions, SYSTEM_REMINDER_GUIDELINES, SYSTEM_REMINDER, mergeConfig, type ModeDefaultConfig } from './config/default-config.js';
 export * from './site-widget-tools/constants.js';
 //# sourceMappingURL=index.d.ts.map

package/build/dts/index.js

@@ -6,7 +6,7 @@ export { handleWixAPIResponse } from './tool-utils.js';
 export { addDocsResources } from './resources/docs.js';
 export { addSupportTool } from './support/index.js';
 export { addGetProfileTool } from './account-tools/get-profile-tool.js';
-export { addCreateSiteWidgetTool, addEditSiteWidgetTool, addPullSiteJobTool, addClaimSiteTool, addSiteCreationWidgetTools, addWixSiteCreationTool, addSearchSiteTemplatesTool, addCreateSiteFromTemplateTool } from './site-widget-tools/index.js';
+export { addCreateSiteWidgetTool, addEditSiteWidgetTool, addPullSiteJobTool, addClaimSiteTool, addSuggestedDomainTool, addSiteCreationWidgetTools, addWixSiteCreationTool, addSearchSiteTemplatesTool, addCreateSiteFromTemplateTool } from './site-widget-tools/index.js';
 export * from './wixel/index.js';
 export { addImportClaudeDesignTool } from './import-claude-design-tool/index.js';
 export { IMPORT_CLAUDE_DESIGN_TOOL_NAME } from './import-claude-design-tool/constants.js';
@@ -27,6 +27,8 @@ export { generateDocsNavigationTree, fetchMenuContent, MENU_CONTENT_THRESHOLD, n
 // Code mode (search + execute via sandboxed JS)
 export { addCodeModeTools, addExecuteCodeModeTool, addSearchCodeModeTool } from './code-mode/index.js';
 export { validateExecuteCode, EXECUTE_FUNCTION_EXPRESSION_HINT } from './code-mode/validation.js';
+// GraphQL tools (search operations + inspect schema + execute)
+export { addGraphqlTools, resetGraphqlSchemaCache, GRAPHQL_TOOL_NAMES, SEARCH_GRAPHQL_TOOL_NAME, INSPECT_GRAPHQL_TOOL_NAME, EXECUTE_GRAPHQL_TOOL_NAME, WIX_GRAPHQL_ENDPOINT } from './graphql/index.js';
 // Config exports
 export { defaultConfig, defaultToolDescriptions, defaultReadmeDocs, widgetSiteCreationConfig, SITE_CREATION_COPY, toWidget, executeCodeModeToolDescriptions, SYSTEM_REMINDER_GUIDELINES, SYSTEM_REMINDER, mergeConfig } from './config/default-config.js';
 export * from './site-widget-tools/constants.js';