todo-agent 0.1.0__py3-none-any.whl → 0.2.1__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.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

todo_agent/core/__init__.py

@@ -9,8 +9,8 @@ from .exceptions import InvalidTaskFormatError, TaskNotFoundError, TodoError
 from .todo_manager import TodoManager
 
 __all__ = [
-    "TodoManager",
-    "TodoError",
-    "TaskNotFoundError",
     "InvalidTaskFormatError",
+    "TaskNotFoundError",
+    "TodoError",
+    "TodoManager",
 ]

todo_agent/core/conversation_manager.py

@@ -3,14 +3,14 @@ Conversation management for todo.sh LLM agent.
 """
 
 import time
-from typing import List, Dict, Optional
 from dataclasses import dataclass
 from enum import Enum
+from typing import Any, Dict, List, Optional
 
 try:
     from todo_agent.infrastructure.token_counter import get_token_counter
 except ImportError:
-    from infrastructure.token_counter import get_token_counter
+    from infrastructure.token_counter import get_token_counter  # type: ignore[no-redef]
 
 
 class MessageRole(Enum):
@@ -76,7 +76,7 @@ class ConversationManager:
         self._total_tokens += token_count
         self._trim_if_needed()
 
-    def get_messages(self, include_tool_calls: bool = True) -> List[Dict[str, str]]:
+    def get_messages(self, include_tool_calls: bool = True) -> List[Dict[str, Any]]:
         """
         Get conversation messages in OpenRouter API format.
 
@@ -86,14 +86,17 @@ class ConversationManager:
         Returns:
             List of message dictionaries for API consumption
         """
-        messages = []
+        messages: List[Dict[str, Any]] = []
 
         # Add conversation messages (system prompt is already in history)
         for msg in self.history:
             if msg.role == MessageRole.TOOL and not include_tool_calls:
                 continue
 
-            message_dict = {"role": msg.role.value, "content": msg.content}
+            message_dict: Dict[str, Any] = {
+                "role": msg.role.value,
+                "content": msg.content,
+            }
 
             # Handle tool calls in assistant messages
             if msg.role == MessageRole.ASSISTANT and msg.tool_calls:
@@ -148,8 +151,11 @@ class ConversationManager:
             system_messages = [
                 msg for msg in self.history if msg.role == MessageRole.SYSTEM
             ]
-            recent_messages = self.history[-self.max_messages:]
-            self.history = system_messages + recent_messages[-self.max_messages + len(system_messages):]
+            recent_messages = self.history[-self.max_messages :]
+            self.history = (
+                system_messages
+                + recent_messages[-self.max_messages + len(system_messages) :]
+            )
 
             # Recalculate total tokens after message count trimming
             self._recalculate_total_tokens()
@@ -213,7 +219,7 @@ 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) -> Dict[str, Any]:
         """
         Get conversation statistics and summary.
 
@@ -235,13 +241,17 @@ class ConversationManager:
 
         thinking_stats = {}
         if thinking_times:
-            thinking_stats = {
-                "total_thinking_time": sum(thinking_times),
-                "average_thinking_time": sum(thinking_times) / len(thinking_times),
-                "min_thinking_time": min(thinking_times),
-                "max_thinking_time": max(thinking_times),
-                "thinking_time_count": len(thinking_times),
-            }
+            # Filter out None values for calculations
+            valid_thinking_times = [t for t in thinking_times if t is not None]
+            if valid_thinking_times:
+                thinking_stats = {
+                    "total_thinking_time": sum(valid_thinking_times),
+                    "average_thinking_time": sum(valid_thinking_times)
+                    / len(valid_thinking_times),
+                    "min_thinking_time": min(valid_thinking_times),
+                    "max_thinking_time": max(valid_thinking_times),
+                    "thinking_time_count": len(valid_thinking_times),
+                }
 
         return {
             "total_messages": len(self.history),
@@ -256,12 +266,24 @@ class ConversationManager:
                 [msg for msg in self.history if msg.role == MessageRole.TOOL]
             ),
             "oldest_message": (
-                min([msg.timestamp for msg in messages_with_timestamps])
+                min(
+                    [
+                        msg.timestamp
+                        for msg in messages_with_timestamps
+                        if msg.timestamp is not None
+                    ]
+                )
                 if messages_with_timestamps
                 else None
             ),
             "newest_message": (
-                max([msg.timestamp for msg in messages_with_timestamps])
+                max(
+                    [
+                        msg.timestamp
+                        for msg in messages_with_timestamps
+                        if msg.timestamp is not None
+                    ]
+                )
                 if messages_with_timestamps
                 else None
             ),

