@webspire/mcp 0.1.0

package/dist/handlers.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type RegistryOptions } from './registry.js';
+export declare function registerTools(server: McpServer, registryOptions?: RegistryOptions): void;
+export declare function registerResources(server: McpServer, registryOptions?: RegistryOptions): void;

package/dist/handlers.js

@@ -0,0 +1,8 @@
+import { registerResourcesWithProvider, registerToolsWithProvider } from './registration.js';
+import { loadRegistry } from './registry.js';
+export function registerTools(server, registryOptions) {
+    registerToolsWithProvider(server, () => loadRegistry(registryOptions));
+}
+export function registerResources(server, registryOptions) {
+    registerResourcesWithProvider(server, () => loadRegistry(registryOptions));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerResources, registerTools } from './handlers.js';
+const args = process.argv.slice(2);
+const urlIdx = args.indexOf('--registry-url');
+const fileIdx = args.indexOf('--registry-file');
+const registryOptions = {
+    url: urlIdx !== -1 ? args[urlIdx + 1] : undefined,
+    filePath: fileIdx !== -1 ? args[fileIdx + 1] : undefined,
+};
+const server = new McpServer({
+    name: 'webspire',
+    version: '0.1.0',
+});
+registerTools(server, registryOptions);
+registerResources(server, registryOptions);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[webspire-mcp] Server running on stdio');

package/dist/registration.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Registry } from './types.js';
+type RegistryProvider = () => Promise<Registry>;
+export declare function registerToolsWithProvider(server: McpServer, getRegistry: RegistryProvider): void;
+export declare function registerResourcesWithProvider(server: McpServer, getRegistry: RegistryProvider): void;
+export {};

package/dist/registration.js

