ETest-Vue-FastAPI/docs/MULTI_AGENT_DEMO.md

588 lines
16 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

# 多 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"
- 确认是否开始
- 等待完成通知