todo-agent 0.1.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

todo_agent/infrastructure/llm_client_factory.py

@@ -7,15 +7,17 @@ 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
+    from todo_agent.infrastructure.ollama_client import OllamaClient
+    from todo_agent.infrastructure.openrouter_client import OpenRouterClient
 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
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from infrastructure.ollama_client import OllamaClient  # type: ignore[no-redef]
+    from infrastructure.openrouter_client import (  # type: ignore[no-redef]
+        OpenRouterClient,
+    )
 
 
 class LLMClientFactory:
@@ -37,9 +39,11 @@ class LLMClientFactory:
             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}")
+            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}")

todo_agent/infrastructure/logger.py

@@ -6,40 +6,39 @@ 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):
+
+    def _ensure_logs_directory(self) -> None:
         """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")
@@ -48,81 +47,79 @@ class Logger:
         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
+            "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):
+
+    def _setup_file_handler(self) -> None:
         """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'
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
         )
         file_handler.setFormatter(file_formatter)
-        
+
         self.logger.addHandler(file_handler)
-    
-    def _setup_console_handler(self):
+
+    def _setup_console_handler(self) -> None:
         """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_formatter = logging.Formatter("%(levelname)s - %(message)s")
         console_handler.setFormatter(console_formatter)
-        
+
         self.logger.addHandler(console_handler)
-    
-    def debug(self, message: str):
+
+    def debug(self, message: str) -> None:
         """Log a debug message."""
         self.logger.debug(message)
-    
-    def info(self, message: str):
+
+    def info(self, message: str) -> None:
         """Log an info message."""
         self.logger.info(message)
-    
-    def warning(self, message: str):
+
+    def warning(self, message: str) -> None:
         """Log a warning message."""
         self.logger.warning(message)
-    
-    def error(self, message: str):
+
+    def error(self, message: str) -> None:
         """Log an error message."""
         self.logger.error(message)
-    
-    def critical(self, message: str):
+
+    def critical(self, message: str) -> None:
         """Log a critical message."""
         self.logger.critical(message)
-    
-    def exception(self, message: str):
+
+    def exception(self, message: str) -> None:
         """Log an exception message with traceback."""
         self.logger.exception(message)

todo_agent/infrastructure/ollama_client.py

@@ -10,14 +10,14 @@ import requests
 
 try:
     from todo_agent.infrastructure.config import Config
+    from todo_agent.infrastructure.llm_client import LLMClient
     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
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from infrastructure.token_counter import get_token_counter  # type: ignore[no-redef]
 
 
 class OllamaClient(LLMClient):
@@ -48,7 +48,7 @@ class OllamaClient(LLMClient):
         """
         return self.token_counter.count_tokens(text)
 
-    def _log_request_details(self, payload: Dict[str, Any], start_time: float):
+    def _log_request_details(self, payload: Dict[str, Any], start_time: float) -> None:
         """Log request details including accurate token count."""
         # Count tokens for messages
         messages = payload.get("messages", [])
@@ -59,7 +59,9 @@ class OllamaClient(LLMClient):
         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):
+    def _log_response_details(
+        self, response: Dict[str, Any], start_time: float
+    ) -> None:
         """Log response details including latency."""
         end_time = time.time()
         latency_ms = (end_time - start_time) * 1000
@@ -72,10 +74,12 @@ class OllamaClient(LLMClient):
             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}")
+                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"Response contains content: {content[:100]}{'...' if len(content) > 100 else ''}"
+            )
 
         self.logger.debug(f"Raw response: {json.dumps(response, indent=2)}")
 
@@ -106,7 +110,7 @@ class OllamaClient(LLMClient):
         start_time = time.time()
         self._log_request_details(payload, start_time)
 
-        response = requests.post(
+        response = requests.post(  # nosec B113
             f"{self.base_url}/api/chat", headers=headers, json=payload
         )
 
@@ -114,7 +118,7 @@ class OllamaClient(LLMClient):
             self.logger.error(f"Ollama API error: {response.text}")
             raise Exception(f"Ollama API error: {response.text}")
 
-        response_data = response.json()
+        response_data: Dict[str, Any] = response.json()
         self._log_response_details(response_data, start_time)
 
         return response_data
@@ -122,7 +126,7 @@ class OllamaClient(LLMClient):
     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"]
@@ -130,16 +134,19 @@ class OllamaClient(LLMClient):
             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})")
