todo-agent 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

todo_agent/interface/cli.py

@@ -2,17 +2,16 @@
 Command-line interface for todo.sh LLM agent.
 """
 
+import readline
 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 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:
     from todo_agent.core.todo_manager import TodoManager
     from todo_agent.infrastructure.config import Config
     from todo_agent.infrastructure.inference import Inference
@@ -25,6 +24,7 @@ try:
         TableFormatter,
         TaskFormatter,
     )
+    from todo_agent.interface.progress import ToolCallProgress
     from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
     from core.todo_manager import TodoManager  # type: ignore[no-redef]
@@ -39,12 +39,8 @@ except ImportError:
         TableFormatter,
         TaskFormatter,
     )
+    from interface.progress import ToolCallProgress  # type: ignore[no-redef]
     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
 
 
 class CLI:
@@ -105,6 +101,113 @@ 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 Group(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()
@@ -207,7 +310,8 @@ class CLI:
                 if user_input.lower() == "list":
                     self.logger.debug("User requested task list")
                     try:
-                        output = self.todo_shell.list_tasks()
+                        # Use suppress_color=False for interactive display to preserve colors
+                        output = self.todo_shell.list_tasks(suppress_color=False)
                         formatted_output = TaskFormatter.format_task_list(output)
                         task_panel = PanelFormatter.create_task_panel(formatted_output)
                         self.console.print(task_panel)
@@ -222,7 +326,8 @@ class CLI:
                 if user_input.lower() == "done":
                     self.logger.debug("User requested completed task list")
                     try:
-                        output = self.todo_shell.list_completed()
+                        # Use suppress_color=False for interactive display to preserve colors
+                        output = self.todo_shell.list_completed(suppress_color=False)
                         formatted_output = TaskFormatter.format_completed_tasks(output)
                         task_panel = PanelFormatter.create_task_panel(
                             formatted_output, title="✅ Completed Tasks"
@@ -246,8 +351,8 @@ class CLI:
 
                 # 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 +382,13 @@ 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,31 @@ 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,69 @@
+"""
+Progress tracking interface for tool call execution.
+"""
+
+from abc import ABC, abstractmethod
+
+
+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

todo_agent/interface/tools.py

@@ -10,22 +10,24 @@ Discovery Tools (Call FIRST):
 - list_completed_tasks() - List all completed tasks from done.txt
 
 Task Management Tools:
-- add_task(description, priority?, project?, context?, due?, recurring?) - Add new task to todo.txt
+- add_task(description, priority?, project?, context?, due?, duration?) - Add new task to todo.txt
 - complete_task(task_number) - Mark task as complete by line number
 - replace_task(task_number, new_description) - Replace entire task content
 - append_to_task(task_number, text) - Add text to end of existing task
 - prepend_to_task(task_number, text) - Add text to beginning of existing task
 - delete_task(task_number, term?) - Delete entire task or remove specific term
+- created_completed_task(description, completion_date?, project?, context?) - Create task and immediately mark as completed
 
 Priority Management Tools:
 - set_priority(task_number, priority) - Set or change task priority (A-Z)
 - remove_priority(task_number) - Remove priority from task
+
+Task Modification Tools:
 - set_due_date(task_number, due_date) - Set or update due date for a task by intelligently rewriting it (use empty string to remove due date)
 - set_context(task_number, context) - Set or update context for a task by intelligently rewriting it (use empty string to remove context)
 - set_project(task_number, projects) - Set or update projects for a task by intelligently rewriting it (handles array of projects with add/remove operations)
 
 Utility Tools:
-- get_overview() - Show task statistics and summary
 - move_task(task_number, destination, source?) - Move task between files
 - archive_tasks() - Archive completed tasks from todo.txt to done.txt
 - get_calendar(month, year) - Get calendar for specific month and year
@@ -68,6 +70,7 @@ class ToolCallHandler:
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
+                "progress_description": "📁 Discovering available projects...",
             },
             {
                 "type": "function",
@@ -83,6 +86,7 @@ class ToolCallHandler:
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
+                "progress_description": "📍 Finding available contexts...",
             },
             {
                 "type": "function",
@@ -102,6 +106,7 @@ class ToolCallHandler:
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
+                "progress_description": "📋 Scanning your task list...",
             },
             {
                 "type": "function",
@@ -120,6 +125,7 @@ class ToolCallHandler:
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
+                "progress_description": "✅ Checking completion history...",
             },
             {
                 "type": "function",
@@ -166,10 +172,6 @@ class ToolCallHandler:
                                 "type": "string",
                                 "description": "Optional due date in YYYY-MM-DD format. Use parse_date() tool to convert natural language expressions like 'tomorrow', 'next week', 'by Friday' to YYYY-MM-DD format",
                             },
-                            "recurring": {
-                                "type": "string",
-                                "description": "Optional recurring pattern in rec:frequency[:interval] format (e.g., 'rec:daily', 'rec:weekly:2', 'rec:monthly'). Use for tasks that repeat automatically.",
-                            },
                             "duration": {
                                 "type": "string",
                                 "description": "Optional duration estimate in format: minutes (e.g., '30m'), hours (e.g., '2h'), or days (e.g., '1d'). Use for time planning and task prioritization.",
@@ -178,6 +180,7 @@ class ToolCallHandler:
                         "required": ["description"],
                     },
                 },
+                "progress_description": "✨ Creating new task: {description}...",
             },
             {
                 "type": "function",
@@ -201,6 +204,7 @@ class ToolCallHandler:
                         "required": ["task_number"],
                     },
                 },
+                "progress_description": "🎯 Marking task #{task_number} as complete...",
             },
             {
                 "type": "function",
@@ -228,6 +232,7 @@ class ToolCallHandler:
                         "required": ["task_number", "new_description"],
                     },
                 },
+                "progress_description": "✏️ Updating task #{task_number} with new description...",
             },
             {
                 "type": "function",
@@ -249,14 +254,15 @@ class ToolCallHandler:
                                 "type": "integer",
                                 "description": "The line number of the task to modify (required)",
                             },
-                            "text": {
+                            "text_to_append": {
                                 "type": "string",
-                                "description": "The text to append to the task (required)",
+                                "description": "Text to add to the end of the task (required)",
                             },
                         },
-                        "required": ["task_number", "text"],
+                        "required": ["task_number", "text_to_append"],
                     },
                 },
+                "progress_description": "📝 Adding notes to task #{task_number}...",
             },
             {
                 "type": "function",
@@ -283,6 +289,7 @@ class ToolCallHandler:
                         "required": ["task_number", "text"],
                     },
                 },
+                "progress_description": "📝 Adding prefix to task #{task_number}...",
             },
             {
                 "type": "function",
@@ -313,6 +320,7 @@ class ToolCallHandler:
                         "required": ["task_number"],
                     },
                 },
+                "progress_description": "🗑️ Deleting task #{task_number}...",
             },
             {
                 "type": "function",
@@ -340,6 +348,7 @@ class ToolCallHandler:
                         "required": ["task_number", "priority"],
                     },
                 },
+                "progress_description": "🏷️ Setting priority {priority} for task #{task_number}...",
             },
             {
                 "type": "function",
@@ -363,6 +372,7 @@ class ToolCallHandler:
                         "required": ["task_number"],
                     },
                 },
+                "progress_description": "🏷️ Removing priority from task #{task_number}...",
             },
             {
                 "type": "function",
@@ -394,6 +404,7 @@ class ToolCallHandler:
                         "required": ["task_number", "due_date"],
                     },
                 },
+                "progress_description": "📅 Setting due date {due_date} for task #{task_number}...",
             },
             {
                 "type": "function",
@@ -425,6 +436,7 @@ class ToolCallHandler:
                         "required": ["task_number", "context"],
                     },
                 },
+                "progress_description": "📍 Setting context {context} for task #{task_number}...",
             },
             {
                 "type": "function",
@@ -460,17 +472,7 @@ class ToolCallHandler:
                         "required": ["task_number", "projects"],
                     },
                 },
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "get_overview",
-                    "description": (
-                        "Show task statistics and summary. Use this when user asks for "
-                        "an overview, summary, or statistics about their tasks."
-                    ),
-                    "parameters": {"type": "object", "properties": {}, "required": []},
-                },
+                "progress_description": "🏷️ Setting project tags for task #{task_number}...",
             },
             {
                 "type": "function",
@@ -502,6 +504,7 @@ class ToolCallHandler:
                         "required": ["task_number", "destination"],
                     },
                 },
+                "progress_description": "📦 Moving task #{task_number} to {destination}...",
             },
             {
                 "type": "function",
@@ -514,6 +517,7 @@ class ToolCallHandler:
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
+                "progress_description": "📦 Archiving completed tasks...",
             },
             {
                 "type": "function",
@@ -540,6 +544,7 @@ class ToolCallHandler:
                         "required": ["date_expression"],
                     },
                 },
+                "progress_description": "📅 Converting date expression '{date_expression}'...",
             },
             {
                 "type": "function",
@@ -575,6 +580,73 @@ class ToolCallHandler:
                         "required": ["month", "year"],
                     },
                 },
+                "progress_description": "📅 Generating calendar for {month}/{year}...",
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "created_completed_task",
+                    "description": (
+                        "Create a task and immediately mark it as completed. "
+                        "USE CASE: Call this when user says they completed something on a specific date (e.g., 'I did the laundry today', 'I finished the report yesterday', 'I cleaned the garage last week') "
+                        "and you have already researched existing tasks to determine no match exists. "
+                        "WORKFLOW: 1) Use list_tasks() to search for existing tasks, 2) Use list_completed_tasks() to verify it's not already done, "
+                        "3) If no match found, call this tool to create and complete the task in one operation. "
+                        "STRATEGIC CONTEXT: This is a convenience tool for the common pattern of 'I did X on [date]' - "
+                        "it creates a task with the specified completion date and immediately marks it complete. "
+                        "The LLM should handle the research and decision-making about whether to use this tool."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "description": {
+                                "type": "string",
+                                "description": "The task description of what was completed (required)",
+                            },
+                            "completion_date": {
+                                "type": "string",
+                                "description": "Optional completion date in YYYY-MM-DD format (defaults to today)",
+                            },
+                            "project": {
+                                "type": "string",
+                                "description": "Optional project name (without the + symbol) for new task creation",
+                            },
+                            "context": {
+                                "type": "string",
+                                "description": "Optional context name (without the @ symbol) for new task creation",
+                            },
+                        },
+                        "required": ["description"],
+                    },
+                },
+                "progress_description": "✅ Creating completed task: {description}...",
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "restore_completed_task",
+                    "description": (
+                        "Restore a completed task from done.txt back to todo.txt, making it active again. "
+                        "USE CASE: Call this when user wants to reactivate a previously completed task. "
+                        "WORKFLOW: 1) Use list_completed_tasks() to find the completed task to restore, "
+                        "2) Call restore_completed_task() with the task number from done.txt. "
+                        "NOT FOR: Creating new tasks, completing tasks, or any other task operations. "
+                        "This tool ONLY restores existing completed tasks to active status. "
+                        "IMPORTANT: Use list_completed_tasks() first to find the correct task number "
+                        "if user doesn't specify it."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "task_number": {
+                                "type": "integer",
+                                "description": "The line number of the completed task in done.txt to restore (required)",
+                            }
+                        },
+                        "required": ["task_number"],
+                    },
+                },
+                "progress_description": "🔄 Restoring completed task #{task_number}...",
             },
         ]
 
@@ -731,8 +803,54 @@ class ToolCallHandler:
 
     def execute_tool(self, tool_call: Dict[str, Any]) -> Dict[str, Any]:
         """Execute a tool call and return the result."""
-        tool_name = tool_call["function"]["name"]
-        arguments = tool_call["function"]["arguments"]
+        # Validate tool call structure
+        if not isinstance(tool_call, dict):
+            return {  # type: ignore[unreachable]
+                "tool_call_id": "unknown",
+                "name": "unknown",
+                "output": "ERROR: Invalid tool call format",
+                "error": True,
+                "error_type": "malformed_tool_call",
+                "error_details": "Tool call is not a dictionary",
+                "user_message": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+            }
+
+        if "function" not in tool_call:
+            return {
+                "tool_call_id": tool_call.get("id", "unknown"),
+                "name": "unknown",
+                "output": "ERROR: Tool call missing function definition",
+                "error": True,
+                "error_type": "malformed_tool_call",
+                "error_details": "Tool call missing function field",
+                "user_message": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+            }
+
+        function = tool_call["function"]
+        if not isinstance(function, dict):
+            return {
+                "tool_call_id": tool_call.get("id", "unknown"),
+                "name": "unknown",
+                "output": "ERROR: Function definition is not a dictionary",
+                "error": True,
+                "error_type": "malformed_tool_call",
+                "error_details": "Function field is not a dictionary",
+                "user_message": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+            }
+
+        tool_name = function.get("name")
+        if not tool_name:
+            return {
+                "tool_call_id": tool_call.get("id", "unknown"),
+                "name": "unknown",
+                "output": "ERROR: Tool call missing function name",
+                "error": True,
+                "error_type": "malformed_tool_call",
+                "error_details": "Function missing name field",
+                "user_message": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+            }
+
+        arguments = function.get("arguments", {})
         tool_call_id = tool_call.get("id", "unknown")
 
         # Handle arguments that might be a string (JSON) or already a dict
@@ -779,11 +897,12 @@ class ToolCallHandler:
             "set_due_date": self.todo_manager.set_due_date,
             "set_context": self.todo_manager.set_context,
             "set_project": self.todo_manager.set_project,
-            "get_overview": self.todo_manager.get_overview,
             "move_task": self.todo_manager.move_task,
             "archive_tasks": self.todo_manager.archive_tasks,
             "parse_date": self._parse_date,
             "get_calendar": self._get_calendar,
+            "created_completed_task": self.todo_manager.created_completed_task,
+            "restore_completed_task": self.todo_manager.restore_completed_task,
         }
 
         if tool_name not in method_map:

{todo_agent-0.3.1.dist-info → todo_agent-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.3.1
+Version: 0.3.3
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate
@@ -68,7 +68,7 @@ todo-agent "show my work tasks"
 
 **Get intelligent insights** beyond basic task lists. It organizes tasks strategically, suggests priorities, and recommends optimal timing based on your patterns.
 
-**Work smarter** with automatic duplicate detection, recurring task handling, and calendar-aware scheduling.
+**Work smarter** with automatic duplicate detection and calendar-aware scheduling.
 
 **Choose your privacy** - use cloud AI (OpenRouter) or run locally (Ollama).
 
@@ -163,7 +163,7 @@ todo-agent "what tasks are blocking other work?"
 ### Natural Language Intelligence
 ```bash
 todo-agent "add dentist appointment next Monday"
-todo-agent "set up recurring daily vitamin reminder"
+
 todo-agent "move all completed tasks to archive"
 todo-agent "show me tasks I can do from home"
 ```