kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

plugins/workflow_enforcement_plugin.py

@@ -13,6 +13,7 @@ from enum import Enum
 from typing import Dict, List, Optional, Any
 
 from core.events.models import EventType, HookPriority
+from core.io.visual_effects import AgnosterSegment
 
 logger = logging.getLogger(__name__)
 
@@ -57,23 +58,32 @@ class WorkflowContext:
 
 class WorkflowEnforcementPlugin:
     """Plugin that enforces todo completion with tool calling verification."""
-    
-    def __init__(self, state_manager, event_bus, renderer, config):
-        """Initialize workflow enforcement plugin."""
-        self.state_manager = state_manager
+
+    def __init__(self, name: str = "workflow_enforcement",
+                 event_bus=None, renderer=None, config=None):
+        """Initialize workflow enforcement plugin.
+
+        Args:
+            name: Plugin name.
+            event_bus: Event bus for hook registration.
+            renderer: Terminal renderer.
+            config: Configuration manager.
+        """
+        self.name = name
         self.event_bus = event_bus
         self.renderer = renderer
-        self.config = config
+        self.config = config or {}
         
         # Workflow state
         self.workflow_context = WorkflowContext()
         
-        # Configuration
-        self.enabled = config.get("workflow_enforcement.enabled", True)
-        self.require_tool_calls = config.get("workflow_enforcement.require_tool_calls", True)
-        self.confirmation_timeout = config.get("workflow_enforcement.confirmation_timeout", 300)  # 5 minutes
-        self.bypass_keywords = config.get("workflow_enforcement.bypass_keywords", 
-                                         ["bypass", "skip", "blocked", "issue", "problem"])
+        # Configuration - use self.config with safe get
+        cfg = self.config if hasattr(self.config, 'get') else {}
+        self.enabled = cfg.get("workflow_enforcement.enabled", True) if cfg else True
+        self.require_tool_calls = cfg.get("workflow_enforcement.require_tool_calls", True) if cfg else True
+        self.confirmation_timeout = cfg.get("workflow_enforcement.confirmation_timeout", 300) if cfg else 300
+        self.bypass_keywords = cfg.get("workflow_enforcement.bypass_keywords",
+                                       ["bypass", "skip", "blocked", "issue", "problem"]) if cfg else ["bypass", "skip", "blocked", "issue", "problem"]
         
         logger.info("Workflow Enforcement Plugin initialized")
     
@@ -106,9 +116,80 @@ class WorkflowEnforcementPlugin:
 
     async def initialize(self):
         """Initialize the plugin."""
-        # Load any persistent workflow state
-        await self._load_workflow_state()
+        # Register status view
+        await self._register_status_view()
+
         logger.info("Workflow enforcement plugin initialized")
+
+    async def _register_status_view(self) -> None:
+        """Register workflow enforcement status view."""
+        try:
+            if (self.renderer and
+                hasattr(self.renderer, 'status_renderer') and
+                self.renderer.status_renderer and
+                hasattr(self.renderer.status_renderer, 'status_registry') and
+                self.renderer.status_renderer.status_registry):
+
+                from core.io.status_renderer import StatusViewConfig, BlockConfig
+
+                view = StatusViewConfig(
+                    name="Workflow Enforcement",
+                    plugin_source="workflow_enforcement",
+                    priority=450,
+                    blocks=[BlockConfig(
+                        width_fraction=1.0,
+                        content_provider=self._get_status_content,
+                        title="Workflow",
+                        priority=100
+                    )],
+                )
+
+                registry = self.renderer.status_renderer.status_registry
+                registry.register_status_view("workflow_enforcement", view)
+                logger.info("Registered 'Workflow Enforcement' status view")
+
+        except Exception as e:
+            logger.error(f"Failed to register status view: {e}")
+
+    def _get_status_content(self) -> List[str]:
+        """Get workflow enforcement status (agnoster style)."""
+        try:
+            # Only show if workflow is active
+            if self.workflow_context.state == WorkflowState.INACTIVE:
+                return []
+
+            seg = AgnosterSegment()
+
+            if self.workflow_context.state == WorkflowState.ENFORCING:
+                current_todo = self._get_current_todo()
+                if current_todo:
+                    progress = f"{current_todo.index + 1}/{len(self.workflow_context.todo_items)}"
+                    seg.add_lime("Workflow", "dark")
+                    seg.add_cyan(f"Todo {progress}", "dark")
+                    seg.add_neutral(current_todo.text[:30] + "..." if len(current_todo.text) > 30 else current_todo.text, "mid")
+                else:
+                    seg.add_lime("Workflow", "dark")
+                    seg.add_cyan("Enforcing", "dark")
+            elif self.workflow_context.state == WorkflowState.WAITING_CONFIRMATION:
+                seg.add_lime("Workflow", "dark")
+                seg.add_cyan("Awaiting Confirm", "dark")
+            elif self.workflow_context.state == WorkflowState.BLOCKED:
+                seg.add_lime("Workflow", "dark")
+                seg.add_neutral("Blocked", "mid")
+            elif self.workflow_context.state == WorkflowState.TODO_DETECTED:
+                seg.add_lime("Workflow", "dark")
+                seg.add_cyan(f"{len(self.workflow_context.todo_items)} todos detected")
+            else:
+                seg.add_lime("Workflow", "dark")
+                seg.add_cyan(self.workflow_context.state.value.title(), "dark")
+
+            return [seg.render()]
+
+        except Exception as e:
+            logger.error(f"Error getting status content: {e}")
+            seg = AgnosterSegment()
+            seg.add_neutral("Workflow: Error", "dark")
+            return [seg.render()]
     
     async def register_hooks(self):
         """Register hooks for workflow enforcement."""
