tapps-agents 3.5.39__py3-none-any.whl → 3.5.41__py3-none-any.whl

tapps_agents/workflow/direct_execution_fallback.py

@@ -257,8 +257,15 @@ class DirectExecutionFallback:
         if skill_command.startswith("@"):
             skill_command = skill_command[1:]
 
-        # Split into parts
-        parts = skill_command.split()
+        # Split into parts, preserving quoted strings
+        # Use shlex.split() to handle complex quotes properly
+        # Use posix=True to properly handle quote removal (even on Windows)
+        try:
+            parts = shlex.split(skill_command, posix=True)
+        except ValueError as e:
+            # Provide helpful error message with truncated command
+            cmd_preview = skill_command[:200] + "..." if len(skill_command) > 200 else skill_command
+            raise ValueError(f"Invalid skill command (malformed quotes): {cmd_preview}") from e
 
         if not parts:
             raise ValueError(f"Invalid skill command: {skill_command}")
@@ -282,7 +289,13 @@ class DirectExecutionFallback:
         if command_name:
             cli_parts.append(command_name)
 
-        cli_parts.extend(remaining_args)
+        # Safely quote arguments that may contain spaces or special characters
+        for arg in remaining_args:
+            # Check if arg needs quoting (contains spaces, quotes, or special chars)
+            if ' ' in arg or '"' in arg or "'" in arg:
+                cli_parts.append(shlex.quote(arg))
+            else:
+                cli_parts.append(arg)
 
         return " ".join(cli_parts)
 

tapps_agents/workflow/message_formatter.py

@@ -103,9 +103,10 @@ class MessageFormatter:
         """
         emoji = self._get_emoji("block") if self.config.use_emoji else ""
         intent_display = user_intent or "Implement feature"
+        path_display = Path(file_path).as_posix()
 
         lines = [
-            f"{emoji}Direct file edit blocked: {file_path}".strip(),
+            f"{emoji}Direct file edit blocked: {path_display}".strip(),
             "",
             f"Detected intent: {workflow.value} (confidence: {confidence:.0f}%)",
             "",

tapps_agents/workflow/models.py

@@ -5,7 +5,7 @@ Workflow models - Data structures for workflow definitions.
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any
+from typing import Any, Literal
 
 
 class WorkflowType(Enum):
@@ -95,6 +95,43 @@ class StepExecution:
     error: str | None = None
 
 
+@dataclass
+class StepResult:
+    """Result of step execution with proper error handling.
+
+    This class represents the outcome of executing a workflow step,
+    including success/failure status, error details, and artifacts created.
+    Used by CursorExecutor to properly track step outcomes and halt
+    workflows when required steps fail.
+    """
+
+    step_id: str
+    status: Literal["completed", "failed", "skipped"]
+    success: bool
+    duration: float
+    started_at: datetime
+    completed_at: datetime
+    error: str | None = None
+    error_traceback: str | None = None
+    artifacts: list[str] = field(default_factory=list)
+    skip_reason: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "step_id": self.step_id,
+            "status": self.status,
+            "success": self.success,
+            "duration": self.duration,
+            "started_at": self.started_at.isoformat(),
+            "completed_at": self.completed_at.isoformat(),
+            "error": self.error,
+            "error_traceback": self.error_traceback,
+            "artifacts": self.artifacts,
+            "skip_reason": self.skip_reason,
+        }
+
+
 @dataclass
 class WorkflowState:
     """Workflow execution state."""

tapps_agents/workflow/parallel_executor.py

@@ -127,21 +127,60 @@ class ParallelStepExecutor:
         """
         Find steps that are ready to execute (dependencies met).
 
+        This method respects the workflow's sequential 'next:' chain to prevent
+        premature step execution. A step is only ready if:
+        1. It's the 'next:' step from a completed step, OR it's the first step
+        2. All its artifact dependencies are met
+
+        This ensures workflows follow the intended sequence (enhance→planning→
+        implementation→review→testing→complete) instead of jumping to the final
+        step prematurely.
+
+        Fix for: Workflow Auto-Continuation Issue (BUG - Workflow stops after 1 step)
+        Root cause: Previous logic only checked artifact dependencies, allowing
+        'complete' step to execute immediately after 'enhance' because it had
+        no 'requires' dependencies.
+
         Args:
             workflow_steps: All workflow steps
             completed_step_ids: Set of completed step IDs
             running_step_ids: Set of currently running step IDs
             available_artifacts: Set of available artifact names (from state.artifacts)
-            Returns:
-                List of steps ready to execute
+
+        Returns:
+            List of steps ready to execute
         """
         ready: list[WorkflowStep] = []
         artifacts = available_artifacts or set()
 
+        # Build set of next steps from completed steps' next: fields
+        next_step_ids: set[str] = set()
+        for step in workflow_steps:
+            if step.id in completed_step_ids and step.next:
+                next_step_ids.add(step.next)
+
+        # If no completed steps yet, first step is ready
+        if not completed_step_ids:
+            first_step = workflow_steps[0] if workflow_steps else None
+            if first_step and first_step.id not in running_step_ids:
+                # Still check artifact dependencies for first step
+                if first_step.requires:
+                    all_met = all(req in artifacts for req in first_step.requires)
+                    if all_met:
+                        return [first_step]
+                else:
+                    return [first_step]
+            return []
+
+        # Find steps that are in the next_step_ids set (sequential progression)
         for step in workflow_steps:
             if step.id in completed_step_ids or step.id in running_step_ids:
                 continue
 
+            # Must be in the next_step_ids set (respects sequential workflow chain)
+            if step.id not in next_step_ids:
+                continue
+
             # Check if all required artifacts exist and are available
             if step.requires:
                 all_met = all(req in artifacts for req in step.requires)
@@ -342,7 +381,7 @@ class ParallelStepExecutor:
                     tasks_map[task] = step
             
             # All tasks completed successfully - collect results
-            for task, step in tasks_map.items():
+            for task in tasks_map:
                 result = await task
                 results.append(result)
         
@@ -416,7 +455,7 @@ class ParallelStepExecutor:
             
             # Re-raise the first exception for upstream handling
             if eg.exceptions:
-                raise eg.exceptions[0]
+                raise eg.exceptions[0] from None
 
         # Sort by step.id for deterministic ordering
         results.sort(key=lambda r: r.step.id)