yaicli 0.0.19__py3-none-any.whl → 0.1.0__py3-none-any.whl

yaicli/entry.py

@@ -0,0 +1,95 @@
+import sys
+from typing import Annotated, Optional
+
+import typer
+
+from yaicli.cli import CLI
+from yaicli.const import DEFAULT_CONFIG_INI
+
+app = typer.Typer(
+    name="yaicli",
+    help="YAICLI - Yet Another AI CLI Interface.",
+    context_settings={"help_option_names": ["-h", "--help"]},
+    pretty_exceptions_enable=False,  # Let the CLI handle errors gracefully
+    add_completion=False,  # Disable default shell completion for now
+)
+
+
+@app.command()
+def main(
+    ctx: typer.Context,
+    prompt: Annotated[
+        Optional[str], typer.Argument(help="The prompt to send to the LLM. Reads from stdin if available.")
+    ] = None,
+    chat: Annotated[
+        bool, typer.Option("--chat", "-c", help="Start in interactive chat mode.", rich_help_panel="Mode Options")
+    ] = False,
+    shell: Annotated[
+        bool,
+        typer.Option(
+            "--shell",
+            "-s",
+            help="Generate and optionally execute a shell command (non-interactive).",
+            rich_help_panel="Mode Options",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose", "-V", help="Show verbose output (e.g., loaded config).", rich_help_panel="Other Options"
+        ),
+    ] = False,
+    template: Annotated[
+        bool,
+        typer.Option(
+            "--template", help="Show the default config file template and exit.", rich_help_panel="Other Options"
+        ),
+    ] = False,
+):  # Removed trailing comma
+    """YAICLI: Your AI assistant in the command line.
+
+    Call with a PROMPT to get a direct answer, use --shell to execute as command,
+    or use --chat for an interactive session.
+    """
+    if template:
+        print(DEFAULT_CONFIG_INI)
+        raise typer.Exit()
+
+    # Combine prompt argument with stdin content if available
+    final_prompt = prompt
+    if not sys.stdin.isatty():
+        stdin_content = sys.stdin.read().strip()
+        if stdin_content:
+            if final_prompt:
+                # Prepend stdin content to the argument prompt
+                final_prompt = f"{stdin_content}\n\n{final_prompt}"
+            else:
+                final_prompt = stdin_content
+
+    # Basic validation for conflicting options or missing prompt
+    if not final_prompt and not chat:
+        # If no prompt and not starting chat, show help
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+    if chat and final_prompt:
+        # Warn if both chat mode and a prompt are given (prompt will be ignored)
+        # Or, could use the prompt as the first message in chat mode
+        print("Warning: Starting in chat mode. Initial prompt argument will be ignored.")
+
+    try:
+        # Instantiate the main CLI class
+        cli_instance = CLI(verbose=verbose)
+        # Run the appropriate mode
+        cli_instance.run(chat=chat, shell=shell, prompt=final_prompt)
+    except Exception as e:
+        # Catch potential errors during CLI initialization or run
+        print(f"An error occurred: {e}")
+        if verbose:
+            import traceback
+
+            traceback.print_exc()
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

yaicli/history.py

