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

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

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

{todo_agent-0.2.6 → todo_agent-0.2.8}/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 == 16000
+        assert manager.max_tokens == 32000
         assert manager.max_messages == 50
         assert manager.system_prompt is None
 

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

@@ -89,6 +89,58 @@ class TestTodoManager(unittest.TestCase):
         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_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_recurring_format(self):
+        """Test adding a task with invalid recurring format 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))
+
+    def test_add_task_with_invalid_recurring_frequency(self):
+        """Test adding a task with invalid recurring frequency 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))
+
+    def test_add_task_with_invalid_recurring_interval(self):
+        """Test adding a task with invalid recurring interval 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))
+
+    def test_add_task_with_zero_recurring_interval(self):
+        """Test adding a task with zero recurring interval 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))
+
+    def test_add_task_with_all_parameters_including_recurring(self):
+        """Test adding a task with all parameters including recurring."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task(
+            "Test task", 
+            priority="A", 
+            project="work", 
+            context="office", 
+            due="2024-01-15",
+            recurring="rec:daily"
+        )
+        self.assertEqual(result, "Added task: (A) Test task +work @office due:2024-01-15 rec:daily")
+        self.todo_shell.add.assert_called_once_with("(A) Test task +work @office due:2024-01-15 rec:daily")
+
     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 → todo_agent-0.2.8}/tests/test_interface/test_formatters.py

@@ -15,12 +15,12 @@ class TestTaskFormatter:
         """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
