todo-agent 0.2.4__tar.gz → 0.2.6__tar.gz

{todo_agent-0.2.4 → todo_agent-0.2.6}/PKG-INFO

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

{todo_agent-0.2.4 → todo_agent-0.2.6}/tests/test_core/test_todo_manager.py

@@ -32,6 +32,63 @@ class TestTodoManager(unittest.TestCase):
         self.assertEqual(result, "Added task: Test task")
         self.todo_shell.add.assert_called_once_with("Test task")
 
+    def test_add_task_with_invalid_priority(self):
+        """Test adding a task with invalid priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="invalid")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_with_invalid_priority_lowercase(self):
+        """Test adding a task with lowercase priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="a")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_with_invalid_priority_multiple_chars(self):
+        """Test adding a task with multiple character priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="AB")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_sanitizes_project_with_plus(self):
+        """Test that project with existing + symbol is properly sanitized."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", project="+work")
+        self.assertEqual(result, "Added task: Test task +work")
+        self.todo_shell.add.assert_called_once_with("Test task +work")
+
+    def test_add_task_sanitizes_context_with_at(self):
+        """Test that context with existing @ symbol is properly sanitized."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", context="@office")
+        self.assertEqual(result, "Added task: Test task @office")
+        self.todo_shell.add.assert_called_once_with("Test task @office")
+
+    def test_add_task_with_empty_project_after_sanitization(self):
+        """Test adding a task with empty project after removing + raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", project="+")
+        self.assertIn("Project name cannot be empty", str(context.exception))
+
+    def test_add_task_with_empty_context_after_sanitization(self):
+        """Test adding a task with empty context after removing @ raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", context="@")
+        self.assertIn("Context name cannot be empty", str(context.exception))
+
+    def test_add_task_with_invalid_due_date(self):
+        """Test adding a task with invalid due date format raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", due="invalid-date")
+        self.assertIn("Invalid due date format", str(context.exception))
+
+    def test_add_task_with_valid_due_date(self):
+        """Test adding a task with valid due date format."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", due="2024-01-15")
+        self.assertEqual(result, "Added task: Test task due:2024-01-15")
+        self.todo_shell.add.assert_called_once_with("Test task due:2024-01-15")
+
     def test_list_tasks(self):
         """Test listing tasks."""
         self.todo_shell.list_tasks.return_value = "1. Task 1\n2. Task 2"

todo_agent-0.2.6/tests/test_infrastructure/test_calendar_utils.py

@@ -0,0 +1,81 @@
+"""
+Tests for calendar utilities.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from todo_agent.infrastructure.calendar_utils import (
+    get_calendar_output,
+    get_current_month_calendar,
+)
+
+
+class TestCalendarUtils:
+    """Test calendar utility functions."""
+
+    def test_get_calendar_output_success(self):
+        """Test successful calendar output generation."""
+        mock_output = "Calendar output from cal -3"
+
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = mock_output
+            mock_run.return_value = mock_result
+
+            result = get_calendar_output()
+
+            assert result == mock_output
+            assert len(result) > 0
+            mock_run.assert_called_once_with(
+                ["cal", "-3"], capture_output=True, text=True, check=True
+            )
+
+    def test_get_calendar_output_fallback(self):
+        """Test calendar output fallback to Python calendar."""
+        with patch("subprocess.run", side_effect=FileNotFoundError("cal not found")):
+            result = get_calendar_output()
+
+            # Should return a string with calendar data
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    def test_get_current_month_calendar_success(self):
+        """Test successful current month calendar generation."""
+        mock_output = "Current month calendar"
+
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = mock_output
+            mock_run.return_value = mock_result
+
+            result = get_current_month_calendar()
+
+            assert result == mock_output
+            assert len(result) > 0
+            mock_run.assert_called_once_with(
+                ["cal"], capture_output=True, text=True, check=True
+            )
+
+    def test_get_current_month_calendar_fallback(self):
+        """Test current month calendar fallback to Python calendar."""
+        with patch("subprocess.run", side_effect=FileNotFoundError("cal not found")):
+            result = get_current_month_calendar()
+
+            # Should return a string with calendar data
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    def test_calendar_output_contains_expected_content(self):
+        """Test that calendar output contains expected content."""
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = "Calendar with July August September 2025"
+            mock_run.return_value = mock_result
+
+            result = get_calendar_output()
+
+            # Should contain some calendar content
+            assert len(result) > 0
+            assert isinstance(result, str)

{todo_agent-0.2.4 → todo_agent-0.2.6}/tests/test_interface/test_cli.py

