todo-agent 0.1.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

todo_agent/infrastructure/token_counter.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional
 try:
     import tiktoken
 except ImportError:
-    tiktoken = None
+    tiktoken = None  # type: ignore
 
 
 class TokenCounter:
@@ -17,12 +17,12 @@ class TokenCounter:
     def __init__(self, model: str = "gpt-4"):
         """
         Initialize token counter for a specific model.
-        
+
         Args:
             model: Model name to use for tokenization (default: gpt-4)
         """
         self.model = model
-        self._encoder = None
+        self._encoder: Optional[Any] = None
         self._initialize_encoder()
 
     def _initialize_encoder(self) -> None:
@@ -32,152 +32,153 @@ class TokenCounter:
                 "tiktoken library is required for accurate token counting. "
                 "Install it with: pip install tiktoken"
             )
-        
 
         self._encoder = tiktoken.get_encoding("cl100k_base")
-            
+
     def count_tokens(self, text: str) -> int:
         """
         Count tokens in text using accurate tokenization.
-        
+
         Args:
             text: Text to count tokens for
-            
+
         Returns:
             Number of tokens
         """
         if not text:
             return 0
-        
+
+        if self._encoder is None:
+            raise RuntimeError("Encoder not initialized")
         return len(self._encoder.encode(text))
 
     def count_message_tokens(self, message: Dict[str, Any]) -> int:
         """
         Count tokens in a single message (including role, content, and tool calls).
-        
+
         Args:
             message: Message dictionary with role, content, etc.
-            
+
         Returns:
             Number of tokens
         """
         tokens = 0
-        
+
         # Count role tokens (typically 1-2 tokens)
         role = message.get("role", "")
         tokens += self.count_tokens(role)
-        
+
         # Count content tokens
         content = message.get("content", "")
         if content:
             tokens += self.count_tokens(content)
-        
+
         # Count tool calls tokens
         tool_calls = message.get("tool_calls", [])
         for tool_call in tool_calls:
             tokens += self.count_tool_call_tokens(tool_call)
-        
+
         # Count tool call ID if present
         tool_call_id = message.get("tool_call_id", "")
         if tool_call_id:
             tokens += self.count_tokens(tool_call_id)
-        
+
         return tokens
 
     def count_tool_call_tokens(self, tool_call: Dict[str, Any]) -> int:
         """
         Count tokens in a tool call.
-        
+
         Args:
             tool_call: Tool call dictionary
-            
+
         Returns:
             Number of tokens
         """
         tokens = 0
-        
+
         # Count tool call ID
         tool_call_id = tool_call.get("id", "")
         tokens += self.count_tokens(tool_call_id)
-        
+
         # Count function call
         function = tool_call.get("function", {})
         if function:
             # Count function name
             function_name = function.get("name", "")
             tokens += self.count_tokens(function_name)
-            
+
             # Count function arguments
             arguments = function.get("arguments", "")
             if arguments:
                 tokens += self.count_tokens(arguments)
-        
+
         return tokens
 
     def count_messages_tokens(self, messages: List[Dict[str, Any]]) -> int:
         """
         Count total tokens in a list of messages.
-        
+
         Args:
             messages: List of message dictionaries
-            
+
         Returns:
             Total number of tokens
         """
         total_tokens = 0
-        
+
         for message in messages:
             total_tokens += self.count_message_tokens(message)
-        
+
         return total_tokens
 
     def count_tools_tokens(self, tools: List[Dict[str, Any]]) -> int:
         """
         Count tokens in tool definitions.
-        
+
         Args:
             tools: List of tool definition dictionaries
-            
+
         Returns:
             Number of tokens
         """
         if not tools:
             return 0
-        
+
         # Convert tools to JSON string and count tokens
