@wix/mcp 1.0.94 → 1.0.96

package/build/dts/docs/docs.js

@@ -2,15 +2,17 @@ import { z } from 'zod';
 import { runSemanticSearchAndFormat } from './semanticSearch.js';
 import { logger } from '../infra/logger.js';
 import { captureException } from '@sentry/node';
-import { fetchArticleContent, isSkillsRegistryUrl } from './fetch-article.js';
+import { fetchArticleContent, fetchSourceContent, isSkillsRegistryUrl, parseSourceContentUrl } from './fetch-article.js';
 import { normalizeMenuContent, summarizeLargeMenu, fetchMenuContent, MENU_CONTENT_THRESHOLD } from './normalize-menu-content.js';
 import { fetchPlatformizedMenu, MenuNotFoundError } from './browse-menu.js';
+import { closestMenuLinks, closestSkillFile, parentMenuUrls, skillManifestUrl, subMenusToRead } from './guessed-url.js';
 import { isQueryOrSearchEndpoint, QUERY_CAPABILITY_MARKER } from './searchFormatting.js';
 import { addGetToKnowTools, addGetSiteContextTool } from './get-to-know.js';
 import { addStartHeadlessBuildTool } from './start-headless-build.js';
 import { addStartDeployWebsiteTool } from './start-deploy-website.js';
