摘要
BMAD-METHOD框架的任务系统是其实现自动化工作流的核心引擎，通过定义标准化的任务模板和执行流程，确保各个AI代理能够按照预设的步骤完成复杂的工作。任务系统不仅规范了代理的行为，还提供了灵活的扩展机制，支持不同场景下的定制化需求。本文将深入分析BMAD-METHOD的任务系统，探讨其设计理念、结构组成、执行机制以及在实际开发中的应用。
正文
1. 引言
在AI辅助的软件开发过程中，如何确保各个代理按照既定的流程和标准执行任务是一个关键挑战。BMAD-METHOD框架通过其创新的任务系统解决了这一问题，为AI代理提供了明确的行动指南和执行标准。
任务系统的核心价值包括：
- 标准化执行：通过预定义的任务模板确保操作的一致性
- 流程自动化：将复杂的工作流程分解为可执行的任务序列
- 质量保障：通过任务约束和检查机制确保输出质量
- 可扩展性：支持任务的定制和扩展以适应不同需求
- 协作协调：通过任务依赖关系协调多个代理的协作
2. 任务系统架构设计
BMAD-METHOD的任务系统采用分层架构设计，由任务定义、任务执行和任务管理三个核心层组成。
2.1 任务定义层
任务定义层负责定义任务的结构、内容和执行要求。
# 任务定义示例
task-definition:
name: "create-next-story"
version: "1.0"
description: "创建下一个开发故事"
author: "BMAD Team"
dependencies:
- "story-tmpl.yaml"
- "core-config.yaml"
parameters:
- name: "epic_file"
type: "string"
required: true
description: "史诗文件路径"
- name: "architecture_docs"
type: "object"
required: true
description: "架构文档"
steps:
- "加载核心配置"
- "识别下一个故事"
- "收集故事需求"
- "收集架构上下文"
- "验证项目结构"
- "填充故事模板"
- "完成故事草稿"
2.2 任务执行层
任务执行层负责按照任务定义执行具体的操作。
class TaskExecutor:
def __init__(self):
self.task_registry = {}
def register_task(self, task_name, task_class):
"""
注册任务
"""
self.task_registry[task_name] = task_class
def execute_task(self, task_name, parameters):
"""
执行任务
"""
if task_name not in self.task_registry:
raise Exception(f"任务未找到: {task_name}")
task_class = self.task_registry[task_name]
task_instance = task_class()
return task_instance.execute(parameters)
2.3 任务管理层
任务管理层负责任务的调度、监控和协调。
class TaskManager:
def __init__(self):
self.executor = TaskExecutor()
self.task_queue = []
self.running_tasks = []
def schedule_task(self, task_name, parameters, priority=0):
"""
调度任务
"""
task = {
"name": task_name,
"parameters": parameters,
"priority": priority,
"status": "pending"
}
# 按优先级插入队列
self.insert_by_priority(task)
def run_next_task(self):
"""
运行下一个任务
"""
if not self.task_queue:
return None
task = self.task_queue.pop(0)
task["status"] = "running"
self.running_tasks.append(task)
try:
result = self.executor.execute_task(task["name"], task["parameters"])
task["status"] = "completed"
task["result"] = result
except Exception as e:
task["status"] = "failed"
task["error"] = str(e)
self.running_tasks.remove(task)
return task
3. 核心任务详解
BMAD-METHOD框架包含多个核心任务，每个任务都有其特定的职责和执行流程。
3.1 文档创建任务（create-doc）
[create-doc.md](file:///e%3A/Dify/BMAD-METHOD/common/tasks/create-doc.md)是任务系统中最核心的任务之一，负责根据模板创建各种文档。
class CreateDocTask:
def __init__(self):
self.template_processor = TemplateProcessor()
self.ai_processor = AIInstructionProcessor()
def execute(self, parameters):
"""
执行文档创建任务
"""
# 1. 验证参数
self.validate_parameters(parameters)
# 2. 加载模板
template = self.load_template(parameters["template"])
# 3. 处理模板变量
processed_content = self.template_processor.replace_placeholders(
template["content"],
parameters["variables"]
)
# 4. 执行AI指令
processed_content = self.ai_processor.process_instructions(
processed_content,
parameters["context"]
)
# 5. 保存文档
self.save_document(parameters["output_path"], processed_content)
return {
"status": "success",
"document_path": parameters["output_path"],
"content": processed_content
}
3.2 故事创建任务（create-next-story）
[create-next-story.md](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/create-next-story.md)负责创建下一个开发故事，是开发流程中的关键任务。
class CreateNextStoryTask:
def __init__(self):
self.config_loader = ConfigLoader()
self.story_creator = StoryCreator()
def execute(self, parameters):
"""
执行创建下一个故事任务
"""
# 1. 加载核心配置
config = self.config_loader.load_core_config()
# 2. 识别下一个故事
next_story_info = self.identify_next_story(
config["prd_sharded_location"],
config["dev_story_location"]
)
# 3. 收集故事需求和上下文
story_requirements = self.gather_requirements(next_story_info)
architecture_context = self.gather_architecture_context(config)
# 4. 验证项目结构
self.verify_project_structure(architecture_context)
# 5. 创建故事
story = self.story_creator.create_story(
next_story_info,
story_requirements,
architecture_context
)
# 6. 保存故事文件
story_path = f"{config['dev_story_location']}/{next_story_info['epic']}.{next_story_info['story']}.story.md"
self.save_story(story_path, story)
# 7. 执行检查清单
self.execute_checklist("story-draft-checklist.md", story)
return {
"status": "success",
"story_path": story_path,
"story": story
}
3.3 文档分片任务（shard-doc）
[shard-doc.md](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/shard-doc.md)负责将大型文档分片为更小的单元，便于管理和使用。
class ShardDocTask:
def __init__(self):
self.doc_parser = DocumentParser()
self.shard_creator = ShardCreator()
def execute(self, parameters):
"""
执行文档分片任务
"""
# 1. 加载文档
document = self.doc_parser.load_document(parameters["document_path"])
# 2. 解析文档结构
sections = self.doc_parser.parse_sections(document)
# 3. 创建分片
shards = []
for section in sections:
shard = self.shard_creator.create_shard(
section,
parameters["output_directory"]
)
shards.append(shard)
# 4. 创建索引文件
index_file = self.create_index_file(shards, parameters["output_directory"])
return {
"status": "success",
"shards": shards,
"index_file": index_file
}
3.4 故事审查任务（review-story）
[review-story.md](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/review-story.md)负责对已完成的故事进行审查和质量评估。
class ReviewStoryTask:
def __init__(self):
self.qa_analyzer = QAAnalyzer()
self.gate_creator = GateCreator()
def execute(self, parameters):
"""
执行故事审查任务
"""
# 1. 加载故事文件
story = self.load_story(parameters["story_path"])
# 2. 验证故事状态
if story["status"] != "Ready for Review":
raise Exception("故事状态必须为'Ready for Review'")
# 3. 进行全面分析
analysis_results = self.qa_analyzer.analyze_story(story)
# 4. 主动重构（如果需要）
if analysis_results["needs_refactoring"]:
story = self.qa_analyzer.refactor_story(story)
# 5. 合规性检查
compliance_results = self.qa_analyzer.check_compliance(story)
# 6. 验收标准验证
ac_validation = self.qa_analyzer.validate_acceptance_criteria(story)
# 7. 生成审查结果
review_results = {
"analysis": analysis_results,
"compliance": compliance_results,
"ac_validation": ac_validation
}
# 8. 更新故事文件
self.update_story_with_results(story, review_results)
# 9. 创建质量门文件
gate_file = self.gate_creator.create_gate_file(
story,
review_results,
parameters["gate_location"]
)
return {
"status": "success",
"review_results": review_results,
"gate_file": gate_file
}
4. 任务执行机制
BMAD-METHOD的任务执行机制确保任务能够按照预定义的流程正确执行。
4.1 参数验证机制
class ParameterValidator:
def __init__(self):
self.validators = {
"string": self.validate_string,
"number": self.validate_number,
"boolean": self.validate_boolean,
"object": self.validate_object,
"array": self.validate_array
}
def validate_parameters(self, parameters, schema):
"""
验证参数
"""
errors = []
for param_name, param_schema in schema.items():
if param_schema.get("required", False) and param_name not in parameters:
errors.append(f"缺少必需参数: {param_name}")
continue
if param_name in parameters:
param_value = parameters[param_name]
param_type = param_schema["type"]
if not self.validators[param_type](param_value):
errors.append(f"参数 {param_name} 类型不正确")
if errors:
raise Exception(f"参数验证失败: {', '.join(errors)}")
return True
def validate_string(self, value):
return isinstance(value, str)
def validate_number(self, value):
return isinstance(value, (int, float))
def validate_boolean(self, value):
return isinstance(value, bool)
def validate_object(self, value):
return isinstance(value, dict)
def validate_array(self, value):
return isinstance(value, list)
4.2 依赖管理机制
class DependencyManager:
def __init__(self):
self.dependencies = {}
def resolve_dependencies(self, task):
"""
解析任务依赖
"""
resolved_deps = []
for dep in task["dependencies"]:
if dep not in self.dependencies:
# 加载依赖
dependency = self.load_dependency(dep)
self.dependencies[dep] = dependency
resolved_deps.append(self.dependencies[dep])
return resolved_deps
def load_dependency(self, dep_path):
"""
加载依赖项
"""
# 根据路径类型加载不同类型的依赖
if dep_path.endswith(".yaml") or dep_path.endswith(".yml"):
return self.load_yaml_file(dep_path)
elif dep_path.endswith(".md"):
return self.load_markdown_file(dep_path)
elif dep_path.endswith(".json"):
return self.load_json_file(dep_path)
else:
raise Exception(f"不支持的依赖类型: {dep_path}")
4.3 错误处理机制
class TaskErrorHandler:
def __init__(self):
self.error_handlers = {}
def register_error_handler(self, error_type, handler):
"""
注册错误处理器
"""
self.error_handlers[error_type] = handler
def handle_task_error(self, task, error):
"""
处理任务错误
"""
error_type = type(error).__name__
if error_type in self.error_handlers:
handler = self.error_handlers[error_type]
return handler(task, error)
else:
# 默认错误处理
return self.default_error_handler(task, error)
def default_error_handler(self, task, error):
"""
默认错误处理器
"""
return {
"status": "failed",
"task": task["name"],
"error": str(error),
"timestamp": self.get_current_timestamp()
}
5. 任务系统在实际开发中的应用
5.1 开发流程中的任务调度
# 开发流程中的任务调度示例
class DevelopmentWorkflow:
def __init__(self):
self.task_manager = TaskManager()
def execute_development_cycle(self, project_config):
"""
执行开发周期
"""
# 1. 创建下一个故事
create_story_task = {
"name": "create-next-story",
"parameters": {
"epic_file": project_config["epic_file"],
"architecture_docs": project_config["architecture_docs"]
}
}
story_result = self.task_manager.execute_task(
create_story_task["name"],
create_story_task["parameters"]
)
# 2. 开发故事
develop_story_task = {
"name": "develop-story",
"parameters": {
"story_path": story_result["story_path"]
}
}
develop_result = self.task_manager.execute_task(
develop_story_task["name"],
develop_story_task["parameters"]
)
# 3. 审查故事
review_story_task = {
"name": "review-story",
"parameters": {
"story_path": story_result["story_path"],
"gate_location": project_config["gate_location"]
}
}
review_result = self.task_manager.execute_task(
review_story_task["name"],
review_story_task["parameters"]
)
return {
"story_created": story_result,
"story_developed": develop_result,
"story_reviewed": review_result
}
5.2 规划阶段的任务执行
# 规划阶段的任务执行示例
class PlanningWorkflow:
def __init__(self):
self.task_manager = TaskManager()
def execute_planning_phase(self, project_info):
"""
执行规划阶段
"""
# 1. 创建项目简报
create_brief_task = {
"name": "create-doc",
"parameters": {
"template": "project-brief-tmpl.yaml",
"variables": {
"project_name": project_info["name"],
"project_idea": project_info["idea"]
},
"output_path": f"docs/briefs/{project_info['name']}-brief.md"
}
}
brief_result = self.task_manager.execute_task(
create_brief_task["name"],
create_brief_task["parameters"]
)
# 2. 创建PRD
create_prd_task = {
"name": "create-doc",
"parameters": {
"template": "prd-tmpl.yaml",
"variables": {
"project_name": project_info["name"],
"project_brief": brief_result["content"]
},
"output_path": f"docs/prd/{project_info['name']}-prd.md"
}
}
prd_result = self.task_manager.execute_task(
create_prd_task["name"],
create_prd_task["parameters"]
)
# 3. 创建架构文档
create_arch_task = {
"name": "create-doc",
"parameters": {
"template": "architecture-tmpl.yaml",
"variables": {
"project_name": project_info["name"],
"prd_content": prd_result["content"]
},
"output_path": f"docs/architecture/{project_info['name']}-architecture.md"
}
}
arch_result = self.task_manager.execute_task(
create_arch_task["name"],
create_arch_task["parameters"]
)
return {
"brief": brief_result,
"prd": prd_result,
"architecture": arch_result
}
6. 任务系统的扩展和定制
6.1 自定义任务创建
# 创建自定义任务的示例
class CustomTaskCreator:
def __init__(self):
self.base_tasks = self.load_base_tasks()
def create_custom_task(self, task_name, task_logic, dependencies=None):
"""
创建自定义任务
"""
# 1. 定义任务结构
custom_task = {
"name": task_name,
"description": f"自定义任务: {task_name}",
"logic": task_logic,
"dependencies": dependencies or []
}
# 2. 验证任务
if self.validate_task(custom_task):
# 3. 注册任务
self.register_task(task_name, custom_task)
# 4. 保存任务定义
self.save_task_definition(task_name, custom_task)
return custom_task
else:
raise Exception("任务验证失败")
def validate_task(self, task):
"""
验证任务定义
"""
required_fields = ["name", "description", "logic"]
for field in required_fields:
if field not in task:
return False
# 验证逻辑函数
if not callable(task["logic"]):
return False
return True
6.2 任务版本管理
# 任务版本管理示例
class TaskVersionManager:
def __init__(self):
self.task_versions = {}
def create_version(self, task_name, task_definition):
"""
创建任务版本
"""
import hashlib
import datetime
# 生成版本哈希
content_hash = hashlib.md5(str(task_definition).encode()).hexdigest()
# 创建版本记录
version_info = {
"version": self.generate_version_number(task_name),
"hash": content_hash,
"definition": task_definition,
"created_at": datetime.datetime.now(),
"author": self.get_current_user()
}
# 保存版本
if task_name not in self.task_versions:
self.task_versions[task_name] = []
self.task_versions[task_name].append(version_info)
return version_info
def get_task_version(self, task_name, version=None):
"""
获取任务版本
"""
if task_name not in self.task_versions:
return None
versions = self.task_versions[task_name]
if version is None:
# 返回最新版本
return versions[-1] if versions else None
else:
# 返回指定版本
for v in versions:
if v["version"] == version:
return v
return None
总结
BMAD-METHOD的任务系统通过标准化的任务定义和执行机制，为AI辅助的软件开发提供了强大的自动化能力。该系统不仅规范了代理的行为，还通过灵活的扩展机制支持不同场景下的定制化需求。
关键要点包括：
- 标准化执行：通过预定义的任务模板确保操作的一致性
- 分层架构：任务定义、执行和管理层协同工作
- 核心任务：包括文档创建、故事生成、文档分片和故事审查等关键任务
- 执行机制：参数验证、依赖管理和错误处理确保任务正确执行
- 实际应用：在开发流程和规划阶段发挥重要作用
- 可扩展性：支持自定义任务和版本管理
通过这种任务系统，BMAD-METHOD框架实现了复杂工作流程的自动化执行，大大提高了AI辅助开发的效率和质量。
参考资料
- BMAD-METHOD GitHub仓库
- BMAD-METHOD官方文档
- 核心架构文档
- [create-next-story任务](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/create-next-story.md)
- [review-story任务](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/review-story.md)
- [shard-doc任务](file:///e%3A/Dify/BMAD-METHOD/bmad-core/tasks/shard-doc.md)
- [create-doc任务](file:///e%3A/Dify/BMAD-METHOD/common/tasks/create-doc.md)
- 用户指南
扫一扫
407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
