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

plugins/agent_orchestrator/activity_monitor.py

@@ -0,0 +1,181 @@
+"""Monitor agent panes for completion via MD5 hashing."""
+
+import asyncio
+import hashlib
+import logging
+from typing import Callable, Dict, Awaitable
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentState:
+    """Tracks activity state for a single agent."""
+
+    name: str
+    last_hash: str = ""
+    idle_count: int = 0
+
+
+class ActivityMonitor:
+    """Monitor agent panes for completion via MD5 hashing.
+
+    Polls tmux panes at regular intervals and computes MD5 hash of content.
+    When content remains unchanged for a threshold number of checks,
+    the agent is considered complete.
+    """
+
+    def __init__(
+        self,
+        orchestrator,
+        on_agent_complete: Callable[[str, str, str], Awaitable[None]],
+        poll_interval: int = 2,
+        idle_threshold: int = 3,
+        capture_lines: int = 500,
+    ):
+        """Initialize activity monitor.
+
+        Args:
+            orchestrator: AgentOrchestrator instance for capturing output
+            on_agent_complete: Async callback(name, duration, output) when agent completes
+            poll_interval: Seconds between polls
+            idle_threshold: Number of unchanged polls before considering done
+            capture_lines: Lines to capture when agent completes
+        """
+        self.orchestrator = orchestrator
+        self.on_agent_complete = on_agent_complete
+        self.poll_interval = poll_interval
+        self.idle_threshold = idle_threshold
+        self.capture_lines = capture_lines
+
+        self.tracked: Dict[str, AgentState] = {}
+        self._running = False
+        self._task = None
+
+    def track(self, name: str) -> None:
+        """Start tracking an agent.
+
+        Args:
+            name: Agent name to track
+        """
+        if name not in self.tracked:
+            self.tracked[name] = AgentState(name=name)
+            logger.debug(f"Now tracking agent: {name}")
+
+    def untrack(self, name: str) -> None:
+        """Stop tracking an agent.
+
+        Args:
+            name: Agent name to stop tracking
+        """
+        if name in self.tracked:
+            del self.tracked[name]
+            logger.debug(f"Stopped tracking agent: {name}")
+
+    def is_tracking(self, name: str) -> bool:
+        """Check if agent is being tracked.
+
+        Args:
+            name: Agent name
+
+        Returns:
+            True if agent is tracked
+        """
+        return name in self.tracked
+
+    async def start(self) -> None:
+        """Start monitoring loop."""
+        self._running = True
+        logger.info(
+            f"Activity monitor started (poll={self.poll_interval}s, "
+            f"threshold={self.idle_threshold})"
+        )
+
+        while self._running:
+            try:
+                await self._check_agents()
+            except Exception as e:
+                logger.error(f"Error in activity monitor: {e}")
+
+            await asyncio.sleep(self.poll_interval)
+
+    async def stop(self) -> None:
+        """Stop monitoring loop."""
+        self._running = False
+        logger.info("Activity monitor stopped")
+
+    async def _check_agents(self) -> None:
+        """Check all tracked agents for completion."""
+        if not self.tracked:
+            return
+
+        completed = []
+
+        for name, state in list(self.tracked.items()):
+            try:
+                # Capture current pane content
+                content = self.orchestrator.capture_output(name, self.capture_lines)
+
+                if not content:
+                    # Session might be gone
+                    continue
+
+                current_hash = hashlib.md5(content.encode()).hexdigest()
+
+                if current_hash == state.last_hash:
+                    # No change - increment idle count
+                    state.idle_count += 1
+                    logger.debug(
+                        f"Agent {name} idle count: {state.idle_count}/{self.idle_threshold}"
+                    )
+
+                    if state.idle_count >= self.idle_threshold:
+                        # Agent is done
+                        completed.append((name, content))
+                else:
+                    # Content changed - reset idle count
+                    if state.idle_count > 0:
+                        logger.debug(f"Agent {name} activity detected, resetting idle count")
+                    state.idle_count = 0
+                    state.last_hash = current_hash
+
+            except Exception as e:
+                logger.error(f"Error checking agent {name}: {e}")
+
+        # Notify completions
+        for name, content in completed:
+            agent = self.orchestrator.get_agent(name)
+            duration = agent.duration if agent else "?"
+
+            logger.info(f"Agent {name} completed @ {duration}")
+
+            # Remove from tracking before callback to prevent re-detection
+            self.untrack(name)
+
+            try:
+                await self.on_agent_complete(name, duration, content)
+            except Exception as e:
+                logger.error(f"Error in completion callback for {name}: {e}")
+
+    def get_tracked_agents(self) -> list:
+        """Get list of currently tracked agent names.
+
+        Returns:
+            List of agent names
+        """
+        return list(self.tracked.keys())
+
+    def reset_agent_state(self, name: str) -> None:
+        """Reset idle state for an agent.
+
+        Useful when sending a message to an agent that should restart
+        activity monitoring.
+
+        Args:
+            name: Agent name
+        """
+        if name in self.tracked:
+            self.tracked[name].idle_count = 0
+            self.tracked[name].last_hash = ""
+            logger.debug(f"Reset activity state for agent: {name}")