@@ -503,85 +584,6 @@ Would you like to retry this todo or skip it?
             "summary": "\n".join(summary_lines)
         }
     
-    async def _save_workflow_state(self):
-        """Save workflow state to persistent storage."""
-        try:
-            await self.state_manager.set_state("workflow_enforcement", {
-                "workflow_context": {
-                    "original_request": self.workflow_context.original_request,
-                    "current_todo_index": self.workflow_context.current_todo_index,
-                    "state": self.workflow_context.state.value,
-                    "bypass_requested": self.workflow_context.bypass_requested,
-                    "bypass_reason": self.workflow_context.bypass_reason,
-                    "todo_items": [
-                        {
-                            "index": todo.index,
-                            "text": todo.text,
-                            "terminal_command": todo.terminal_command,
-                            "completed": todo.completed,
-                            "confirmed": todo.confirmed,
-                            "attempted": todo.attempted,
-                            "failure_reason": todo.failure_reason
-                        }
-                        for todo in self.workflow_context.todo_items
-                    ]
-                }
-            })
-        except Exception as e:
-            logger.warning(f"Failed to save workflow state: {e}")
-    
-    async def _load_workflow_state(self):
-        """Load workflow state from persistent storage."""
-        try:
-            state_data = await self.state_manager.get_state("workflow_enforcement")
-            if state_data and "workflow_context" in state_data:
-                context_data = state_data["workflow_context"]
-                
-                # Reconstruct workflow context
-                self.workflow_context.original_request = context_data.get("original_request", "")
-                self.workflow_context.current_todo_index = context_data.get("current_todo_index", 0)
-                self.workflow_context.state = WorkflowState(context_data.get("state", WorkflowState.INACTIVE.value))
-                self.workflow_context.bypass_requested = context_data.get("bypass_requested", False)
-                self.workflow_context.bypass_reason = context_data.get("bypass_reason", "")
-                
-                # Reconstruct todo items
-                todo_items_data = context_data.get("todo_items", [])
-                self.workflow_context.todo_items = [
-                    TodoItem(
-                        index=item["index"],
-                        text=item["text"],
-                        terminal_command=item.get("terminal_command"),
-                        completed=item.get("completed", False),
-                        confirmed=item.get("confirmed", False),
-                        attempted=item.get("attempted", False),
-                        failure_reason=item.get("failure_reason")
-                    )
-                    for item in todo_items_data
-                ]
-                
-                if self.workflow_context.state != WorkflowState.INACTIVE:
-                    logger.info(f"Restored workflow state: {self.workflow_context.state.value}")
-        except Exception as e:
-            logger.warning(f"Failed to load workflow state: {e}")
-    
-    def get_status_line(self) -> Dict[str, List[str]]:
-        """Return status information for display."""
-        if self.workflow_context.state == WorkflowState.INACTIVE:
-            return {"A": [], "B": [], "C": []}
-        
-        status_text = f"Workflow: {self.workflow_context.state.value.title()}"
-        
-        if self.workflow_context.state == WorkflowState.ENFORCING:
-            current_todo = self._get_current_todo()
-            if current_todo:
-                progress = f"{current_todo.index + 1}/{len(self.workflow_context.todo_items)}"
-                status_text = f"Workflow: Todo {progress}"
-        
-        return {
-            "A": [],
-            "B": [status_text],
-            "C": []
-        }
     
     async def _handle_workflow_response(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
         """Handle LLM responses during active workflow enforcement."""