todo-agent 0.1.0__py3-none-any.whl

todo_agent/infrastructure/inference.py

@@ -0,0 +1,221 @@
+"""
+LLM inference engine for todo.sh agent.
+"""
+
+import os
+import time
+from typing import Any, Dict, List, Optional
+
+try:
+    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
+
+
+class Inference:
+    """LLM inference engine that orchestrates tool calling and conversation management."""
+
+    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
+            logger: Optional logger instance
+        """
+        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()}")
+
+    def _setup_system_prompt(self) -> None:
+        """Set up the system prompt for the LLM."""
+        system_prompt = self._load_system_prompt()
+        self.conversation_manager.set_system_prompt(system_prompt)
+        self.logger.debug("System prompt loaded and set")
+
+    def _load_system_prompt(self) -> str:
+        """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")
+        
+        try:
+            with open(prompt_file_path, 'r', 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
+            )
+            
+        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)}")
+            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"]
+        }
+        
+        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)
+                if tool_info:
+                    # Get first sentence of description for concise overview
+                    first_sentence = tool_info["function"]["description"].split('.')[0] + '.'
+                    tools_section.append(f"- {tool_name}(): {first_sentence}")
+        
+        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 ''}")
+            
+            # 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")
+
+            # Send to LLM with function calling enabled
+            self.logger.debug("Sending request to LLM with tools")
+            response = self.llm_client.chat_with_tools(
+                messages=messages, tools=self.tool_handler.tools
+            )
+
+            # Handle multiple tool calls in sequence
+            tool_call_count = 0
+            while True:
+                tool_calls = self.llm_client.extract_tool_calls(response)
+
+                if not tool_calls:
+                    break
+
+                tool_call_count += 1
+                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: {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'))}")
+                    else:
+                        self.logger.debug(f"Tool {tool_name} succeeded")
+                    
+                    self.logger.debug(f"Tool result: {result}")
+                    tool_results.append(result)
+
+                # Add tool call sequence to conversation
+                self.conversation_manager.add_tool_call_sequence(
+                    tool_calls, tool_results
+                )
+                self.logger.debug("Added tool call sequence to conversation")
+
+                # Continue conversation with tool results
+                messages = self.conversation_manager.get_messages()
+                response = self.llm_client.chat_with_tools(
+                    messages=messages, tools=self.tool_handler.tools
+                )
+
+            # 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")
+
+            # Return final user-facing response and thinking time
+            return final_content, thinking_time
+
+        except Exception as e:
+            # 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
+
+    def get_conversation_summary(self) -> Dict[str, any]:
+        """
+        Get conversation statistics and summary.
+        
+        Returns:
+            Dictionary with conversation metrics
+        """
+        return self.conversation_manager.get_conversation_summary()
+
+    def clear_conversation(self) -> None:
+        """Clear conversation history."""
+        self.conversation_manager.clear_conversation()
+        self.logger.info("Conversation history cleared")
+
+    def get_conversation_manager(self) -> ConversationManager:
+        """
+        Get the conversation manager instance.
+        
+        Returns:
+            Conversation manager instance
+        """
+        return self.conversation_manager

todo_agent/infrastructure/llm_client.py

@@ -0,0 +1,62 @@
+"""
+Abstract LLM client interface for todo.sh agent.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+class LLMClient(ABC):
+    """Abstract interface for LLM clients."""
+
+    @abstractmethod
+    def chat_with_tools(
+        self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Send chat message with function calling enabled.
+
+        Args:
+            messages: List of message dictionaries
+            tools: List of tool definitions
+
+        Returns:
+            API response dictionary
+        """
+        pass
+
+    @abstractmethod
+    def extract_tool_calls(self, response: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Extract tool calls from API response.
+
+        Args:
+            response: API response dictionary
+
+        Returns:
+            List of tool call dictionaries
+        """
+        pass
+
+    @abstractmethod
+    def extract_content(self, response: Dict[str, Any]) -> str:
+        """
+        Extract content from API response.
+
+        Args:
+            response: API response dictionary
+
+        Returns:
+            Extracted content string
+        """
+        pass
+
+    @abstractmethod
+    def get_model_name(self) -> str:
+        """
+        Get the model name being used by this client.
+
+        Returns:
+            Model name string
+        """
+        pass

todo_agent/infrastructure/llm_client_factory.py

@@ -0,0 +1,48 @@
+"""
+Factory for creating LLM clients based on configuration.
+"""
+
+from typing import Optional
+
+try:
+    from todo_agent.infrastructure.config import Config
+    from todo_agent.infrastructure.llm_client import LLMClient
+    from todo_agent.infrastructure.openrouter_client import OpenRouterClient
+    from todo_agent.infrastructure.ollama_client import OllamaClient
+    from todo_agent.infrastructure.logger import Logger
+except ImportError:
+    from infrastructure.config import Config
+    from infrastructure.llm_client import LLMClient
+    from infrastructure.openrouter_client import OpenRouterClient
+    from infrastructure.ollama_client import OllamaClient
+    from infrastructure.logger import Logger
+
+
+class LLMClientFactory:
+    """Factory for creating LLM clients based on configuration."""
+
+    @staticmethod
+    def create_client(config: Config, logger: Optional[Logger] = None) -> LLMClient:
+        """
+        Create appropriate LLM client based on configuration.
+
+        Args:
+            config: Configuration object
+            logger: Optional logger instance
+
+        Returns:
+            LLM client instance
+
+        Raises:
+            ValueError: If provider is not supported
+        """
+        logger = logger or Logger("llm_client_factory")
+        
+        if config.provider == "openrouter":
+            logger.info(f"Creating OpenRouter client with model: {config.openrouter_model}")
+            return OpenRouterClient(config)
+        elif config.provider == "ollama":
+            logger.info(f"Creating Ollama client with model: {config.ollama_model}")
+            return OllamaClient(config)
+        else:
+            raise ValueError(f"Unsupported LLM provider: {config.provider}")

todo_agent/infrastructure/logger.py

@@ -0,0 +1,128 @@
+"""
+Logging infrastructure for todo.sh LLM agent.
+"""
+
+import logging
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+class Logger:
+    """Custom logger that respects LOG_LEVEL environment variable and logs to screen and file."""
+    
+    def __init__(self, name: str = "todo_agent"):
+        """
+        Initialize the logger.
+        
+        Args:
+            name: Logger name, defaults to "todo_agent"
+        """
+        self.name = name
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(logging.DEBUG)
+        
+        # Clear any existing handlers
+        self.logger.handlers.clear()
+        
+        # Create logs directory if it doesn't exist
+        self._ensure_logs_directory()
+        
+        # Set up file handler (always active)
+        self._setup_file_handler()
+        
+        # Set up console handler with appropriate log level
+        self._setup_console_handler()
+    
+    def _ensure_logs_directory(self):
+        """Ensure the logs directory exists in TODO_DIR."""
+        logs_dir = self._get_logs_directory()
+        logs_dir.mkdir(exist_ok=True)
+    
+    def _get_logs_directory(self) -> Path:
+        """Get the logs directory path from TODO_DIR environment variable."""
+        todo_dir = os.getenv("TODO_DIR")
+        if todo_dir:
+            return Path(todo_dir) / "logs"
+        else:
+            # Fallback to local logs directory if TODO_DIR is not set
+            return Path("logs")
+    
+    def _get_log_level(self) -> int:
+        """Get log level from LOG_LEVEL environment variable."""
+        log_level_str = os.getenv("LOG_LEVEL", "INFO").upper()
+        
+        # Map string values to logging constants
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL
+        }
+        
+        return level_map.get(log_level_str, logging.INFO)
+    
+    def _should_log_to_console(self) -> bool:
+        """Check if we should log to console based on DEBUG environment variable."""
+        return os.getenv("DEBUG") is not None
+    
+    def _setup_file_handler(self):
+        """Set up file handler for logging to file."""
+        # Create log filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d")
+        logs_dir = self._get_logs_directory()
+        log_file = logs_dir / f"todo_agent_{timestamp}.log"
+        
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        
+        # Create formatter for file logging
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        file_handler.setFormatter(file_formatter)
+        
+        self.logger.addHandler(file_handler)
+    
+    def _setup_console_handler(self):
+        """Set up console handler for logging to screen with appropriate log level."""
+        # Only add console handler if DEBUG environment variable is set
+        if not self._should_log_to_console():
+            return
+            
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(self._get_log_level())
+        
+        # Create formatter for console logging (more concise)
+        console_formatter = logging.Formatter(
+            '%(levelname)s - %(message)s'
+        )
+        console_handler.setFormatter(console_formatter)
+        
+        self.logger.addHandler(console_handler)
+    
+    def debug(self, message: str):
+        """Log a debug message."""
+        self.logger.debug(message)
+    
+    def info(self, message: str):
+        """Log an info message."""
+        self.logger.info(message)
+    
+    def warning(self, message: str):
+        """Log a warning message."""
+        self.logger.warning(message)
+    
+    def error(self, message: str):
+        """Log an error message."""
+        self.logger.error(message)
+    
+    def critical(self, message: str):
+        """Log a critical message."""
+        self.logger.critical(message)
+    
+    def exception(self, message: str):
+        """Log an exception message with traceback."""
+        self.logger.exception(message)

todo_agent/infrastructure/ollama_client.py

@@ -0,0 +1,152 @@
+"""
+LLM client for Ollama API communication.
+"""
+
+import json
+import time
+from typing import Any, Dict, List
+
+import requests
+
+try:
+    from todo_agent.infrastructure.config import Config
+    from todo_agent.infrastructure.logger import Logger
+    from todo_agent.infrastructure.token_counter import get_token_counter
+    from todo_agent.infrastructure.llm_client import LLMClient
+except ImportError:
+    from infrastructure.config import Config
+    from infrastructure.logger import Logger
+    from infrastructure.token_counter import get_token_counter
+    from infrastructure.llm_client import LLMClient
+
+
+class OllamaClient(LLMClient):
+    """Ollama API client implementation."""
+
+    def __init__(self, config: Config):
+        """
+        Initialize Ollama client.
+
+        Args:
+            config: Configuration object
+        """
+        self.config = config
+        self.base_url = config.ollama_base_url
+        self.model = config.ollama_model
+        self.logger = Logger("ollama_client")
+        self.token_counter = get_token_counter(self.model)
+
+    def _estimate_tokens(self, text: str) -> int:
+        """
+        Estimate token count for text using accurate tokenization.
+
+        Args:
+            text: Text to count tokens for
+
+        Returns:
+            Number of tokens
+        """
+        return self.token_counter.count_tokens(text)
+
+    def _log_request_details(self, payload: Dict[str, Any], start_time: float):
+        """Log request details including accurate token count."""
+        # Count tokens for messages
+        messages = payload.get("messages", [])
+        tools = payload.get("tools", [])
+
+        total_tokens = self.token_counter.count_request_tokens(messages, tools)
+
+        self.logger.info(f"Request sent - Token count: {total_tokens}")
+        # self.logger.debug(f"Raw request payload: {json.dumps(payload, indent=2)}")
+
+    def _log_response_details(self, response: Dict[str, Any], start_time: float):
+        """Log response details including latency."""
+        end_time = time.time()
+        latency_ms = (end_time - start_time) * 1000
+
+        self.logger.info(f"Response received - Latency: {latency_ms:.2f}ms")
+
+        # Log tool call details if present
+        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")
+            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 response and "content" in response["message"]:
+            content = response["message"]["content"]
+            self.logger.debug(f"Response contains content: {content[:100]}{'...' if len(content) > 100 else ''}")
+
+        self.logger.debug(f"Raw response: {json.dumps(response, indent=2)}")
+
+    def chat_with_tools(
+        self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Send chat message with function calling enabled.
+
+        Args:
+            messages: List of message dictionaries
+            tools: List of tool definitions
+
+        Returns:
+            API response dictionary
+        """
+        headers = {
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "tools": tools,
+            "stream": False,
+        }
+
+        start_time = time.time()
+        self._log_request_details(payload, start_time)
+
+        response = requests.post(
+            f"{self.base_url}/api/chat", headers=headers, json=payload
+        )
+
+        if response.status_code != 200:
+            self.logger.error(f"Ollama API error: {response.text}")
+            raise Exception(f"Ollama API error: {response.text}")
+
+        response_data = response.json()
+        self._log_response_details(response_data, start_time)
+
+        return response_data
+
+    def extract_tool_calls(self, response: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Extract tool calls from API response."""
+        tool_calls = []
+        
+        # Ollama response format is different from OpenRouter
+        if "message" in response and "tool_calls" in response["message"]:
+            tool_calls = response["message"]["tool_calls"]
+            self.logger.debug(f"Extracted {len(tool_calls)} tool calls from response")
+            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 call {i+1}: {tool_name} (ID: {tool_call_id})")
+        else:
+            self.logger.debug("No tool calls found in response")
+        
+        return tool_calls
+
+    def extract_content(self, response: Dict[str, Any]) -> str:
+        """Extract content from API response."""
+        if "message" in response and "content" in response["message"]:
+            return response["message"]["content"]
+        return ""
+
+    def get_model_name(self) -> str:
+        """
+        Get the model name being used by this client.
+
+        Returns:
+            Model name string
+        """
+        return self.model