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

todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.9'
-__version_tuple__ = version_tuple = (0, 2, 9)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)
 
 __commit_id__ = commit_id = None

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 = 32000, max_messages: int = 50, model: str = "gpt-4"
+        self, max_tokens: int = 64000, max_messages: int = 100, model: str = "gpt-4"
     ):
         self.history: List[ConversationMessage] = []
         self.max_tokens = max_tokens

todo_agent/core/exceptions.py

@@ -12,16 +12,67 @@ class TodoError(Exception):
 class TaskNotFoundError(TodoError):
     """Task not found in todo file."""
 
-    pass
+    def __init__(self, message: str = "Task not found"):
+        super().__init__(message)
+        self.message = message
 
 
 class InvalidTaskFormatError(TodoError):
     """Invalid task format."""
 
-    pass
+    def __init__(self, message: str = "Invalid task format"):
+        super().__init__(message)
+        self.message = message
 
 
 class TodoShellError(TodoError):
     """Subprocess execution error."""
 
-    pass
+    def __init__(self, message: str = "Todo.sh command failed"):
+        super().__init__(message)
+        self.message = message
+
+
+class ProviderError(Exception):
+    """Base exception for LLM provider errors."""
+    
+    def __init__(self, message: str, error_type: str, provider: str):
+        super().__init__(message)
+        self.message = message
+        self.error_type = error_type
+        self.provider = provider
+
+
+class MalformedResponseError(ProviderError):
+    """Provider returned malformed or invalid response."""
+    
+    def __init__(self, message: str, provider: str):
+        super().__init__(message, "malformed_response", provider)
+
+
+class RateLimitError(ProviderError):
+    """Provider rate limit exceeded."""
+    
+    def __init__(self, message: str, provider: str):
+        super().__init__(message, "rate_limit", provider)
+
+
+class AuthenticationError(ProviderError):
+    """Provider authentication failed."""
+    
+    def __init__(self, message: str, provider: str):
+        super().__init__(message, "auth_error", provider)
+
+
+class TimeoutError(ProviderError):
+    """Provider request timed out."""
+    
+    def __init__(self, message: str, provider: str):
+        super().__init__(message, "timeout", provider)
+
+
+class GeneralProviderError(ProviderError):
+    """General provider error."""
+    
+    def __init__(self, message: str, provider: str):
+        super().__init__(message, "general_error", provider)

todo_agent/core/todo_manager.py

@@ -19,7 +19,7 @@ class TodoManager:
         project: Optional[str] = None,
         context: Optional[str] = None,
         due: Optional[str] = None,
-        recurring: Optional[str] = None,
+        duration: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
         # Validate and sanitize inputs
@@ -55,32 +55,31 @@ class TodoManager:
                     f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
                 )
 
-        if recurring:
-            # Validate recurring format
-            if not recurring.startswith("rec:"):
-                raise ValueError(
-                    f"Invalid recurring format '{recurring}'. Must start with 'rec:'."
-                )
-            # Basic validation of recurring syntax
-            parts = recurring.split(":")
-            if len(parts) < 2 or len(parts) > 3:
+        if duration is not None:
+            # Validate duration format (e.g., "30m", "2h", "1d")
+            if not duration or not isinstance(duration, str):
+                raise ValueError("Duration must be a non-empty string.")
+
+            # Check if duration ends with a valid unit
+            if not any(duration.endswith(unit) for unit in ["m", "h", "d"]):
                 raise ValueError(
-                    f"Invalid recurring format '{recurring}'. Expected 'rec:frequency' or 'rec:frequency:interval'."
+                    f"Invalid duration format '{duration}'. Must end with m (minutes), h (hours), or d (days)."
                 )
