@synergy-design-system/mcp 0.1.0 → 1.1.0

package/dist/build/build.js

@@ -0,0 +1,33 @@
+import ora from 'ora';
+import { buildAssets } from './assets.js';
+import { buildComponents } from './components.js';
+import { buildFrameworkFiles } from './frameworks.js';
+import { buildStaticFiles } from './static.js';
+import { buildTokens } from './tokens.js';
+import { buildStyles } from './styles.js';
+const spinner = ora({
+    prefixText: 'MCP:',
+    text: 'Generating static metadata...',
+});
+const build = async () => {
+    spinner.start();
+    await buildAssets();
+    await buildComponents();
+    await buildFrameworkFiles();
+    await buildTokens();
+    await buildStyles();
+    // Should be run last as we will copy files where we see fit and paths must exist
+    await buildStaticFiles();
+};
+build()
+    .then(() => {
+    spinner.succeed('Static metadata generated successfully.');
+    process.exit(0);
+})
+    .catch((error) => {
+    spinner.fail(`Failed to generate static metadata. Error: ${error}`);
+    process.exit(1);
+})
+    .finally(() => {
+    spinner.stop();
+});

package/dist/build/components.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up all data from the components and framework packages and adds them to the static metadata.
+ */
+export declare const buildComponents: () => Promise<void>;

