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

core/llm/message_display_service.py

@@ -8,6 +8,8 @@ single responsibility for message display orchestration.
 import logging
 from typing import Any, Dict, List, Optional, Tuple
 
+from core.io.visual_effects import ColorPalette
+
 logger = logging.getLogger(__name__)
 
 
@@ -68,8 +70,8 @@ class MessageDisplayService:
             
             # Format tool execution display with consistent styling
             tool_display = self._format_tool_header(result, tool_data)
-            result_display = self._format_tool_result(result)
-            
+            result_display = self._format_tool_result(result, tool_data)
+
             # Build combined tool display message
             combined_output = [tool_display, result_display]
             
@@ -154,21 +156,64 @@ class MessageDisplayService:
         Returns:
             Formatted tool header string
         """
+        # Tool indicator with dynamic color support
+        indicator = f"{ColorPalette.BRIGHT_LIME}⏺{ColorPalette.RESET}"
+
         if result.tool_type == "terminal":
             # Extract actual command from original tool data
             command = tool_data.get("command", "unknown") if tool_data else result.tool_id
-            return f"\033[1;33m⟣\033[0m terminal({command})"
+            return f"{indicator} terminal({command})"
         elif result.tool_type == "mcp_tool":
             # Extract tool name and arguments from original tool data
             tool_name = tool_data.get("name", "unknown") if tool_data else result.tool_id
             arguments = tool_data.get("arguments", {}) if tool_data else {}
-            return f"\033[1;33m⟣\033[0m {tool_name}({arguments})"
+
+            # Clean up malformed tool names (may contain XML from confused LLM)
+            if '<' in tool_name or '>' in tool_name:
+                import re
+                # Try to extract clean tool name
+                match = re.search(r'<tool_call>([^<]+)', tool_name)
+                if match:
+                    tool_name = match.group(1).strip()
+                else:
+                    # Find last word that looks like a tool name
+                    words = re.findall(r'\b([a-z_]+)\b', tool_name.lower())
+                    tool_name = words[-1] if words else "mcp_tool"
+
+            # For Read-like tools, show file path with line info
+            if tool_name.lower() in ("read", "file_read", "readfile"):
+                file_path = arguments.get("file_path") or arguments.get("path") or arguments.get("file", "")
+                offset = arguments.get("offset")
+                limit = arguments.get("limit")
+                if offset is not None or limit is not None:
+                    offset_val = offset if offset is not None else 0
+                    if limit:
+                        return f"{indicator} {tool_name}({file_path}, lines {offset_val + 1}-{offset_val + limit})"
+                    else:
+                        return f"{indicator} {tool_name}({file_path}, from line {offset_val + 1})"
+                return f"{indicator} {tool_name}({file_path})"
+
+            # Format arguments cleanly
+            if arguments:
+                # Show key arguments inline, truncate long values
+                arg_parts = []
+                for k, v in list(arguments.items())[:3]:  # Max 3 args
+                    v_str = str(v)
+                    if len(v_str) > 30:
+                        v_str = v_str[:27] + "..."
+                    arg_parts.append(f'{k}="{v_str}"')
+                args_display = ", ".join(arg_parts)
+                if len(arguments) > 3:
+                    args_display += f", +{len(arguments) - 3} more"
+                return f"{indicator} {tool_name}({args_display})"
+            else:
+                return f"{indicator} {tool_name}()"
         elif result.tool_type.startswith("file_"):
             # Extract filename/path from file operation data
             display_info = self._extract_file_display_info(tool_data, result.tool_type)
-            return f"\033[1;33m⟣\033[0m {result.tool_type}({display_info})"
+            return f"{indicator} {result.tool_type}({display_info})"
         else:
-            return f"\033[1;33m⟣\033[0m {result.tool_type}({result.tool_id})"
+            return f"{indicator} {result.tool_type}({result.tool_id})"
 
     def _extract_file_display_info(self, tool_data: Dict, tool_type: str) -> str:
         """Extract display information from file operation data.
@@ -197,11 +242,12 @@ class MessageDisplayService:
 
         return "unknown"
     