@@ -0,0 +1,72 @@
+from os.path import exists
+
+from prompt_toolkit.history import FileHistory, _StrOrBytesPath
+
+
+class LimitedFileHistory(FileHistory):
+    """Limited file history.
+
+    This class extends the FileHistory class from prompt_toolkit.history.
+    It adds a limit to the number of entries in the history file.
+    """
+
+    def __init__(self, filename: _StrOrBytesPath, max_entries: int = 500, trim_every: int = 2):
+        """Initialize the LimitedFileHistory object.
+
+        Args:
+            filename: Path to the history file
+            max_entries: Maximum number of entries to keep
+            trim_every: Trim history every `trim_every` appends
+
+        Examples:
+            >>> history = LimitedFileHistory("~/.yaicli_history", max_entries=500, trim_every=10)
+            >>> history.append_string("echo hello")
+            >>> history.append_string("echo world")
+            >>> session = PromptSession(history=history)
+        """
+        self.max_entries = max_entries
+        self._append_count = 0
+        self._trim_every = trim_every
+        super().__init__(filename)
+
+    def store_string(self, string: str) -> None:
+        """Store a string in the history file.
+
+        Call the original method to deposit a new record.
+        """
+        super().store_string(string)
+
+        self._append_count += 1
+        if self._append_count >= self._trim_every:
+            self._trim_history()
+            self._append_count = 0
+
+    def _trim_history(self):
+        """Trim the history file to the specified maximum number of entries."""
+        if not exists(self.filename):
+            return
+
+        with open(self.filename, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # By record: each record starts with "# timestamp" followed by a number of "+lines".
+        entries = []
+        current_entry = []
+
+        for line in lines:
+            if line.startswith("# "):
+                if current_entry:
+                    entries.append(current_entry)
+                current_entry = [line]
+            elif line.startswith("+") or line.strip() == "":
+                current_entry.append(line)
+
+        if current_entry:
+            entries.append(current_entry)
+
+        # Keep the most recent max_entries row (the next row is newer)
+        trimmed_entries = entries[-self.max_entries :]
+
+        with open(self.filename, "w", encoding="utf-8") as f:
+            for entry in trimmed_entries:
+                f.writelines(entry)

yaicli/printer.py

@@ -0,0 +1,244 @@
+import itertools
+import time
+import traceback
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    Optional,
+    Tuple,
+)
+
+from rich import get_console
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+
+from yaicli.const import DEFAULT_CODE_THEME, EventTypeEnum
+
+
+class Printer:
+    """Handles printing responses to the console, including stream processing."""
+
+    _REASONING_PREFIX = "> "
+    _CURSOR_ANIMATION_SLEEP = 0.005
+
+    def __init__(self, config: Dict[str, Any], console: Console, verbose: bool = False):
+        self.config = config
+        self.console = console or get_console()
+        self.verbose = verbose
+        self.code_theme = config.get("CODE_THEME", DEFAULT_CODE_THEME)
+        self.in_reasoning: bool = False
+
+    def _reset_state(self) -> None:
+        """Resets the printer state for a new stream."""
+        self.in_reasoning = False
+
+    def _process_reasoning_chunk(self, chunk: str, content: str, reasoning: str) -> Tuple[str, str]:
+        """Adds a reasoning chunk to the reasoning text.
+        This method handles the processing of reasoning chunks, and update the reasoning state
+        when <think> tag is closed.
+
+        Args:
+            chunk (str): The reasoning chunk to process.
+            content (str): The current content text.
+            reasoning (str): The current reasoning text.
+
+        Returns:
+            Tuple[str, str]: The updated content text and reasoning text.
+        """
+        if not self.in_reasoning:
+            self.in_reasoning = True
+            reasoning = ""
+
+        tmp = chunk.replace("\n", f"\n{self._REASONING_PREFIX}")
+        tmp_reasoning = reasoning + tmp
+
+        reasoning += chunk
+        if "</think>" in tmp_reasoning:
+            self.in_reasoning = False
+            reasoning, content = reasoning.split("</think>", maxsplit=1)
+        return content, reasoning
+
+    def _process_content_chunk(self, chunk: str, content: str, reasoning: str) -> Tuple[str, str]:
+        """Adds a content chunk to the content text.
+        This method handles the processing of content chunks, and update the reasoning state
+        when <think> tag is opened.
+
+        Args:
+            chunk (str): The content chunk to process.
+            content (str): The current content text.
+            reasoning (str): The current reasoning text.
+
+        Returns:
+            Tuple[str, str]: The updated content text and reasoning text.
+        """
+        if content == "":
+            chunk = chunk.lstrip()  # Remove leading whitespace from first chunk
+
+        if self.in_reasoning:
+            self.in_reasoning = False
+        content += chunk
+
+        if content.startswith("<think>"):
+            # Remove <think> tag and leading whitespace
+            self.in_reasoning = True
+            reasoning = content[7:].lstrip()
+            content = ""  # Content starts after the initial <think> tag
+
+        return content, reasoning
+
+    def _handle_event(self, event: Dict[str, Any], content: str, reasoning: str) -> Tuple[str, str]:
+        """Process a single stream event and return the updated content and reasoning.
+
+        Args:
+            event (Dict[str, Any]): The stream event to process.
+            content (str): The current content text (non-reasoning).
+            reasoning (str): The current reasoning text.
+        Returns:
+            Tuple[str, str]: The updated content text and reasoning text.
+        """
+        event_type = event.get("type")
+        chunk = event.get("chunk")
+
+        if event_type == EventTypeEnum.ERROR and self.verbose:
+            self.console.print(f"Stream error: {event.get('message')}", style="dim")
+            return content, reasoning
+
+        # Handle explicit reasoning end event
+        if event_type == EventTypeEnum.REASONING_END:
+            if self.in_reasoning:
+                self.in_reasoning = False
+            return content, reasoning
+
+        if event_type in (EventTypeEnum.REASONING, EventTypeEnum.CONTENT) and chunk:
+            if event_type == EventTypeEnum.REASONING or self.in_reasoning:
+                return self._process_reasoning_chunk(str(chunk), content, reasoning)
+            return self._process_content_chunk(str(chunk), content, reasoning)
+
+        return content, reasoning
+
+    def _format_display_text(self, content: str, reasoning: str) -> str:
+        """Format the text for display, combining content and reasoning if needed.
+
+        Args:
+            content (str): The content text.
+            reasoning (str): The reasoning text.
+
+        Returns:
+            str: The formatted text for display.
+        """
+        display_text = ""
+
+        # Add reasoning with proper formatting if it exists
+        if reasoning:
+            formatted_reasoning = reasoning.replace("\n", f"\n{self._REASONING_PREFIX}")
+            if not formatted_reasoning.startswith(self._REASONING_PREFIX):
+                formatted_reasoning = self._REASONING_PREFIX + formatted_reasoning
+            # Reasoning prefix is now added per line
+            display_text += f"\nThinking:\n{formatted_reasoning}"
+
+            # Only add newlines if there is content following the reasoning
+            if content:
+                display_text += "\n\n"
+
+        # Add content
+        display_text += content
+
+        return display_text
+
+    def _update_live_display(self, live: Live, content: str, reasoning: str, cursor: Iterator[str]) -> None:
+        """Update live display content and execute cursor animation
+        Sleep for a short duration to control the cursor animation speed.
+
+        Args:
+            live (Live): The live display object.
+            content (str): The current content text.
+            reasoning (str): The current reasoning text.
+            cursor (Iterator[str]): The cursor animation iterator.
+        """
+        # Format display text without cursor first
+        display_text = self._format_display_text(content, reasoning)
+        cursor_char = next(cursor)
+
+        # Add cursor at the end of reasoning or content depending on current state
+        if self.in_reasoning:
+            # Add cursor at the end of reasoning content
+            if reasoning:
+                # Append cursor directly if reasoning ends without newline, otherwise append after prefix
+                if reasoning.endswith("\n"):
+                    display_text += f"\n{self._REASONING_PREFIX}{cursor_char}"
+                else:
+                    display_text += cursor_char
+            else:
+                # If reasoning just started and no content yet
+                # Updated to match formatting
+                display_text = f"\nThinking:\n{self._REASONING_PREFIX}{cursor_char}"
+        else:
+            # Add cursor at the end of normal content
+            display_text += cursor_char
+
+        markdown = Markdown(display_text, code_theme=self.code_theme)
+        live.update(markdown)
+        time.sleep(self._CURSOR_ANIMATION_SLEEP)
+
+    def display_stream(self, stream_iterator: Iterator[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
+        """Display streaming response content
+        Handle stream events and update the live display accordingly.
+        This method separates content and reasoning blocks for display and further processing.
+
+        Args:
+            stream_iterator (Iterator[Dict[str, Any]]): The stream iterator to process.
+        Returns:
+            Tuple[Optional[str], Optional[str]]: The final content and reasoning texts if successful, None otherwise.
+        """
+        self.console.print("Assistant:", style="bold green")
+        self._reset_state()  # Reset state for the new stream
+        content = ""
+        reasoning = ""
+        # Removed in_reasoning local variable initialization
+        cursor = itertools.cycle(["_", " "])
+
+        with Live(console=self.console) as live:
+            try:
+                for event in stream_iterator:
+                    # Pass only content and reasoning, rely on self.in_reasoning
+                    content, reasoning = self._handle_event(event, content, reasoning)
+
+                    if event.get("type") in (
+                        EventTypeEnum.CONTENT,
+                        EventTypeEnum.REASONING,
+                        EventTypeEnum.REASONING_END,
+                    ):
+                        # Pass only necessary variables, rely on self.in_reasoning
+                        self._update_live_display(live, content, reasoning, cursor)
+
+                # Remove cursor and finalize display
+                display_text = self._format_display_text(content, reasoning)
+                live.update(Markdown(display_text, code_theme=self.code_theme))
+                return content, reasoning
+
+            except Exception as e:
+                self.console.print(f"An error occurred during stream display: {e}", style="red")
+                display_text = self._format_display_text(content, reasoning) + " [Display Error]"
+                live.update(Markdown(markup=display_text, code_theme=self.code_theme))
+                if self.verbose:
+                    traceback.print_exc()
+                return None, None
+
+    def display_normal(self, content: Optional[str], reasoning: Optional[str] = None) -> None:
+        """Display a complete, non-streamed response.
+
+        Args:
+            content (Optional[str]): The main content to display.
+            reasoning (Optional[str]): The reasoning content to display.
+        """
+        self.console.print("Assistant:", style="bold green")
+
+        if content or reasoning:
+            # Use the existing _format_display_text method
+            display_text = self._format_display_text(content or "", reasoning or "")
+            self.console.print(Markdown(display_text, code_theme=self.code_theme))
+            self.console.print()  # Add a newline for spacing
+        else:
+            self.console.print("Assistant did not provide any content.", style="yellow")

yaicli/utils.py

@@ -0,0 +1,112 @@
+import platform
+from os import getenv
+from os.path import basename, pathsep
+from typing import Any, Optional, TypeVar
+
+from distro import name as distro_name
+
+from yaicli.const import DEFAULT_OS_NAME, DEFAULT_SHELL_NAME
+
+T = TypeVar("T", int, float, str)
+
+
+def detect_os(config: dict[str, Any]) -> str:
+    """Detect operating system + version based on config or system info."""
+    os_name_config = config.get("OS_NAME", DEFAULT_OS_NAME)
+    if os_name_config != DEFAULT_OS_NAME:
+        return os_name_config
+
+    current_platform = platform.system()
+    if current_platform == "Linux":
+        return "Linux/" + distro_name(pretty=True)
+    if current_platform == "Windows":
+        return "Windows " + platform.release()
+    if current_platform == "Darwin":
+        return "Darwin/MacOS " + platform.mac_ver()[0]
+    return current_platform
+
+
+def detect_shell(config: dict[str, Any]) -> str:
+    """Detect shell name based on config or environment."""
+    shell_name_config = config.get("SHELL_NAME", DEFAULT_SHELL_NAME)
+    if shell_name_config != DEFAULT_SHELL_NAME:
+        return shell_name_config
+
+    current_platform = platform.system()
+    if current_platform in ("Windows", "nt"):
+        # Basic check for PowerShell based on environment variables
+        is_powershell = len(getenv("PSModulePath", "").split(pathsep)) >= 3
+        return "powershell.exe" if is_powershell else "cmd.exe"
+
+    # For Linux/MacOS, check SHELL environment variable
+    return basename(getenv("SHELL") or "/bin/sh")
+
+
+def filter_command(command: str) -> Optional[str]:
+    """Filter out unwanted characters from command
+
+    The LLM may return commands in markdown format with code blocks.
+    This method removes markdown formatting from the command.
+    It handles various formats including:
+    - Commands surrounded by ``` (plain code blocks)
+    - Commands with language specifiers like ```bash, ```zsh, etc.
+    - Commands with specific examples like ```ls -al```
+
+    example:
+    ```bash\nls -la\n``` ==> ls -al
+    ```zsh\nls -la\n``` ==> ls -al
+    ```ls -la``` ==> ls -la
+    ls -la ==> ls -la
+    ```\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
+    ```bash\ncd /tmp\nls -la\n``` ==> cd /tmp\nls -la
+    ```plaintext\nls -la\n``` ==> ls -la
+    """
+    if not command or not command.strip():
+        return ""
+
+    # Handle commands that are already without code blocks
+    if "```" not in command:
+        return command.strip()
+
+    # Handle code blocks with or without language specifiers
+    lines = command.strip().split("\n")
+
+    # Check if it's a single-line code block like ```ls -al```
+    if len(lines) == 1 and lines[0].startswith("```") and lines[0].endswith("```"):
+        return lines[0][3:-3].strip()
+
+    # Handle multi-line code blocks
+    if lines[0].startswith("```"):
+        # Remove the opening ``` line (with or without language specifier)
+        content_lines = lines[1:]
+
+        # If the last line is a closing ```, remove it
+        if content_lines and content_lines[-1].strip() == "```":
+            content_lines = content_lines[:-1]
+
+        # Join the remaining lines and strip any extra whitespace
+        return "\n".join(line.strip() for line in content_lines if line.strip())
+    else:
+        # If the first line doesn't start with ```, return the entire command without the ``` characters
+        return command.strip().replace("```", "")
+
+
+def str2bool(value: str) -> bool:
+    """Convert a string representation of truth to true (1) or false (0).
+    True values are 'y', 'yes', 't', 'true', 'on', and '1';
+    false values are 'n', 'no', 'f', 'false', 'off', and '0'.
+    Raises ValueError if 'value' is anything else.
+    """
+    if value in {False, True}:
+        return bool(value)
+
+    norm = value.strip().lower()
+
+    if norm in {"1", "true", "t", "yes", "y", "on"}:
+        return True
+
+    if norm in {"0", "false", "f", "no", "n", "off"}:
+        return False
+
+    # Handle empty strings and other invalid values
+    raise ValueError(f"Invalid boolean value: {value}")