-        tools_json = json.dumps(tools, separators=(',', ':'))
+        tools_json = json.dumps(tools, separators=(",", ":"))
         return self.count_tokens(tools_json)
 
     def count_request_tokens(
-        self, 
-        messages: List[Dict[str, Any]], 
-        tools: Optional[List[Dict[str, Any]]] = None
+        self,
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> int:
         """
         Count total tokens in a complete request (messages + tools).
-        
+
         Args:
             messages: List of message dictionaries
             tools: Optional list of tool definitions
-            
+
         Returns:
             Total number of tokens
         """
         total_tokens = self.count_messages_tokens(messages)
-        
+
         if tools:
             total_tokens += self.count_tools_tokens(tools)
-        
+
         return total_tokens
 
 
 def get_token_counter(model: str = "gpt-4") -> TokenCounter:
     """
     Get a token counter instance for the specified model.
-    
+
     Args:
         model: Model name to use for tokenization
-        
+
     Returns:
         TokenCounter instance
     """

todo_agent/interface/__init__.py

@@ -5,6 +5,21 @@ This module contains user interfaces and presentation logic.
 """
 
 from .cli import CLI
+from .formatters import (
+    PanelFormatter,
+    ResponseFormatter,
+    StatsFormatter,
+    TableFormatter,
+    TaskFormatter,
+)
 from .tools import ToolCallHandler
 
-__all__ = ["CLI", "ToolCallHandler"]
+__all__ = [
+    "CLI",
+    "PanelFormatter",
+    "ResponseFormatter",
+    "StatsFormatter",
+    "TableFormatter",
+    "TaskFormatter",
+    "ToolCallHandler",
+]

todo_agent/interface/cli.py

@@ -2,42 +2,60 @@
 Command-line interface for todo.sh LLM agent.
 """
 
-import threading
-import time
-from typing import Optional
-
 try:
+    import readline
+
+    from rich.align import Align
     from rich.console import Console
     from rich.live import Live
     from rich.spinner import Spinner
     from rich.text import Text
+
     from todo_agent.core.todo_manager import TodoManager
     from todo_agent.infrastructure.config import Config
-    from todo_agent.infrastructure.todo_shell import TodoShell
-    from todo_agent.infrastructure.logger import Logger
     from todo_agent.infrastructure.inference import Inference
+    from todo_agent.infrastructure.logger import Logger
+    from todo_agent.infrastructure.todo_shell import TodoShell
+    from todo_agent.interface.formatters import (
+        CLI_WIDTH,
+        PanelFormatter,
+        ResponseFormatter,
+        TableFormatter,
+        TaskFormatter,
+    )
     from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
+    from core.todo_manager import TodoManager  # type: ignore[no-redef]
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.inference import Inference  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from infrastructure.todo_shell import TodoShell  # type: ignore[no-redef]
+    from interface.formatters import (  # type: ignore[no-redef]
+        CLI_WIDTH,
+        PanelFormatter,
+        ResponseFormatter,
+        TableFormatter,
+        TaskFormatter,
+    )
+    from interface.tools import ToolCallHandler  # type: ignore[no-redef]
+    from rich.align import Align
     from rich.console import Console
     from rich.live import Live
     from rich.spinner import Spinner
     from rich.text import Text
-    from core.todo_manager import TodoManager
-    from infrastructure.config import Config
-    from infrastructure.todo_shell import TodoShell
-    from infrastructure.logger import Logger
-    from infrastructure.inference import Inference
-    from interface.tools import ToolCallHandler
 
 
 class CLI:
     """User interaction loop and input/output handling."""
 
-    def __init__(self):
+    def __init__(self) -> None:
+        # Initialize readline for arrow key navigation
+        readline.set_history_length(50)  # Match existing conversation cap
+
         # Initialize logger first
         self.logger = Logger("cli")
         self.logger.info("Initializing CLI")
-        
+
         self.config = Config()
         self.config.validate()
         self.logger.debug("Configuration validated")
@@ -58,8 +76,8 @@ class CLI:
         self.inference = Inference(self.config, self.tool_handler, self.logger)
         self.logger.debug("Inference engine initialized")
 
-        # Initialize rich console for animations
-        self.console = Console()
+        # Initialize rich console for animations with consistent width
+        self.console = Console(width=CLI_WIDTH)
 
         self.logger.info("CLI initialization completed")
 
@@ -85,22 +103,51 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
-
-
-    def run(self):
+    def _print_header(self) -> None:
+        """Print the application header with unicode borders."""
+        header_panel = PanelFormatter.create_header_panel()
+        self.console.print(header_panel)
+
+        subtitle = Text(
+            "Type your request naturally, or enter 'quit' to exit, or 'help' for commands",
+            style="dim",
+        )
+        self.console.print(Align.center(subtitle), style="dim")
+
+    def _print_help(self) -> None:
+        """Print help information in a formatted table."""
+        table = TableFormatter.create_command_table()
+        self.console.print(table)
+        self.console.print("Or just type your request naturally!", style="italic green")
+
+    def _print_about(self) -> None:
+        """Print about information in a formatted panel."""
+        about_panel = PanelFormatter.create_about_panel()
+        self.console.print(about_panel)
+
+    def _print_stats(self, summary: dict) -> None:
+        """Print conversation statistics in a formatted table."""
+        table = TableFormatter.create_stats_table(summary)
+        self.console.print(table)
+
+    def run(self) -> None:
         """Main CLI interaction loop."""
         self.logger.info("Starting CLI interaction loop")
-        print("Todo.sh LLM Agent - Type 'quit' to exit")
-        print("Commands: 'clear' (clear conversation), 'history' (show stats), 'help'")
-        print("=" * 50)
+
+        # Print header
+        self._print_header()
+
+        # Print separator
+        self.console.print("─" * CLI_WIDTH, style="dim")
 
         while True:
             try:
-                user_input = input("\n> ").strip()
+                # Print prompt with unicode character
+                user_input = self.console.input("\n[bold cyan]▶[/bold cyan] ").strip()
 
                 if user_input.lower() in ["quit", "exit", "q"]:
                     self.logger.info("User requested exit")
-                    print("Goodbye!")
+                    self.console.print("\n[bold green]Goodbye! 👋[/bold green]")
                     break
 
                 if not user_input:
@@ -110,61 +157,64 @@ class CLI:
                 if user_input.lower() == "clear":
                     self.logger.info("User requested conversation clear")
                     self.inference.clear_conversation()
-                    print("Conversation history cleared.")
+                    self.console.print(
+                        ResponseFormatter.format_success(
+                            "Conversation history cleared."
+                        )
+                    )
                     continue
 
-                if user_input.lower() == "history":
-                    self.logger.debug("User requested conversation history")
+                if user_input.lower() == "stats":
+                    self.logger.debug("User requested conversation stats")
                     summary = self.inference.get_conversation_summary()
-                    print(f"Conversation Stats:")
-                    print(f"  Total messages: {summary['total_messages']}")
-                    print(f"  User messages: {summary['user_messages']}")
-                    print(f"  Assistant messages: {summary['assistant_messages']}")
-                    print(f"  Tool messages: {summary['tool_messages']}")
-                    print(f"  Estimated tokens: {summary['estimated_tokens']}")
-                    
-                    # Display thinking time statistics if available
-                    if 'thinking_time_count' in summary and summary['thinking_time_count'] > 0:
-                        print(f"  Thinking time stats:")
-                        print(f"    Total thinking time: {summary['total_thinking_time']:.2f}s")
-                        print(f"    Average thinking time: {summary['average_thinking_time']:.2f}s")
-                        print(f"    Min thinking time: {summary['min_thinking_time']:.2f}s")
-                        print(f"    Max thinking time: {summary['max_thinking_time']:.2f}s")
-                        print(f"    Requests with timing: {summary['thinking_time_count']}")
+                    self._print_stats(summary)
                     continue
 
                 if user_input.lower() == "help":
                     self.logger.debug("User requested help")
-                    print("Available commands:")
-                    print("  clear    - Clear conversation history")
-                    print("  history  - Show conversation statistics")
-                    print("  help     - Show this help message")
-                    print("  list     - List all tasks (no LLM interaction)")
-                    print("  quit     - Exit the application")
-                    print("  Or just type your request naturally!")
+                    self._print_help()
+                    continue
+
+                if user_input.lower() == "about":
+                    self.logger.debug("User requested about information")
+                    self._print_about()
                     continue
 
                 if user_input.lower() == "list":
                     self.logger.debug("User requested task list")
                     try:
                         output = self.todo_shell.list_tasks()
-                        print(output)
+                        formatted_output = TaskFormatter.format_task_list(output)
+                        task_panel = PanelFormatter.create_task_panel(formatted_output)
+                        self.console.print(task_panel)
                     except Exception as e:
-                        self.logger.error(f"Error listing tasks: {str(e)}")
-                        print(f"Error: Failed to list tasks: {str(e)}")
+                        self.logger.error(f"Error listing tasks: {e!s}")
+                        error_msg = ResponseFormatter.format_error(
+                            f"Failed to list tasks: {e!s}"
+                        )
+                        self.console.print(error_msg)
                     continue
 
-                self.logger.info(f"Processing user request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}")
+                self.logger.info(
+                    f"Processing user request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}"
+                )
                 response = self.handle_request(user_input)
-                print(response)
+
+                # Format the response and create a panel
+                formatted_response = ResponseFormatter.format_response(response)
+                response_panel = PanelFormatter.create_response_panel(
+                    formatted_response
+                )
+                self.console.print(response_panel)
 
             except KeyboardInterrupt:
                 self.logger.info("User interrupted with Ctrl+C")
-                print("\nGoodbye!")
+                self.console.print("\n[bold green]Goodbye! 👋[/bold green]")
                 break
             except Exception as e:
-                self.logger.error(f"Error in CLI loop: {str(e)}")
-                print(f"Error: {str(e)}")
+                self.logger.error(f"Error in CLI loop: {e!s}")
+                error_msg = ResponseFormatter.format_error(str(e))
+                self.console.print(error_msg)
 
     def handle_request(self, user_input: str) -> str:
         """
@@ -181,20 +231,22 @@ class CLI:
             try:
                 # Process request through inference engine
                 response, thinking_time = self.inference.process_request(user_input)
-                
+
                 # Update spinner with completion message and thinking time
-                live.update(self._create_thinking_spinner(f"(thought for {thinking_time:.1f}s)"))
-                
+                live.update(
+                    self._create_thinking_spinner(f"(thought for {thinking_time:.1f}s)")
+                )
+
                 return response
             except Exception as e:
                 # Update spinner with error message
                 live.update(self._create_thinking_spinner("Request failed"))
-                
+
                 # Log the error
-                self.logger.error(f"Error in handle_request: {str(e)}")
-                
+                self.logger.error(f"Error in handle_request: {e!s}")
+
                 # Return error message
-                return f"Error: {str(e)}"
+                return ResponseFormatter.format_error(str(e))
 
     def run_single_request(self, user_input: str) -> str:
         """
@@ -206,5 +258,7 @@ class CLI:
         Returns:
             Formatted response
         """
-        self.logger.info(f"Running single request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}")
+        self.logger.info(
+            f"Running single request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}"
+        )
         return self.handle_request(user_input)