claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/commander/proxy/output_handler.py

@@ -0,0 +1,191 @@
+"""Handles output from Claude Code instances."""
+
+import hashlib
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from claude_mpm.commander.llm.summarizer import OutputSummarizer
+from claude_mpm.commander.tmux_orchestrator import TmuxOrchestrator
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OutputChunk:
+    """Represents a chunk of output from an instance."""
+
+    instance_name: str
+    raw_output: str
+    summary: str | None = None
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+    is_complete: bool = False
+
+
+class OutputHandler:
+    """Captures and summarizes output from Claude Code instances."""
+
+    # Patterns that indicate Claude Code has finished responding
+    COMPLETION_PATTERNS = [
+        "> ",  # Default prompt
+        "$ ",  # Shell prompt
+        "\n> ",  # Prompt on new line
+    ]
+
+    def __init__(
+        self,
+        orchestrator: TmuxOrchestrator,
+        summarizer: OutputSummarizer | None = None,
+    ):
+        """Initialize OutputHandler.
+
+        Args:
+            orchestrator: TmuxOrchestrator for capturing output from panes.
+            summarizer: Optional OutputSummarizer for long output.
+        """
+        self.orchestrator = orchestrator
+        self.summarizer = summarizer
+        self._output_buffers: dict[str, str] = {}
+        self._last_output_hash: dict[str, str] = {}
+
+    async def capture_output(self, pane_target: str, lines: int = 100) -> str:
+        """Capture raw output from a pane.
+
+        Args:
+            pane_target: Tmux pane target.
+            lines: Number of lines to capture from history.
+
+        Returns:
+            Captured output as string.
+        """
+        logger.debug(f"Capturing {lines} lines from pane {pane_target}")
+        return self.orchestrator.capture_output(pane_target, lines=lines)
+
+    def _hash_output(self, output: str) -> str:
+        """Generate hash of output for change detection.
+
+        Args:
+            output: Output text to hash.
+
+        Returns:
+            MD5 hash of the output.
+        """
+        # MD5 is sufficient for non-security change detection
+        return hashlib.md5(output.encode(), usedforsecurity=False).hexdigest()  # nosec B324
+
+    async def get_new_output(self, instance_name: str, pane_target: str) -> str | None:
+        """Get only new output since last capture (diff-based).
+
+        Args:
+            instance_name: Name of the instance.
+            pane_target: Tmux pane target.
+
+        Returns:
+            New output since last capture, or None if no change.
+        """
+        current_output = await self.capture_output(pane_target)
+        current_hash = self._hash_output(current_output)
+
+        # Check if output has changed
+        last_hash = self._last_output_hash.get(instance_name)
+        if last_hash == current_hash:
+            logger.debug(f"No new output for {instance_name}")
+            return None
+
+        # Update hash
+        self._last_output_hash[instance_name] = current_hash
+
+        # For first capture, return full output
+        if last_hash is None:
+            logger.debug(f"First capture for {instance_name}")
+            return current_output
+
+        # Extract new lines by comparing with buffered output
+        last_output = self._output_buffers.get(instance_name, "")
+
+        # Simple diff: if current output contains last output as prefix,
+        # return the difference
+        if current_output.startswith(last_output):
+            new_output = current_output[len(last_output) :]
+            logger.debug(f"New output for {instance_name}: {len(new_output)} chars")
+            return new_output
+
+        # If not a simple append, return full current output
+        # (pane may have been cleared or output wrapped)
+        logger.debug(f"Output changed significantly for {instance_name}")
+        return current_output
+
+    async def process_output(
+        self, instance_name: str, pane_target: str, context: str | None = None
+    ) -> OutputChunk | None:
+        """Capture new output and optionally summarize.
+
+        Args:
+            instance_name: Name of the instance.
+            pane_target: Tmux pane target.
+            context: Optional context (e.g., what command was sent).
+
+        Returns:
+            OutputChunk with raw and summarized output, or None if no new output.
+        """
+        # Get new output
+        new_output = await self.get_new_output(instance_name, pane_target)
+        if new_output is None:
+            return None
+
+        # Update buffer with full current output
+        current_output = await self.capture_output(pane_target)
+        self._output_buffers[instance_name] = current_output
+
+        # Create chunk
+        chunk = OutputChunk(
+            instance_name=instance_name,
+            raw_output=new_output,
+            is_complete=self.detect_completion(new_output),
+        )
+
+        # Summarize if needed and summarizer is available
+        if self.summarizer and self.summarizer.needs_summarization(new_output):
+            try:
+                logger.debug(f"Summarizing output for {instance_name}")
+                chunk.summary = await self.summarizer.summarize(new_output, context)
+            except Exception as e:
+                logger.error(f"Failed to summarize output: {e}")
+                # Continue without summary
+
+        return chunk
+
+    def detect_completion(self, output: str) -> bool:
+        """Detect if Claude Code has finished responding (prompt returned).
+
+        Args:
+            output: Output text to check.
+
+        Returns:
+            True if output ends with a completion pattern.
+        """
+        if not output:
+            return False
+
+        # Strip only trailing newlines/tabs/carriage returns, keep spaces
+        output_check = output.rstrip("\n\t\r")
+
+        for pattern in self.COMPLETION_PATTERNS:
+            # Check if output ends with the exact pattern
+            if output_check.endswith(pattern):
+                return True
+
+            # Special handling for trailing whitespace:
+            # If pattern has trailing space and output has extra trailing spaces,
+            # still match (e.g., ">  " should match "> " pattern)
+            if pattern.endswith(" "):
+                pattern_base = pattern.rstrip(" ")
+                # Check if after stripping spaces, we have pattern_base followed by at least one space
+                output_stripped_spaces = output_check.rstrip(" ")
+                # Check: output must end with pattern_base + at least one space
+                if output_stripped_spaces.endswith(pattern_base) and len(
+                    output_check
+                ) > len(output_stripped_spaces):
+                    return True
+
+        return False