-            frequency = parts[1]
-            if frequency not in ["daily", "weekly", "monthly", "yearly"]:
+
+            # Extract the numeric part and validate it
+            value = duration[:-1]
+            if not value:
+                raise ValueError("Duration value cannot be empty.")
+
+            try:
+                # Check if the value is a valid positive number
+                numeric_value = float(value)
+                if numeric_value <= 0:
+                    raise ValueError("Duration value must be positive.")
+            except ValueError:
                 raise ValueError(
-                    f"Invalid frequency '{frequency}'. Must be one of: daily, weekly, monthly, yearly."
+                    f"Invalid duration value '{value}'. Must be a positive number."
                 )
-            if len(parts) == 3:
-                try:
-                    interval = int(parts[2])
-                    if interval < 1:
-                        raise ValueError("Interval must be at least 1.")
-                except ValueError:
-                    raise ValueError(
-                        f"Invalid interval '{parts[2]}'. Must be a positive integer."
-                    )
 
         # Build the full task description with priority, project, and context
         full_description = description
@@ -97,8 +96,8 @@ class TodoManager:
         if due:
             full_description = f"{full_description} due:{due}"
 
-        if recurring:
-            full_description = f"{full_description} {recurring}"
+        if duration:
+            full_description = f"{full_description} duration:{duration}"
 
         self.todo_shell.add(full_description)
         return f"Added task: {full_description}"
@@ -118,24 +117,6 @@ class TodoManager:
         result = self.todo_shell.complete(task_number)
         return f"Completed task {task_number}: {result}"
 
-    def get_overview(self, **kwargs: Any) -> str:
-        """Show current task statistics."""
-        tasks = self.todo_shell.list_tasks()
-        completed = self.todo_shell.list_completed()
-
-        task_count = (
-            len([line for line in tasks.split("\n") if line.strip()])
-            if tasks.strip()
-            else 0
-        )
-        completed_count = (
-            len([line for line in completed.split("\n") if line.strip()])
-            if completed.strip()
-            else 0
-        )
-
-        return f"Task Overview:\n- Active tasks: {task_count}\n- Completed tasks: {completed_count}"
-
     def replace_task(self, task_number: int, new_description: str) -> str:
         """Replace entire task content."""
         result = self.todo_shell.replace(task_number, new_description)
@@ -373,4 +354,121 @@ class TodoManager:
     def get_current_datetime(self, **kwargs: Any) -> str:
         """Get the current date and time."""
         now = datetime.now()
