autogen/autogen_sdls_system.py

"""
AutoGen SDLC 多智能体协同系统 - 主程序入口
实现端到端软件交付的自动化流程
"""
import os
import sys
from pathlib import Path
from typing import Dict, Any, Optional, List
import json

# 添加项目根目录到路径
sys.path.insert(0, str(Path(__file__).parent))

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
from config.llm_config import (
    get_llm_config, 
    PM_PROMPT, 
    QA_PROMPT, 
    DEV_PROMPT, 
    ORCH_PROMPT
)
from utils.logger import get_logger
from utils.callback_handler import get_callback_handler


class AutoGenSDLCSystem:
    """AutoGen SDLC 多智能体协同系统"""
    
    def __init__(
        self,
        api_key: Optional[str] = None,
        base_url: Optional[str] = None,
        model: str = "qwen3.5-flash",
        workspace_dir: str = "workspace"
    ):
        """
        初始化 SDLC 系统
        
        Args:
            api_key: API Key，默认从环境变量读取
            base_url: API Base URL
            model: 模型名称
            workspace_dir: 工作目录
        """
        # 配置 LLM
        self.api_key = api_key or os.getenv("DASHSCOPE_API_KEY", "")
        self.base_url = base_url or "https://dashscope.aliyuncs.com/compatible-mode/v1"
        self.model = model
        
        if not self.api_key:
            raise ValueError("请设置 DASHSCOPE_API_KEY 环境变量或传入 api_key 参数")
        
        self.llm_config = get_llm_config(
            model=model,
            api_key=self.api_key,
            base_url=self.base_url
        )
        
        # 初始化日志和回调
        self.logger = get_logger()
        self.callback_handler = get_callback_handler()
        
        # 创建工作目录
        self.workspace_dir = Path(workspace_dir)
        self.workspace_dir.mkdir(parents=True, exist_ok=True)
        
        # 创建 Agent
        self._create_agents()
        
        # 创建 GroupChat
        self.groupchat = None
        self.manager = None
    
    def _create_agents(self):
        """创建所有 Agent"""
        # PM Agent
        self.pm_agent = AssistantAgent(
            name="PM_Agent",
            system_message=PM_PROMPT,
            llm_config=self.llm_config,
            description="资深软件产品经理，负责需求分析和 SRS 生成",
            human_input_mode="NEVER"
        )
        
        # QA Agent
        self.qa_agent = AssistantAgent(
            name="QA_Agent",
            system_message=QA_PROMPT,
            llm_config=self.llm_config,
            description="资深测试工程师，负责测试用例设计",
            human_input_mode="NEVER"
        )
        
        # Dev Agent
        self.dev_agent = AssistantAgent(
            name="Dev_Agent",
            system_message=DEV_PROMPT,
            llm_config=self.llm_config,
            description="资深软件工程师，负责代码实现",
            human_input_mode="NEVER"
        )
        
        # Orchestrator Agent
        self.orchestrator = AssistantAgent(
            name="Orchestrator",
            system_message=ORCH_PROMPT,
            llm_config=self.llm_config,
            description="多智能体协调器，负责流程控制和验证",
            human_input_mode="NEVER"
        )
        
        # User Proxy（用于执行代码）
        self.user_proxy = UserProxyAgent(
            name="User_Proxy",
            human_input_mode="NEVER",  # 修复：Web 环境不支持 TERMINAL
            max_consecutive_auto_reply=0,
            code_execution_config={
                "work_dir": str(self.workspace_dir),
                "use_docker": False,
            },
            is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE")
        )
        
        self.logger.log_event("agents_created", "所有 Agent 已创建", {
            "agents": ["PM_Agent", "QA_Agent", "Dev_Agent", "Orchestrator", "User_Proxy"]
        })
    
    def create_groupchat(self, max_round: int = 20):
        """
        创建 GroupChat
        
        Args:
            max_round: 最大对话轮数
        """
        self.groupchat = GroupChat(
            agents=[self.pm_agent, self.qa_agent, self.dev_agent, 
                    self.orchestrator, self.user_proxy],
            messages=[],
            max_round=max_round,
            speaker_selection_method="round_robin"  # 轮流发言确保流程可控
        )
        
        self.manager = GroupChatManager(
            groupchat=self.groupchat,
            llm_config=self.llm_config
        )
        
        self.logger.log_event("groupchat_created", "GroupChat 已创建", {
            "max_round": max_round
        })
    
    def run_workflow(self, user_requirement: str, max_round: int = 20) -> Dict[str, Any]:
        """
        运行完整的 SDLC 工作流
        
        Args:
            user_requirement: 用户需求描述
            max_round: 最大对话轮数
        
        Returns:
            工作流结果
        """
        self.logger.log_event("workflow_started", "SDLC 工作流启动", {
            "requirement": user_requirement
        })
        
        # 创建 GroupChat
        self.create_groupchat(max_round)
        
        # 构建初始消息
        initial_message = f"""
请启动完整的 SDLC 流程，开发以下功能：

【用户需求】
{user_requirement}

【工作流程】
1. PM_Agent: 分析需求，生成 SRS 文档
2. QA_Agent: 根据 SRS 设计测试用例
3. Dev_Agent: 根据 SRS 和测试用例编写代码
4. User_Proxy: 执行测试验证
5. Orchestrator: 汇总结果并生成最终报告

请各 Agent 按顺序协作完成。每个步骤完成后，Orchestrator 进行验证。
如果测试失败，Dev_Agent 需要修复代码直到测试通过。

开始工作！
"""
        
        try:
            # 启动对话
            chat_result = self.user_proxy.initiate_chat(
                self.manager,
                message=initial_message,
                max_turns=max_round,
                summary_method="reflection_with_llm"
            )
            
            # 记录结果
            self.logger.log_event(
                "workflow_completed",
                "SDLC 工作流完成",
                {"chat_summary": chat_result.summary if hasattr(chat_result, 'summary') else "完成"}
            )
            
            # 导出对话历史
            for msg in self.groupchat.messages:
                self.logger.log_message(
                    agent_name=msg.get("name", "Unknown"),
                    message=msg.get("content", ""),
                    role=msg.get("role", "assistant")
                )
            
            return {
                "success": True,
                "summary": chat_result.summary if hasattr(chat_result, 'summary') else "工作流完成",
                "messages": self.groupchat.messages,
                "workspace": str(self.workspace_dir)
            }
            
        except Exception as e:
            self.logger.log_event("workflow_error", f"工作流执行出错：{str(e)}")
            return {
                "success": False,
                "error": str(e),
                "messages": self.groupchat.messages if self.groupchat else []
            }
    
    def export_conversation(self, output_path: Optional[str] = None) -> str:
        """导出对话历史"""
        return self.logger.export_to_json(output_path)
    
    def export_report(self, output_path: Optional[str] = None) -> str:
        """导出 Markdown 格式报告"""
        return self.logger.export_to_markdown(output_path)


