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

tapps_agents/workflow/agent_handlers/orchestrator_handler.py

@@ -1,43 +1,43 @@
-"""
-Orchestrator Agent Handler
-
-Handles execution of orchestrator agent steps for workflow finalization.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from pathlib import Path
-from typing import Any
-
-from ..models import WorkflowStep
-from .base import AgentExecutionHandler
-
-
-class OrchestratorHandler(AgentExecutionHandler):
-    """Handler for orchestrator agent execution."""
-    
-    def supports(self, agent_name: str, action: str) -> bool:
-        """Check if this handler supports orchestrator agent."""
-        return agent_name == "orchestrator" and action in {"finalize", "complete"}
-    
-    async def execute(
-        self,
-        step: WorkflowStep,
-        action: str,
-        target_path: Path | None,
-    ) -> list[dict[str, Any]]:
-        """
-        Execute orchestrator step.
-        
-        Args:
-            step: Workflow step definition
-            action: Normalized action name
-            target_path: Target file path (not used for orchestrator)
-            
-        Returns:
-            List of created artifacts (empty for orchestrator)
-        """
-        # Nothing to do other than marking completion.
-        # The orchestrator step is a no-op that just marks workflow completion.
-        return []
-
+"""
+Orchestrator Agent Handler
+
+Handles execution of orchestrator agent steps for workflow finalization.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from pathlib import Path
+from typing import Any
+
+from ..models import WorkflowStep
+from .base import AgentExecutionHandler
+
+
+class OrchestratorHandler(AgentExecutionHandler):
+    """Handler for orchestrator agent execution."""
+    
+    def supports(self, agent_name: str, action: str) -> bool:
+        """Check if this handler supports orchestrator agent."""
+        return agent_name == "orchestrator" and action in {"finalize", "complete"}
+    
+    async def execute(
+        self,
+        step: WorkflowStep,
+        action: str,
+        target_path: Path | None,
+    ) -> list[dict[str, Any]]:
+        """
+        Execute orchestrator step.
+        
+        Args:
+            step: Workflow step definition
+            action: Normalized action name
+            target_path: Target file path (not used for orchestrator)
+            
+        Returns:
+            List of created artifacts (empty for orchestrator)
+        """
+        # Nothing to do other than marking completion.
+        # The orchestrator step is a no-op that just marks workflow completion.
+        return []
+

tapps_agents/workflow/agent_handlers/planner_handler.py

