@morya-ui/mcp 0.1.1

package/dist/__tests__/resources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/resources.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { createToolHandlers } from '../tools.js';
+import { countCatalogResourceTemplates, countCatalogResources } from '../resources.js';
+describe('@morya-ui/mcp resources', () => {
+    const handlers = createToolHandlers();
+    it('registers static resources and resource templates', () => {
+        expect(countCatalogResources(handlers.catalog)).toBeGreaterThan(100);
+        expect(countCatalogResourceTemplates()).toBe(3);
+    });
+});

package/dist/__tests__/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tools.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+import { createToolHandlers } from '../tools.js';
+function read(result) {
+    return JSON.parse(result.content[0].text);
+}
+describe('@morya-ui/mcp handlers', () => {
+    const handlers = createToolHandlers();
+    it('returns complete pagination metadata for component lists', () => {
+        const result = read(handlers.list({ kind: 'components', limit: 5, offset: 5 }));
+        expect(result.total).toBeGreaterThan(5);
+        expect(result.count).toBe(5);
+        expect(result.offset).toBe(5);
+        expect(result.limit).toBe(5);
+        expect(result.has_more).toBe(true);
+        expect(result.next_offset).toBe(10);
+    });
+    it('paginates categories instead of returning the complete collection', () => {
+        const result = read(handlers.list({ kind: 'categories', limit: 1, offset: 1 }));
+        expect(result.items).toHaveLength(1);
+        expect(result.count).toBe(1);
+    });
+    it('resolves documented aliases when reading component API', () => {
+        const result = read(handlers.getComponent({ component: '数据表格', includeApi: true }));
+        expect(result.id).toBe('Table');
+        expect(result.exportName).toBe('MTable');
+    });
+    it('paginates component examples and reports API coverage', () => {
+        const first = read(handlers.getComponent({ component: 'Table', detail: 'full', examplesLimit: 1 }));
+        expect(first.examples).toHaveLength(1);
+        expect(first.exampleCount).toBeGreaterThan(1);
+        expect(first.examplesOffset).toBe(0);
+        expect(first.examplesLimit).toBe(1);
+        expect(first.hasMoreExamples).toBe(true);
+        expect(first.nextExamplesOffset).toBe(1);
+        expect(first.apiCoverage.props.total).toBeGreaterThan(0);
+        const second = read(handlers.getComponent({ component: 'Table', detail: 'full', examplesLimit: 1, examplesOffset: 1 }));
+        expect(second.examplesOffset).toBe(1);
+        expect(second.examples[0]?.id).not.toBe(first.examples[0]?.id);
+    });
+    it('reports unknown props without rejecting valid props', () => {
+        const result = read(handlers.validateUsage({
+            component: 'Button',
+            code: '<MButton label="Save" severity="danger" foo="bar" />',
+        }));
+        expect(result.ok).toBe(false);
+        expect(result.issues).toEqual([
+            expect.objectContaining({ type: 'unknown-prop' }),
+        ]);
+        expect(result.issues[0].message).toContain('foo');
+    });
+    it('flags icon-only buttons that put icons in the default slot', () => {
+        const result = read(handlers.validateUsage({
+            component: 'Button',
+            code: '<MButton icon-only aria-label="Add"><Plus /></MButton>',
+        }));
+        expect(result.ok).toBe(false);
+        expect(result.issues).toEqual(expect.arrayContaining([
+            expect.objectContaining({ type: 'icon-only-missing-icon' }),
+            expect.objectContaining({ type: 'icon-only-default-slot' }),
+        ]));
+    });
+    it('accepts icon-only buttons with icon prop', () => {
+        const result = read(handlers.validateUsage({
+            component: 'Button',
+            code: '<MButton icon="plus" icon-only aria-label="Add" />',
+        }));
+        expect(result.ok).toBe(true);
+    });
+    it('recommends a page pattern from product intent', () => {
+        const result = read(handlers.recommendPage({
+            intent: '油井管理列表',
+            pageType: 'list',
+            features: ['筛选', '分页'],
+        }));
+        expect(result.matchedPattern).toBe('admin-list');
+    });
+    it('returns a dashboard scaffold when includeScaffold is true', () => {
+        const result = read(handlers.recommendPage({
+            intent: '生产监控仪表盘',
+            pageType: 'dashboard',
+            includeScaffold: true,
+        }));
+        expect(result.matchedPattern).toBe('dashboard');
+        expect(result.scaffold.files.component).toContain('MGrid');
+        expect(result.scaffold.files.component).toContain('MSkeleton');
+    });
+    it('lists component decision guides when query is omitted', () => {
+        const result = read(handlers.recommendComponent({ limit: 5 }));
+        expect(result.kind).toBe('decisions');
+        expect(result.items.length).toBeGreaterThan(0);
+        expect(result.items[0]?.id).toBeTruthy();
+    });
+    it('reads a decision guide by id', () => {
+        const result = read(handlers.recommendComponent({ decision: 'overlay-choice' }));
+        expect(result.id).toBe('overlay-choice');
+        expect(result.options.some((option) => option.component === 'Drawer')).toBe(true);
+    });
+    it('exposes catalog health in version metadata', () => {
+        const result = read(handlers.version());
+        expect(result.health.ok).toBe(true);
+        expect(result.health.patternReferences).toEqual([]);
+        expect(result.counts.patterns).toBeGreaterThan(0);
+        expect(result.counts.decisions).toBeGreaterThan(0);
+        expect(result.counts.resources).toBeGreaterThan(100);
+        expect(result.counts.resourceTemplates).toBe(3);
+        expect(result.tools).toHaveLength(13);
+        expect(result.tools).not.toContain('create_page');
+    });
+});

