@idealyst/mcp-server 1.0.84

package/src/index.ts

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { components } from "./data/components/index.js";
+import { cliCommands } from "./data/cli-commands.js";
+import { frameworkGuides } from "./data/framework-guides.js";
+import { navigationGuides } from "./data/navigation-guides.js";
+import { iconGuide } from "./data/icon-guide.js";
+import iconsData from "./data/icons.json" with { type: "json" };
+
+const server = new Server(
+  {
+    name: "@idealyst/mcp-server",
+    version: "1.0.83",
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+// List all available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "list_components",
+        description: "List all available Idealyst components with brief descriptions",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "get_component_docs",
+        description: "Get detailed documentation for a specific Idealyst component including props, usage, and examples",
+        inputSchema: {
+          type: "object",
+          properties: {
+            component: {
+              type: "string",
+              description: "The name of the component (e.g., 'Button', 'Card', 'Input')",
+            },
+          },
+          required: ["component"],
+        },
+      },
+      {
+        name: "get_component_example",
+        description: "Get a code example for a specific Idealyst component",
+        inputSchema: {
+          type: "object",
+          properties: {
+            component: {
+              type: "string",
+              description: "The name of the component",
+            },
+            example_type: {
+              type: "string",
+              description: "Type of example: 'basic', 'variants', 'with-icons', 'interactive'",
+              enum: ["basic", "variants", "with-icons", "interactive"],
+            },
+          },
+          required: ["component"],
+        },
+      },
+      {
+        name: "get_cli_usage",
+        description: "Get information about Idealyst CLI commands and usage",
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "Specific CLI command to get info about (optional)",
+            },
+          },
+        },
+      },
+      {
+        name: "search_components",
+        description: "Search for components by name, category, or feature",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query",
+            },
+            category: {
+              type: "string",
+              description: "Filter by category: 'layout', 'form', 'display', 'navigation', 'overlay', 'data'",
+              enum: ["layout", "form", "display", "navigation", "overlay", "data"],
+            },
+          },
+        },
+      },
+      {
+        name: "search_icons",
+        description: "Search for Material Design Icons by name or keyword. Returns matching icon names from 7,447 available icons.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search term to find icons (e.g., 'home', 'user', 'arrow')",
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results to return (default: 20)",
+            },
+          },
+          required: ["query"],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  switch (name) {
+    case "list_components": {
+      const componentList = Object.entries(components).map(([name, data]) => ({
+        name,
+        category: data.category,
+        description: data.description,
+      }));
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(componentList, null, 2),
+          },
+        ],
+      };
+    }
+
+    case "get_component_docs": {
+      const componentName = args?.component as string;
+      const component = components[componentName];
+
+      if (!component) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Component "${componentName}" not found. Available components: ${Object.keys(components).join(", ")}`,
+            },
+          ],
+        };
+      }
+
+      const docs = `# ${componentName}
+
+${component.description}
+
+## Category
+${component.category}
+
+## Props
+${component.props}
+
+## Usage Examples
+${component.usage}
+
+## Features
+${component.features.map((f: string) => `- ${f}`).join("\n")}
+
+## Best Practices
+${component.bestPractices.map((bp: string) => `- ${bp}`).join("\n")}
+`;
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: docs,
+          },
+        ],
+      };
+    }
+
+    case "get_component_example": {
+      const componentName = args?.component as string;
+      const exampleType = (args?.example_type as string) || "basic";
+      const component = components[componentName];
+
+      if (!component) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Component "${componentName}" not found.`,
+            },
+          ],
+        };
+      }
+
+      const example = component.examples[exampleType] || component.examples.basic;
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: example,
+          },
+        ],
+      };
+    }
+
+    case "get_cli_usage": {
+      const commandName = args?.command as string;
+
+      if (commandName) {
+        const command = cliCommands[commandName];
+        if (!command) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Command "${commandName}" not found. Available commands: ${Object.keys(cliCommands).join(", ")}`,
+              },
+            ],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# ${commandName}
+
+${command.description}
+
+## Usage
+\`\`\`bash
+${command.usage}
+\`\`\`
+
+## Options
+${command.options.map((opt: any) => `- \`${opt.flag}\`: ${opt.description}`).join("\n")}
+
+## Examples
+${command.examples.map((ex: string) => `\`\`\`bash\n${ex}\n\`\`\``).join("\n\n")}
+`,
+            },
+          ],
+        };
+      }
+
+      // Return all commands
+      const allCommands = Object.entries(cliCommands).map(([name, data]) => ({
+        name,
+        description: data.description,
+        usage: data.usage,
+      }));
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(allCommands, null, 2),
+          },
+        ],
+      };
+    }
+
+    case "search_components": {
+      const query = (args?.query as string)?.toLowerCase() || "";
+      const category = args?.category as string;
+
+      let results = Object.entries(components);
+
+      if (category) {
+        results = results.filter(([_, data]) => data.category === category);
+      }
+
+      if (query) {
+        results = results.filter(([name, data]) =>
+          name.toLowerCase().includes(query) ||
+          data.description.toLowerCase().includes(query) ||
+          data.features.some((f: string) => f.toLowerCase().includes(query))
+        );
+      }
+
+      const resultList = results.map(([name, data]) => ({
+        name,
+        category: data.category,
+        description: data.description,
+      }));
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(resultList, null, 2),
+          },
+        ],
+      };
+    }
+
+    case "search_icons": {
+      const query = (args?.query as string)?.toLowerCase() || "";
+      const limit = (args?.limit as number) || 20;
+
+      if (!query) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Please provide a search query.",
+            },
+          ],
+        };
+      }
+
+      // Filter icons that match the query
+      const matchingIcons = iconsData.icons.filter((icon: string) =>
+        icon.toLowerCase().includes(query)
+      );
+
+      // Limit results
+      const limitedResults = matchingIcons.slice(0, limit);
+
+      const result = {
+        query,
+        total: iconsData.total,
+        matches: matchingIcons.length,
+        returned: limitedResults.length,
+        icons: limitedResults,
+      };
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    default:
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Unknown tool: ${name}`,
+          },
+        ],
+      };
+  }
+});
+
+// List available resources
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "idealyst://framework/getting-started",
+        name: "Getting Started with Idealyst",
+        description: "Complete guide to setting up and using the Idealyst framework",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://framework/components-overview",
+        name: "Components Overview",
+        description: "Overview of all available Idealyst components organized by category",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://framework/theming",
+        name: "Theming Guide",
+        description: "Guide to customizing themes in Idealyst",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://framework/cli",
+        name: "CLI Reference",
+        description: "Complete reference for the Idealyst CLI",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://navigation/overview",
+        name: "Navigation System Overview",
+        description: "Overview of the Idealyst navigation system for cross-platform routing",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://navigation/route-configuration",
+        name: "Route Configuration",
+        description: "Learn how to define and structure routes in Idealyst",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://navigation/navigator-types",
+        name: "Navigator Types",
+        description: "Guide to stack, tab, drawer, and modal navigators",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://navigation/custom-layouts",
+        name: "Custom Layouts (Web)",
+        description: "Creating custom layouts with headers and sidebars for web applications",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://navigation/use-navigator",
+        name: "useNavigator Hook",
+        description: "Complete reference for the useNavigator hook API",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "idealyst://icons/reference",
+        name: "Icon Reference Guide",
+        description: "Complete guide to Material Design Icons with 7,447 available icons, common icons by category, and usage examples",
+        mimeType: "text/markdown",
+      },
+    ],
+  };
+});
+
+// Handle resource reads
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  // Check framework guides first, then navigation guides, then icon guide
+  let guide = frameworkGuides[uri] || navigationGuides[uri];
+
+  // Handle icon reference
+  if (uri === "idealyst://icons/reference") {
+    guide = iconGuide;
+  }
+
+  if (!guide) {
+    throw new Error(`Resource not found: ${uri}`);
+  }
+
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/markdown",
+        text: guide,
+      },
+    ],
+  };
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Idealyst MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/test-client.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test client to verify the MCP server is working
+ */
+
+import { spawn } from 'child_process';
+
+// Start the MCP server
+const server = spawn('node', ['./dist/index.js'], {
+  stdio: ['pipe', 'pipe', 'pipe']
+});
+
+let responseData = '';
+
+server.stdout.on('data', (data) => {
+  responseData += data.toString();
+
+  // Try to parse JSON responses
+  const lines = responseData.split('\n');
+  lines.forEach(line => {
+    if (line.trim() && line.includes('{')) {
+      try {
+        const json = JSON.parse(line);
+        console.log('Response:', JSON.stringify(json, null, 2));
+      } catch (e) {
+        // Not JSON, probably stderr message
+      }
+    }
+  });
+});
+
+server.stderr.on('data', (data) => {
+  console.error('Server:', data.toString().trim());
+});
+
+// Wait a moment for server to start
+setTimeout(() => {
+  console.log('\n📋 Testing list_tools...\n');
+
+  // Send a request to list tools
+  const request = {
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'tools/list',
+    params: {}
+  };
+
+  server.stdin.write(JSON.stringify(request) + '\n');
+
+  // Wait for response
+  setTimeout(() => {
+    console.log('\n🔍 Testing get_component_docs for Button...\n');
+
+    const toolRequest = {
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'tools/call',
+      params: {
+        name: 'get_component_docs',
+        arguments: {
+          component: 'Button'
+        }
+      }
+    };
+
+    server.stdin.write(JSON.stringify(toolRequest) + '\n');
+
+    // Close after a moment
+    setTimeout(() => {
+      console.log('\n✅ Test complete!\n');
+      server.kill();
+      process.exit(0);
+    }, 2000);
+  }, 2000);
+}, 1000);
+
+// Handle errors
+server.on('error', (error) => {
+  console.error('Error:', error);
+  process.exit(1);
+});
+
+server.on('close', (code) => {
+  console.log(`Server process exited with code ${code}`);
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}