todo-agent 0.2.9__tar.gz → 0.3.2__tar.gz

{todo_agent-0.2.9 → todo_agent-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.2.9
+Version: 0.3.2
 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"
 ```

{todo_agent-0.2.9 → todo_agent-0.3.2}/README.md

@@ -21,7 +21,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).
 
@@ -116,7 +116,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"
 ```

{todo_agent-0.2.9 → todo_agent-0.3.2}/tests/test_core/test_conversation_manager.py

@@ -14,7 +14,7 @@ class TestConversationManager:
         """Test ConversationManager initialization."""
         manager = ConversationManager()
         assert len(manager.history) == 0
-        assert manager.max_tokens == 32000
+        assert manager.max_tokens == 64000
         assert manager.max_messages == 50
         assert manager.system_prompt is None
 

{todo_agent-0.2.9 → todo_agent-0.3.2}/tests/test_core/test_todo_manager.py

@@ -3,10 +3,9 @@ Tests for TodoManager.
 """
 
 import unittest
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 import pytest
-from unittest.mock import patch
 
 try:
     from todo_agent.core.todo_manager import TodoManager
@@ -149,46 +148,48 @@ class TestTodoManager(unittest.TestCase):
             self.todo_manager.set_due_date(1, "2025/1/5")
         self.assertIn("Invalid due date format", str(context.exception))
 
-    def test_add_task_with_valid_recurring_daily(self):
-        """Test adding a task with valid daily recurring format."""
-        self.todo_shell.add.return_value = "Test task"
-        result = self.todo_manager.add_task("Test task", recurring="rec:daily")
-        self.assertEqual(result, "Added task: Test task rec:daily")
-        self.todo_shell.add.assert_called_once_with("Test task rec:daily")
-
-    def test_add_task_with_valid_recurring_weekly_interval(self):
-        """Test adding a task with valid weekly recurring format with interval."""
-        self.todo_shell.add.return_value = "Test task"
-        result = self.todo_manager.add_task("Test task", recurring="rec:weekly:2")
-        self.assertEqual(result, "Added task: Test task rec:weekly:2")
-        self.todo_shell.add.assert_called_once_with("Test task rec:weekly:2")
+    def test_add_task_with_invalid_duration_format(self):
+        """Test adding a task with invalid duration format raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", duration="30s")
+        self.assertIn("Invalid duration format", str(context.exception))
 
-    def test_add_task_with_invalid_recurring_format(self):
-        """Test adding a task with invalid recurring format raises ValueError."""
+    def test_add_task_with_invalid_duration_unit(self):
+        """Test adding a task with invalid duration unit raises ValueError."""
         with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="invalid")
-        self.assertIn("Invalid recurring format", str(context.exception))
+            self.todo_manager.add_task("Test task", duration="30s")
+        self.assertIn("Invalid duration format", str(context.exception))
 
-    def test_add_task_with_invalid_recurring_frequency(self):
-        """Test adding a task with invalid recurring frequency raises ValueError."""
+    def test_add_task_with_invalid_duration_value(self):
+        """Test adding a task with invalid duration value raises ValueError."""
         with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:invalid")
-        self.assertIn("Invalid frequency", str(context.exception))
+            self.todo_manager.add_task("Test task", duration="0m")
+        self.assertIn("Must be a positive number", str(context.exception))
 
-    def test_add_task_with_invalid_recurring_interval(self):
-        """Test adding a task with invalid recurring interval raises ValueError."""
+    def test_add_task_with_negative_duration(self):
+        """Test adding a task with negative duration raises ValueError."""
         with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:weekly:invalid")
-        self.assertIn("Invalid interval", str(context.exception))
+            self.todo_manager.add_task("Test task", duration="-30m")
+        self.assertIn("Must be a positive number", str(context.exception))
 
-    def test_add_task_with_zero_recurring_interval(self):
-        """Test adding a task with zero recurring interval raises ValueError."""
+    def test_add_task_with_empty_duration(self):
+        """Test adding a task with empty duration raises ValueError."""
         with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:weekly:0")