todo_agent/core/todo_manager.py

@@ -2,14 +2,14 @@
 Todo.sh operations orchestration and business logic.
 """
 
-from typing import Optional
 from datetime import datetime
+from typing import Any, Optional
 
 
 class TodoManager:
     """Orchestrates todo.sh operations with business logic."""
 
-    def __init__(self, todo_shell):
+    def __init__(self, todo_shell: Any) -> None:
         self.todo_shell = todo_shell
 
     def add_task(
@@ -23,20 +23,20 @@ class TodoManager:
         """Add new task with explicit project/context parameters."""
         # Build the full task description with priority, project, and context
         full_description = description
-        
+
         if priority:
             full_description = f"({priority}) {full_description}"
-        
+
         if project:
             full_description = f"{full_description} +{project}"
-        
+
         if context:
             full_description = f"{full_description} @{context}"
-        
+
         if due:
             full_description = f"{full_description} due:{due}"
-        
-        result = self.todo_shell.add(full_description)
+
+        self.todo_shell.add(full_description)
         return f"Added task: {full_description}"
 
     def list_tasks(self, filter: Optional[str] = None) -> str:
@@ -44,7 +44,7 @@ class TodoManager:
         result = self.todo_shell.list_tasks(filter)
         if not result.strip():
             return "No tasks found."
-        
+
         # Return the raw todo.txt format for the LLM to format conversationally
         # The LLM will convert this into natural language in its response
         return result
@@ -54,14 +54,22 @@ class TodoManager:
         result = self.todo_shell.complete(task_number)
         return f"Completed task {task_number}: {result}"
 
-    def get_overview(self, **kwargs) -> str:
+    def get_overview(self, **kwargs: Any) -> str:
         """Show current task statistics."""
         tasks = self.todo_shell.list_tasks()
         completed = self.todo_shell.list_completed()
-        
-        task_count = len([line for line in tasks.split('\n') if line.strip()]) if tasks.strip() else 0
-        completed_count = len([line for line in completed.split('\n') if line.strip()]) if completed.strip() else 0
-        
+
+        task_count = (
+            len([line for line in tasks.split("\n") if line.strip()])
+            if tasks.strip()
+            else 0
+        )
+        completed_count = (
+            len([line for line in completed.split("\n") if line.strip()])
+            if completed.strip()
+            else 0
+        )
+
         return f"Task Overview:\n- Active tasks: {task_count}\n- Completed tasks: {completed_count}"
 
     def replace_task(self, task_number: int, new_description: str) -> str:
@@ -97,14 +105,14 @@ class TodoManager:
         result = self.todo_shell.remove_priority(task_number)
         return f"Removed priority from task {task_number}: {result}"
 
-    def list_projects(self, **kwargs) -> str:
+    def list_projects(self, **kwargs: Any) -> str:
         """List all available projects in todo.txt."""
         result = self.todo_shell.list_projects()
         if not result.strip():
             return "No projects found."
         return result
 
-    def list_contexts(self, **kwargs) -> str:
+    def list_contexts(self, **kwargs: Any) -> str:
         """List all available contexts in todo.txt."""
         result = self.todo_shell.list_contexts()
         if not result.strip():
@@ -112,17 +120,17 @@ class TodoManager:
         return result
 
     def list_completed_tasks(
-        self, 
+        self,
         filter: Optional[str] = None,
         project: Optional[str] = None,
         context: Optional[str] = None,
         text_search: Optional[str] = None,
         date_from: Optional[str] = None,
         date_to: Optional[str] = None,
-        **kwargs
+        **kwargs: Any,
     ) -> str:
         """List completed tasks with optional filtering.
-        
+
         Args:
             filter: Raw filter string (e.g., '+work', '@office')
             project: Filter by project (without + symbol)
