lime-ui-x-mcp 1.0.0

package/index.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { cwd, exit } from 'node:process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import {
+  scanComponents,
+  getReadmeContent,
+  searchComponents,
+  categorizeComponents,
+  setProjectDir,
+  getProjectDir,
+} from './src/loader.js';
+
+const projectDir = cwd();
+setProjectDir(projectDir);
+
+const uniModulesPath = resolve(projectDir, 'uni_modules');
+if (!existsSync(uniModulesPath)) {
+  console.error(`[lime-ui-x-mcp] Warning: uni_modules not found at ${uniModulesPath}`);
+  console.error(`[lime-ui-x-mcp] Make sure you're running this command inside a uni-app project with lime-ui-x installed.`);
+}
+
+const server = new Server(
+  {
+    name: 'lime-ui-x-mcp',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      resources: {},
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const categorized = categorizeComponents();
+
+  const resources = [];
+
+  resources.push({
+    uri: 'lime-ui://components',
+    name: 'LimeUI-X 组件总览',
+    description: 'LimeUI-X 组件库所有组件按分类的完整列表',
+    mimeType: 'application/json',
+  });
+
+  for (const comp of categorized.flatMap(c => c.components)) {
+    if (comp.hasReadme) {
+      resources.push({
+        uri: `lime-ui://components/${comp.pluginName}/readme`,
+        name: `${comp.name} 文档`,
+        description: `${comp.name} (${comp.componentTag}) 的完整文档`,
+        mimeType: 'text/markdown',
+      });
+    }
+
+    resources.push({
+      uri: `lime-ui://components/${comp.pluginName}/meta`,
+      name: `${comp.name} 元数据`,
+      description: `${comp.name} 的 front-matter 元数据`,
+      mimeType: 'application/json',
+    });
+  }
+
+  return { resources };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const uri = request.params.uri;
+
+  if (uri === 'lime-ui://components') {
+    const categorized = categorizeComponents();
+    return {
+      contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(categorized, null, 2) }],
+    };
+  }
+
+  const readmeMatch = uri.match(/^lime-ui:\/\/components\/(lime-[^/]+)\/readme$/);
+  if (readmeMatch) {
+    const content = getReadmeContent(readmeMatch[1]);
+    if (content) return { contents: [{ uri, mimeType: 'text/markdown', text: content }] };
+    throw new Error(`Component readme not found: ${readmeMatch[1]}`);
+  }
+
+  const metaMatch = uri.match(/^lime-ui:\/\/components\/(lime-[^/]+)\/meta$/);
+  if (metaMatch) {
+    const { components } = scanComponents();
+    const comp = components.find(c => c.pluginName === metaMatch[1]);
+    if (comp) {
+      return {
+        contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(comp, null, 2) }],
+      };
+    }
+    throw new Error(`Component not found: ${metaMatch[1]}`);
+  }
+
+  throw new Error(`Resource not found: ${uri}`);
+});
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'list_components',
+      description: '列出 LimeUI-X 组件库所有组件，按分类分组（基础组件、导航组件、表单组件、反馈组件、展示组件、业务组件、原生组件、API 插件、SDK 工具库）',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          category: {
+            type: 'string',
+            description: '按分类筛选：basic(基础), nav(导航), form(表单), feedback(反馈), display(展示), business(业务), native(原生), api(API插件), sdk(工具库)',
+            enum: ['basic', 'nav', 'form', 'feedback', 'display', 'business', 'native', 'api', 'sdk'],
+          },
+        },
+      },
+    },
+    {
+      name: 'get_component_doc',
+      description: '获取指定组件的完整文档（readme.md 内容）',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          pluginName: { type: 'string', description: '插件名称，如 lime-button、lime-dialog、lime-form' },
+        },
+        required: ['pluginName'],
+      },
+    },
+    {
+      name: 'find_components',
+      description: '按关键字搜索组件（名称、描述、标签、分类等）',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: '搜索关键字，如 "按钮"、"表单"、"弹窗"' },
+          limit: { type: 'number', description: '返回结果数量上限（默认 20）' },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'get_component_dependencies',
+      description: '获取指定组件及其所有依赖的完整依赖链',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          pluginName: { type: 'string', description: '插件名称，如 lime-button、lime-dialog' },
+        },
+        required: ['pluginName'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  switch (name) {
+    case 'list_components': {
+      const categorized = categorizeComponents();
+      const category = args?.category;
+      const result = category ? categorized.filter(c => c.id === category) : categorized;
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            totalComponents: result.reduce((sum, cat) => sum + cat.components.length, 0),
+            categories: result.map(cat => ({
+              id: cat.id,
+              name: cat.name,
+              count: cat.components.length,
+              components: cat.components.map(comp => ({
+                id: comp.id,
+                name: comp.name,
+                description: comp.description,
+                componentTag: comp.componentTag,
+                pluginName: comp.pluginName,
+                hasReadme: comp.hasReadme,
+                version: comp.version,
+              })),
+            })),
+          }, null, 2),
+        }],
+      };
+    }
+
+    case 'get_component_doc': {
+      const pluginName = args?.pluginName;
+      if (!pluginName) throw new Error('pluginName is required');
+
+      const content = getReadmeContent(pluginName);
+      if (!content) throw new Error(`Component not found or no readme available: ${pluginName}`);
+
+      return { content: [{ type: 'text', text: content }] };
+    }
+
+    case 'find_components': {
+      const query = args?.query;
+      if (!query) throw new Error('query is required');
+
+      const results = searchComponents(query);
+      const limited = results.slice(0, args?.limit || 20);
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            query,
+            total: results.length,
+            returned: limited.length,
+            components: limited.map(comp => ({
+              id: comp.id,
+              name: comp.name,
+              description: comp.description,
+              componentTag: comp.componentTag,
+              category: comp.category,
+              tags: comp.tags,
+              pluginName: comp.pluginName,
+              version: comp.version,
+            })),
+          }, null, 2),
+        }],
+      };
+    }
+
+    case 'get_component_dependencies': {
+      const pluginName = args?.pluginName;
+      if (!pluginName) throw new Error('pluginName is required');
+
+      const { components } = scanComponents();
+      const comp = components.find(c => c.pluginName === pluginName);
+      if (!comp) throw new Error(`Component not found: ${pluginName}`);
+
+      function resolveDepChain(depNames, visited = new Set()) {
+        const chain = [];
+        for (const dep of depNames) {
+          if (visited.has(dep)) continue;
+          visited.add(dep);
+          const depComp = components.find(c => c.pluginName === dep);
+          chain.push(depComp
+            ? { pluginName: depComp.pluginName, name: depComp.name, description: depComp.description, componentTag: depComp.componentTag, version: depComp.version }
+            : { pluginName: dep, name: dep, isExternal: true }
+          );
+          if (depComp?.dependencies.length) {
+            chain.push(...resolveDepChain(depComp.dependencies, visited));
+          }
+        }
+        return chain;
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            component: { pluginName: comp.pluginName, name: comp.name, componentTag: comp.componentTag },
+            directDependencies: comp.dependencies,
+            dependencyChain: resolveDepChain(comp.dependencies),
+          }, null, 2),
+        }],
+      };
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+});
+
+async function main() {
+  try {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[lime-ui-x-mcp] Server started | project dir: ${getProjectDir()}`);
+  } catch (err) {
+    console.error('[lime-ui-x-mcp] Failed to start:', err);
+    exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "lime-ui-x-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for LimeUI-X component library - provides component discovery, documentation query, and dependency analysis for AI assistants",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "lime-ui-x-mcp": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "limeui",
+    "uni-app",
+    "uni-app-x",
+    "ui-components",
+    "troe",
+    "trae"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "gray-matter": "^4.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/loader.js

@@ -0,0 +1,205 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { cwd } from 'node:process';
+import parseFrontMatter from 'gray-matter';
+
+let _projectDir = cwd();
+
+const LIME_PREFIX = 'lime-';
+
+export function setProjectDir(dir) {
+  _projectDir = dir;
+}
+
+export function getProjectDir() {
+  return _projectDir;
+}
+
+function getUniModulesPath() {
+  return resolve(_projectDir, 'uni_modules');
+}
+
+const COMPONENT_CATEGORIES = [
+  { id: 'basic', name: '基础组件', dir: 'basic', order: 1 },
+  { id: 'nav', name: '导航组件', dir: 'nav', order: 2 },
+  { id: 'form', name: '表单组件', dir: 'form', order: 3 },
+  { id: 'feedback', name: '反馈组件', dir: 'feedback', order: 4 },
+  { id: 'display', name: '展示组件', dir: 'display', order: 5 },
+  { id: 'business', name: '业务组件', dir: 'business', order: 6 },
+  { id: 'native', name: '原生组件', dir: 'native', order: 7 },
+  { id: 'api', name: 'API 插件', dir: 'api', order: 8 },
+  { id: 'sdk', name: 'SDK 工具库', dir: 'sdk', order: 9 },
+];
+
+function isLimePlugin(dirName) {
+  return dirName.startsWith(LIME_PREFIX);
+}
+
+function getComponentName(pluginName) {
+  return pluginName.replace(LIME_PREFIX, '');
+}
+
+function findReadme(dirPath) {
+  for (const name of ['readme.md', 'README.md', 'Readme.md']) {
+    const filePath = join(dirPath, name);
+    if (existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+
+function findIndexFile(dirPath) {
+  for (const name of ['index.ts', 'index.uts', 'index.uvue', 'index.js']) {
+    const filePath = join(dirPath, name);
+    if (existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+
+function findChangelog(dirPath) {
+  const filePath = join(dirPath, 'changelog.md');
+  return existsSync(filePath) ? filePath : null;
+}
+
+function getPackageInfo(dirPath) {
+  const pkgPath = join(dirPath, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function scanComponents() {
+  const components = [];
+  const uniModulesPath = getUniModulesPath();
+
+  if (!existsSync(uniModulesPath)) {
+    return { components, errors: [{ message: `uni_modules not found at ${uniModulesPath}. Make sure you're running this command inside a uni-app project that has lime-ui-x installed.` }] };
+  }
+
+  const entries = readdirSync(uniModulesPath);
+
+  for (const entry of entries) {
+    if (!isLimePlugin(entry)) continue;
+
+    const dirPath = join(uniModulesPath, entry);
+    if (!statSync(dirPath).isDirectory()) continue;
+
+    try {
+      const componentName = getComponentName(entry);
+
+      let frontMatter = { data: {}, content: null };
+      const readmePath = findReadme(dirPath);
+      if (readmePath) {
+        const raw = readFileSync(readmePath, 'utf-8');
+        const parsed = parseFrontMatter(raw);
+        frontMatter = { data: parsed.data || {}, content: parsed.content || raw };
+      }
+
+      const pkgInfo = getPackageInfo(dirPath);
+
+      components.push({
+        id: componentName,
+        pluginName: entry,
+        name: frontMatter.data.name || pkgInfo?.name || componentName,
+        description: frontMatter.data.description || pkgInfo?.description || '',
+        componentTag: frontMatter.data.componentTag || `l-${componentName}`,
+        category: frontMatter.data.category || null,
+        tags: frontMatter.data.tags || [],
+        dependencies: frontMatter.data.dependencies || [],
+        version: pkgInfo?.version || null,
+        hasReadme: !!readmePath,
+        hasIndexFile: !!findIndexFile(dirPath),
+        hasChangelog: !!findChangelog(dirPath),
+      });
+    } catch {
+      // silently skip erroneous entries
+    }
+  }
+
+  components.sort((a, b) => a.pluginName.localeCompare(b.pluginName));
+  return { components, errors: [] };
+}
+
+export function getReadmeContent(pluginName) {
+  const dirPath = join(getUniModulesPath(), pluginName);
+  if (!existsSync(dirPath)) return null;
+  const readmePath = findReadme(dirPath);
+  if (!readmePath) return null;
+  try {
+    return readFileSync(readmePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+export function getChangelogContent(pluginName) {
+  const dirPath = join(getUniModulesPath(), pluginName);
+  if (!existsSync(dirPath)) return null;
+  const changelogPath = findChangelog(dirPath);
+  if (!changelogPath) return null;
+  try {
+    return readFileSync(changelogPath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+export function getPackageJson(pluginName) {
+  return getPackageInfo(join(getUniModulesPath(), pluginName));
+}
+
+export function searchComponents(query) {
+  const { components } = scanComponents();
+  const q = query.toLowerCase();
+
+  return components.filter(c =>
+    c.name.toLowerCase().includes(q) ||
+    c.id.toLowerCase().includes(q) ||
+    c.description.toLowerCase().includes(q) ||
+    c.componentTag?.toLowerCase().includes(q) ||
+    (c.tags && c.tags.some(t => t.toLowerCase().includes(q))) ||
+    (c.category && c.category.toLowerCase().includes(q))
+  );
+}
+
+export function categorizeComponents() {
+  const { components } = scanComponents();
+
+  const categorized = COMPONENT_CATEGORIES.map(cat => ({
+    ...cat,
+    components: [],
+  }));
+
+  const categoryMap = {
+    '基础组件': 'basic',
+    '导航组件': 'nav',
+    '表单组件': 'form',
+    '反馈组件': 'feedback',
+    '展示组件': 'display',
+    '业务组件': 'business',
+    '原生组件': 'native',
+    'API 插件': 'api',
+    'SDK 工具库': 'sdk',
+  };
+
+  for (const comp of components) {
+    const catId = categoryMap[comp.category] || 'other';
+    const category = categorized.find(c => c.id === catId);
+    if (category) {
+      category.components.push(comp);
+    } else {
+      let other = categorized.find(c => c.id === 'other');
+      if (!other) {
+        other = { id: 'other', name: '其他', dir: 'other', order: 99, components: [] };
+        categorized.push(other);
+      }
+      other.components.push(comp);
+    }
+  }
+
+  return categorized.filter(c => c.components.length > 0);
+}
+
+export { COMPONENT_CATEGORIES };