todo-agent 0.2.1__tar.gz → 0.2.4__tar.gz

{todo_agent-0.2.1 → todo_agent-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.2.1
+Version: 0.2.4
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate

{todo_agent-0.2.1 → todo_agent-0.2.4}/tests/test_core/test_conversation_manager.py

@@ -14,7 +14,7 @@ class TestConversationManager:
         """Test ConversationManager initialization."""
         manager = ConversationManager()
         assert len(manager.history) == 0
-        assert manager.max_tokens == 4000
+        assert manager.max_tokens == 16000
         assert manager.max_messages == 50
         assert manager.system_prompt is None
 

{todo_agent-0.2.1 → todo_agent-0.2.4}/tests/test_interface/test_cli.py

@@ -151,8 +151,8 @@ class TestCLI:
 
         result = self.cli.handle_request(user_input)
 
-        # Verify error is properly formatted
-        assert result == f"Error: {error_message}"
+        # Verify error is properly formatted with unicode
+        assert result == f"❌ {error_message}"
 
         # Verify inference engine was called
         self.cli.inference.process_request.assert_called_once_with(user_input)

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
 
-__commit_id__ = commit_id = 'g753e8c9be'
+__commit_id__ = commit_id = 'gc2b1a1313'

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent/core/conversation_manager.py

@@ -35,7 +35,7 @@ class ConversationManager:
     """Manages conversation state and memory for LLM interactions."""
 
     def __init__(
-        self, max_tokens: int = 4000, max_messages: int = 50, model: str = "gpt-4"
+        self, max_tokens: int = 16000, max_messages: int = 50, model: str = "gpt-4"
     ):
         self.history: List[ConversationMessage] = []
         self.max_tokens = max_tokens

todo_agent-0.2.4/todo_agent/interface/__init__.py

@@ -0,0 +1,25 @@
+"""
+Interface layer for todo.sh LLM agent.
+
+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",
+    "PanelFormatter",
+    "ResponseFormatter",
+    "StatsFormatter",
+    "TableFormatter",
+    "TaskFormatter",
+    "ToolCallHandler",
+]

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent/interface/cli.py

@@ -2,7 +2,12 @@
 Command-line interface for todo.sh LLM agent.
 """
 
+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
@@ -13,6 +18,13 @@ try:
     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]
@@ -20,7 +32,15 @@ except ImportError:
     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
@@ -31,6 +51,9 @@ class CLI:
     """User interaction loop and input/output handling."""
 
     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")
@@ -55,8 +78,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")
 
@@ -82,20 +105,72 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
+    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 _get_memory_usage(self) -> Optional[Text]:
+        """Get session memory usage as a progress bar."""
+        # Get conversation manager to access memory limits and current usage
+        conversation_manager = self.inference.get_conversation_manager()
+        
+        # Get current usage from conversation summary
+        summary = conversation_manager.get_conversation_summary()
+        current_tokens = summary.get("estimated_tokens", 0)
+        current_messages = summary.get("total_messages", 0)
+        
+        # Get limits from conversation manager
+        max_tokens = conversation_manager.max_tokens
+        max_messages = conversation_manager.max_messages
+        
+        # Create memory usage bar
+        memory_bar = PanelFormatter.create_memory_usage_bar(
+            current_tokens, max_tokens, current_messages, max_messages
+        )
+        
+        return memory_bar
+
     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:
@@ -105,76 +180,69 @@ 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: {e!s}")
-                        print(f"Error: Failed to list 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 ''}"
                 )
                 response = self.handle_request(user_input)
-                print(response)
+
+                # Format the response and create a panel
+                formatted_response = ResponseFormatter.format_response(response)
+                
+                # Get memory usage
+                memory_usage = self._get_memory_usage()
+                
+                # Create response panel with memory usage
+                response_panel = PanelFormatter.create_response_panel(
+                    formatted_response, memory_usage=memory_usage
+                )
+                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: {e!s}")
-                print(f"Error: {e!s}")
+                error_msg = ResponseFormatter.format_error(str(e))
+                self.console.print(error_msg)
 
     def handle_request(self, user_input: str) -> str:
         """
@@ -206,7 +274,7 @@ class CLI:
                 self.logger.error(f"Error in handle_request: {e!s}")
 
                 # Return error message
-                return f"Error: {e!s}"
+                return ResponseFormatter.format_error(str(e))
 
     def run_single_request(self, user_input: str) -> str:
         """

