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

plugins/agent_orchestrator/xml_parser.py

@@ -0,0 +1,191 @@
+"""Parse XML agent commands from LLM response text."""
+
+import re
+from typing import List
+
+from .models import AgentTask, ParsedCommand
+
+
+class XMLCommandParser:
+    """Parse XML agent commands from LLM response text."""
+
+    def parse(self, text: str) -> List[ParsedCommand]:
+        """Extract all agent commands from text."""
+        commands = []
+
+        # <agent>...</agent>
+        commands.extend(self._parse_agent_blocks(text))
+
+        # <message to="name">content</message>
+        commands.extend(self._parse_messages(text))
+
+        # <stop>name</stop>
+        commands.extend(self._parse_stops(text))
+
+        # <status />
+        commands.extend(self._parse_status(text))
+
+        # <capture>name lines</capture>
+        commands.extend(self._parse_captures(text))
+
+        # <clone>...</clone>
+        commands.extend(self._parse_clones(text))
+
+        # <team>...</team>
+        commands.extend(self._parse_teams(text))
+
+        # <broadcast to="pattern">content</broadcast>
+        commands.extend(self._parse_broadcasts(text))
+
+        return commands
+
+    def _parse_agent_blocks(self, text: str) -> List[ParsedCommand]:
+        """Parse <agent>...</agent> blocks."""
+        commands = []
+        pattern = r"<agent>(.*?)</agent>"
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            block = match.group(1)
+            agents = self._parse_agent_definitions(block)
+            if agents:
+                commands.append(ParsedCommand(type="agent", agents=agents))
+
+        return commands
+
+    def _parse_agent_definitions(self, block: str) -> List[AgentTask]:
+        """Parse individual agent definitions within <agent> block."""
+        agents = []
+
+        # Match <name>...</name> pattern (agent name is the tag name)
+        # Use negative lookahead to avoid matching <task>, <files>, <file>
+        pattern = r"<((?!task|files|file|todo|goal|n\d)\w[\w-]*)>(.*?)</\1>"
+
+        for match in re.finditer(pattern, block, re.DOTALL):
+            name = match.group(1)
+            content = match.group(2)
+
+            # Extract <task>...</task>
+            task_match = re.search(r"<task>(.*?)</task>", content, re.DOTALL)
+            task = task_match.group(1).strip() if task_match else ""
+
+            # Extract <files>...</files>
+            files = []
+            files_match = re.search(r"<files>(.*?)</files>", content, re.DOTALL)
+            if files_match:
+                file_pattern = r"<file>(.*?)</file>"
+                files = [f.strip() for f in re.findall(file_pattern, files_match.group(1))]
+
+            agents.append(AgentTask(name=name, task=task, files=files))
+
+        return agents
+
+    def _parse_messages(self, text: str) -> List[ParsedCommand]:
+        """Parse <message to="name">content</message>."""
+        commands = []
+        pattern = r'<message\s+to=["\']([^"\']+)["\']>(.*?)</message>'
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            target = match.group(1)
+            content = match.group(2).strip()
+            commands.append(
+                ParsedCommand(type="message", target=target, content=content)
+            )
+
+        return commands
+
+    def _parse_stops(self, text: str) -> List[ParsedCommand]:
+        """Parse <stop>name</stop> or <stop>name1, name2</stop>."""
+        commands = []
+        pattern = r"<stop>(.*?)</stop>"
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            content = match.group(1).strip()
+            # Split by comma or whitespace
+            targets = [t.strip() for t in re.split(r"[,\s]+", content) if t.strip()]
+            if targets:
+                commands.append(ParsedCommand(type="stop", targets=targets))
+
+        return commands
+
+    def _parse_status(self, text: str) -> List[ParsedCommand]:
+        """Parse <status></status> - requires proper open AND close tag."""
+        # Must have both opening and closing tag - ignores mentions in prose
+        if re.search(r"<status>\s*</status>", text):
+            return [ParsedCommand(type="status")]
+        return []
+
+    def _parse_captures(self, text: str) -> List[ParsedCommand]:
+        """Parse <capture>name [lines]</capture>."""
+        commands = []
+        pattern = r"<capture>(.*?)</capture>"
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            content = match.group(1).strip()
+            parts = content.split()
+
+            target = parts[0] if parts else ""
+            lines = 50  # default
+
+            if len(parts) > 1:
+                try:
+                    lines = int(parts[-1])
+                    # If last part is a number, target might be comma-separated names
+                    target = " ".join(parts[:-1]).replace(",", "").strip()
+                except ValueError:
+                    # Last part is not a number, everything is the target
+                    target = content
+
+            if target:
+                commands.append(
+                    ParsedCommand(type="capture", target=target, lines=lines)
+                )
+
+        return commands
+
+    def _parse_clones(self, text: str) -> List[ParsedCommand]:
+        """Parse <clone>...</clone> blocks."""
+        commands = []
+        pattern = r"<clone>(.*?)</clone>"
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            block = match.group(1)
+            agents = self._parse_agent_definitions(block)
+            for agent in agents:
+                commands.append(
+                    ParsedCommand(type="clone", agents=[agent], conversation=True)
+                )
+
+        return commands
+
+    def _parse_teams(self, text: str) -> List[ParsedCommand]:
+        """Parse <team lead="name" workers="N">...</team>."""
+        commands = []
+        pattern = r'<team\s+lead=["\']([^"\']+)["\']\s+workers=["\'](\d+)["\']>(.*?)</team>'
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            lead = match.group(1)
+            workers = int(match.group(2))
+            content = match.group(3)
+
+            # Parse task content as if it were an agent definition
+            agents = self._parse_agent_definitions(f"<{lead}>{content}</{lead}>")
+
+            commands.append(
+                ParsedCommand(type="team", lead=lead, workers=workers, agents=agents)
+            )
+
+        return commands
+
+    def _parse_broadcasts(self, text: str) -> List[ParsedCommand]:
+        """Parse <broadcast to="pattern">content</broadcast>."""
+        commands = []
+        pattern = r'<broadcast\s+to=["\']([^"\']+)["\']>(.*?)</broadcast>'
+
+        for match in re.finditer(pattern, text, re.DOTALL):
+            pat = match.group(1)
+            content = match.group(2).strip()
+            commands.append(
+                ParsedCommand(type="broadcast", pattern=pat, content=content)
+            )
+
+        return commands

