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

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

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

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

@@ -15,7 +15,7 @@ class TestConversationManager:
         manager = ConversationManager()
         assert len(manager.history) == 0
         assert manager.max_tokens == 64000
-        assert manager.max_messages == 50
+        assert manager.max_messages == 100
         assert manager.system_prompt is None
 
     def test_add_message(self):

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

@@ -212,7 +212,7 @@ class TestTodoManager(unittest.TestCase):
         self.todo_shell.list_tasks.return_value = "1. Task 1\n2. Task 2"
         result = self.todo_manager.list_tasks()
         self.assertEqual(result, "1. Task 1\n2. Task 2")
-        self.todo_shell.list_tasks.assert_called_once_with(None)
+        self.todo_shell.list_tasks.assert_called_once_with(None, suppress_color=True)
 
     def test_complete_task(self):
         """Test completing a task."""
@@ -228,28 +228,36 @@ class TestTodoManager(unittest.TestCase):
         )
         result = self.todo_manager.list_completed_tasks()
         self.assertEqual(result, "1. Completed task 1\n2. Completed task 2")
-        self.todo_shell.list_completed.assert_called_once_with(None)
+        self.todo_shell.list_completed.assert_called_once_with(
+            None, suppress_color=True
+        )
 
     def test_list_completed_tasks_with_project_filter(self):
         """Test listing completed tasks with project filter."""
         self.todo_shell.list_completed.return_value = "1. Work task completed"
         result = self.todo_manager.list_completed_tasks(project="work")
         self.assertEqual(result, "1. Work task completed")
-        self.todo_shell.list_completed.assert_called_once_with("+work")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+work", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_context_filter(self):
         """Test listing completed tasks with context filter."""
         self.todo_shell.list_completed.return_value = "1. Office task completed"
         result = self.todo_manager.list_completed_tasks(context="office")
         self.assertEqual(result, "1. Office task completed")
-        self.todo_shell.list_completed.assert_called_once_with("@office")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "@office", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_text_search(self):
         """Test listing completed tasks with text search."""
         self.todo_shell.list_completed.return_value = "1. Review task completed"
         result = self.todo_manager.list_completed_tasks(text_search="review")
         self.assertEqual(result, "1. Review task completed")
-        self.todo_shell.list_completed.assert_called_once_with("review")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "review", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_filters(self):
         """Test listing completed tasks with date filters."""
@@ -259,14 +267,18 @@ class TestTodoManager(unittest.TestCase):
         )
         self.assertEqual(result, "1. Task completed in date range")
         # With both date_from and date_to, we use the year-month pattern from date_from
-        self.todo_shell.list_completed.assert_called_once_with("2025-08")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_from_only(self):
         """Test listing completed tasks with only date_from filter."""
         self.todo_shell.list_completed.return_value = "1. Task completed from date"
         result = self.todo_manager.list_completed_tasks(date_from="2025-08-01")
         self.assertEqual(result, "1. Task completed from date")
-        self.todo_shell.list_completed.assert_called_once_with("2025-08-01")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08-01", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_to_only(self):
         """Test listing completed tasks with only date_to filter."""
@@ -274,7 +286,9 @@ class TestTodoManager(unittest.TestCase):
         result = self.todo_manager.list_completed_tasks(date_to="2025-08-31")
         self.assertEqual(result, "1. Task completed in month")
         # With only date_to, we use the year-month pattern
-        self.todo_shell.list_completed.assert_called_once_with("2025-08")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_multiple_filters(self):
         """Test listing completed tasks with multiple filters."""
@@ -285,21 +299,27 @@ class TestTodoManager(unittest.TestCase):
             project="work", context="office", text_search="review"
         )
         self.assertEqual(result, "1. Work task from office completed")
-        self.todo_shell.list_completed.assert_called_once_with("+work @office review")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+work @office review", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_raw_filter(self):
         """Test listing completed tasks with raw filter string."""
         self.todo_shell.list_completed.return_value = "1. Custom filtered task"
         result = self.todo_manager.list_completed_tasks(filter="+urgent @home")
         self.assertEqual(result, "1. Custom filtered task")
-        self.todo_shell.list_completed.assert_called_once_with("+urgent @home")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+urgent @home", suppress_color=True
+        )
 
     def test_list_completed_tasks_no_results(self):
         """Test listing completed tasks when no results found."""
         self.todo_shell.list_completed.return_value = ""
         result = self.todo_manager.list_completed_tasks(project="nonexistent")
         self.assertEqual(result, "No completed tasks found matching the criteria.")