-        return f"Current date and time: {now.strftime('%Y-%m-%d %H:%M:%S')} ({now.strftime('%A, %B %d, %Y at %I:%M %p')})"
+        week_number = now.isocalendar()[1]
+        timezone = now.astimezone().tzinfo
+        return f"Current date and time: {now.strftime('%Y-%m-%d %H:%M:%S')} {timezone} ({now.strftime('%A, %B %d, %Y at %I:%M %p')}) - Week {week_number}"
+
+    def created_completed_task(
+        self,
+        description: str,
+        completion_date: Optional[str] = None,
+        project: Optional[str] = None,
+        context: Optional[str] = None,
+    ) -> str:
+        """
+        Create a task and immediately mark it as completed.
+
+        This is a convenience method for handling "I did X on [date]" statements.
+        The task is created with the specified completion date and immediately marked complete.
+
+        Args:
+            description: The task description of what was completed
+            completion_date: Completion date in YYYY-MM-DD format (defaults to today)
+            project: Optional project name (without the + symbol)
+            context: Optional context name (without the @ symbol)
+
+        Returns:
+            Confirmation message with the completed task details
+        """
+        # Set default completion date to today if not provided
+        if not completion_date:
+            completion_date = datetime.now().strftime("%Y-%m-%d")
+
+        # Validate completion date format
+        try:
+            datetime.strptime(completion_date, "%Y-%m-%d")
+        except ValueError:
+            raise ValueError(
+                f"Invalid completion date format '{completion_date}'. Must be YYYY-MM-DD."
+            )
+
+        # Build the task description with project and context
+        full_description = description
+
+        if project:
+            # Remove any existing + symbols to prevent duplication
+            clean_project = project.strip().lstrip("+")
+            if not clean_project:
+                raise ValueError(
+                    "Project name cannot be empty after removing + symbol."
+                )
+            full_description = f"{full_description} +{clean_project}"
+
+        if context:
+            # Remove any existing @ symbols to prevent duplication
+            clean_context = context.strip().lstrip("@")
+            if not clean_context:
+                raise ValueError(
+                    "Context name cannot be empty after removing @ symbol."
+                )
+            full_description = f"{full_description} @{clean_context}"
+
+        # Add the task first
+        self.todo_shell.add(full_description)
+
+        # Get the task number by finding the newly added task
+        tasks = self.todo_shell.list_tasks()
+        task_lines = [line.strip() for line in tasks.split("\n") if line.strip()]
+        if not task_lines:
+            raise RuntimeError("Failed to add task - no tasks found after addition")
+
+        # Find the task that matches our description (it should be the last one added)
+        # Look for the task that contains our description
+        task_number = None
+        for i, line in enumerate(task_lines, 1):  # Start from 1 for todo.sh numbering
+            if description in line:
+                task_number = i
+                break
+
+        if task_number is None:
+            # Fallback: use the last task number if we can't find a match
+            task_number = len(task_lines)
+            # Log a warning that we're using fallback logic
+            import logging
+
+            logging.warning(
+                f"Could not find exact match for '{description}', using fallback task number {task_number}"
+            )
+
+        # Mark it as complete
+        self.todo_shell.complete(task_number)
+
+        return f"Created and completed task: {full_description} (completed on {completion_date})"
+
+    def restore_completed_task(self, task_number: int) -> str:
+        """
+        Restore a completed task from done.txt back to todo.txt.
+
+        This method moves a completed task from done.txt back to todo.txt,
+        effectively restoring it to active status.
+
+        Args:
+            task_number: The line number of the completed task in done.txt to restore
+
+        Returns:
+            Confirmation message with the restored task details
+        """
+        # Validate task number
+        if task_number <= 0:
+            raise ValueError("Task number must be a positive integer")
+
+        # Use the move command to restore the task from done.txt to todo.txt
+        result = self.todo_shell.move(task_number, "todo.txt", "done.txt")
+        
+        # Extract the task description from the result for confirmation
+        # The result format is typically: "TODO: X moved from '.../done.txt' to '.../todo.txt'."
+        if "moved from" in result and "to" in result:
+            # Try to extract the task description if possible
+            return f"Restored completed task {task_number} to active status: {result}"
+        else:
+            return f"Restored completed task {task_number} to active status"

todo_agent/infrastructure/calendar_utils.py