plugins/agent_orchestrator_plugin.py

@@ -0,0 +1,9 @@
+"""Agent Orchestrator Plugin - wrapper for plugin discovery.
+
+This file exists to enable plugin discovery which looks for *_plugin.py files.
+The actual implementation is in the agent_orchestrator/ directory.
+"""
+
+from plugins.agent_orchestrator.plugin import AgentOrchestratorPlugin
+
+__all__ = ["AgentOrchestratorPlugin"]

plugins/enhanced_input/box_styles.py

@@ -99,6 +99,7 @@ class BoxStyleRegistry:
             "thick": BoxStyle("┏", "┓", "┗", "┛", "━", "┃"),
             "dotted": BoxStyle("┌", "┐", "└", "┘", "┄", "┆"),
             "dashed": BoxStyle("┌", "┐", "└", "┘", "┅", "┇"),
+            "thin": BoxStyle("┌", "┐", "└", "┘", "─", ""),
 
             # Minimal styles
             "minimal": BoxStyle(" ", " ", " ", " ", "─", " "),

plugins/enhanced_input/color_engine.py

@@ -2,6 +2,8 @@
 
 from typing import List, Tuple
 
+from core.io.visual_effects import get_color_support, ColorSupport, rgb_to_256
+
 
 class ColorEngine:
     """Handles all color and gradient operations for enhanced input rendering."""
@@ -132,7 +134,10 @@ class ColorEngine:
         return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
 
     def _rgb_to_ansi(self, r: int, g: int, b: int, is_background: bool = False) -> str:
-        """Convert RGB to ANSI escape code.
+        """Convert RGB to ANSI escape code with automatic fallback.
+
+        Uses true color (24-bit) when supported, otherwise falls back
+        to 256-color palette.
 
         Args:
             r: Red component (0-255).
@@ -143,10 +148,20 @@ class ColorEngine:
         Returns:
             ANSI escape sequence.
         """
-        if is_background:
-            return f"\033[48;2;{r};{g};{b}m"
+        support = get_color_support()
+
+        if support == ColorSupport.TRUE_COLOR:
+            if is_background:
+                return f"\033[48;2;{r};{g};{b}m"
+            else:
+                return f"\033[38;2;{r};{g};{b}m"
         else:
-            return f"\033[38;2;{r};{g};{b}m"
+            # Use 256-color fallback
+            idx = rgb_to_256(r, g, b)
+            if is_background:
+                return f"\033[48;5;{idx}m"
+            else:
+                return f"\033[38;5;{idx}m"
 
     def _interpolate_color(self, color1: Tuple[int, int, int], color2: Tuple[int, int, int], factor: float) -> Tuple[int, int, int]:
         """Interpolate between two RGB colors.

plugins/enhanced_input/config.py

@@ -20,7 +20,7 @@ class InputConfig:
 
     # Dimensions
     min_width: int = 60
-    max_width: int = 120
+    max_width: int = 80
     min_height: int = 3
     max_height: int = 10
 
@@ -75,7 +75,7 @@ class InputConfig:
             show_placeholder=config.get("plugins.enhanced_input.show_placeholder", True),
 
             min_width=config.get("plugins.enhanced_input.min_width", 60),
-            max_width=config.get("plugins.enhanced_input.max_width", 120),
+            max_width=config.get("plugins.enhanced_input.max_width", 100),
             min_height=config.get("plugins.enhanced_input.min_height", 3),
             max_height=config.get("plugins.enhanced_input.max_height", 10),
 

plugins/enhanced_input_plugin.py

@@ -9,6 +9,8 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, List, TYPE_CHECKING
 
