@zeyue0329/xiaoma-cli 1.0.40 → 1.0.42

package/tools/workflow-coordinator/src/parser/workflow-parser.js

@@ -0,0 +1,144 @@
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const path = require('path');
+
+class WorkflowParser {
+  constructor() {
+    // 工作流目录相对于项目根目录
+    // 从 tools/workflow-coordinator/src/parser 向上找到项目根目录
+    const projectRoot = path.resolve(__dirname, '../../../..');
+    this.workflowsDir = path.join(projectRoot, 'xiaoma-core/workflows');
+  }
+
+  /**
+   * 解析工作流YAML文件
+   * @param {string} workflowName - 工作流名称
+   * @returns {Promise<Object>} 执行计划
+   */
+  async parse(workflowName) {
+    // 1. 查找工作流文件
+    const workflowFile = this.findWorkflowFile(workflowName);
+
+    if (!workflowFile) {
+      throw new Error(`工作流文件未找到: ${workflowName}\n查找路径: ${this.workflowsDir}`);
+    }
+
+    // 2. 读取并解析YAML
+    const yamlContent = await fs.readFile(workflowFile, 'utf-8');
+    const workflowDef = yaml.load(yamlContent);
+
+    // 3. 验证工作流定义
+    this.validate(workflowDef);
+
+    // 4. 构建执行计划
+    const executionPlan = {
+      metadata: {
+        id: workflowDef.workflow.id,
+        name: workflowDef.workflow.name,
+        description: workflowDef.workflow.description,
+        type: workflowDef.workflow.type,
+        projectTypes: workflowDef.workflow.project_types || []
+      },
+      steps: workflowDef.workflow.sequence.map(step => this.parseStep(step)),
+      qualityGates: workflowDef.workflow.quality_gates || {},
+      errorHandling: workflowDef.workflow.error_handling || {}
+    };
+
+    return executionPlan;
+  }
+
+  /**
+   * 解析单个步骤
+   */
+  parseStep(stepYaml) {
+    return {
+      id: stepYaml.step,
+      description: stepYaml.action || stepYaml.step,
+      agent: stepYaml.agent,
+      duration: stepYaml.duration,
+      requires: stepYaml.requires || [],
+      detailedSteps: stepYaml.detailed_steps || [],
+      validationCriteria: stepYaml.validation_criteria || [],
+      outputs: this.extractOutputs(stepYaml),
+      onSuccess: stepYaml.on_success,
+      onFailure: stepYaml.on_failure
+    };
+  }
+
+  /**
+   * 从步骤定义中提取输出文件列表
+   */
+  extractOutputs(stepYaml) {
+    const outputs = [];
+
+    // 从validation_criteria提取file_created
+    if (stepYaml.validation_criteria) {
+      stepYaml.validation_criteria.forEach(criterion => {
+        if (typeof criterion === 'string' && criterion.includes('file_created:')) {
+          const filePath = criterion.split('file_created:')[1].trim().replace(/["']/g, '');
+          outputs.push({ file: filePath });
+        }
+      });
+    }
+
+    // 从detailed_steps的output字段提取
+    if (stepYaml.detailed_steps) {
+      stepYaml.detailed_steps.forEach(detailStep => {
+        if (detailStep.output && detailStep.output.file) {
+          outputs.push({ file: detailStep.output.file });
+        }
+        if (detailStep.output_files && Array.isArray(detailStep.output_files)) {
+          detailStep.output_files.forEach(file => {
+            outputs.push({ file: file });
+          });
+        }
+      });
+    }
+
+    return outputs;
+  }
+
+  /**
+   * 查找工作流文件
+   */
+  findWorkflowFile(workflowName) {
+    const possibleNames = [
+      `${workflowName}.yaml`,
+      `${workflowName}.yml`,
+      `automated-${workflowName}.yaml`,
+      `automated-${workflowName}.yml`
+    ];
+
+    for (const name of possibleNames) {
+      const filePath = path.join(this.workflowsDir, name);
+      if (fs.existsSync(filePath)) {
+        return filePath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 验证工作流定义
+   */
+  validate(workflowDef) {
+    if (!workflowDef.workflow) {
+      throw new Error('无效的工作流定义: 缺少 workflow 字段');
+    }
+
+    if (!workflowDef.workflow.id) {
+      throw new Error('无效的工作流定义: 缺少 workflow.id');
+    }
+
+    if (!workflowDef.workflow.sequence || !Array.isArray(workflowDef.workflow.sequence)) {
+      throw new Error('无效的工作流定义: 缺少 workflow.sequence 或格式错误');
+    }
+
+    if (workflowDef.workflow.sequence.length === 0) {
+      throw new Error('无效的工作流定义: workflow.sequence 为空');
+    }
+  }
+}
+
+module.exports = WorkflowParser;

package/tools/workflow-coordinator/src/utils/state-manager.js

@@ -0,0 +1,59 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class StateManager {
+  constructor() {
+    // 状态目录相对于项目根目录
+    // 从 tools/workflow-coordinator/src/utils 向上找到项目根目录
+    const projectRoot = path.resolve(__dirname, '../../../..');
+    this.stateDir = path.join(projectRoot, '.xiaoma-core');
+    this.stateFile = path.join(this.stateDir, '.coordinator-state.json');
+  }
+
+  /**
+   * 保存工作流状态
+   */
+  async save(state) {
+    await fs.ensureDir(this.stateDir);
+    await fs.writeFile(
+      this.stateFile,
+      JSON.stringify(state, null, 2),
+      'utf-8'
+    );
+  }
+
+  /**
+   * 加载工作流状态
+   */
+  async load() {
+    if (!fs.existsSync(this.stateFile)) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(this.stateFile, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error('状态文件加载失败:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * 清除状态文件
+   */
+  async clear() {
+    if (fs.existsSync(this.stateFile)) {
+      await fs.remove(this.stateFile);
+    }
+  }
+
+  /**
+   * 检查是否存在状态文件
+   */
+  exists() {
+    return fs.existsSync(this.stateFile);
+  }
+}
+
+module.exports = StateManager;

package/tools/workflow-coordinator/src/utils/validator.js

@@ -0,0 +1,86 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class Validator {
+  /**
+   * 验证步骤输出
+   */
+  async validateOutputs(stepDef, actualOutputs) {
+    const issues = [];
+
+    // 验证所有预期输出文件
+    for (const expectedOutput of stepDef.outputs || []) {
+      const filePath = expectedOutput.file;
+      const actualOutput = actualOutputs.find(o => o.file === filePath);
+
+      if (!actualOutput) {
+        issues.push({
+          level: 'error',
+          message: `输出文件未报告: ${filePath}`
+        });
+        continue;
+      }
+
+      if (!actualOutput.exists) {
+        issues.push({
+          level: 'error',
+          message: `输出文件不存在: ${filePath}`
+        });
+        continue;
+      }
+
+      if (actualOutput.size === 0) {
+        issues.push({
+          level: 'warning',
+          message: `输出文件为空: ${filePath}`
+        });
+      }
+    }
+
+    // 验证validation_criteria
+    for (const criterion of stepDef.validationCriteria || []) {
+      if (typeof criterion === 'string') {
+        // 验证file_created标准
+        if (criterion.includes('file_created:')) {
+          const filePath = criterion.split('file_created:')[1].trim().replace(/["']/g, '');
+          const actualOutput = actualOutputs.find(o => o.file === filePath);
+
+          if (!actualOutput || !actualOutput.exists) {
+            issues.push({
+              level: 'error',
+              message: `验证失败: ${criterion}`
+            });
+          }
+        }
+      }
+    }
+
+    return {
+      passed: issues.filter(i => i.level === 'error').length === 0,
+      issues: issues,
+      warnings: issues.filter(i => i.level === 'warning').length,
+      errors: issues.filter(i => i.level === 'error').length
+    };
+  }
+
+  /**
+   * 验证文件是否存在
+   */
+  validateFileExists(filePath) {
+    return fs.existsSync(filePath);
+  }
+
+  /**
+   * 验证文件内容是否非空
+   */
+  async validateFileNotEmpty(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+
+    const stats = await fs.stat(filePath);
+    return stats.size > 0;
+  }
+}
+
+module.exports = Validator;

package/tools/workflow-coordinator/test/integration-test.js

@@ -0,0 +1,266 @@
+/**
+ * 工作流协调器集成测试
+ *
+ * 测试完整的工作流执行流程:
+ * 1. 启动工作流
+ * 2. 模拟步骤完成
+ * 3. 验证下一步指令
+ * 4. 测试失败重试
+ * 5. 测试工作流完成
+ */
+
+const fetch = require('node-fetch');
+
+const BASE_URL = 'http://localhost:3001';
+
+// 辅助函数:发送POST请求
+async function post(endpoint, body) {
+  const response = await fetch(`${BASE_URL}${endpoint}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  return response.json();
+}
+
+// 辅助函数:发送GET请求
+async function get(endpoint) {
+  const response = await fetch(`${BASE_URL}${endpoint}`);
+  return response.json();
+}
+
+// 测试1: 健康检查
+async function testHealthCheck() {
+  console.log('\n=== 测试1: 健康检查 ===');
+
+  const result = await get('/health');
+  console.log('✓ 健康检查响应:', result);
+
+  if (result.status !== 'ok') {
+    throw new Error('健康检查失败');
+  }
+}
+
+// 测试2: 启动工作流
+async function testStartWorkflow() {
+  console.log('\n=== 测试2: 启动工作流 ===');
+
+  const result = await post('/workflow/start', {
+    workflowId: 'test-workflow-' + Date.now(),
+    context: {
+      userRequirement: '用户需求示例'
+    }
+  });
+
+  console.log('✓ 工作流启动响应:');
+  console.log('  - 工作流名称:', result.workflowName);
+  console.log('  - 总步骤数:', result.totalSteps);
+  console.log('  - 第一步ID:', result.firstStep.stepId);
+  console.log('  - 智能体:', result.firstStep.agent);
+
+  if (!result.success) {
+    throw new Error('工作流启动失败');
+  }
+
+  return result;
+}
+
+// 测试3: 查询状态
+async function testQueryStatus() {
+  console.log('\n=== 测试3: 查询状态 ===');
+
+  const result = await get('/workflow/status');
+  console.log('✓ 工作流状态:', result);
+
+  if (result.status === 'not_started') {
+    throw new Error('工作流未启动');
+  }
+}
+
+// 测试4: 步骤完成(带输出验证失败)
+async function testStepCompleteWithValidationFailure(workflowData) {
+  console.log('\n=== 测试4: 步骤完成(输出验证失败) ===');
+
+  // 模拟文件不存在的情况
+  const result = await post('/workflow/step-complete', {
+    workflowId: workflowData.workflowId,
+    stepId: workflowData.firstStep.stepId,
+    status: 'completed',
+    outputs: [
+      {
+        file: workflowData.firstStep.expectedOutputs[0],
+        exists: false,  // 文件不存在
+        size: 0
+      }
+    ],
+    duration: 5000
+  });
+
+  console.log('✓ 验证失败响应:');
+  console.log('  - 成功标志:', result.success);
+  console.log('  - 操作:', result.action);
+  console.log('  - 问题数:', result.issues?.length || 0);
+
+  if (result.success !== false || result.action !== 'fix_quality') {
+    throw new Error('应该返回验证失败');
+  }
+}
+
+// 测试5: 步骤完成(成功)
+async function testStepCompleteSuccess(workflowData) {
+  console.log('\n=== 测试5: 步骤完成(成功) ===');
+
+  // 模拟所有文件都存在
+  const outputs = workflowData.firstStep.expectedOutputs.map(file => ({
+    file: file,
+    exists: true,
+    size: 1024
+  }));
+
+  const result = await post('/workflow/step-complete', {
+    workflowId: workflowData.workflowId,
+    stepId: workflowData.firstStep.stepId,
+    status: 'completed',
+    outputs: outputs,
+    duration: 10000
+  });
+
+  console.log('✓ 步骤完成响应:');
+  console.log('  - 成功标志:', result.success);
+  console.log('  - 有下一步:', result.hasNextStep);
+
+  if (result.hasNextStep) {
+    console.log('  - 下一步ID:', result.nextStep.stepId);
+    console.log('  - 智能体:', result.nextStep.agent);
+    console.log('  - 进度:', `${result.progress.percentComplete}%`);
+  }
+
+  if (!result.success) {
+    throw new Error('步骤完成失败');
+  }
+
+  return result;
+}
+
+// 测试6: 步骤失败和重试
+async function testStepFailure(workflowData, currentStepId) {
+  console.log('\n=== 测试6: 步骤失败和重试 ===');
+
+  const result = await post('/workflow/step-failed', {
+    workflowId: workflowData.workflowId,
+    stepId: currentStepId,
+    error: '模拟错误:文件未找到',
+    errorDetails: {
+      missingFile: 'templates/test.md'
+    }
+  });
+
+  console.log('✓ 失败处理响应:');
+  console.log('  - 成功标志:', result.success);
+  console.log('  - 操作:', result.action);
+
+  if (result.action === 'retry') {
+    console.log('  - 重试次数:', `${result.retryCount}/${result.maxRetries}`);
+  }
+
+  return result;
+}
+
+// 测试7: 完成所有剩余步骤
+async function testCompleteAllSteps(workflowData) {
+  console.log('\n=== 测试7: 完成所有剩余步骤 ===');
+
+  let hasNext = true;
+  let currentStepIndex = 1; // 已经完成了第一步
+  let nextStep = null;
+
+  // 获取当前状态
+  const status = await get('/workflow/status');
+  const totalSteps = status.totalSteps;
+
+  console.log(`需要完成 ${totalSteps - currentStepIndex} 个步骤`);
+
+  while (hasNext && currentStepIndex < totalSteps) {
+    // 获取当前步骤
+    const statusNow = await get('/workflow/status');
+    const currentStep = statusNow.currentStep;
+
+    console.log(`\n正在完成步骤 ${currentStepIndex + 1}/${totalSteps}: ${currentStep}`);
+
+    // 模拟步骤完成
+    const result = await post('/workflow/step-complete', {
+      workflowId: workflowData.workflowId,
+      stepId: currentStep,
+      status: 'completed',
+      outputs: [], // 简化:不验证输出
+      duration: 5000
+    });
+
+    hasNext = result.hasNextStep;
+    currentStepIndex++;
+
+    if (result.hasNextStep) {
+      console.log(`✓ 进度: ${result.progress.percentComplete}%`);
+    } else {
+      console.log('\n✓ 工作流执行完成!');
+      console.log('摘要:');
+      console.log('  - 总耗时:', result.summary.totalDurationFormatted);
+      console.log('  - 完成步骤:', result.summary.totalSteps);
+      console.log('  - 错误数:', result.summary.errors);
+    }
+  }
+}
+
+// 主测试函数
+async function runTests() {
+  console.log('╔════════════════════════════════════════╗');
+  console.log('║   工作流协调器集成测试   ║');
+  console.log('╚════════════════════════════════════════╝');
+
+  try {
+    // 确保协调器正在运行
+    console.log('\n检查协调器是否运行...');
+    await testHealthCheck();
+
+    // 启动工作流
+    const workflowData = await testStartWorkflow();
+
+    // 等待一下让状态保存
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    // 查询状态
+    await testQueryStatus();
+
+    // 测试输出验证失败
+    await testStepCompleteWithValidationFailure(workflowData);
+
+    // 测试步骤成功完成
+    const step1Result = await testStepCompleteSuccess(workflowData);
+
+    if (step1Result.hasNextStep) {
+      // 测试步骤失败和重试
+      await testStepFailure(workflowData, step1Result.nextStep.stepId);
+
+      // 重试后成功完成
+      await testStepCompleteSuccess({
+        ...workflowData,
+        firstStep: step1Result.nextStep
+      });
+    }
+
+    // 完成所有剩余步骤
+    await testCompleteAllSteps(workflowData);
+
+    console.log('\n╔════════════════════════════════════════╗');
+    console.log('║   所有测试通过! ✓   ║');
+    console.log('╚════════════════════════════════════════╝\n');
+
+  } catch (error) {
+    console.error('\n❌ 测试失败:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+// 运行测试
+runTests().catch(console.error);

package/tools/workflow-coordinator/test/quick-test.js

@@ -0,0 +1,127 @@
+/**
+ * 快速测试脚本
+ * 测试核心功能:启动->完成多步->查看进度
+ */
+
+const fetch = require('node-fetch');
+const chalk = require('chalk');
+
+const BASE_URL = 'http://localhost:3001';
+
+async function post(endpoint, body) {
+  const response = await fetch(`${BASE_URL}${endpoint}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  return response.json();
+}
+
+async function get(endpoint) {
+  const response = await fetch(`${BASE_URL}${endpoint}`);
+  return response.json();
+}
+
+async function main() {
+  console.log(chalk.blue.bold('\n╔════════════════════════════════════════╗'));
+  console.log(chalk.blue.bold('║   工作流协调器快速测试   ║'));
+  console.log(chalk.blue.bold('╚════════════════════════════════════════╝\n'));
+
+  try {
+    // 1. 健康检查
+    console.log(chalk.cyan('1. 健康检查...'));
+    const health = await get('/health');
+    console.log(chalk.green(`   ✓ 状态: ${health.status}\n`));
+
+    // 2. 启动工作流
+    console.log(chalk.cyan('2. 启动工作流...'));
+    const workflowId = 'test-' + Date.now();
+    const startResult = await post('/workflow/start', {
+      workflowId: workflowId,
+      context: {}
+    });
+
+    if (!startResult.success) {
+      throw new Error('工作流启动失败');
+    }
+
+    console.log(chalk.green(`   ✓ 工作流: ${startResult.workflowName}`));
+    console.log(chalk.gray(`   - ID: ${startResult.workflowId}`));
+    console.log(chalk.gray(`   - 总步骤: ${startResult.totalSteps}`));
+    console.log(chalk.gray(`   - 第一步: ${startResult.firstStep.stepId}`));
+    console.log(chalk.gray(`   - 智能体: ${startResult.firstStep.agent || '未指定'}\n`));
+
+    // 3. 查询状态
+    console.log(chalk.cyan('3. 查询初始状态...'));
+    const status1 = await get('/workflow/status');
+    console.log(chalk.green(`   ✓ 状态: ${status1.status}`));
+    console.log(chalk.gray(`   - 当前步骤: ${status1.currentStep}`));
+    console.log(chalk.gray(`   - 进度: ${status1.currentStepIndex}/${status1.totalSteps}\n`));
+
+    // 4. 完成多个步骤
+    console.log(chalk.cyan('4. 模拟完成所有步骤...\n'));
+
+    let hasNext = true;
+    let completedCount = 0;
+
+    while (hasNext) {
+      const currentStatus = await get('/workflow/status');
+      const currentStepId = currentStatus.currentStep;
+
+      console.log(chalk.yellow(`   步骤 ${completedCount + 1}: ${currentStepId}`));
+
+      const completeResult = await post('/workflow/step-complete', {
+        workflowId: workflowId,
+        stepId: currentStepId,
+        status: 'completed',
+        outputs: [],  // 简化:不检查输出
+        duration: 5000
+      });
+
+      completedCount++;
+
+      if (completeResult.hasNextStep) {
+        console.log(chalk.green(`      ✓ 完成 (进度: ${completeResult.progress.percentComplete}%)`));
+        hasNext = true;
+      } else {
+        console.log(chalk.green.bold(`      ✓ 完成 - 工作流全部完成!\n`));
+        hasNext = false;
+
+        // 显示摘要
+        const summary = completeResult.summary;
+        console.log(chalk.cyan('5. 工作流完成摘要:'));
+        console.log(chalk.green(`   ✓ 工作流名称: ${summary.workflowName}`));
+        console.log(chalk.gray(`   - 总耗时: ${summary.totalDurationFormatted}`));
+        console.log(chalk.gray(`   - 完成步骤: ${summary.totalSteps}`));
+        console.log(chalk.gray(`   - 错误数: ${summary.errors}`));
+
+        if (summary.outputs.length > 0) {
+          console.log(chalk.gray(`   - 输出文件: ${summary.outputs.length}个`));
+          summary.outputs.slice(0, 5).forEach(file => {
+            console.log(chalk.gray(`     • ${file}`));
+          });
+          if (summary.outputs.length > 5) {
+            console.log(chalk.gray(`     ... 还有 ${summary.outputs.length - 5} 个文件`));
+          }
+        }
+      }
+    }
+
+    console.log(chalk.green.bold('\n╔════════════════════════════════════════╗'));
+    console.log(chalk.green.bold('║   测试全部通过! ✓   ║'));
+    console.log(chalk.green.bold('╚════════════════════════════════════════╝\n'));
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n❌ 测试失败'));
+    console.error(chalk.red(`错误: ${error.message}\n`));
+
+    if (error.code === 'ECONNREFUSED') {
+      console.log(chalk.yellow('提示: 请确保协调器正在运行'));
+      console.log(chalk.gray('启动命令: node src/index.js start automated-requirements-analysis\n'));
+    }
+
+    process.exit(1);
+  }
+}
+
+main();