-        self.assertIn("Must be a positive integer", str(context.exception))
+            self.todo_manager.add_task("Test task", duration="")
+        self.assertIn("Duration must be a non-empty string", str(context.exception))
+
+    def test_add_task_with_duration(self):
+        """Test adding a task with duration parameter."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task(
+            "Test task",
+            duration="30m",
+        )
+        self.assertEqual(result, "Added task: Test task duration:30m")
+        self.todo_shell.add.assert_called_once_with("Test task duration:30m")
 
-    def test_add_task_with_all_parameters_including_recurring(self):
-        """Test adding a task with all parameters including recurring."""
+    def test_add_task_with_all_parameters_including_duration(self):
+        """Test adding a task with all parameters including duration."""
         self.todo_shell.add.return_value = "Test task"
         result = self.todo_manager.add_task(
             "Test task",
@@ -196,13 +197,14 @@ class TestTodoManager(unittest.TestCase):
             project="work",
             context="office",
             due="2024-01-15",
-            recurring="rec:daily",
+            duration="2h",
         )
         self.assertEqual(
-            result, "Added task: (A) Test task +work @office due:2024-01-15 rec:daily"
+            result,
+            "Added task: (A) Test task +work @office due:2024-01-15 duration:2h",
         )
         self.todo_shell.add.assert_called_once_with(
-            "(A) Test task +work @office due:2024-01-15 rec:daily"
+            "(A) Test task +work @office due:2024-01-15 duration:2h"
         )
 
     def test_list_tasks(self):
@@ -299,60 +301,62 @@ class TestTodoManager(unittest.TestCase):
         self.assertEqual(result, "No completed tasks found matching the criteria.")
         self.todo_shell.list_completed.assert_called_once_with("+nonexistent")
 
-
-
     def test_add_task_sanitizes_inputs(self):
         """Test that add_task sanitizes inputs to prevent duplicates."""
         # Mock the todo_shell
         mock_shell = Mock()
         mock_shell.add.return_value = "1 Test task +project1 @context1"
-        
+
         manager = TodoManager(mock_shell)
-        
+
         # Test with inputs that already have + and @ symbols
         result = manager.add_task(
             description="Test task",
             project="+project1",  # Already has + symbol
-            context="@context1"   # Already has @ symbol
+            context="@context1",  # Already has @ symbol
         )
-        
+
         # Verify the task was added with properly formatted projects and contexts
         mock_shell.add.assert_called_once()
         call_args = mock_shell.add.call_args[0][0]
-        
+
         # Should have exactly one instance of each (sanitization prevents duplicates)
         assert call_args.count("+project1") == 1
         assert call_args.count("@context1") == 1
-        
+
         # Verify the result message
         assert "Added task:" in result
 
-
-
     def test_parse_task_components_deduplicates(self):
         """Test that _parse_task_components deduplicates projects and contexts."""
         from todo_agent.infrastructure.todo_shell import TodoShell
-        
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Test with duplicate projects and contexts in the task line
         task_line = "1 (A) Task description +project1 +project1 +project2 @context1 @context1 @context2"
         components = shell._parse_task_components(task_line)
-        
+
         # Verify deduplication
-        assert components["projects"] == ["+project1", "+project2"]  # Sorted and deduplicated
-        assert components["contexts"] == ["@context1", "@context2"]  # Sorted and deduplicated
+        assert components["projects"] == [
+            "+project1",
+            "+project2",
+        ]  # Sorted and deduplicated
+        assert components["contexts"] == [
+            "@context1",
+            "@context2",
+        ]  # Sorted and deduplicated
         assert components["priority"] == "A"
         assert components["description"] == "Task description"
 
     def test_reconstruct_task_maintains_deduplication(self):
         """Test that _reconstruct_task maintains deduplication."""
         from todo_agent.infrastructure.todo_shell import TodoShell
-        
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Create components with potential duplicates
         components = {
             "priority": "A",
@@ -360,13 +364,12 @@ class TestTodoManager(unittest.TestCase):
             "projects": ["+project1", "+project1", "+project2"],  # Duplicate project1
             "contexts": ["@context1", "@context1", "@context2"],  # Duplicate context1
             "due": "2024-01-01",
-            "recurring": None,
-            "other_tags": []
+            "other_tags": [],
         }
-        
+
         # Reconstruct the task
         reconstructed = shell._reconstruct_task(components)
-        
+
         # Verify that duplicates are preserved in reconstruction (since we handle deduplication in parsing)
         # This is expected behavior - reconstruction should preserve the exact components given
         assert reconstructed.count("+project1") == 2
@@ -376,83 +379,96 @@ class TestTodoManager(unittest.TestCase):
 
     def test_todo_shell_set_project_actually_prevents_duplicates(self):
         """Test that the todo_shell set_project method actually prevents duplicates."""
-        from todo_agent.infrastructure.todo_shell import TodoShell
         from unittest.mock import patch
-        
+
+        from todo_agent.infrastructure.todo_shell import TodoShell
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Mock the list_tasks method to return a task with existing projects
-        with patch.object(shell, 'list_tasks') as mock_list_tasks:
-            mock_list_tasks.return_value = "1 (A) Existing task +existing_project @existing_context"
-            
+        with patch.object(shell, "list_tasks") as mock_list_tasks:
+            mock_list_tasks.return_value = (
+                "1 (A) Existing task +existing_project @existing_context"
+            )
+
             # Mock the replace method to capture what gets called
-            with patch.object(shell, 'replace') as mock_replace:
-                mock_replace.return_value = "1 (A) Existing task +existing_project @existing_context"
-                
+            with patch.object(shell, "replace") as mock_replace:
+                mock_replace.return_value = (
+                    "1 (A) Existing task +existing_project @existing_context"
+                )
+
                 # Try to add a project that already exists
                 result = shell.set_project(1, ["existing_project"])
-                
+
                 # Since the project already exists, replace should NOT be called
                 # (our deduplication logic prevents unnecessary updates)
                 mock_replace.assert_not_called()
-                
+
                 # The result should be the reconstructed task without duplicates
                 assert "+existing_project" in result
                 assert result.count("+existing_project") == 1  # Only one instance
 
     def test_todo_shell_set_context_actually_prevents_duplicates(self):
         """Test that the todo_shell set_context method actually prevents duplicates."""
-        from todo_agent.infrastructure.todo_shell import TodoShell
         from unittest.mock import patch
-        
+
+        from todo_agent.infrastructure.todo_shell import TodoShell
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Mock the list_tasks method to return a task with existing context
-        with patch.object(shell, 'list_tasks') as mock_list_tasks:
-            mock_list_tasks.return_value = "1 (A) Existing task +existing_project @existing_context"
-            
+        with patch.object(shell, "list_tasks") as mock_list_tasks:
+            mock_list_tasks.return_value = (
+                "1 (A) Existing task +existing_project @existing_context"
+            )
+
             # Mock the replace method to capture what gets called
-            with patch.object(shell, 'replace') as mock_replace:
-                mock_replace.return_value = "1 (A) Existing task +existing_project @existing_context"
-                
+            with patch.object(shell, "replace") as mock_replace:
+                mock_replace.return_value = (
+                    "1 (A) Existing task +existing_project @existing_context"
+                )
+
                 # Try to set a context that already exists
                 result = shell.set_context(1, "existing_context")
-                
+
                 # Since the context already exists, replace should NOT be called
                 # (our deduplication logic prevents unnecessary updates)
                 mock_replace.assert_not_called()
-                
+
                 # The result should be the reconstructed task without duplicates
                 assert "@existing_context" in result
                 assert result.count("@existing_context") == 1  # Only one instance
 
     def test_todo_shell_set_project_adds_new_projects(self):
         """Test that the todo_shell set_project method adds new projects and prevents duplicates."""
-        from todo_agent.infrastructure.todo_shell import TodoShell
         from unittest.mock import patch
-        
+
+        from todo_agent.infrastructure.todo_shell import TodoShell
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Mock the list_tasks method to return a task with existing projects
-        with patch.object(shell, 'list_tasks') as mock_list_tasks:
-            mock_list_tasks.return_value = "1 (A) Existing task +existing_project @existing_context"
-            
+        with patch.object(shell, "list_tasks") as mock_list_tasks:
+            mock_list_tasks.return_value = (
+                "1 (A) Existing task +existing_project @existing_context"
+            )
+
             # Mock the replace method to capture what gets called
-            with patch.object(shell, 'replace') as mock_replace:
+            with patch.object(shell, "replace") as mock_replace:
                 mock_replace.return_value = "1 (A) Existing task +existing_project +new_project @existing_context"
-                
+
                 # Try to add a new project
-                result = shell.set_project(1, ["new_project"])
-                
+                shell.set_project(1, ["new_project"])
+
                 # Since we're adding a new project, replace should be called
                 mock_replace.assert_called_once()
-                
+
                 # Get the actual task description that was passed to replace
                 actual_task_description = mock_replace.call_args[0][1]
-                
+
                 # Verify that the new project was added and no duplicates exist
                 assert "+new_project" in actual_task_description
                 assert actual_task_description.count("+existing_project") == 1
@@ -460,62 +476,176 @@ class TestTodoManager(unittest.TestCase):
 
     def test_todo_shell_set_context_adds_new_contexts(self):
         """Test that the todo_shell set_context method adds new contexts and prevents duplicates."""
-        from todo_agent.infrastructure.todo_shell import TodoShell
         from unittest.mock import patch
-        
+
+        from todo_agent.infrastructure.todo_shell import TodoShell
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Mock the list_tasks method to return a task with existing context
-        with patch.object(shell, 'list_tasks') as mock_list_tasks:
-            mock_list_tasks.return_value = "1 (A) Existing task +existing_project @existing_context"
-            
+        with patch.object(shell, "list_tasks") as mock_list_tasks:
+            mock_list_tasks.return_value = (
+                "1 (A) Existing task +existing_project @existing_context"
+            )
+
             # Mock the replace method to capture what gets called
-            with patch.object(shell, 'replace') as mock_replace:
-                mock_replace.return_value = "1 (A) Existing task +existing_project @new_context"
-                
+            with patch.object(shell, "replace") as mock_replace:
+                mock_replace.return_value = (
+                    "1 (A) Existing task +existing_project @new_context"
+                )
+
                 # Try to set a new context
-                result = shell.set_context(1, "new_context")
-                
+                shell.set_context(1, "new_context")
+
                 # Since we're adding a new context, replace should be called
                 mock_replace.assert_called_once()
-                
+
                 # Get the actual task description that was passed to replace
                 actual_task_description = mock_replace.call_args[0][1]
-                
+
                 # Verify that the new context was added and the old context was replaced
                 # (set_context replaces all contexts with the new one)
                 assert "@new_context" in actual_task_description
-                assert "@existing_context" not in actual_task_description  # Old context replaced
-                assert actual_task_description.count("@new_context") == 1  # Only one instance
+                assert (
+                    "@existing_context" not in actual_task_description
+                )  # Old context replaced
+                assert (
+                    actual_task_description.count("@new_context") == 1
+                )  # Only one instance
 
     def test_parse_task_components_actually_deduplicates(self):
         """Test that _parse_task_components actually removes duplicates from input."""
         from todo_agent.infrastructure.todo_shell import TodoShell
-        
+
         # Create a TodoShell instance
         shell = TodoShell("/tmp/todo.txt")
-        
+
         # Test with a task line that has multiple duplicates
         task_line = "1 (A) Task description +project1 +project1 +project1 +project2 @context1 @context1 @context2"
         components = shell._parse_task_components(task_line)
-        
+
         # Verify that duplicates were actually removed
         assert len(components["projects"]) == 2  # Should only have 2 unique projects
         assert len(components["contexts"]) == 2  # Should only have 2 unique contexts
-        
+
         # Verify the specific projects and contexts
         assert "+project1" in components["projects"]
         assert "+project2" in components["projects"]
         assert "@context1" in components["contexts"]
         assert "@context2" in components["contexts"]
-        
+
         # Verify no duplicates exist in the lists
         assert components["projects"].count("+project1") == 1
         assert components["projects"].count("+project2") == 1
         assert components["contexts"].count("@context1") == 1
         assert components["contexts"].count("@context2") == 1
 
+    def test_get_current_datetime(self):
+        """Test getting current date and time."""
+        with patch("todo_agent.core.todo_manager.datetime") as mock_datetime:
+            mock_now = Mock()
+            mock_now.strftime.side_effect = lambda fmt: {
+                "%Y-%m-%d %H:%M:%S": "2025-01-15 10:30:00",
+                "%A, %B %d, %Y at %I:%M %p": "Wednesday, January 15, 2025 at 10:30 AM",
+            }[fmt]
+            mock_now.isocalendar.return_value = (2025, 3, 3)
+            mock_now.astimezone.return_value.tzinfo = Mock()
+            mock_datetime.now.return_value = mock_now
+
+            result = self.todo_manager.get_current_datetime()
+            self.assertIn("2025-01-15 10:30:00", result)
+            self.assertIn("Week 3", result)
+
+    def test_created_completed_task_basic(self):
+        """Test creating and immediately completing a task."""
+        # Mock the todo_shell methods
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task\n2 Another task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task("Test task")
+
+        # Verify the task was added
+        self.todo_shell.add.assert_called_once_with("Test task")
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        # Verify the result message
+        self.assertIn("Created and completed task: Test task", result)
+
+    def test_created_completed_task_with_project_and_context(self):
+        """Test creating and completing a task with project and context."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task\n2 Another task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", project="work", context="office"
+        )
+
+        # Verify the task was added with project and context
+        self.todo_shell.add.assert_called_once_with("Test task +work @office")
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        self.assertIn("+work @office", result)
+
+    def test_created_completed_task_with_custom_date(self):
+        """Test creating and completing a task with a custom completion date."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", completion_date="2025-01-10"
+        )
+
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        self.assertIn("completed on 2025-01-10", result)
+
+    def test_created_completed_task_with_invalid_date(self):
+        """Test that invalid completion date raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task(
+                "Test task", completion_date="invalid-date"
+            )
+        self.assertIn("Invalid completion date format", str(context.exception))
+
+    def test_created_completed_task_sanitizes_project_and_context(self):
+        """Test that project and context with existing symbols are properly sanitized."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", project="+work", context="@office"
+        )
+
+        # Verify the task was added with properly sanitized project and context
+        self.todo_shell.add.assert_called_once_with("Test task +work @office")
+        self.assertIn("+work @office", result)
+
+    def test_created_completed_task_with_empty_project_after_sanitization(self):
+        """Test that empty project after sanitization raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task("Test task", project="+")
+        self.assertIn("Project name cannot be empty", str(context.exception))
+
+    def test_created_completed_task_with_empty_context_after_sanitization(self):
+        """Test that empty context after sanitization raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task("Test task", context="@")
+        self.assertIn("Context name cannot be empty", str(context.exception))
+
+    def test_created_completed_task_no_tasks_after_addition(self):
+        """Test that RuntimeError is raised when no tasks are found after addition."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = ""  # No tasks found
+
+        with self.assertRaises(RuntimeError) as context:
+            self.todo_manager.created_completed_task("Test task")
+        self.assertIn("Failed to add task", str(context.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

{todo_agent-0.2.9 → todo_agent-0.3.2}/tests/test_infrastructure/test_calendar_utils.py

@@ -17,7 +17,7 @@ class TestCalendarUtils:
 
     def test_get_calendar_output_success(self):
         """Test successful calendar output generation."""
-        mock_output = "Calendar output from cal -3"
+        mock_output = "Calendar output from cal"
 
         with patch("subprocess.run") as mock_run:
             mock_result = Mock()
@@ -29,7 +29,7 @@ class TestCalendarUtils:
             assert result == mock_output
             assert len(result) > 0
             mock_run.assert_called_once_with(
-                ["cal", "-3"], capture_output=True, text=True, check=True
+                ["cal"], capture_output=True, text=True, check=True
             )
 
     def test_get_calendar_output_fallback(self):

{todo_agent-0.2.9 → todo_agent-0.3.2}/tests/test_infrastructure/test_inference.py

@@ -104,7 +104,7 @@ class TestInference:
     def test_system_prompt_datetime_interpolation(self):
         """Test that current datetime is properly interpolated into system prompt."""
         # Mock the file reading
-        mock_prompt_content = "CURRENT DATE/TIME: {current_datetime}\n{tools_section}"
+        mock_prompt_content = "CURRENT DATE/TIME: {current_datetime}\nCALENDAR: {calendar_output}"
 
         with patch("builtins.open", mock_open(read_data=mock_prompt_content)):
             # Call the method that loads the system prompt
@@ -122,9 +122,9 @@ class TestInference:
                 "System prompt should contain properly formatted datetime"
             )
 
-            # Verify that tools_section is also interpolated
-            assert "{tools_section}" not in result
-            assert "list_tasks" in result  # Should contain tool information
+            # Verify that calendar_output is also interpolated
+            assert "{calendar_output}" not in result
+            assert "September" in result  # Should contain calendar month information
 
     def test_process_request_with_tool_calls(self):
         """Test request processing with tool calls."""