package/dist/build/components.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { copyFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { rimraf } from 'rimraf';
+import ora from 'ora';
+import { pascalCase } from 'change-case';
+import { componentPath, componentStaticPath, createPath, getAbsolutePath, } from '../utilities/index.js';
+const directories = {
+    angularPackageDir: getAbsolutePath('../../../../packages/angular'),
+    componentDir: getAbsolutePath('../../../../packages/components'),
+    reactPackageDir: getAbsolutePath('../../../../packages/react'),
+    vuePackageDir: getAbsolutePath('../../../../packages/vue'),
+};
+/**
+ * Gets the file list for a specific component.
+ * @param component The module to get the file list for.
+ * @returns An array of tuples that define file paths related to the component.
+ */
+const getComponentFileList = (component) => {
+    const { tagName, tagNameWithoutPrefix, } = component;
+    const staticFiles = [];
+    const vueComponentName = pascalCase([
+        'syn',
+        'vue',
+        tagNameWithoutPrefix,
+    ].join('-'));
+    // Dynamic paths to generated wrappers
+    const angularFile = `${directories.angularPackageDir}/components/${tagNameWithoutPrefix}/${tagNameWithoutPrefix}.component.ts`;
+    const componentFile = `${directories.componentDir}/src/components/${tagNameWithoutPrefix}/${tagNameWithoutPrefix}.component.ts`;
+    const reactFile = `${directories.reactPackageDir}/src/components/${tagNameWithoutPrefix}.ts`;
+    const vueFile = `${directories.vuePackageDir}/src/components/${vueComponentName}.vue`;
+    // Add support for styles
+    const defaultStyleFile = `${directories.componentDir}/src/components/${tagNameWithoutPrefix}/${tagNameWithoutPrefix}.styles.ts`;
+    const customStyleFile = `${directories.componentDir}/src/components/${tagNameWithoutPrefix}/${tagNameWithoutPrefix}.custom.styles.ts`;
+    staticFiles.push([
+        angularFile,
+        'component.angular.ts',
+    ]);
+    staticFiles.push([
+        componentFile,
+        'component.ts',
+    ]);
+    staticFiles.push([
+        reactFile,
+        'component.react.ts',
+    ]);
+    staticFiles.push([
+        vueFile,
+        'component.vue',
+    ]);
+    staticFiles.push([
+        defaultStyleFile,
+        'component.styles.ts',
+    ]);
+    staticFiles.push([
+        customStyleFile,
+        'component.custom.styles.ts',
+    ]);
+    return {
+        componentName: tagName,
+        entries: staticFiles
+            .filter(([fileName]) => existsSync(fileName)),
+    };
+};
+/**
+ * Sets up all data from the components and framework packages and adds them to the static metadata.
+ */
+export const buildComponents = async () => {
+    const spinner = ora({
+        prefixText: 'Components:',
+        text: 'Generating static metadata...',
+    }).start();
+    try {
+        // Import the custom elements manifest
+        const customElementsManifestImport = await import('@synergy-design-system/components/custom-elements.json', {
+            with: { type: 'json' },
+        });
+        const customElementsManifest = customElementsManifestImport.default?.modules;
+        spinner.text = 'Cleaning up old metadata...';
+        await rimraf(componentPath);
+        spinner.succeed('Old metadata cleaned up.');
+        spinner.text = 'Creating new metadata directory...';
+        // Create the components directory if it doesn't exist
+        await createPath(componentPath);
+        spinner.text = 'Generating components metadata...';
+        // Create and populate the metadata for each component
+        const componentMetadata = customElementsManifest
+            .filter(module => module.declarations && module.declarations.length === 1)
+            .filter(module => module
+            .declarations
+            .some(declaration => declaration.tagName))
+            .map(module => module.declarations[0])
+            .map(getComponentFileList)
+            .flat()
+            .map(({ componentName, entries }) => {
+            const absoluteComponentPath = join(componentPath, componentName);
+            // Create the component directory if it doesn't exist
+            if (!existsSync(absoluteComponentPath)) {
+                mkdirSync(absoluteComponentPath, { recursive: true });
+            }
+            return entries.map(([source, target]) => {
+                const targetFileName = join(absoluteComponentPath, target);
+                return copyFile(source, targetFileName);
+            });
+        });
+        await Promise.all(componentMetadata);
+        spinner.succeed('Components metadata generated successfully.');
+        spinner.text = 'Generating static metadata...';
+        if (!existsSync(componentStaticPath)) {
+            mkdirSync(componentStaticPath, { recursive: true });
+        }
+        const staticFiles = [
+            'README.md',
+            'CHANGELOG.md',
+            'LIMITATIONS.md',
+        ]
+            .map(staticFile => join(getAbsolutePath('../../../../packages/components'), staticFile))
+            .filter(existsSync)
+            .map(staticFile => {
+            const base = basename(staticFile);
+            const target = join(componentStaticPath, base);
+            return copyFile(staticFile, target);
+        });
+        await Promise.all(staticFiles);
+        spinner.succeed('Static metadata generated successfully.');
+        spinner.succeed('Generation of metadata generated successfully.');
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate components metadata. Error: ${error}`);
+        throw error;
+    }
+};

package/dist/build/frameworks.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up all static data from the supported frameworks.
+ */
+export declare const buildFrameworkFiles: () => Promise<void>;

package/dist/build/frameworks.js

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { copyFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import ora from 'ora';
+import { angularPath, createPath, getAbsolutePath, reactPath, vuePath, } from '../utilities/index.js';
+/**
+ * List of static files that should be copied to the static metadata directory.
+ */
+const staticFilesToCopy = [
+    // Angular specific documentation
+    [
+        getAbsolutePath('../../../../packages/angular/README.md'),
+        angularPath,
+    ],
+    [
+        getAbsolutePath('../../../../packages/angular/LIMITATIONS.md'),
+        angularPath,
+    ],
+    // React specific documentation
+    [
+        getAbsolutePath('../../../../packages/react/README.md'),
+        reactPath,
+    ],
+    [
+        getAbsolutePath('../../../../packages/react/LIMITATIONS.md'),
+        reactPath,
+    ],
+    // Vue specific documentation
+    [
+        getAbsolutePath('../../../../packages/vue/README.md'),
+        vuePath,
+    ],
+    [
+        getAbsolutePath('../../../../packages/vue/LIMITATIONS.md'),
+        vuePath,
+    ],
+];
+/**
+ * Sets up all static data from the supported frameworks.
+ */
+export const buildFrameworkFiles = async () => {
+    const spinner = ora({
+        prefixText: 'Framework files:',
+        text: 'Generating framework metadata...',
+    }).start();
+    try {
+        const staticFiles = staticFilesToCopy
+            .filter(file => existsSync(file.at(0)))
+            .map(async ([staticFile, target]) => {
+            await createPath(target);
+            return copyFile(staticFile, join(target, basename(staticFile)));
+        });
+        await Promise.all(staticFiles);
+        spinner.succeed('Framework metadata generated successfully.');
+        spinner.succeed('Generation of metadata generated successfully.');
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate framework metadata. Error: ${error}`);
+        throw error;
+    }
+};