@@ -35,12 +35,12 @@ class TestTaskFormatter:
         """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

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

@@ -237,3 +237,70 @@ class TestCalendarTool:
         assert "2025" in result["output"]
         assert result["tool_call_id"] == "test_id"
         assert result["name"] == "get_calendar"
+
+
+class TestParseDateTool:
+    """Test parse_date 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)
+
+    def test_parse_date_next_weekday(self):
+        """Test parsing 'next thursday'."""
+        tool_call = {
+            "function": {
+                "name": "parse_date",
+                "arguments": '{"date_expression": "next thursday"}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "parse_date"
+        # Should return a valid YYYY-MM-DD format
+        assert len(result["output"]) == 10
+        assert result["output"].count("-") == 2
+
+    def test_parse_date_tomorrow(self):
+        """Test parsing 'tomorrow'."""
+        tool_call = {
+            "function": {
+                "name": "parse_date",
+                "arguments": '{"date_expression": "tomorrow"}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "parse_date"
+        # Should return a valid YYYY-MM-DD format
+        assert len(result["output"]) == 10
+        assert result["output"].count("-") == 2
+
+    def test_parse_date_in_days(self):
+        """Test parsing 'in 3 days'."""
+        tool_call = {
+            "function": {
+                "name": "parse_date",
+                "arguments": '{"date_expression": "in 3 days"}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "parse_date"
+        # Should return a valid YYYY-MM-DD format
+        assert len(result["output"]) == 10
+        assert result["output"].count("-") == 2

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

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

{todo_agent-0.2.6 → todo_agent-0.2.8}/todo_agent/core/conversation_manager.py

@@ -35,14 +35,16 @@ class ConversationManager:
     """Manages conversation state and memory for LLM interactions."""
 
     def __init__(
-        self, max_tokens: int = 16000, max_messages: int = 50, model: str = "gpt-4"
+        self, max_tokens: int = 32000, max_messages: int = 50, model: str = "gpt-4"
     ):
         self.history: List[ConversationMessage] = []
         self.max_tokens = max_tokens
         self.max_messages = max_messages
         self.system_prompt: Optional[str] = None
         self.token_counter = get_token_counter(model)
-        self._total_tokens = 0  # Running total of tokens in conversation
+        self._total_tokens: int = 0  # Running total of tokens in conversation
+        self._tools_tokens: int = 0  # Cache for tools token count
+        self._last_tools_hash: Optional[int] = None  # Track if tools have changed
 
     def add_message(
         self,
@@ -140,10 +142,44 @@ class ConversationManager:
                 self._total_tokens -= message.token_count
             self.history.pop(index)
 
-    def _trim_if_needed(self) -> None:
+    def get_request_tokens(self, tools: List[Dict[str, Any]]) -> int:
+        """
+        Get total request tokens (conversation + tools).
+
+        Args:
+            tools: Current tool definitions
+
+        Returns:
+            Total request tokens
+        """
+        # Check if tools have changed
+        tools_hash = hash(str(tools))
+        if tools_hash != self._last_tools_hash:
+            self._tools_tokens = self.token_counter.count_tools_tokens(tools)
+            self._last_tools_hash = tools_hash
+
+        return self._total_tokens + self._tools_tokens
+
+    def update_request_tokens(self, actual_prompt_tokens: int) -> None:
+        """
+        Update the conversation with actual token count from API response.
+
+        Args:
+            actual_prompt_tokens: Actual prompt tokens used by the API
+        """
+        # Calculate tools tokens by subtracting conversation tokens
+        tools_tokens = actual_prompt_tokens - self._total_tokens
+        if tools_tokens >= 0:
+            self._tools_tokens = tools_tokens
+        # Note: logger not available in this context, so we'll handle logging in the calling code
+
+    def _trim_if_needed(self, tools: Optional[List[Dict[str, Any]]] = None) -> None:
         """
         Trim conversation history if it exceeds token or message limits.
         Preserves most recent messages and system prompt.
+
+        Args:
+            tools: Optional tools for request token calculation
         """
         # Check message count limit
         if len(self.history) > self.max_messages:
@@ -160,8 +196,10 @@ class ConversationManager:
             # Recalculate total tokens after message count trimming
             self._recalculate_total_tokens()
 
-        # Check token limit - remove oldest non-system messages until under limit
-        while self._total_tokens > self.max_tokens and len(self.history) > 2:
+        # Check token limit using request tokens if tools provided
+        current_tokens = self.get_request_tokens(tools) if tools else self._total_tokens
+
+        while current_tokens > self.max_tokens and len(self.history) > 2:
             # Find oldest non-system message to remove
             for i, msg in enumerate(self.history):
                 if msg.role != MessageRole.SYSTEM:
@@ -171,6 +209,11 @@ class ConversationManager:
                 # No non-system messages found, break to avoid infinite loop
                 break
 
+            # Recalculate request tokens
+            current_tokens = (
+                self.get_request_tokens(tools) if tools else self._total_tokens
+            )
+
     def _recalculate_total_tokens(self) -> None:
         """Recalculate total token count from scratch (used after major restructuring)."""
         self._total_tokens = 0
@@ -219,10 +262,15 @@ class ConversationManager:
         self.history.insert(0, system_message)
         self._total_tokens += token_count
 
-    def get_conversation_summary(self) -> Dict[str, Any]:
+    def get_conversation_summary(
+        self, tools: Optional[List[Dict[str, Any]]] = None
+    ) -> Dict[str, Any]:
         """
         Get conversation statistics and summary.
 
+        Args:
+            tools: Optional tools for request token calculation
+
         Returns:
             Dictionary with conversation metrics
         """
@@ -256,6 +304,9 @@ class ConversationManager:
         return {
             "total_messages": len(self.history),
             "estimated_tokens": self._total_tokens,
+            "request_tokens": self.get_request_tokens(tools)
+            if tools
+            else self._total_tokens,
             "user_messages": len(
                 [msg for msg in self.history if msg.role == MessageRole.USER]
             ),

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

@@ -19,6 +19,7 @@ class TodoManager:
         project: Optional[str] = None,
         context: Optional[str] = None,
         due: Optional[str] = None,
+        recurring: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
         # Validate and sanitize inputs
@@ -54,6 +55,31 @@ class TodoManager:
                     f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
                 )
 
+        if recurring:
+            # Validate recurring format
+            if not recurring.startswith("rec:"):
+                raise ValueError(
+                    f"Invalid recurring format '{recurring}'. Must start with 'rec:'."
+                )
+            # Basic validation of recurring syntax
+            parts = recurring.split(":")
+            if len(parts) < 2 or len(parts) > 3:
+                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.")
+
         # Build the full task description with priority, project, and context
         full_description = description
 
@@ -69,6 +95,9 @@ class TodoManager:
         if due:
             full_description = f"{full_description} due:{due}"
 
+        if recurring:
+            full_description = f"{full_description} {recurring}"
+
         self.todo_shell.add(full_description)
         return f"Added task: {full_description}"
 

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

@@ -187,6 +187,18 @@ class Inference:
                 messages=messages, tools=self.tool_handler.tools
             )
 
+            # Extract actual token usage from API response
+            usage = response.get("usage", {})
+            actual_prompt_tokens = usage.get("prompt_tokens", 0)
+            actual_completion_tokens = usage.get("completion_tokens", 0)
+            actual_total_tokens = usage.get("total_tokens", 0)
+
+            # Update conversation manager with actual token count
+            self.conversation_manager.update_request_tokens(actual_prompt_tokens)
+            self.logger.debug(
+                f"Updated with actual API tokens: prompt={actual_prompt_tokens}, completion={actual_completion_tokens}, total={actual_total_tokens}"
+            )
+
             # Handle multiple tool calls in sequence
             tool_call_count = 0
             while True:
@@ -237,6 +249,14 @@ class Inference:
                     messages=messages, tools=self.tool_handler.tools
                 )
 
+                # Update with actual tokens from subsequent API calls
+                usage = response.get("usage", {})
+                actual_prompt_tokens = usage.get("prompt_tokens", 0)
+                self.conversation_manager.update_request_tokens(actual_prompt_tokens)
+                self.logger.debug(
+                    f"Updated with actual API tokens after tool calls: prompt={actual_prompt_tokens}"
+                )
+
             # Calculate and log total thinking time
             end_time = time.time()
             thinking_time = end_time - start_time
@@ -270,7 +290,9 @@ class Inference:
         Returns:
             Dictionary with conversation metrics
         """
-        return self.conversation_manager.get_conversation_summary()
+        return self.conversation_manager.get_conversation_summary(
+            self.tool_handler.tools
+        )
 
     def clear_conversation(self) -> None:
         """Clear conversation history."""

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

@@ -72,12 +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.6 → todo_agent-0.2.8}/todo_agent/infrastructure/openrouter_client.py

@@ -78,12 +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}")