@wix/mcp 1.0.5 → 1.0.6

package/build/docs/semanticSearch.test.js

@@ -1,459 +0,0 @@
-import { describe, test, expect, beforeEach, vi, afterAll } from 'vitest';
-import { DEFAULT_MAX_RESULTS, runSemanticSearchAndFormat } from './semanticSearch.js';
-import { LONG_KB_CONTENT } from './long-content.js';
-const sampleSearchResponse = {
-    results: {
-        SDK_DOCS_KB_ID: {
-            results: [
-                {
-                    entry: {
-                        content: 'SDK Documentation content 1\nline 2\nline 3'
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.95
-                    }
-                },
-                {
-                    entry: {
-                        content: 'SDK Documentation content 2'
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.85
-                    }
-                },
-                {
-                    entry: {
-                        content: LONG_KB_CONTENT,
-                        chunkedContent: ['some-chunked-content']
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.83
-                    }
-                }
-            ]
-        },
-        SDK_SCHEMAS_KB_ID: {
-            results: [
-                {
-                    entry: {
-                        content: 'SDK Schema content 1'
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.9
-                    }
-                }
-            ]
-        },
-        BUILD_APPS_KB_ID: {
-            results: [
-                {
-                    entry: {
-                        content: 'Build Apps content 1'
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.88
-                    }
-                }
-            ]
-        },
-        MCP_REST_RECIPES_KB_ID: {
-            results: [
-                {
-                    entry: {
-                        content: 'Build Apps content 1'
-                    },
-                    scoresInfo: {
-                        overallMatchScore: 0.92
-                    }
-                }
-            ]
-        }
-    }
-};
-const originalProcessEnv = process.env;
-describe('Semantic Search', () => {
-    let fetchMock;
-    global.fetch = vi.fn();
-    beforeEach(() => {
-        vi.clearAllMocks();
-        process.env = { ...originalProcessEnv };
-        fetchMock = global.fetch;
-        fetchMock.mockReset();
-        fetchMock.mockResolvedValue({
-            ok: true,
-            status: 200,
-            statusText: 'OK',
-            json: async () => sampleSearchResponse
-        });
-    });
-    afterAll(() => {
-        process.env = originalProcessEnv;
-    });
-    test('performs SDK semantic search successfully', async () => {
-        const sdkResponse = {
-            results: {
-                SDK_DOCS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'SDK Documentation content 1'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.95
-                            }
-                        },
-                        {
-                            entry: {
-                                content: 'SDK Documentation content 2'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.85
-                            }
-                        }
-                    ]
-                },
-                SDK_SCHEMAS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'SDK Schema content 1'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.9
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => sdkResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'SDK',
-            toolParams: {
-                searchTerm: 'wix-data query'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('mcp-docs-search/v1/search');
-        expect(url).toContain(`maxResults=${DEFAULT_MAX_RESULTS}`);
-        expect(url).toContain('rerank=false');
-        expect(url).toContain('kbName=SDK_SCHEMAS_KB_ID');
-        expect(url).toContain('kbName=SDK_DOCS_KB_ID');
-        expect(url).toContain('searchTerm=wix-data+query');
-        // Results should be sorted by score and limited to 10
-        expect(result).toBe('SDK Documentation content 1\n\n---\n\nSDK Schema content 1\n\n---\n\nSDK Documentation content 2');
-    });
-    test('performs REST semantic search successfully', async () => {
-        const restResponse = {
-            results: {
-                REST_METHODS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'REST Methods content'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.98
-                            }
-                        }
-                    ]
-                },
-                REST_DOCS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'REST Documentation content'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.95
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => restResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'REST',
-            toolParams: {
-                searchTerm: 'create collection'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('kbName=REST_METHODS_KB_ID');
-        expect(url).toContain('kbName=REST_DOCS_KB_ID');
-        expect(url).toContain('kbName=MCP_REST_RECIPES_KB_ID');
-        expect(result).toBe('REST Methods content\n\n---\n\nREST Documentation content');
-    });
-    test('performs BUSINESS_SOLUTIONS semantic search successfully', async () => {
-        const restResponse = {
-            results: {
-                REST_DOCS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'REST Documentation content'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.95
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => restResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'BUSINESS_SOLUTIONS',
-            toolParams: {
-                searchTerm: 'create collection'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).not.toContain('kbName=REST_METHODS_KB_ID');
-        expect(url).toContain('kbName=REST_DOCS_KB_ID');
-        expect(url).toContain('kbName=MCP_REST_RECIPES_KB_ID');
-        expect(result).toBe('REST Documentation content');
-    });
-    test('performs WDS semantic search successfully', async () => {
-        const wdsResponse = {
-            results: {
-                WDS_DOCS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'WDS Documentation content'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.95
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => wdsResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'WDS',
-            toolParams: {
-                searchTerm: 'Button component'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('kbName=WDS_DOCS_KB_ID');
-        expect(result).toBe('WDS Documentation content');
-    });
-    test('performs BUILD_APPS semantic search successfully', async () => {
-        const buildAppsResponse = {
-            results: {
-                BUILD_APPS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'Build Apps content 1'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.88
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => buildAppsResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'BUILD_APPS',
-            toolParams: {
-                searchTerm: 'deploy app'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('kbName=BUILD_APPS_KB_ID');
-        expect(result).toBe('Build Apps content 1');
-    });
-    test('performs WIX_HEADLESS semantic search successfully', async () => {
-        const wixHeadlessResponse = {
-            results: {
-                WIX_HEADLESS_KB_ID: {
-                    results: [
-                        {
-                            entry: {
-                                content: 'Wix Headless content 1'
-                            },
-                            scoresInfo: {
-                                overallMatchScore: 0.92
-                            }
-                        }
-                    ]
-                }
-            }
-        };
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => wixHeadlessResponse
-        });
-        const result = await runSemanticSearchAndFormat({
-            toolName: 'WIX_HEADLESS',
-            toolParams: {
-                searchTerm: 'query'
-            }
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('kbName=HEADLESS_KB_ID');
-        expect(result).toBe('Wix Headless content 1');
-    });
-    test('handles API error response', async () => {
-        fetchMock.mockResolvedValueOnce({
-            ok: false,
-            status: 500,
-            statusText: 'Internal Server Error'
-        });
-        await expect(runSemanticSearchAndFormat({
-            toolName: 'SDK',
-            toolParams: {
-                searchTerm: 'query'
-            }
-        })).rejects.toThrow('Failed to run rag search: Internal Server Error');
-    });
-    test('handles empty results', async () => {
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => ({ results: {} })
-        });
-        await expect(runSemanticSearchAndFormat({
-            toolName: 'SDK',
-            toolParams: {
-                searchTerm: 'query'
-            }
-        })).rejects.toThrow('No result from search');
-    });
-    test('respects maxResults parameter', async () => {
-        const maxResults = 5;
-        await runSemanticSearchAndFormat({
-            toolName: 'SDK',
-            toolParams: {
-                searchTerm: 'query'
-            },
-            maxResults
-        });
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('maxResults=5');
-    });
-    test('respects rerank parameter', async () => {
-        await runSemanticSearchAndFormat({
-            toolName: 'SDK',
-            toolParams: {
-                searchTerm: 'query'
-            },
-            maxResults: 5,
-            rerank: true
-        });
-        const [url] = fetchMock.mock.calls[0];
-        expect(url).toContain('rerank=true');
-    });
-    describe('light mode and long content', () => {
-        test('respects no linesInEachResult parameter - default behavior', async () => {
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 5,
-                rerank: false
-            });
-            expect(result).toContain('line 3');
-        });
-        test('respects linesInEachResult parameter', async () => {
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 5,
-                rerank: false,
-                linesInEachResult: 2
-            });
-            expect(result).toContain('line 2');
-        });
-        test('respects linesInEachResult parameter', async () => {
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 5,
-                rerank: false,
-                linesInEachResult: 1
-            });
-            expect(result).not.toContain('line 2');
-        });
-        test('respects linesInEachResult even if content is too long', async () => {
-            const longContentLines = LONG_KB_CONTENT.split('\n');
-            const longContentLine1 = longContentLines[0];
-            const longContentLine16 = longContentLines[16];
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 10,
-                rerank: false,
-                linesInEachResult: 15
-            });
-            expect(result).toContain(longContentLine1);
-            expect(result).not.toContain('some-chunked-content');
-            expect(result).not.toContain(longContentLine16);
-        });
-        test('uses chunked content if content is too long and linesInEachResult is not set', async () => {
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 10,
-                rerank: false
-            });
-            expect(result).toContain('some-chunked-content');
-        });
-        test('uses chunked content if content is too long and linesInEachResult is set', async () => {
-            const result = await runSemanticSearchAndFormat({
-                toolName: 'SDK',
-                toolParams: {
-                    searchTerm: 'query'
-                },
-                maxResults: 10,
-                rerank: false,
-                linesInEachResult: 1500
-            });
-            expect(result).toContain('some-chunked-content');
-        });
-    });
-});