-    def _format_tool_result(self, result) -> str:
+    def _format_tool_result(self, result, tool_data: Dict = None) -> str:
         """Format tool execution result summary.
 
         Args:
             result: Tool execution result
+            tool_data: Original tool data for request info (optional)
 
         Returns:
             Formatted result summary string
@@ -214,15 +260,60 @@ class MessageDisplayService:
             if result.tool_type == "terminal" and result.output:
                 return f"\033[32m ▮ Read {output_lines} lines ({output_chars} chars)\033[0m"
             elif result.tool_type == "file_read" and result.output:
-                # Extract line count from output message "✓ Read X lines from..."
+                # Extract line count and optional range from output
+                # Format: "✓ Read X lines from path (lines N-M):" or "✓ Read X lines from path:"
                 import re
-                match = re.search(r'Read (\d+) lines', result.output)
+                match = re.search(r'Read (\d+) lines from .+?(?:\(lines ([^)]+)\))?:', result.output)
                 if match:
                     line_count = match.group(1)
+                    lines_from_output = match.group(2)  # May be None
+
+                    # Build line range from various sources
+                    lines_spec = None
+                    if lines_from_output:
+                        lines_spec = lines_from_output
+                    elif tool_data:
+                        if tool_data.get("lines"):
+                            lines_spec = tool_data["lines"]
+                        elif tool_data.get("offset") is not None or tool_data.get("limit") is not None:
+                            # Calculate range from offset/limit
+                            offset = tool_data.get("offset", 0)
+                            limit = tool_data.get("limit")
+                            start = offset + 1  # 1-indexed for display
+                            if limit:
+                                lines_spec = f"{start}-{start + int(line_count) - 1}"
+                            else:
+                                lines_spec = f"{start}+"
+
+                    if lines_spec:
+                        return f"\033[32m ▮ Read {line_count} lines (lines {lines_spec})\033[0m"
                     return f"\033[32m ▮ Read {line_count} lines\033[0m"
                 return f"\033[32m ▮ Success\033[0m"
             elif result.tool_type == "mcp_tool" and result.output:
-                preview = result.output[:50] + "..." if len(result.output) > 50 else result.output
+                # Try to summarize JSON output
+                try:
+                    import json
+                    data = json.loads(result.output)
+                    if isinstance(data, dict):
+                        # Count items in response
+                        if "content" in data:
+                            content = data["content"]
+                            if isinstance(content, list):
+                                return f"\033[32m ▮ Returned {len(content)} items\033[0m"
+                            elif isinstance(content, str):
+                                preview = content[:40] + "..." if len(content) > 40 else content
+                                return f"\033[32m ▮ {preview}\033[0m"
+                        # Count top-level keys
+                        keys = list(data.keys())[:3]
+                        return f"\033[32m ▮ Returned {{{', '.join(keys)}{'...' if len(data) > 3 else ''}}}\033[0m"
+                    elif isinstance(data, list):
+                        return f"\033[32m ▮ Returned {len(data)} items\033[0m"
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                # Fallback to text preview
+                preview = result.output[:50].replace('\n', ' ')
+                if len(result.output) > 50:
+                    preview += "..."
                 return f"\033[32m ▮ {preview}\033[0m"
             else:
                 return f"\033[32m ▮ Success\033[0m"
@@ -286,6 +377,7 @@ class MessageDisplayService:
         find_text = diff_info.get('find', '')
         replace_text = diff_info.get('replace', '')
         count = diff_info.get('count', 0)
+        line_numbers = diff_info.get('lines', [])  # First few line numbers where edit occurred
 
         formatted_lines = []
 
@@ -296,10 +388,17 @@ class MessageDisplayService:
         # Add pretty diff visualization
         formatted_lines.append("")
 
-        # Removed lines (red with -)
+        # Calculate starting line number for display
+        start_line = line_numbers[0] if line_numbers else None
+
+        # Removed lines (red with -) with line numbers
         removed_lines = find_text.split('\n')
-        for line in removed_lines[:3]:  # Show max 3 lines
-            formatted_lines.append(f"    \033[31m│- {line}\033[0m")
+        for i, line in enumerate(removed_lines[:3]):  # Show max 3 lines
+            if start_line:
+                line_num = start_line + i
+                formatted_lines.append(f"    \033[31m│- {line_num:4d} {line}\033[0m")
+            else:
+                formatted_lines.append(f"    \033[31m│- {line}\033[0m")
 
         if len(removed_lines) > 3:
             formatted_lines.append(f"    \033[31m│  ... ({len(removed_lines) - 3} more lines)\033[0m")
@@ -307,10 +406,14 @@ class MessageDisplayService:
         # Separator
         formatted_lines.append("    \033[90m│\033[0m")
 
-        # Added lines (green with +)
+        # Added lines (green with +) with line numbers
         added_lines = replace_text.split('\n')
-        for line in added_lines[:3]:  # Show max 3 lines
-            formatted_lines.append(f"    \033[32m│+ {line}\033[0m")
+        for i, line in enumerate(added_lines[:3]):  # Show max 3 lines
+            if start_line:
+                line_num = start_line + i
+                formatted_lines.append(f"    \033[32m│+ {line_num:4d} {line}\033[0m")
+            else:
+                formatted_lines.append(f"    \033[32m│+ {line}\033[0m")
 
         if len(added_lines) > 3:
             formatted_lines.append(f"    \033[32m│  ... ({len(added_lines) - 3} more lines)\033[0m")
@@ -341,7 +444,21 @@ class MessageDisplayService:
         """Clear thinking/generating display."""
         self.renderer.update_thinking(False)
         logger.debug("Cleared thinking display")
-    
+
+    def show_loading(self, message: str = "Loading...") -> None:
+        """Show loading indicator with custom message.
+
+        Args:
+            message: Loading message to display (default: "Loading...")
+        """
+        self.renderer.update_thinking(True, message)
+        logger.debug(f"Showing loading: {message}")
+
+    def hide_loading(self) -> None:
+        """Hide loading indicator.""" 
+        self.renderer.update_thinking(False)
+        logger.debug("Hiding loading indicator")
+
     def start_streaming_response(self) -> None:
         """Start a streaming response session.
 
@@ -409,7 +526,7 @@ class MessageDisplayService:
 
                 # Format tool execution display with consistent styling
                 tool_display = self._format_tool_header(result, tool_data)
-                result_display = self._format_tool_result(result)
+                result_display = self._format_tool_result(result, tool_data)
 
                 # Build combined tool display message
                 combined_output = [tool_display, result_display]

core/llm/plugin_sdk.py

@@ -45,10 +45,9 @@ class {class_name}:
             }}
         }}
     
-    def __init__(self, name: str, state_manager, event_bus, renderer, config):
+    def __init__(self, name: str, event_bus, renderer, config):
         """Initialize the plugin."""
         self.name = name
-        self.state_manager = state_manager
         self.event_bus = event_bus
         self.renderer = renderer
         self.config = config