# 多 Agent 协作演示 - 工单自动领取功能开发

## 用户指令

```
用户: @FeiBot 开始开发ETest的工单自动领取功能
```

---

## Step 1: Orchestrator 接收指令

**Orchestrator Agent 执行：**

```python
def on_user_request(request: str):
    # 1. 解析用户意图
    intent = parse_intent(request)
    # 结果: task="工单自动领取", type="new_feature"
    
    # 2. 读取项目配置
    config = read_json("C:\\PPRO\\ETest-Vue-FastAPI\\.openclaw\\skill-project.json")
    
    # 3. 读取当前状态
    handover = read_file("C:\\PPRO\\ETest-Vue-FastAPI\\docs\\AGENT_HANDOVER.md")
    
    # 4. 确定工作流程
    workflow = config['workflows']['new_feature']
    
    # 5. 分析依赖关系
    # 架构 → 数据库 → 后端 → 前端
    
    return plan
```

**Orchestrator 输出：**

```
📋 任务分析完成

任务: 开发工单自动领取功能
类型: 新功能开发
预计需要: 3 个 Agent 协作
预计时间: 2-3 小时

🔄 工作流程:
Phase 1: Architect Agent 设计架构 (30分钟)
    ├── 设计数据模型 (test_permission, work_order扩展)
    ├── 设计接口契约 (claim API)
    └── 输出: DATA_MODEL.md, API_CONTRACT.md

Phase 2: Backend Agent 实现后端 (60分钟)
    ├── 创建数据库迁移脚本
    ├── 实现 test_permission 实体和DAO
    ├── 实现工单领取 API
    └── 输出: 后端代码 + 迁移脚本

Phase 3: Frontend Agent 实现前端 (45分钟)
    ├── 实现工单池页面
    ├── 实现领取按钮和逻辑
    └── 输出: 前端页面

是否开始执行？ (是/否/调整)
```

---

## Step 2: 用户确认

```
用户: 是
```

---

## Step 3: 启动 Architect Agent

**Orchestrator 生成 Architect Agent 配置：**

```json
{
  "agent_id": "etest-architect-001",
  "role": "architect",
  "skill": "software-architect-etest",
  "task": "设计工单自动领取功能的架构",
  "system_prompt": """
你是 ETest 项目的架构师 Agent。

任务: 设计工单自动领取功能的架构

使用的 Skill: software-architect-etest

必须首先阅读的上下文文件:
1. C:\PPRO\ETest-Vue-FastAPI\docs\README.md - 项目概览
2. C:\PPRO\ETest-Vue-FastAPI\docs\AGENT_HANDOVER.md - 当前状态
3. C:\PPRO\ETest-Vue-FastAPI\references\etest-detailed-design.md - 详细设计
4. C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-backend\module_admin\entity\do\test_work_order_do.py - 现有工单实体

输出文件:
- C:\PPRO\ETest-Vue-FastAPI\docs\DATA_MODEL.md - 更新的数据模型
- C:\PPRO\ETest-Vue-FastAPI\docs\API_CONTRACT.md - 接口定义

设计要求:
1. 保持向后兼容 (现有字段不变，新增字段可空)
2. 支持权限矩阵 (test_permission 表)
3. 实现乐观锁防止并发冲突
4. 排序规则: 优先级高 > 截止日期近

完成后:
1. 更新 docs/AGENT_HANDOVER.md 记录进度
2. 通知 Orchestrator: "架构设计完成"

开始工作前，先读取所有上下文文件，然后回复:"已读取上下文，开始设计架构"。
""",
  "context_files": [
    "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\README.md",
    "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\AGENT_HANDOVER.md",
    "C:\\PPRO\\ETest-Vue-FastAPI\\references\\etest-detailed-design.md",
    "C:\\PPRO\\ETest-Vue-FastAPI\\ruoyi-fastapi-backend\\module_admin\\entity\\do\\test_work_order_do.py"
  ],
  "output_files": [
    "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\DATA_MODEL.md",
    "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\API_CONTRACT.md"
  ]
}
```

**Orchestrator 启动 Architect Agent：**

```python
architect_agent = sessions_spawn(
    task="设计工单自动领取功能架构",
    agent_id="software-architect-etest",
    system_prompt=system_prompt,
    mode="session",
    label="etest-architect-001"
)
```

