risingLee
/
ETest-Vue-FastAPI
1
0
Fork 0
Code Issues 6 Pull Requests Packages Projects Releases Wiki Activity
ETest-Vue-FastAPI/docs/MULTI_AGENT_DEMO.md

588 lines
16 KiB
Markdown
Raw Permalink Normal View History

3-30 更新
2026-03-30 10:38:36 +08:00
# 多 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"
- 确认是否开始
- 等待完成通知