@wix/mcp 1.0.7 → 1.0.8

package/build/docs/semanticSearch.test.js

@@ -0,0 +1,459 @@
+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');
+        });
+    });
+});