+                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"]
+            content = response["message"]["content"]
+            return content if isinstance(content, str) else str(content)
         return ""
 
     def get_model_name(self) -> str:

todo_agent/infrastructure/openrouter_client.py

@@ -10,14 +10,14 @@ import requests
 
 try:
     from todo_agent.infrastructure.config import Config
+    from todo_agent.infrastructure.llm_client import LLMClient
     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
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from infrastructure.token_counter import get_token_counter  # type: ignore[no-redef]
 
 
 class OpenRouterClient(LLMClient):
@@ -34,53 +34,59 @@ class OpenRouterClient(LLMClient):
     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):
+    def _log_request_details(self, payload: Dict[str, Any], start_time: float) -> None:
         """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):
+    def _log_response_details(
+        self, response: Dict[str, Any], start_time: float
+    ) -> None:
         """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}")
-        
+        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"]:
+        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")
                 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}")
+                    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"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(
@@ -111,7 +117,7 @@ class OpenRouterClient(LLMClient):
         start_time = time.time()
         self._log_request_details(payload, start_time)
 
-        response = requests.post(
+        response = requests.post(  # nosec B113
             f"{self.base_url}/chat/completions", headers=headers, json=payload
         )
 
@@ -119,7 +125,7 @@ class OpenRouterClient(LLMClient):
             self.logger.error(f"OpenRouter API error: {response.text}")
             raise Exception(f"OpenRouter API error: {response.text}")
 
-        response_data = response.json()
+        response_data: Dict[str, Any] = response.json()
         self._log_response_details(response_data, start_time)
 
         return response_data
@@ -140,15 +146,19 @@ class OpenRouterClient(LLMClient):
     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"]:
+        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.debug(f"Extracted {len(tool_calls)} tool calls from response")
+                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})")
+                    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:
@@ -157,10 +167,11 @@ class OpenRouterClient(LLMClient):
 
     def extract_content(self, response: Dict[str, Any]) -> str:
         """Extract content from API response."""
-        if "choices" in response and response["choices"]:
+        if response.get("choices"):
             choice = response["choices"][0]
             if "message" in choice and "content" in choice["message"]:
-                return choice["message"]["content"]
+                content = choice["message"]["content"]
+                return content if isinstance(content, str) else str(content)
         return ""
 
     def get_model_name(self) -> str:

todo_agent/infrastructure/todo_shell.py

@@ -3,19 +3,19 @@ Subprocess wrapper for todo.sh operations.
 """
 
 import os
-import subprocess
-from typing import List, Optional
+import subprocess  # nosec B404
+from typing import Any, List, Optional
 
 try:
     from todo_agent.core.exceptions import TodoShellError
 except ImportError:
-    from core.exceptions import TodoShellError
+    from core.exceptions import TodoShellError  # type: ignore[no-redef]
 
 
 class TodoShell:
     """Subprocess execution wrapper with error management."""
 
-    def __init__(self, todo_file_path: str, logger=None):
+    def __init__(self, todo_file_path: str, logger: Optional[Any] = None) -> None:
         self.todo_file_path = todo_file_path
         self.todo_dir = os.path.dirname(todo_file_path) or os.getcwd()
         self.logger = logger
@@ -40,13 +40,13 @@ class TodoShell:
             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(
+            result = subprocess.run(  # nosec B603
                 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 ===")
@@ -54,7 +54,7 @@ class TodoShell:
                 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
@@ -69,7 +69,7 @@ class TodoShell:
             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)}")
+                self.logger.error(f"Exception: {e!s}")
             raise TodoShellError(f"Todo.sh command failed: {e}")
 
     def add(self, description: str) -> str:
@@ -106,7 +106,9 @@ class TodoShell:
             command.append(term)
         return self.execute(command)
 
-    def move(self, task_number: int, destination: str, source: Optional[str] = None) -> str:
+    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: