todo-agent 0.2.9__py3-none-any.whl → 0.3.2__py3-none-any.whl

todo_agent/infrastructure/todo_shell.py

@@ -4,7 +4,7 @@ Subprocess wrapper for todo.sh operations.
 
 import os
 import subprocess  # nosec B404
-from typing import Any, List, Optional
+from typing import Any, List, Optional, TypedDict
 
 try:
     from todo_agent.core.exceptions import TodoShellError
@@ -12,6 +12,18 @@ except ImportError:
     from core.exceptions import TodoShellError  # type: ignore[no-redef]
 
 
+class TaskComponents(TypedDict):
+    """Type definition for task components."""
+
+    priority: str | None
+    description: str
+    projects: list[str]
+    contexts: list[str]
+    due: str | None
+
+    other_tags: list[str]
+
+
 class TodoShell:
     """Subprocess execution wrapper with error management."""
 
@@ -243,19 +255,19 @@ class TodoShell:
     def _extract_task_number(self, line: str) -> Optional[int]:
         """
         Extract task number from a line that may contain ANSI color codes.
-        
+
         Args:
             line: Task line that may contain ANSI color codes
-            
+
         Returns:
             Task number if found, None otherwise
         """
         from rich.text import Text
-        
+
         # Use rich to properly handle ANSI color codes
         text = Text.from_ansi(line)
         clean_line = text.plain
-        
+
         # Split on first space and check if first part is a number
         parts = clean_line.split(" ", 1)
         if parts and parts[0].isdigit():
@@ -319,7 +331,8 @@ class TodoShell:
                     # Remove the project if it exists (with or without + prefix)
                     project_to_remove = f"+{clean_project}"
                     components["projects"] = [
-                        p for p in components["projects"] 
+                        p
+                        for p in components["projects"]
                         if p != project_to_remove and p != clean_project
                     ]
                 else:
@@ -345,7 +358,7 @@ class TodoShell:
         # Replace the task with the new description
         return self.replace(task_number, new_description)
 
-    def _parse_task_components(self, task_line: str) -> dict:
+    def _parse_task_components(self, task_line: str) -> TaskComponents:
         """
         Parse a todo.txt task line into its components.
 
@@ -357,9 +370,10 @@ class TodoShell:
         """
         # Remove ANSI color codes first using rich
         from rich.text import Text
+
         text = Text.from_ansi(task_line)
         task_line = text.plain
-        
+
         # Remove task number prefix if present (e.g., "1 " or "1. ")
         # First try the format without dot (standard todo.sh format)
         if " " in task_line and task_line.split(" ")[0].isdigit():
@@ -368,13 +382,12 @@ class TodoShell:
         elif ". " in task_line:
             task_line = task_line.split(". ", 1)[1]
 
-        components = {
+        components: TaskComponents = {
             "priority": None,
             "description": "",
             "projects": [],
             "contexts": [],
             "due": None,
-            "recurring": None,
             "other_tags": [],
         }
 
@@ -409,17 +422,8 @@ class TodoShell:
                 components["due"] = word[4:]  # Remove 'due:' prefix
                 continue
 
-            # Recurring: rec:frequency[:interval]
-            if word.startswith("rec:"):
-                components["recurring"] = word
-                continue
-
             # Other tags (like custom tags)
-            if (
-                ":" in word
-                and not word.startswith("due:")
-                and not word.startswith("rec:")
-            ):
+            if ":" in word and not word.startswith("due:"):
                 other_tags_set.add(word)
                 continue
 
@@ -430,13 +434,13 @@ class TodoShell:
                 components["description"] = word
 
         # Convert sets back to sorted lists for consistent ordering
-        components["projects"] = sorted(list(projects_set))
-        components["contexts"] = sorted(list(contexts_set))
-        components["other_tags"] = sorted(list(other_tags_set))
+        components["projects"] = sorted(projects_set)
+        components["contexts"] = sorted(contexts_set)
+        components["other_tags"] = sorted(other_tags_set)
 
         return components
 
-    def _reconstruct_task(self, components: dict) -> str:
+    def _reconstruct_task(self, components: TaskComponents) -> str:
         """
         Reconstruct a task description from parsed components.
 
@@ -466,10 +470,6 @@ class TodoShell:
         if components["due"]:
             parts.append(f"due:{components['due']}")
 
-        # Add recurring pattern
-        if components["recurring"]:
-            parts.append(components["recurring"])
-
         # Add other tags
         parts.extend(components["other_tags"])
 

todo_agent/interface/cli.py

@@ -3,16 +3,14 @@ Command-line interface for todo.sh LLM agent.
 """
 
 from typing import Optional
+import readline
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
 
 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.inference import Inference
@@ -26,6 +24,7 @@ try:
         TaskFormatter,
     )
     from todo_agent.interface.tools import ToolCallHandler