package/build/interactive-command-tools/eventually.d.ts

@@ -1,6 +0,0 @@
-interface Options {
-    timeout?: number;
-    interval?: number;
-}
-export default function eventually<ReturnType = void>(expectation: () => ReturnType | Promise<ReturnType>, options?: Options): Promise<ReturnType>;
-export {};

package/build/interactive-command-tools/eventually.js

@@ -1,15 +0,0 @@
-import waitForExpect from 'wait-for-expect';
-const defaultOptions = {
-    timeout: 10000,
-    interval: 200
-};
-export default async function eventually(expectation, options) {
-    return new Promise((resolve, reject) => {
-        waitForExpect
-            .default(async () => {
-            const ret = await expectation();
-            resolve(ret);
-        }, options?.timeout ?? defaultOptions.timeout, options?.interval ?? defaultOptions.interval)
-            .catch((error) => reject(error));
-    });
-}

package/build/interactive-command-tools/handleStdout.d.ts

@@ -1,13 +0,0 @@
-import Stream from 'node:stream';
-export declare function handleStdout(stdout: Stream.Readable): {
-    waitForText(match: string | RegExp, { timeout }?: {
-        timeout?: number | undefined;
-    }): Promise<string | undefined>;
-    waitForAndCallback(matchesAndCallbacks: {
-        match: string;
-        callback: (stop: () => void) => void;
-    }[], { timeout }?: {
-        timeout?: number | undefined;
-    }): Promise<unknown>;
-    getOutput(): Promise<string>;
-};