@@ -133,19 +141,19 @@ class TodoManager:
         """
         # Build filter string from individual parameters
         filter_parts = []
-        
+
         if filter:
             filter_parts.append(filter)
-        
+
         if project:
             filter_parts.append(f"+{project}")
-            
+
         if context:
             filter_parts.append(f"@{context}")
-            
+
         if text_search:
             filter_parts.append(text_search)
-            
+
         # Handle date filtering - todo.sh supports direct date pattern matching
         # LIMITATIONS: Due to todo.sh constraints, complex date ranges are not supported.
         # The filtering behavior is:
@@ -164,31 +172,33 @@ class TodoManager:
             # For end date only, we'll use the year-month pattern
             # This will match all tasks in that month
             filter_parts.append(date_to[:7])  # YYYY-MM format
-        
+
         # Combine all filters
         combined_filter = " ".join(filter_parts) if filter_parts else None
-        
+
         result = self.todo_shell.list_completed(combined_filter)
         if not result.strip():
             return "No completed tasks found matching the criteria."
         return result
 
-    def move_task(self, task_number: int, destination: str, source: Optional[str] = None) -> str:
+    def move_task(
+        self, task_number: int, destination: str, source: Optional[str] = None
+    ) -> str:
         """Move task from source to destination file."""
         result = self.todo_shell.move(task_number, destination, source)
         return f"Moved task {task_number} to {destination}: {result}"
 
-    def archive_tasks(self, **kwargs) -> str:
+    def archive_tasks(self, **kwargs: Any) -> str:
         """Archive completed tasks."""
         result = self.todo_shell.archive()
         return f"Archived tasks: {result}"
 
-    def deduplicate_tasks(self, **kwargs) -> str:
+    def deduplicate_tasks(self, **kwargs: Any) -> str:
         """Remove duplicate tasks."""
         result = self.todo_shell.deduplicate()
         return f"Deduplicated tasks: {result}"
 
-    def get_current_datetime(self, **kwargs) -> str:
+    def get_current_datetime(self, **kwargs: Any) -> str:
         """Get the current date and time."""
         now = datetime.now()
         return f"Current date and time: {now.strftime('%Y-%m-%d %H:%M:%S')} ({now.strftime('%A, %B %d, %Y at %I:%M %p')})"

todo_agent/infrastructure/__init__.py

@@ -8,4 +8,4 @@ from .config import Config
 from .openrouter_client import OpenRouterClient
 from .todo_shell import TodoShell
 
-__all__ = ["OpenRouterClient", "TodoShell", "Config"]
+__all__ = ["Config", "OpenRouterClient", "TodoShell"]

todo_agent/infrastructure/config.py

@@ -11,18 +11,18 @@ class Config:
     DEFAULT_MODEL = "openai/gpt-4o-mini"
     # DEFAULT_MODEL = "mistralai/mistral-small-3.1-24b-instruct"
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Provider selection
         self.provider = os.getenv("LLM_PROVIDER", "openrouter")
-        
+
         # OpenRouter configuration
         self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
         self.openrouter_model = os.getenv("OPENROUTER_MODEL", self.DEFAULT_MODEL)
-        
+
         # Ollama configuration
         self.ollama_base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
         self.ollama_model = os.getenv("OLLAMA_MODEL", "mistral-small3.1")
-        
+
         # Common configuration
         self.model = self._get_model_for_provider()
         self.log_level = os.getenv("LOG_LEVEL", "INFO")
@@ -40,7 +40,9 @@ class Config:
         """Validate required configuration."""
         if self.provider == "openrouter":
             if not self.openrouter_api_key:
-                raise ValueError("OPENROUTER_API_KEY environment variable is required for OpenRouter provider")
+                raise ValueError(
+                    "OPENROUTER_API_KEY environment variable is required for OpenRouter provider"
+                )
         elif self.provider == "ollama":
             # Ollama doesn't require API key, but we could validate the base URL is reachable
             pass

todo_agent/infrastructure/inference.py

@@ -4,29 +4,39 @@ LLM inference engine for todo.sh agent.
 
 import os
 import time
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 try:
+    from todo_agent.core.conversation_manager import ConversationManager, MessageRole
     from todo_agent.infrastructure.config import Config
     from todo_agent.infrastructure.llm_client_factory import LLMClientFactory
     from todo_agent.infrastructure.logger import Logger
-    from todo_agent.core.conversation_manager import ConversationManager, MessageRole
     from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
-    from infrastructure.config import Config
-    from infrastructure.llm_client_factory import LLMClientFactory
-    from infrastructure.logger import Logger
-    from core.conversation_manager import ConversationManager, MessageRole
-    from interface.tools import ToolCallHandler
+    from core.conversation_manager import (  # type: ignore[no-redef]
+        ConversationManager,
+        MessageRole,
+    )
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.llm_client_factory import (  # type: ignore[no-redef]
+        LLMClientFactory,
+    )
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from interface.tools import ToolCallHandler  # type: ignore[no-redef]
 
 
 class Inference:
     """LLM inference engine that orchestrates tool calling and conversation management."""
 
-    def __init__(self, config: Config, tool_handler: ToolCallHandler, logger: Optional[Logger] = None):
+    def __init__(
+        self,
+        config: Config,
+        tool_handler: ToolCallHandler,
+        logger: Optional[Logger] = None,
+    ):
         """
         Initialize the inference engine.