+    from todo_agent.interface.progress import ToolCallProgress
 except ImportError:
     from core.todo_manager import TodoManager  # type: ignore[no-redef]
     from infrastructure.config import Config  # type: ignore[no-redef]
@@ -40,11 +39,7 @@ except ImportError:
         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 interface.progress import ToolCallProgress  # type: ignore[no-redef]
 
 
 class CLI:
@@ -105,6 +100,100 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
+    def _create_tool_call_spinner(self, progress_description: str, 
+                                 sequence: int = 0, total_sequences: int = 0) -> Group:
+        """
+        Create a multi-line spinner showing tool call progress.
+        
+        Args:
+            progress_description: User-friendly description of what the tool is doing
+            sequence: Current sequence number
+            total_sequences: Total number of sequences
+            
+        Returns:
+            Group object with spinner and optional sequence info
+        """
+        # Line 1: Main progress with spinner
+        main_line = Spinner("dots", text=Text(progress_description, style="cyan"))
+        
+        # Line 2: Sequence progress (show current sequence even if we don't know total)
+        # if sequence > 0:
+        #     if total_sequences > 0:
+        #         sequence_text = Text(f"Sequence {sequence}/{total_sequences}", style="dim")
+        #     else:
+        #         sequence_text = Text(f"Sequence {sequence}", style="dim")
+        #     return Group(main_line, sequence_text)
+        
+        return main_line
+
+    def _create_completion_spinner(self, thinking_time: float) -> Spinner:
+        """
+        Create completion spinner with timing.
+        
+        Args:
+            thinking_time: Total thinking time in seconds
+            
+        Returns:
+            Spinner object showing completion
+        """
+        return Spinner("dots", text=Text(f"✅ Complete ({thinking_time:.1f}s)", style="green"))
+
+    def _create_cli_progress_callback(self, live_display: Live) -> ToolCallProgress:
+        """
+        Create a CLI-specific progress callback for tool call tracking.
+        
+        Args:
+            live_display: The live display to update
+            
+        Returns:
+            ToolCallProgress implementation for CLI
+        """
+        class CLIProgressCallback(ToolCallProgress):
+            def __init__(self, cli: CLI, live: Live):
+                self.cli = cli
+                self.live = live
+                self.current_sequence = 0
+                self.total_sequences = 0
+            
+            def on_thinking_start(self) -> None:
+                """Show initial thinking spinner."""
+                spinner = self.cli._create_thinking_spinner("🤔 Analyzing your request...")
+                self.live.update(spinner)
+            
+            def on_tool_call_start(self, tool_name: str, progress_description: str,
+                                 sequence: int, total_sequences: int) -> None:
+                """Show tool execution progress."""
+                self.current_sequence = sequence
+                self.total_sequences = total_sequences
+                
+                # Create multi-line spinner
+                spinner = self.cli._create_tool_call_spinner(
+                    progress_description=progress_description,
+                    sequence=sequence,
+                    total_sequences=total_sequences
+                )
+                self.live.update(spinner)
+            
+            def on_tool_call_complete(self, tool_name: str, success: bool, duration: float) -> None:
+                """Tool completion - no action needed."""
+                pass
+            
+            def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+                """Show sequence completion."""
+                spinner = self.cli._create_tool_call_spinner(
+                    progress_description=f"🔄 Sequence {sequence} complete",
+                    sequence=sequence,
+                    total_sequences=total_sequences
+                )
+                self.live.update(spinner)
+            
+            def on_thinking_complete(self, total_time: float) -> None:
+                """Show completion spinner."""
+                spinner = self.cli._create_completion_spinner(total_time)
+                self.live.update(spinner)
+        
+        return CLIProgressCallback(self, live_display)
+
     def _print_header(self) -> None:
         """Print the application header with unicode borders."""
         header_panel = PanelFormatter.create_header_panel()
