@zeyue0329/xiaoma-cli 1.0.40 → 1.0.42

package/tools/workflow-coordinator/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "xiaoma-workflow-coordinator",
+  "version": "1.0.0",
+  "description": "工作流协调器 - 驱动XiaoMa-CLI工作流自动执行",
+  "main": "src/index.js",
+  "bin": {
+    "xiaoma-coordinator": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "nodemon src/index.js",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [
+    "workflow",
+    "automation",
+    "coordinator"
+  ],
+  "author": "XiaoMa Team",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "fs-extra": "^11.1.1",
+    "js-yaml": "^4.1.0",
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "nodemon": "^3.0.1"
+  }
+}

package/tools/workflow-coordinator/src/api/server.js

@@ -0,0 +1,207 @@
+const express = require('express');
+const cors = require('cors');
+const chalk = require('chalk');
+
+class CoordinatorServer {
+  constructor(controller) {
+    this.app = express();
+    this.controller = controller;
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    this.app.use(express.json({ limit: '50mb' }));
+    this.app.use(cors());
+
+    // 请求日志
+    this.app.use((req, res, next) => {
+      const timestamp = new Date().toISOString();
+      console.log(chalk.gray(`[${timestamp}] ${req.method} ${req.path}`));
+      next();
+    });
+  }
+
+  setupRoutes() {
+    // API: 启动工作流
+    this.app.post('/workflow/start', async (req, res) => {
+      try {
+        const { workflowId, context } = req.body;
+
+        console.log(chalk.cyan(`\n📥 收到启动请求: ${workflowId}`));
+
+        const result = await this.controller.startWorkflow(workflowId, context);
+
+        console.log(chalk.green(`✅ 返回第一步指令: ${result.firstStep.stepId}`));
+        console.log(chalk.gray(`   智能体: ${result.firstStep.agent}`));
+
+        res.json(result);
+      } catch (error) {
+        console.error(chalk.red(`❌ 启动失败: ${error.message}`));
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+
+    // API: 步骤完成回调
+    this.app.post('/workflow/step-complete', async (req, res) => {
+      try {
+        const { workflowId, stepId, status, outputs, duration } = req.body;
+
+        console.log(chalk.cyan(`\n📥 步骤完成: ${stepId}`));
+        console.log(chalk.gray(`   耗时: ${Math.round(duration / 1000)}秒`));
+        console.log(chalk.gray(`   输出: ${outputs.length}个文件`));
+
+        outputs.forEach(output => {
+          const icon = output.exists ? '✓' : '✗';
+          const color = output.exists ? chalk.green : chalk.red;
+          console.log(color(`     ${icon} ${output.file} (${output.size} bytes)`));
+        });
+
+        const result = await this.controller.onStepComplete({
+          workflowId,
+          stepId,
+          status,
+          outputs,
+          duration
+        });
+
+        if (result.hasNextStep) {
+          console.log(chalk.green(`✅ 返回下一步指令: ${result.nextStep.stepId}`));
+          console.log(chalk.yellow(`   进度: ${result.progress.percentComplete}% (${result.progress.currentStepIndex}/${result.progress.totalSteps})`));
+        } else {
+          console.log(chalk.green.bold(`\n🎉 工作流执行完成!\n`));
+          if (result.summary) {
+            console.log(chalk.cyan(`总耗时: ${result.summary.totalDurationFormatted}`));
+            console.log(chalk.cyan(`完成步骤: ${result.summary.totalSteps}`));
+            console.log(chalk.cyan(`生成文档: ${result.summary.outputs.length}个`));
+          }
+        }
+
+        res.json(result);
+      } catch (error) {
+        console.error(chalk.red(`❌ 处理失败: ${error.message}`));
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+
+    // API: 步骤失败回调
+    this.app.post('/workflow/step-failed', async (req, res) => {
+      try {
+        const { workflowId, stepId, error, errorDetails } = req.body;
+
+        console.log(chalk.red(`\n❌ 步骤失败: ${stepId}`));
+        console.log(chalk.red(`   错误: ${error}`));
+
+        const result = await this.controller.onStepFailed({
+          workflowId,
+          stepId,
+          error,
+          errorDetails
+        });
+
+        if (result.action === 'retry') {
+          console.log(chalk.yellow(`⏳ 准备重试: ${result.retryCount}/${result.maxRetries}`));
+        } else if (result.action === 'abort') {
+          console.log(chalk.red.bold(`🚨 工作流中止`));
+          console.log(chalk.red(`   ${result.escalation}`));
+        }
+
+        res.json(result);
+      } catch (error) {
+        console.error(chalk.red(`❌ 处理失败: ${error.message}`));
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+
+    // API: 查询状态
+    this.app.get('/workflow/status', (req, res) => {
+      try {
+        const status = this.controller.getStatus();
+        res.json(status);
+      } catch (error) {
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+
+    // API: 中止工作流
+    this.app.post('/workflow/abort', async (req, res) => {
+      try {
+        const { workflowId, reason } = req.body;
+
+        console.log(chalk.yellow(`\n⏸️  中止工作流: ${reason}`));
+
+        await this.controller.abort(workflowId, reason);
+
+        res.json({
+          success: true,
+          message: '工作流已中止,状态已保存'
+        });
+      } catch (error) {
+        res.status(500).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+
+    // 健康检查
+    this.app.get('/health', (req, res) => {
+      res.json({
+        status: 'ok',
+        timestamp: new Date().toISOString()
+      });
+    });
+
+    // 根路径
+    this.app.get('/', (req, res) => {
+      res.json({
+        name: 'XiaoMa Workflow Coordinator',
+        version: '1.0.0',
+        endpoints: [
+          'POST /workflow/start',
+          'POST /workflow/step-complete',
+          'POST /workflow/step-failed',
+          'GET  /workflow/status',
+          'POST /workflow/abort',
+          'GET  /health'
+        ]
+      });
+    });
+  }
+
+  async start(port) {
+    return new Promise((resolve, reject) => {
+      this.server = this.app.listen(port, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = CoordinatorServer;

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

@@ -0,0 +1,263 @@
+const StateManager = require('../utils/state-manager');
+const Validator = require('../utils/validator');
+
+class WorkflowController {
+  constructor(executionPlan) {
+    this.executionPlan = executionPlan;
+    this.stateManager = new StateManager();
+    this.validator = new Validator();
+    this.state = null;
+  }
+
+  /**
+   * 启动工作流
+   */
+  async startWorkflow(workflowId, context = {}) {
+    // 初始化状态
+    this.state = {
+      workflowId: workflowId,
+      workflowName: this.executionPlan.metadata.name,
+      status: 'in_progress',
+      startTime: new Date().toISOString(),
+      currentStepIndex: 0,
+      completedSteps: [],
+      context: context,
+      errors: [],
+      retries: {}
+    };
+
+    // 保存状态
+    await this.stateManager.save(this.state);
+
+    // 获取第一步
+    const firstStepDef = this.executionPlan.steps[0];
+    const firstStep = this.buildStepInstruction(firstStepDef);
+
+    return {
+      success: true,
+      workflowId: workflowId,
+      workflowName: this.executionPlan.metadata.name,
+      totalSteps: this.executionPlan.steps.length,
+      firstStep: firstStep
+    };
+  }
+
+  /**
+   * 步骤完成回调
+   */
+  async onStepComplete({ workflowId, stepId, status, outputs, duration }) {
+    // 1. 验证步骤输出
+    const stepDef = this.executionPlan.steps[this.state.currentStepIndex];
+    const validationResult = await this.validator.validateOutputs(stepDef, outputs);
+
+    if (!validationResult.passed) {
+      return {
+        success: false,
+        action: 'fix_quality',
+        issues: validationResult.issues,
+        message: '步骤输出质量验证失败,请修复问题后重试'
+      };
+    }
+
+    // 2. 记录完成步骤
+    this.state.completedSteps.push({
+      stepId: stepId,
+      agent: stepDef.agent,
+      status: status,
+      outputs: outputs,
+      duration: duration,
+      completedAt: new Date().toISOString()
+    });
+
+    // 3. 移动到下一步
+    this.state.currentStepIndex++;
+
+    // 4. 保存状态
+    await this.stateManager.save(this.state);
+
+    // 5. 检查是否还有下一步
+    if (this.state.currentStepIndex >= this.executionPlan.steps.length) {
+      // 工作流完成
+      this.state.status = 'completed';
+      this.state.endTime = new Date().toISOString();
+      await this.stateManager.save(this.state);
+
+      return {
+        success: true,
+        hasNextStep: false,
+        message: '🎉 工作流执行完成!',
+        summary: this.generateSummary()
+      };
+    }
+
+    // 6. 获取下一步指令
+    const nextStepDef = this.executionPlan.steps[this.state.currentStepIndex];
+    const nextStep = this.buildStepInstruction(nextStepDef);
+
+    return {
+      success: true,
+      hasNextStep: true,
+      nextStep: nextStep,
+      progress: {
+        currentStepIndex: this.state.currentStepIndex + 1,
+        totalSteps: this.executionPlan.steps.length,
+        percentComplete: Math.round(((this.state.currentStepIndex + 1) / this.executionPlan.steps.length) * 100)
+      }
+    };
+  }
+
+  /**
+   * 步骤失败回调
+   */
+  async onStepFailed({ workflowId, stepId, error, errorDetails }) {
+    const stepDef = this.executionPlan.steps[this.state.currentStepIndex];
+
+    // 记录错误
+    this.state.errors.push({
+      stepId: stepId,
+      error: error,
+      errorDetails: errorDetails,
+      timestamp: new Date().toISOString()
+    });
+
+    // 检查是否可以重试
+    const maxRetries = stepDef.onFailure?.max_retries || 3;
+    const currentRetries = this.state.retries[stepId] || 0;
+
+    if (currentRetries < maxRetries) {
+      // 可以重试
+      this.state.retries[stepId] = currentRetries + 1;
+      await this.stateManager.save(this.state);
+
+      const retryStep = this.buildStepInstruction(stepDef);
+
+      return {
+        success: true,
+        action: 'retry',
+        retryCount: currentRetries + 1,
+        maxRetries: maxRetries,
+        retryStep: retryStep,
+        message: `将进行第 ${currentRetries + 1} 次重试`
+      };
+    } else {
+      // 达到最大重试次数,中止工作流
+      this.state.status = 'failed';
+      this.state.endTime = new Date().toISOString();
+      await this.stateManager.save(this.state);
+
+      return {
+        success: false,
+        action: 'abort',
+        message: `步骤 "${stepId}" 执行失败,已达最大重试次数`,
+        escalation: stepDef.onFailure?.escalation || '需要人工介入'
+      };
+    }
+  }
+
+  /**
+   * 构建步骤执行指令
+   */
+  buildStepInstruction(stepDef) {
+    // 从 detailed_steps 中提取命令和提示词
+    const detailedSteps = stepDef.detailedSteps || [];
+
+    // 找到第一个命令步骤(非智能体切换)
+    const commandStep = detailedSteps.find(ds =>
+      ds.command && ds.command.startsWith('*')
+    );
+
+    // 找到智能体切换步骤
+    const agentSwitchStep = detailedSteps.find(ds =>
+      ds.command && ds.command.startsWith('/')
+    );
+
+    return {
+      stepId: stepDef.id,
+      stepDescription: stepDef.description,
+      agent: stepDef.agent,
+      switchCommand: agentSwitchStep?.command || `/agent ${stepDef.agent}`,
+      executeCommand: commandStep?.command || '',
+      prompt: commandStep?.prompt_template || '',
+      inputFiles: stepDef.requires || [],
+      expectedOutputs: stepDef.outputs || [],
+      detailedSteps: detailedSteps,
+      estimatedDuration: stepDef.duration
+    };
+  }
+
+  /**
+   * 生成完成摘要
+   */
+  generateSummary() {
+    const totalDuration = this.state.completedSteps.reduce((sum, step) => sum + (step.duration || 0), 0);
+    const allOutputs = this.state.completedSteps.flatMap(step => step.outputs || []);
+
+    return {
+      workflowId: this.state.workflowId,
+      workflowName: this.state.workflowName,
+      status: this.state.status,
+      startTime: this.state.startTime,
+      endTime: this.state.endTime,
+      totalDuration: totalDuration,
+      totalDurationFormatted: this.formatDuration(totalDuration),
+      totalSteps: this.state.completedSteps.length,
+      outputs: allOutputs.map(o => o.file),
+      errors: this.state.errors.length
+    };
+  }
+
+  /**
+   * 格式化时长
+   */
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}小时${minutes % 60}分钟`;
+    } else if (minutes > 0) {
+      return `${minutes}分钟${seconds % 60}秒`;
+    } else {
+      return `${seconds}秒`;
+    }
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    if (!this.state) {
+      return {
+        status: 'not_started',
+        message: '协调器已启动,等待工作流开始'
+      };
+    }
+
+    return {
+      workflowId: this.state.workflowId,
+      workflowName: this.state.workflowName,
+      status: this.state.status,
+      currentStepIndex: this.state.currentStepIndex + 1,
+      totalSteps: this.executionPlan.steps.length,
+      completedSteps: this.state.completedSteps.map(s => s.stepId),
+      currentStep: this.executionPlan.steps[this.state.currentStepIndex]?.id,
+      errors: this.state.errors.length,
+      startTime: this.state.startTime
+    };
+  }
+
+  /**
+   * 中止工作流
+   */
+  async abort(workflowId, reason) {
+    if (this.state) {
+      this.state.status = 'aborted';
+      this.state.abortReason = reason;
+      this.state.endTime = new Date().toISOString();
+      await this.stateManager.save(this.state);
+    }
+  }
+}
+
+module.exports = WorkflowController;

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

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const chalk = require('chalk');
+const WorkflowParser = require('./parser/workflow-parser');
+const WorkflowController = require('./controller/workflow-controller');
+const CoordinatorServer = require('./api/server');
+
+require('dotenv').config();
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const workflowName = args[1];
+
+  console.log(chalk.blue.bold('\n╔════════════════════════════════════════╗'));
+  console.log(chalk.blue.bold('║   XiaoMa 工作流协调器   ║'));
+  console.log(chalk.blue.bold('╚════════════════════════════════════════╝\n'));
+
+  if (command === 'start' && workflowName) {
+    try {
+      // 1. 解析工作流
+      console.log(chalk.cyan(`📋 解析工作流: ${workflowName}`));
+      const parser = new WorkflowParser();
+      const executionPlan = await parser.parse(workflowName);
+
+      console.log(chalk.green(`✅ 工作流解析完成`));
+      console.log(chalk.gray(`   名称: ${executionPlan.metadata.name}`));
+      console.log(chalk.gray(`   步骤数: ${executionPlan.steps.length}`));
+      console.log(chalk.gray(`   类型: ${executionPlan.metadata.type}`));
+
+      // 2. 创建控制器
+      const controller = new WorkflowController(executionPlan);
+
+      // 3. 启动HTTP服务
+      console.log(chalk.cyan(`\n🌐 启动HTTP服务...`));
+      const server = new CoordinatorServer(controller);
+      const port = process.env.COORDINATOR_PORT || 3001;
+
+      await server.start(port);
+
+      console.log(chalk.green.bold(`✅ HTTP服务已启动: http://localhost:${port}\n`));
+
+      console.log(chalk.yellow(`⏳ 等待Claude Code连接...\n`));
+      console.log(chalk.gray(`提示: 在Claude Code中执行以下命令启动工作流:\n`));
+      console.log(chalk.cyan(`  /workflow-helper`));
+      console.log(chalk.cyan(`  *start-workflow ${workflowName}\n`));
+
+      console.log(chalk.gray(`按 Ctrl+C 停止协调器\n`));
+
+      // 处理退出信号
+      process.on('SIGINT', async () => {
+        console.log(chalk.yellow(`\n\n⏸️  收到停止信号,正在关闭...`));
+        await server.stop();
+        console.log(chalk.green(`✅ 协调器已停止\n`));
+        process.exit(0);
+      });
+
+    } catch (error) {
+      console.error(chalk.red.bold(`\n❌ 启动失败\n`));
+      console.error(chalk.red(`错误: ${error.message}\n`));
+
+      if (error.message.includes('工作流文件未找到')) {
+        console.log(chalk.yellow(`提示: 请确认工作流文件存在于 xiaoma-core/workflows/ 目录下\n`));
+        console.log(chalk.gray(`可用的工作流文件应该是:\n`));
+        console.log(chalk.gray(`  - requirements-analysis.yaml`));
+        console.log(chalk.gray(`  - story-development.yaml`));
+        console.log(chalk.gray(`  - 或其他 .yaml 文件\n`));
+      }
+
+      process.exit(1);
+    }
+
+  } else if (command === 'test-api') {
+    // 测试API端点
+    console.log(chalk.cyan(`🧪 API端点测试模式\n`));
+    console.log(chalk.gray(`启动简单的测试服务器...\n`));
+
+    const express = require('express');
+    const app = express();
+    app.use(express.json());
+
+    app.post('/workflow/start', (req, res) => {
+      console.log(chalk.green(`✓ 收到 /workflow/start 请求`));
+      console.log(chalk.gray(`  请求体: ${JSON.stringify(req.body, null, 2)}`));
+      res.json({ success: true, message: 'Test OK' });
+    });
+
+    const port = process.env.COORDINATOR_PORT || 3001;
+    app.listen(port, () => {
+      console.log(chalk.green(`✅ 测试服务器运行在 http://localhost:${port}\n`));
+      console.log(chalk.gray(`测试命令:`));
+      console.log(chalk.cyan(`  curl -X POST http://localhost:${port}/workflow/start -H "Content-Type: application/json" -d '{"workflowId":"test"}'\n`));
+    });
+
+  } else {
+    // 显示帮助
+    console.log(chalk.gray('用法:\n'));
+    console.log(chalk.white('  xiaoma-coordinator start <workflow-name>'));
+    console.log(chalk.gray('    启动工作流协调器\n'));
+    console.log(chalk.white('  xiaoma-coordinator test-api'));
+    console.log(chalk.gray('    启动API测试服务器\n'));
+    console.log(chalk.gray('示例:\n'));
+    console.log(chalk.cyan('  xiaoma-coordinator start requirements-analysis'));
+    console.log(chalk.cyan('  xiaoma-coordinator start story-development\n'));
+  }
+}
+
+main().catch(error => {
+  console.error(chalk.red(`\n❌ 未处理的错误: ${error.message}\n`));
+  console.error(error.stack);
+  process.exit(1);
+});