**Orchestrator 通知用户：**

```
🚀 已启动 Architect Agent (etest-architect-001)

正在执行:
- 读取项目上下文...
- 分析现有代码结构...
- 设计数据模型...
- 定义接口契约...

预计完成: 30分钟
你可以随时询问进度。
```

---

## Step 4: Architect Agent 工作

**Architect Agent 自动执行：**

```python
def agent_startup():
    # 1. 读取所有上下文文件
    context = {}
    for file in context_files:
        context[file] = read_file(file)
    
    # 2. 分析现有实体
    work_order_entity = parse_python_entity("test_work_order_do.py")
    
    # 3. 设计数据模型
    data_model = design_data_model(
        existing=work_order_entity,
        requirements="工单自动领取",
        constraints=["向后兼容", "乐观锁"]
    )
    
    # 4. 生成文档
    write_file("docs/DATA_MODEL.md", data_model)
    
    # 5. 设计接口
    api_contract = design_api([
        "POST /workorders/claim",
        "PUT /workorders/{id}/priority",
        "PUT /workorders/{id}/expected-date"
    ])
    
    # 6. 生成文档
    write_file("docs/API_CONTRACT.md", api_contract)
    
    # 7. 更新交接记录
    update_handover({
        "task": "架构设计",
        "status": "已完成",
        "output": ["DATA_MODEL.md", "API_CONTRACT.md"]
    })
    
    # 8. 通知 Orchestrator
    return "架构设计完成"
```

**Architect Agent 输出：**

```
✅ 架构设计完成

已生成:
1. docs/DATA_MODEL.md
   - test_permission 表设计
   - work_order 表扩展 (priority, expected_finish_date, claimed_by, etc.)
   - 索引设计

2. docs/API_CONTRACT.md
   - POST /api/v1/workorders/claim - 领取工单
   - PUT /api/v1/workorders/{id}/priority - 调整优先级
   - PUT /api/v1/workorders/{id}/expected-date - 修改截止日期
   - GET /api/v1/workorders/pending - 获取待领取列表

设计要点:
- 向后兼容: 所有新增字段允许 NULL
- 乐观锁: 使用 version 字段或状态检查
- 排序: ORDER BY priority DESC, expected_finish_date ASC

等待 Backend Agent 接手...
```

---

## Step 5: Orchestrator 启动 Backend Agent

**收到 Architect 完成通知后：**

```python
def on_agent_complete(agent_id: str, result: dict):
    if agent_id == "etest-architect-001":
        # 架构完成，启动 Backend Agent
        backend_config = {
            "agent_id": "etest-backend-001",
            "role": "backend",
            "skill": "fastapi-crud",
            "task": "实现工单自动领取后端功能",
            "system_prompt": """
你是 ETest 项目的后端开发 Agent。

任务: 实现工单自动领取后端功能

使用的 Skill: fastapi-crud

必须首先阅读的上下文文件:
1. C:\PPRO\ETest-Vue-FastAPI\docs\API_CONTRACT.md - 接口定义
2. C:\PPRO\ETest-Vue-FastAPI\docs\DATA_MODEL.md - 数据模型
3. C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-backend\module_admin\entity\do\test_work_order_do.py - 现有实体

输出文件:
- C:\PPRO\ETest-Vue-FastAPI\sql\migration\add_workorder_claim.sql - 迁移脚本
- C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-backend\module_admin\entity\do\test_permission_do.py - 权限实体
- C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-backend\module_admin\controller\work_order_controller.py - 控制器
- C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-backend\module_admin\service\work_order_service.py - 服务层

实现要求:
1. 使用若依框架的 BaseController 模式
2. 实现乐观锁 (UPDATE ... WHERE tester_id IS NULL)
3. 添加详细的错误处理
4. 遵循现有代码风格

完成后:
1. 更新 docs/AGENT_HANDOVER.md
2. 通知 Orchestrator: "后端开发完成"
""",
            "context_files": [
                "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\API_CONTRACT.md",
                "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\DATA_MODEL.md",
                "C:\\PPRO\\ETest-Vue-FastAPI\\ruoyi-fastapi-backend\\module_admin\\entity\\do\\test_work_order_do.py"
            ]
        }
        
        spawn_agent(backend_config)
```