package/build/interactive-command-tools/handleStdout.js

@@ -1,75 +0,0 @@
-import stripAnsi from 'strip-ansi';
-import eventually from './eventually.js';
-import { logger } from '../logger.js';
-export function handleStdout(stdout) {
-    let checkStartIndex = 0;
-    const lines = [];
-    logger.log(`handleStdout: stdout: ${stdout}`);
-    stdout.on('data', (chunk) => {
-        logger.log(`handleStdout: chunk: ${chunk}`);
-        // log(`create-cli: chunk: ${chunk}`);
-        lines.push(...stripAnsi(chunk.toString()).split('\n'));
-    });
-    return {
-        async waitForText(match, { timeout = 2 * 60 * 1000 } = {}) {
-            return eventually(() => {
-                const matchedIndex = lines.findIndex((line, index) => {
-                    if (index < checkStartIndex) {
-                        return false;
-                    }
-                    if (typeof match === 'string') {
-                        return line.includes(match);
-                    }
-                    return line.match(match);
-                });
-                checkStartIndex = matchedIndex >= 0 ? matchedIndex + 1 : lines.length;
-                if (matchedIndex !== -1) {
-                    return lines[matchedIndex];
-                }
-                const message = `Could not match text in output: ${match}`;
-                throw new Error(message);
-            }, { timeout });
-        },
-        async waitForAndCallback(matchesAndCallbacks, { timeout = 2 * 60 * 1000 } = {}) {
-            let stopResolve;
-            const stopPromise = new Promise((resolve) => {
-                stopResolve = resolve;
-            });
-            // Keep track of matches we've already processed
-            const processedMatches = new Set();
-            const waitPromise = eventually(() => {
-                //log(`create-cli: waiting for ${matchesAndCallbacks.length - processedMatches.size} matches`);
-                for (const { match, callback } of matchesAndCallbacks) {
-                    // Skip if we've already processed this match
-                    if (processedMatches.has(match)) {
-                        continue;
-                    }
-                    if (lines.some((line) => line.includes(match))) {
-                        logger.log(`create-cli: found match ${match}`);
-                        // Add to processed matches so we don't match it again
-                        processedMatches.add(match);
-                        callback(() => {
-                            logger.log(`create-cli: stopping match loop`);
-                            stopResolve();
-                        });
-                    }
-                    else {
-                        // log(`create-cli: waiting for ${match}`);
-                    }
-                }
-                // If we've processed all matches, we're done
-                if (processedMatches.size === matchesAndCallbacks.length) {
-                    return true;
-                }
-                throw new Error(`Could not find any of the remaining matches: ${matchesAndCallbacks
-                    .filter((m) => !processedMatches.has(m.match))
-                    .map((m) => m.match)
-                    .join(', ')}`);
-            }, { timeout });
-            return Promise.race([waitPromise, stopPromise]);
-        },
-        async getOutput() {
-            return lines.join('\n');
-        }
-    };
-}