-        self.todo_shell.list_completed.assert_called_once_with("+nonexistent")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+nonexistent", suppress_color=True
+        )
 
     def test_add_task_sanitizes_inputs(self):
         """Test that add_task sanitizes inputs to prevent duplicates."""
@@ -557,14 +577,14 @@ class TestTodoManager(unittest.TestCase):
             self.assertIn("2025-01-15 10:30:00", result)
             self.assertIn("Week 3", result)
 
-    def test_created_completed_task_basic(self):
+    def test_create_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")
+        result = self.todo_manager.create_completed_task("Test task")
 
         # Verify the task was added
         self.todo_shell.add.assert_called_once_with("Test task")
@@ -573,13 +593,13 @@ class TestTodoManager(unittest.TestCase):
         # Verify the result message
         self.assertIn("Created and completed task: Test task", result)
 
-    def test_created_completed_task_with_project_and_context(self):
+    def test_create_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(
+        result = self.todo_manager.create_completed_task(
             "Test task", project="work", context="office"
         )
 
@@ -589,35 +609,38 @@ class TestTodoManager(unittest.TestCase):
         self.todo_shell.complete.assert_called_once_with(1)
         self.assertIn("+work @office", result)
 
-    def test_created_completed_task_with_custom_date(self):
+    def test_create_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"
+        self.todo_shell.addto.return_value = "Task added to done.txt"
 
-        result = self.todo_manager.created_completed_task(
+        result = self.todo_manager.create_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)
+        # Verify the task was added directly to done.txt with the custom date
+        self.todo_shell.addto.assert_called_once_with(
+            "done.txt", "x 2025-01-10 Test task"
+        )
+        # Verify add and complete were NOT called when using custom date
+        self.todo_shell.add.assert_not_called()
+        self.todo_shell.complete.assert_not_called()
         self.assertIn("completed on 2025-01-10", result)
 
-    def test_created_completed_task_with_invalid_date(self):
+    def test_create_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(
+            self.todo_manager.create_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):
+    def test_create_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(
+        result = self.todo_manager.create_completed_task(
             "Test task", project="+work", context="@office"
         )
 
@@ -625,25 +648,25 @@ class TestTodoManager(unittest.TestCase):
         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):
+    def test_create_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.todo_manager.create_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):
+    def test_create_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.todo_manager.create_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):
+    def test_create_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.todo_manager.create_completed_task("Test task")
         self.assertIn("Failed to add task", str(context.exception))
 
 

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

@@ -104,7 +104,9 @@ 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}\nCALENDAR: {calendar_output}"
+        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

{todo_agent-0.3.2 → todo_agent-0.3.5}/tests/test_infrastructure/test_ollama_client.py

@@ -22,9 +22,7 @@ class TestOllamaClient:
         self.config.ollama_model = "llama3.2"
 
         # Patch the dependencies that are now initialized in the parent class
