siada-cli 0.0.1__py3-none-any.whl

siada/io/color_settings.py

@@ -0,0 +1,207 @@
+from dataclasses import dataclass
+from typing import Dict, ClassVar
+
+
+@dataclass
+class ColorSettings:
+    user_input_color: str = "blue"
+    tool_output_color: str = None
+    tool_error_color: str = "red"
+    tool_warning_color: str = "#FFA500"
+    tool_result_color: str = "#00FF00"
+    tool_call_color: str = "#FFD700"
+    assistant_output_color: str = "blue"
+    completion_menu_color: str = None
+    completion_menu_bg_color: str = None
+    completion_menu_current_color: str = None
+    completion_menu_current_bg_color: str = None
+    code_theme: str = "default"
+    split_line_color: str = "#0000FF"
+    shell_model_color: str = "#FF00FF"
+    at_file_reference_color: str = "#FF6B6B"
+    
+    # Predefined theme configurations
+    THEMES: ClassVar[Dict[str, Dict[str, str]]] = {
+        "default": {
+            "user_input_color": "blue",
+            "tool_output_color": None,
+            "tool_error_color": "red", 
+            "tool_warning_color": "#FFA500",
+            "tool_result_color": "#00FF00",
+            "tool_call_color": "#FFD700",
+            "assistant_output_color": "blue",
+            "completion_menu_color": None,
+            "completion_menu_bg_color": None,
+            "completion_menu_current_color": None,
+            "completion_menu_current_bg_color": None,
+            "code_theme": "default",
+            "split_line_color": "#0000FF",
+            "shell_model_color": "#FF00FF",
+            "at_file_reference_color": "#FF6B6B"
+        },
+        "dark": {
+            "user_input_color": "#32FF32",
+            "tool_output_color": None,
+            "tool_error_color": "#FF3333",
+            "tool_warning_color": "#FFFF00", 
+            "tool_result_color": "#00FF7F",
+            "tool_call_color": "#FFA500",
+            "assistant_output_color": "#00FFFF",
+            "completion_menu_color": None,
+            "completion_menu_bg_color": None,
+            "completion_menu_current_color": None,
+            "completion_menu_current_bg_color": None,
+            "code_theme": "monokai",
+            "split_line_color": "#4169E1",
+            "shell_model_color": "#DA70D6",
+            "at_file_reference_color": "#FF8A80"
+        },
+        "light": {
+            "user_input_color": "green",
+            "tool_output_color": None,
+            "tool_error_color": "red",
+            "tool_warning_color": "#FFA500",
+            "tool_result_color": "#008000",
+            "tool_call_color": "#FF8C00",
+            "assistant_output_color": "blue", 
+            "completion_menu_color": None,
+            "completion_menu_bg_color": None,
+            "completion_menu_current_color": None,
+            "completion_menu_current_bg_color": None,
+            "code_theme": "default",
+            "split_line_color": "#1E90FF",
+            "shell_model_color": "#9370DB",
+            "at_file_reference_color": "#E91E63"
+        }
+    }
+    
+    @classmethod
+    def from_theme(cls, theme_name: str) -> 'ColorSettings':
+        """Create ColorSettings instance from theme name"""
+        if theme_name not in cls.THEMES:
+            raise ValueError(f"Unknown theme: {theme_name}. Available themes: {list(cls.THEMES.keys())}")
+        
+        theme_config = cls.THEMES[theme_name]
+        return cls(**theme_config)
+    
+    @classmethod
+    def get_available_themes(cls) -> list:
+        """Get list of all available themes"""
+        return list(cls.THEMES.keys())
+    
+    def apply_to_args(self, args):
+        """Apply color settings to args object"""
+        args.user_input_color = self.user_input_color
+        args.tool_output_color = self.tool_output_color
+        args.tool_error_color = self.tool_error_color
+        args.tool_warning_color = self.tool_warning_color
+        args.tool_result_color = self.tool_result_color
+        args.tool_call_color = self.tool_call_color
+        args.assistant_output_color = self.assistant_output_color
+        args.completion_menu_color = self.completion_menu_color
+        args.completion_menu_bg_color = self.completion_menu_bg_color
+        args.completion_menu_current_color = self.completion_menu_current_color
+        args.completion_menu_current_bg_color = self.completion_menu_current_bg_color
+        args.code_theme = self.code_theme
+        args.split_line_color = self.split_line_color
+        args.shell_model_color = self.shell_model_color
+        args.at_file_reference_color = self.at_file_reference_color
+
+
+class RunningConfigColorSettings:
+    """Runtime color settings with processed color values."""
+    
+    def __init__(self, color_settings=None, pretty=True):
+        """Initialize running color settings.
+        
+        Args:
+            color_settings (ColorSettings, optional): Base color settings
+            pretty (bool): Whether to apply colors (if False, most colors will be None)
+        """
+        from .color_utils import ColorUtils
+        
+        self.color_settings = color_settings or ColorSettings()
+        self.user_input_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.user_input_color) if pretty else None
+        )
+        self.tool_output_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.tool_output_color) if pretty else None
+        )
+        self.tool_error_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.tool_error_color) if pretty else None
+        )
+        self.tool_warning_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.tool_warning_color) if pretty else None
+        )
+        self.tool_result_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.tool_result_color) if pretty else None
+        )
+        self.tool_call_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.tool_call_color) if pretty else None
+        )
+        self.assistant_output_color = ColorUtils.ensure_hash_prefix(
+            self.color_settings.assistant_output_color
+        )
+        self.completion_menu_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.completion_menu_color) if pretty else None
+        )
+        self.completion_menu_bg_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.completion_menu_bg_color)
+            if pretty
+            else None
+        )
+        self.completion_menu_current_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.completion_menu_current_color)
+            if pretty
+            else None
+        )
+        self.completion_menu_current_bg_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.completion_menu_current_bg_color)
+            if pretty
+            else None
+        )
+        self.split_line_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.split_line_color) if pretty else None
+        )
+        self.shell_model_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.shell_model_color) if pretty else None
+        )
+        self.at_file_reference_color = (
+            ColorUtils.ensure_hash_prefix(self.color_settings.at_file_reference_color) if pretty else None
+        )
+        
+        self.code_theme = self.color_settings.code_theme
+        
+        # Validate color settings after initialization
+        self._validate_color_settings()
+    
+    def _validate_color_settings(self):
+        """Validate configured color strings and reset invalid ones."""
+        from rich.color import ColorParseError
+        from rich.style import Style as RichStyle
+        
+        color_attributes = [
+            "user_input_color",
+            "tool_output_color", 
+            "tool_error_color",
+            "tool_warning_color",
+            "assistant_output_color",
+            "completion_menu_color",
+            "completion_menu_bg_color",
+            "completion_menu_current_color",
+            "completion_menu_current_bg_color",
+            "split_line_color",
+            "shell_model_color",
+            "at_file_reference_color",
+        ]
+        
+        for attr_name in color_attributes:
+            color_value = getattr(self, attr_name, None)
+            if color_value:
+                try:
+                    # Try creating a style to validate the color
+                    RichStyle(color=color_value)
+                except ColorParseError as e:
+                    # Print warning and reset invalid color to None
+                    print(f"Warning: Invalid configuration for {attr_name}: '{color_value}'. {e}. Disabling this color.")
+                    setattr(self, attr_name, None)

siada/io/color_utils.py

@@ -0,0 +1,16 @@
+class ColorUtils:
+    """A utility class for color-related operations."""
+
+    @staticmethod
+    def ensure_hash_prefix(color: str) -> str:
+        """Ensure hex color values have a # prefix."""
+        if not color:
+            return color
+        if isinstance(color, str) and color.strip() and not color.startswith("#"):
+            # Check if it's a valid hex color (3 or 6 hex digits)
+            if all(c in "0123456789ABCDEFabcdef" for c in color) and len(color) in (
+                3,
+                6,
+            ):
+                return f"#{color}"
+        return color 

siada/io/components/mdstream.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+
+import io
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import CodeBlock, Heading, Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+
+class NoInsetCodeBlock(CodeBlock):
+    """A code block with syntax highlighting and no padding."""
+
+    def __rich_console__(self, console, options):
+        code = str(self.text).rstrip()
+        syntax = Syntax(code, self.lexer_name, theme=self.theme, word_wrap=True, padding=(1, 0))
+        yield syntax
+
+
+class LeftHeading(Heading):
+    """A heading class that renders left-justified."""
+
+    def __rich_console__(self, console, options):
+        text = self.text
+        text.justify = "left"  # Override justification
+        if self.tag == "h1":
+            # Draw a border around h1s, but keep text left-aligned
+            yield Panel(
+                text,
+                box=box.HEAVY,
+                style="markdown.h1.border",
+            )
+        else:
+            # Styled text for h2 and beyond
+            if self.tag == "h2":
+                yield Text("")  # Keep the blank line before h2
+            yield text
+
+
+class NoInsetMarkdown(Markdown):
+    """Markdown with code blocks that have no padding and left-justified headings."""
+
+    elements = {
+        **Markdown.elements,
+        "fence": NoInsetCodeBlock,
+        "code_block": NoInsetCodeBlock,
+        "heading_open": LeftHeading,
+    }
+
+
+class MarkdownRender:
+    """Streaming markdown renderer that progressively displays content with a live updating window.
+
+    Uses rich.console and rich.live to render markdown content with smooth scrolling
+    and partial updates. Maintains a sliding window of visible content while streaming
+    in new markdown text.
+    """
+
+    live = None  # Rich Live display instance
+    when = 0  # Timestamp of last update
+    min_delay = 1.0 / 20  # Minimum time between updates (20fps)
+    live_window = 6  # Number of lines to keep visible at bottom during streaming
+
+    def __init__(self, mdargs=None):
+        """Initialize the markdown stream.
+
+        Args:
+            mdargs (dict, optional): Additional arguments to pass to rich Markdown renderer
+        """
+        self.printed = []  # Stores lines that have already been printed
+
+        if mdargs:
+            self.mdargs = mdargs
+        else:
+            self.mdargs = dict()
+
+        # Defer Live creation until the first update.
+        self.live = None
+        self._live_started = False
+
+    @staticmethod
+    def render_markdown_to_lines(text, mdargs=None):
+        """Render markdown text to a list of lines.
+
+        Args:
+            text (str): Markdown text to render
+            mdargs (dict, optional): Additional markdown arguments to override defaults
+
+        Returns:
+            list: List of rendered lines with line endings preserved
+        """
+        # Use provided mdargs or fall back to instance mdargs
+        final_mdargs = mdargs if mdargs is not None else {}
+        
+        # Render the markdown to a string buffer
+        string_io = io.StringIO()
+        console = Console(file=string_io, force_terminal=True)
+        markdown = NoInsetMarkdown(text, **final_mdargs)
+        console.print(markdown)
+        output = string_io.getvalue()
+
+        # Split rendered output into lines
+        return output.splitlines(keepends=True)
+
+    def close(self):
+        """Explicitly close the Live display and clean up resources."""
+        if self.live:
+            try:
+                self.live.stop()
+                self.live = None
+            except Exception as e:
+                pass
+
+    def __del__(self):
+        """Destructor to ensure Live display is properly cleaned up."""
+        try:
+            self.close()
+        except Exception:
+            pass  # Ignore any errors during cleanup
+
+    def update(self, text, final=False):
+        """Update the displayed markdown content.
+
+        Args:
+            text (str): The markdown text received so far
+            final (bool): If True, this is the final update and we should clean up
+
+        Splits the output into "stable" older lines and the "last few" lines
+        which aren't considered stable. They may shift around as new chunks
+        are appended to the markdown text.
+
+        The stable lines emit to the console above the Live window.
+        The unstable lines emit into the Live window so they can be repainted.
+
+        Markdown going to the console works better in terminal scrollback buffers.
+        The live window doesn't play nice with terminal scrollback.
+        """
+        # On the first call, stop the spinner and start the Live renderer
+        if not getattr(self, "_live_started", False):
+            self.live = Live(Text(""), refresh_per_second=1.0 / self.min_delay)
+            self.live.start()
+            self._live_started = True
+
+        now = time.time()
+        # Throttle updates to maintain smooth rendering
+        if not final and now - self.when < self.min_delay:
+            return
+        self.when = now
+
+        # Measure render time and adjust min_delay to maintain smooth rendering
+        start = time.time()
+        lines = MarkdownRender.render_markdown_to_lines(text, self.mdargs)
+        render_time = time.time() - start
+
+        # Set min_delay to render time plus a small buffer
+        self.min_delay = min(max(render_time * 10, 1.0 / 20), 2)
+
+        num_lines = len(lines)
+
+        # How many lines have "left" the live window and are now considered stable?
+        # Or if final, consider all lines to be stable.
+        if not final:
+            num_lines -= self.live_window
+
+        # If we have stable content to display...
+        if final or num_lines > 0:
+            # How many stable lines do we need to newly show above the live window?
+            num_printed = len(self.printed)
+            show = num_lines - num_printed
+
+            # Skip if no new lines to show above live window
+            if show <= 0:
+                return
+
+            # Get the new lines and display them
+            show = lines[num_printed:num_lines]
+            show = "".join(show)
+            show = Text.from_ansi(show)
+            self.live.console.print(show)  # to the console above the live area
+
+            # Update our record of printed lines
+            self.printed = lines[:num_lines]
+
+        # Handle final update cleanup
+        if final:
+            self.live.update(Text(""))
+            self.live.stop()
+            self.live = None
+            return
+
+        # Update the live window with remaining lines
+        rest = lines[num_lines:]
+        rest = "".join(rest)
+        rest = Text.from_ansi(rest)
+        self.live.update(rest)
+
+    def find_minimal_suffix(self, text, match_lines=50):
+        """
+        Splits text into chunks on blank lines "\n\n".
+        """

siada/io/console_printer.py

@@ -0,0 +1,68 @@
+from rich.console import Console
+from rich.style import Style as RichStyle
+from rich.text import Text
+
+from siada.io.color_utils import ColorUtils
+
+
+class ConsolePrinter:
+    """A utility class for handling styled console output."""
+
+    def __init__(self, console: Console, pretty: bool = True, colors: dict = None):
+        """
+        Initializes the ConsolePrinter.
+        :param console: The rich Console object.
+        :param pretty: Whether to use pretty output with colors and styles.
+        :param colors: A dictionary mapping message types to color strings.
+                       Expected keys: 'error', 'warning', 'output'.
+        """
+        self.console = console
+        self.pretty = pretty
+        self.colors = colors if colors else {}
+
+    def print_messages(self, *messages, color_name: str = None, bold: bool = False):
+        """Internal method to print styled messages to the console."""
+        color = self.colors.get(color_name)
+        
+        # Convert each message to Text, treating each message as a whole unit
+        text_messages = [Text(str(msg)) for msg in messages]
+        style_dict = {}
+
+        if self.pretty:
+            if color:
+                style_dict["color"] = ColorUtils.ensure_hash_prefix(color)
+            if bold:
+                style_dict["reverse"] = True
+
+        style = RichStyle(**style_dict)
+
+        try:
+            self.console.print(*text_messages, style=style)
+        except UnicodeEncodeError:
+            # Fallback to ASCII-safe output
+            plain_messages = [m.plain if isinstance(m, Text) else str(m) for m in text_messages]
+            safe_messages = [str(m).encode("ascii", errors="replace").decode("ascii") for m in plain_messages]
+            self.console.print(*safe_messages, style=style)
+
+    def error(self, *messages):
+        """Prints error messages."""
+        self.print_messages(*messages, color_name='error')
+
+    def warning(self, *messages):
+        """Prints warning messages."""
+        self.print_messages(*messages, color_name='warning')
+
+    def output(self, *messages, bold: bool = False):
+        """Prints standard tool output."""
+        self.print_messages(*messages, color_name='output', bold=bold)
+
+    def print(self, *args, **kwargs):
+        self.console.print(*args, **kwargs)
+
+    def result(self, *messages):
+        """Prints tool result messages."""
+        self.print_messages(*messages, color_name='result')
+
+    def call(self, *messages):
+        """Prints tool call messages."""
+        self.print_messages(*messages, color_name='call')