kollabor 0.4.9__py3-none-any.whl

core/io/buffer_manager.py

@@ -0,0 +1,362 @@
+"""Input buffer management for terminal input handling."""
+
+import logging
+from typing import List, Tuple
+
+
+logger = logging.getLogger(__name__)
+
+
+class BufferManager:
+    """Manages input buffer with validation, history, and editing capabilities.
+
+    Handles text input buffer operations including character insertion, deletion,
+    cursor movement, input validation, and command history.
+    """
+
+    def __init__(self, buffer_limit: int = 1000, history_limit: int = 100):
+        """Initialize the buffer manager.
+
+        Args:
+            buffer_limit: Maximum characters allowed in buffer.
+            history_limit: Maximum commands to keep in history.
+        """
+        self._buffer = ""
+        self._cursor_pos = 0
+        self._buffer_limit = buffer_limit
+        self._history: List[str] = []
+        self._history_limit = history_limit
+        self._history_index = -1
+        self._temp_buffer = ""  # For history navigation
+
+        logger.debug(
+            "BufferManager initialized with limits: "
+            f"buffer={buffer_limit}, history={history_limit}"
+        )
+
+    @property
+    def content(self) -> str:
+        """Get current buffer content."""
+        return self._buffer
+
+    @property
+    def cursor_position(self) -> int:
+        """Get current cursor position."""
+        return self._cursor_pos
+
+    @property
+    def is_empty(self) -> bool:
+        """Check if buffer is empty or only whitespace."""
+        return not self._buffer.strip()
+
+    @property
+    def length(self) -> int:
+        """Get current buffer length."""
+        return len(self._buffer)
+
+    def insert_char(self, char: str) -> bool:
+        """Insert a character at the current cursor position.
+
+        Args:
+            char: Character to insert.
+
+        Returns:
+            True if character was inserted, False if rejected.
+        """
+        if not self._is_valid_char(char):
+            return False
+
+        if len(self._buffer) >= self._buffer_limit:
+            logger.warning(f"Buffer limit reached: {self._buffer_limit}")
+            return False
+
+        # Insert character at cursor position
+        self._buffer = (
+            self._buffer[: self._cursor_pos]
+            + char
+            + self._buffer[self._cursor_pos :]
+        )
+        self._cursor_pos += 1
+
+        return True
+
+    def delete_char(self) -> bool:
+        """Delete character before cursor (backspace behavior).
+
+        Returns:
+            True if character was deleted, False if at beginning.
+        """
+        if self._cursor_pos == 0:
+            return False
+
+        self._buffer = (
+            self._buffer[: self._cursor_pos - 1] + self._buffer[self._cursor_pos :]
+        )
+        self._cursor_pos -= 1
+        return True
+
+    def delete_forward(self) -> bool:
+        """Delete character after cursor (delete key behavior).
+
+        Returns:
+            True if character was deleted, False if at end.
+        """
+        if self._cursor_pos >= len(self._buffer):
+            return False
+
+        self._buffer = (
+            self._buffer[: self._cursor_pos] + self._buffer[self._cursor_pos + 1 :]
+        )
+        return True
+
+    def move_cursor(self, direction: str) -> bool:
+        """Move cursor left or right.
+
+        Args:
+            direction: "left" or "right".
+
+        Returns:
+            True if cursor moved, False if at boundary.
+        """
+        if direction == "left" and self._cursor_pos > 0:
+            self._cursor_pos -= 1
+            return True
+        elif direction == "right" and self._cursor_pos < len(self._buffer):
+            self._cursor_pos += 1
+            return True
+        return False
+
+    def move_to_start(self) -> None:
+        """Move cursor to start of buffer."""
+        self._cursor_pos = 0
+
+    def move_to_end(self) -> None:
+        """Move cursor to end of buffer."""
+        self._cursor_pos = len(self._buffer)
+
+    def clear(self) -> None:
+        """Clear the buffer and reset cursor."""
+        self._buffer = ""
+        self._cursor_pos = 0
+        self._reset_history_navigation()
+
+    def get_content_and_clear(self) -> str:
+        """Get buffer content and clear it.
+
+        Returns:
+            The buffer content before clearing.
+        """
+        content = self._buffer
+        self.clear()
+        return content
+
+    def add_to_history(self, command: str) -> None:
+        """Add a command to history.
+
+        Args:
+            command: Command to add to history.
+        """
+        if not command.strip():
+            return
+
+        # Remove duplicate if it exists
+        if command in self._history:
+            self._history.remove(command)
+
+        # Add to end and maintain limit
+        self._history.append(command)
+        if len(self._history) > self._history_limit:
+            self._history = self._history[-self._history_limit :]
+
+        self._reset_history_navigation()
+        logger.debug(f"Added to history: {command[:50]}...")
+
+    def navigate_history(self, direction: str) -> bool:
+        """Navigate through command history.
+
+        Args:
+            direction: "up" for previous, "down" for next.
+
+        Returns:
+            True if history was navigated, False if at boundary.
+        """
+        if not self._history:
+            return False
+
+        # Save current buffer on first history navigation
+        if self._history_index == -1:
+            self._temp_buffer = self._buffer
+
+        if direction == "up":
+            if self._history_index < len(self._history) - 1:
+                self._history_index += 1
+                self._load_from_history()
+                return True
+        elif direction == "down":
+            if self._history_index > -1:
+                self._history_index -= 1
+                if self._history_index == -1:
+                    # Restore temp buffer
+                    self._buffer = self._temp_buffer
+                    self._cursor_pos = len(self._buffer)
+                else:
+                    self._load_from_history()
+                return True
+
+        return False
+
+    def get_display_info(self) -> Tuple[str, int]:
+        """Get buffer content and cursor position for display.
+
+        Returns:
+            Tuple of (buffer_content, cursor_position).
+        """
+        return self._buffer, self._cursor_pos
+
+    def validate_content(self) -> List[str]:
+        """Validate current buffer content.
+
+        Returns:
+            List of validation error messages (empty if valid).
+        """
+        errors = []
+
+        # Check for potentially dangerous content
+        dangerous_patterns = [
+            "rm -rf",
+            "sudo rm",
+            ":(){ :|:& };:",
+            "fork bomb",
+        ]
+
+        for pattern in dangerous_patterns:
+            if pattern in self._buffer.lower():
+                errors.append(
+                    f"Potentially dangerous command pattern detected: {pattern}"
+                )
+
+        # Check for very long lines that might cause issues
+        if len(self._buffer) > self._buffer_limit * 0.9:
+            errors.append(
+                f"Input approaching buffer limit "
+                f"({len(self._buffer)}/{self._buffer_limit})"
+            )
+
+        return errors
+
+    def _is_valid_char(self, char: str) -> bool:
+        """Check if character is valid for input.
+
+        Args:
+            char: Character to validate.
+
+        Returns:
+            True if character is valid.
+        """
+        if not char or len(char) != 1:
+            return False
+
+        char_code = ord(char)
+
+        # Allow printable ASCII characters
+        if 32 <= char_code <= 126:
+            return True
+
+        # Allow some special characters like tab
+        if char_code in [9]:  # Tab
+            return True
+
+        return False
+
+    def _load_from_history(self) -> None:
+        """Load buffer from history at current index."""
+        if 0 <= self._history_index < len(self._history):
+            # History is stored newest-first, but we navigate oldest-first
+            history_item = self._history[-(self._history_index + 1)]
+            self._buffer = history_item
+            self._cursor_pos = len(self._buffer)
+
+    def _reset_history_navigation(self) -> None:
+        """Reset history navigation state."""
+        self._history_index = -1
+        self._temp_buffer = ""
+
+    async def handle_paste(self, paste_content: str) -> bool:
+        """Handle pasted content with proper line break and size management.
+
+        Args:
+            paste_content: Content that was pasted.
+
+        Returns:
+            True if paste was successfully handled, False if rejected.
+        """
+        if not paste_content:
+            return False
+
+        # Check if adding paste content would exceed buffer limit
+        if len(self._buffer) + len(paste_content) > self._buffer_limit:
+            total_len = len(self._buffer) + len(paste_content)
+            logger.warning(
+                "Paste rejected: would exceed buffer limit "
+                f"({total_len} > {self._buffer_limit})"
+            )
+            return False
+
+        # Process paste content (handle line breaks properly)
+        processed_content = self._process_paste_content(paste_content)
+
+        # Insert at current cursor position
+        self._buffer = (
+            self._buffer[: self._cursor_pos]
+            + processed_content
+            + self._buffer[self._cursor_pos :]
+        )
+
+        # Move cursor to end of pasted content
+        self._cursor_pos += len(processed_content)
+
+        # Reset history navigation since buffer was modified
+        self._reset_history_navigation()
+
+        logger.debug(
+            "Paste handled successfully: " f"{len(processed_content)} chars inserted"
+        )
+        return True
+
+    def _process_paste_content(self, content: str) -> str:
+        """Process pasted content to handle line breaks and formatting.
+
+        Args:
+            content: Raw pasted content.
+
+        Returns:
+            Processed content suitable for buffer insertion.
+        """
+        # For now, convert line breaks to spaces to prevent auto-submission
+        # This preserves the content while making it safe for single-line input
+        processed = content.replace("\n", " ").replace("\r", " ")
+
+        # Normalize multiple spaces to single spaces
+        import re
+
+        processed = re.sub(r"\s+", " ", processed)
+
+        # Strip leading/trailing whitespace
+        processed = processed.strip()
+
+        return processed
+
+    def get_stats(self) -> dict:
+        """Get buffer statistics for debugging.
+
+        Returns:
+            Dictionary with buffer statistics.
+        """
+        return {
+            "buffer_length": len(self._buffer),
+            "buffer_limit": self._buffer_limit,
+            "cursor_position": self._cursor_pos,
+            "history_count": len(self._history),
+            "history_limit": self._history_limit,
+            "history_index": self._history_index,
+        }

