tapps-agents 3.6.0__py3-none-any.whl → 3.6.1__py3-none-any.whl

tapps_agents/workflow/agent_handlers/__init__.py

@@ -1,41 +1,41 @@
-"""
-Agent Execution Handlers
-
-This module provides agent-specific execution handlers using the Strategy Pattern
-to reduce complexity in WorkflowExecutor._execute_step.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from .analyst_handler import AnalystHandler
-from .architect_handler import ArchitectHandler
-from .base import AgentExecutionHandler
-from .debugger_handler import DebuggerHandler
-from .designer_handler import DesignerHandler
-from .documenter_handler import DocumenterHandler
-from .enhancer_handler import EnhancerHandler
-from .implementer_handler import ImplementerHandler
-from .ops_handler import OpsHandler
-from .orchestrator_handler import OrchestratorHandler
-from .planner_handler import PlannerHandler
-from .registry import AgentHandlerRegistry
-from .reviewer_handler import ReviewerHandler
-from .tester_handler import TesterHandler
-
-__all__ = [
-    "AgentExecutionHandler",
-    "AgentHandlerRegistry",
-    "AnalystHandler",
-    "ArchitectHandler",
-    "DebuggerHandler",
-    "DesignerHandler",
-    "DocumenterHandler",
-    "EnhancerHandler",
-    "ImplementerHandler",
-    "OpsHandler",
-    "OrchestratorHandler",
-    "PlannerHandler",
-    "ReviewerHandler",
-    "TesterHandler",
-]
-
+"""
+Agent Execution Handlers
+
+This module provides agent-specific execution handlers using the Strategy Pattern
+to reduce complexity in WorkflowExecutor._execute_step.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from .analyst_handler import AnalystHandler
+from .architect_handler import ArchitectHandler
+from .base import AgentExecutionHandler
+from .debugger_handler import DebuggerHandler
+from .designer_handler import DesignerHandler
+from .documenter_handler import DocumenterHandler
+from .enhancer_handler import EnhancerHandler
+from .implementer_handler import ImplementerHandler
+from .ops_handler import OpsHandler
+from .orchestrator_handler import OrchestratorHandler
+from .planner_handler import PlannerHandler
+from .registry import AgentHandlerRegistry
+from .reviewer_handler import ReviewerHandler
+from .tester_handler import TesterHandler
+
+__all__ = [
+    "AgentExecutionHandler",
+    "AgentHandlerRegistry",
+    "AnalystHandler",
+    "ArchitectHandler",
+    "DebuggerHandler",
+    "DesignerHandler",
+    "DocumenterHandler",
+    "EnhancerHandler",
+    "ImplementerHandler",
+    "OpsHandler",
+    "OrchestratorHandler",
+    "PlannerHandler",
+    "ReviewerHandler",
+    "TesterHandler",
+]
+

tapps_agents/workflow/agent_handlers/analyst_handler.py