plugins/agent_orchestrator/file_attacher.py

@@ -0,0 +1,77 @@
+"""Read and format files for attachment to agent tasks."""
+
+from pathlib import Path
+from typing import List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class FileAttacher:
+    """Read and format files for attachment to agent tasks."""
+
+    def attach(self, file_paths: List[str]) -> str:
+        """Read files and format with delimiters.
+
+        Args:
+            file_paths: List of file paths to attach
+
+        Returns:
+            Formatted string with all file contents
+        """
+        parts = []
+
+        for file_path in file_paths:
+            content = self._read_file(file_path)
+            if content is not None:
+                parts.append(self._format_file(file_path, content))
+            else:
+                logger.warning(f"Could not read file: {file_path}")
+
+        return "\n\n".join(parts)
+
+    def _read_file(self, file_path: str) -> Optional[str]:
+        """Read file contents.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            File contents or None if file cannot be read
+        """
+        path = Path(file_path)
+
+        if not path.exists():
+            logger.warning(f"File does not exist: {file_path}")
+            return None
+
+        if not path.is_file():
+            logger.warning(f"Path is not a file: {file_path}")
+            return None
+
+        try:
+            return path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            # Try with different encoding
+            try:
+                return path.read_text(encoding="latin-1")
+            except Exception as e:
+                logger.error(f"Failed to read file {file_path}: {e}")
+                return None
+        except Exception as e:
+            logger.error(f"Failed to read file {file_path}: {e}")
+            return None
+
+    def _format_file(self, file_path: str, content: str) -> str:
+        """Format file with delimiters.
+
+        Args:
+            file_path: Original file path
+            content: File contents
+
+        Returns:
+            Formatted file block
+        """
+        return f"""--file_start {file_path}--
+{content}
+--file_end--"""

plugins/agent_orchestrator/message_injector.py