@@ -295,6 +295,49 @@ class TestCLI:
                 f"Error: Failed to list tasks: {error_message}"
             )
 
+    def test_done_command_success(self):
+        """Test successful done command execution."""
+        expected_output = (
+            "x 2025-08-29 2025-08-28 Buy groceries\nx 2025-08-28 2025-08-27 Call mom"
+        )
+
+        # Mock the todo_shell.list_completed method
+        self.cli.todo_shell.list_completed.return_value = expected_output
+
+        with patch("builtins.print") as mock_print:
+            # Simulate the done command logic
+            try:
+                output = self.cli.todo_shell.list_completed()
+                print(output)
+            except Exception as e:
+                print(f"Error: Failed to list completed tasks: {e!s}")
+
+            # Verify todo_shell.list_completed was called
+            self.cli.todo_shell.list_completed.assert_called_once()
+
+            # Verify print was called with the expected output
+            mock_print.assert_called_once_with(expected_output)
+
+    def test_done_command_exception_handling(self):
+        """Test done command handles exceptions properly."""
+        error_message = "Database connection failed"
+
+        # Mock exception in todo_shell.list_completed
+        self.cli.todo_shell.list_completed.side_effect = Exception(error_message)
+
+        with patch("builtins.print") as mock_print:
+            # Simulate the done command logic with error
+            try:
+                output = self.cli.todo_shell.list_completed()
+                print(output)
+            except Exception as e:
+                print(f"Error: Failed to list completed tasks: {e!s}")
+
+            # Verify error was handled and formatted correctly
+            mock_print.assert_called_once_with(
+                f"Error: Failed to list completed tasks: {error_message}"
+            )
+
     def test_help_command_displays_available_commands(self):
         """Test that help command displays all available commands."""
         with patch("builtins.print") as mock_print:
@@ -304,6 +347,7 @@ class TestCLI:
             print("  history  - Show conversation statistics")
             print("  help     - Show this help message")
             print("  list     - List all tasks (no LLM interaction)")
+            print("  done     - List completed tasks (no LLM interaction)")
             print("  quit     - Exit the application")
             print("  Or just type your request naturally!")
 
@@ -314,6 +358,7 @@ class TestCLI:
                 "  history  - Show conversation statistics",
                 "  help     - Show this help message",
                 "  list     - List all tasks (no LLM interaction)",
+                "  done     - List completed tasks (no LLM interaction)",
                 "  quit     - Exit the application",
                 "  Or just type your request naturally!",
             ]

todo_agent-0.2.6/tests/test_interface/test_formatters.py

@@ -0,0 +1,75 @@
+"""
+Tests for formatters module.
+"""
+
+import pytest
+from rich.text import Text
+
+from todo_agent.interface.formatters import TaskFormatter
+
+
+class TestTaskFormatter:
+    """Test TaskFormatter functionality."""
+
+    def test_format_task_list_preserves_ansi_codes(self):
+        """Test that format_task_list preserves ANSI color codes."""
+        # Sample output with ANSI color codes (simulating todo.sh output)
+        raw_tasks = "\033[1;33m1\033[0m (A) \033[1;32m2025-08-29\033[0m Clean cat box \033[1;34m@home\033[0m \033[1;35m+chores\033[0m \033[1;31mdue:2025-08-29\033[0m"
+        
+        result = TaskFormatter.format_task_list(raw_tasks)
+        
+        # The result should be a Rich Text object
+        assert isinstance(result, Text)
+        
+        # Check that the Rich Text object contains the original ANSI codes
+        # We can check this by looking at the raw text content
+        result_str = result.plain
+        assert "1" in result_str  # Task number should be present
+        assert "(A)" in result_str  # Priority should be present
+        assert "2025-08-29" in result_str  # Date should be present
+        assert "@home" in result_str  # Context should be present
+        assert "+chores" in result_str  # Project should be present
+        assert "due:2025-08-29" in result_str  # Due date should be present
+
+    def test_format_completed_tasks_preserves_ansi_codes(self):
+        """Test that format_completed_tasks preserves ANSI color codes."""
+        # Sample completed task output with ANSI color codes
+        raw_tasks = "\033[1;32mx\033[0m \033[1;32m2025-08-29\033[0m \033[1;32m2025-08-28\033[0m Clean cat box \033[1;34m@home\033[0m \033[1;35m+chores\033[0m"
+        
+        result = TaskFormatter.format_completed_tasks(raw_tasks)
+        
+        # The result should be a Rich Text object
+        assert isinstance(result, Text)
+        
+        # Check that the Rich Text object contains the original content
+        # We can check this by looking at the raw text content
+        result_str = result.plain
+        assert "x" in result_str  # Completion marker should be present
+        assert "2025-08-29" in result_str  # Completion date should be present
+        assert "2025-08-28" in result_str  # Creation date should be present
+        assert "@home" in result_str  # Context should be present
+        assert "+chores" in result_str  # Project should be present
+
+    def test_format_task_list_handles_empty_input(self):
+        """Test that format_task_list handles empty input gracefully."""
+        result = TaskFormatter.format_task_list("")
+        assert isinstance(result, Text)
+        assert "No tasks found" in str(result)
+
+    def test_format_completed_tasks_handles_empty_input(self):
+        """Test that format_completed_tasks handles empty input gracefully."""
+        result = TaskFormatter.format_completed_tasks("")
+        assert isinstance(result, Text)
+        assert "No completed tasks found" in str(result)
+
+    def test_format_task_list_handles_whitespace_only(self):
+        """Test that format_task_list handles whitespace-only input."""
+        result = TaskFormatter.format_task_list("   \n  \t  ")
+        assert isinstance(result, Text)
+        assert "No tasks found" in str(result)
+
+    def test_format_completed_tasks_handles_whitespace_only(self):
+        """Test that format_completed_tasks handles whitespace-only input."""
+        result = TaskFormatter.format_completed_tasks("   \n  \t  ")
+        assert isinstance(result, Text)
+        assert "No completed tasks found" in str(result)