**Orchestrator 通知用户：**

```
✅ Architect Agent 完成

🚀 已启动 Backend Agent (etest-backend-001)

正在执行:
- 创建数据库迁移脚本...
- 实现 test_permission 实体...
- 实现工单领取 API...

预计完成: 60分钟
```

---

## Step 6: Backend Agent 工作

**Backend Agent 自动执行：**

```python
def implement_backend():
    # 1. 读取接口定义
    api_contract = read_file("docs/API_CONTRACT.md")
    
    # 2. 生成迁移脚本
    migration_sql = generate_migration([
        "test_permission 表",
        "work_order 扩展字段",
        "索引"
    ])
    write_file("sql/migration/add_workorder_claim.sql", migration_sql)
    
    # 3. 生成实体
    permission_entity = generate_entity("TestPermission", fields=[...])
    write_file("module_admin/entity/do/test_permission_do.py", permission_entity)
    
    # 4. 生成 DAO
    permission_dao = generate_dao("TestPermission")
    write_file("module_admin/dao/test_permission_dao.py", permission_dao)
    
    # 5. 生成 Service
    workorder_service = generate_service([
        "claim_workorder",
        "update_priority",
        "update_expected_date",
        "get_pending_list"
    ])
    write_file("module_admin/service/work_order_service.py", workorder_service)
    
    # 6. 生成 Controller
    workorder_controller = generate_controller([
        "POST /workorders/claim",
        "PUT /workorders/{id}/priority",
        "PUT /workorders/{id}/expected-date",
        "GET /workorders/pending"
    ])
    write_file("module_admin/controller/work_order_controller.py", workorder_controller)
    
    # 7. 更新交接记录
    update_handover({
        "task": "后端开发",
        "status": "已完成",
        "output": [
            "sql/migration/add_workorder_claim.sql",
            "module_admin/entity/do/test_permission_do.py",
            "module_admin/service/work_order_service.py",
            "module_admin/controller/work_order_controller.py"
        ]
    })
    
    return "后端开发完成"
```

**Backend Agent 输出：**

```
✅ 后端开发完成

已生成:
1. sql/migration/add_workorder_claim.sql
   - 创建 test_permission 表
   - 扩展 test_work_order 表
   - 创建索引

2. module_admin/entity/do/test_permission_do.py
   - TestPermission 实体

3. module_admin/dao/test_permission_dao.py
   - TestPermissionDao 数据访问

4. module_admin/service/work_order_service.py
   - claim_workorder() - 领取工单（乐观锁）
   - update_priority() - 调整优先级
   - update_expected_date() - 修改截止日期
   - get_pending_list() - 获取待领取列表

5. module_admin/controller/work_order_controller.py
   - 4个API端点
   - 完整的错误处理

等待 Frontend Agent 接手...
```

---

## Step 7: Orchestrator 启动 Frontend Agent

```python
def on_agent_complete(agent_id: str, result: dict):
    if agent_id == "etest-backend-001":
        # 后端完成，启动 Frontend Agent
        frontend_config = {
            "agent_id": "etest-frontend-001",
            "role": "frontend",
            "skill": "vue-component",
            "task": "实现工单自动领取前端页面",
            "system_prompt": """
你是 ETest 项目的前端开发 Agent。

任务: 实现工单自动领取前端页面

使用的 Skill: vue-component

必须首先阅读的上下文文件:
1. C:\PPRO\ETest-Vue-FastAPI\docs\API_CONTRACT.md - 接口定义
2. C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-frontend\src\views\ - 现有页面参考

输出文件:
- C:\PPRO\ETest-Vue-FastAPI\ruoyi-fastapi-frontend\src\views\workorder\claim\index.vue - 工单池页面

实现要求:
1. 使用 Element Plus 组件
2. 实现工单列表（按优先级排序）
3. 实现领取按钮（带乐观锁提示）
4. 遵循若依前端框架规范

完成后:
1. 更新 docs/AGENT_HANDOVER.md
2. 通知 Orchestrator: "前端开发完成"
""",
            "context_files": [
                "C:\\PPRO\\ETest-Vue-FastAPI\\docs\\API_CONTRACT.md"
            ]
        }
        
        spawn_agent(frontend_config)
```

**Orchestrator 通知用户：**

