@iress-oss/ids-mcp-server 0.0.1-dev.5 → 0.0.1-dev.7

package/dist/componentHandlers.js

@@ -0,0 +1,241 @@
+/**
+ * Tool handlers for component-related operations
+ */
+import { z } from 'zod';
+import * as path from 'path';
+import { getMarkdownFiles, mapIressComponentToFile, extractIressComponents, readFileContent, } from './utils.js';
+import { DOCS_DIR } from './config.js';
+function checkIressComponentMatch(query) {
+    if (query.startsWith('Iress')) {
+        const componentFile = mapIressComponentToFile(query);
+        if (componentFile) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Found exact match for **${query}**:\n\n**${componentFile}**\n   ${query} component documentation\n\n*Use \`get_iress_component_info\` with "${query}" for detailed information.*`,
+                    },
+                ],
+            };
+        }
+    }
+    return null;
+}
+function calculateRelevanceScore(file, content, query, lines) {
+    let relevanceScore = 0;
+    const queryLower = query.toLowerCase();
+    const filenameLower = file.toLowerCase();
+    // Check for Iress component mentions in content
+    const iressComponents = extractIressComponents(content);
+    const hasMatchingIressComponent = iressComponents.some((comp) => comp.toLowerCase().includes(queryLower) ||
+        queryLower.includes(comp.toLowerCase().replace('iress', '')));
+    if (hasMatchingIressComponent) {
+        relevanceScore += 75;
+    }
+    // High relevance for filename matches
+    if (filenameLower.includes(queryLower)) {
+        relevanceScore += 100;
+    }
+    // Medium relevance for title matches
+    const title = lines.find((line) => line.startsWith('#'))?.replace(/^#+\s*/, '') ?? '';
+    if (title.toLowerCase().includes(queryLower)) {
+        relevanceScore += 50;
+    }
+    // Lower relevance for content matches
+    const contentMatches = content.toLowerCase().split(queryLower).length - 1;
+    relevanceScore += contentMatches * 2;
+    return relevanceScore;
+}
+function createSearchResult(file, relevanceScore, lines) {
+    const componentName = file
+        .replace(/^components-/, '')
+        .replace('-docs.md', '');
+    const description = lines
+        .slice(0, 10)
+        .find((line) => line.trim() && !line.startsWith('#') && !line.startsWith('<!--'))
+        ?.trim() ?? 'IDS component documentation';
+    return {
+        file,
+        relevance: relevanceScore,
+        description: `${componentName}: ${description}`,
+    };
+}
+export function handleFindComponent(args) {
+    const schema = z.object({
+        query: z.string(),
+        category: z.enum(['components', 'foundations', 'resources']).optional(),
+    });
+    const { query, category } = schema.parse(args);
+    // Check if query is an Iress component name
+    const iressMatch = checkIressComponentMatch(query);
+    if (iressMatch) {
+        return iressMatch;
+    }
+    const markdownFiles = getMarkdownFiles();
+    // Filter files by category if specified
+    const filteredFiles = category
+        ? markdownFiles.filter((file) => file.startsWith(`${category}-`))
+        : markdownFiles;
+    const results = [];
+    for (const file of filteredFiles) {
+        try {
+            const filePath = path.join(DOCS_DIR, file);
+            const content = readFileContent(filePath);
+            const lines = content.split('\n');
+            const relevanceScore = calculateRelevanceScore(file, content, query, lines);
+            if (relevanceScore > 0) {
+                results.push(createSearchResult(file, relevanceScore, lines));
+            }
+        }
+        catch (error) {
+            console.error(`Error reading file ${file}:`, error);
+        }
+    }
+    // Sort by relevance
+    results.sort((a, b) => b.relevance - a.relevance);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: results.length > 0
+                    ? `Found ${results.length} relevant IDS components:\n\n${results
+                        .slice(0, 10) // Limit to top 10 results
+                        .map((r, index) => `${index + 1}. **${r.file}**\n   ${r.description}`)
+                        .join('\n\n')}`
+                    : `No IDS components found matching "${query}". Try searching for common component names like "button", "input", "table", or "modal".`,
+            },
+        ],
+    };
+}
+function findComponentFile(component, markdownFiles) {
+    return markdownFiles.find((file) => file.includes(`components-${component.toLowerCase()}`) ||
+        file.toLowerCase().includes(component.toLowerCase()));
+}
+function formatAvailableComponents(markdownFiles) {
+    return markdownFiles
+        .filter((f) => f.startsWith('components-'))
+        .map((f) => `- ${f.replace('components-', '').replace('-docs.md', '')}`)
+        .join('\n');
+}
+function isPropsRelatedLine(line) {
+    return (line.includes('mode') ||
+        line.includes('prop') ||
+        line.includes('Properties') ||
+        line.includes('API') ||
+        line.includes('Examples'));
+}
+function extractPropSections(content) {
+    const lines = content.split('\n');
+    const propSections = [];
+    let inPropsSection = false;
+    let currentSection = '';
+    for (const line of lines) {
+        if (isPropsRelatedLine(line)) {
+            if (currentSection) {
+                propSections.push(currentSection);
+            }
+            currentSection = line + '\n';
+            inPropsSection = true;
+        }
+        else if (inPropsSection && line.trim()) {
+            currentSection += line + '\n';
+        }
+        else if (inPropsSection && !line.trim()) {
+            if (currentSection) {
+                propSections.push(currentSection);
+                currentSection = '';
+            }
+            inPropsSection = false;
+        }
+    }
+    if (currentSection) {
+        propSections.push(currentSection);
+    }
+    return propSections;
+}
+function formatPropsResponse(propSections, content, componentFile) {
+    return propSections.length > 0
+        ? propSections.join('\n---\n\n')
+        : `Props information extracted from ${componentFile}:\n\n${content.slice(0, 2000)}...`;
+}
+export function handleGetComponentProps(args) {
+    const schema = z.object({
+        component: z.string(),
+    });
+    const { component } = schema.parse(args);
+    const markdownFiles = getMarkdownFiles();
+    const componentFile = findComponentFile(component, markdownFiles);
+    if (!componentFile) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Component "${component}" not found. Available components:\n${formatAvailableComponents(markdownFiles)}`,
+                },
+            ],
+        };
+    }
+    try {
+        const filePath = path.join(DOCS_DIR, componentFile);
+        const content = readFileContent(filePath);
+        const propSections = extractPropSections(content);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**${component} Component Props & API**\n\n${formatPropsResponse(propSections, content, componentFile)}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to read component file ${componentFile}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function handleListComponents(args) {
+    const schema = z.object({
+        category: z
+            .enum(['components', 'foundations', 'resources', 'all'])
+            .default('all'),
+    });
+    const { category } = schema.parse(args);
+    const markdownFiles = getMarkdownFiles();
+    const categorized = {
+        components: markdownFiles
+            .filter((f) => f.startsWith('components-'))
+            .map((f) => f.replace('components-', '').replace('-docs.md', '')),
+        foundations: markdownFiles
+            .filter((f) => f.startsWith('foundations-'))
+            .map((f) => f.replace('foundations-', '').replace('-docs.md', '')),
+        resources: markdownFiles
+            .filter((f) => f.startsWith('resources-'))
+            .map((f) => f.replace('resources-', '').replace('-docs.md', '')),
+    };
+    let output = '**IDS Component Library**\n\n';
+    if (category === 'all') {
+        const componentsList = categorized.components
+            .map((c) => `- ${c}`)
+            .join('\n');
+        const foundationsList = categorized.foundations
+            .map((c) => `- ${c}`)
+            .join('\n');
+        const resourcesList = categorized.resources.map((c) => `- ${c}`).join('\n');
+        output += `**Components (${categorized.components.length})**\n${componentsList}\n\n`;
+        output += `**Foundations (${categorized.foundations.length})**\n${foundationsList}\n\n`;
+        output += `**Resources (${categorized.resources.length})**\n${resourcesList}`;
+    }
+    else {
+        const items = categorized[category];
+        const itemsList = items.map((c) => `- ${c}`).join('\n');
+        const categoryTitle = category.charAt(0).toUpperCase() + category.slice(1);
+        output += `**${categoryTitle} (${items.length})**\n${itemsList}`;
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: output,
+            },
+        ],
+    };
+}

package/dist/componentHandlers.test.js

@@ -0,0 +1,380 @@
+/**
+ * Tests for component handlers
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { handleFindComponent, handleGetComponentProps, handleListComponents, } from './componentHandlers.js';
+import * as utils from './utils.js';
+// Mock the utils module
+vi.mock('./utils.js', () => ({
+    getMarkdownFiles: vi.fn(),
+    mapIressComponentToFile: vi.fn(),
+    extractIressComponents: vi.fn(),
+    readFileContent: vi.fn(),
+}));
+// Mock the config module
+vi.mock('./config.js', () => ({
+    DOCS_DIR: '/mocked/docs/path',
+}));
+const mockUtils = vi.mocked(utils);
+describe('componentHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('handleFindComponent', () => {
+        const mockMarkdownFiles = [
+            'components-button-docs.md',
+            'components-input-docs.md',
+            'components-table-docs.md',
+            'foundations-colors-docs.md',
+            'resources-icons-docs.md',
+        ];
+        const mockButtonContent = `# Button Component
+
+A versatile button component for user interactions.
+
+## Props
+- variant: string - Button style variant
+- size: string - Button size
+
+## Examples
+\`\`\`jsx
+<Button variant="primary">Click me</Button>
+\`\`\`
+`;
+        it('should find exact match for Iress component', () => {
+            const args = {
+                query: 'IressButton',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue('components-button-docs.md');
+            const result = handleFindComponent(args);
+            expect(mockUtils.mapIressComponentToFile).toHaveBeenCalledWith('IressButton');
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].type).toBe('text');
+            expect(result.content[0].text).toContain('Found exact match for **IressButton**');
+            expect(result.content[0].text).toContain('components-button-docs.md');
+            expect(result.content[0].text).toContain('Use `get_iress_component_info` with "IressButton"');
+        });
+        it('should return null for non-matching Iress component', () => {
+            const args = {
+                query: 'IressNonExistent',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockReturnValue('No relevant content');
+            mockUtils.extractIressComponents.mockReturnValue([]);
+            const result = handleFindComponent(args);
+            expect(result.content[0].text).toContain('No IDS components found matching "IressNonExistent"');
+        });
+        it('should search and rank components by relevance', () => {
+            const args = {
+                query: 'button',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.extractIressComponents.mockReturnValue([]);
+            // Mock file content with different relevance scores
+            mockUtils.readFileContent.mockImplementation((filePath) => {
+                if (filePath.includes('button')) {
+                    return mockButtonContent;
+                }
+                return 'Some other component content';
+            });
+            const result = handleFindComponent(args);
+            expect(result.content[0].text).toContain('Found');
+            expect(result.content[0].text).toContain('relevant IDS components');
+            expect(result.content[0].text).toContain('button-docs.md');
+        });
+        it('should filter by category when specified', () => {
+            const args = {
+                query: 'component',
+                category: 'components',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.extractIressComponents.mockReturnValue([]);
+            mockUtils.readFileContent.mockReturnValue('Component content');
+            handleFindComponent(args);
+            // Should only search components category files
+            expect(mockUtils.readFileContent).toHaveBeenCalledWith('/mocked/docs/path/components-button-docs.md');
+            expect(mockUtils.readFileContent).toHaveBeenCalledWith('/mocked/docs/path/components-input-docs.md');
+            expect(mockUtils.readFileContent).not.toHaveBeenCalledWith('/mocked/docs/path/foundations-colors-docs.md');
+        });
+        it('should handle Iress component mentions in content', () => {
+            const args = {
+                query: 'button',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(['components-form-docs.md']);
+            mockUtils.extractIressComponents.mockReturnValue(['IressButton']);
+            mockUtils.readFileContent.mockReturnValue('This form uses IressButton component');
+            const result = handleFindComponent(args);
+            expect(result.content[0].text).toContain('relevant IDS components');
+        });
+        it('should validate input parameters using zod schema', () => {
+            const invalidArgs = {
+                query: 123, // Should be string
+            };
+            expect(() => handleFindComponent(invalidArgs)).toThrow();
+        });
+        it('should validate category parameter using zod schema', () => {
+            const invalidArgs = {
+                query: 'button',
+                category: 'invalid-category', // Should be enum value
+            };
+            expect(() => handleFindComponent(invalidArgs)).toThrow();
+        });
+        it('should handle file reading errors gracefully', () => {
+            const args = {
+                query: 'button',
+            };
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(['components-button-docs.md']);
+            mockUtils.readFileContent.mockImplementation(() => {
+                throw new Error('File read error');
+            });
+            // Should not throw, but handle error gracefully
+            const result = handleFindComponent(args);
+            expect(result.content[0].text).toContain('No IDS components found matching "button"');
+        });
+        it('should limit results to top 10', () => {
+            const args = {
+                query: 'component',
+            };
+            const manyFiles = Array.from({ length: 15 }, (_, i) => `components-comp${i}-docs.md`);
+            mockUtils.mapIressComponentToFile.mockReturnValue(null);
+            mockUtils.getMarkdownFiles.mockReturnValue(manyFiles);
+            mockUtils.extractIressComponents.mockReturnValue([]);
+            mockUtils.readFileContent.mockReturnValue('component content');
+            const result = handleFindComponent(args);
+            // Count the number of component entries by splitting on numbered items
+            const entries = result.content[0].text.split(/\n\d+\. /).length - 1;
+            expect(entries).toBeLessThanOrEqual(10);
+        });
+    });
+    describe('handleGetComponentProps', () => {
+        const mockMarkdownFiles = [
+            'components-button-docs.md',
+            'components-input-docs.md',
+        ];
+        const mockComponentContent = `# Button Component
+
+## Overview
+A button component
+
+## Props
+- variant: string - The button variant
+- size: string - The button size  
+
+Some text after props
+
+## API
+Additional API methods
+
+Some text after API
+
+## Examples
+Usage examples here
+
+Some text after examples
+`;
+        it('should return component props when component exists', () => {
+            const args = {
+                component: 'button',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockReturnValue(mockComponentContent);
+            const result = handleGetComponentProps(args);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].type).toBe('text');
+            expect(result.content[0].text).toContain('**button Component Props & API**');
+            expect(result.content[0].text).toContain('## API');
+            expect(result.content[0].text).toContain('Additional API methods');
+        });
+        it('should return error when component not found', () => {
+            const args = {
+                component: 'nonexistent',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleGetComponentProps(args);
+            expect(result.content[0].text).toContain('Component "nonexistent" not found');
+            expect(result.content[0].text).toContain('Available components:');
+            expect(result.content[0].text).toContain('- button');
+            expect(result.content[0].text).toContain('- input');
+        });
+        it('should handle case-insensitive component matching', () => {
+            const args = {
+                component: 'BUTTON',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockReturnValue(mockComponentContent);
+            const result = handleGetComponentProps(args);
+            expect(result.content[0].text).toContain('**BUTTON Component Props & API**');
+        });
+        it('should extract props from content with no specific props sections', () => {
+            const args = {
+                component: 'button',
+            };
+            const contentWithoutProps = `# Button Component
+This is a simple button component without specific props sections.
+Here is some general documentation.`;
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockReturnValue(contentWithoutProps);
+            const result = handleGetComponentProps(args);
+            expect(result.content[0].text).toContain('This is a simple button component');
+        });
+        it('should throw error when file reading fails', () => {
+            const args = {
+                component: 'button',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockImplementation(() => {
+                throw new Error('File access denied');
+            });
+            expect(() => handleGetComponentProps(args)).toThrow('Failed to read component file components-button-docs.md: File access denied');
+        });
+        it('should validate input parameters using zod schema', () => {
+            const invalidArgs = {
+                component: 123, // Should be string
+            };
+            expect(() => handleGetComponentProps(invalidArgs)).toThrow();
+        });
+        it('should handle multiple prop-related sections', () => {
+            const contentWithMultipleSections = `# Button Component
+
+## Props
+- variant: string
+
+## API
+Methods available
+
+## Properties  
+Additional properties
+
+## mode
+Different modes
+`;
+            const args = {
+                component: 'button',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            mockUtils.readFileContent.mockReturnValue(contentWithMultipleSections);
+            const result = handleGetComponentProps(args);
+            expect(result.content[0].text).toContain('Props');
+            expect(result.content[0].text).toContain('API');
+            expect(result.content[0].text).toContain('Properties');
+            expect(result.content[0].text).toContain('mode');
+        });
+    });
+    describe('handleListComponents', () => {
+        const mockMarkdownFiles = [
+            'components-button-docs.md',
+            'components-input-docs.md',
+            'components-table-docs.md',
+            'foundations-colors-docs.md',
+            'foundations-typography-docs.md',
+            'resources-icons-docs.md',
+        ];
+        it('should list all components by default', () => {
+            const args = {};
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].type).toBe('text');
+            expect(result.content[0].text).toContain('**IDS Component Library**');
+            expect(result.content[0].text).toContain('**Components (3)**');
+            expect(result.content[0].text).toContain('- button');
+            expect(result.content[0].text).toContain('- input');
+            expect(result.content[0].text).toContain('- table');
+            expect(result.content[0].text).toContain('**Foundations (2)**');
+            expect(result.content[0].text).toContain('- colors');
+            expect(result.content[0].text).toContain('- typography');
+            expect(result.content[0].text).toContain('**Resources (1)**');
+            expect(result.content[0].text).toContain('- icons');
+        });
+        it('should list only components when category is "components"', () => {
+            const args = {
+                category: 'components',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('**Components (3)**');
+            expect(result.content[0].text).toContain('- button');
+            expect(result.content[0].text).toContain('- input');
+            expect(result.content[0].text).toContain('- table');
+            expect(result.content[0].text).not.toContain('**Foundations');
+            expect(result.content[0].text).not.toContain('**Resources');
+        });
+        it('should list only foundations when category is "foundations"', () => {
+            const args = {
+                category: 'foundations',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('**Foundations (2)**');
+            expect(result.content[0].text).toContain('- colors');
+            expect(result.content[0].text).toContain('- typography');
+            expect(result.content[0].text).not.toContain('**Components');
+            expect(result.content[0].text).not.toContain('**Resources');
+        });
+        it('should list only resources when category is "resources"', () => {
+            const args = {
+                category: 'resources',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('**Resources (1)**');
+            expect(result.content[0].text).toContain('- icons');
+            expect(result.content[0].text).not.toContain('**Components');
+            expect(result.content[0].text).not.toContain('**Foundations');
+        });
+        it('should list all categories when category is "all"', () => {
+            const args = {
+                category: 'all',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('**Components (3)**');
+            expect(result.content[0].text).toContain('**Foundations (2)**');
+            expect(result.content[0].text).toContain('**Resources (1)**');
+        });
+        it('should handle empty file lists', () => {
+            const args = {
+                category: 'components',
+            };
+            mockUtils.getMarkdownFiles.mockReturnValue([]);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('**Components (0)**');
+        });
+        it('should validate category parameter using zod schema', () => {
+            const invalidArgs = {
+                category: 'invalid-category', // Should be enum value
+            };
+            expect(() => handleListComponents(invalidArgs)).toThrow();
+        });
+        it('should use default category when not specified', () => {
+            const args = {};
+            mockUtils.getMarkdownFiles.mockReturnValue(mockMarkdownFiles);
+            const result = handleListComponents(args);
+            // Should default to 'all' and show all categories
+            expect(result.content[0].text).toContain('**Components');
+            expect(result.content[0].text).toContain('**Foundations');
+            expect(result.content[0].text).toContain('**Resources');
+        });
+        it('should properly format component names by removing prefixes and suffixes', () => {
+            const customFiles = [
+                'components-complex-button-component-docs.md',
+                'foundations-design-tokens-docs.md',
+                'resources-icon-library-docs.md',
+            ];
+            const args = {};
+            mockUtils.getMarkdownFiles.mockReturnValue(customFiles);
+            const result = handleListComponents(args);
+            expect(result.content[0].text).toContain('- complex-button-component');
+            expect(result.content[0].text).toContain('- design-tokens');
+            expect(result.content[0].text).toContain('- icon-library');
+        });
+    });
+});

package/dist/config.js

@@ -0,0 +1,16 @@
+/**
+ * Configuration constants for the IDS MCP Server
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const DOCS_DIR = path.join(__dirname, '..', 'generated', 'docs');
+export const SERVER_CONFIG = {
+    name: 'ids-mcp-server',
+    version: '1.0.0',
+};
+export const CAPABILITIES = {
+    resources: {},
+    tools: {},
+};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { SERVER_CONFIG, CAPABILITIES } from './config.js';
+import { toolDefinitions } from './tools.js';
+import { handleToolCall } from './toolHandler.js';
+import { handleListResources, handleReadResource } from './resourceHandlers.js';
+/**
+ * Create MCP server for Iress Design System (IDS) component library context
+ */
+const server = new Server(SERVER_CONFIG, { capabilities: CAPABILITIES });
+/**
+ * List available IDS component documentation resources
+ */
+server.setRequestHandler(ListResourcesRequestSchema, () => {
+    const result = handleListResources();
+    return result;
+});
+/**
+ * Read content from a specific markdown file
+ */
+server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+    const result = handleReadResource(request);
+    return result;
+});
+/**
+ * List available IDS development tools
+ */
+server.setRequestHandler(ListToolsRequestSchema, () => {
+    return {
+        tools: toolDefinitions,
+    };
+});
+/**
+ * Handle IDS component library tool calls
+ */
+server.setRequestHandler(CallToolRequestSchema, (request) => {
+    const result = handleToolCall(request);
+    return result;
+});
+/**
+ * Start the server
+ */
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('IDS Component Library MCP Server running on stdio');
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});