todo-agent 0.3.1__py3-none-any.whl → 0.3.3__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.3.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)
 
 __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,6 @@ 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."""
@@ -56,33 +55,6 @@ 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:
-                raise ValueError(
-                    f"Invalid recurring format '{recurring}'. Expected 'rec:frequency' or 'rec:frequency:interval'."
-                )
-            frequency = parts[1]
-            if frequency not in ["daily", "weekly", "monthly", "yearly"]:
-                raise ValueError(
-                    f"Invalid frequency '{frequency}'. Must be one of: daily, weekly, monthly, yearly."
-                )
-            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."
-                    )
-
         if duration is not None:
             # Validate duration format (e.g., "30m", "2h", "1d")
             if not duration or not isinstance(duration, str):
@@ -124,18 +96,17 @@ 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}"
 
-    def list_tasks(self, filter: Optional[str] = None) -> str:
+    def list_tasks(
+        self, filter: Optional[str] = None, suppress_color: bool = True
+    ) -> str:
         """List tasks with optional filtering."""
-        result = self.todo_shell.list_tasks(filter)
+        result = self.todo_shell.list_tasks(filter, suppress_color=suppress_color)
         if not result.strip():
             return "No tasks found."
 
@@ -148,24 +119,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)
@@ -307,16 +260,16 @@ class TodoManager:
                 operation_desc = ", ".join(operations)
                 return f"Updated projects for task {task_number} ({operation_desc}): {result}"
 
-    def list_projects(self, **kwargs: Any) -> str:
+    def list_projects(self, suppress_color: bool = True, **kwargs: Any) -> str:
         """List all available projects in todo.txt."""
-        result = self.todo_shell.list_projects()
+        result = self.todo_shell.list_projects(suppress_color=suppress_color)
         if not result.strip():
             return "No projects found."
         return result
 
-    def list_contexts(self, **kwargs: Any) -> str:
+    def list_contexts(self, suppress_color: bool = True, **kwargs: Any) -> str:
         """List all available contexts in todo.txt."""
-        result = self.todo_shell.list_contexts()
+        result = self.todo_shell.list_contexts(suppress_color=suppress_color)
         if not result.strip():
             return "No contexts found."
         return result
@@ -329,6 +282,7 @@ class TodoManager:
         text_search: Optional[str] = None,
         date_from: Optional[str] = None,
         date_to: Optional[str] = None,
+        suppress_color: bool = True,
         **kwargs: Any,
     ) -> str:
         """List completed tasks with optional filtering.
@@ -378,7 +332,9 @@ class TodoManager:
         # Combine all filters
         combined_filter = " ".join(filter_parts) if filter_parts else None
 
-        result = self.todo_shell.list_completed(combined_filter)
+        result = self.todo_shell.list_completed(
+            combined_filter, suppress_color=suppress_color
+        )
         if not result.strip():
             return "No completed tasks found matching the criteria."
         return result
@@ -406,3 +362,118 @@ class TodoManager:
         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

@@ -12,6 +12,10 @@ try:
     from todo_agent.infrastructure.config import Config
     from todo_agent.infrastructure.llm_client_factory import LLMClientFactory
     from todo_agent.infrastructure.logger import Logger
+    from todo_agent.interface.formatters import (
+        get_provider_error_message as _get_error_msg,
+    )
+    from todo_agent.interface.progress import NoOpProgress, ToolCallProgress
     from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
     from core.conversation_manager import (  # type: ignore[no-redef]
@@ -23,6 +27,13 @@ except ImportError:
         LLMClientFactory,
     )
     from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from interface.formatters import (  # type: ignore[no-redef]
+        get_provider_error_message as _get_error_msg,
+    )
+    from interface.progress import (  # type: ignore[no-redef]
+        NoOpProgress,
+        ToolCallProgress,
+    )
     from interface.tools import ToolCallHandler  # type: ignore[no-redef]
 
 