-        
+
         Args:
             config: Configuration object
             tool_handler: Tool call handler for executing tools
@@ -35,17 +45,19 @@ class Inference:
         self.config = config
         self.tool_handler = tool_handler
         self.logger = logger or Logger("inference")
-        
+
         # Initialize LLM client using factory
         self.llm_client = LLMClientFactory.create_client(config, self.logger)
-        
+
         # Initialize conversation manager
         self.conversation_manager = ConversationManager()
-        
+
         # Set up system prompt
         self._setup_system_prompt()
-        
-        self.logger.info(f"Inference engine initialized with {config.provider} provider using model: {self.llm_client.get_model_name()}")
+
+        self.logger.info(
+            f"Inference engine initialized with {config.provider} provider using model: {self.llm_client.get_model_name()}"
+        )
 
     def _setup_system_prompt(self) -> None:
         """Set up the system prompt for the LLM."""
@@ -57,75 +69,106 @@ class Inference:
         """Load and format the system prompt from file."""
         # Generate tools section programmatically
         tools_section = self._generate_tools_section()
-        
+
         # Get current datetime for interpolation
         from datetime import datetime
+
         current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
+
         # Load system prompt from file
-        prompt_file_path = os.path.join(os.path.dirname(__file__), "prompts", "system_prompt.txt")
-        
+        prompt_file_path = os.path.join(
+            os.path.dirname(__file__), "prompts", "system_prompt.txt"
+        )
+
         try:
-            with open(prompt_file_path, 'r', encoding='utf-8') as f:
+            with open(prompt_file_path, encoding="utf-8") as f:
                 system_prompt_template = f.read()
-            
+
             # Format the template with the tools section and current datetime
             return system_prompt_template.format(
-                tools_section=tools_section,
-                current_datetime=current_datetime
+                tools_section=tools_section, current_datetime=current_datetime
             )
-            
+
         except FileNotFoundError:
             self.logger.error(f"System prompt file not found: {prompt_file_path}")
             raise
         except Exception as e:
-            self.logger.error(f"Error loading system prompt: {str(e)}")
+            self.logger.error(f"Error loading system prompt: {e!s}")
             raise
 
     def _generate_tools_section(self) -> str:
         """Generate the AVAILABLE TOOLS section with strategic categorization."""
         tool_categories = {
-            "Discovery Tools": ["list_projects", "list_contexts", "list_tasks", "list_completed_tasks"],
-            "Modification Tools": ["add_task", "complete_task", "replace_task", "append_to_task", "prepend_to_task"],
-            "Management Tools": ["delete_task", "set_priority", "remove_priority", "move_task"],
-            "Maintenance Tools": ["archive_tasks", "deduplicate_tasks", "get_overview"]
+            "Discovery Tools": [
+                "list_projects",
+                "list_contexts",
+                "list_tasks",
+                "list_completed_tasks",
+            ],
+            "Modification Tools": [
+                "add_task",
+                "complete_task",
+                "replace_task",
+                "append_to_task",
+                "prepend_to_task",
+            ],
+            "Management Tools": [
+                "delete_task",
+                "set_priority",
+                "remove_priority",
+                "move_task",
+            ],
+            "Maintenance Tools": ["archive_tasks", "deduplicate_tasks", "get_overview"],
         }
-        
+
         tools_section = []
         for category, tool_names in tool_categories.items():
             tools_section.append(f"\n**{category}:**")
             for tool_name in tool_names:
-                tool_info = next((t for t in self.tool_handler.tools if t["function"]["name"] == tool_name), None)
+                tool_info = next(
+                    (
+                        t
+                        for t in self.tool_handler.tools
+                        if t["function"]["name"] == tool_name
+                    ),
+                    None,
+                )
                 if tool_info:
                     # Get first sentence of description for concise overview
-                    first_sentence = tool_info["function"]["description"].split('.')[0] + '.'
+                    first_sentence = (
+                        tool_info["function"]["description"].split(".")[0] + "."
+                    )
                     tools_section.append(f"- {tool_name}(): {first_sentence}")
-        
-        return '\n'.join(tools_section)
+
+        return "\n".join(tools_section)
 
     def process_request(self, user_input: str) -> tuple[str, float]:
         """
         Process a user request through the LLM with tool orchestration.
-        
+
         Args:
             user_input: Natural language user request
-            
+
         Returns:
             Tuple of (formatted response for user, thinking time in seconds)
         """
         # Start timing the request
         start_time = time.time()