@@ -1,75 +1,75 @@
-"""
-Analyst Agent Handler
-
-Handles execution of analyst agent steps for requirements gathering.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from pathlib import Path
-from typing import Any
-
-from ..models import WorkflowStep
-from .base import AgentExecutionHandler
-
-
-class AnalystHandler(AgentExecutionHandler):
-    """Handler for analyst agent execution."""
-    
-    def supports(self, agent_name: str, action: str) -> bool:
-        """Check if this handler supports analyst agent."""
-        return agent_name == "analyst" and action in {
-            "gather_requirements",
-            "gather-requirements",
-            "analyze",
-        }
-    
-    async def execute(
-        self,
-        step: WorkflowStep,
-        action: str,
-        target_path: Path | None,
-    ) -> list[dict[str, Any]]:
-        """
-        Execute analyst step.
-        
-        Args:
-            step: Workflow step definition
-            action: Normalized action name
-            target_path: Target file path (not used for analyst)
-            
-        Returns:
-            List of created artifacts
-        """
-        # Prefer enhanced text from enhancer when present (e.g. full-sdlc enhance step), else user_prompt
-        user_prompt = (
-            self.state.variables.get("enhanced_prompt")
-            or self.state.variables.get("description")
-            or self.state.variables.get("user_prompt")
-            or ""
-        )
-        if not user_prompt:
-            # Check if executor has auto_mode attribute
-            auto_mode = getattr(self.executor, "auto_mode", False) if self.executor else False
-            if not auto_mode:
-                user_prompt = "Generate requirements for this project"
-        
-        # Run analyst agent
-        requirements_result = await self.run_agent(
-            "analyst",
-            "gather-requirements",
-            description=user_prompt,
-            output_file="requirements.md",
-        )
-        self.state.variables["analyst_result"] = requirements_result
-        
-        # Create requirements.md artifact if requested
-        created_artifacts: list[dict[str, Any]] = []
-        if "requirements.md" in (step.creates or []):
-            req_path = self.project_root / "requirements.md"
-            # Analyst agent should have created this, but verify
-            if req_path.exists():
-                created_artifacts.append({"name": "requirements.md", "path": str(req_path)})
-        
-        return created_artifacts
-
+"""
+Analyst Agent Handler
+
+Handles execution of analyst agent steps for requirements gathering.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from pathlib import Path
+from typing import Any
+
+from ..models import WorkflowStep
+from .base import AgentExecutionHandler
+
+
+class AnalystHandler(AgentExecutionHandler):
+    """Handler for analyst agent execution."""
+    
+    def supports(self, agent_name: str, action: str) -> bool:
+        """Check if this handler supports analyst agent."""
+        return agent_name == "analyst" and action in {
+            "gather_requirements",
+            "gather-requirements",
+            "analyze",
+        }
+    
+    async def execute(
+        self,
+        step: WorkflowStep,
+        action: str,
+        target_path: Path | None,
+    ) -> list[dict[str, Any]]:
+        """
+        Execute analyst step.
+        
+        Args:
+            step: Workflow step definition
+            action: Normalized action name
+            target_path: Target file path (not used for analyst)
+            
+        Returns:
+            List of created artifacts
+        """
+        # Prefer enhanced text from enhancer when present (e.g. full-sdlc enhance step), else user_prompt
+        user_prompt = (
+            self.state.variables.get("enhanced_prompt")
+            or self.state.variables.get("description")
+            or self.state.variables.get("user_prompt")
+            or ""
+        )
+        if not user_prompt:
+            # Check if executor has auto_mode attribute
+            auto_mode = getattr(self.executor, "auto_mode", False) if self.executor else False
+            if not auto_mode:
+                user_prompt = "Generate requirements for this project"
+        
+        # Run analyst agent
+        requirements_result = await self.run_agent(
+            "analyst",
+            "gather-requirements",
+            description=user_prompt,
+            output_file="requirements.md",
+        )
+        self.state.variables["analyst_result"] = requirements_result
+        
+        # Create requirements.md artifact if requested
+        created_artifacts: list[dict[str, Any]] = []
+        if "requirements.md" in (step.creates or []):
+            req_path = self.project_root / "requirements.md"
+            # Analyst agent should have created this, but verify
+            if req_path.exists():
+                created_artifacts.append({"name": "requirements.md", "path": str(req_path)})
+        
+        return created_artifacts
+

tapps_agents/workflow/agent_handlers/architect_handler.py