@@ -1,98 +1,98 @@
-"""
-Planner Agent Handler
-
-Handles execution of planner agent steps for story creation.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from pathlib import Path
-from typing import Any
-
-from ..models import WorkflowStep
-from .base import AgentExecutionHandler
-
-
-class PlannerHandler(AgentExecutionHandler):
-    """Handler for planner agent execution."""
-    
-    def supports(self, agent_name: str, action: str) -> bool:
-        """Check if this handler supports planner agent."""
-        return agent_name == "planner" and action in {
-            "create_stories",
-            "create-stories",
-            "plan",
-            "breakdown",
-        }
-    
-    async def execute(
-        self,
-        step: WorkflowStep,
-        action: str,
-        target_path: Path | None,
-    ) -> list[dict[str, Any]]:
-        """
-        Execute planner step.
-        
-        Args:
-            step: Workflow step definition
-            action: Normalized action name
-            target_path: Target file path (not used for planner)
-            
-        Returns:
-            List of created artifacts
-        """
-        # Try to get enhanced prompt from enhancer if available
-        from ...workflow.output_passing import WorkflowOutputPasser
-        output_passer = WorkflowOutputPasser(self.state)
-        
-        # Prepare inputs with outputs from previous steps (e.g., enhancer)
-        base_inputs: dict[str, Any] = {}
-        enhanced_inputs = output_passer.prepare_agent_inputs(
-            step_id=step.id,
-            agent_name="planner",
-            command=action,
-            base_inputs=base_inputs,
-        )
-        
-        # Get description from enhanced inputs or fallback to requirements file
-        plan_description = enhanced_inputs.get("description") or enhanced_inputs.get("enhancer_description")
-        
-        if not plan_description:
-            # Read requirements if available
-            requirements_path = self.project_root / "requirements.md"
-            plan_description = (
-                requirements_path.read_text(encoding="utf-8")
-                if requirements_path.exists()
-                else "Create user stories for this project"
-            )
-        
-        # Run planner agent with enhanced inputs
-        planner_result = await self.run_agent(
-            "planner",
-            "plan",
-            description=plan_description,
-            **{k: v for k, v in enhanced_inputs.items() if k not in ("description", "enhancer_description")},
-        )
-        self.state.variables["planner_result"] = planner_result
-        
-        # Store output for next steps
-        output_passer.store_agent_output(
-            step_id=step.id,
-            agent_name="planner",
-            command=action,
-            output=planner_result if isinstance(planner_result, dict) else {"result": planner_result},
-        )
-        
-        # Create stories directory if it doesn't exist
-        stories_dir = self.project_root / "stories"
-        stories_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Create stories/ artifact if requested
-        created_artifacts: list[dict[str, Any]] = []
-        if "stories/" in (step.creates or []):
-            if stories_dir.exists():
-                created_artifacts.append({"name": "stories/", "path": str(stories_dir)})
-        
-        return created_artifacts
-
+"""
+Planner Agent Handler
+
+Handles execution of planner agent steps for story creation.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from pathlib import Path
+from typing import Any
+
+from ..models import WorkflowStep
+from .base import AgentExecutionHandler
+
+
+class PlannerHandler(AgentExecutionHandler):
+    """Handler for planner agent execution."""
+    
+    def supports(self, agent_name: str, action: str) -> bool:
+        """Check if this handler supports planner agent."""
+        return agent_name == "planner" and action in {
+            "create_stories",
+            "create-stories",
+            "plan",
+            "breakdown",
+        }
+    
+    async def execute(
+        self,
+        step: WorkflowStep,
+        action: str,
+        target_path: Path | None,
+    ) -> list[dict[str, Any]]:
+        """
+        Execute planner step.
+        
+        Args:
+            step: Workflow step definition
+            action: Normalized action name
+            target_path: Target file path (not used for planner)
+            
+        Returns:
+            List of created artifacts
+        """
+        # Try to get enhanced prompt from enhancer if available
+        from ...workflow.output_passing import WorkflowOutputPasser
+        output_passer = WorkflowOutputPasser(self.state)
+        
+        # Prepare inputs with outputs from previous steps (e.g., enhancer)
+        base_inputs: dict[str, Any] = {}
+        enhanced_inputs = output_passer.prepare_agent_inputs(
+            step_id=step.id,
+            agent_name="planner",
+            command=action,
+            base_inputs=base_inputs,
+        )
+        
+        # Get description from enhanced inputs or fallback to requirements file
+        plan_description = enhanced_inputs.get("description") or enhanced_inputs.get("enhancer_description")
+        
+        if not plan_description:
+            # Read requirements if available
+            requirements_path = self.project_root / "requirements.md"
+            plan_description = (
+                requirements_path.read_text(encoding="utf-8")
+                if requirements_path.exists()
+                else "Create user stories for this project"
+            )
+        
+        # Run planner agent with enhanced inputs
+        planner_result = await self.run_agent(
+            "planner",
+            "plan",
+            description=plan_description,
+            **{k: v for k, v in enhanced_inputs.items() if k not in ("description", "enhancer_description")},
+        )
+        self.state.variables["planner_result"] = planner_result
+        
+        # Store output for next steps
+        output_passer.store_agent_output(
+            step_id=step.id,
+            agent_name="planner",
+            command=action,
+            output=planner_result if isinstance(planner_result, dict) else {"result": planner_result},
+        )
+        
+        # Create stories directory if it doesn't exist
+        stories_dir = self.project_root / "stories"
+        stories_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create stories/ artifact if requested
+        created_artifacts: list[dict[str, Any]] = []
+        if "stories/" in (step.creates or []):
+            if stories_dir.exists():
+                created_artifacts.append({"name": "stories/", "path": str(stories_dir)})
+        
+        return created_artifacts
+

tapps_agents/workflow/agent_handlers/registry.py