def main():
    """主函数 - 演示模式"""
    print("=" * 60)
    print("AutoGen SDLC 多智能体协同系统")
    print("=" * 60)
    
    # 检查 API Key
    api_key = os.getenv("DASHSCOPE_API_KEY")
    if not api_key:
        print("\n❌ 错误：未设置 DASHSCOPE_API_KEY 环境变量")
        print("请运行：export DASHSCOPE_API_KEY='your_api_key'")
        return
    
    # 创建系统实例
    system = AutoGenSDLCSystem(api_key=api_key)
    
    # 演示用例
    demo_requirement = "我需要一个电池健康状态 (SOH) 预测 API，能够接收电池的电压、电流、温度数据，输出健康度百分比"
    
    print(f"\n📋 演示需求：{demo_requirement}")
    print("\n🚀 启动 SDLC 工作流...\n")
    
    # 运行工作流
    result = system.run_workflow(demo_requirement, max_round=15)
    
    # 输出结果
    print("\n" + "=" * 60)
    if result["success"]:
        print("✅ 工作流成功完成！")
        print(f"📄 摘要：{result['summary'][:200]}...")
        print(f"📂 工作目录：{result['workspace']}")
    else:
        print(f"❌ 工作流失败：{result.get('error', '未知错误')}")
    
    # 导出报告
    report_path = system.export_report()
    print(f"📊 对话报告已导出：{report_path}")
    
    print("\n" + "=" * 60)


if __name__ == "__main__":
    main()