@@ -0,0 +1,471 @@
+import { z } from 'zod';
+import { searchSnippets } from './registry.js';
+function formatSnippetBrief(s) {
+    return [
+        `**${s.title}** (${s.id})`,
+        `  ${s.description}`,
+        `  Category: ${s.category} | Tags: ${s.tags.join(', ')}`,
+        s.darkMode ? '  Dark mode: yes' : '',
+        s.responsive ? '  Responsive: yes' : '',
+        s.meta.useCases.length > 0 ? `  Use cases: ${s.meta.useCases.slice(0, 2).join('; ')}` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function formatAccessibility(s) {
+    const a11y = s.meta.accessibility;
+    const features = [];
+    if (a11y.prefersReducedMotion)
+        features.push('prefers-reduced-motion');
+    if (a11y.prefersColorScheme)
+        features.push('prefers-color-scheme');
+    if (a11y.supportsCheck)
+        features.push('@supports fallback');
+    if (a11y.ariaNotes?.length)
+        features.push(...a11y.ariaNotes);
+    return features.length > 0 ? `## Accessibility\nRespects: ${features.join(', ')}` : '';
+}
+function formatSnippetFull(s) {
+    const props = s.meta.customProperties
+        .map((p) => `  ${p}: ${s.meta.defaultValues?.[p] ?? 'unset'}`)
+        .join('\n');
+    return [
+        `# ${s.title}`,
+        '',
+        s.description,
+        '',
+        '## Usage',
+        '```html',
+        s.meta.usageExample,
+        '```',
+        '',
+        '## CSS',
+        '```css',
+        s.css,
+        '```',
+        '',
+        s.meta.customProperties.length > 0 ? `## Custom Properties\n${props}` : '',
+        s.meta.classes.length > 0 ? `## Classes\n${s.meta.classes.join(', ')}` : '',
+        formatAccessibility(s),
+        s.dependencies?.length ? `## Dependencies\n${s.dependencies.join(', ')}` : '',
+        s.variants?.length ? `## Variants\n${s.variants.join(', ')}` : '',
+        '',
+        `Browser support: ${s.meta.browser}`,
+        `Size: ${s.meta.lines} lines, ${s.meta.bytes} bytes`,
+        s.darkMode ? 'Dark mode: supported' : '',
+        s.responsive ? 'Responsive: yes' : '',
+    ]
+        .filter((line) => line !== '')
+        .join('\n');
+}
+function formatPatternBrief(p) {
+    return [
+        `**${p.title}** (${p.id})`,
+        `  ${p.summary}`,
+        `  Family: ${p.family} | Tier: ${p.tier} | Kind: ${p.kind}`,
+        p.tags.length > 0 ? `  Tags: ${p.tags.join(', ')}` : '',
+        p.extends ? `  Extends: ${p.extends}` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function formatPatternFull(p) {
+    return [
+        `# ${p.title}`,
+        '',
+        p.description ?? p.summary,
+        '',
+        '## Identity',
+        `ID: ${p.id}`,
+        `Family: ${p.family}`,
+        `Tier: ${p.tier}`,
+        `Kind: ${p.kind}`,
+        p.extends ? `Extends: ${p.extends}` : '',
+        '',
+        p.tags.length > 0 ? `## Tags\n${p.tags.join(', ')}` : '',
+        p.slots.length > 0
+            ? `## Slots\n${p.slots.map((s) => `- ${s.name}${s.required ? ' (required)' : ''}: ${s.description}`).join('\n')}`
+            : '',
+        p.props.length > 0
+            ? `## Props\n${p.props.map((prop) => `- ${prop.name} (${prop.type}) default=${String(prop.default)}`).join('\n')}`
+            : '',
+        '## HTML',
+        '```html',
+        p.html,
+        '```',
+        p.css ? `## CSS\n\`\`\`css\n${p.css}\n\`\`\`` : '',
+        p.js ? `## JS\n\`\`\`js\n${p.js}\n\`\`\`` : '',
+    ]
+        .filter((line) => line !== '')
+        .join('\n');
+}
+export function registerToolsWithProvider(server, getRegistry) {
+    server.tool('list_categories', 'List all available snippet categories with snippet counts', {}, async () => {
+        const registry = await getRegistry();
+        const counts = {};
+        for (const snippet of registry.snippets) {
+            counts[snippet.category] = (counts[snippet.category] ?? 0) + 1;
+        }
+        const result = Object.entries(counts)
+            .sort(([, a], [, b]) => b - a)
+            .map(([cat, count]) => `${cat}: ${count} snippet${count > 1 ? 's' : ''}`)
+            .join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${registry.snippets.length} snippets across ${Object.keys(counts).length} categories:\n\n${result}`,
+                },
+            ],
+        };
+    });
+    server.tool('search_snippets', 'Search Webspire CSS snippets by keyword, problem description, or use case. Returns matching snippets with their descriptions and IDs.', {
+        query: z
+            .string()
+            .describe('Search query: problem description, use case, or CSS technique (e.g. "glass card", "fade animation", "blur entrance")'),
+        category: z
+            .string()
+            .optional()
+            .describe('Filter by category: glass, animations, easing, scroll, decorative, interactions, text'),
+        tags: z.array(z.string()).optional().describe('Filter by tags'),
+        darkMode: z.boolean().optional().describe('Filter for dark mode support'),
+        responsive: z.boolean().optional().describe('Filter for responsive support'),
+    }, async ({ query, category, tags, darkMode, responsive }) => {
+        const registry = await getRegistry();
+        const results = searchSnippets(registry, {
+            query,
+            category,
+            tags,
+            darkMode,
+            responsive,
+        });
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No snippets found matching your query. Try broader keywords or check available categories with list_categories.',
+                    },
+                ],
+            };
+        }
+        const text = results.map(formatSnippetBrief).join('\n\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${results.length} snippet${results.length > 1 ? 's' : ''}:\n\n${text}`,
+                },
+            ],
+        };
+    });
+    server.tool('get_snippet', 'Get full CSS source, metadata, usage example, and custom properties for a specific snippet. Use this after finding a snippet via search_snippets or recommend_snippet.', {
+        id: z
+            .string()
+            .describe('Snippet ID, e.g. "glass/frosted", "animations/fade-in", "easing/tokens"'),
+    }, async ({ id }) => {
+        const registry = await getRegistry();
+        const snippet = registry.snippets.find((s) => s.id === id);
+        if (!snippet) {
+            const available = registry.snippets.map((s) => s.id).join(', ');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Snippet "${id}" not found. Available snippets: ${available}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: formatSnippetFull(snippet) }],
+        };
+    });
+    server.tool('recommend_snippet', 'Describe a UI problem or desired effect and get the best matching Webspire snippets with reasoning. Supports optional constraints like dark mode or reduced motion requirements.', {
+        use_case: z
+            .string()
+            .describe('Describe the UI problem or effect you need (e.g. "I need a blurred card overlay on my hero section", "my list items should animate in one by one")'),
+        category: z.string().optional().describe('Limit recommendations to a specific category'),
+        needs_dark_mode: z
+            .boolean()
+            .optional()
+            .describe('Only recommend snippets with dark mode support'),
+        needs_responsive: z
+            .boolean()
+            .optional()
+            .describe('Only recommend snippets with responsive support'),
+        needs_reduced_motion: z
+            .boolean()
+            .optional()
+            .describe('Only recommend snippets that respect prefers-reduced-motion'),
+    }, async ({ use_case, category, needs_dark_mode, needs_responsive, needs_reduced_motion }) => {
+        const registry = await getRegistry();
+        let filteredRegistry = registry;
+        if (needs_reduced_motion) {
+            filteredRegistry = {
+                ...registry,
+                snippets: registry.snippets.filter((s) => s.meta.accessibility.prefersReducedMotion),
+            };
+        }
+        const results = searchSnippets(filteredRegistry, {
+            query: use_case,
+            category,
+            darkMode: needs_dark_mode ? true : undefined,
+            responsive: needs_responsive ? true : undefined,
+            limit: 5,
+        });
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No matching snippet found for your description. Try rephrasing or relax the constraints.',
+                    },
+                ],
+            };
+        }
+        const text = results
+            .map((s, i) => {
+            const reasons = [];
+            if (s.darkMode)
+                reasons.push('dark mode');
+            if (s.meta.accessibility.prefersReducedMotion)
+                reasons.push('reduced motion');
+            if (s.meta.accessibility.supportsCheck)
+                reasons.push('@supports fallback');
+            const reasonStr = reasons.length > 0 ? ` (${reasons.join(', ')})` : '';
+            return `${i + 1}. ${formatSnippetBrief(s)}${reasonStr}\n   Usage: \`${s.meta.usageExample}\``;
+        })
+            .join('\n\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Top ${results.length} recommendation${results.length > 1 ? 's' : ''} for "${use_case}":\n\n${text}\n\nUse get_snippet(id) for full CSS and details.`,
+                },
+            ],
+        };
+    });
+    server.tool('list_pattern_families', 'List all available pattern families with counts', {}, async () => {
+        const registry = await getRegistry();
+        const patterns = registry.patterns ?? [];
+        const counts = {};
+        for (const pattern of patterns) {
+            counts[pattern.family] = (counts[pattern.family] ?? 0) + 1;
+        }
+        const result = Object.entries(counts)
+            .sort(([, a], [, b]) => b - a)
+            .map(([family, count]) => `${family}: ${count} pattern${count > 1 ? 's' : ''}`)
+            .join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${patterns.length} patterns across ${Object.keys(counts).length} families:\n\n${result}`,
+                },
+            ],
+        };
+    });
+    server.tool('search_patterns', 'Search Webspire UI patterns by intent, family, and tier.', {
+        query: z.string().describe('Search query, e.g. "hero with image", "pricing section"'),
+        family: z
+            .string()
+            .optional()
+            .describe('Filter by pattern family, e.g. hero, pricing, navbar'),
+        tier: z.enum(['base', 'enhanced']).optional().describe('Filter by tier'),
+    }, async ({ query, family, tier }) => {
+        const registry = await getRegistry();
+        let patterns = registry.patterns ?? [];
+        if (family) {
+            patterns = patterns.filter((p) => p.family === family);
+        }
+        if (tier) {
+            patterns = patterns.filter((p) => p.tier === tier);
+        }
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const results = patterns
+            .map((p) => {
+            const haystack = [
+                p.title,
+                p.summary,
+                p.description ?? '',
+                p.family,
+                p.kind,
+                ...p.tags,
+                ...p.search.intent,
+                ...p.search.keywords,
+                ...p.search.useCases,
+            ]
+                .join(' ')
+                .toLowerCase();
+            const score = terms.reduce((acc, t) => acc + (haystack.includes(t) ? 1 : 0), 0);
+            return { pattern: p, score };
+        })
+            .filter((row) => row.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 10)
+            .map((row) => row.pattern);
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No patterns found matching your query.',
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${results.length} pattern${results.length > 1 ? 's' : ''}:\n\n${results.map(formatPatternBrief).join('\n\n')}`,
+                },
+            ],
+        };
+    });
+    server.tool('get_pattern', 'Get full pattern data including HTML (and optional CSS/JS) for a specific pattern.', {
+        id: z.string().describe('Pattern ID, e.g. "hero/base", "hero/with-image"'),
+    }, async ({ id }) => {
+        const registry = await getRegistry();
+        const pattern = (registry.patterns ?? []).find((p) => p.id === id);
+        if (!pattern) {
+            const available = (registry.patterns ?? []).map((p) => p.id).join(', ');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Pattern "${id}" not found. Available patterns: ${available}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: formatPatternFull(pattern) }],
+        };
+    });
+}
+export function registerResourcesWithProvider(server, getRegistry) {
+    server.resource('categories', 'webspire://categories', {
+        description: 'List all snippet categories with counts',
+        mimeType: 'application/json',
+    }, async () => {
+        const registry = await getRegistry();
+        const counts = {};
+        for (const snippet of registry.snippets) {
+            counts[snippet.category] = (counts[snippet.category] ?? 0) + 1;
+        }
+        return {
+            contents: [
+                {
+                    uri: 'webspire://categories',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(counts, null, 2),
+                },
+            ],
+        };
+    });
+    server.resource('category', 'webspire://category/{name}', {
+        description: 'List snippets in a specific category',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const name = uri.pathname.replace('//', '').split('/').pop();
+        const registry = await getRegistry();
+        const snippets = registry.snippets.filter((s) => s.category === name);
+        const brief = snippets.map((s) => ({
+            id: s.id,
+            title: s.title,
+            description: s.description,
+            tags: s.tags,
+            darkMode: s.darkMode,
+            responsive: s.responsive,
+        }));
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(brief, null, 2),
+                },
+            ],
+        };
+    });
+    server.resource('snippet', 'webspire://snippet/{id}', {
+        description: 'Get full snippet data including CSS source',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const parts = uri.pathname.replace('//', '').split('/');
+        const id = parts.slice(1).join('/');
+        const registry = await getRegistry();
+        const snippet = registry.snippets.find((s) => s.id === id);
+        if (!snippet) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'text/plain',
+                        text: `Snippet "${id}" not found`,
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(snippet, null, 2),
+                },
+            ],
+        };
+    });
+    server.resource('patterns', 'webspire://patterns', { description: 'List all patterns', mimeType: 'application/json' }, async () => {
+        const registry = await getRegistry();
+        const patterns = (registry.patterns ?? []).map((p) => ({
+            id: p.id,
+            title: p.title,
+            summary: p.summary,
+            family: p.family,
+            tier: p.tier,
+            kind: p.kind,
+        }));
+        return {
+            contents: [
+                {
+                    uri: 'webspire://patterns',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(patterns, null, 2),
+                },
+            ],
+        };
+    });
+    server.resource('pattern', 'webspire://pattern/{id}', {
+        description: 'Get full pattern data including HTML source',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const parts = uri.pathname.replace('//', '').split('/');
+        const id = parts.slice(1).join('/');
+        const registry = await getRegistry();
+        const pattern = (registry.patterns ?? []).find((p) => p.id === id);
+        if (!pattern) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'text/plain',
+                        text: `Pattern "${id}" not found`,
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(pattern, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/registry.d.ts

@@ -0,0 +1,17 @@
+import { type SnippetSearchOptions } from './search.js';
+import type { Registry, SnippetEntry } from './types.js';
+export type { Registry, SnippetEntry };
+export interface RegistryOptions {
+    url?: string;
+    filePath?: string;
+}
+/**
+ * Load the registry with fallback chain:
+ * 1. Explicit --registry-file path
+ * 2. Bundled data/registry.json (shipped with npm package)
+ * 3. Remote fetch from --registry-url or default URL
+ */
+export declare function loadRegistry(options?: RegistryOptions): Promise<Registry>;
+export type SearchOptions = SnippetSearchOptions;
+export declare function searchSnippets(registry: Registry, options: SearchOptions): SnippetEntry[];
+export declare function suggestSnippets(registry: Registry, problem: string): SnippetEntry[];

package/dist/registry.js

@@ -0,0 +1,60 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { searchSnippets as searchEntries } from './search.js';
+const DEFAULT_REGISTRY_URL = 'https://webspire.de/registry.json';
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cache = null;
+/**
+ * Resolve the path to the bundled registry.json shipped with this package.
+ * Works both from src/ (development) and dist/ (published).
+ */
+function getBundledRegistryPath() {
+    try {
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        // From dist/ → ../data/registry.json, from src/ → ../data/registry.json
+        const candidate = resolve(thisDir, '..', 'data', 'registry.json');
+        return existsSync(candidate) ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Load the registry with fallback chain:
+ * 1. Explicit --registry-file path
+ * 2. Bundled data/registry.json (shipped with npm package)
+ * 3. Remote fetch from --registry-url or default URL
+ */
+export async function loadRegistry(options) {
+    // 1. Explicit file path
+    if (options?.filePath) {
+        const raw = await readFile(options.filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    // 2. Bundled registry (no cache needed — file is local and fast)
+    const bundledPath = getBundledRegistryPath();
+    if (bundledPath && !options?.url) {
+        const raw = await readFile(bundledPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    // 3. Remote fetch with TTL cache
+    if (cache && Date.now() - cache.loadedAt < CACHE_TTL_MS) {
+        return cache.registry;
+    }
+    const url = options?.url ?? DEFAULT_REGISTRY_URL;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch registry from ${url}: ${response.statusText}`);
+    }
+    const registry = (await response.json());
+    cache = { registry, loadedAt: Date.now() };
+    return registry;
+}
+export function searchSnippets(registry, options) {
+    return searchEntries(registry.snippets, options);
+}
+export function suggestSnippets(registry, problem) {
+    return searchSnippets(registry, { query: problem, limit: 5 });
+}

package/dist/search.d.ts

@@ -0,0 +1,12 @@
+import type { SnippetEntry } from './types.js';
+export interface SnippetSearchOptions {
+    query: string;
+    category?: string;
+    tags?: string[];
+    darkMode?: boolean;
+    responsive?: boolean;
+    limit?: number;
+}
+export declare function stem(word: string): string;
+export declare function scoreSnippet(snippet: SnippetEntry, stems: string[]): number;
+export declare function searchSnippets(snippets: SnippetEntry[], options: SnippetSearchOptions): SnippetEntry[];

package/dist/search.js

@@ -0,0 +1,65 @@
+const STEM_SUFFIXES = [
+    'ions',
+    'ing',
+    'tion',
+    'ness',
+    'ment',
+    'able',
+    'ible',
+    'ous',
+    'ive',
+    'ed',
+    'es',
+    's',
+];
+export function stem(word) {
+    for (const suffix of STEM_SUFFIXES) {
+        if (word.length > suffix.length + 2 && word.endsWith(suffix)) {
+            return word.slice(0, -suffix.length);
+        }
+    }
+    return word;
+}
+export function scoreSnippet(snippet, stems) {
+    let score = 0;
+    for (const solve of snippet.meta.solves) {
+        const lower = solve.toLowerCase();
+        score += stems.filter((w) => lower.includes(w)).length * 3;
+    }
+    for (const useCase of snippet.meta.useCases) {
+        const lower = useCase.toLowerCase();
+        score += stems.filter((w) => lower.includes(w)).length * 2;
+    }
+    const desc = snippet.description.toLowerCase();
+    score += stems.filter((w) => desc.includes(w)).length;
+    const title = snippet.title.toLowerCase();
+    score += stems.filter((w) => title.includes(w)).length * 2;
+    score += stems.filter((w) => snippet.tags.some((t) => t.includes(w))).length;
+    const classes = snippet.meta.classes.join(' ').toLowerCase();
+    score += stems.filter((w) => classes.includes(w)).length;
+    return score;
+}
+export function searchSnippets(snippets, options) {
+    const { query, category, tags, darkMode, responsive, limit = 10 } = options;
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const stems = words.map(stem);
+    if (stems.length === 0) {
+        return [];
+    }
+    const scored = snippets
+        .filter((snippet) => {
+        if (category && snippet.category !== category)
+            return false;
+        if (tags?.length && !tags.some((t) => snippet.tags.includes(t)))
+            return false;
+        if (darkMode !== undefined && snippet.darkMode !== darkMode)
+            return false;
+        if (responsive !== undefined && snippet.responsive !== responsive)
+            return false;
+        return true;
+    })
+        .map((snippet) => ({ snippet, score: scoreSnippet(snippet, stems) }))
+        .filter(({ score }) => score > 0)
+        .sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map(({ snippet }) => snippet);
+}

package/dist/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type RegistryOptions } from './registry.js';
+export declare function registerTools(server: McpServer, registryOptions?: RegistryOptions): void;