todo_agent-0.2.4/todo_agent/interface/formatters.py

@@ -0,0 +1,457 @@
+"""
+Formatters for CLI output with unicode characters and consistent styling.
+"""
+
+from typing import Any, Dict, Optional
+
+from rich.align import Align
+from rich.box import ROUNDED
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.table import Table
+from rich.text import Text
+
+# CLI width configuration
+CLI_WIDTH = 100
+PANEL_WIDTH = CLI_WIDTH - 2  # Leave 2 characters for borders
+
+
+class TaskFormatter:
+    """Formats task-related output with unicode characters and consistent styling."""
+
+    @staticmethod
+    def format_task_list(raw_tasks: str) -> Text:
+        """
+        Format a raw task list with unicode characters and numbering.
+
+        Args:
+            raw_tasks: Raw task output from todo.sh
+            title: Title for the task list
+
+        Returns:
+            Formatted task list as Rich Text object
+        """
+        if not raw_tasks.strip():
+            return Text("No tasks found.")
+
+        lines = raw_tasks.strip().split("\n")
+        formatted_text = Text()
+        task_count = 0
+
+        # Add header
+        formatted_text.append("Tasks", style="bold blue")
+        formatted_text.append("\n\n")
+
+        for line in lines:
+            line = line.strip()
+            # Skip empty lines, separators, and todo.sh's own summary line
+            if line and line != "--" and not line.startswith("TODO:"):
+                task_count += 1
+                # Parse todo.txt format and make it more readable
+                formatted_task = TaskFormatter._format_single_task(line, task_count)
+                # Create a Text object that respects ANSI codes
+                task_text = Text.from_ansi(formatted_task)
+                formatted_text.append(task_text)
+                formatted_text.append("\n")
+
+        # Add task count at the end
+        if task_count > 0:
+            formatted_text.append("\n")
+            formatted_text.append(f"TODO: {task_count} of {task_count} tasks shown")
+        else:
+            formatted_text = Text("No tasks found.")
+
+        return formatted_text
+
+    @staticmethod
+    def _format_single_task(task_line: str, task_number: int) -> str:
+        """
+        Format a single task line with unicode characters.
+
+        Args:
+            task_line: Raw task line from todo.sh
+            task_number: Task number for display
+
+        Returns:
+            Formatted task string
+        """
+        # Parse todo.txt format: "1 (A) 2025-08-29 Clean cat box @home +chores due:2025-08-29"
+        parts = task_line.split(
+            " ", 1
+        )  # Split on first space to separate number from rest
+        if len(parts) < 2:
+            return f"  {task_number:2d} │   │ {task_line}"
+
+        rest = parts[1]
+
+        # Extract priority if present (format: "(A)")
+        priority = ""
+        description = rest
+
+        if rest.startswith("(") and ")" in rest:
+            priority_end = rest.find(")")
+            priority = rest[1:priority_end]
+            description = rest[priority_end + 1 :].strip()
+
+        # Format with unicode characters
+        if priority:
+            formatted_line = f"  {task_number:2d} │ {priority} │ {description}"
+        else:
+            formatted_line = f"  {task_number:2d} │   │ {description}"
+
+        return formatted_line
+
+    @staticmethod
+    def format_projects(raw_projects: str) -> str:
+        """
+        Format project list with unicode characters.
+
+        Args:
+            raw_projects: Raw project output from todo.sh
+
+        Returns:
+            Formatted project list string
+        """
+        if not raw_projects.strip():
+            return "No projects found."
+
+        lines = raw_projects.strip().split("\n")
+        formatted_lines = []
+
+        for i, project in enumerate(lines, 1):
+            if project.strip():
+                # Remove the + prefix and format nicely
+                clean_project = project.strip().lstrip("+")
+                formatted_lines.append(f"  {i:2d} │ {clean_project}")
+
+        if formatted_lines:
+            return "\n".join(formatted_lines)
+        else:
+            return "No projects found."
+
+    @staticmethod
+    def format_contexts(raw_contexts: str) -> str:
+        """
+        Format context list with unicode characters.
+
+        Args:
+            raw_contexts: Raw context output from todo.sh
+
+        Returns:
+            Formatted context list string
+        """
+        if not raw_contexts.strip():
+            return "No contexts found."
+
+        lines = raw_contexts.strip().split("\n")
+        formatted_lines = []
+
+        for i, context in enumerate(lines, 1):
+            if context.strip():
+                # Remove the @ prefix and format nicely
+                clean_context = context.strip().lstrip("@")
+                formatted_lines.append(f"  {i:2d} │ {clean_context}")
+
+        if formatted_lines:
+            return "\n".join(formatted_lines)
+        else:
+            return "No contexts found."
+
+
+class ResponseFormatter:
+    """Formats LLM responses and other output with consistent styling."""
+
+    @staticmethod
+    def format_response(response: str) -> str:
+        """
+        Format an LLM response with consistent styling.
+
+        Args:
+            response: Raw response text
+            title: Title for the response panel
+
+        Returns:
+            Formatted response string
+        """
+        # If response contains task lists, format them nicely
+        if "No tasks found" in response or "1." in response:
+            # This might be a task list response, try to format it
+            lines = response.split("\n")
+            formatted_lines = []
+
+            for line in lines:
+                if line.strip().startswith(
+                    ("1.", "2.", "3.", "4.", "5.", "6.", "7.", "8.", "9.")
+                ):
+                    # This looks like a numbered task list, format it
+                    parts = line.split(".", 1)
+                    if len(parts) == 2:
+                        number = parts[0].strip()
+                        content = parts[1].strip()
+                        formatted_lines.append(f"  {number:>2} │ {content}")
+                    else:
+                        formatted_lines.append(line)
+                else:
+                    formatted_lines.append(line)
+
+            return "\n".join(formatted_lines)
+
+        return response
+
+    @staticmethod
+    def format_error(error_message: str) -> str:
+        """
+        Format error messages consistently.
+
+        Args:
+            error_message: Error message to format
+
+        Returns:
+            Formatted error string
+        """
+        return f"❌ {error_message}"
+
+    @staticmethod
+    def format_success(message: str) -> str:
+        """
+        Format success messages consistently.
+
+        Args:
+            message: Success message to format
+
+        Returns:
+            Formatted success string
+        """
+        return f"✅ {message}"
+
+
+class StatsFormatter:
+    """Formats statistics and overview information."""
+
+    @staticmethod
+    def format_overview(overview: str) -> str:
+        """
+        Format task overview with unicode characters.
+
+        Args:
+            overview: Raw overview string
+
+        Returns:
+            Formatted overview string
+        """
+        if "Task Overview:" in overview:
+            lines = overview.split("\n")
+            formatted_lines = []
+
+            for line in lines:
+                if line.startswith("- Active tasks:"):
+                    formatted_lines.append(f"📋 {line[2:]}")
+                elif line.startswith("- Completed tasks:"):
+                    formatted_lines.append(f"✅ {line[2:]}")
+                else:
+                    formatted_lines.append(line)
+
+            return "\n".join(formatted_lines)
+
+        return overview
+
+
+class TableFormatter:
+    """Creates rich tables for various data displays."""
+
+    @staticmethod
+    def create_command_table() -> Table:
+        """Create a table for displaying available commands."""
+        table = Table(
+            title="Available Commands",
+            box=ROUNDED,
+            show_header=True,
+            header_style="bold magenta",
+            width=PANEL_WIDTH,
+        )
+
+        table.add_column("Command", style="cyan", width=12)
+        table.add_column("Description", style="white")
+
+        commands = [
+            ("clear", "Clear conversation history"),
+            ("stats", "Show conversation statistics"),
+            ("help", "Show this help message"),
+            ("about", "Show application information"),
+            ("list", "List all tasks (no LLM interaction)"),
+            ("quit", "Exit the application"),
+        ]
+
+        for cmd, desc in commands:
+            table.add_row(cmd, desc)
+
+        return table
+
+    @staticmethod
+    def create_stats_table(summary: Dict[str, Any]) -> Table:
+        """Create a table for displaying conversation statistics."""
+        table = Table(
+            title="Conversation Statistics",
+            box=ROUNDED,
+            show_header=True,
+            header_style="bold magenta",
+            width=PANEL_WIDTH,
+        )
+
+        table.add_column("Metric", style="cyan", width=20)
+        table.add_column("Value", style="white")
+
+        # Basic stats
+        table.add_row("Total Messages", str(summary["total_messages"]))
+        table.add_row("User Messages", str(summary["user_messages"]))
+        table.add_row("Assistant Messages", str(summary["assistant_messages"]))
+        table.add_row("Tool Messages", str(summary["tool_messages"]))
+        table.add_row("Estimated Tokens", str(summary["estimated_tokens"]))
+
+        # Thinking time stats if available
+        if "thinking_time_count" in summary and summary["thinking_time_count"] > 0:
+            table.add_row("", "")  # Empty row for spacing
+            table.add_row(
+                "Total Thinking Time", f"{summary['total_thinking_time']:.2f}s"
+            )
+            table.add_row(
+                "Average Thinking Time", f"{summary['average_thinking_time']:.2f}s"
+            )
+            table.add_row("Min Thinking Time", f"{summary['min_thinking_time']:.2f}s")
+            table.add_row("Max Thinking Time", f"{summary['max_thinking_time']:.2f}s")
+            table.add_row("Requests with Timing", str(summary["thinking_time_count"]))
+
+        return table
+
+
+class PanelFormatter:
+    """Creates rich panels for various content displays."""
+
+    @staticmethod
+    def create_header_panel() -> Panel:
+        """Create the application header panel."""
+        header_text = Text("Todo.sh LLM Agent", style="bold blue")
+        return Panel(
+            Align.center(header_text),
+            title="🤖",
+            border_style="dim",
+            box=ROUNDED,
+            width=PANEL_WIDTH + 2,
+        )
+
+    @staticmethod
+    def create_task_panel(content: str, title: str = "📋 Current Tasks") -> Panel:
+        """Create a panel for displaying task lists."""
+        return Panel(
+            content, title=title, border_style="dim", box=ROUNDED, width=PANEL_WIDTH
+        )
+
+    @staticmethod
+    def create_response_panel(content: str, title: str = "🤖 Assistant", memory_usage: Optional[Text] = None) -> Panel:
+        """Create a panel for displaying LLM responses."""
+        if memory_usage:
+            # Create the combined content with centered memory usage
+            return Panel(
+                Align.center(
+                    Text.assemble(
+                        content,
+                        "\n\n",
+                        "─" * (PANEL_WIDTH - 4),  # Separator line
+                        "\n",
+                        memory_usage
+                    )
+                ),
+                title=title, border_style="dim", box=ROUNDED, width=PANEL_WIDTH
+            )
+        else:
+            return Panel(
+                content, title=title, border_style="dim", box=ROUNDED, width=PANEL_WIDTH
+            )
+
+    @staticmethod
+    def create_error_panel(content: str, title: str = "❌ Error") -> Panel:
+        """Create a panel for displaying errors."""
+        return Panel(
+            content, title=title, border_style="red", box=ROUNDED, width=PANEL_WIDTH
+        )
+
+    @staticmethod
+    def create_about_panel() -> Panel:
+        """Create a panel for displaying about information."""
+        from todo_agent._version import __commit_id__, __version__
+
+        about_content = Text()
+        about_content.append("Todo.sh LLM Agent\n", style="bold blue")
+        about_content.append("\n")
+        about_content.append(
+            "A natural language interface for todo.sh task management\n", style="white"
+        )
+        about_content.append("powered by LLM function calling.\n", style="white")
+        about_content.append("\n")
+        about_content.append("Version: ", style="cyan")
+        about_content.append(f"{__version__}\n", style="white")
+        if __commit_id__:
+            about_content.append("Commit: ", style="cyan")
+            about_content.append(f"{__commit_id__}\n", style="white")
+        about_content.append("\n")
+        about_content.append(
+            "Transform natural language into todo.sh commands:\n", style="italic"
+        )
+        about_content.append("• 'add buy groceries to shopping list'\n", style="dim")
+        about_content.append("• 'show my work tasks'\n", style="dim")
+        about_content.append("• 'mark task 3 as done'\n", style="dim")
+        about_content.append("\n")
+        about_content.append("GitHub: ", style="cyan")
+        about_content.append(
+            "https://github.com/codeprimate/todo-agent\n", style="blue"
+        )
+
+        return Panel(
+            Align.center(about_content),
+            title="i  About",
+            border_style="dim",
+            box=ROUNDED,
+            width=PANEL_WIDTH + 2,
+        )
+
+    @staticmethod
+    def create_memory_usage_bar(current_tokens: int, max_tokens: int, current_messages: int, max_messages: int) -> Text:
+        """
+        Create a rich progress bar showing session memory usage.
+        
+        Args:
+            current_tokens: Current number of tokens in conversation
+            max_tokens: Maximum allowed tokens
+            current_messages: Current number of messages in conversation
+            max_messages: Maximum allowed messages
+            
+        Returns:
+            Rich Text object with memory usage progress bar
+        """
+        # Calculate percentage
+        token_percentage = min(100, (current_tokens / max_tokens) * 100)
+        
+        # Determine color based on usage
+        if token_percentage >= 90:
+            color = "red"
+        elif token_percentage >= 75:
+            color = "yellow"
+        else:
+            color = "green"
+        
+        # Create the progress bar text
+        memory_text = Text()
+        memory_text.append(f"{current_tokens:,}/{max_tokens:,} ", style="dim")
+        
+        # Create a simple text-based progress bar
+        bar_length = 25
+        token_filled = int((token_percentage / 100) * bar_length)
+        token_bar = "█" * token_filled + "░" * (bar_length - token_filled)
+        memory_text.append(f"[{token_bar}] ", style="dim")
+        memory_text.append(f"{token_percentage:.1f}%", style="dim")
+        
+        # Add message count without progress bar
+        memory_text.append(" | ", style="dim")
+        memory_text.append(f"{current_messages}/{max_messages}", style="dim")
+        
+        return memory_text

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent/main.py