+from core.io.visual_effects import AgnosterSegment
+
 logger = logging.getLogger(__name__)
 
 # Add parent directory to path so we can import from chat_app
@@ -29,7 +31,6 @@ from plugins.enhanced_input.box_renderer import BoxRenderer
 # Type hints (only needed for type checking)
 if TYPE_CHECKING:
     from core.config import ConfigManager
-    from core.storage import StateManager
     from core.events import EventBus
     from core.io.terminal_renderer import TerminalRenderer
 
@@ -80,7 +81,11 @@ class EnhancedInputPlugin:
                     "type": "dropdown",
                     "label": "Box Style",
                     "config_path": "plugins.enhanced_input.style",
-                    "options": ["rounded", "square", "double", "thick", "thin"],
+                    "options": [
+                        "rounded", "square", "double", "thick", "thin",
+                        "dotted", "dashed", "minimal", "brackets", "underline",
+                        "lines_only", "dots_only", "mixed_weight", "sophisticated"
+                    ],
                     "help": "Visual style of the input box border"
                 },
                 {
@@ -180,23 +185,61 @@ class EnhancedInputPlugin:
                     "label": "Show Status",
                     "config_path": "plugins.enhanced_input.show_status",
                     "help": "Display status information below input box"
+                },
+                # Color settings
+                {
+                    "type": "dropdown",
+                    "label": "Border Color",
+                    "config_path": "plugins.enhanced_input.colors.border",
+                    "options": ["dim", "white", "cyan", "green", "yellow", "magenta", "blue", "red"],
+                    "help": "Color of the input box border"
+                },
+                {
+                    "type": "dropdown",
+                    "label": "Text Color",
+                    "config_path": "plugins.enhanced_input.colors.text",
+                    "options": ["dim", "white", "cyan", "green", "yellow", "magenta", "blue", "red"],
+                    "help": "Color of the input text"
+                },
+                {
+                    "type": "dropdown",
+                    "label": "Placeholder Color",
+                    "config_path": "plugins.enhanced_input.colors.placeholder",
+                    "options": ["dim", "white", "cyan", "green", "yellow", "magenta", "blue"],
+                    "help": "Color of the placeholder text"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Gradient Mode",
+                    "config_path": "plugins.enhanced_input.colors.gradient_mode",
+                    "help": "Enable gradient coloring effects"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Border Gradient",
+                    "config_path": "plugins.enhanced_input.colors.border_gradient",
+                    "help": "Apply gradient to border"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Text Gradient",
+                    "config_path": "plugins.enhanced_input.colors.text_gradient",
+                    "help": "Apply gradient to input text"
                 }
             ]
         }
 
-    def __init__(self, name: str, state_manager: 'StateManager', event_bus: 'EventBus',
+    def __init__(self, name: str, event_bus: 'EventBus',
                  renderer: 'TerminalRenderer', config: 'ConfigManager') -> None:
         """Initialize the enhanced input plugin.
 
         Args:
             name: Plugin name.
-            state_manager: State management system.
             event_bus: Event bus for hook registration.
             renderer: Terminal renderer.
             config: Configuration manager.
         """
         self.name = name
-        self.state_manager = state_manager
         self.event_bus = event_bus
         self.renderer = renderer
 
@@ -364,20 +407,27 @@ class EnhancedInputPlugin:
             logger.error(f"Failed to register enhanced input status view: {e}")
 
     def _get_input_ui_content(self) -> List[str]:
-        """Get input UI content for status view."""
+        """Get input UI content (agnoster style)."""
         try:
+            seg = AgnosterSegment()
+
             if not self.config.enabled:
-                return ["Input: - Off"]
+                seg.add_neutral("Input: Off", "dark")
+                return [seg.render()]
 
             style_display = self.state.get_status_display()
 
-            return [
-                f"Input: {style_display} ··· Width: {self.config.width_mode}"
-            ]
+            seg.add_lime("Input", "dark")
+            seg.add_cyan(style_display, "dark")
+            seg.add_neutral(f"Width: {self.config.width_mode}", "mid")
+
+            return [seg.render()]
 
         except Exception as e:
             logger.error(f"Error getting input UI content: {e}")
-            return ["Input UI: Error"]
+            seg = AgnosterSegment()
+            seg.add_neutral("Input: Error", "dark")
+            return [seg.render()]
 
 
     async def shutdown(self) -> None:

plugins/fullscreen/__init__.py

@@ -1,9 +1,13 @@
 """Full-screen plugins directory."""
 
 from .matrix_plugin import MatrixRainPlugin
-from .example_plugin import ExamplePlugin
+from .example_plugin import EnhancedExamplePlugin
+from .setup_wizard_plugin import SetupWizardPlugin
+from .space_shooter_plugin import SpaceShooterPlugin
 
 __all__ = [
     "MatrixRainPlugin",
-    "ExamplePlugin"
+    "EnhancedExamplePlugin",
+    "SetupWizardPlugin",
+    "SpaceShooterPlugin"
 ]