todo-agent 0.1.0__py3-none-any.whl

todo_agent/infrastructure/openrouter_client.py

@@ -0,0 +1,173 @@
+"""
+LLM client for OpenRouter 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 OpenRouterClient(LLMClient):
+    """LLM API communication and response handling."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.api_key = config.openrouter_api_key
+        self.model = config.model
+        self.base_url = "https://openrouter.ai/api/v1"
+        self.logger = Logger("openrouter_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 token count and latency."""
+        end_time = time.time()
+        latency_ms = (end_time - start_time) * 1000
+        
+        # Extract token usage from response if available
+        usage = response.get("usage", {})
+        prompt_tokens = usage.get("prompt_tokens", "unknown")
+        completion_tokens = usage.get("completion_tokens", "unknown")
+        total_tokens = usage.get("total_tokens", "unknown")
+        
+        self.logger.info(f"Response received - Latency: {latency_ms:.2f}ms")
+        self.logger.info(f"Token usage - Prompt: {prompt_tokens}, Completion: {completion_tokens}, Total: {total_tokens}")
+        
+        # Log tool call details if present
+        if "choices" in response and response["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")
+                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 ''}")
+        
+        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 = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "tools": tools,
+            "tool_choice": "auto",
+        }
+
+        start_time = time.time()
+        self._log_request_details(payload, start_time)
+
+        response = requests.post(
+            f"{self.base_url}/chat/completions", headers=headers, json=payload
+        )
+
+        if response.status_code != 200:
+            self.logger.error(f"OpenRouter API error: {response.text}")
+            raise Exception(f"OpenRouter API error: {response.text}")
+
+        response_data = response.json()
+        self._log_response_details(response_data, start_time)
+
+        return response_data
+
+    def continue_with_tool_result(self, tool_result: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Continue conversation with tool execution result.
+
+        Args:
+            tool_result: Tool execution result
+
+        Returns:
+            API response dictionary
+        """
+        # TODO: Implement continuation logic
+        return {}
+
+    def extract_tool_calls(self, response: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Extract tool calls from API response."""
+        tool_calls = []
+        if "choices" in response and response["choices"]:
+            choice = response["choices"][0]
+            if "message" in choice and "tool_calls" in choice["message"]:
+                tool_calls = choice["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")
+        else:
+            self.logger.debug("No choices found in response")
+        return tool_calls
+
+    def extract_content(self, response: Dict[str, Any]) -> str:
+        """Extract content from API response."""
+        if "choices" in response and response["choices"]:
+            choice = response["choices"][0]
+            if "message" in choice and "content" in choice["message"]:
+                return choice["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

todo_agent/infrastructure/prompts/system_prompt.txt

@@ -0,0 +1,51 @@
+You are a todo.sh assistant managing tasks in standard todo.txt format.
+
+CURRENT DATE/TIME: {current_datetime}
+
+CORE PRINCIPLES:
+1. **Strategic Tool Usage**: Batch discovery tools ([list_tasks, list_completed_tasks, list_projects, list_contexts]) to minimize API calls
+2. **Conversational**: Respond naturally without mentioning tools or technical details
+3. **Data Integrity**: Only reference tasks/projects/contexts returned by actual tool calls - NEVER hallucinate
+4. **Safety**: Always verify current state before modifications using list_tasks() and list_completed_tasks()
+5. **Todo.txt Compliance**: Use standard format and ordering
+
+TODO.TXT FORMAT:
+- Priority: (A), (B), (C) • Completion: "x YYYY-MM-DD" • Creation: YYYY-MM-DD
+- Projects: +project • Contexts: @context • Due dates: due:YYYY-MM-DD
+- Example: "(A) 2024-01-15 Call dentist +health @phone due:2024-01-20"
+
+WORKFLOW:
+**Discovery First**: Gather context with batched tool calls before any action
+**Verify Before Action**: Check for duplicates, conflicts, or existing completions
+**Sequential Processing**: Tools execute in order within batches
+
+CONTEXT INFERENCE:
+- Extract temporal urgency from due dates and creation dates
+- Identify task relationships through shared projects/contexts
+- Determine scope boundaries from natural language (work vs personal tasks)
+- Recognize priority patterns and dependencies
+
+TASK ADVICE:
+Think deeply and critically to categorize tasks and suggest actions:
+- Consider real-life implications and importance to my responsibilities regardless of explicit priority
+- When users request prioritization help, use Eisenhower Matrix:
+    Q1 (Urgent+Important: DO), Q2 (Important: SCHEDULE), Q3 (Urgent: DELEGATE), Q4 (Neither: ELIMINATE) [assign SPARINGLY].
+
+COMPLETED TASKS:
+When users mention past accomplishments ("I did XXX today"):
+1. add_task() with description
+2. complete_task() with same ID using "x YYYY-MM-DD" format
+
+ERROR HANDLING:
+- Empty results: Suggest next steps
+- Ambiguous requests: Show numbered options
+- Large lists: Use filtering/summaries for 10+ items
+- Failed operations: Explain clearly with alternatives
+
+CRITICAL RULES:
+- **Anti-hallucination**: If no tool data exists, say "I need to check your tasks first"
+- Use appropriate discovery tools extensively
+- Never assume task existence without verification
+- Maintain todo.txt standard compliance
+
+AVAILABLE TOOLS: {tools_section}

todo_agent/infrastructure/todo_shell.py

@@ -0,0 +1,151 @@
+"""
+Subprocess wrapper for todo.sh operations.
+"""
+
+import os
+import subprocess
+from typing import List, Optional
+
+try:
+    from todo_agent.core.exceptions import TodoShellError
+except ImportError:
+    from core.exceptions import TodoShellError
+
+
+class TodoShell:
+    """Subprocess execution wrapper with error management."""
+
+    def __init__(self, todo_file_path: str, logger=None):
+        self.todo_file_path = todo_file_path
+        self.todo_dir = os.path.dirname(todo_file_path) or os.getcwd()
+        self.logger = logger
+
+    def execute(self, command: List[str], cwd: Optional[str] = None) -> str:
+        """
+        Execute todo.sh command.
+
+        Args:
+            command: List of command arguments
+            cwd: Working directory (defaults to todo.sh directory)
+
+        Returns:
+            Command output as string
+
+        Raises:
+            TodoShellError: If command execution fails
+        """
+        # Log the raw command being executed
+        if self.logger:
+            raw_command = " ".join(command)
+            self.logger.debug(f"=== RAW COMMAND EXECUTION ===")
+            self.logger.debug(f"Raw command: {raw_command}")
+            self.logger.debug(f"Working directory: {cwd or self.todo_dir}")
+        
+        try:
+            working_dir = cwd or self.todo_dir
+            result = subprocess.run(
+                command, cwd=working_dir, capture_output=True, text=True, check=True
+            )
+            
+            # Log the raw output
+            if self.logger:
+                self.logger.debug(f"=== RAW COMMAND OUTPUT ===")
+                self.logger.debug(f"Raw command: {raw_command}")
+                self.logger.debug(f"Raw stdout: {result.stdout}")
+                self.logger.debug(f"Raw stderr: {result.stderr}")
+                self.logger.debug(f"Return code: {result.returncode}")
+            
+            return result.stdout.strip()
+        except subprocess.CalledProcessError as e:
+            # Log error details
+            if self.logger:
+                self.logger.error(f"=== COMMAND EXECUTION FAILED ===")
+                self.logger.error(f"Raw command: {' '.join(command)}")
+                self.logger.error(f"Error stderr: {e.stderr}")
+                self.logger.error(f"Error return code: {e.returncode}")
+            raise TodoShellError(f"Todo.sh command failed: {e.stderr}")
+        except Exception as e:
+            # Log error details
+            if self.logger:
+                self.logger.error(f"=== COMMAND EXECUTION EXCEPTION ===")
+                self.logger.error(f"Raw command: {' '.join(command)}")
+                self.logger.error(f"Exception: {str(e)}")
+            raise TodoShellError(f"Todo.sh command failed: {e}")
+
+    def add(self, description: str) -> str:
+        """Add new task."""
+        return self.execute(["todo.sh", "add", description])
+
+    def list_tasks(self, filter_str: Optional[str] = None) -> str:
+        """List tasks with optional filtering."""
+        command = ["todo.sh", "ls"]
+        if filter_str:
+            command.append(filter_str)
+        return self.execute(command)
+
+    def complete(self, task_number: int) -> str:
+        """Mark task complete."""
+        return self.execute(["todo.sh", "do", str(task_number)])
+
+    def replace(self, task_number: int, new_description: str) -> str:
+        """Replace task content."""
+        return self.execute(["todo.sh", "replace", str(task_number), new_description])
+
+    def append(self, task_number: int, text: str) -> str:
+        """Append text to task."""
+        return self.execute(["todo.sh", "append", str(task_number), text])
+
+    def prepend(self, task_number: int, text: str) -> str:
+        """Prepend text to task."""
+        return self.execute(["todo.sh", "prepend", str(task_number), text])
+
+    def delete(self, task_number: int, term: Optional[str] = None) -> str:
+        """Delete task or term."""
+        command = ["todo.sh", "-f", "del", str(task_number)]
+        if term:
+            command.append(term)
+        return self.execute(command)
+
+    def move(self, task_number: int, destination: str, source: Optional[str] = None) -> str:
+        """Move task from source to destination file."""
+        command = ["todo.sh", "-f", "move", str(task_number), destination]
+        if source:
+            command.append(source)
+        return self.execute(command)
+
+    def set_priority(self, task_number: int, priority: str) -> str:
+        """Set task priority."""
+        return self.execute(["todo.sh", "pri", str(task_number), priority])
+
+    def remove_priority(self, task_number: int) -> str:
+        """Remove task priority."""
+        return self.execute(["todo.sh", "depri", str(task_number)])
+
+    def list_projects(self) -> str:
+        """List projects."""
+        return self.execute(["todo.sh", "lsp"])
+
+    def list_contexts(self) -> str:
+        """List contexts."""
+        return self.execute(["todo.sh", "lsc"])
+
+    def list_completed(self, filter_str: Optional[str] = None) -> str:
+        """List completed tasks with optional filtering."""
+        command = ["todo.sh", "listfile", "done.txt"]
+        if filter_str:
+            command.append(filter_str)
+        return self.execute(command)
+
+    def archive(self) -> str:
+        """Archive completed tasks."""
+        return self.execute(["todo.sh", "-f", "archive"])
+
+    def deduplicate(self) -> str:
+        """Remove duplicate tasks."""
+        try:
+            return self.execute(["todo.sh", "-f", "deduplicate"])
+        except TodoShellError as e:
+            # Handle the case where no duplicates are found (not really an error)
+            if "No duplicate tasks found" in str(e):
+                return "No duplicate tasks found"
+            raise

todo_agent/infrastructure/token_counter.py

@@ -0,0 +1,184 @@
+"""
+Token counting utilities for accurate LLM token estimation.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+try:
+    import tiktoken
+except ImportError:
+    tiktoken = None
+
+
+class TokenCounter:
+    """Accurate token counting using tiktoken library."""
+
+    def __init__(self, model: str = "gpt-4"):
+        """
+        Initialize token counter for a specific model.
+        
+        Args:
+            model: Model name to use for tokenization (default: gpt-4)
+        """
+        self.model = model
+        self._encoder = None
+        self._initialize_encoder()
+
+    def _initialize_encoder(self) -> None:
+        """Initialize the tiktoken encoder for the specified model."""
+        if tiktoken is None:
+            raise ImportError(
+                "tiktoken library is required for accurate token counting. "
+                "Install it with: pip install tiktoken"
+            )
+        
+
+        self._encoder = tiktoken.get_encoding("cl100k_base")
+            
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens in text using accurate tokenization.
+        
+        Args:
+            text: Text to count tokens for
+            
+        Returns:
+            Number of tokens
+        """
+        if not text:
+            return 0
+        
+        return len(self._encoder.encode(text))
+
+    def count_message_tokens(self, message: Dict[str, Any]) -> int:
+        """
+        Count tokens in a single message (including role, content, and tool calls).
+        
+        Args:
+            message: Message dictionary with role, content, etc.
+            
+        Returns:
+            Number of tokens
+        """
+        tokens = 0
+        
+        # Count role tokens (typically 1-2 tokens)
+        role = message.get("role", "")
+        tokens += self.count_tokens(role)
+        
+        # Count content tokens
+        content = message.get("content", "")
+        if content:
+            tokens += self.count_tokens(content)
+        
+        # Count tool calls tokens
+        tool_calls = message.get("tool_calls", [])
+        for tool_call in tool_calls:
+            tokens += self.count_tool_call_tokens(tool_call)
+        
+        # Count tool call ID if present
+        tool_call_id = message.get("tool_call_id", "")
+        if tool_call_id:
+            tokens += self.count_tokens(tool_call_id)
+        
+        return tokens
+
+    def count_tool_call_tokens(self, tool_call: Dict[str, Any]) -> int:
+        """
+        Count tokens in a tool call.
+        
+        Args:
+            tool_call: Tool call dictionary
+            
+        Returns:
+            Number of tokens
+        """
+        tokens = 0
+        
+        # Count tool call ID
+        tool_call_id = tool_call.get("id", "")
+        tokens += self.count_tokens(tool_call_id)
+        
+        # Count function call
+        function = tool_call.get("function", {})
+        if function:
+            # Count function name
+            function_name = function.get("name", "")
+            tokens += self.count_tokens(function_name)
+            
+            # Count function arguments
+            arguments = function.get("arguments", "")
+            if arguments:
+                tokens += self.count_tokens(arguments)
+        
+        return tokens
+
+    def count_messages_tokens(self, messages: List[Dict[str, Any]]) -> int:
+        """
+        Count total tokens in a list of messages.
+        
+        Args:
+            messages: List of message dictionaries
+            
+        Returns:
+            Total number of tokens
+        """
+        total_tokens = 0
+        
+        for message in messages:
+            total_tokens += self.count_message_tokens(message)
+        
+        return total_tokens
+
+    def count_tools_tokens(self, tools: List[Dict[str, Any]]) -> int:
+        """
+        Count tokens in tool definitions.
+        
+        Args:
+            tools: List of tool definition dictionaries
+            
+        Returns:
+            Number of tokens
+        """
+        if not tools:
+            return 0
+        
+        # Convert tools to JSON string and count tokens
+        tools_json = json.dumps(tools, separators=(',', ':'))
+        return self.count_tokens(tools_json)
+
+    def count_request_tokens(
+        self, 
+        messages: List[Dict[str, Any]], 
+        tools: Optional[List[Dict[str, Any]]] = None
+    ) -> int:
+        """
+        Count total tokens in a complete request (messages + tools).
+        
+        Args:
+            messages: List of message dictionaries
+            tools: Optional list of tool definitions
+            
+        Returns:
+            Total number of tokens
+        """
+        total_tokens = self.count_messages_tokens(messages)
+        
+        if tools:
+            total_tokens += self.count_tools_tokens(tools)
+        
+        return total_tokens
+
+
+def get_token_counter(model: str = "gpt-4") -> TokenCounter:
+    """
+    Get a token counter instance for the specified model.
+    
+    Args:
+        model: Model name to use for tokenization
+        
+    Returns:
+        TokenCounter instance
+    """
+    return TokenCounter(model)

todo_agent/interface/__init__.py

@@ -0,0 +1,10 @@
+"""
+Interface layer for todo.sh LLM agent.
+
+This module contains user interfaces and presentation logic.
+"""
+
+from .cli import CLI
+from .tools import ToolCallHandler
+
+__all__ = ["CLI", "ToolCallHandler"]