{todo_agent-0.2.4 → todo_agent-0.2.6}/tests/test_interface/test_tools.py

@@ -178,3 +178,62 @@ class TestToolErrorHandling:
 
         assert result["error"] is False
         assert result["output"] == "1. Test task"
+
+
+class TestCalendarTool:
+    """Test calendar tool functionality."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.mock_todo_manager = Mock(spec=TodoManager)
+        self.mock_logger = Mock()
+        self.tool_handler = ToolCallHandler(self.mock_todo_manager, self.mock_logger)
+
+    @patch("subprocess.run")
+    def test_get_calendar_success(self, mock_run):
+        """Test successful calendar retrieval using system cal command."""
+        # Mock the subprocess.run to return a calendar
+        mock_run.return_value.stdout = "   January 2025\nSu Mo Tu We Th Fr Sa\n          1  2  3  4\n 5  6  7  8  9 10 11\n12 13 14 15 16 17 18\n19 20 21 22 23 24 25\n26 27 28 29 30 31\n"
+        mock_run.return_value.returncode = 0
+
+        tool_call = {
+            "function": {
+                "name": "get_calendar",
+                "arguments": '{"month": 1, "year": 2025}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert "January 2025" in result["output"]
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "get_calendar"
+
+        # Verify subprocess.run was called with correct arguments
+        mock_run.assert_called_once_with(
+            ["cal", "1", "2025"], capture_output=True, text=True, check=True
+        )
+
+    @patch("subprocess.run")
+    def test_get_calendar_fallback_to_python(self, mock_run):
+        """Test calendar fallback to Python calendar module when cal command fails."""
+        # Mock subprocess.run to raise FileNotFoundError
+        mock_run.side_effect = FileNotFoundError("cal command not found")
+
+        tool_call = {
+            "function": {
+                "name": "get_calendar",
+                "arguments": '{"month": 1, "year": 2025}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert "January" in result["output"]
+        assert "2025" in result["output"]
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "get_calendar"

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)
 
-__commit_id__ = commit_id = 'gc2b1a1313'
+__commit_id__ = commit_id = 'g670ed96a8'

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/core/todo_manager.py

@@ -21,6 +21,39 @@ class TodoManager:
         due: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
+        # Validate and sanitize inputs
+        if priority and not (
+            len(priority) == 1 and priority.isalpha() and priority.isupper()
+        ):
+            raise ValueError(
+                f"Invalid priority '{priority}'. Must be a single uppercase letter (A-Z)."
+            )
+
+        if project:
+            # Remove any existing + symbols to prevent duplication
+            project = project.strip().lstrip("+")
+            if not project:
+                raise ValueError(
+                    "Project name cannot be empty after removing + symbol."
+                )
+
+        if context:
+            # Remove any existing @ symbols to prevent duplication
+            context = context.strip().lstrip("@")
+            if not context:
+                raise ValueError(
+                    "Context name cannot be empty after removing @ symbol."
+                )
+
+        if due:
+            # Basic date format validation
+            try:
+                datetime.strptime(due, "%Y-%m-%d")
+            except ValueError:
+                raise ValueError(
+                    f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
+                )
+
         # Build the full task description with priority, project, and context
         full_description = description
 

todo_agent-0.2.6/todo_agent/infrastructure/calendar_utils.py

@@ -0,0 +1,64 @@
+"""
+Calendar utilities for generating calendar output in system prompts.
+"""
+
+import calendar
+import subprocess
+from datetime import datetime, timedelta
+
+
+def get_calendar_output() -> str:
+    """
+    Generate calendar output for previous, current, and next month.
+
+    Returns:
+        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
+        )
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar module
+        return _get_python_cal_output()
+
+
+def _get_python_cal_output() -> str:
+    """
+    Generate calendar output using Python calendar module as fallback.
+
+    Returns:
+        Calendar output formatted similar to cal command
+    """
+    current_date = datetime.now()
+
+    # Calculate previous, current, and next month
+    prev_month = current_date - timedelta(days=current_date.day)
+    next_month = current_date.replace(day=1) + timedelta(days=32)
+    next_month = next_month.replace(day=1)
+
+    calendars = []
+
+    for date in [prev_month, current_date, next_month]:
+        cal = calendar.month(date.year, date.month)
+        calendars.append(cal.strip())
+
+    return "\n\n".join(calendars)
+
+
+def get_current_month_calendar() -> str:
+    """
+    Get calendar for current month only.
+
+    Returns:
+        Calendar output for current month
+    """
+    try:
+        result = subprocess.run(["cal"], capture_output=True, text=True, check=True)
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar
+        current_date = datetime.now()
+        return calendar.month(current_date.year, current_date.month).strip()

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/infrastructure/inference.py