-        with patch(
-            "todo_agent.infrastructure.llm_client.Logger"
-        ) as mock_logger, patch(
+        with patch("todo_agent.infrastructure.llm_client.Logger") as mock_logger, patch(
             "todo_agent.infrastructure.llm_client.get_token_counter"
         ) as mock_token_counter:
             mock_logger.return_value = Mock()
@@ -61,7 +59,7 @@ class TestOllamaClient:
         """Test request payload generation."""
         messages = [{"role": "user", "content": "Hello"}]
         tools = [{"name": "test_tool", "description": "A test tool"}]
-        
+
         payload = self.client._get_request_payload(messages, tools)
         expected = {
             "model": "llama3.2",
@@ -102,7 +100,7 @@ class TestOllamaClient:
             "error_type": "general_error",
             "provider": "ollama",
             "status_code": 500,
-            "raw_error": "Internal Server Error"
+            "raw_error": "Internal Server Error",
         }
         mock_make_request.return_value = error_response
 
@@ -144,11 +142,7 @@ class TestOllamaClient:
 
     def test_extract_tool_calls_with_error_response(self):
         """Test extracting tool calls from error response."""
-        error_response = {
-            "error": True,
-            "error_type": "timeout",
-            "provider": "ollama"
-        }
+        error_response = {"error": True, "error_type": "timeout", "provider": "ollama"}
 
         tool_calls = self.client.extract_tool_calls(error_response)
         assert len(tool_calls) == 0
@@ -166,9 +160,7 @@ class TestOllamaClient:
 
     def test_extract_content_without_content(self):
         """Test extracting content from response without content."""
-        response = {
-            "message": {}
-        }
+        response = {"message": {}}
 
         content = self.client.extract_content(response)
         assert content == ""
@@ -182,11 +174,7 @@ class TestOllamaClient:
 
     def test_extract_content_with_error_response(self):
         """Test extracting content from error response."""
-        error_response = {
-            "error": True,
-            "error_type": "timeout",
-            "provider": "ollama"
-        }
+        error_response = {"error": True, "error_type": "timeout", "provider": "ollama"}
 
         content = self.client.extract_content(error_response)
         assert content == ""
@@ -196,16 +184,15 @@ class TestOllamaClient:
         response_data = {
             "message": {
                 "content": "Hello",
-                "tool_calls": [
-                    {"id": "call_1", "function": {"name": "test_tool"}}
-                ]
+                "tool_calls": [{"id": "call_1", "function": {"name": "test_tool"}}],
             }
         }
 
-        with patch.object(self.client.logger, "info") as mock_info, \
-             patch.object(self.client.logger, "debug") as mock_debug:
+        with patch.object(self.client.logger, "info") as mock_info, patch.object(
+            self.client.logger, "debug"
+        ) as mock_debug:
             self.client._process_response(response_data, 0.0)
-            
+
             # Should log response details
             assert mock_info.call_count >= 1
             assert mock_debug.call_count >= 1

{todo_agent-0.3.2 → todo_agent-0.3.5}/tests/test_infrastructure/test_openrouter_client.py

@@ -21,9 +21,7 @@ class TestOpenRouterClient:
     def setup_method(self):
         """Set up test fixtures."""
         # Patch the dependencies that are now initialized in the parent class
-        with patch(
-            "todo_agent.infrastructure.llm_client.Logger"
-        ) as mock_logger, patch(
+        with patch("todo_agent.infrastructure.llm_client.Logger") as mock_logger, patch(
             "todo_agent.infrastructure.llm_client.get_token_counter"
         ) as mock_token_counter:
             mock_logger.return_value = Mock()
@@ -62,7 +60,7 @@ class TestOpenRouterClient:
         """Test request payload generation."""
         messages = [{"role": "user", "content": "Hello"}]
         tools = [{"name": "test_tool", "description": "A test tool"}]
-        
+
         payload = self.client._get_request_payload(messages, tools)
         expected = {
             "model": "test-model",
@@ -77,7 +75,9 @@ class TestOpenRouterClient:
         endpoint = self.client._get_api_endpoint()
         assert endpoint == "https://openrouter.ai/api/v1/chat/completions"
 
-    @patch("todo_agent.infrastructure.openrouter_client.OpenRouterClient._make_http_request")
+    @patch(
+        "todo_agent.infrastructure.openrouter_client.OpenRouterClient._make_http_request"
+    )
     def test_chat_with_tools_success(self, mock_make_request):
         """Test successful chat with tools."""
         messages = [{"role": "user", "content": "Hello"}]
@@ -104,7 +104,9 @@ class TestOpenRouterClient:
         assert result == expected_response
         mock_make_request.assert_called_once_with(messages, tools)
 
-    @patch("todo_agent.infrastructure.openrouter_client.OpenRouterClient._make_http_request")
+    @patch(
+        "todo_agent.infrastructure.openrouter_client.OpenRouterClient._make_http_request"
+    )
     def test_chat_with_tools_api_error(self, mock_make_request):
         """Test API error handling."""
         messages = [{"role": "user", "content": "Hello"}]
@@ -115,7 +117,7 @@ class TestOpenRouterClient:
             "error_type": "auth_error",
             "provider": "openrouter",
             "status_code": 401,
-            "raw_error": "Unauthorized"
+            "raw_error": "Unauthorized",
         }
         mock_make_request.return_value = error_response
 
@@ -179,7 +181,7 @@ class TestOpenRouterClient:
         error_response = {
             "error": True,
             "error_type": "timeout",
-            "provider": "openrouter"
+            "provider": "openrouter",
         }
 
         tool_calls = self.client.extract_tool_calls(error_response)
@@ -202,13 +204,7 @@ class TestOpenRouterClient:
 
     def test_extract_content_no_content(self):
         """Test extracting content from response without content."""
-        response = {
-            "choices": [
-                {
-                    "message": {}
-                }
-            ]
-        }
+        response = {"choices": [{"message": {}}]}
 
         content = self.client.extract_content(response)
         assert content == ""
@@ -232,7 +228,7 @@ class TestOpenRouterClient:
         error_response = {
             "error": True,
             "error_type": "timeout",
-            "provider": "openrouter"
+            "provider": "openrouter",
         }
 
         content = self.client.extract_content(error_response)
@@ -253,21 +249,18 @@ class TestOpenRouterClient:
                         "content": "Hello",
                         "tool_calls": [
                             {"id": "call_1", "function": {"name": "test_tool"}}
-                        ]
+                        ],
                     }
                 }
             ],