```
✅ Backend Agent 完成

🚀 已启动 Frontend Agent (etest-frontend-001)

正在执行:
- 实现工单池页面...
- 实现领取按钮...

预计完成: 45分钟
```

---

## Step 8: Frontend Agent 工作

**Frontend Agent 自动执行：**

```python
def implement_frontend():
    # 1. 读取接口定义
    api_contract = read_file("docs/API_CONTRACT.md")
    
    # 2. 生成页面
    page_vue = generate_vue_page({
        "name": "WorkOrderClaim",
        "components": ["ElTable", "ElButton", "ElTag"],
        "api_calls": [
            "GET /workorders/pending",
            "POST /workorders/claim"
        ],
        "features": [
            "按优先级排序显示",
            "显示截止日期",
            "领取按钮（乐观锁处理）",
            "领取成功/失败提示"
        ]
    })
    
    # 3. 生成路由配置
    route_config = generate_route({
        "path": "/workorder/claim",
        "component": "WorkOrderClaim",
        "meta": {"title": "工单领取"}
    })
    
    # 4. 写入文件
    write_file("ruoyi-fastapi-frontend/src/views/workorder/claim/index.vue", page_vue)
    append_file("ruoyi-fastapi-frontend/src/router/index.js", route_config)
    
    # 5. 更新交接记录
    update_handover({
        "task": "前端开发",
        "status": "已完成",
        "output": [
            "ruoyi-fastapi-frontend/src/views/workorder/claim/index.vue"
        ]
    })
    
    return "前端开发完成"
```

**Frontend Agent 输出：**

```
✅ 前端开发完成

已生成:
1. ruoyi-fastapi-frontend/src/views/workorder/claim/index.vue
   - 工单池列表（按优先级排序）
   - 显示优先级标签（颜色区分）
   - 显示预计完成日期
   - 领取按钮（带加载状态）
   - 乐观锁冲突提示

2. 路由配置已更新
   - /workorder/claim

等待最终确认...
```

---

## Step 9: Orchestrator 汇总完成

```python
def on_agent_complete(agent_id: str, result: dict):
    if agent_id == "etest-frontend-001":
        # 所有 Agent 完成
        final_report = generate_final_report()
        notify_user(final_report)
```

**Orchestrator 最终报告：**

```
🎉 工单自动领取功能开发完成！

✅ 所有 Agent 工作完成

📊 工作统计:
┌─────────────┬──────────┬──────────┐
│ Agent       │ 耗时     │ 输出文件 │
├─────────────┼──────────┼──────────┤
│ Architect   │ 25分钟   │ 2个      │
│ Backend     │ 55分钟   │ 5个      │
│ Frontend    │ 40分钟   │ 1个      │
├─────────────┼──────────┼──────────┤
│ 总计        │ 2小时    │ 8个      │
└─────────────┴──────────┴──────────┘

📁 生成的文件:
1. docs/DATA_MODEL.md
2. docs/API_CONTRACT.md
3. sql/migration/add_workorder_claim.sql
4. module_admin/entity/do/test_permission_do.py
5. module_admin/dao/test_permission_dao.py
6. module_admin/service/work_order_service.py
7. module_admin/controller/work_order_controller.py
8. ruoyi-fastapi-frontend/src/views/workorder/claim/index.vue

📋 下一步建议:
1. 执行数据库迁移: mysql < sql/migration/add_workorder_claim.sql
2. 重启后端服务
3. 访问 http://localhost/workorder/claim 测试

📝 文档已更新:
- docs/AGENT_HANDOVER.md
- docs/CHANGELOG.md

是否需要我执行数据库迁移？
```

---

## 总结

**完整流程：**

1. **用户** → "开始开发工单领取功能"
2. **Orchestrator** → 分析任务、规划 Agent
3. **Architect Agent** → 设计架构（30分钟）
4. **Backend Agent** → 实现后端（60分钟）
5. **Frontend Agent** → 实现前端（45分钟）
6. **Orchestrator** → 汇总报告

**关键机制：**
- 每个 Agent 自动加载所需上下文
- Orchestrator 按依赖顺序启动 Agent
- 每个 Agent 完成后更新 AGENT_HANDOVER.md
- 用户随时可查看进度

**用户只需要：**
- 说一句话"开始开发xxx"
- 确认是否开始
- 等待完成通知