@@ -36,8 +36,16 @@ Examples:
 
         if args.command:
             # Single command mode
-            response = cli.run_single_request(args.command)
-            print(response)
+            # Handle special commands that don't need LLM processing
+            if args.command.lower() in ["help", "about"]:
+                if args.command.lower() == "help":
+                    cli._print_help()
+                elif args.command.lower() == "about":
+                    cli._print_about()
+            else:
+                # Process through LLM
+                response = cli.run_single_request(args.command)
+                print(response)
         else:
             # Interactive mode
             cli.run()

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.2.1
+Version: 0.2.4
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate

{todo_agent-0.2.1 → todo_agent-0.2.4}/todo_agent.egg-info/SOURCES.txt

@@ -51,4 +51,5 @@ todo_agent/infrastructure/token_counter.py
 todo_agent/infrastructure/prompts/system_prompt.txt
 todo_agent/interface/__init__.py
 todo_agent/interface/cli.py
+todo_agent/interface/formatters.py
 todo_agent/interface/tools.py

todo_agent-0.2.1/todo_agent/interface/__init__.py

@@ -1,10 +0,0 @@
-"""
-Interface layer for todo.sh LLM agent.
-
-This module contains user interfaces and presentation logic.
-"""
-
-from .cli import CLI
-from .tools import ToolCallHandler
-
-__all__ = ["CLI", "ToolCallHandler"]