core/io/config_status_view.py

@@ -0,0 +1,272 @@
+"""Configuration status view for displaying config errors and status."""
+
+import logging
+from typing import Dict, Any, Optional, List
+
+from .status_renderer import StatusViewConfig, StatusMetric
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigStatusView:
+    """Status view for configuration monitoring and error reporting."""
+
+    def __init__(self, config_service, event_bus):
+        """Initialize the configuration status view.
+
+        Args:
+            config_service: The configuration service to monitor.
+            event_bus: Event bus for receiving notifications.
+        """
+        self.config_service = config_service
+        self.event_bus = event_bus
+        self.view_id = "config_status"
+        self.priority = 900  # High priority for config errors
+
+        # Register for config reload notifications
+        if hasattr(config_service, "register_reload_callback"):
+            config_service.register_reload_callback(self._on_config_reload)
+
+        logger.debug("ConfigStatusView initialized")
+
+    def _on_config_reload(self) -> None:
+        """Callback when configuration is reloaded."""
+        # Trigger status refresh by emitting event
+        if self.event_bus and hasattr(self.event_bus, "emit_with_hooks"):
+            # Note: This is called from sync context during config reload
+            # EventBus doesn't have emit_async method
+            # Skip the event emission during sync config reload
+            logger.debug("Config reloaded - status refresh skipped (sync context)")
+
+    def get_status_data(self) -> Dict[str, Any]:
+        """Get configuration status data.
+
+        Returns:
+            Dictionary with config status information.
+        """
+        if not self.config_service:
+            return {"error": "No config service", "status": "ERROR"}
+
+        config_error = self.config_service.get_config_error()
+        has_error = self.config_service.has_config_error()
+
+        using_cache = has_error and self.config_service._cached_config is not None
+        status_data = {
+            "has_error": has_error,
+            "error_message": config_error,
+            "status": "ERROR" if has_error else "OK",
+            "using_cache": using_cache,
+        }
+
+        # Add validation info
+        try:
+            validation_result = self.config_service.validate_config()
+            status_data.update(
+                {
+                    "valid": validation_result.get("valid", True),
+                    "warnings": validation_result.get("warnings", []),
+                    "errors": validation_result.get("errors", []),
+                }
+            )
+        except Exception as e:
+            logger.warning(f"Could not validate config: {e}")
+            status_data["validation_error"] = str(e)
+
+        return status_data
+
+    def format_status_line(self, data: Dict[str, Any]) -> Optional[str]:
+        """Format the configuration status line.
+
+        Args:
+            data: Status data dictionary.
+
+        Returns:
+            Formatted status line or None if no status needed.
+        """
+        if not data:
+            return None
+
+        # Show errors prominently
+        if data.get("has_error"):
+            error_msg = data.get("error_message", "Unknown config error")
+            if data.get("using_cache"):
+                return f" Config Error (using cache): {error_msg[:40]}..."
+            else:
+                return f"Config Error: {error_msg[:50]}..."
+
+        # Show validation warnings
+        warnings = data.get("warnings", [])
+        if warnings:
+            warning_count = len(warnings)
+            if warning_count == 1:
+                return f" Config Warning: {warnings[0][:45]}..."
+            else:
+                return f" Config: {warning_count} warnings"
+
+        # Show validation errors (different from load errors)
+        errors = data.get("errors", [])
+        if errors:
+            error_count = len(errors)
+            if error_count == 1:
+                return f"Config Validation: {errors[0][:40]}..."
+            else:
+                return f"Config: {error_count} validation errors"
+
+        # Normal status - only show if explicitly requested
+        if data.get("show_normal_status", False):
+            return "[OK] Config: OK"
+
+        # No status line needed for normal operation
+        return None
+
+    def should_display(self, data: Dict[str, Any]) -> bool:
+        """Determine if this status view should be displayed.
+
+        Args:
+            data: Status data dictionary.
+
+        Returns:
+            True if status should be shown, False otherwise.
+        """
+        if not data:
+            return False
+
+        # Always show errors and warnings
+        return (
+            data.get("has_error", False)
+            or data.get("warnings", [])
+            or data.get("errors", [])
+            or data.get("show_normal_status", False)
+        )
+
+    def get_color_scheme(self, data: Dict[str, Any]) -> str:
+        """Get color scheme based on config status.
+
+        Args:
+            data: Status data dictionary.
+
+        Returns:
+            Color scheme name.
+        """
+        if data.get("has_error"):
+            return "error"
+        elif data.get("warnings") or data.get("errors"):
+            return "warning"
+        else:
+            return "success"
+
+    def get_priority(self) -> int:
+        """Get display priority for this status view.
+
+        Returns:
+            Priority value (higher = more important).
+        """
+        # High priority for config issues
+        return self.priority
+
+    async def handle_status_event(
+        self, event_type: str, event_data: Dict[str, Any]
+    ) -> None:
+        """Handle status-related events.
+
+        Args:
+            event_type: Type of the event.
+            event_data: Event data dictionary.
+        """
+        if event_type in ["config_reloaded", "config_error", "config_changed"]:
+            # Refresh status display
+            await self.refresh_status()
+
+    async def refresh_status(self) -> None:
+        """Refresh the status display."""
+        if self.event_bus and hasattr(self.event_bus, "emit_with_hooks"):
+            from ..events.models import EventType
+
+            await self.event_bus.emit_with_hooks(
+                EventType.STATUS_CONTENT_UPDATE,
+                {"view_id": self.view_id, "source": "config_status"},
+                "config_status_view",
+            )
+
+    def get_status_view_config(self) -> StatusViewConfig:
+        """Get StatusViewConfig for registry registration.
+
+        Returns:
+            StatusViewConfig that can be registered with StatusViewRegistry.
+        """
+        from .status_renderer import BlockConfig
+
+        return StatusViewConfig(
+            name="Configuration Status",
+            plugin_source="core",
+            priority=self.priority,
+            blocks=[
+                BlockConfig(
+                    width_fraction=1.0,
+                    content_provider=self._get_config_status_content,
+                    title="Configuration Status",
+                    priority=100
+                )
+            ],
+        )
+
+    def _get_config_status_content(self) -> List[str]:
+        """Get configuration status content for status view.
+
+        Returns:
+            List of status content lines.
+        """
+        status_data = self.get_status_data()
+
+        # Show errors prominently
+        if status_data.get("has_error"):
+            error_msg = status_data.get("error_message", "Unknown config error")
+            if status_data.get("using_cache"):
+                return [f"Config: ERROR (using cache)", f"Error: {error_msg[:60]}"]
+            else:
+                return [f"Config: ERROR", f"Error: {error_msg[:60]}"]
+
+        # Show validation warnings
+        warnings = status_data.get("warnings", [])
+        if warnings:
+            lines = [f"Config: {len(warnings)} warning(s)"]
+            for warning in warnings[:3]:  # Show first 3 warnings
+                lines.append(f"- {warning[:60]}")
+            return lines
+
+        # Show validation errors
+        errors = status_data.get("errors", [])
+        if errors:
+            lines = [f"Config: {len(errors)} validation error(s)"]
+            for error in errors[:3]:  # Show first 3 errors
+                lines.append(f"- {error[:60]}")
+            return lines
+
+        # Normal status - show healthy config
+        return ["Config: OK", "No errors or warnings"]
+
+    def _get_config_status_metrics(self) -> List[StatusMetric]:
+        """Get configuration status as StatusMetric objects.
+
+        Returns:
+            List of StatusMetric objects for display.
+        """
+        status_data = self.get_status_data()
+
+        if not self.should_display(status_data):
+            return []
+
+        status_line = self.format_status_line(status_data)
+        if not status_line:
+            return []
+
+        color_scheme = self.get_color_scheme(status_data)
+
+        return [
+            StatusMetric(
+                name="config",
+                value=status_line,
+                color=color_scheme,
+                unit="",
+            )
+        ]