-            "usage": {
-                "prompt_tokens": 10,
-                "completion_tokens": 5,
-                "total_tokens": 15
-            }
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
         }
 
-        with patch.object(self.client.logger, "info") as mock_info, \
-             patch.object(self.client.logger, "debug") as mock_debug:
+        with patch.object(self.client.logger, "info") as mock_info, patch.object(
+            self.client.logger, "debug"
+        ) as mock_debug:
             self.client._process_response(response_data, 0.0)
-            
+
             # Should log response details
             assert mock_info.call_count >= 2  # Latency and token usage
             assert mock_debug.call_count >= 1  # Raw response

{todo_agent-0.3.2 → todo_agent-0.3.5}/tests/test_infrastructure/test_todo_shell.py

@@ -100,7 +100,7 @@ class TestTodoShell:
             result = self.todo_shell.list_tasks()
 
             # Verify the correct command was used
-            mock_execute.assert_called_once_with(["todo.sh", "ls"])
+            mock_execute.assert_called_once_with(["todo.sh", "ls"], suppress_color=True)
             assert result == "1. Task 1\n2. Task 2"
 
     def test_list_tasks_with_filter_appends_filter_to_command(self):
@@ -111,7 +111,9 @@ class TestTodoShell:
             result = self.todo_shell.list_tasks("+work")
 
             # Verify filter was appended to command
-            mock_execute.assert_called_once_with(["todo.sh", "ls", "+work"])
+            mock_execute.assert_called_once_with(
+                ["todo.sh", "ls", "+work"], suppress_color=True
+            )
             assert result == "1. Work task"
 
     def test_complete_task_uses_do_command_with_task_number(self):
@@ -500,7 +502,9 @@ class TestTodoShell:
             result = self.todo_shell.list_projects()
 
             # Verify lsp command
-            mock_execute.assert_called_once_with(["todo.sh", "lsp"])
+            mock_execute.assert_called_once_with(
+                ["todo.sh", "lsp"], suppress_color=True
+            )
             assert result == "+work\n+home\n+shopping"
 
     def test_list_contexts_uses_lsc_command(self):
@@ -511,7 +515,9 @@ class TestTodoShell:
             result = self.todo_shell.list_contexts()
 
             # Verify lsc command
-            mock_execute.assert_called_once_with(["todo.sh", "lsc"])
+            mock_execute.assert_called_once_with(
+                ["todo.sh", "lsc"], suppress_color=True
+            )
             assert result == "@work\n@home\n@shopping"
 
     def test_list_completed_uses_listfile_command(self):
@@ -522,7 +528,9 @@ class TestTodoShell:
             result = self.todo_shell.list_completed()
 
             # Verify listfile command with done.txt
-            mock_execute.assert_called_once_with(["todo.sh", "listfile", "done.txt"])
+            mock_execute.assert_called_once_with(
+                ["todo.sh", "listfile", "done.txt"], suppress_color=True
+            )
             assert result == "1. Completed task"
 
     def test_list_completed_with_filter_appends_filter(self):
@@ -534,7 +542,7 @@ class TestTodoShell:
 
             # Verify filter was appended to command
             mock_execute.assert_called_once_with(
-                ["todo.sh", "listfile", "done.txt", "+work"]
+                ["todo.sh", "listfile", "done.txt", "+work"], suppress_color=True
             )
             assert result == "1. Work task completed"
 
@@ -584,6 +592,41 @@ class TestTodoShell:
             ):
                 self.todo_shell.execute(["todo.sh", "add", "test"])
 
+    def test_execute_suppresses_color_codes_when_requested(self):
+        """Test that execute method strips ANSI color codes when suppress_color=True."""
+        # Mock subprocess to return output with ANSI color codes
+        mock_result = type(
+            "MockResult",
+            (),
+            {
+                "stdout": "\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",
+                "stderr": "",
+                "returncode": 0,
+            },
+        )()
+
+        with patch("subprocess.run", return_value=mock_result):
+            # Test with suppress_color=True (default for LLM consumption)
+            result = self.todo_shell.execute(["todo.sh", "ls"], suppress_color=True)
+
+            # Should return clean text without ANSI codes
+            assert (
+                result == "1 (A) 2025-08-29 Clean cat box @home +chores due:2025-08-29"
+            )
+            assert "\033[" not in result  # No ANSI escape sequences
+
+            # Test with suppress_color=False (for interactive display)
+            result_with_color = self.todo_shell.execute(
+                ["todo.sh", "ls"], suppress_color=False
+            )
+
+            # Should preserve ANSI codes
+            assert "\033[" in result_with_color  # ANSI escape sequences preserved
+            assert (
+                result_with_color
+                == "\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"
+            )
+
     def test_set_project_adds_projects_to_task_without_projects(self):
         """Test that set_project adds projects to task that doesn't have any."""
         # Mock the list_tasks to return a task without projects

