todo-agent 0.2.6__py3-none-any.whl → 0.2.9__py3-none-any.whl

todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.9'
+__version_tuple__ = version_tuple = (0, 2, 9)
 
 __commit_id__ = commit_id = None

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/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,33 @@ 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 +97,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}"
 
@@ -138,6 +169,114 @@ class TodoManager:
         result = self.todo_shell.remove_priority(task_number)
         return f"Removed priority from task {task_number}: {result}"
 
+    def set_due_date(self, task_number: int, due_date: str) -> str:
+        """
+        Set or update due date for a task by intelligently rewriting it.
+
+        Args:
+            task_number: The task number to modify
+            due_date: Due date in YYYY-MM-DD format, or empty string to remove due date
+
+        Returns:
+            Confirmation message with the updated task
+        """
+        # Validate due date format only if not empty
+        if due_date.strip():
+            try:
+                datetime.strptime(due_date, "%Y-%m-%d")
+            except ValueError:
+                raise ValueError(
+                    f"Invalid due date format '{due_date}'. Must be YYYY-MM-DD."
+                )
+
+        result = self.todo_shell.set_due_date(task_number, due_date)
+        if due_date.strip():
+            return f"Set due date {due_date} for task {task_number}: {result}"
+        else:
+            return f"Removed due date from task {task_number}: {result}"
+
+    def set_context(self, task_number: int, context: str) -> str:
+        """
+        Set or update context for a task by intelligently rewriting it.
+
+        Args:
+            task_number: The task number to modify
+            context: Context name (without @ symbol), or empty string to remove context
+
+        Returns:
+            Confirmation message with the updated task
+        """
+        # Validate context name if not empty
+        if context.strip():
+            # Remove any existing @ symbols to prevent duplication
+            clean_context = context.strip().lstrip("@")
+            if not clean_context:
+                raise ValueError(
+                    "Context name cannot be empty after removing @ symbol."
+                )
+
+        result = self.todo_shell.set_context(task_number, context)
+        if context.strip():
+            clean_context = context.strip().lstrip("@")
+            return f"Set context @{clean_context} for task {task_number}: {result}"
+        else:
+            return f"Removed context from task {task_number}: {result}"
+
+    def set_project(self, task_number: int, projects: list) -> str:
+        """
+        Set or update projects for a task by intelligently rewriting it.
+
+        Args:
+            task_number: The task number to modify
+            projects: List of project operations. Each item can be:
+                     - "project" (add project)
+                     - "-project" (remove project)
+                     - Empty string removes all projects
+
+        Returns:
+            Confirmation message with the updated task
+        """
+        # Validate project names if not empty
+        if projects:
+            for project in projects:
+                if project.strip() and not project.startswith("-"):
+                    # Remove any existing + symbols to prevent duplication
+                    clean_project = project.strip().lstrip("+")
+                    if not clean_project:
+                        raise ValueError(
+                            "Project name cannot be empty after removing + symbol."
+                        )
+                elif project.startswith("-"):
+                    clean_project = project[1:].strip().lstrip("+")
+                    if not clean_project:
+                        raise ValueError(
+                            "Project name cannot be empty after removing - and + symbols."
+                        )
+
+        result = self.todo_shell.set_project(task_number, projects)
+
+        if not projects:
+            return f"No project changes made to task {task_number}: {result}"
+        else:
+            # Build operation description
+            operations = []
+            for project in projects:
+                if not project.strip():
+                    # Empty string is a NOOP - skip
+                    continue
+                elif project.startswith("-"):
+                    clean_project = project[1:].strip().lstrip("+")
+                    operations.append(f"removed +{clean_project}")
+                else:
+                    clean_project = project.strip().lstrip("+")
+                    operations.append(f"added +{clean_project}")
+
+            if not operations:
+                return f"No project changes made to task {task_number}: {result}"
+            else:
+                operation_desc = ", ".join(operations)
+                return f"Updated projects for task {task_number} ({operation_desc}): {result}"
+
     def list_projects(self, **kwargs: Any) -> str:
         """List all available projects in todo.txt."""
         result = self.todo_shell.list_projects()

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/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/infrastructure/openrouter_client.py

@@ -72,26 +72,32 @@ class OpenRouterClient(LLMClient):
             f"Token usage - Prompt: {prompt_tokens}, Completion: {completion_tokens}, Total: {total_tokens}"
         )
 
-        # Log tool call details if present
-        if response.get("choices"):
-            choice = response["choices"][0]
-            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}")
-            elif "message" in choice and "content" in choice["message"]:
-                content = choice["message"]["content"]
-                self.logger.debug(
-                    f"Response contains content: {content[:100]}{'...' if len(content) > 100 else ''}"
-                )
+        # Extract and log choice details
+        choices = response.get("choices", [])
+        if not choices:
+            return
+            
+        choice = choices[0]
+        message = choice.get("message", {})
+        
+        # Always log reasoning and content if present
+        reasoning = message.get("reasoning", "")
+        if reasoning:
+            self.logger.info(f"LLM reasoning: {reasoning}")
+            
+        content = message.get("content", "")
+        if content:
+            self.logger.info(f"LLM content: {content}")
+        
+        # Handle tool calls
+        tool_calls = message.get("tool_calls", [])
+        if tool_calls:
+            self.logger.info(f"Response contains {len(tool_calls)} tool calls")
+            
+            # Log each tool call
+            for i, tool_call in enumerate(tool_calls, 1):
+                tool_name = tool_call.get("function", {}).get("name", "unknown")
+                self.logger.info(f"  Tool call {i}: {tool_name}")
 
         self.logger.debug(f"Raw response: {json.dumps(response, indent=2)}")