@@ -1,119 +1,119 @@
-"""
-Agent Handler Registry
-
-Registry for agent execution handlers using Strategy Pattern.
-
-Epic 20: Complexity Reduction - Story 20.1
-"""
-
-from typing import Any
-
-from .base import AgentExecutionHandler
-
-
-class AgentHandlerRegistry:
-    """
-    Registry for agent execution handlers.
-    
-    Maintains a list of handlers and provides lookup functionality
-    to find the appropriate handler for a given agent/action combination.
-    """
-    
-    def __init__(self):
-        """Initialize the registry."""
-        self._handlers: list[AgentExecutionHandler] = []
-    
-    def register(self, handler: AgentExecutionHandler) -> None:
-        """
-        Register a handler.
-        
-        Args:
-            handler: Handler instance to register
-        """
-        self._handlers.append(handler)
-    
-    def find_handler(
-        self,
-        agent_name: str,
-        action: str,
-    ) -> AgentExecutionHandler | None:
-        """
-        Find a handler that supports the given agent and action.
-        
-        Args:
-            agent_name: Agent name (lowercase)
-            action: Normalized action name
-            
-        Returns:
-            Handler instance if found, None otherwise
-        """
-        for handler in self._handlers:
-            if handler.supports(agent_name, action):
-                return handler
-        return None
-    
-    @classmethod
-    def create_registry(
-        cls,
-        project_root: Any,
-        state: Any,
-        workflow: Any,
-        run_agent_fn: Any,
-        executor: Any = None,
-    ) -> "AgentHandlerRegistry":
-        """
-        Create and populate a registry with all available handlers.
-        
-        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
-            
-        Returns:
-            Populated registry instance
-        """
-        registry = cls()
-        
-        # Import and register all handlers
-        from .analyst_handler import AnalystHandler
-        from .architect_handler import ArchitectHandler
-        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 .reviewer_handler import ReviewerHandler
-        from .tester_handler import TesterHandler
-        
-        handlers = [
-            DebuggerHandler,
-            ImplementerHandler,
-            ReviewerHandler,
-            TesterHandler,
-            AnalystHandler,
-            PlannerHandler,
-            ArchitectHandler,
-            DesignerHandler,
-            EnhancerHandler,
-            OpsHandler,
-            DocumenterHandler,
-            OrchestratorHandler,
-        ]
-        
-        for handler_class in handlers:
-            handler = handler_class(
-                project_root=project_root,
-                state=state,
-                workflow=workflow,
-                run_agent_fn=run_agent_fn,
-                executor=executor,
-            )
-            registry.register(handler)
-        
-        return registry
-
+"""
+Agent Handler Registry
+
+Registry for agent execution handlers using Strategy Pattern.
+
+Epic 20: Complexity Reduction - Story 20.1
+"""
+
+from typing import Any
+
+from .base import AgentExecutionHandler
+
+
+class AgentHandlerRegistry:
+    """
+    Registry for agent execution handlers.
+    
+    Maintains a list of handlers and provides lookup functionality
+    to find the appropriate handler for a given agent/action combination.
+    """
+    
+    def __init__(self):
+        """Initialize the registry."""
+        self._handlers: list[AgentExecutionHandler] = []
+    
+    def register(self, handler: AgentExecutionHandler) -> None:
+        """
+        Register a handler.
+        
+        Args:
+            handler: Handler instance to register
+        """
+        self._handlers.append(handler)
+    
+    def find_handler(
+        self,
+        agent_name: str,
+        action: str,
+    ) -> AgentExecutionHandler | None:
+        """
+        Find a handler that supports the given agent and action.
+        
+        Args:
+            agent_name: Agent name (lowercase)
+            action: Normalized action name
+            
+        Returns:
+            Handler instance if found, None otherwise
+        """
+        for handler in self._handlers:
+            if handler.supports(agent_name, action):
+                return handler
+        return None
+    
+    @classmethod
+    def create_registry(
+        cls,
+        project_root: Any,
+        state: Any,
+        workflow: Any,
+        run_agent_fn: Any,
+        executor: Any = None,
+    ) -> "AgentHandlerRegistry":
+        """
+        Create and populate a registry with all available handlers.
+        
+        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
+            
+        Returns:
+            Populated registry instance
+        """
+        registry = cls()
+        
+        # Import and register all handlers
+        from .analyst_handler import AnalystHandler
+        from .architect_handler import ArchitectHandler
+        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 .reviewer_handler import ReviewerHandler
+        from .tester_handler import TesterHandler
+        
+        handlers = [
+            DebuggerHandler,
+            ImplementerHandler,
+            ReviewerHandler,
+            TesterHandler,
+            AnalystHandler,
+            PlannerHandler,
+            ArchitectHandler,
+            DesignerHandler,
+            EnhancerHandler,
+            OpsHandler,
+            DocumenterHandler,
+            OrchestratorHandler,
+        ]
+        
+        for handler_class in handlers:
+            handler = handler_class(
+                project_root=project_root,
+                state=state,
+                workflow=workflow,
+                run_agent_fn=run_agent_fn,
+                executor=executor,
+            )
+            registry.register(handler)
+        
+        return registry
+