{todo_agent-0.3.2 → todo_agent-0.3.5}/tests/test_interface/test_cli.py

@@ -141,7 +141,9 @@ class TestCLI:
         # Verify inference engine was called with correct input and progress callback
         call_args = self.cli.inference.process_request.call_args
         assert call_args[0][0] == user_input  # First argument should be user_input
-        assert call_args[0][1] is not None  # Second argument should be progress callback
+        assert (
+            call_args[0][1] is not None
+        )  # Second argument should be progress callback
 
     def test_handle_request_exception_handling(self):
         """Test that exceptions in handle_request are properly caught and formatted."""
@@ -159,7 +161,9 @@ class TestCLI:
         # Verify inference engine was called with progress callback
         call_args = self.cli.inference.process_request.call_args
         assert call_args[0][0] == user_input  # First argument should be user_input
-        assert call_args[0][1] is not None  # Second argument should be progress callback
+        assert (
+            call_args[0][1] is not None
+        )  # Second argument should be progress callback
 
     def test_run_single_request_delegates_to_handle_request(self):
         """Test that run_single_request properly delegates to handle_request."""
@@ -382,7 +386,9 @@ class TestCLI:
         # Should still call inference engine (let it handle empty input)
         call_args = self.cli.inference.process_request.call_args
         assert call_args[0][0] == ""  # First argument should be empty string
-        assert call_args[0][1] is not None  # Second argument should be progress callback
+        assert (
+            call_args[0][1] is not None
+        )  # Second argument should be progress callback
 
     def test_long_input_truncation_in_logging(self):
         """Test that long inputs are properly truncated in logging."""
@@ -396,7 +402,9 @@ class TestCLI:
         # Verify inference engine was called with full input and progress callback
         call_args = self.cli.inference.process_request.call_args
         assert call_args[0][0] == long_input  # First argument should be long_input
-        assert call_args[0][1] is not None  # Second argument should be progress callback
+        assert (
+            call_args[0][1] is not None
+        )  # Second argument should be progress callback
 
         # Verify response is correct
         assert result == "Response"

{todo_agent-0.3.2 → todo_agent-0.3.5}/tests/test_interface/test_tools.py

@@ -108,16 +108,16 @@ class TestToolErrorHandling:
         assert "Permission denied" in result["user_message"]
         assert "check file permissions" in result["user_message"]
 
-    def test_created_completed_task_tool_execution(self):
-        """Test that the created_completed_task tool can be executed successfully."""
+    def test_create_completed_task_tool_execution(self):
+        """Test that the create_completed_task tool can be executed successfully."""
         # Mock the todo_manager method
-        self.mock_todo_manager.created_completed_task.return_value = (
+        self.mock_todo_manager.create_completed_task.return_value = (
             "Created and completed task: Test task (completed on 2025-01-15)"
         )
 
         tool_call = {
             "function": {
-                "name": "created_completed_task",
+                "name": "create_completed_task",
                 "arguments": '{"description": "Test task", "completion_date": "2025-01-15"}',
             },
             "id": "test_id",
@@ -128,10 +128,10 @@ class TestToolErrorHandling:
         assert result["error"] is False
         assert "Created and completed task: Test task" in result["output"]
         assert result["tool_call_id"] == "test_id"
-        assert result["name"] == "created_completed_task"
+        assert result["name"] == "create_completed_task"
 
         # Verify the method was called with correct arguments
-        self.mock_todo_manager.created_completed_task.assert_called_once_with(
+        self.mock_todo_manager.create_completed_task.assert_called_once_with(
             description="Test task", completion_date="2025-01-15"
         )
 

{todo_agent-0.3.2 → todo_agent-0.3.5}/todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.3.5'
+__version_tuple__ = version_tuple = (0, 3, 5)
 
-__commit_id__ = commit_id = 'gaaa8652a7'
+__commit_id__ = commit_id = 'g698d691a3'