mcp-probe-kit 1.13.0 → 1.15.1

package/build/tools/__tests__/start_ui.integration.test.js

@@ -0,0 +1,179 @@
+/**
+ * 集成测试：start_ui 工具
+ *
+ * 测试完整的工作流程和端到端场景
+ */
+import { describe, test, expect } from 'vitest';
+import { startUi } from '../start_ui.js';
+describe('start_ui 集成测试', () => {
+    describe('任务 9.3: 完整的手动模式流程', () => {
+        test('生成可执行的工具调用指导', async () => {
+            const result = await startUi({
+                description: '登录页面',
+                framework: 'react'
+            });
+            expect(result.isError).not.toBe(true);
+            const text = result.content[0].text;
+            // 1. 应该包含快速开始部分
+            expect(text).toMatch(/^#\s+快速开始/m);
+            // 2. 应该包含 4 个步骤
+            expect(text).toMatch(/步骤 1.*生成设计系统/);
+            expect(text).toMatch(/步骤 2.*生成组件目录/);
+            expect(text).toMatch(/步骤 3.*搜索.*模板/);
+            expect(text).toMatch(/步骤 4.*渲染.*代码/);
+            // 3. 每个步骤应该包含工具名称
+            expect(text).toMatch(/ui_design_system/);
+            expect(text).toMatch(/init_component_catalog/);
+            expect(text).toMatch(/ui_search/);
+            expect(text).toMatch(/render_ui/);
+            // 4. 每个步骤应该包含 JSON 参数
+            const jsonBlocks = text.match(/```json[\s\S]*?```/g);
+            expect(jsonBlocks).toBeTruthy();
+            expect(jsonBlocks.length).toBeGreaterThanOrEqual(3);
+            // 5. 所有 JSON 应该是有效的
+            jsonBlocks.forEach(block => {
+                const jsonContent = block.replace(/```json\n/, '').replace(/\n```/, '');
+                expect(() => JSON.parse(jsonContent)).not.toThrow();
+            });
+            // 6. 应该包含预期输出
+            expect(text).toMatch(/预期输出/);
+            // 7. 应该包含失败处理
+            expect(text).toMatch(/失败处理/);
+            // 8. 应该包含高级选项
+            expect(text).toMatch(/高级选项/);
+        });
+        test('不同框架生成不同的指导', async () => {
+            const reactResult = await startUi({
+                description: '测试',
+                framework: 'react'
+            });
+            const vueResult = await startUi({
+                description: '测试',
+                framework: 'vue'
+            });
+            const htmlResult = await startUi({
+                description: '测试',
+                framework: 'html'
+            });
+            // 应该包含对应的框架名称
+            expect(reactResult.content[0].text).toMatch(/react/i);
+            expect(vueResult.content[0].text).toMatch(/vue/i);
+            expect(htmlResult.content[0].text).toMatch(/html/i);
+            // 应该是不同的内容
+            expect(reactResult.content[0].text).not.toBe(vueResult.content[0].text);
+            expect(vueResult.content[0].text).not.toBe(htmlResult.content[0].text);
+        });
+        test('复杂描述生成正确的指导', async () => {
+            const result = await startUi({
+                description: '带有用户认证和权限管理的管理后台',
+                framework: 'react'
+            });
+            expect(result.isError).not.toBe(true);
+            const text = result.content[0].text;
+            // 应该包含转义后的描述
+            expect(text).toMatch(/带有用户认证和权限管理的管理后台/);
+            // 所有 JSON 应该是有效的
+            const jsonBlocks = text.match(/```json[\s\S]*?```/g);
+            expect(jsonBlocks).toBeTruthy();
+            jsonBlocks.forEach(block => {
+                const jsonContent = block.replace(/```json\n/, '').replace(/\n```/, '');
+                expect(() => JSON.parse(jsonContent)).not.toThrow();
+            });
+        });
+    });
+    describe('任务 9.3: 错误恢复流程', () => {
+        test('缺少参数时提供清晰的恢复指导', async () => {
+            const result = await startUi({});
+            expect(result.isError).toBe(true);
+            const text = result.content[0].text;
+            // 应该说明问题
+            expect(text).toMatch(/缺少必要参数/);
+            // 应该提供用法示例
+            expect(text).toMatch(/用法/);
+            expect(text).toMatch(/start_ui/);
+            // 应该提供具体示例
+            expect(text).toMatch(/示例/);
+        });
+        test('无效模式时提供清晰的恢复指导', async () => {
+            const result = await startUi({
+                description: '测试',
+                mode: 'invalid'
+            });
+            expect(result.isError).toBe(true);
+            const text = result.content[0].text;
+            // 应该说明问题
+            expect(text).toMatch(/无效的模式/);
+            // 应该列出有效选项
+            expect(text).toMatch(/auto/);
+            expect(text).toMatch(/manual/);
+            // 应该提供示例
+            expect(text).toMatch(/示例/);
+        });
+    });
+    describe('任务 9.3: 工具调用可执行性', () => {
+        test('生成的 JSON 参数可以直接使用', async () => {
+            const result = await startUi({
+                description: '用户列表',
+                framework: 'vue'
+            });
+            const text = result.content[0].text;
+            // 提取所有 JSON 代码块
+            const jsonBlocks = text.match(/```json\n([\s\S]*?)\n```/g);
+            expect(jsonBlocks).toBeTruthy();
+            // 验证每个 JSON 都可以解析并包含有效参数
+            jsonBlocks.forEach(block => {
+                const jsonContent = block.replace(/```json\n/, '').replace(/\n```/, '');
+                const parsed = JSON.parse(jsonContent);
+                // 应该是一个对象
+                expect(typeof parsed).toBe('object');
+                expect(parsed).not.toBeNull();
+                // 不应该包含未替换的占位符
+                const jsonStr = JSON.stringify(parsed);
+                expect(jsonStr).not.toMatch(/\{description\}/);
+                expect(jsonStr).not.toMatch(/\{framework\}/);
+                expect(jsonStr).not.toMatch(/\{templateName\}/);
+            });
+        });
+        test('工具名称是有效的 MCP 工具', async () => {
+            const result = await startUi({
+                description: '测试',
+                framework: 'react'
+            });
+            const text = result.content[0].text;
+            // 定义有效的工具名称
+            const validTools = [
+                'ui_design_system',
+                'init_component_catalog',
+                'ui_search',
+                'render_ui'
+            ];
+            // 应该只包含有效的工具名称
+            validTools.forEach(tool => {
+                if (text.includes(tool)) {
+                    // 工具名称应该在代码块或工具标记中
+                    const toolPattern = new RegExp(`(\`${tool}\`|\\*\\*工具\\*\\*.*${tool})`);
+                    expect(text).toMatch(toolPattern);
+                }
+            });
+        });
+    });
+    describe('向后兼容性', () => {
+        test('支持旧的调用方式', async () => {
+            // 只传描述字符串
+            const result1 = await startUi({ description: '测试' });
+            expect(result1.isError).not.toBe(true);
+            // 传描述和框架
+            const result2 = await startUi({
+                description: '测试',
+                framework: 'react'
+            });
+            expect(result2.isError).not.toBe(true);
+            // 使用别名
+            const result3 = await startUi({
+                desc: '测试',
+                stack: 'vue'
+            });
+            expect(result3.isError).not.toBe(true);
+        });
+    });
+});

package/build/tools/__tests__/start_ui.property.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 属性测试：start_ui 工具
+ *
+ * 使用 fast-check 进行基于属性的测试，验证跨所有输入的通用正确性属性
+ */
+export {};

package/build/tools/__tests__/start_ui.property.test.js

@@ -0,0 +1,263 @@
+/**
+ * 属性测试：start_ui 工具
+ *
+ * 使用 fast-check 进行基于属性的测试，验证跨所有输入的通用正确性属性
+ */
+import { describe, test, expect } from 'vitest';
+import * as fc from 'fast-check';
+import { startUi } from '../start_ui.js';
+describe('start_ui 属性测试', () => {
+    // Feature: ui-workflow-execution-issue, Property 11: Token 长度约束
+    test('任务 1.1: 指导少于 800 tokens', async () => {
+        await fc.assert(fc.asyncProperty(fc.record({
+            description: fc.string({ minLength: 1, maxLength: 100 }),
+            framework: fc.constantFrom('react', 'vue', 'html')
+        }), async (input) => {
+            const result = await startUi(input);
+            const text = result.content[0].text;
+            // 简单的 token 估算：按空格和标点分割
+            const tokenCount = text.split(/[\s\n]+/).length;
+            // 硬性约束：必须少于 800 tokens
+            expect(tokenCount).toBeLessThan(800);
+        }), { numRuns: 100 });
+    });
+    // Feature: ui-workflow-execution-issue, Property 18: 一致的 Markdown 结构
+    test('任务 1.2: 指导使用一致的 Markdown 结构', async () => {
+        await fc.assert(fc.asyncProperty(fc.record({
+            description: fc.string({ minLength: 1, maxLength: 100 }),
+            framework: fc.constantFrom('react', 'vue', 'html')
+        }), async (input) => {
+            const result = await startUi(input);
+            const text = result.content[0].text;
+            // 应该包含 H1 标题（快速开始）
+            expect(text).toMatch(/^#\s+快速开始/m);
+            // 应该包含 H2 标题（步骤）
+            expect(text).toMatch(/^##\s+步骤/m);
+            // 应该包含代码块
+            expect(text).toMatch(/```json/);
+            // 应该包含高级选项部分
+            expect(text).toMatch(/^##\s+高级选项/m);
+        }), { numRuns: 100 });
+    });
+    // Feature: ui-workflow-execution-issue, Property 2: 代码块中的工具调用
+    test('任务 2.2: 工具调用在代码块中', async () => {
+        await fc.assert(fc.asyncProperty(fc.record({
+            description: fc.string({ minLength: 1, maxLength: 100 }),
+            framework: fc.constantFrom('react', 'vue', 'html')
+        }), async (input) => {
+            const result = await startUi(input);
+            const text = result.content[0].text;
+            // 如果包含 JSON 参数，应该在代码块中
+            const jsonBlocks = text.match(/```json[\s\S]*?```/g);
+            expect(jsonBlocks).toBeTruthy();
+            expect(jsonBlocks.length).toBeGreaterThan(0);
+        }), { numRuns: 100 });
+    });
+    // Feature: ui-workflow-execution-issue, Property 3: 完整的工具调用参数
+    test('任务 2.2: 工具调用包含完整参数', async () => {
+        await fc.assert(fc.asyncProperty(fc.record({
+            description: fc.string({ minLength: 1, maxLength: 100 }),
+            framework: fc.constantFrom('react', 'vue', 'html')
+        }), async (input) => {
+            const result = await startUi(input);
+            const text = result.content[0].text;
+            // 提取所有 JSON 代码块
+            const jsonBlocks = text.match(/```json\n([\s\S]*?)\n```/g);
+            if (jsonBlocks) {
+                jsonBlocks.forEach(block => {
+                    // 提取 JSON 内容
+                    const jsonContent = block.replace(/```json\n/, '').replace(/\n```/, '');
+                    // 应该是有效的 JSON
+                    expect(() => JSON.parse(jsonContent)).not.toThrow();
+                    const parsed = JSON.parse(jsonContent);
+                    // 不应该包含模板占位符
+                    const jsonStr = JSON.stringify(parsed);
+                    // 检查特定的模板占位符，而不是所有花括号
+                    expect(jsonStr).not.toMatch(/\{description\}/);
+                    expect(jsonStr).not.toMatch(/\{framework\}/);
+                    expect(jsonStr).not.toMatch(/\{templateName\}/);
+                });
+            }
+        }), { numRuns: 100 });
+    });
+    // Feature: ui-workflow-execution-issue, Property 13: 标准 MCP 工具语法
+    test('任务 2.2: 使用标准 MCP 工具语法', async () => {
+        await fc.assert(fc.asyncProperty(fc.record({
+            description: fc.string({ minLength: 1, maxLength: 100 }),
+            framework: fc.constantFrom('react', 'vue', 'html')
+        }), async (input) => {
+            const result = await startUi(input);
+            const text = result.content[0].text;
+            // 应该包含有效的工具名称
+            const validTools = [
+                'ui_design_system',
+                'init_component_catalog',
+                'ui_search',
+                'render_ui'
+            ];
+            let foundTool = false;
+            validTools.forEach(tool => {
+                if (text.includes(tool)) {
+                    foundTool = true;
+                }
+            });
+            expect(foundTool).toBe(true);
+        }), { numRuns: 100 });
+    });
+});
+// Feature: ui-workflow-execution-issue, Property 4: 预期输出文档
+test('任务 3.4: 每个步骤包含预期输出', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 应该包含"预期输出"部分
+        expect(text).toMatch(/预期输出|Expected Output/i);
+        // 每个步骤都应该有预期输出
+        const stepSections = text.match(/^##\s+步骤\s+\d+:/gm);
+        if (stepSections) {
+            // 至少应该有一些步骤有预期输出
+            const outputCount = (text.match(/预期输出|Expected Output/gi) || []).length;
+            expect(outputCount).toBeGreaterThan(0);
+        }
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 6: 显式依赖关系
+test('任务 3.4: 步骤包含依赖关系说明', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 应该包含依赖关系的说明（如"确保步骤 1"）
+        const hasDependency = text.includes('确保步骤') ||
+            text.includes('确保') ||
+            text.includes('依赖') ||
+            text.includes('需要');
+        expect(hasDependency).toBe(true);
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 8: 全面的错误处理
+test('任务 3.4: 每个步骤包含失败处理', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 应该包含"失败处理"部分
+        expect(text).toMatch(/失败处理|Failure Handling|On Failure/i);
+        // 每个步骤都应该有失败处理
+        const stepSections = text.match(/^##\s+步骤\s+\d+:/gm);
+        if (stepSections) {
+            // 至少应该有一些步骤有失败处理
+            const failureCount = (text.match(/失败处理|Failure Handling|On Failure/gi) || []).length;
+            expect(failureCount).toBeGreaterThan(0);
+        }
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 22: 模式参数支持
+test('任务 5.4: 接受模式参数', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html'),
+        mode: fc.constantFrom('auto', 'manual', undefined)
+    }), async (input) => {
+        // 不应该抛出错误
+        const result = await startUi(input);
+        // 应该返回有效的响应
+        expect(result.content).toBeDefined();
+        expect(result.content[0].text).toBeTruthy();
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 24: 手动模式指导
+test('任务 5.4: 手动模式返回指导', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        // 默认或显式 manual 模式
+        const result1 = await startUi(input);
+        const result2 = await startUi({ ...input, mode: 'manual' });
+        // 应该返回指导文本
+        expect(result1.content[0].text).toMatch(/快速开始|Quick Start/i);
+        expect(result2.content[0].text).toMatch(/快速开始|Quick Start/i);
+        // 应该包含工具调用
+        expect(result1.content[0].text).toMatch(/ui_design_system|init_component_catalog/);
+        expect(result2.content[0].text).toMatch(/ui_design_system|init_component_catalog/);
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 15: 无副作用
+test('任务 5.5: start_ui 无副作用', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        // 调用 start_ui
+        const result = await startUi(input);
+        // 应该只返回文本，不应该有 isError（除非是错误情况）
+        expect(result.content).toBeDefined();
+        expect(result.content[0].type).toBe('text');
+        // 不应该抛出异常
+        expect(result).toBeTruthy();
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 1: 显式工具调用规范
+test('任务 6.4: 指导包含显式工具名称', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 应该包含明确的工具名称
+        const hasToolNames = text.includes('ui_design_system') ||
+            text.includes('init_component_catalog') ||
+            text.includes('ui_search') ||
+            text.includes('render_ui');
+        expect(hasToolNames).toBe(true);
+        // 应该有明确的调用指令
+        expect(text).toMatch(/调用|执行|运行|call|execute|run/i);
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 5: 无模糊语言
+test('任务 6.4: 无模糊语言', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 不应该包含模糊的指令（没有具体工具名称或文件名）
+        // 如果包含"检查"，应该伴随具体的文件名或工具名
+        const checkMatches = text.match(/检查[^。\n]*/g) || [];
+        checkMatches.forEach(match => {
+            // 应该包含具体的文件名、工具名或目录名
+            const hasSpecific = match.includes('.json') ||
+                match.includes('.md') ||
+                match.includes('ui_') ||
+                match.includes('文件') ||
+                match.includes('权限') ||
+                match.includes('docs/') ||
+                match.includes('目录');
+            expect(hasSpecific).toBe(true);
+        });
+    }), { numRuns: 100 });
+});
+// Feature: ui-workflow-execution-issue, Property 16: 范围声明
+test('任务 6.4: 包含职责范围声明', async () => {
+    await fc.assert(fc.asyncProperty(fc.record({
+        description: fc.string({ minLength: 1, maxLength: 100 }),
+        framework: fc.constantFrom('react', 'vue', 'html')
+    }), async (input) => {
+        const result = await startUi(input);
+        const text = result.content[0].text;
+        // 应该包含职责说明
+        expect(text).toMatch(/职责说明|职责|Responsibility/i);
+        // 应该说明只提供指导
+        expect(text).toMatch(/仅提供|只提供|提供指导|provide guidance/i);
+    }), { numRuns: 100 });
+});

package/build/tools/__tests__/start_ui.unit.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 单元测试：start_ui 工具
+ *
+ * 测试具体的功能点、边界情况和错误条件
+ */
+export {};

package/build/tools/__tests__/start_ui.unit.test.js

@@ -0,0 +1,109 @@
+/**
+ * 单元测试：start_ui 工具
+ *
+ * 测试具体的功能点、边界情况和错误条件
+ */
+import { describe, test, expect } from 'vitest';
+import { startUi } from '../start_ui.js';
+describe('start_ui 单元测试', () => {
+    describe('任务 7.3: 错误处理', () => {
+        test('缺少描述参数时返回错误', async () => {
+            const result = await startUi({});
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toMatch(/缺少必要参数|Missing required parameter/i);
+            expect(result.content[0].text).toMatch(/用法|Usage/i);
+        });
+        test('空描述参数时返回错误', async () => {
+            const result = await startUi({ description: '' });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toMatch(/缺少必要参数|Missing required parameter/i);
+        });
+        test('无效 mode 值时返回错误', async () => {
+            const result = await startUi({
+                description: '测试',
+                mode: 'invalid'
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toMatch(/无效的模式|Invalid mode/i);
+            expect(result.content[0].text).toMatch(/auto.*manual/i);
+        });
+        test('错误响应包含使用示例', async () => {
+            const result = await startUi({});
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toMatch(/示例|Example/i);
+            expect(result.content[0].text).toMatch(/start_ui/);
+        });
+    });
+    describe('参数解析', () => {
+        test('默认 framework 为 react', async () => {
+            const result = await startUi({ description: '测试' });
+            expect(result.content[0].text).toMatch(/react/i);
+        });
+        test('支持 vue framework', async () => {
+            const result = await startUi({
+                description: '测试',
+                framework: 'vue'
+            });
+            expect(result.content[0].text).toMatch(/vue/i);
+        });
+        test('支持 html framework', async () => {
+            const result = await startUi({
+                description: '测试',
+                framework: 'html'
+            });
+            expect(result.content[0].text).toMatch(/html/i);
+        });
+        test('自动生成模板名称', async () => {
+            const result = await startUi({ description: '登录页面' });
+            // 应该生成类似 login 的模板名
+            expect(result.content[0].text).toMatch(/login|登录/i);
+        });
+    });
+    describe('模式参数', () => {
+        test('默认模式为 manual', async () => {
+            const result = await startUi({ description: '测试' });
+            expect(result.isError).not.toBe(true);
+            expect(result.content[0].text).toMatch(/快速开始|Quick Start/i);
+        });
+        test('显式 manual 模式返回指导', async () => {
+            const result = await startUi({
+                description: '测试',
+                mode: 'manual'
+            });
+            expect(result.isError).not.toBe(true);
+            expect(result.content[0].text).toMatch(/快速开始|Quick Start/i);
+        });
+        test('auto 模式返回未实现消息', async () => {
+            const result = await startUi({
+                description: '测试',
+                mode: 'auto'
+            });
+            expect(result.isError).toBe(false);
+            expect(result.content[0].text).toMatch(/尚未实现|not yet implemented/i);
+        });
+    });
+    describe('输出格式', () => {
+        test('返回有效的 markdown', async () => {
+            const result = await startUi({ description: '测试' });
+            const text = result.content[0].text;
+            // 应该包含 markdown 标题
+            expect(text).toMatch(/^#/m);
+            // 应该包含代码块
+            expect(text).toMatch(/```/);
+        });
+        test('包含所有必需的步骤', async () => {
+            const result = await startUi({ description: '测试' });
+            const text = result.content[0].text;
+            // 应该包含 4 个步骤
+            expect(text).toMatch(/步骤 1/);
+            expect(text).toMatch(/步骤 2/);
+            expect(text).toMatch(/步骤 3/);
+            expect(text).toMatch(/步骤 4/);
+        });
+        test('包含高级选项部分', async () => {
+            const result = await startUi({ description: '测试' });
+            const text = result.content[0].text;
+            expect(text).toMatch(/高级选项|Advanced Options/i);
+        });
+    });
+});

package/build/tools/index.d.ts

@@ -41,3 +41,7 @@ export { genSkill } from "./gen_skill.js";
 export { startRalph } from "./start_ralph.js";
 export { interview } from "./interview.js";
 export { askUser } from "./ask_user.js";
+export { uiDesignSystem, uiSearch, syncUiData } from "./ui-ux-tools.js";
+export { initComponentCatalog } from "./init_component_catalog.js";
+export { renderUi } from "./render_ui.js";
+export { startUi } from "./start_ui.js";

package/build/tools/index.js

@@ -43,3 +43,8 @@ export { startRalph } from "./start_ralph.js";
 // 访谈工具
 export { interview } from "./interview.js";
 export { askUser } from "./ask_user.js";
+// UI/UX Pro Max 工具
+export { uiDesignSystem, uiSearch, syncUiData } from "./ui-ux-tools.js";
+export { initComponentCatalog } from "./init_component_catalog.js";
+export { renderUi } from "./render_ui.js";
+export { startUi } from "./start_ui.js";

package/build/tools/init_component_catalog.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 初始化组件目录工具
+ *
+ * 基于设计系统规范生成组件目录
+ * 组件定义包含占位符，渲染时自动替换为实际值
+ */
+/**
+ * 初始化组件目录工具
+ */
+export declare function initComponentCatalog(args: any): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;