@@ -15,10 +15,8 @@ def get_calendar_output() -> str:
         Formatted calendar string showing three months side by side
     """
     try:
-        # Use cal -3 to get three months side by side
-        result = subprocess.run(
-            ["cal", "-3"], capture_output=True, text=True, check=True
-        )
+        # Use cal to get current month calendar
+        result = subprocess.run(["cal"], capture_output=True, text=True, check=True)
         return result.stdout.strip()
     except (subprocess.SubprocessError, FileNotFoundError):
         # Fallback to Python calendar module

todo_agent/infrastructure/inference.py

@@ -4,6 +4,7 @@ LLM inference engine for todo.sh agent.
 
 import os
 import time
+from datetime import datetime
 from typing import Any, Dict, Optional
 
 try:
@@ -12,6 +13,7 @@ try:
     from todo_agent.infrastructure.llm_client_factory import LLMClientFactory
     from todo_agent.infrastructure.logger import Logger
     from todo_agent.interface.tools import ToolCallHandler
+    from todo_agent.interface.progress import ToolCallProgress, NoOpProgress
 except ImportError:
     from core.conversation_manager import (  # type: ignore[no-redef]
         ConversationManager,
@@ -23,6 +25,7 @@ except ImportError:
     )
     from infrastructure.logger import Logger  # type: ignore[no-redef]
     from interface.tools import ToolCallHandler  # type: ignore[no-redef]
+    from interface.progress import ToolCallProgress, NoOpProgress  # type: ignore[no-redef]
 
 
 class Inference:
@@ -67,13 +70,10 @@ class Inference:
 
     def _load_system_prompt(self) -> str:
         """Load and format the system prompt from file."""
-        # Generate tools section programmatically
-        tools_section = self._generate_tools_section()
-
         # Get current datetime for interpolation
-        from datetime import datetime
-
-        current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        now = datetime.now()
+        timezone_info = time.tzname[time.daylight]
+        current_datetime = f"{now.strftime('%Y-%m-%d %H:%M:%S')} {timezone_info}"
 
         # Get calendar output
         from .calendar_utils import get_calendar_output
@@ -93,9 +93,8 @@ class Inference:
             with open(prompt_file_path, encoding="utf-8") as f:
                 system_prompt_template = f.read()
 
-            # Format the template with the tools section, current datetime, and calendar
+            # Format the template with current datetime and calendar
             return system_prompt_template.format(
-                tools_section=tools_section,
                 current_datetime=current_datetime,
                 calendar_output=calendar_output,
             )
@@ -107,64 +106,28 @@ class Inference:
             self.logger.error(f"Error loading system prompt: {e!s}")
             raise
 
-    def _generate_tools_section(self) -> str:
-        """Generate the AVAILABLE TOOLS section with strategic categorization."""
-        tool_categories = {
-            "Discovery Tools": [
-                "list_projects",
-                "list_contexts",
-                "list_tasks",
-                "list_completed_tasks",
-            ],
-            "Modification Tools": [
-                "add_task",
-                "complete_task",
-                "replace_task",
-                "append_to_task",
-                "prepend_to_task",
-            ],
-            "Management Tools": [
-                "delete_task",
-                "set_priority",
-                "remove_priority",
-                "move_task",
-            ],
-            "Maintenance Tools": ["archive_tasks", "deduplicate_tasks", "get_overview"],
-        }
-
-        tools_section = []
-        for category, tool_names in tool_categories.items():
-            tools_section.append(f"\n**{category}:**")
-            for tool_name in tool_names:
-                tool_info = next(
-                    (
-                        t
-                        for t in self.tool_handler.tools
-                        if t["function"]["name"] == tool_name
-                    ),
-                    None,
-                )
-                if tool_info:
-                    # Get first sentence of description for concise overview
-                    first_sentence = (
-                        tool_info["function"]["description"].split(".")[0] + "."
-                    )
-                    tools_section.append(f"- {tool_name}(): {first_sentence}")
 
-        return "\n".join(tools_section)
 
-    def process_request(self, user_input: str) -> tuple[str, float]:
+    def process_request(self, user_input: str, progress_callback: Optional[ToolCallProgress] = None) -> tuple[str, float]:
         """
         Process a user request through the LLM with tool orchestration.
 
         Args:
             user_input: Natural language user request