@@ -0,0 +1,135 @@
+"""Inject messages back into conversation as user role."""
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class MessageInjector:
+    """Inject messages back into conversation as user role.
+
+    Formats messages with delimiters and adds them to the conversation
+    history. Can optionally trigger the LLM to continue generating.
+    """
+
+    def __init__(self, event_bus, conversation_manager):
+        """Initialize message injector.
+
+        Args:
+            event_bus: Event bus for emitting events
+            conversation_manager: Conversation manager for adding messages
+        """
+        self.event_bus = event_bus
+        self.conversation_manager = conversation_manager
+
+    async def inject(
+        self,
+        source: str,
+        content: str,
+        trigger_llm: bool = True,
+        metadata: Optional[dict] = None,
+    ) -> bool:
+        """Inject message into conversation.
+
+        Args:
+            source: Source identifier (e.g., agent name)
+            content: Message content
+            trigger_llm: Whether to trigger LLM to continue
+            metadata: Optional metadata dict
+
+        Returns:
+            True if injection was successful
+        """
+        # Format with XML tags (hidden from user display)
+        formatted = f"""<sys_msg>
+{content}
+</sys_msg>"""
+
+        # Emit pre-injection event (plugins can modify/block)
+        context = {
+            "source": source,
+            "content": formatted,
+            "original_content": content,
+            "trigger_llm": trigger_llm,
+            "metadata": metadata or {},
+            "blocked": False,
+        }
+
+        try:
+            # Try to emit pre-injection event
+            from core.events.types import EventType
+
+            if hasattr(EventType, "PRE_MESSAGE_INJECT"):
+                context = await self.event_bus.emit_with_hooks(
+                    EventType.PRE_MESSAGE_INJECT, context, "message_injector"
+                )
+        except Exception as e:
+            logger.debug(f"Pre-injection event not available: {e}")
+
+        if context.get("blocked"):
+            logger.info(f"Message injection blocked for source: {source}")
+            return False
+
+        # Add to conversation as user message
+        try:
+            self.conversation_manager.add_message(
+                role="user", content=context["content"]
+            )
+            logger.info(f"Injected message from: {source}")
+        except Exception as e:
+            logger.error(f"Failed to inject message: {e}")
+            return False
+
+        # Emit post-injection event
+        try:
+            from core.events.types import EventType
+
+            if hasattr(EventType, "POST_MESSAGE_INJECT"):
+                await self.event_bus.emit_with_hooks(EventType.POST_MESSAGE_INJECT, context, "message_injector")
+        except Exception as e:
+            logger.debug(f"Post-injection event not available: {e}")
+
+        # Trigger LLM to continue
+        if context.get("trigger_llm", True):
+            try:
+                from core.events.types import EventType
+
+                if hasattr(EventType, "TRIGGER_LLM_CONTINUE"):
+                    await self.event_bus.emit_with_hooks(EventType.TRIGGER_LLM_CONTINUE, {}, "message_injector")
+            except Exception as e:
+                logger.debug(f"Trigger LLM continue event not available: {e}")
+
+        return True
+
+    async def inject_raw(
+        self,
+        content: str,
+        trigger_llm: bool = False,
+    ) -> bool:
+        """Inject raw content without formatting.
+
+        Args:
+            content: Raw content to inject
+            trigger_llm: Whether to trigger LLM to continue
+
+        Returns:
+            True if injection was successful
+        """
+        try:
+            self.conversation_manager.add_message(role="user", content=content)
+            logger.info("Injected raw message")
+
+            if trigger_llm:
+                try:
+                    from core.events.types import EventType
+
+                    if hasattr(EventType, "TRIGGER_LLM_CONTINUE"):
+                        await self.event_bus.emit_with_hooks(EventType.TRIGGER_LLM_CONTINUE, {}, "message_injector")
+                except Exception:
+                    pass
+
+            return True
+        except Exception as e:
+            logger.error(f"Failed to inject raw message: {e}")
+            return False

plugins/agent_orchestrator/models.py

@@ -0,0 +1,48 @@
+"""Data models for agent orchestration."""
+
+from dataclasses import dataclass, field
+from typing import List
+import time
+
+
+@dataclass
+class AgentTask:
+    """Parsed agent task from XML."""
+
+    name: str
+    task: str
+    files: List[str] = field(default_factory=list)
+
+
+@dataclass
+class AgentSession:
+    """Running agent session."""
+
+    name: str
+    full_name: str
+    status: str  # running, idle
+    start_time: float
+
+    @property
+    def duration(self) -> str:
+        """Get formatted duration since start."""
+        elapsed = time.time() - self.start_time
+        minutes = int(elapsed // 60)
+        seconds = int(elapsed % 60)
+        return f"{minutes}m{seconds:02d}s"
+
+
+@dataclass
+class ParsedCommand:
+    """Parsed XML command from LLM response."""
+
+    type: str  # agent, message, stop, status, capture, clone, team, broadcast
+    agents: List[AgentTask] = field(default_factory=list)
+    target: str = ""
+    targets: List[str] = field(default_factory=list)
+    content: str = ""
+    lines: int = 50
+    pattern: str = ""
+    lead: str = ""
+    workers: int = 3
+    conversation: bool = False