opencode-collaboration 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

src/core/git_workflow_enforcer.py

@@ -0,0 +1,352 @@
+"""Git 工作流强制约束模块。
+
+功能：
+1. 验证 Agent 通过 Git pull 获取最新文件
+2. 强制执行 Git 操作
+3. 检测工作流违规
+"""
+import subprocess
+import logging
+from typing import Tuple, Optional, Dict, Any
+from dataclasses import dataclass
+from pathlib import Path
+import os
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WorkflowViolation:
+    """工作流违规。"""
+    agent_id: str
+    action: str
+    reason: str
+    suggestion: str
+    
+    def to_dict(self) -> Dict[str, str]:
+        return {
+            "agent_id": self.agent_id,
+            "action": self.action,
+            "reason": self.reason,
+            "suggestion": self.suggestion
+        }
+
+
+class GitWorkflowEnforcer:
+    """Git 工作流强制执行器。"""
+    
+    REQUIRED_GIT_OPERATIONS = [
+        "READ_REQUIREMENTS",
+        "READ_DESIGN",
+        "READ_TEST_REPORT",
+        "READ_SIGNOFF",
+        "READ_CODE",
+    ]
+    
+    def __init__(self, project_path: str = "."):
+        """初始化。
+        
+        Args:
+            project_path: 项目路径
+        """
+        self.project_path = Path(project_path)
+    
+    def is_git_repository(self) -> bool:
+        """检查是否为 Git 仓库。"""
+        return (self.project_path / ".git").exists()
+    
+    def get_git_root(self) -> Optional[Path]:
+        """获取 Git 根目录。"""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return Path(result.stdout.strip())
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return None
+    
+    def verify_git_pull(self, agent_id: str, file_path: str) -> Tuple[bool, Optional[WorkflowViolation]]:
+        """验证 Agent 是否通过 Git pull 获取最新文件。
+        
+        Args:
+            agent_id: Agent ID
+            file_path: 要读取的文件路径
+            
+        Returns:
+            (是否通过, 违规信息)
+        """
+        abs_path = self.project_path / file_path
+        
+        if not abs_path.exists():
+            return True, None
+        
+        local_content = self._read_local_file(str(abs_path))
+        
+        git_content = self._git_show(f"HEAD:{file_path}")
+        
+        if git_content is None:
+            logger.warning(f"文件不在 Git 中: {file_path}")
+            return True, None
+        
+        if local_content != git_content:
+            return False, WorkflowViolation(
+                agent_id=agent_id,
+                action="READ_FILE",
+                reason=f"本地文件与 Git HEAD 不一致",
+                suggestion="请先执行 'git pull' 获取最新版本"
+            )
+        
+        return True, None
+    
+    def verify_git_status(self, agent_id: str) -> Tuple[bool, Optional[WorkflowViolation]]:
+        """验证工作区是否干净。
+        
+        Args:
+            agent_id: Agent ID
+            
+        Returns:
+            (是否干净, 违规信息)
+        """
+        try:
+            result = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.stdout.strip():
+                return False, WorkflowViolation(
+                    agent_id=agent_id,
+                    action="GIT_STATUS",
+                    reason="工作区有未提交的更改",
+                    suggestion="请先提交或暂存更改"
+                )
+            
+            return True, None
+        
+        except subprocess.TimeoutExpired:
+            return False, WorkflowViolation(
+                agent_id=agent_id,
+                action="GIT_STATUS",
+                reason="Git 命令超时",
+                suggestion="检查网络连接和 Git 配置"
+            )
+    
+    def enforce_git_operation(self, agent_id: str, operation: str) -> Tuple[bool, Optional[WorkflowViolation]]:
+        """强制执行 Git 操作。
+        
+        Args:
+            agent_id: Agent ID
+            operation: 操作类型
+            
+        Returns:
+            (是否通过, 违规信息)
+        """
+        if operation in self.REQUIRED_GIT_OPERATIONS:
+            success, error = self._run_git_pull()
+            if not success:
+                return False, WorkflowViolation(
+                    agent_id=agent_id,
+                    action=operation,
+                    reason="Git pull 失败",
+                    suggestion=str(error) if error else "请检查 Git 配置"
+                )
+        
+        return True, None
+    
+    def check_file_in_git(self, file_path: str) -> bool:
+        """检查文件是否在 Git 版本控制中。"""
+        try:
+            result = subprocess.run(
+                ["git", "ls-files", "--error-unmatch", file_path],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+    
+    def get_file_version(self, file_path: str) -> Optional[str]:
+        """获取文件的 Git HEAD 版本哈希。"""
+        try:
+            result = subprocess.run(
+                ["git", "log", "-1", "--format=%H", "--", file_path],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return None
+    
+    def get_commit_info(self, commit_hash: str = "HEAD") -> Dict[str, Any]:
+        """获取提交信息。"""
+        try:
+            result = subprocess.run(
+                ["git", "log", "-1", "--format=%H%n%an%n%ae%n%ad%n%s", "--date=iso",
+                 commit_hash],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                lines = result.stdout.strip().split('\n')
+                return {
+                    "hash": lines[0] if len(lines) > 0 else "",
+                    "author": lines[1] if len(lines) > 1 else "",
+                    "email": lines[2] if len(lines) > 2 else "",
+                    "date": lines[3] if len(lines) > 3 else "",
+                    "message": '\n'.join(lines[4:]) if len(lines) > 4 else ""
+                }
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return {}
+    
+    def _run_git_pull(self) -> Tuple[bool, Optional[Exception]]:
+        """执行 git pull。"""
+        try:
+            result = subprocess.run(
+                ["git", "pull", "--ff-only"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode == 0:
+                logger.info(f"Git pull 成功: {result.stdout}")
+                return True, None
+            else:
+                logger.error(f"Git pull 失败: {result.stderr}")
+                return False, Exception(result.stderr)
+        
+        except subprocess.TimeoutExpired:
+            error = Exception("Git pull 超时")
+            logger.error(str(error))
+            return False, error
+    
+    def _read_local_file(self, file_path: str) -> str:
+        """读取本地文件内容。"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except (IOError, UnicodeDecodeError) as e:
+            logger.warning(f"读取文件失败: {file_path}, {e}")
+            return ""
+    
+    def _git_show(self, file_path: str) -> Optional[str]:
+        """从 Git 获取文件内容。"""
+        try:
+            result = subprocess.run(
+                ["git", "show", file_path],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            if result.returncode == 0:
+                return result.stdout
+            else:
+                logger.debug(f"Git show 失败: {result.stderr}")
+                return None
+        
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            logger.warning(f"Git show 超时: {file_path}")
+            return None
+
+
+class GitConfigChecker:
+    """Git 配置检查器。"""
+    
+    def __init__(self, project_path: str = "."):
+        self.project_path = Path(project_path)
+    
+    def check_git_installed(self) -> bool:
+        """检查 Git 是否安装。"""
+        try:
+            subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                timeout=5
+            )
+            return True
+        except FileNotFoundError:
+            return False
+    
+    def check_git_configured(self) -> Tuple[bool, str]:
+        """检查 Git 是否已配置。"""
+        try:
+            result = subprocess.run(
+                ["git", "config", "--global", "--list"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if "user.name" in result.stdout and "user.email" in result.stdout:
+                return True, "Git 已配置用户信息"
+            else:
+                return False, "Git 未配置用户信息 (user.name/user.email)"
+        except FileNotFoundError:
+            return False, "Git 未安装"
+    
+    def check_remote_configured(self) -> Tuple[bool, str]:
+        """检查远程仓库是否配置。"""
+        try:
+            result = subprocess.run(
+                ["git", "remote", "-v"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.stdout.strip():
+                return True, f"远程仓库已配置: {result.stdout.strip()}"
+            else:
+                return False, "未配置远程仓库"
+        except subprocess.TimeoutExpired:
+            return False, "Git 命令超时"
+    
+    def get_full_status(self) -> Dict[str, Any]:
+        """获取完整的 Git 状态。"""
+        enforcer = GitWorkflowEnforcer(str(self.project_path))
+        
+        return {
+            "git_installed": self.check_git_installed(),
+            "git_configured": self.check_git_configured()[0],
+            "is_repository": enforcer.is_git_repository(),
+            "remote_configured": self.check_remote_configured()[0],
+            "git_root": str(enforcer.get_git_root()) if enforcer.get_git_root() else None
+        }
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    checker = GitConfigChecker(".")
+    print("Git 配置检查:")
+    status = checker.get_full_status()
+    for key, value in status.items():
+        print(f"  {key}: {value}")
+    
+    print("\nGit 工作流强制执行:")
+    enforcer = GitWorkflowEnforcer(".")
+    is_clean, violation = enforcer.verify_git_status("test_agent")
+    print(f"  工作区干净: {is_clean}")
+    if violation:
+        print(f"  违规: {violation.reason}")

src/core/iteration_status_manager.py

@@ -0,0 +1,290 @@
+"""迭代状态管理模块。
+
+功能：
+1. 管理多迭代状态隔离
+2. 验证迭代状态与实际进度一致
+3. 重置指定阶段状态
+"""
+import logging
+from typing import Dict, Optional, List
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+import yaml
+
+
+logger = logging.getLogger(__name__)
+
+
+class IterationStatus(Enum):
+    """迭代状态。"""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    ARCHIVED = "archived"
+
+
+class PhaseStatus(Enum):
+    """阶段状态。"""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    APPROVED = "approved"
+
+
+@dataclass
+class IterationState:
+    """迭代状态。"""
+    version: str
+    status: str = IterationStatus.PENDING.value
+    start_date: str = ""
+    end_date: str = ""
+    requirements: str = PhaseStatus.PENDING.value
+    design: str = PhaseStatus.PENDING.value
+    development: str = PhaseStatus.PENDING.value
+    testing: str = PhaseStatus.PENDING.value
+    deployment: str = PhaseStatus.PENDING.value
+    history: List[Dict] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict:
+        return {
+            "version": self.version,
+            "status": self.status,
+            "start_date": self.start_date,
+            "end_date": self.end_date,
+            "requirements": self.requirements,
+            "design": self.design,
+            "development": self.development,
+            "testing": self.testing,
+            "deployment": self.deployment,
+            "history": self.history
+        }
+
+
+class IterationStatusManager:
+    """迭代状态管理器。"""
+    
+    PHASES = ["requirements", "design", "development", "testing", "deployment"]
+    
+    def __init__(self, state_path: str):
+        """初始化。
+        
+        Args:
+            state_path: state.yaml 文件路径
+        """
+        self.state_path = state_path
+        self.state = self._load_state()
+        self.current_iteration = self._get_current_iteration()
+    
+    def _load_state(self) -> Dict:
+        """加载状态文件。"""
+        try:
+            with open(self.state_path, 'r', encoding='utf-8') as f:
+                return yaml.safe_load(f) or {}
+        except (IOError, yaml.YAMLError) as e:
+            logger.error(f"加载状态文件失败: {e}")
+            return {}
+    
+    def _save_state(self):
+        """保存状态文件。"""
+        try:
+            with open(self.state_path, 'w', encoding='utf-8') as f:
+                yaml.dump(self.state, f, allow_unicode=True, sort_keys=False)
+        except IOError as e:
+            logger.error(f"保存状态文件失败: {e}")
+    
+    def _get_current_iteration(self) -> Optional[str]:
+        """获取当前迭代版本。"""
+        return self.state.get("iteration", {}).get("current")
+    
+    def get_iteration_state(self, version: str = None) -> Optional[IterationState]:
+        """获取指定迭代的状态。"""
+        target_version = version or self.current_iteration
+        if not target_version:
+            return None
+        
+        iterations = self.state.get("iterations", {})
+        if target_version in iterations:
+            data = iterations[target_version]
+            return IterationState(**data)
+        return None
+    
+    def get_current_state(self) -> Optional[IterationState]:
+        """获取当前迭代状态。"""
+        return self.get_iteration_state()
+    
+    def start_iteration(self, version: str) -> IterationState:
+        """开始新迭代，初始化状态。"""
+        if "iterations" not in self.state:
+            self.state["iterations"] = {}
+        
+        now = datetime.now().isoformat()
+        new_iteration = IterationState(
+            version=version,
+            status=IterationStatus.IN_PROGRESS.value,
+            start_date=now
+        )
+        
+        self.state["iterations"][version] = new_iteration.to_dict()
+        self.state["iteration"] = {
+            "current": version,
+            "status": "in_progress"
+        }
+        
+        self.current_iteration = version
+        self._save_state()
+        
+        logger.info(f"开始新迭代: {version}")
+        return new_iteration
+    
+    def complete_iteration(self, version: str = None) -> bool:
+        """完成迭代。"""
+        target_version = version or self.current_iteration
+        if not target_version:
+            logger.error("没有当前迭代")
+            return False
+        
+        now = datetime.now().isoformat()
+        if target_version in self.state.get("iterations", {}):
+            self.state["iterations"][target_version]["status"] = IterationStatus.COMPLETED.value
+            self.state["iterations"][target_version]["end_date"] = now
+            self.state["iterations"][target_version]["status"] = IterationStatus.COMPLETED.value
+            self.state["iteration"]["status"] = "completed"
+            
+            self._save_state()
+            logger.info(f"迭代已完成: {target_version}")
+            return True
+        
+        return False
+    
+    def update_phase_status(self, phase: str, status: str, version: str = None) -> bool:
+        """更新阶段状态。"""
+        if phase not in self.PHASES:
+            logger.error(f"未知阶段: {phase}")
+            return False
+        
+        target_version = version or self.current_iteration
+        if not target_version:
+            logger.error("没有当前迭代")
+            return False
+        
+        if target_version in self.state.get("iterations", {}):
+            self.state["iterations"][target_version][phase] = status
+            
+            self._save_state()
+            logger.info(f"迭代 {target_version} 的 {phase} 状态已更新为 {status}")
+            return True
+        
+        return False
+    
+    def reset_phase(self, phase: str, version: str = None) -> bool:
+        """重置指定阶段状态为 pending。"""
+        return self.update_phase_status(phase, PhaseStatus.PENDING.value, version)
+    
+    def archive_iteration(self, version: str) -> bool:
+        """归档迭代。"""
+        if version in self.state.get("iterations", {}):
+            self.state["iterations"][version]["status"] = IterationStatus.ARCHIVED.value
+            
+            if self.state.get("iteration", {}).get("current") == version:
+                self.state["iteration"]["current"] = None
+                self.state["iteration"]["status"] = "archived"
+            
+            self._save_state()
+            logger.info(f"迭代已归档: {version}")
+            return True
+        
+        return False
+    
+    def switch_iteration(self, version: str) -> bool:
+        """切换到指定迭代。"""
+        if version in self.state.get("iterations", {}):
+            self.state["iteration"]["current"] = version
+            self.state["iteration"]["status"] = self.state["iterations"][version]["status"]
+            self.current_iteration = version
+            
+            self._save_state()
+            logger.info(f"已切换到迭代: {version}")
+            return True
+        
+        logger.error(f"迭代不存在: {version}")
+        return False
+    
+    def get_progress(self, version: str = None) -> Dict:
+        """获取迭代进度。"""
+        target_version = version or self.current_iteration
+        if not target_version:
+            return {"error": "没有当前迭代"}
+        
+        iteration = self.get_iteration_state(target_version)
+        if not iteration:
+            return {"error": f"迭代不存在: {target_version}"}
+        
+        completed_phases = 0
+        total_phases = len(self.PHASES)
+        
+        for phase in self.PHASES:
+            status = getattr(iteration, phase)
+            if status in [PhaseStatus.COMPLETED.value, PhaseStatus.APPROVED.value]:
+                completed_phases += 1
+        
+        return {
+            "version": target_version,
+            "overall_status": iteration.status,
+            "phases": {
+                phase: getattr(iteration, phase) for phase in self.PHASES
+            },
+            "progress_percent": (completed_phases / total_phases) * 100,
+            "completed_phases": completed_phases,
+            "total_phases": total_phases
+        }
+    
+    def get_all_iterations(self) -> List[Dict]:
+        """获取所有迭代信息。"""
+        iterations = self.state.get("iterations", {})
+        return [
+            {"version": k, **v} for k, v in iterations.items()
+        ]
+    
+    def validate_consistency(self, version: str = None) -> Dict:
+        """验证迭代状态与实际进度一致。"""
+        target_version = version or self.current_iteration
+        if not target_version:
+            return {"valid": False, "reason": "没有当前迭代"}
+        
+        iteration = self.get_iteration_state(target_version)
+        if not iteration:
+            return {"valid": False, "reason": f"迭代不存在: {target_version}"}
+        
+        issues = []
+        
+        for phase in self.PHASES:
+            status = getattr(iteration, phase)
+            
+            if status == PhaseStatus.IN_PROGRESS.value:
+                issues.append({
+                    "phase": phase,
+                    "status": status,
+                    "issue": "阶段状态为进行中，请确保工作已完成后再更新状态"
+                })
+        
+        return {
+            "valid": len(issues) == 0,
+            "version": target_version,
+            "issues": issues
+        }
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    manager = IterationStatusManager("state/project_state.yaml")
+    
+    print("当前迭代状态:")
+    print(manager.get_current_state())
+    
+    print("\n进度:")
+    print(manager.get_progress())
+    
+    print("\n一致性验证:")
+    print(manager.validate_consistency())