aico-cli 0.4.0 → 0.4.2

package/templates/skills/swimlane-diagram/swimlane-diagram.test.mjs

@@ -0,0 +1,358 @@
+/**
+ * 泳道图生成器技能 - 测试文件
+ *
+ * 使用Node.js原生测试框架进行测试
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import assert from 'assert';
+
+// 导入要测试的模块
+import { SwimlaneDiagramGenerator, utils } from './swimlane-diagram.mjs';
+import { validators } from './validators.mjs';
+import { generators } from './generators.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 测试套件
+console.log('🚀 开始泳道图生成器技能测试...\n');
+
+// 测试数据
+const testJourneyData = [
+  {
+    name: '准备阶段',
+    steps: [
+      { description: '用户打开应用', score: 5, actor: '用户' },
+      { description: '系统初始化', score: 4, actor: '系统' }
+    ]
+  }
+];
+
+const testSequenceData = [
+  { from: '用户', to: '系统', message: '提交请求', type: 'sync' }
+];
+
+// 测试用例集合
+const testCases = {
+  // 验证器测试
+  validators: [
+    {
+      name: '验证图表类型 - 有效类型',
+      test: () => {
+        validators.diagramType('journey');
+        validators.diagramType('sequence');
+        console.log('✅ 有效类型验证通过');
+      }
+    },
+    {
+      name: '验证图表类型 - 无效类型',
+      test: () => {
+        try {
+          validators.diagramType('invalid');
+          throw new Error('应该抛出错误');
+        } catch (error) {
+          assert(error.message.includes('无效的图表类型'));
+          console.log('✅ 无效类型验证通过');
+        }
+      }
+    },
+    {
+      name: '验证用户旅程图数据 - 有效数据',
+      test: () => {
+        validators.journeyData(testJourneyData);
+        console.log('✅ 有效旅程图数据验证通过');
+      }
+    }
+  ],
+
+  // 生成器测试
+  generators: [
+    {
+      name: '生成用户旅程图 - 基础功能',
+      test: () => {
+        const result = generators.journey({
+          title: '测试旅程图',
+          sections: testJourneyData
+        });
+
+        assert(result.includes('journey'));
+        assert(result.includes('title 测试旅程图'));
+        assert(result.includes('section 准备阶段'));
+        console.log('✅ 基础旅程图生成通过');
+      }
+    },
+    {
+      name: '生成时序图 - 基础功能',
+      test: () => {
+        const result = generators.sequence({
+          title: '测试时序图',
+          participants: ['用户', '系统'],
+          interactions: testSequenceData
+        });
+
+        assert(result.includes('sequenceDiagram'));
+        assert(result.includes('participant 用户'));
+        assert(result.includes('用户->>系统: 提交请求'));
+        console.log('✅ 基础时序图生成通过');
+      }
+    }
+  ],
+
+  // 核心功能测试
+  core: [
+    {
+      name: 'SwimlaneDiagramGenerator - 实例化',
+      test: () => {
+        const generator = new SwimlaneDiagramGenerator();
+        assert(generator instanceof SwimlaneDiagramGenerator);
+        console.log('✅ 实例化测试通过');
+      }
+    },
+    {
+      name: 'SwimlaneDiagramGenerator - 生成用户旅程图',
+      test: () => {
+        const generator = new SwimlaneDiagramGenerator();
+        const result = generator.generate({
+          type: 'journey',
+          title: '集成测试旅程图',
+          data: testJourneyData
+        });
+
+        assert(result.includes('journey'));
+        assert(result.includes('title 集成测试旅程图'));
+        console.log('✅ 集成旅程图生成通过');
+      }
+    },
+    {
+      name: 'SwimlaneDiagramGenerator - 生成时序图',
+      test: () => {
+        const generator = new SwimlaneDiagramGenerator();
+        const result = generator.generate({
+          type: 'sequence',
+          title: '集成测试时序图',
+          data: testSequenceData,
+          participants: ['用户', '系统']
+        });
+
+        assert(result.includes('sequenceDiagram'));
+        assert(result.includes('participant 用户'));
+        console.log('✅ 集成时序图生成通过');
+      }
+    }
+  ],
+
+  // 工具函数测试
+  utils: [
+    {
+      name: '工具函数 - 解析用户旅程图数据',
+      test: () => {
+        const rawData = [
+          {
+            name: '测试阶段',
+            steps: [
+              { description: '测试步骤', score: 5, actor: '测试者' }
+            ]
+          }
+        ];
+
+        const result = utils.parseJourneyData(rawData);
+        assert(Array.isArray(result));
+        assert(result[0].name === '测试阶段');
+        assert(result[0].steps[0].description === '测试步骤');
+        console.log('✅ 旅程图数据解析通过');
+      }
+    },
+    {
+      name: '工具函数 - 美化Mermaid代码',
+      test: () => {
+        const rawCode = 'journey\n  title 测试\n    section 阶段\n      步骤: 5: 用户';
+        const result = utils.formatMermaidCode(rawCode);
+
+        assert(result.includes('journey'));
+        assert(result.includes('    title 测试'));
+        console.log('✅ Mermaid代码美化通过');
+      }
+    }
+  ],
+
+  // 边界测试
+  edgeCases: [
+    {
+      name: '边界测试 - 空数据验证',
+      test: () => {
+        try {
+          validators.journeyData([]);
+          throw new Error('应该抛出错误');
+        } catch (error) {
+          assert(error.message.includes('不能为空'));
+          console.log('✅ 空数据验证通过');
+        }
+      }
+    },
+    {
+      name: '边界测试 - 无效评分处理',
+      test: () => {
+        const invalidData = [
+          {
+            name: '测试阶段',
+            steps: [
+              { description: '测试步骤', score: 10, actor: '用户' }
+            ]
+          }
+        ];
+
+        try {
+          validators.journeyData(invalidData);
+          throw new Error('应该抛出错误');
+        } catch (error) {
+          assert(error.message.includes('评分必须在1-5之间'));
+          console.log('✅ 无效评分验证通过');
+        }
+      }
+    }
+  ]
+};
+
+// 测试运行器
+async function runTests() {
+  let passed = 0;
+  let failed = 0;
+  const results = [];
+
+  // 按类别运行测试
+  for (const [category, tests] of Object.entries(testCases)) {
+    console.log(`\n📋 运行 ${category} 测试...`);
+
+    for (const testCase of tests) {
+      try {
+        await testCase.test();
+        passed++;
+        results.push({ name: testCase.name, status: '✅ 通过' });
+      } catch (error) {
+        failed++;
+        results.push({
+          name: testCase.name,
+          status: '❌ 失败',
+          error: error.message
+        });
+        console.error(`❌ ${testCase.name} 失败:`, error.message);
+      }
+    }
+  }
+
+  // 输出测试结果
+  console.log('\n' + '='.repeat(50));
+  console.log('📊 测试结果汇总');
+  console.log('='.repeat(50));
+
+  results.forEach(result => {
+    console.log(`${result.status} ${result.name}`);
+    if (result.error) {
+      console.log(`   错误: ${result.error}`);
+    }
+  });
+
+  console.log('\n' + '='.repeat(50));
+  console.log(`🎯 总计: ${passed + failed} 个测试`);
+  console.log(`✅ 通过: ${passed}`);
+  console.log(`❌ 失败: ${failed}`);
+
+  if (failed === 0) {
+    console.log('\n🎉 所有测试通过！泳道图生成器技能功能正常。');
+  } else {
+    console.log('\n⚠️ 存在测试失败，请检查相关功能。');
+    process.exit(1);
+  }
+}
+
+// 性能测试函数
+function runPerformanceTest() {
+  console.log('\n⚡ 运行性能测试...');
+
+  const generator = new SwimlaneDiagramGenerator();
+  const startTime = Date.now();
+
+  // 生成100个简单的时序图
+  for (let i = 0; i < 100; i++) {
+    generator.generate({
+      type: 'sequence',
+      title: `性能测试 ${i}`,
+      data: [{ from: 'A', to: 'B', message: '测试消息', type: 'sync' }],
+      participants: ['A', 'B']
+    });
+  }
+
+  const endTime = Date.now();
+  const duration = endTime - startTime;
+
+  console.log(`⏱️  生成100个时序图耗时: ${duration}ms`);
+  console.log(`📈 平均每个图表: ${(duration / 100).toFixed(2)}ms`);
+
+  if (duration < 1000) {
+    console.log('✅ 性能测试通过 - 生成速度良好');
+  } else {
+    console.log('⚠️ 性能测试警告 - 生成速度较慢');
+  }
+}
+
+// 错误处理测试
+function runErrorHandlingTest() {
+  console.log('\n🛡️ 运行错误处理测试...');
+
+  const generator = new SwimlaneDiagramGenerator();
+
+  // 测试无效参数
+  try {
+    generator.generate(null);
+    console.log('❌ 应该抛出参数错误');
+  } catch (error) {
+    assert(error.message.includes('生成泳道图失败'));
+    console.log('✅ 空参数错误处理通过');
+  }
+
+  // 测试无效类型
+  try {
+    generator.generate({
+      type: 'invalid',
+      title: '测试',
+      data: []
+    });
+    console.log('❌ 应该抛出类型错误');
+  } catch (error) {
+    assert(error.message.includes('生成泳道图失败'));
+    console.log('✅ 无效类型错误处理通过');
+  }
+
+  console.log('✅ 错误处理测试完成');
+}
+
+// 主测试函数
+async function main() {
+  try {
+    await runTests();
+    runPerformanceTest();
+    runErrorHandlingTest();
+
+    console.log('\n🎊 泳道图生成器技能测试全部完成！');
+
+  } catch (error) {
+    console.error('💥 测试运行失败:', error);
+    process.exit(1);
+  }
+}
+
+// 如果直接运行此文件，则执行测试
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(error => {
+    console.error('测试运行器错误:', error);
+    process.exit(1);
+  });
+}
+
+export default {
+  runTests,
+  runPerformanceTest,
+  runErrorHandlingTest
+};

package/templates/skills/swimlane-diagram/validators.mjs

@@ -0,0 +1,291 @@
+/**
+ * 泳道图生成器 - 验证器模块
+ *
+ * 负责参数验证、数据校验和错误处理
+ */
+
+/**
+ * 验证图表类型
+ * @param {string} type - 图表类型
+ * @throws {Error} 如果类型无效
+ */
+export function validateDiagramType(type) {
+  const validTypes = ['journey', 'sequence'];
+
+  if (!type) {
+    throw new Error('图表类型不能为空');
+  }
+
+  if (!validTypes.includes(type)) {
+    throw new Error(`无效的图表类型: ${type}。支持的类型: ${validTypes.join(', ')}`);
+  }
+}
+
+/**
+ * 验证生成参数
+ * @param {Object} params - 生成参数
+ * @throws {Error} 如果参数无效
+ */
+export function validateParameters(params) {
+  if (!params) {
+    throw new Error('生成参数不能为空');
+  }
+
+  if (!params.title || typeof params.title !== 'string') {
+    throw new Error('图表标题不能为空且必须是字符串');
+  }
+
+  if (!params.data || !Array.isArray(params.data)) {
+    throw new Error('图表数据不能为空且必须是数组');
+  }
+
+  // 根据类型进行特定验证
+  switch (params.type) {
+    case 'journey':
+      validateJourneyData(params.data);
+      break;
+    case 'sequence':
+      validateSequenceData(params.data);
+      break;
+  }
+}
+
+/**
+ * 验证用户旅程图数据
+ * @param {Array} data - 旅程图数据
+ * @throws {Error} 如果数据无效
+ */
+export function validateJourneyData(data) {
+  if (data.length === 0) {
+    throw new Error('用户旅程图数据不能为空');
+  }
+
+  data.forEach((section, index) => {
+    if (!section.name) {
+      throw new Error(`第${index + 1}个阶段缺少名称`);
+    }
+
+    if (!section.steps || !Array.isArray(section.steps)) {
+      throw new Error(`阶段"${section.name}"缺少步骤数据`);
+    }
+
+    if (section.steps.length === 0) {
+      throw new Error(`阶段"${section.name}"至少需要一个步骤`);
+    }
+
+    section.steps.forEach((step, stepIndex) => {
+      if (!step.description) {
+        throw new Error(`阶段"${section.name}"的第${stepIndex + 1}个步骤缺少描述`);
+      }
+
+      if (typeof step.score !== 'number' || step.score < 1 || step.score > 5) {
+        throw new Error(`步骤"${step.description}"的评分必须在1-5之间`);
+      }
+
+      if (!step.actor) {
+        throw new Error(`步骤"${step.description}"缺少参与者`);
+      }
+    });
+  });
+}
+
+/**
+ * 验证时序图数据
+ * @param {Array} data - 时序图数据
+ * @throws {Error} 如果数据无效
+ */
+export function validateSequenceData(data) {
+  if (data.length === 0) {
+    throw new Error('时序图数据不能为空');
+  }
+
+  const participants = new Set();
+
+  data.forEach((interaction, index) => {
+    if (!interaction.from) {
+      throw new Error(`第${index + 1}个交互缺少发送者`);
+    }
+
+    if (!interaction.to) {
+      throw new Error(`第${index + 1}个交互缺少接收者`);
+    }
+
+    if (!interaction.message) {
+      throw new Error(`第${index + 1}个交互缺少消息内容`);
+    }
+
+    // 收集参与者
+    participants.add(interaction.from);
+    participants.add(interaction.to);
+
+    // 验证消息类型
+    if (interaction.type && !['sync', 'async'].includes(interaction.type)) {
+      throw new Error(`第${index + 1}个交互的消息类型无效，必须是'sync'或'async'`);
+    }
+  });
+
+  // 验证参与者数量（避免图表过于复杂）
+  if (participants.size > 10) {
+    throw new Error('时序图参与者数量过多（最多10个），建议拆分图表');
+  }
+}
+
+/**
+ * 验证参与者列表
+ * @param {Array} participants - 参与者列表
+ * @throws {Error} 如果参与者无效
+ */
+export function validateParticipants(participants) {
+  if (!participants || !Array.isArray(participants)) {
+    throw new Error('参与者列表不能为空且必须是数组');
+  }
+
+  if (participants.length === 0) {
+    throw new Error('参与者列表不能为空');
+  }
+
+  participants.forEach((participant, index) => {
+    if (typeof participant !== 'string') {
+      throw new Error(`第${index + 1}个参与者必须是字符串`);
+    }
+
+    if (participant.trim().length === 0) {
+      throw new Error(`第${index + 1}个参与者名称不能为空`);
+    }
+
+    // 验证名称长度
+    if (participant.length > 50) {
+      throw new Error(`参与者"${participant}"名称过长（最多50个字符）`);
+    }
+  });
+}
+
+/**
+ * 验证消息内容
+ * @param {string} message - 消息内容
+ * @throws {Error} 如果消息无效
+ */
+export function validateMessage(message) {
+  if (!message || typeof message !== 'string') {
+    throw new Error('消息内容不能为空且必须是字符串');
+  }
+
+  if (message.trim().length === 0) {
+    throw new Error('消息内容不能为空');
+  }
+
+  if (message.length > 200) {
+    throw new Error('消息内容过长（最多200个字符）');
+  }
+}
+
+/**
+ * 验证阶段名称
+ * @param {string} sectionName - 阶段名称
+ * @throws {Error} 如果名称无效
+ */
+export function validateSectionName(sectionName) {
+  if (!sectionName || typeof sectionName !== 'string') {
+    throw new Error('阶段名称不能为空且必须是字符串');
+  }
+
+  if (sectionName.trim().length === 0) {
+    throw new Error('阶段名称不能为空');
+  }
+
+  if (sectionName.length > 100) {
+    throw new Error('阶段名称过长（最多100个字符）');
+  }
+}
+
+/**
+ * 验证步骤描述
+ * @param {string} description - 步骤描述
+ * @throws {Error} 如果描述无效
+ */
+export function validateStepDescription(description) {
+  if (!description || typeof description !== 'string') {
+    throw new Error('步骤描述不能为空且必须是字符串');
+  }
+
+  if (description.trim().length === 0) {
+    throw new Error('步骤描述不能为空');
+  }
+
+  if (description.length > 150) {
+    throw new Error('步骤描述过长（最多150个字符）');
+  }
+}
+
+/**
+ * 验证评分
+ * @param {number} score - 评分值
+ * @throws {Error} 如果评分无效
+ */
+export function validateScore(score) {
+  if (typeof score !== 'number') {
+    throw new Error('评分必须是数字');
+  }
+
+  if (score < 1 || score > 5) {
+    throw new Error('评分必须在1-5之间');
+  }
+
+  if (!Number.isInteger(score)) {
+    throw new Error('评分必须是整数');
+  }
+}
+
+/**
+ * 创建验证错误对象
+ * @param {string} message - 错误消息
+ * @param {string} field - 错误字段
+ * @param {any} value - 错误值
+ * @returns {Object} 验证错误对象
+ */
+export function createValidationError(message, field = null, value = null) {
+  return {
+    message,
+    field,
+    value,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * 批量验证多个字段
+ * @param {Array} validations - 验证规则数组
+ * @returns {Array} 验证错误数组
+ */
+export function batchValidate(validations) {
+  const errors = [];
+
+  validations.forEach(({ value, validator, field, message }) => {
+    try {
+      validator(value);
+    } catch (error) {
+      errors.push(createValidationError(
+        message || error.message,
+        field,
+        value
+      ));
+    }
+  });
+
+  return errors;
+}
+
+/**
+ * 验证器集合
+ */
+export const validators = {
+  diagramType: validateDiagramType,
+  parameters: validateParameters,
+  journeyData: validateJourneyData,
+  sequenceData: validateSequenceData,
+  participants: validateParticipants,
+  message: validateMessage,
+  sectionName: validateSectionName,
+  stepDescription: validateStepDescription,
+  score: validateScore
+};