tapps-agents 3.5.38__py3-none-any.whl → 3.5.40__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/enforcer.py

@@ -22,6 +22,8 @@ from pathlib import Path
 from typing import Literal, TypedDict
 
 from tapps_agents.core.llm_behavior import EnforcementConfig
+from tapps_agents.workflow.intent_detector import IntentDetector, WorkflowType
+from tapps_agents.workflow.message_formatter import MessageConfig, MessageFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -140,6 +142,14 @@ class WorkflowEnforcer:
             # Load config from file
             self.config = self._load_config(config_path)
 
+        # Initialize intent detector and message formatter (ENH-001-S2, S3)
+        self._intent_detector = IntentDetector()
+        self._message_formatter = MessageFormatter(MessageConfig(
+            use_emoji=True,
+            show_benefits=self.config.suggest_workflows,
+            show_override=True,
+        ))
+
         logger.info(
             f"WorkflowEnforcer initialized with mode={self.config.mode}, "
             f"confidence_threshold={self.config.confidence_threshold}"
@@ -322,55 +332,58 @@ class WorkflowEnforcer:
             - allow: Empty message
 
         Note:
-            Story 1 uses basic message templates.
-            Story 3 will add MessageFormatter for rich, context-aware messages.
+            Uses MessageFormatter (ENH-001-S3) for rich, context-aware messages.
+            Uses IntentDetector (ENH-001-S2) for workflow detection and confidence.
         """
         # Determine should_block flag
         should_block = action == "block" and self.config.block_direct_edits
 
-        # Generate message based on action
+        # Detect intent and get confidence (ENH-001-S2 integration)
+        detection_result = self._intent_detector.detect_workflow(
+            user_intent=user_intent,
+            file_path=file_path if file_path.exists() else None,
+        )
+        workflow = detection_result.workflow_type
+        confidence = detection_result.confidence
+
+        # Generate message using MessageFormatter (ENH-001-S3 integration)
         if action == "block":
             if self.config.suggest_workflows:
-                message = (
-                    f"⚠️ Direct file edit blocked: {file_path}\n\n"
-                    f"TappsCodingAgents workflows provide:\n"
-                    f"  • Automatic testing (80%+ coverage)\n"
-                    f"  • Quality gates (75+ score required)\n"
-                    f"  • Comprehensive documentation\n"
-                    f"  • Early bug detection\n\n"
-                    f"Suggested workflow:\n"
-                    f"  @simple-mode *build \"{user_intent or 'Implement feature'}\"\n\n"
-                    f"To bypass enforcement, use: --skip-enforcement flag"
+                message = self._message_formatter.format_blocking_message(
+                    workflow=workflow,
+                    user_intent=user_intent,
+                    file_path=file_path,
+                    confidence=confidence,
                 )
             else:
                 message = (
-                    f"⚠️ Direct file edit blocked: {file_path}\n"
+                    f"Direct file edit blocked: {file_path}\n"
                     f"Use --skip-enforcement flag to bypass."
                 )
         elif action == "warn":
             if self.config.suggest_workflows:
-                message = (
-                    f"💡 Consider using a workflow for: {file_path}\n"
-                    f"Suggested: @simple-mode *build \"{user_intent or 'Implement feature'}\"\n"
-                    f"(Proceeding with direct edit...)"
+                message = self._message_formatter.format_warning_message(
+                    workflow=workflow,
+                    user_intent=user_intent,
+                    confidence=confidence,
                 )
             else:
-                message = f"💡 Consider using a workflow for: {file_path}"
+                message = f"Consider using a workflow for: {file_path}"
         else:  # allow
-            message = ""
+            message = self._message_formatter.format_allow_message()
 
-        # Create decision
+        # Create decision with actual confidence from intent detection
         decision: EnforcementDecision = {
             "action": action,
             "message": message,
             "should_block": should_block,
-            "confidence": 0.0,  # Story 1: No intent detection yet
+            "confidence": confidence,
         }
 
         # Log decision
         logger.debug(
             f"Enforcement decision: action={action}, should_block={should_block}, "
-            f"file_path={file_path}, user_intent={user_intent[:100]}"
+            f"file_path={file_path}, workflow={workflow.value}, confidence={confidence:.1f}%"
         )
 
         return decision

tapps_agents/workflow/message_formatter.py

@@ -0,0 +1,188 @@
+"""
+Message Formatter - ENH-001-S3
+
+Formats enforcement messages for the Workflow Enforcement System.
+Provides rich, context-aware messages for blocking and warning modes
+with support for CLI and IDE output formats.
+
+Design Principles:
+    - Separation of Concerns: Message formatting separate from enforcement logic
+    - Configurable: Emoji support, output format selection
+    - Context-Aware: Messages tailored to detected workflow type
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Literal
+
+from tapps_agents.workflow.intent_detector import WorkflowType
+
+logger = logging.getLogger(__name__)
+
+
+class OutputFormat(str, Enum):
+    """Output format for messages."""
+
+    CLI = "cli"
+    IDE = "ide"
+
+
+@dataclass
+class MessageConfig:
+    """Configuration for message formatting."""
+
+    use_emoji: bool = True
+    output_format: OutputFormat = OutputFormat.CLI
+    show_benefits: bool = True
+    show_override: bool = True
+
+
+# Workflow-specific benefits
+WORKFLOW_BENEFITS: dict[WorkflowType, list[str]] = {
+    WorkflowType.BUILD: [
+        "Automatic testing (80%+ coverage)",
+        "Quality gates (75+ score required)",
+        "Comprehensive documentation",
+        "Early bug detection",
+    ],
+    WorkflowType.FIX: [
+        "Root cause analysis",
+        "Regression test generation",
+        "Fix verification",
+        "Related issue detection",
+    ],
+    WorkflowType.REFACTOR: [
+        "Behavior preservation tests",
+        "Code quality improvement",
+        "Technical debt reduction",
+        "Safe incremental changes",
+    ],
+    WorkflowType.REVIEW: [
+        "Security vulnerability detection",
+        "Code quality scoring",
+        "Best practice suggestions",
+        "Maintainability analysis",
+    ],
+}
+
+
+class MessageFormatter:
+    """
+    Formats enforcement messages for workflow enforcement system.
+
+    Provides rich, context-aware messages for blocking and warning modes
+    with configurable emoji support and output format selection.
+    """
+
+    def __init__(self, config: MessageConfig | None = None) -> None:
+        """Initialize formatter with optional configuration."""
+        self.config = config or MessageConfig()
+
+    def format_blocking_message(
+        self,
+        workflow: WorkflowType,
+        user_intent: str,
+        file_path: Path,
+        confidence: float,
+    ) -> str:
+        """
+        Format blocking mode message with benefits and override instructions.
+
+        Args:
+            workflow: Detected workflow type
+            user_intent: User's intent description
+            file_path: Path to file being edited
+            confidence: Detection confidence (0-100)
+
+        Returns:
+            Formatted blocking message
+        """
+        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: {path_display}".strip(),
+            "",
+            f"Detected intent: {workflow.value} (confidence: {confidence:.0f}%)",
+            "",
+        ]
+
+        if self.config.show_benefits:
+            lines.append("TappsCodingAgents workflows provide:")
+            for benefit in self._get_workflow_benefits(workflow):
+                bullet = "  * " if self.config.output_format == OutputFormat.IDE else "  - "
+                lines.append(f"{bullet}{benefit}")
+            lines.append("")
+
+        lines.append("Suggested workflow:")
+        lines.append(f'  @simple-mode {workflow.value} "{intent_display}"')
+        lines.append("")
+
+        if self.config.show_override:
+            lines.extend(self._get_override_instructions())
+
+        return "\n".join(lines)
+
+    def format_warning_message(
+        self,
+        workflow: WorkflowType,
+        user_intent: str,
+        confidence: float,
+    ) -> str:
+        """
+        Format warning mode message (lighter suggestion).
+
+        Args:
+            workflow: Detected workflow type
+            user_intent: User's intent description
+            confidence: Detection confidence (0-100)
+
+        Returns:
+            Formatted warning message
+        """
+        emoji = self._get_emoji("warn") if self.config.use_emoji else ""
+        intent_display = user_intent or "Implement feature"
+
+        lines = [
+            f"{emoji}Consider using a workflow (confidence: {confidence:.0f}%)".strip(),
+            f'Suggested: @simple-mode {workflow.value} "{intent_display}"',
+            "(Proceeding with direct edit...)",
+        ]
+
+        return "\n".join(lines)
+
+    def format_allow_message(self) -> str:
+        """Format allow message (empty for silent mode)."""
+        return ""
+
+    def _get_emoji(self, action: Literal["block", "warn", "allow"]) -> str:
+        """Get emoji for action type."""
+        emojis = {
+            "block": "\u26a0\ufe0f ",  # Warning sign
+            "warn": "\U0001f4a1 ",  # Light bulb
+            "allow": "\u2705 ",  # Check mark
+        }
+        return emojis.get(action, "")
+
+    def _get_workflow_benefits(self, workflow: WorkflowType) -> list[str]:
+        """Get benefits list for workflow type."""
+        return WORKFLOW_BENEFITS.get(workflow, WORKFLOW_BENEFITS[WorkflowType.BUILD])
+
+    def _get_override_instructions(self) -> list[str]:
+        """Get override instructions based on output format."""
+        if self.config.output_format == OutputFormat.IDE:
+            return [
+                "To bypass enforcement:",
+                "  * Use --skip-enforcement flag",
+                "  * Or set enforcement.mode: silent in config",
+            ]
+        return [
+            "To bypass enforcement:",
+            "  - Use --skip-enforcement flag",
+            "  - Or set enforcement.mode: silent in .tapps-agents/config.yaml",
+        ]

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)