package/dist/build/static.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up all data from the components and framework packages and adds them to the static metadata.
+ */
+export declare const buildStaticFiles: () => Promise<void>;

package/dist/build/static.js

@@ -0,0 +1,57 @@
+import { existsSync } from 'node:fs';
+import { copyFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import ora from 'ora';
+import { componentMigrationPath, createPath, getAbsolutePath, setupPath, } from '../utilities/index.js';
+/**
+ * List of static files that should be copied to the static metadata directory.
+ */
+const staticFilesToCopy = [
+    // The icon usage documentation needs to be copied to the static metadata directory
+    [
+        getAbsolutePath('../../../../packages/docs/src/static/icon-usage.md'),
+        setupPath,
+    ],
+    // Copy prerequisites as it includes information about font setup
+    [
+        getAbsolutePath('../../../../packages/docs/src/static/prerequisites.md'),
+        setupPath,
+    ],
+    // Copy the migration guide
+    [
+        getAbsolutePath('../../../../packages/components/BREAKING_CHANGES.md'),
+        componentMigrationPath,
+    ],
+    // Copy the v3 migration guide
+    [
+        getAbsolutePath('../../../../packages/docs/src/static/migration-synergy-v3.md'),
+        componentMigrationPath,
+    ],
+];
+/**
+ * Sets up all data from the components and framework packages and adds them to the static metadata.
+ */
+export const buildStaticFiles = async () => {
+    const spinner = ora({
+        prefixText: 'Static files:',
+        text: 'Generating static metadata...',
+    }).start();
+    try {
+        // Create the wanted directories if they don't exist
+        const createAllPaths = Promise.all(staticFilesToCopy.map(([, target]) => createPath(target)));
+        await createAllPaths;
+        const staticFiles = staticFilesToCopy
+            .filter(file => existsSync(file.at(0)))
+            .map(([staticFile, target]) => {
+            const targetFileName = join(target, basename(staticFile));
+            return copyFile(staticFile, targetFileName);
+        });
+        await Promise.all(staticFiles);
+        spinner.succeed('Static metadata generated successfully.');
+        spinner.succeed('Generation of metadata generated successfully.');
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate components metadata. Error: ${error}`);
+        throw error;
+    }
+};

package/dist/build/styles.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up all wanted data from the styles package and adds it to the static metadata.
+ */
+export declare const buildStyles: () => Promise<void>;

package/dist/build/styles.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { globby } from 'globby';
+import { rimraf } from 'rimraf';
+import ora from 'ora';
+import { createPath, stylesPath, } from '../utilities/index.js';
+/**
+ * List of relative paths to files that should be copied to the static metadata directory.
+ */
+const filesToCopy = [
+    'README.md',
+    'CHANGELOG.md',
+    'dist/*.css',
+];
+/**
+ * Sets up all wanted data from the styles package and adds it to the static metadata.
+ */
+export const buildStyles = async () => {
+    const spinner = ora({
+        prefixText: 'Styles:',
+        text: 'Generating static metadata...',
+    }).start();
+    try {
+        spinner.text = 'Cleaning up old metadata...';
+        await rimraf(stylesPath);
+        spinner.succeed('Old metadata cleaned up.');
+        spinner.text = 'Creating new metadata directory...';
+        // Create the styles directory if it doesn't exist
+        await createPath(stylesPath);
+        spinner.succeed('New metadata directory created.');
+        spinner.text = 'Copying files to metadata directory...';
+        // Get the module's root directory
+        // Note that the default export resolves to dist/index.css,
+        // so we need to go up one level to get to the root of the package!
+        const moduleUrl = import.meta.resolve('@synergy-design-system/styles');
+        const modulePath = fileURLToPath(moduleUrl);
+        const moduleDir = path.join(path.dirname(modulePath), '../');
+        // Process the files (placeholder for actual logic)
+        // eslint-disable-next-line no-console
+        const contents = await globby(filesToCopy, {
+            cwd: moduleDir,
+            onlyFiles: true,
+        });
+        // Write the files to the tokens directory into a flat structure
+        const copies = contents.map(file => {
+            const sourcePath = path.join(moduleDir, file);
+            const destPath = path.join(stylesPath, path.basename(file));
+            return fs.copyFile(sourcePath, destPath);
+        });
+        await Promise.all(copies);
+        spinner.succeed('Styles metadata generated successfully.');
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate styles metadata. Error: ${error}`);
+        throw error; // Re-throw to handle it in the calling function
+    }
+};