@@ -1,107 +1,107 @@
-"""
-Architect Agent Handler
-
-Handles execution of architect agent steps for system design.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from pathlib import Path
-from typing import Any
-
-from ..models import WorkflowStep
-from .base import AgentExecutionHandler
-
-
-class ArchitectHandler(AgentExecutionHandler):
-    """Handler for architect agent execution."""
-    
-    def supports(self, agent_name: str, action: str) -> bool:
-        """Check if this handler supports architect agent."""
-        return agent_name == "architect" and action in {
-            "design_system",
-            "design-system",
-            "design_architecture",
-        }
-    
-    async def execute(
-        self,
-        step: WorkflowStep,
-        action: str,
-        target_path: Path | None,
-    ) -> list[dict[str, Any]]:
-        """
-        Execute architect step.
-        
-        Args:
-            step: Workflow step definition
-            action: Normalized action name
-            target_path: Target file path (not used for architect)
-            
-        Returns:
-            List of created artifacts
-        """
-        # Get outputs from previous steps (e.g., planner, enhancer)
-        from ...workflow.output_passing import WorkflowOutputPasser
-        output_passer = WorkflowOutputPasser(self.state)
-        
-        base_inputs: dict[str, Any] = {}
-        enhanced_inputs = output_passer.prepare_agent_inputs(
-            step_id=step.id,
-            agent_name="architect",
-            command=action,
-            base_inputs=base_inputs,
-        )
-        
-        # Get requirements from enhanced inputs or fallback to file
-        requirements = enhanced_inputs.get("requirements") or enhanced_inputs.get("planner_requirements")
-        if not requirements:
-            requirements_path = self.project_root / "requirements.md"
-            requirements = (
-                requirements_path.read_text(encoding="utf-8")
-                if requirements_path.exists()
-                else ""
-            )
-        
-        # Get context from enhanced inputs (user stories from planner) or build from files
-        context = enhanced_inputs.get("context") or enhanced_inputs.get("planner_context")
-        if not context:
-            # Build context from stories if available
-            stories_dir = self.project_root / "stories"
-            context_parts = []
-            if stories_dir.exists():
-                story_files = list(stories_dir.glob("*.md"))
-                if story_files:
-                    context_parts.append("User Stories:")
-                    for story_file in story_files[:10]:  # Limit to first 10 stories
-                        context_parts.append(story_file.read_text(encoding="utf-8")[:1000])
-            context = "\n\n".join(context_parts) if context_parts else ""
-        
-        # Run architect agent with enhanced inputs
-        architect_result = await self.run_agent(
-            "architect",
-            "design-system",
-            requirements=requirements,
-            context=context,
-            output_file="architecture.md",
-            **{k: v for k, v in enhanced_inputs.items() if k not in ("requirements", "context", "planner_requirements", "planner_context")},
-        )
-        self.state.variables["architect_result"] = architect_result
-        
-        # Store output for next steps
-        output_passer.store_agent_output(
-            step_id=step.id,
-            agent_name="architect",
-            command=action,
-            output=architect_result if isinstance(architect_result, dict) else {"result": architect_result},
-        )
-        
-        # Create architecture.md artifact if requested
-        created_artifacts: list[dict[str, Any]] = []
-        if "architecture.md" in (step.creates or []):
-            arch_path = self.project_root / "architecture.md"
-            if arch_path.exists():
-                created_artifacts.append({"name": "architecture.md", "path": str(arch_path)})
-        
-        return created_artifacts
-
+"""
+Architect Agent Handler
+
+Handles execution of architect agent steps for system design.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from pathlib import Path
+from typing import Any
+
+from ..models import WorkflowStep
+from .base import AgentExecutionHandler
+
+
+class ArchitectHandler(AgentExecutionHandler):
+    """Handler for architect agent execution."""
+    
+    def supports(self, agent_name: str, action: str) -> bool:
+        """Check if this handler supports architect agent."""
+        return agent_name == "architect" and action in {
+            "design_system",
+            "design-system",
+            "design_architecture",
+        }
+    
+    async def execute(
+        self,
+        step: WorkflowStep,
+        action: str,
+        target_path: Path | None,
+    ) -> list[dict[str, Any]]:
+        """
+        Execute architect step.
+        
+        Args:
+            step: Workflow step definition
+            action: Normalized action name
+            target_path: Target file path (not used for architect)
+            
+        Returns:
+            List of created artifacts
+        """
+        # Get outputs from previous steps (e.g., planner, enhancer)
+        from ...workflow.output_passing import WorkflowOutputPasser
+        output_passer = WorkflowOutputPasser(self.state)
+        
+        base_inputs: dict[str, Any] = {}
+        enhanced_inputs = output_passer.prepare_agent_inputs(
+            step_id=step.id,
+            agent_name="architect",
+            command=action,
+            base_inputs=base_inputs,
+        )
+        
+        # Get requirements from enhanced inputs or fallback to file
+        requirements = enhanced_inputs.get("requirements") or enhanced_inputs.get("planner_requirements")
+        if not requirements:
+            requirements_path = self.project_root / "requirements.md"
+            requirements = (
+                requirements_path.read_text(encoding="utf-8")
+                if requirements_path.exists()
+                else ""
+            )
+        
+        # Get context from enhanced inputs (user stories from planner) or build from files
+        context = enhanced_inputs.get("context") or enhanced_inputs.get("planner_context")
+        if not context:
+            # Build context from stories if available
+            stories_dir = self.project_root / "stories"
+            context_parts = []
+            if stories_dir.exists():
+                story_files = list(stories_dir.glob("*.md"))
+                if story_files:
+                    context_parts.append("User Stories:")
+                    for story_file in story_files[:10]:  # Limit to first 10 stories
+                        context_parts.append(story_file.read_text(encoding="utf-8")[:1000])
+            context = "\n\n".join(context_parts) if context_parts else ""
+        
+        # Run architect agent with enhanced inputs
+        architect_result = await self.run_agent(
+            "architect",
+            "design-system",
+            requirements=requirements,
+            context=context,
+            output_file="architecture.md",
+            **{k: v for k, v in enhanced_inputs.items() if k not in ("requirements", "context", "planner_requirements", "planner_context")},
+        )
+        self.state.variables["architect_result"] = architect_result
+        
+        # Store output for next steps
+        output_passer.store_agent_output(
+            step_id=step.id,
+            agent_name="architect",
+            command=action,
+            output=architect_result if isinstance(architect_result, dict) else {"result": architect_result},
+        )
+        
+        # Create architecture.md artifact if requested
+        created_artifacts: list[dict[str, Any]] = []
+        if "architecture.md" in (step.creates or []):
+            arch_path = self.project_root / "architecture.md"
+            if arch_path.exists():
+                created_artifacts.append({"name": "architecture.md", "path": str(arch_path)})
+        
+        return created_artifacts
+