claude_mpm/commander/proxy/relay.py

@@ -0,0 +1,155 @@
+"""Relays output from instances to user."""
+
+import asyncio
+import logging
+from typing import Awaitable, Callable
+
+from .formatter import OutputFormatter
+from .output_handler import OutputHandler
+
+logger = logging.getLogger(__name__)
+
+
+class OutputRelay:
+    """Relays instance output to user with summarization."""
+
+    def __init__(
+        self,
+        handler: OutputHandler,
+        formatter: OutputFormatter,
+        on_output: Callable[[str], Awaitable[None]] | None = None,
+    ):
+        """Initialize OutputRelay.
+
+        Args:
+            handler: OutputHandler for capturing output.
+            formatter: OutputFormatter for display formatting.
+            on_output: Optional callback to display output.
+        """
+        self.handler = handler
+        self.formatter = formatter
+        self.on_output = on_output
+        self._monitoring: dict[str, asyncio.Task] = {}
+
+    async def _monitor_output(
+        self, instance_name: str, pane_target: str, poll_interval: float
+    ) -> None:
+        """Monitor output from an instance continuously.
+
+        Args:
+            instance_name: Name of the instance.
+            pane_target: Tmux pane target.
+            poll_interval: Seconds between polls.
+        """
+        logger.info(f"Starting output relay for {instance_name}")
+
+        try:
+            while True:
+                # Process output
+                chunk = await self.handler.process_output(instance_name, pane_target)
+
+                # If we got new output, format and display
+                if chunk and self.on_output:
+                    # Use summary format if available, otherwise raw
+                    if chunk.summary:
+                        output = self.formatter.format_summary(chunk)
+                    else:
+                        output = self.formatter.format_raw(chunk)
+
+                    await self.on_output(output)
+
+                # Wait before next poll
+                await asyncio.sleep(poll_interval)
+
+        except asyncio.CancelledError:
+            logger.info(f"Output relay cancelled for {instance_name}")
+            raise
+        except Exception as e:
+            logger.error(f"Error in output relay for {instance_name}: {e}")
+            if self.on_output:
+                error_msg = self.formatter.format_error(instance_name, str(e))
+                try:
+                    await self.on_output(error_msg)
+                except Exception:  # nosec B110
+                    # Intentionally ignore errors in error reporting to avoid cascading failures
+                    pass
+            raise
+
+    async def start_relay(
+        self, instance_name: str, pane_target: str, poll_interval: float = 0.5
+    ) -> None:
+        """Start relaying output from an instance.
+
+        Args:
+            instance_name: Name of the instance.
+            pane_target: Tmux pane target.
+            poll_interval: Seconds between polls (default: 0.5).
+        """
+        # Stop existing relay if any
+        if instance_name in self._monitoring:
+            await self.stop_relay(instance_name)
+
+        # Start monitoring task
+        task = asyncio.create_task(
+            self._monitor_output(instance_name, pane_target, poll_interval)
+        )
+        self._monitoring[instance_name] = task
+
+        logger.info(f"Started output relay for {instance_name}")
+
+    async def stop_relay(self, instance_name: str) -> None:
+        """Stop relaying output from an instance.
+
+        Args:
+            instance_name: Name of the instance.
+        """
+        task = self._monitoring.pop(instance_name, None)
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+            logger.info(f"Stopped output relay for {instance_name}")
+
+    async def stop_all(self) -> None:
+        """Stop all output relays."""
+        logger.info("Stopping all output relays")
+
+        # Cancel all tasks
+        tasks = list(self._monitoring.values())
+        for task in tasks:
+            task.cancel()
+
+        # Wait for cancellation
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+        self._monitoring.clear()
+
+    async def get_latest_output(
+        self, instance_name: str, pane_target: str, context: str | None = None
+    ) -> str:
+        """Get and format latest output from instance.
+
+        Args:
+            instance_name: Name of the instance.
+            pane_target: Tmux pane target.
+            context: Optional context for summarization.
+
+        Returns:
+            Formatted output string.
+        """
+        # Process output once
+        chunk = await self.handler.process_output(
+            instance_name, pane_target, context=context
+        )
+
+        if chunk is None:
+            return self.formatter.format_status(instance_name, "No new output")
+
+        # Format with summary if available
+        if chunk.summary:
+            return self.formatter.format_summary(chunk)
+
+        return self.formatter.format_raw(chunk)