package/dist/build/tokens.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up all wanted data from the tokens package and adds it to the static metadata.
+ */
+export declare const buildTokens: () => Promise<void>;

package/dist/build/tokens.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { globby } from 'globby';
+import { rimraf } from 'rimraf';
+import ora from 'ora';
+import { createPath, tokensPath, } from '../utilities/index.js';
+/**
+ * List of relative paths to files that should be copied to the static metadata directory.
+ */
+const filesToCopy = [
+    'README.md',
+    'CHANGELOG.md',
+    'dist/js/*.js',
+    'dist/themes/*.css',
+];
+/**
+ * Sets up all wanted data from the tokens package and adds it to the static metadata.
+ */
+export const buildTokens = async () => {
+    const spinner = ora({
+        prefixText: 'Tokens:',
+        text: 'Generating static metadata...',
+    }).start();
+    try {
+        spinner.text = 'Cleaning up old metadata...';
+        await rimraf(tokensPath);
+        spinner.succeed('Old metadata cleaned up.');
+        spinner.text = 'Creating new metadata directory...';
+        // Create the tokens directory if it doesn't exist
+        await createPath(tokensPath);
+        spinner.succeed('New metadata directory created.');
+        spinner.text = 'Copying files to metadata directory...';
+        // Get the module's root directory
+        // Note that the default export resolves to dist/js/index.js,
+        // so we need to go up two levels to get to the root of the package!
+        const moduleUrl = import.meta.resolve('@synergy-design-system/tokens');
+        const modulePath = fileURLToPath(moduleUrl);
+        const moduleDir = path.join(path.dirname(modulePath), '../../');
+        // Process the files (placeholder for actual logic)
+        // eslint-disable-next-line no-console
+        const contents = await globby(filesToCopy, {
+            cwd: moduleDir,
+            onlyFiles: true,
+        });
+        // Write the files to the tokens directory into a flat structure
+        const copies = contents.map(file => {
+            const sourcePath = path.join(moduleDir, file);
+            const destPath = path.join(tokensPath, path.basename(file));
+            return fs.copyFile(sourcePath, destPath);
+        });
+        await Promise.all(copies);
+        spinner.succeed('Tokens metadata generated successfully.');
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate tokens metadata. Error: ${error}`);
+        throw error; // Re-throw to handle it in the calling function
+    }
+};

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Creates a new instance of the MCP server configured for the Synergy Design System.
+ * @returns A new instance of the MCP server configured for the Synergy Design System.
+ */
+export declare const createServer: () => McpServer;

package/dist/server.js

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import * as tools from './tools/index.js';
+import { getVersion } from './utilities/version.js';
+/**
+ * Creates a new instance of the MCP server configured for the Synergy Design System.
+ * @returns A new instance of the MCP server configured for the Synergy Design System.
+ */
+export const createServer = () => {
+    const version = getVersion();
+    const server = new McpServer({
+        description: 'A server for the Synergy Design System that provides tools to interact with components and resources.',
+        name: 'synergy design system',
+        title: 'Synergy Design System MCP Server',
+        version,
+    });
+    Object.values(tools).forEach(tool => {
+        tool(server);
+    });
+    return server;
+};

package/dist/tools/asset-info.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Simple tool to list all available assets in the Synergy Design System.
+ * This tool fetches the asset data from the Synergy package and formats it for display.
+ * @todo: Maybe also include the metadata like in docs and use this to map the new/old sets?
+ * @param server - The MCP server instance to register the tool on.
+ */
+export declare const assetInfoTool: (server: McpServer) => void;

package/dist/tools/asset-info.js

@@ -0,0 +1,140 @@
+/* eslint-disable complexity */
+import { z } from 'zod';
+import * as availableIconsets from '@synergy-design-system/assets';
+import { getAssetsMetaData, getStructuredMetaData, } from '../utilities/index.js';
+const iconsetListAliases = {
+    sick2018Icons: [
+        'current',
+        'default',
+        'legacy',
+        'v2',
+        'synergy2018',
+        'brand2018',
+        'sick2018',
+    ],
+    sick2025Icons: [
+        'synergy2025',
+        'new',
+        'next',
+        'brand2025',
+        'sick2025',
+        'v3',
+    ],
+};
+const DEFAULT_LIMIT = 5;
+/**
+ * Simple tool to list all available assets in the Synergy Design System.
+ * This tool fetches the asset data from the Synergy package and formats it for display.
+ * @todo: Maybe also include the metadata like in docs and use this to map the new/old sets?
+ * @param server - The MCP server instance to register the tool on.
+ */
+export const assetInfoTool = (server) => {
+    server.registerTool('asset-info', {
+        description: 'Get information about available icons in the Synergy Design System. Will return the full list of icons in a set or just a subset',
+        inputSchema: {
+            filter: z
+                .string()
+                .optional()
+                .describe('A filter to apply to the icon names. If provided, only icons matching this filter will be returned. Supports multiple filters separated by "|" (e.g., "home|search|menu" to find icons containing any of these terms).'),
+            iconset: z
+                .enum([
+                'current', // Special key, maps to 2018 currently, should map to 2025 in the next major version
+                'default', // Alias for current
+                'legacy', // Fallback to 2018
+                'v2', // Fallback to 2018
+                'synergy2018', // Fallback name of the set for 2018
+                'brand2018', // Alternative name of the set for 2018
+                'sick2018', // Official name for 2018 (Synergy V2)
+                'brand2025', // Alternative name of the set for 2025
+                'sick2025', // Official name for 2025 (Synergy V3)
+                'synergy2025', // Alias for sick2025
+                'new', // Alias for sick2025
+                'next', // Alias for sick2025
+                'v3', // Done for completeness, maps to 2025
+            ])
+                .default('current')
+                .optional()
+                .describe('The name of the icon set to retrieve icons from.'),
+            limit: z
+                .number()
+                .default(DEFAULT_LIMIT)
+                .optional()
+                .describe(`The maximum number of icons to return. Defaults to ${DEFAULT_LIMIT}. When using multiple filters (pipe-separated), this limit applies per filter term.`),
+        },
+        title: 'Available Icons',
+    }, async ({ filter, iconset, limit, }) => {
+        // Get the iconset that should be used by key/value of iconsetListAliases
+        const setToUse = iconset
+            ? Object
+                .entries(iconsetListAliases)
+                .find(([, aliases]) => aliases.includes(iconset))?.[0] || 'sick2018Icons'
+            : 'sick2018Icons';
+        const foundIconSet = typeof availableIconsets[setToUse] !== undefined
+            ? availableIconsets[setToUse]
+            : availableIconsets.sick2018Icons;
+        // Filter the icons if a filter is provided
+        // Support pipe-separated filters (e.g., "icon1|icon2|icon3") for multiple icon matching
+        let availableIcons;
+        if (!filter) {
+            availableIcons = Object.keys(foundIconSet);
+        }
+        else {
+            const lowerFilter = filter.toLowerCase();
+            // Check if filter contains pipe separator for multiple filters
+            if (lowerFilter.includes('|')) {
+                const filterTerms = lowerFilter.split('|').map(term => term.trim());
+                const iconsPerTerm = [];
+                // For each filter term, find matching icons and apply limit per term
+                filterTerms.forEach(term => {
+                    const matchingIcons = Object
+                        .keys(foundIconSet)
+                        .filter(iconName => iconName.toLowerCase().includes(term))
+                        .slice(0, limit ?? DEFAULT_LIMIT); // Apply limit per filter term
+                    iconsPerTerm.push(...matchingIcons);
+                });
+                // Remove duplicates while preserving order
+                availableIcons = [...new Set(iconsPerTerm)];
+            }
+            else {
+                // Original single filter behavior
+                availableIcons = Object
+                    .keys(foundIconSet)
+                    .filter(iconName => iconName.toLowerCase().includes(lowerFilter));
+            }
+        }
+        // For single filters or no filter, apply the limit normally
+        const limitedIcons = (!filter || !filter.includes('|')) && (limit ?? DEFAULT_LIMIT) > 0
+            ? availableIcons.slice(0, limit ?? DEFAULT_LIMIT)
+            : availableIcons;
+        const icons = limitedIcons.map(icon => `- ${icon}`).join('\n');
+        const content = [
+            {
+                text: `Available icons in iconset "${setToUse}":`,
+                type: 'text',
+            },
+            {
+                text: `Showing ${limitedIcons.length} of ${availableIcons.length} icons`,
+                type: 'text',
+            },
+            {
+                text: icons,
+                type: 'text',
+            },
+        ];
+        const aiRules = await getStructuredMetaData('../../metadata/static/assets');
+        const assetData = await getAssetsMetaData((fileName) => !fileName.toLowerCase().startsWith('changelog'));
+        return {
+            content: [
+                {
+                    text: JSON.stringify(aiRules, null, 2),
+                    type: 'text',
+                },
+                {
+                    text: JSON.stringify(assetData, null, 2),
+                    type: 'text',
+                },
+                ...content,
+            ],
+        };
+    });
+};

package/dist/tools/asset-list.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Simple tool to list all available iconsets in the Synergy Design System.
+ * @param server - The MCP server instance to register the tool on.
+ */
+export declare const assetListTool: (server: McpServer) => void;

package/dist/tools/asset-list.js

@@ -0,0 +1,40 @@
+import { getStructuredMetaData, } from '../utilities/index.js';
+/**
+ * Simple tool to list all available iconsets in the Synergy Design System.
+ * @param server - The MCP server instance to register the tool on.
+ */
+export const assetListTool = (server) => {
+    server.registerTool('asset-list', {
+        description: 'Get the available iconsets in the Synergy Design System.',
+        title: 'Available iconsets',
+    }, async () => {
+        const aiRules = await getStructuredMetaData('../../metadata/static/assets');
+        return {
+            content: [
+                {
+                    text: 'Available iconsets in the Synergy Design System:',
+                    type: 'text',
+                },
+                {
+                    text: JSON.stringify([
+                        {
+                            text: JSON.stringify(aiRules, null, 2),
+                            type: 'text',
+                        },
+                        {
+                            description: 'The original set of icons from the Synergy Design System. Use this for projects using Synergy Major Version 2.0.',
+                            iconset: 'sick2018Icons',
+                            title: 'Synergy 2018 Icons',
+                        },
+                        {
+                            description: 'New icon set for the brand 2025 refresh. Use this for projects using Synergy Major Version 3.0.',
+                            iconset: 'sick2025Icons',
+                            title: 'Synergy 2025 Icons',
+                        },
+                    ], null, 2),
+                    type: 'text',
+                },
+            ],
+        };
+    });
+};

package/dist/tools/component-info.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Simple tool to retrieve information about a given component in the Synergy Design System.
+ * @param server - The MCP server instance to register the tool on.
+ */
+export declare const componentInfoTool: (server: McpServer) => void;