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

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

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

{todo_agent-0.2.1 → todo_agent-0.2.3}/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.3}/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.3'
+__version_tuple__ = version_tuple = (0, 2, 3)
 
-__commit_id__ = commit_id = 'g753e8c9be'
+__commit_id__ = commit_id = 'ge1a08d166'

todo_agent-0.2.3/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.3}/todo_agent/interface/cli.py

@@ -3,6 +3,9 @@ Command-line interface for todo.sh LLM agent.
 """
 
 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 +16,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 +30,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 +49,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 +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")
 
@@ -82,20 +103,51 @@ 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 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 +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: {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)
+                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: {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 +246,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.3/todo_agent/interface/formatters.py

@@ -0,0 +1,399 @@
+"""
+Formatters for CLI output with unicode characters and consistent styling.
+"""
+
+from typing import Any, Dict
+
+from rich.align import Align
+from rich.box import ROUNDED
+from rich.panel import Panel
+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") -> Panel:
+        """Create a panel for displaying LLM responses."""
+        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,
+        )

{todo_agent-0.2.1 → todo_agent-0.2.3}/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.3}/todo_agent.egg-info/PKG-INFO

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

{todo_agent-0.2.1 → todo_agent-0.2.3}/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"]