@@ -244,10 +333,10 @@ class CLI:
                 # Format the response and create a panel
                 formatted_response = ResponseFormatter.format_response(response)
 
-                # Get memory usage 
+                # Get memory usage
                 # DISABLED FOR NOW
-                # memory_usage = self._get_memory_usage()
-                memory_usage = None 
+                memory_usage = self._get_memory_usage()
+                #memory_usage = None
 
                 # Create response panel with memory usage
                 response_panel = PanelFormatter.create_response_panel(
@@ -277,8 +366,11 @@ class CLI:
         # Show thinking spinner during LLM processing
         with self._get_thinking_live() as live:
             try:
-                # Process request through inference engine
-                response, thinking_time = self.inference.process_request(user_input)
+                # Create progress callback for tool call tracking
+                progress_callback = self._create_cli_progress_callback(live)
+                
+                # Process request through inference engine with progress tracking
+                response, thinking_time = self.inference.process_request(user_input, progress_callback)
 
                 # Update spinner with completion message and thinking time
                 live.update(

todo_agent/interface/formatters.py

@@ -14,6 +14,28 @@ from rich.text import Text
 CLI_WIDTH = 100
 PANEL_WIDTH = CLI_WIDTH - 2  # Leave 2 characters for borders
 
+# Provider error message mapping
+PROVIDER_ERROR_MESSAGES = {
+    "malformed_response": "I got a confusing response from my AI service. Please try again, or type 'clear' to reset our conversation.",
+    "malformed_tool_call": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+    "rate_limit": "I'm a bit overwhelmed right now. Please wait a moment and try again, or type 'clear' to start fresh.",
+    "auth_error": "I can't connect to my AI service. Please check your configuration, or type 'clear' to reset.",
+    "timeout": "The request took too long. Please try again, or type 'clear' to reset our conversation.",
+    "general_error": "Something went wrong with my AI service. Please try again, or type 'clear' to reset our conversation."
+}
+
+def get_provider_error_message(error_type: str) -> str:
+    """
+    Get user-friendly error message for provider errors.
+    
+    Args:
+        error_type: The type of provider error
+        
+    Returns:
+        User-friendly error message with recovery suggestion
+    """
+    return PROVIDER_ERROR_MESSAGES.get(error_type, PROVIDER_ERROR_MESSAGES["general_error"])
+
 
 class TaskFormatter:
     """Formats task-related output with unicode characters and consistent styling."""

todo_agent/interface/progress.py

@@ -0,0 +1,58 @@
+"""
+Progress tracking interface for tool call execution.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class ToolCallProgress(ABC):
+    """Abstract interface for tool call progress tracking."""
+    
+    @abstractmethod
+    def on_thinking_start(self) -> None:
+        """Called when LLM starts thinking."""
+        pass
+    
+    @abstractmethod
+    def on_tool_call_start(self, tool_name: str, progress_description: str, 
+                          sequence: int, total_sequences: int) -> None:
+        """Called when a tool call starts."""
+        pass
+    
+    @abstractmethod
+    def on_tool_call_complete(self, tool_name: str, success: bool, 
+                             duration: float) -> None:
+        """Called when a tool call completes (optional - no action needed)."""
+        pass
+    
+    @abstractmethod
+    def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+        """Called when a tool call sequence completes."""
+        pass
+    
+    @abstractmethod
+    def on_thinking_complete(self, total_time: float) -> None:
+        """Called when thinking is complete."""
+        pass
+
+
+class NoOpProgress(ToolCallProgress):
+    """No-operation implementation for when progress tracking is not needed."""
+    
+    def on_thinking_start(self) -> None:
+        pass
+    
+    def on_tool_call_start(self, tool_name: str, progress_description: str, 
+                          sequence: int, total_sequences: int) -> None:
+        pass
+    
+    def on_tool_call_complete(self, tool_name: str, success: bool, 
+                             duration: float) -> None:
+        pass
+    
+    def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+        pass
+    
+    def on_thinking_complete(self, total_time: float) -> None:
+        pass