@@ -66,11 +77,29 @@ class Inference:
         self.conversation_manager.set_system_prompt(system_prompt)
         self.logger.debug("System prompt loaded and set")
 
+    def current_tasks(self) -> str:
+        """
+        Get current tasks from the todo manager.
+        
+        Returns:
+            Formatted string of current tasks or error message
+        """
+        try:
+            # Use the todo manager from the tool handler to get current tasks
+            tasks = self.tool_handler.todo_manager.list_tasks(suppress_color=True)
+            
+            # If no tasks found, return a clear message
+            if not tasks.strip() or tasks == "No tasks found.":
+                return "No current tasks found."
+                
+            return tasks
+            
+        except Exception as e:
+            self.logger.warning(f"Failed to get current tasks: {e!s}")
+            return f"Error retrieving current tasks: {e!s}"
+
     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
         now = datetime.now()
         timezone_info = time.tzname[time.daylight]
@@ -85,6 +114,9 @@ class Inference:
             self.logger.warning(f"Failed to get calendar output: {e!s}")
             calendar_output = "Calendar unavailable"
 
+        # Get current tasks
+        current_tasks = self.current_tasks()
+
         # Load system prompt from file
         prompt_file_path = os.path.join(
             os.path.dirname(__file__), "prompts", "system_prompt.txt"
@@ -94,11 +126,11 @@ 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, calendar, and current tasks
             return system_prompt_template.format(
-                tools_section=tools_section,
                 current_datetime=current_datetime,
                 calendar_output=calendar_output,
+                current_tasks=current_tasks,
             )
 
         except FileNotFoundError:
@@ -108,58 +140,15 @@ 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)
@@ -167,6 +156,13 @@ class Inference:
         # 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(
                 f"Starting request processing for: {user_input[:30]}{'...' if len(user_input) > 30 else ''}"
@@ -188,6 +184,26 @@ 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}")
+
+                error_message = _get_error_msg(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)
@@ -202,6 +218,7 @@ class Inference:
 
             # Handle multiple tool calls in sequence
             tool_call_count = 0
+
             while True:
                 tool_calls = self.llm_client.extract_tool_calls(response)
 
@@ -213,6 +230,11 @@ class Inference:
                     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 = []
                 for i, tool_call in enumerate(tool_calls):
@@ -225,6 +247,19 @@ 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, tool_call
+                    )
+
+                    # 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)
@@ -250,6 +285,28 @@ 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}"
+                    )
+
+                    error_message = _get_error_msg(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)
@@ -262,6 +319,9 @@ class Inference:
             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)
             self.conversation_manager.add_message(
@@ -295,6 +355,52 @@ class Inference:
             self.tool_handler.tools
         )
 
+    def _get_tool_progress_description(self, tool_name: str, tool_call: Dict[str, Any]) -> str:
+        """
+        Get user-friendly progress description for a tool with parameter interpolation.
+
+        Args:
+            tool_name: Name of the tool
+            tool_call: The tool call dictionary containing parameters
+
+        Returns:
+            Progress description string with interpolated parameters
+        """
+        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:
+            template = tool_def["progress_description"]
+            
+            # Extract arguments from tool call
+            arguments = tool_call.get("function", {}).get("arguments", {})
+            if isinstance(arguments, str):
+                import json
+                try:
+                    arguments = json.loads(arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+            
+            # Use .format() like the system prompt does
+            try:
+                return template.format(**arguments)
+            except KeyError as e:
+                # If a required parameter is missing, fall back to template
+                self.logger.warning(f"Missing parameter {e} for progress description of {tool_name}")
+                return template
+            except Exception as e:
+                self.logger.warning(f"Failed to interpolate progress description for {tool_name}: {e}")
+                return template
+
+        # Fallback to generic description
+        return f"🔧 Executing {tool_name}..."
+
     def clear_conversation(self) -> None:
         """Clear conversation history."""
         self.conversation_manager.clear_conversation()