tapps_agents/workflow/agent_handlers/base.py

@@ -1,84 +1,84 @@
-"""
-Base Agent Execution Handler
-
-Abstract base class for agent-specific execution handlers.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Any
-
-from ..models import WorkflowStep
-
-
-class AgentExecutionHandler(ABC):
-    """
-    Abstract base class for agent-specific execution handlers.
-    
-    Each handler encapsulates the logic for executing a specific agent type,
-    reducing complexity in the main WorkflowExecutor._execute_step method.
-    """
-    
-    def __init__(
-        self,
-        project_root: Path,
-        state: Any,
-        workflow: Any,
-        run_agent_fn: Any,
-        executor: Any = None,
-    ):
-        """
-        Initialize the handler.
-        
-        Args:
-            project_root: Root directory for the project
-            state: WorkflowState instance
-            workflow: Workflow instance
-            run_agent_fn: Function to run agent commands
-            executor: Optional executor instance for utility methods
-        """
-        self.project_root = project_root
-        self.state = state
-        self.workflow = workflow
-        self.run_agent = run_agent_fn
-        self.executor = executor
-    
-    @abstractmethod
-    async def execute(
-        self,
-        step: WorkflowStep,
-        action: str,
-        target_path: Path | None,
-    ) -> list[dict[str, Any]]:
-        """
-        Execute the agent step.
-        
-        Args:
-            step: Workflow step definition
-            action: Normalized action name
-            target_path: Optional target file path
-            
-        Returns:
-            List of created artifacts (dict with 'name' and 'path' keys)
-            
-        Raises:
-            ValueError: If step requirements are not met
-        """
-        pass
-    
-    @abstractmethod
-    def supports(self, agent_name: str, action: str) -> bool:
-        """
-        Check if this handler supports the given agent and action.
-        
-        Args:
-            agent_name: Agent name (lowercase)
-            action: Normalized action name
-            
-        Returns:
-            True if this handler can execute the step
-        """
-        pass
-
+"""
+Base Agent Execution Handler
+
+Abstract base class for agent-specific execution handlers.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from ..models import WorkflowStep
+
+
+class AgentExecutionHandler(ABC):
+    """
+    Abstract base class for agent-specific execution handlers.
+    
+    Each handler encapsulates the logic for executing a specific agent type,
+    reducing complexity in the main WorkflowExecutor._execute_step method.
+    """
+    
+    def __init__(
+        self,
+        project_root: Path,
+        state: Any,
+        workflow: Any,
+        run_agent_fn: Any,
+        executor: Any = None,
+    ):
+        """
+        Initialize the handler.
+        
+        Args:
+            project_root: Root directory for the project
+            state: WorkflowState instance
+            workflow: Workflow instance
+            run_agent_fn: Function to run agent commands
+            executor: Optional executor instance for utility methods
+        """
+        self.project_root = project_root
+        self.state = state
+        self.workflow = workflow
+        self.run_agent = run_agent_fn
+        self.executor = executor
+    
+    @abstractmethod
+    async def execute(
+        self,
+        step: WorkflowStep,
+        action: str,
+        target_path: Path | None,
+    ) -> list[dict[str, Any]]:
+        """
+        Execute the agent step.
+        
+        Args:
+            step: Workflow step definition
+            action: Normalized action name
+            target_path: Optional target file path
+            
+        Returns:
+            List of created artifacts (dict with 'name' and 'path' keys)
+            
+        Raises:
+            ValueError: If step requirements are not met
+        """
+        pass
+    
+    @abstractmethod
+    def supports(self, agent_name: str, action: str) -> bool:
+        """
+        Check if this handler supports the given agent and action.
+        
+        Args:
+            agent_name: Agent name (lowercase)
+            action: Normalized action name
+            
+        Returns:
+            True if this handler can execute the step
+        """
+        pass
+