package/build/interactive-command-tools/interactive-command-utils.d.ts

@@ -1,7 +0,0 @@
-import Stream from 'node:stream';
-export declare const ENTER = "\r";
-export declare const mockInteractiveGenerateCommandTool: ({ extensionType, stdin, stdout }: {
-    extensionType: string;
-    stdin: Stream.Writable;
-    stdout: Stream.Readable;
-}) => Promise<string>;

package/build/interactive-command-tools/interactive-command-utils.js

@@ -1,75 +0,0 @@
-import { handleStdout } from './handleStdout.js';
-import { logger } from '../logger.js';
-export const ENTER = '\r';
-const DOWN = '\u001b[B';
-export const mockInteractiveGenerateCommandTool = async ({ extensionType, stdin, stdout }) => {
-    try {
-        logger.log('RunWixCliCommand: handle stdout');
-        const stdoutHandler = handleStdout(stdout);
-        logger.log('RunWixCliCommand: waiting for text');
-        await stdoutHandler.waitForText('What kind of extension would you like to generate?');
-        // Enter the extension type
-        if (extensionType === 'DASHBOARD_PAGE') {
-            // No need to press enter
-        }
-        else if (extensionType === 'BACKEND_EVENT') {
-            logger.log('RunWixCliCommand: writing DOWN 9 times');
-            for (let i = 0; i < 9; i++) {
-                stdin.write(DOWN);
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-        }
-        logger.log('RunWixCliCommand: writing ENTER 1');
-        stdin.write(ENTER);
-        // Wait for next step
-        if (extensionType === 'DASHBOARD_PAGE') {
-            await stdoutHandler.waitForText('Page title');
-            logger.log('RunWixCliCommand: writing ENTER 2');
-            stdin.write(ENTER);
-            await stdoutHandler.waitForText('Enter the route for the new page');
-            logger.log('RunWixCliCommand: writing ENTER 3');
-            stdin.write(ENTER);
-        }
-        else if (extensionType === 'BACKEND_EVENT') {
-            await stdoutHandler.waitForText('Event folder');
-            logger.log('RunWixCliCommand: writing ENTER 2');
-            stdin.write(ENTER);
-            logger.log('RunWixCliCommand: waiting for text');
-            // Check if the text is "Would you like to install dependencies now?", if dependencies are already installed, it will not be printed
-            try {
-                await stdoutHandler.waitForText('Would you like to install dependencies now?', { timeout: 1000 });
-                logger.log('RunWixCliCommand: writing ENTER 3');
-                stdin.write(ENTER);
-            }
-            catch (error) {
-                if (error instanceof Error &&
-                    error.message.includes('Could not match text in output')) {
-                    logger.log('RunWixCliCommand: dependencies are already installed, skipping install');
-                    logger.log(await stdoutHandler.getOutput());
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        logger.log('RunWixCliCommand: waiting for success message');
-        try {
-            await stdoutHandler.waitForText('Successfully', { timeout: 1000 });
-            logger.log('RunWixCliCommand: success message found');
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                error.message.includes('Could not match text in output')) {
-                logger.log('RunWixCliCommand: success message not found, skipping'); // just skip and try to continue by returning the output
-            }
-            else {
-                throw error;
-            }
-        }
-        return stdoutHandler.getOutput();
-    }
-    catch (error) {
-        logger.error('RunWixCliCommand: error', error);
-        throw error;
-    }
-};

package/build/logger.d.ts

@@ -1,10 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-interface Logger {
-    log(...data: unknown[]): void;
-    error(...data: unknown[]): void;
-}
-export declare const logger: Logger;
-export declare const attachMcpServerLogger: (server: McpServer) => void;
-export declare const attachStdErrLogger: () => void;
-export declare const attachFileLogger: () => void;
-export {};