package/dist/catalog.d.ts

@@ -0,0 +1,97 @@
+export type Locale = 'zh-CN' | 'en-US';
+export interface ApiProp {
+    name: string;
+    type: string;
+    default?: string;
+    description: string;
+}
+export interface ApiEvent {
+    name: string;
+    payload?: string;
+    description: string;
+}
+export interface ApiSlot {
+    name: string;
+    description: string;
+}
+export interface ApiMethod {
+    name: string;
+    type?: string;
+    description: string;
+}
+export interface ExampleItem {
+    id: string;
+    section: string;
+    sectionId: string;
+    lang: string;
+    preview: boolean;
+    code: string;
+    locale: Locale;
+}
+export interface DocSection {
+    id: string;
+    title: string;
+    body: string;
+}
+export interface ComponentRecord {
+    id: string;
+    name: string;
+    exportName: string;
+    category: string;
+    description: string;
+    descriptionEn: string;
+    import: string;
+    props: ApiProp[];
+    events: ApiEvent[];
+    slots: ApiSlot[];
+    methods: ApiMethod[];
+    examples: ExampleItem[];
+    locales: Partial<Record<Locale, {
+        title: string;
+        description: string;
+        sections: DocSection[];
+        markdown: string;
+    }>>;
+}
+export interface GuideRecord {
+    id: string;
+    title: string;
+    titleEn: string;
+    description: string;
+    descriptionEn: string;
+    order: number;
+    locales: Partial<Record<Locale, {
+        title: string;
+        description: string;
+        markdown: string;
+        sections: DocSection[];
+    }>>;
+}
+export interface Catalog {
+    generatedAt: string;
+    library: {
+        name: string;
+        version: string;
+    };
+    mcp: {
+        name: string;
+        version: string;
+    };
+    components: ComponentRecord[];
+    guides: GuideRecord[];
+}
+/** Common product-language names mapped to the library's canonical component ids. */
+export declare const componentAliases: Record<string, string>;
+export declare function loadCatalog(): Catalog;
+export declare function resolveLocale(mode?: string): Locale;
+export declare function normalizeName(input: string): string;
+export declare function findComponent(catalog: Catalog, name: string): ComponentRecord | undefined;
+export declare function findGuide(catalog: Catalog, name: string): GuideRecord | undefined;
+export declare function toKebab(name: string): string;
+export declare function textResult(payload: unknown): {
+    structuredContent?: Record<string, unknown> | undefined;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/dist/catalog.js

@@ -0,0 +1,75 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Common product-language names mapped to the library's canonical component ids. */
+export const componentAliases = {
+    datatable: 'Table',
+    'data-table': 'Table',
+    'data table': 'Table',
+    '数据表': 'Table',
+    '数据表格': 'Table',
+    '数据列表': 'Table',
+    tableview: 'Table',
+    formitem: 'Form',
+    'form-item': 'Form',
+    '表单项': 'Form',
+    confirm: 'ConfirmDialog',
+    'confirm-dialog': 'ConfirmDialog',
+    '确认框': 'ConfirmDialog',
+    '确认弹窗': 'ConfirmDialog',
+    pagination: 'Pagination',
+    pager: 'Pagination',
+    分页器: 'Pagination',
+    layoutheader: 'Layout',
+    layoutsider: 'Layout',
+    layoutcontent: 'Layout',
+    layoutfooter: 'Layout',
+    griditem: 'Grid',
+};
+const here = dirname(fileURLToPath(import.meta.url));
+export function loadCatalog() {
+    const path = join(here, '../data/catalog.json');
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+export function resolveLocale(mode) {
+    const value = (mode || '').toLowerCase();
+    if (value === 'en' || value === 'en-us' || value === 'english')
+        return 'en-US';
+    return 'zh-CN';
+}
+export function normalizeName(input) {
+    return input.trim().toLowerCase().replace(/^wk/, '').replace(/[-_\s]/g, '');
+}
+export function findComponent(catalog, name) {
+    const rawKey = name.trim().toLowerCase();
+    const alias = componentAliases[rawKey] || componentAliases[normalizeName(name)];
+    const key = normalizeName(alias || name);
+    return catalog.components.find((item) => {
+        return (normalizeName(item.id) === key ||
+            normalizeName(item.name) === key ||
+            normalizeName(item.exportName) === key);
+    });
+}
+export function findGuide(catalog, name) {
+    const key = normalizeName(name);
+    return catalog.guides.find((item) => {
+        return (normalizeName(item.id) === key ||
+            normalizeName(item.title) === key ||
+            normalizeName(item.titleEn || '') === key);
+    });
+}
+export function toKebab(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/_/g, '-')
+        .toLowerCase();
+}
+export function textResult(payload) {
+    const text = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+    return {
+        content: [{ type: 'text', text }],
+        ...(payload !== null && typeof payload === 'object'
+            ? { structuredContent: payload }
+            : {}),
+    };
+}

package/dist/decisions.d.ts

@@ -0,0 +1,19 @@
+export interface ComponentDecisionOption {
+    component: string;
+    when: string[];
+    whenEn: string[];
+    avoidWhen: string[];
+    avoidWhenEn: string[];
+}
+export interface ComponentDecision {
+    id: string;
+    title: string;
+    titleEn: string;
+    question: string;
+    questionEn: string;
+    keywords: string[];
+    options: ComponentDecisionOption[];
+}
+export declare const componentDecisions: ComponentDecision[];
+export declare function findDecision(name: string): ComponentDecision | undefined;
+export declare function scoreDecision(decision: ComponentDecision, query: string): number;

package/dist/decisions.js

@@ -0,0 +1,155 @@
+export const componentDecisions = [
+    {
+        id: 'overlay-choice',
+        title: '如何选择浮层组件',
+        titleEn: 'Choosing an overlay component',
+        question: '这是确认、短任务、上下文操作，还是需要保留页面上下文的编辑？',
+        questionEn: 'Is this a confirmation, short task, contextual action, or an edit that needs page context?',
+        keywords: ['弹窗', '浮层', '模态', '侧栏', '确认', '编辑', 'dialog', 'drawer', 'popover', 'tooltip', 'modal', 'side editing', 'side panel', 'context'],
+        options: [
+            {
+                component: 'Dialog',
+                when: ['需要用户聚焦完成一项短到中等任务', '需要确认危险操作', '内容不适合直接放在页面流中'],
+                whenEn: ['The user should focus on a short or medium-sized task', 'A destructive action needs confirmation', 'Content should not interrupt the page flow'],
+                avoidWhen: ['内容接近完整页面', '用户需要持续查看底层页面上下文'],
+                avoidWhenEn: ['The content is effectively a full page', 'The user must continuously reference the underlying page'],
+            },
+            {
+                component: 'Drawer',
+                when: ['需要侧边编辑或查看详情', '需要保留底层列表或工作区上下文', '内容比普通确认框更长'],
+                whenEn: ['Side editing or detail inspection is needed', 'The underlying list or workspace context should remain visible', 'The content is longer than a normal confirmation'],
+                avoidWhen: ['只是简单确认', '操作必须阻塞用户直到明确确认'],
+                avoidWhenEn: ['It is only a simple confirmation', 'The action must block the user until an explicit decision'],
+            },
+            {
+                component: 'Popover',
+                when: ['轻量上下文操作或补充信息', '不需要阻塞页面', '内容与触发元素强相关'],
+                whenEn: ['Lightweight contextual actions or supporting information', 'The page should not be blocked', 'The content is tightly related to the trigger'],
+                avoidWhen: ['需要复杂表单或危险操作确认'],
+                avoidWhenEn: ['A complex form or destructive confirmation is required'],
+            },
+            {
+                component: 'Tooltip',
+                when: ['只展示简短说明', '用户悬停或聚焦控件时需要补充提示'],
+                whenEn: ['Only a short explanation is needed', 'Extra help is needed on hover or focus'],
+                avoidWhen: ['信息是必需内容', '需要放置交互控件'],
+                avoidWhenEn: ['The information is essential content', 'Interactive controls need to be placed inside'],
+            },
+        ],
+    },
+    {
+        id: 'data-display-choice',
+        title: '如何选择数据展示组件',
+        titleEn: 'Choosing a data display component',
+        question: '用户需要比较行列数据、浏览卡片，还是查看树状层级？',
+        questionEn: 'Does the user need to compare rows and columns, browse cards, or inspect a hierarchy?',
+        keywords: ['表格', '列表', '卡片', '树', '层级', '数据展示', 'table', 'list', 'tree', 'dataview'],
+        options: [
+            {
+                component: 'Table',
+                when: ['数据有稳定列结构', '用户需要排序、筛选、批量或行操作', '需要高密度比较多条记录'],
+                whenEn: ['Data has a stable column structure', 'Users need sorting, filtering, bulk actions, or row actions', 'Many records must be compared at high density'],
+                avoidWhen: ['每条数据结构差异很大', '移动端无法承载横向列结构'],
+                avoidWhenEn: ['Each record has a very different structure', 'A horizontal column layout cannot work on mobile'],
+            },
+            {
+                component: 'DataView',
+                when: ['数据适合卡片或自定义列表项', '视觉浏览比列对齐更重要', '同一数据需要切换多种展示布局'],
+                whenEn: ['Data fits cards or custom list items', 'Visual browsing matters more than column alignment', 'The same data needs multiple presentation layouts'],
+                avoidWhen: ['用户必须精确比较字段', '需要复杂列级排序或固定列'],
+                avoidWhenEn: ['Users must compare fields precisely', 'Complex column sorting or frozen columns are required'],
+            },
+            {
+                component: 'TreeTable',
+                when: ['数据同时具有表格列和父子层级', '用户需要展开、收起层级节点'],
+                whenEn: ['Data has both table columns and parent-child hierarchy', 'Users need to expand and collapse hierarchy nodes'],
+                avoidWhen: ['数据没有真实层级关系', '普通 Table 已能表达关系'],
+                avoidWhenEn: ['There is no real hierarchy', 'A regular Table already expresses the relationship'],
+            },
+            {
+                component: 'Tree',
+                when: ['主要任务是浏览或选择层级节点', '节点信息不需要多列比较'],
+                whenEn: ['The main task is browsing or selecting hierarchy nodes', 'Nodes do not need multi-column comparison'],
+                avoidWhen: ['每行需要展示多个可比较字段'],
+                avoidWhenEn: ['Each row needs several comparable fields'],
+            },
+        ],
+    },
+    {
+        id: 'selection-choice',
+        title: '如何选择选择器',
+        titleEn: 'Choosing a selection control',
+        question: '选项是平面少量、层级结构、多选标签，还是需要输入搜索？',
+        questionEn: 'Are options a small flat set, a hierarchy, multi-select tags, or searchable input?',
+        keywords: ['选择', '下拉', '多选', '树选择', '搜索选择', 'select', 'treeselect', 'autocomplete', 'dropdown'],
+        options: [
+            {
+                component: 'Select',
+                when: ['平面选项数量中等', '需要单选或多选', '表单字段需要明确选项集合'],
+                whenEn: ['The options are a medium-sized flat set', 'Single or multiple selection is needed', 'The form needs a defined option set'],
+                avoidWhen: ['选项有明显层级', '用户需要输入自由文本并搜索建议'],
+                avoidWhenEn: ['Options have a meaningful hierarchy', 'Users need free text with suggestions'],
+            },
+            {
+                component: 'TreeSelect',
+                when: ['选项有父子层级', '用户需要按组织、分类或资源树选择'],
+                whenEn: ['Options have parent-child hierarchy', 'Users select from organizations, categories, or resource trees'],
+                avoidWhen: ['选项只是简单平面枚举'],
+                avoidWhenEn: ['Options are a simple flat enum'],
+            },
+            {
+                component: 'AutoComplete',
+                when: ['用户需要输入关键词搜索建议', '候选项很多或来自远程接口', '输入值本身也有意义'],
+                whenEn: ['Users type keywords to search suggestions', 'There are many or remote candidates', 'The entered value is meaningful itself'],
+                avoidWhen: ['用户只能从固定枚举中选择', '不应该允许自由输入'],
+                avoidWhenEn: ['Users must choose from a fixed enum', 'Free input must not be allowed'],
+            },
+        ],
+    },
+    {
+        id: 'surface-choice',
+        title: '如何选择内容容器',
+        titleEn: 'Choosing a content surface',
+        question: '内容是否需要独立的视觉表面、标题和边界？',
+        questionEn: 'Does the content need an independent visual surface, heading, and boundary?',
+        keywords: ['容器', '卡片', '面板', '分组', '表面', 'card', 'panel', 'fieldset', 'surface'],
+        options: [
+            {
+                component: 'Card',
+                when: ['内容是页面中的独立业务区块', '需要标题、副标题、页脚或 hover 表面', '需要清晰的边界和内边距'],
+                whenEn: ['The content is an independent business section', 'A title, subtitle, footer, or hover surface is useful', 'A clear boundary and padding are needed'],
+                avoidWhen: ['页面已有过多嵌套表面', '内容只是简单分组'],
+                avoidWhenEn: ['The page already has too many nested surfaces', 'The content is only a simple group'],
+            },
+            {
+                component: 'Panel',
+                when: ['需要可折叠或强调一个较长内容区块', '内容具有明确的面板标题'],
+                whenEn: ['A collapsible or prominent longer section is needed', 'The content has a clear panel heading'],
+                avoidWhen: ['只需要普通内容容器', '标题和边界会增加视觉噪音'],
+                avoidWhenEn: ['A regular content container is enough', 'A heading and boundary would add visual noise'],
+            },
+            {
+                component: 'Fieldset',
+                when: ['需要语义化分组相关表单字段', '分组标题对理解表单很重要'],
+                whenEn: ['Related form fields need semantic grouping', 'A group title is important for understanding the form'],
+                avoidWhen: ['内容不是表单字段', '只是为了增加装饰边框'],
+                avoidWhenEn: ['The content is not form fields', 'The border would be purely decorative'],
+            },
+        ],
+    },
+];
+export function findDecision(name) {
+    const key = name.trim().toLowerCase().replace(/[-_\s]/g, '');
+    return componentDecisions.find((decision) => decision.id.replace(/[-_\s]/g, '') === key);
+}
+export function scoreDecision(decision, query) {
+    const normalized = query.toLowerCase().trim();
+    return decision.keywords.reduce((score, keyword) => {
+        const key = keyword.toLowerCase();
+        if (normalized === key)
+            return score + 100;
+        if (normalized.includes(key) || key.includes(normalized))
+            return score + 20;
+        return score;
+    }, 0);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,106 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { registerCatalogResources } from './resources.js';
+import { createToolHandlers } from './tools.js';
+const handlers = createToolHandlers();
+const server = new McpServer({
+    name: handlers.catalog.mcp.name,
+    version: handlers.catalog.mcp.version,
+});
+registerCatalogResources(server, handlers.catalog);
+function register(name, description, inputSchema, handler) {
+    return server.registerTool(name, {
+        title: description.split('.')[0],
+        description,
+        inputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, handler);
+}
+register('list', 'List morya-ui components, guides, examples, categories, or page patterns.', {
+    kind: z
+        .enum(['components', 'guides', 'examples', 'categories', 'patterns'])
+        .optional()
+        .describe('What to list. Defaults to components.'),
+    mode: z.string().optional().describe('Locale mode: zh / en. Defaults to zh.'),
+    limit: z.number().int().min(1).max(200).optional(),
+    offset: z.number().int().min(0).optional(),
+}, async (args) => handlers.list(args));
+register('search', 'Search components, guides, API text, examples, page patterns, and component decision guides.', {
+    query: z.string().min(1),
+    scope: z.enum(['all', 'components', 'guides', 'api', 'examples', 'patterns', 'decisions']).optional(),
+    mode: z.string().optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+    offset: z.number().int().min(0).optional(),
+}, async (args) => handlers.search(args));
+register('get_component', 'Read component docs and metadata from the generated catalog.', {
+    component: z.string().min(1).optional(),
+    components: z.array(z.string()).max(10).optional(),
+    mode: z.string().optional(),
+    detail: z.enum(['compact', 'full']).optional(),
+    includeApi: z.boolean().optional(),
+    includeExamples: z.boolean().optional(),
+    examplesLimit: z.number().int().min(1).max(100).optional(),
+    examplesOffset: z.number().int().min(0).optional(),
+    sections: z.array(z.string()).optional(),
+}, async (args) => handlers.getComponent(args));
+register('get_example', 'Return one source-backed example for a component.', {
+    component: z.string().min(1),
+    mode: z.string().optional(),
+    section: z.string().optional(),
+    variant: z.string().optional(),
+}, async (args) => handlers.getExample(args));
+register('get_guide', 'Read a guide (introduction, quick-start, theme, config, …).', {
+    guide: z.string().min(1),
+    mode: z.string().optional(),
+    section: z.string().optional(),
+    detail: z.enum(['compact', 'full']).optional(),
+}, async (args) => handlers.getGuide(args));
+register('get_setup', 'Return installation and setup guidance for consuming morya-ui.', {
+    environment: z.string().optional(),
+    mode: z.string().optional(),
+}, async (args) => handlers.getSetup(args));
+register('validate_usage', 'Validate component usage snippets against documented props/events.', {
+    component: z.string().min(1).optional(),
+    code: z.string().min(1).optional(),
+    mode: z.string().optional(),
+    usages: z
+        .array(z.object({
+        component: z.string().optional(),
+        code: z.string().optional(),
+    }))
+        .max(10)
+        .optional(),
+}, async (args) => handlers.validateUsage(args));
+register('list_patterns', 'List reusable page patterns for composing morya-ui components.', {
+    mode: z.string().optional(),
+    limit: z.number().int().min(1).max(200).optional(),
+    offset: z.number().int().min(0).optional(),
+}, async (args) => handlers.listPatterns(args));
+register('get_pattern', 'Read the structure, component composition, layout, and interaction rules for a page pattern.', {
+    pattern: z.string().min(1),
+    mode: z.string().optional(),
+}, async (args) => handlers.getPattern(args));
+register('recommend_page', 'Recommend a page pattern and component composition from product intent. Pass includeScaffold: true for starter Vue code.', {
+    intent: z.string().min(1),
+    pageType: z.string().optional(),
+    features: z.array(z.string()).max(20).optional(),
+    mode: z.string().optional(),
+    includeScaffold: z.boolean().optional(),
+}, async (args) => handlers.recommendPage(args));
+register('get_design_rules', 'Return design-token, semantic-action, accessibility, and composition rules for generated pages.', { mode: z.string().optional() }, async (args) => handlers.getDesignRules(args));
+register('recommend_component', 'List, read, or recommend component selection guides. Omit query/decision to list; pass decision only to read; pass query to recommend.', {
+    query: z.string().optional(),
+    decision: z.string().optional(),
+    mode: z.string().optional(),
+    limit: z.number().int().min(1).max(200).optional(),
+    offset: z.number().int().min(0).optional(),
+}, async (args) => handlers.recommendComponent(args));
+register('version', 'Return MCP package, library version, and catalog status.', {}, async () => handlers.version());
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/patterns.d.ts

@@ -0,0 +1,80 @@
+export interface PatternComponent {
+    component: string;
+    role: string;
+    reason?: string;
+    required?: boolean;
+}
+export interface PagePattern {
+    id: string;
+    title: string;
+    titleEn: string;
+    description: string;
+    descriptionEn: string;
+    keywords: string[];
+    goldenPage?: string;
+    components: PatternComponent[];
+    structure: string[];
+    layout: Record<string, string>;
+    styleRules: string[];
+    interactionRules: string[];
+    avoid: string[];
+}
+export declare const pagePatterns: PagePattern[];
+export declare const designRules: {
+    readonly tokens: {
+        readonly colors: readonly ["--m-color-primary", "--m-color-surface", "--m-color-text", "--m-color-border"];
+        readonly spacing: "--m-space-*";
+        readonly radius: "--m-radius-sm/md/lg";
+        readonly typography: "--m-font-size-xs/sm/md/lg";
+        readonly motion: "--m-motion-fast/normal";
+    };
+    readonly actions: {
+        readonly primary: {
+            readonly component: "MButton";
+            readonly props: readonly ["severity omitted or primary"];
+        };
+        readonly secondary: {
+            readonly component: "MButton";
+            readonly props: readonly ["severity=\"secondary\"", "outlined or text"];
+        };
+        readonly destructive: {
+            readonly component: "MButton";
+            readonly props: readonly ["severity=\"danger\""];
+            readonly requiresConfirmation: true;
+        };
+        readonly cancel: {
+            readonly component: "MButton";
+            readonly props: readonly ["severity=\"secondary\"", "text"];
+        };
+    };
+    readonly status: {
+        readonly component: "MTag";
+        readonly mapping: {
+            readonly active: "success";
+            readonly pending: "warn";
+            readonly disabled: "secondary";
+            readonly error: "danger";
+        };
+    };
+    readonly feedback: {
+        readonly default: "message";
+        readonly message: {
+            readonly api: "message.success | info | warn | error";
+            readonly when: readonly ["单行操作回执（已保存/已删除/已创建）", "轻量警告或错误", "复制成功等一句话反馈"];
+            readonly avoid: readonly ["不要写 summary/detail 结构"];
+        };
+        readonly toast: {
+            readonly api: "toast.success | info | warn | error({ summary, detail? })";
+            readonly when: readonly ["同时需要标题与补充说明", "后台任务/批量结果含统计", "异步通知感、角落堆叠"];
+            readonly avoid: readonly ["仅有单行文案时不要使用 Toast"];
+        };
+        readonly inlineMessage: {
+            readonly component: "MMessage";
+            readonly when: readonly ["登录/表单区常驻错误", "页面级错误需与表单同区展示"];
+        };
+        readonly doc: "docs/feedback-message-vs-toast.md";
+    };
+    readonly global: readonly ["优先使用组件库组件和 --m-* Token，不重复维护第二套色板", "操作反馈默认 message；无 detail 禁止用 toast.add({ summary only })", "图标按钮必须提供 aria-label 或 ariaLabel", "表单字段必须有可见 label 或等价的可访问名称", "浮层默认 Teleport 到 body；只有有明确布局约束时才改 appendTo", "优先使用组件的 documented variant，不通过深层 CSS 覆盖内部样式"];
+};
+export declare function findPattern(input: string): PagePattern | undefined;
+export declare function scorePattern(pattern: PagePattern, query: string): number;