-        
+
         try:
-            self.logger.debug(f"Starting request processing for: {user_input[:30]}{'...' if len(user_input) > 30 else ''}")
-            
+            self.logger.debug(
+                f"Starting request processing for: {user_input[:30]}{'...' if len(user_input) > 30 else ''}"
+            )
+
             # Add user message to conversation
             self.conversation_manager.add_message(MessageRole.USER, user_input)
             self.logger.debug("Added user message to conversation")
 
             # Get conversation history for LLM
             messages = self.conversation_manager.get_messages()
-            self.logger.debug(f"Retrieved {len(messages)} messages from conversation history")
+            self.logger.debug(
+                f"Retrieved {len(messages)} messages from conversation history"
+            )
 
             # Send to LLM with function calling enabled
             self.logger.debug("Sending request to LLM with tools")
@@ -142,26 +185,32 @@ class Inference:
                     break
 
                 tool_call_count += 1
-                self.logger.debug(f"Executing tool call sequence #{tool_call_count} with {len(tool_calls)} tools")
+                self.logger.debug(
+                    f"Executing tool call sequence #{tool_call_count} with {len(tool_calls)} tools"
+                )
 
                 # Execute all tool calls and collect results
                 tool_results = []
                 for i, tool_call in enumerate(tool_calls):
                     tool_name = tool_call.get("function", {}).get("name", "unknown")
                     tool_call_id = tool_call.get("id", "unknown")
-                    self.logger.debug(f"=== TOOL EXECUTION #{i+1}/{len(tool_calls)} ===")
+                    self.logger.debug(
+                        f"=== TOOL EXECUTION #{i + 1}/{len(tool_calls)} ==="
+                    )
                     self.logger.debug(f"Tool: {tool_name}")
                     self.logger.debug(f"Tool Call ID: {tool_call_id}")
                     self.logger.debug(f"Raw tool call: {tool_call}")
-                    
+
                     result = self.tool_handler.execute_tool(tool_call)
-                    
+
                     # Log tool execution result (success or error)
                     if result.get("error", False):
-                        self.logger.warning(f"Tool {tool_name} failed: {result.get('user_message', result.get('output', 'Unknown error'))}")
+                        self.logger.warning(
+                            f"Tool {tool_name} failed: {result.get('user_message', result.get('output', 'Unknown error'))}"
+                        )
                     else:
                         self.logger.debug(f"Tool {tool_name} succeeded")
-                    
+
                     self.logger.debug(f"Tool result: {result}")
                     tool_results.append(result)
 
@@ -180,12 +229,16 @@ class Inference:
             # Calculate and log total thinking time
             end_time = time.time()
             thinking_time = end_time - start_time
-            
+
             # Add final assistant response to conversation with thinking time
             final_content = self.llm_client.extract_content(response)
-            self.conversation_manager.add_message(MessageRole.ASSISTANT, final_content, thinking_time=thinking_time)
-            
-            self.logger.info(f"Request completed successfully with {tool_call_count} tool call sequences in {thinking_time:.2f}s")
+            self.conversation_manager.add_message(
+                MessageRole.ASSISTANT, final_content, thinking_time=thinking_time
+            )
+
+            self.logger.info(
+                f"Request completed successfully with {tool_call_count} tool call sequences in {thinking_time:.2f}s"
+            )
 
             # Return final user-facing response and thinking time
             return final_content, thinking_time
@@ -194,13 +247,15 @@ class Inference:
             # Calculate and log thinking time even for failed requests
             end_time = time.time()
             thinking_time = end_time - start_time
-            self.logger.error(f"Error processing request after {thinking_time:.2f}s: {str(e)}")
-            return f"Error: {str(e)}", thinking_time
+            self.logger.error(
+                f"Error processing request after {thinking_time:.2f}s: {e!s}"
+            )
+            return f"Error: {e!s}", thinking_time
 
-    def get_conversation_summary(self) -> Dict[str, any]:
+    def get_conversation_summary(self) -> Dict[str, Any]:
         """
         Get conversation statistics and summary.
-        
+
         Returns:
             Dictionary with conversation metrics
         """
@@ -214,7 +269,7 @@ class Inference:
     def get_conversation_manager(self) -> ConversationManager:
         """
         Get the conversation manager instance.
-        
+
         Returns:
             Conversation manager instance
         """