+            progress_callback: Optional progress callback for tool call tracking
 
         Returns:
             Tuple of (formatted response for user, thinking time in seconds)
         """
         # Start timing the request
         start_time = time.time()
+        
+        # Initialize progress callback if not provided
+        if progress_callback is None:
+            progress_callback = NoOpProgress()
+        
+        # Notify progress callback that thinking has started
+        progress_callback.on_thinking_start()
 
         try:
             self.logger.debug(
@@ -187,6 +150,30 @@ class Inference:
                 messages=messages, tools=self.tool_handler.tools
             )
 
+            # Check for provider errors
+            if response.get("error", False):
+                error_type = response.get("error_type", "general_error")
+                provider = response.get("provider", "unknown")
+                self.logger.error(f"Provider error from {provider}: {error_type}")
+                
+                # Import here to avoid circular imports
+                try:
+                    from todo_agent.interface.formatters import get_provider_error_message
+                    error_message = get_provider_error_message(error_type)
+                except ImportError:
+                    from interface.formatters import get_provider_error_message
+                    error_message = get_provider_error_message(error_type)
+                
+                # Add error message to conversation
+                self.conversation_manager.add_message(MessageRole.ASSISTANT, error_message)
+                
+                # Calculate thinking time and return
+                end_time = time.time()
+                thinking_time = end_time - start_time
+                progress_callback.on_thinking_complete(thinking_time)
+                
+                return error_message, thinking_time
+
             # Extract actual token usage from API response
             usage = response.get("usage", {})
             actual_prompt_tokens = usage.get("prompt_tokens", 0)
@@ -201,6 +188,8 @@ class Inference:
 
             # Handle multiple tool calls in sequence
             tool_call_count = 0
+            total_sequences = 0  # We'll track this as we go
+            
             while True:
                 tool_calls = self.llm_client.extract_tool_calls(response)
 
@@ -211,6 +200,9 @@ class Inference:
                 self.logger.debug(
                     f"Executing tool call sequence #{tool_call_count} with {len(tool_calls)} tools"
                 )
+                
+                # Notify progress callback of sequence start
+                progress_callback.on_sequence_complete(tool_call_count, 0)  # We don't know total yet
 
                 # Execute all tool calls and collect results
                 tool_results = []
@@ -224,6 +216,14 @@ class Inference:
                     self.logger.debug(f"Tool Call ID: {tool_call_id}")
                     self.logger.debug(f"Raw tool call: {tool_call}")
 
+                    # Get progress description for the tool
+                    progress_description = self._get_tool_progress_description(tool_name)
+                    
+                    # Notify progress callback of tool call start
+                    progress_callback.on_tool_call_start(
+                        tool_name, progress_description, tool_call_count, 0  # We don't know total yet
+                    )
+                    
                     result = self.tool_handler.execute_tool(tool_call)
 
                     # Log tool execution result (success or error)
@@ -249,6 +249,30 @@ class Inference:
                     messages=messages, tools=self.tool_handler.tools
                 )
 
+                # Check for provider errors in continuation
+                if response.get("error", False):
+                    error_type = response.get("error_type", "general_error")
+                    provider = response.get("provider", "unknown")
+                    self.logger.error(f"Provider error in continuation from {provider}: {error_type}")
+                    
+                    # Import here to avoid circular imports
+                    try:
+                        from todo_agent.interface.formatters import get_provider_error_message
+                        error_message = get_provider_error_message(error_type)
+                    except ImportError:
+                        from interface.formatters import get_provider_error_message
+                        error_message = get_provider_error_message(error_type)
+                    
+                    # Add error message to conversation
+                    self.conversation_manager.add_message(MessageRole.ASSISTANT, error_message)
+                    
+                    # Calculate thinking time and return
+                    end_time = time.time()
+                    thinking_time = end_time - start_time
+                    progress_callback.on_thinking_complete(thinking_time)
+                    
+                    return error_message, thinking_time
+
                 # Update with actual tokens from subsequent API calls
                 usage = response.get("usage", {})
                 actual_prompt_tokens = usage.get("prompt_tokens", 0)
@@ -260,6 +284,9 @@ class Inference:
             # Calculate and log total thinking time
             end_time = time.time()
             thinking_time = end_time - start_time
+            
+            # Notify progress callback that thinking is complete
+            progress_callback.on_thinking_complete(thinking_time)
 
             # Add final assistant response to conversation with thinking time
             final_content = self.llm_client.extract_content(response)
@@ -294,6 +321,25 @@ class Inference:
             self.tool_handler.tools
         )
 
+    def _get_tool_progress_description(self, tool_name: str) -> str:
+        """
+        Get user-friendly progress description for a tool.
+        
+        Args:
+            tool_name: Name of the tool
+            
+        Returns:
+            Progress description string
+        """
+        tool_def = next((t for t in self.tool_handler.tools 
+                         if t.get("function", {}).get("name") == tool_name), None)
+        
+        if tool_def and "progress_description" in tool_def:
+            return tool_def["progress_description"]
+        
+        # Fallback to generic description
+        return f"🔧 Executing {tool_name}..."
+
     def clear_conversation(self) -> None:
         """Clear conversation history."""
         self.conversation_manager.clear_conversation()