-import { defaultToolDescriptions } from '../config/default-config.js';
-import { desc } from '../config/param-descriptions.js';
+import { defaultToolDescriptions, HELP_CENTER_IS_FOR_PEOPLE } from '../config/default-config.js';
+import { desc as paramDescriptionsOf } from '../config/param-descriptions.js';
+import { isMintlifyDocsSite, isMintlifyUrl, MINTLIFY_URL_PREFIXES, mintlifyDocumentTypes, readMintlifyMarkdown, rewriteDocsLinks, toDevWixUrl, toMintlifyHostText } from './mintlify-docs.js';
 import dedent from 'dedent';
 export const VALID_DOCS_TOOLS = [
     'WDS',
@@ -21,7 +23,8 @@ export const VALID_DOCS_TOOLS = [
     'VELO',
     'BUSINESS_SOLUTIONS',
     'CLI',
-    'OVERVIEW'
+    'OVERVIEW',
+    'HELP_CENTER'
 ];
 const REST_SEARCH_API_GROUNDING_REMINDER = dedent `
   # Before calling a Wix API
@@ -53,7 +56,17 @@ function shouldTryMenuFallbackForDocsRead(error, articleUrl) {
     if (!message.includes('404') || !isMenuFallbackUrl) {
         return false;
     }
-    return !['This resource is deprecated', 'No schema found'].some((knownArticleError) => message.includes(knownArticleError));
+    return !isKnownArticleError(error);
+}
+// A 404 that says why (a deprecated page, a method with no schema) is the answer itself.
+function isKnownArticleError(error) {
+    const message = getErrorMessage(error);
+    return [
+        'This resource is deprecated',
+        'This method is deprecated',
+        'This article is deprecated',
+        'No schema found'
+    ].some((knownArticleError) => message.includes(knownArticleError));
 }
 function formatDocsReadError(toolAction, error) {
     return `Could not fetch ${toolAction}: "${getErrorMessage(error)}".`;
@@ -66,18 +79,59 @@ export const addDocsTools = (server, allowedTools = [
     'WIX_HEADLESS',
     'BUSINESS_SOLUTIONS',
     'CLI',
-    'OVERVIEW'
+    'OVERVIEW',
+    'HELP_CENTER'
 ], options = {}) => {
-    const { getToKnowWixEnabled = false, startDeployWebsiteEnabled = true, startHeadlessBuildEnabled = true, disableTools, toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, skillsRepo, repo, skillsPr, commitHash, skillsTags, dynamicContextEnabled, usePlatformizedSearch = true, usePlatformizedBrowse = true } = options;
+    const { getToKnowWixEnabled = false, startDeployWebsiteEnabled = true, startHeadlessBuildEnabled = true, disableTools, toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, skillsRepo, repo, skillsPr, commitHash, skillsTags, readmeRecipesIndexEnabled, dynamicContextEnabled, includeCompanionApp, usePlatformizedSearch = true, usePlatformizedBrowse = true, docsSite } = options;
     const effectiveRepo = repo ?? skillsRepo;
     const effectiveCommitHash = commitHash ?? skillsPr;
+    // Mintlify docs: search as today, then resolve the links in the results.
+    const mintlifyDocs = isMintlifyDocsSite(docsSite);
+    const runSearch = mintlifyDocs
+        ? async (params) => {
+            // Stage 2 (docsSite=mintlify): REST and SDK search the Mintlify KBs.
+            const documentTypes = mintlifyDocumentTypes(docsSite, params.toolName);
+            const result = await runSemanticSearchAndFormat(documentTypes ? { ...params, documentTypes } : params);
+            return (await rewriteDocsLinks(result, { label: `search ${params.toolName}` })).text;
+        }
+        : runSemanticSearchAndFormat;
+    const docsUrlPrefixes = mintlifyDocs
+        ? ['https://dev.wix.com/docs/', ...MINTLIFY_URL_PREFIXES]
+        : ['https://dev.wix.com/docs/'];
+    // The backends only know dev.wix.com; Mintlify paths map back one to one.
+    const toBackendUrl = (url) => mintlifyDocs && isMintlifyUrl(url) ? toDevWixUrl(url) : url;
+    // Mintlify docs: a separate text block naming where a read's content came from.
+    const sourceNote = (source) => mintlifyDocs
+        ? [{ type: 'text', text: `[docs source] ${source}` }]
+        : [];
+    // Mintlify docs: tool and parameter texts show docs URLs on the Mintlify host, or
+    // the model cites dev.wix.com (it copies the examples' host into answers).
+    const docsText = (text) => mintlifyDocs ? toMintlifyHostText(text) : text;
+    const desc = (toolName) => {
+        const descriptions = paramDescriptionsOf(toolName);
+        if (!mintlifyDocs)
+            return descriptions;
+        return Object.fromEntries(Object.entries(descriptions).map(([param, text]) => [
+            param,
+            docsText(text)
+        ]));
+    };
     // Helper to get description (custom or default)
-    const getDescription = (toolName, defaultDesc) => toolDescriptions?.[toolName] ?? defaultDesc;
+    const getDescription = (toolName, defaultDesc) => docsText(toolDescriptions?.[toolName] ?? defaultDesc);
     // Menu text for a docs URL, shared by BrowseWixRESTDocsMenu and the
     // ReadFullDocs* category fallbacks. Platformized browse first — its 404 is a
     // real answer (null, no such menu); any other failure falls back to the
     // legacy get-menu-content scrape, which keeps its original thresholding.
     const fetchMenuTextForUrl = async (httpClient, url) => {
+        const text = await fetchMenuTextForBackendUrl(httpClient, toBackendUrl(url));
+        if (!text || !mintlifyDocs)
+            return text;
+        // Menu links are Portal Service nodes, the same tree the Mintlify
+        // navigation is built from, so they map by rule without a page check.
+        return (await rewriteDocsLinks(text, { verify: false, label: 'menu' }))
+            .text;
+    };
+    const fetchMenuTextForBackendUrl = async (httpClient, url) => {
         if (usePlatformizedBrowse) {
             try {
                 return await fetchPlatformizedMenu(url);
@@ -96,16 +150,81 @@ export const addDocsTools = (server, allowedTools = [
             ? summarizeLargeMenu(menuContent, url)
             : normalizeMenuContent(menuContent);
     };
+    // A docs or skills page that 404'd, most often a URL rewritten or guessed from a real one:
+    // the closest file in the skill or its folder's files, or the nearest menu above a docs page
+    // with its closest entries (one level into its closest sub-menus when none of its own is
+    // close). Null when nothing near exists, so the 404 stands.
+    const nearestToMissingPage = async (httpClient, url, isSkillsPage) => {
+        try {
+            if (isSkillsPage) {
+                const manifestUrl = skillManifestUrl(url);
+                if (!manifestUrl)
+                    return null;
+                const manifest = JSON.parse(await fetchArticleContent(httpClient, manifestUrl, 'article'));
+                const guess = closestSkillFile(url, manifest, manifestUrl);
+                if (!guess)
+                    return null;
+                if (guess.kind === 'file') {
+                    const text = await fetchArticleContent(httpClient, guess.url, 'article');
+                    return `Note: "${url}" does not exist. Found a similar file in the skill, ${guess.url}, and read it:\n\n${text}`;
+                }
+                return `Note: "${url}" does not exist, and no file in ${guess.folder ? `its folder (${guess.folder}/)` : 'the skill'} has a name close to it. ${guess.folder ? 'The files in that folder' : "The skill's top-level folders and files"}, to read the one you need (every file: ${guess.manifestUrl}):\n\n${guess.files.map((f) => `- ${f}`).join('\n')}`;
+            }
+            for (const menuUrl of parentMenuUrls(url)) {
+                const text = await fetchMenuTextForUrl(httpClient, menuUrl);
+                if (!text)
+                    continue;
+                const subMenus = (await Promise.all(subMenusToRead(text, menuUrl, url).map(async (sub) => ({
+                    sub,
+                    text: await fetchMenuTextForUrl(httpClient, sub).catch(() => null)
+                })))).filter((m) => !!m.text);
+                const closest = closestMenuLinks([text, ...subMenus.map((m) => m.text)].join('\n'), menuUrl, url);
+                return [
+                    `Note: "${url}" does not exist. Showing the nearest documentation menu above it, ${menuUrl}; read the page you need from its links.`,
+                    ...(closest.length
+                        ? [
+                            `Closest to what you asked for:\n${closest.map((l) => `- ${l}`).join('\n')}`
+                        ]
+                        : []),
+                    text
+                ].join('\n\n');
+            }
+        }
+        catch (error) {
+            logger.error(`[docs] no nearest page for ${url}: ${error}`);
+        }
+        return null;
+    };
+    // The two site-creation guides register first, so they head the tool list: an agent that
+    // loads every definition at once and gets a cut-down copy keeps the start and the end.
+    // On by default: they are routing slots, not docs sources.
+    if (startDeployWebsiteEnabled) {
+        addStartDeployWebsiteTool(server, disableTools || [], toolDescriptions, {
+            skillsPortalUrl,
+            repo: effectiveRepo,
+            commitHash: effectiveCommitHash
+        });
+    }
+    // Same reach as StartDeployWebsite: the slot for a site that needs Wix business features.
+    if (startHeadlessBuildEnabled) {
+        addStartHeadlessBuildTool(server, disableTools || [], toolDescriptions, {
+            skillsPortalUrl,
+            repo: effectiveRepo,
+            commitHash: effectiveCommitHash
+        });
+    }
     if (dynamicContextEnabled &&
         authStrategy &&
         !disableTools?.includes('GetSiteContext')) {
         addGetSiteContextTool({
             server,
             authStrategy,
+            includeCompanionApp,
             toolDescriptions,
             disableTools: disableTools || []
         });
     }
+    // Named in SERVER_INSTRUCTIONS (config/default-config.ts): when this tool's name or what it is for changes, update them to match.
     if (getToKnowWixEnabled && !disableTools?.includes('WixREADME')) {
         addGetToKnowTools({
             server,
@@ -117,24 +236,9 @@ export const addDocsTools = (server, allowedTools = [
             dynamicContextEnabled,
             repo: effectiveRepo,
             commitHash: effectiveCommitHash,
-            skillsTags
-        });
-    }
-    // On by default: it is a routing slot, not a docs source — the agent with
-    // ready-made site files must find it next to the site-creation tools.
-    if (startDeployWebsiteEnabled) {
-        addStartDeployWebsiteTool(server, disableTools || [], toolDescriptions, {
-            skillsPortalUrl,
-            repo: effectiveRepo,
-            commitHash: effectiveCommitHash
-        });
-    }
-    // Same reach as StartDeployWebsite: the slot for a site built in code with no code yet.
-    if (startHeadlessBuildEnabled) {
-        addStartHeadlessBuildTool(server, disableTools || [], toolDescriptions, {
-            skillsPortalUrl,
-            repo: effectiveRepo,
-            commitHash: effectiveCommitHash
+            skillsTags,
+            readmeRecipesIndexEnabled,
+            docsSite
         });
     }
     // WDS Documentation
@@ -155,7 +259,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults }, { panorama }) => {
             try {
                 logger.log(`Searching for ${searchTerm} in Wix WDS`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'WDS',
                     toolParams: {
                         searchTerm: searchTerm
@@ -207,7 +311,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults, reason }, { panorama }) => {
             try {
                 logger.log(`[SearchWixRESTDocumentation] searchTerm="${searchTerm}", reason="${reason}"`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'REST',
                     toolParams: {
                         searchTerm: searchTerm
@@ -270,7 +374,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults }, { panorama }) => {
             try {
                 logger.log(`Searching for ${searchTerm} in Wix Sample Flows`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'BUSINESS_SOLUTIONS',
                     toolParams: {
                         searchTerm: '**RECIPE**:  Business Recipes - full setup flow for::: ' +
@@ -328,7 +432,7 @@ export const addDocsTools = (server, allowedTools = [
                 panorama
                     .transaction('SearchWixSDKDocumentation')
                     .start({ maxResults });
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'SDK',
                     toolParams: {
                         searchTerm: searchTerm
@@ -386,7 +490,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults }, { panorama }) => {
             try {
                 logger.log(`Searching for ${searchTerm} in Build Apps`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'BUILD_APPS',
                     toolParams: {
                         searchTerm: `wix cli docs for ${searchTerm}`
@@ -436,7 +540,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults }, { panorama }) => {
             try {
                 logger.log(`Searching for ${searchTerm} in Wix Overview`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'OVERVIEW',
                     toolParams: {
                         searchTerm: searchTerm
@@ -486,7 +590,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults }, { panorama }) => {
             try {
                 logger.log(`Searching for ${searchTerm} in Headless`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'WIX_HEADLESS',
                     toolParams: {
                         searchTerm: searchTerm
@@ -542,7 +646,7 @@ export const addDocsTools = (server, allowedTools = [
                 panorama
                     .transaction('SearchWixVeloDocumentation')
                     .start({ maxResults });
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'VELO',
                     toolParams: {
                         searchTerm: searchTerm
@@ -583,6 +687,66 @@ export const addDocsTools = (server, allowedTools = [
         });
     }
     // CLI Documentation
+    // Help Center (support.wix.com): how site owners do things in the Wix
+    // dashboard and editors. Articles are long and prose-only, so fewer results
+    // with a larger line budget than the developer docs tools.
+    if (allowedTools.includes('HELP_CENTER') &&
+        !disableTools?.includes('SearchWixHelpCenter')) {
+        server.tool('SearchWixHelpCenter', getDescription('SearchWixHelpCenter', defaultToolDescriptions.SearchWixHelpCenter ?? ''), (() => {
+            const d = desc('SearchWixHelpCenter');
+            return {
+                searchTerm: z.string().describe(d.searchTerm),
+                maxResults: z
+                    .number()
+                    .describe(d.maxResults)
+                    .min(1)
+                    .max(15)
+                    .optional()
+                    .default(15),
+                reason: z.string().describe(d.reason)
+            };
+        })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults, reason }, { panorama }) => {
+            try {
+                logger.log(`[SearchWixHelpCenter] searchTerm="${searchTerm}", reason="${reason}"`);
+                const result = await runSemanticSearchAndFormat({
+                    toolName: 'HELP_CENTER',
+                    toolParams: {
+                        searchTerm: searchTerm
+                    },
+                    maxResults: Math.max(1, Math.min(maxResults ?? 15, 15)),
+                    linesInEachResult: 60,
+                    usePlatformizedSearch
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `${HELP_CENTER_IS_FOR_PEOPLE}\n\n${result}`
+                        }
+                    ]
+                };
+            }
+            catch (error) {
+                panorama.errorMonitor().reportError(error);
+                captureException(error, {
+                    tags: {
+                        componentId: 'SearchWixHelpCenter',
+                        toolName: 'SearchWixHelpCenter'
+                    }
+                });
+                logger.error(`Error searching for ${searchTerm} in the Wix Help Center: ${error}`);
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${error.message}\n\n${HELP_CENTER_IS_FOR_PEOPLE}`
+                        }
+                    ]
+                };
+            }
+        });
+    }
     if (allowedTools.includes('CLI') &&
         !disableTools?.includes('SearchWixCLIDocumentation')) {
         server.tool('SearchWixCLIDocumentation', getDescription('SearchWixCLIDocumentation', defaultToolDescriptions.SearchWixCLIDocumentation ?? ''), (() => {
@@ -601,7 +765,7 @@ export const addDocsTools = (server, allowedTools = [
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ searchTerm, maxResults, reason }, { panorama }) => {
             try {
                 logger.log(`[SearchWixCLIDocumentation] searchTerm="${searchTerm}", reason="${reason}"`);
-                const result = await runSemanticSearchAndFormat({
+                const result = await runSearch({
                     toolName: 'CLI',
                     toolParams: {
                         searchTerm: searchTerm
@@ -642,9 +806,32 @@ export const addDocsTools = (server, allowedTools = [
                 articleUrl: z.string().url().describe(d.articleUrl)
             };
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ articleUrl }, { httpClient }) => {
-            // URL validation: known docs prefixes, or a Wix skills registry page
+            // A file with no docs page, such as a skill kept out of the public
+            // mirror, is linked as get-source-content and read from its repository.
+            const source = parseSourceContentUrl(articleUrl);
+            if (source) {
+                try {
+                    const text = await fetchSourceContent(httpClient, source.repo, source.path, source.commitHash);
+                    return { content: [{ type: 'text', text }] };
+                }
+                catch (error) {
+                    logger.error(`Error fetching source content for ${articleUrl}: ${error}`);
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: formatDocsReadError('source content', error)
+                            }
+                        ]
+                    };
+                }
+            }
+            // URL validation: known docs prefixes, a Help Center article
+            // (get-article-content reads support.wix.com/<locale>/article/<slug>),
+            // or a Wix skills registry page
             // (https://www.wix.com/skills/..., https://dev.wix.com/docs/skills/...).
-            const validPrefixes = ['https://dev.wix.com/docs/'];
+            const validPrefixes = [...docsUrlPrefixes, 'https://support.wix.com/'];
             if (skillsPortalUrl)
                 validPrefixes.push(skillsPortalUrl);
             const isSkillsPage = isSkillsRegistryUrl(articleUrl);
@@ -655,7 +842,7 @@ export const addDocsTools = (server, allowedTools = [
                     content: [
                         {
                             type: 'text',
-                            text: `Invalid article URL: must start with https://dev.wix.com/docs/, or be a Wix skills page (https://www.wix.com/skills/..., https://www.wix.com/headless/...). Got: "${articleUrl}"`
+                            text: `Invalid article URL: must start with https://dev.wix.com/docs/ or https://support.wix.com/, or be a Wix skills page (https://www.wix.com/skills/..., https://www.wix.com/headless/..., or that file's github.com/wix/skills source). Got: "${articleUrl}"`
                         }
                     ]
                 };
@@ -668,6 +855,30 @@ export const addDocsTools = (server, allowedTools = [
                 articleUrl.startsWith('https://dev.wix.com/docs/')) {
                 articleUrl = articleUrl.replace(/\.md$/, '');
             }
+            // Mintlify docs: read the page from the Mintlify site when it has one,
+            // else fall through to today's backend with the dev.wix.com URL.
+            if (mintlifyDocs && !isSkillsPage) {
+                try {
+                    const page = await readMintlifyMarkdown(articleUrl);
+                    if (page) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: isQueryOrSearchEndpoint(page.url)
+                                        ? [page.markdown, ARTICLE_CAPABILITY_NOTE].join('\n\n')
+                                        : page.markdown
+                                },
+                                ...sourceNote(`Mintlify site: ${page.url}.md`)
+                            ]
+                        };
+                    }
+                }
+                catch (error) {
+                    logger.error(`[mintlify] reading ${articleUrl} from Mintlify failed, falling back: ${error}`);
+                }
+                articleUrl = toBackendUrl(articleUrl);
+            }
             try {
                 const articleContent = await fetchArticleContent(httpClient, articleUrl, 'article', false, skillsPortalUrl, effectiveRepo, effectiveCommitHash);
                 if (!articleContent) {
@@ -682,7 +893,10 @@ export const addDocsTools = (server, allowedTools = [
                             text: isQueryOrSearchEndpoint(articleUrl)
                                 ? [articleContent, ARTICLE_CAPABILITY_NOTE].join('\n\n')
                                 : articleContent
-                        }
+                        },
+                        ...sourceNote(isSkillsPage
+                            ? `skills registry: ${articleUrl}`
+                            : `today's backend (dev.wix.com/rawdocs, ingvar), not on the Mintlify site: ${articleUrl}`)
                     ]
                 };
             }
@@ -707,6 +921,13 @@ export const addDocsTools = (server, allowedTools = [
                         // menu fallback failed too — fall through to error below
                     }
                 }
+                if (getErrorMessage(error).includes('404') &&
+                    !isKnownArticleError(error)) {
+                    const nearest = await nearestToMissingPage(httpClient, articleUrl, isSkillsPage);
+                    if (nearest) {
+                        return { content: [{ type: 'text', text: nearest }] };
+                    }
+                }
                 return {
                     isError: true,
                     content: [
@@ -728,7 +949,7 @@ export const addDocsTools = (server, allowedTools = [
             };
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ articleUrl, reason }, { httpClient }) => {
             // URL validation: only allow known docs prefixes
-            const validPrefixes = ['https://dev.wix.com/docs/'];
+            const validPrefixes = [...docsUrlPrefixes];
             if (skillsPortalUrl)
                 validPrefixes.push(skillsPortalUrl);
             if (!validPrefixes.some((p) => articleUrl.startsWith(p))) {
@@ -746,18 +967,28 @@ export const addDocsTools = (server, allowedTools = [
             if (articleUrl.startsWith('https://dev.wix.com/docs/')) {
                 articleUrl = articleUrl.replace(/\.md$/, '');
             }
+            // Mintlify docs: schemas stay on PAPI through ingvar, by dev.wix.com URL.
+            articleUrl = toBackendUrl(articleUrl);
             try {
                 logger.log(`[ReadFullDocsMethodSchema] url="${articleUrl}", reason="${reason}"`);
                 const articleContent = await fetchArticleContent(httpClient, articleUrl, 'methodSchema', false, skillsPortalUrl, effectiveRepo, effectiveCommitHash, true);
                 if (!articleContent) {
                     throw new Error('Method schema is empty');
                 }
+                // Mintlify docs: the schema text links other methods on dev.wix.com;
+                // resolve those to their Mintlify pages, as in search results.
+                const schemaText = mintlifyDocs
+                    ? (await rewriteDocsLinks(articleContent, {
+                        label: 'schema ReadFullDocsMethodSchema'
+                    })).text
+                    : articleContent;
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: articleContent
-                        }
+                            text: schemaText
+                        },
+                        ...sourceNote(`PAPI, through today's backend (dev.wix.com/rawdocs, ingvar): ${articleUrl}`)
                     ]
                 };
             }
@@ -803,7 +1034,7 @@ export const addDocsTools = (server, allowedTools = [
             };
         })(), { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ menuUrl, reason }, { httpClient }) => {
             try {
-                if (menuUrl && !menuUrl.startsWith('https://dev.wix.com/docs/')) {
+                if (menuUrl && !docsUrlPrefixes.some((p) => menuUrl.startsWith(p))) {
                     return {
                         content: [
                             {

package/build/dts/docs/fetch-article.d.ts

@@ -36,5 +36,26 @@ export declare function fetchRecipesIndex(): Promise<string>;
  */
 export declare function fetchArticle(articleUrl: string): Promise<string>;
 export declare function isSkillsRegistryUrl(url: string): boolean;
+/**
+ * The forms of a skills URL agents hold that the registry serves under another
+ * name: wix.com without www (a 301 the fetch client does not follow), and the
+ * GitHub source of the same file. Both map to the www.wix.com/skills page.
+ */
+export declare function normalizeSkillsUrl(url: string): string;
+/**
+ * A file read from its source repository rather than the published docs, via
+ * the rawdocs get-source-content API (e.g. the management index as authored in
+ * wix-private/ax-skills). The API serves only the files it allows.
+ */
+/**
+ * The repo and path a get-source-content URL names: what a file served from its
+ * source repository links a file that has no docs page to.
+ */
+export declare function parseSourceContentUrl(url: string): {
+    repo: string;
+    path: string;
+    commitHash?: string;
+} | undefined;
+export declare function fetchSourceContent(httpClient: HttpClient, repo: string, path: string, commitHash?: string): Promise<string>;
 export declare function fetchArticleContent(httpClient: HttpClient, articleUrl: string, mode: 'article' | 'methodSchema' | 'raw', stripHeader?: boolean, skillsPortalUrl?: string, repo?: string, commitHash?: string, fetchMcpWhiteList?: boolean): Promise<string>;
 //# sourceMappingURL=fetch-article.d.ts.map

package/build/dts/docs/fetch-article.js

@@ -1,6 +1,6 @@
 import { HttpClient } from '@wix/http-client';
 import { logger } from '../infra/logger.js';
-import { GET_ARTICLE_CONTENT_URL } from '../constants.js';
+import { GET_ARTICLE_CONTENT_URL, GET_SOURCE_CONTENT_URL } from '../constants.js';
 // ---------------------------------------------------------------------------
 // Public constants and utilities
 // ---------------------------------------------------------------------------
@@ -62,7 +62,22 @@ const SKILLS_REGISTRY_URL = new RegExp('^https://(?:dev\\.wix\\.com(?:/docs)?|ww
     // served as raw markdown like the registry, and read the same way.
     '|^https://www\\.wix\\.com/headless/');
 export function isSkillsRegistryUrl(url) {
-    return SKILLS_REGISTRY_URL.test(url.trim());
+    return SKILLS_REGISTRY_URL.test(normalizeSkillsUrl(url));
+}
+// A GitHub view of the skills repository, as an installed plugin cross-references it:
+// github.com/wix/skills/blob/<ref>/skills/<skill>/<path>, with or without a line anchor.
+const GITHUB_SKILLS_URL = /^https:\/\/(?:www\.)?github\.com\/wix\/skills\/(?:blob|raw|tree)\/[^/]+\/skills\/([^#?]+)/;
+/**
+ * The forms of a skills URL agents hold that the registry serves under another
+ * name: wix.com without www (a 301 the fetch client does not follow), and the
+ * GitHub source of the same file. Both map to the www.wix.com/skills page.
+ */
+export function normalizeSkillsUrl(url) {
+    const apex = url
+        .trim()
+        .replace(/^https:\/\/wix\.com\//, 'https://www.wix.com/');
+    const gh = apex.match(GITHUB_SKILLS_URL);
+    return gh ? `https://www.wix.com/skills/${gh[1]}` : apex;
 }
 async function fetchSkillsRegistryPage(httpClient, url) {
     let data;
@@ -173,6 +188,53 @@ async function fetchArticleContentFromDigor(httpClient, articleUrl, mode, stripH
     }
     return articleContent;
 }
+/**
+ * A file read from its source repository rather than the published docs, via
+ * the rawdocs get-source-content API (e.g. the management index as authored in
+ * wix-private/ax-skills). The API serves only the files it allows.
+ */
+/**
+ * The repo and path a get-source-content URL names: what a file served from its
+ * source repository links a file that has no docs page to.
+ */
+export function parseSourceContentUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    if (`${parsed.origin}${parsed.pathname}` !== GET_SOURCE_CONTENT_URL) {
+        return undefined;
+    }
+    const repo = parsed.searchParams.get('repo');
+    const path = parsed.searchParams.get('path');
+    const commitHash = parsed.searchParams.get('commitHash');
+    if (!repo || !path)
+        return undefined;
+    return commitHash ? { repo, path, commitHash } : { repo, path };
+}
+export async function fetchSourceContent(httpClient, repo, path, commitHash) {
+    const url = new URL(GET_SOURCE_CONTENT_URL);
+    url.searchParams.set('repo', repo);
+    url.searchParams.set('path', path);
+    if (commitHash)
+        url.searchParams.set('commitHash', commitHash);
+    let data;
+    try {
+        ({ data } = await httpClient.get(url.toString()));
+    }
+    catch (error) {
+        const { message, status } = getHttpErrorDetails(error);
+        const statusSuffix = status ? ` (status ${status})` : '';
+        throw new Error(`${message}${statusSuffix}`);
+    }
+    if (!data?.content) {
+        throw new Error('Source content is empty');
+    }
+    return data.content;
+}
 export async function fetchArticleContent(httpClient, articleUrl, mode, stripHeader = false, skillsPortalUrl, repo, commitHash, fetchMcpWhiteList) {
     // Apply portal URL override if configured
     const effectiveUrl = applyPortalUrlOverride(articleUrl, skillsPortalUrl);
@@ -190,12 +252,12 @@ export async function fetchArticleContent(httpClient, articleUrl, mode, stripHea
             // Fall through to the normal fetch for this URL: the registry for a
             // skills page (rawdocs cannot serve those), rawdocs otherwise.
             content = isSkillsRegistryUrl(articleUrl)
-                ? await fetchSkillsRegistryPage(httpClient, articleUrl)
+                ? await fetchSkillsRegistryPage(httpClient, normalizeSkillsUrl(articleUrl))
                 : await fetchArticleContentFromDigor(httpClient, articleUrl, mode, stripHeader);
         }
     }
     else if (isSkillsRegistryUrl(articleUrl)) {
-        content = await fetchSkillsRegistryPage(httpClient, articleUrl);
+        content = await fetchSkillsRegistryPage(httpClient, normalizeSkillsUrl(articleUrl));
     }
     else if (mode === 'raw') {
         let parsedUrl;

package/build/dts/docs/get-to-know.d.ts

@@ -28,14 +28,19 @@ export interface AddGetToKnowTools {
     repo?: string;
     commitHash?: string;
     skillsTags?: string[];
+    readmeRecipesIndexEnabled?: boolean;
+    /** The connection's docsSite (see ./mintlify-docs.ts): a Mintlify mode resolves the README's docs links. */
+    docsSite?: string;
 }
 interface AddGetSiteContextTool {
     server: WixMcpServer;
     authStrategy: McpAuthenticationStrategy;
     partnerContextEnabled?: boolean;
+    /** Render the site's companion app. Off by default: only Aria (via the toolkit) needs it. */
+    includeCompanionApp?: boolean;
     toolDescriptions?: Record<string, string>;
     disableTools?: string[];
 }
-export declare function addGetSiteContextTool({ server, authStrategy, toolDescriptions }: AddGetSiteContextTool): void;
-export declare function addGetToKnowTools({ server, disableTools, toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, dynamicContextEnabled, repo, commitHash, skillsTags }: AddGetToKnowTools): Promise<void>;
+export declare function addGetSiteContextTool({ server, authStrategy, includeCompanionApp, toolDescriptions }: AddGetSiteContextTool): void;
+export declare function addGetToKnowTools({ server, disableTools, toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, dynamicContextEnabled, repo, commitHash, skillsTags, readmeRecipesIndexEnabled, docsSite }: AddGetToKnowTools): Promise<void>;
 //# sourceMappingURL=get-to-know.d.ts.map