@@ -75,6 +75,15 @@ class Inference:
 
         current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
+        # Get calendar output
+        from .calendar_utils import get_calendar_output
+
+        try:
+            calendar_output = get_calendar_output()
+        except Exception as e:
+            self.logger.warning(f"Failed to get calendar output: {e!s}")
+            calendar_output = "Calendar unavailable"
+
         # Load system prompt from file
         prompt_file_path = os.path.join(
             os.path.dirname(__file__), "prompts", "system_prompt.txt"
@@ -84,9 +93,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 and current datetime
+            # Format the template with the tools section, current datetime, and calendar
             return system_prompt_template.format(
-                tools_section=tools_section, current_datetime=current_datetime
+                tools_section=tools_section,
+                current_datetime=current_datetime,
+                calendar_output=calendar_output,
             )
 
         except FileNotFoundError:

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/infrastructure/llm_client_factory.py

@@ -2,6 +2,8 @@
 Factory for creating LLM clients based on configuration.
 """
 
+# mypy: disable-error-code="no-redef"
+
 from typing import Optional
 
 try:
@@ -15,8 +17,8 @@ except ImportError:
     from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
     from infrastructure.logger import Logger  # type: ignore[no-redef]
     from infrastructure.ollama_client import OllamaClient  # type: ignore[no-redef]
-    from infrastructure.openrouter_client import (  # type: ignore[no-redef]
-        OpenRouterClient,
+    from infrastructure.openrouter_client import (
+        OpenRouterClient,  # type: ignore[no-redef, misc]
     )
 
 

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/infrastructure/ollama_client.py

@@ -72,6 +72,12 @@ class OllamaClient(LLMClient):
         if "message" in response and "tool_calls" in response["message"]:
             tool_calls = response["message"]["tool_calls"]
             self.logger.info(f"Response contains {len(tool_calls)} tool calls")
+            
+            # Log thinking content (response body) if present
+            content = response["message"].get("content", "")
+            if content and content.strip():
+                self.logger.info(f"LLM thinking before tool calls: {content}")
+            
             for i, tool_call in enumerate(tool_calls):
                 tool_name = tool_call.get("function", {}).get("name", "unknown")
                 self.logger.info(f"  Tool call {i + 1}: {tool_name}")

{todo_agent-0.2.4 → todo_agent-0.2.6}/todo_agent/infrastructure/openrouter_client.py

@@ -78,6 +78,12 @@ class OpenRouterClient(LLMClient):
             if "message" in choice and "tool_calls" in choice["message"]:
                 tool_calls = choice["message"]["tool_calls"]
                 self.logger.info(f"Response contains {len(tool_calls)} tool calls")
+                
+                # Log thinking content (response body) if present
+                content = choice["message"].get("content", "")
+                if content and content.strip():
+                    self.logger.info(f"LLM thinking before tool calls: {content}")
+                
                 for i, tool_call in enumerate(tool_calls):
                     tool_name = tool_call.get("function", {}).get("name", "unknown")
                     self.logger.info(f"  Tool call {i + 1}: {tool_name}")