todo-agent 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

todo_agent/infrastructure/token_counter.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional
 try:
     import tiktoken
 except ImportError:
-    tiktoken = None
+    tiktoken = None  # type: ignore
 
 
 class TokenCounter:
@@ -17,12 +17,12 @@ class TokenCounter:
     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._encoder: Optional[Any] = None
         self._initialize_encoder()
 
     def _initialize_encoder(self) -> None:
@@ -32,152 +32,153 @@ class TokenCounter:
                 "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
-        
+
+        if self._encoder is None:
+            raise RuntimeError("Encoder not initialized")
         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=(',', ':'))
+        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
+        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
     """

todo_agent/interface/cli.py

@@ -2,42 +2,39 @@
 Command-line interface for todo.sh LLM agent.
 """
 
-import threading
-import time
-from typing import Optional
-
 try:
     from rich.console import Console
     from rich.live import Live
     from rich.spinner import Spinner
     from rich.text import Text
+
     from todo_agent.core.todo_manager import TodoManager
     from todo_agent.infrastructure.config import Config
-    from todo_agent.infrastructure.todo_shell import TodoShell
-    from todo_agent.infrastructure.logger import Logger
     from todo_agent.infrastructure.inference import Inference
+    from todo_agent.infrastructure.logger import Logger
+    from todo_agent.infrastructure.todo_shell import TodoShell
     from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
+    from core.todo_manager import TodoManager  # type: ignore[no-redef]
+    from infrastructure.config import Config  # type: ignore[no-redef]
+    from infrastructure.inference import Inference  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from infrastructure.todo_shell import TodoShell  # type: ignore[no-redef]
+    from interface.tools import ToolCallHandler  # type: ignore[no-redef]
     from rich.console import Console
     from rich.live import Live
     from rich.spinner import Spinner
     from rich.text import Text
-    from core.todo_manager import TodoManager
-    from infrastructure.config import Config
-    from infrastructure.todo_shell import TodoShell
-    from infrastructure.logger import Logger
-    from infrastructure.inference import Inference
-    from interface.tools import ToolCallHandler
 
 
 class CLI:
     """User interaction loop and input/output handling."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Initialize logger first
         self.logger = Logger("cli")
         self.logger.info("Initializing CLI")
-        
+
         self.config = Config()
         self.config.validate()
         self.logger.debug("Configuration validated")
@@ -85,9 +82,7 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
-
-
-    def run(self):
+    def run(self) -> None:
         """Main CLI interaction loop."""
         self.logger.info("Starting CLI interaction loop")
         print("Todo.sh LLM Agent - Type 'quit' to exit")
@@ -122,15 +117,28 @@ class CLI:
                     print(f"  Assistant messages: {summary['assistant_messages']}")
                     print(f"  Tool messages: {summary['tool_messages']}")
                     print(f"  Estimated tokens: {summary['estimated_tokens']}")
-                    
+
                     # Display thinking time statistics if available
-                    if 'thinking_time_count' in summary and summary['thinking_time_count'] > 0:
+                    if (
+                        "thinking_time_count" in summary
+                        and summary["thinking_time_count"] > 0
+                    ):
                         print(f"  Thinking time stats:")
-                        print(f"    Total thinking time: {summary['total_thinking_time']:.2f}s")
-                        print(f"    Average thinking time: {summary['average_thinking_time']:.2f}s")
-                        print(f"    Min thinking time: {summary['min_thinking_time']:.2f}s")
-                        print(f"    Max thinking time: {summary['max_thinking_time']:.2f}s")
-                        print(f"    Requests with timing: {summary['thinking_time_count']}")
+                        print(
+                            f"    Total thinking time: {summary['total_thinking_time']:.2f}s"
+                        )
+                        print(
+                            f"    Average thinking time: {summary['average_thinking_time']:.2f}s"
+                        )
+                        print(
+                            f"    Min thinking time: {summary['min_thinking_time']:.2f}s"
+                        )
+                        print(
+                            f"    Max thinking time: {summary['max_thinking_time']:.2f}s"
+                        )
+                        print(
+                            f"    Requests with timing: {summary['thinking_time_count']}"
+                        )
                     continue
 
                 if user_input.lower() == "help":
@@ -150,11 +158,13 @@ class CLI:
                         output = self.todo_shell.list_tasks()
                         print(output)
                     except Exception as e:
-                        self.logger.error(f"Error listing tasks: {str(e)}")
-                        print(f"Error: Failed to list tasks: {str(e)}")
+                        self.logger.error(f"Error listing tasks: {e!s}")
+                        print(f"Error: Failed to list tasks: {e!s}")
                     continue
 
-                self.logger.info(f"Processing user request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}")
+                self.logger.info(
+                    f"Processing user request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}"
+                )
                 response = self.handle_request(user_input)
                 print(response)
 
@@ -163,8 +173,8 @@ class CLI:
                 print("\nGoodbye!")
                 break
             except Exception as e:
-                self.logger.error(f"Error in CLI loop: {str(e)}")
-                print(f"Error: {str(e)}")
+                self.logger.error(f"Error in CLI loop: {e!s}")
+                print(f"Error: {e!s}")
 
     def handle_request(self, user_input: str) -> str:
         """
@@ -181,20 +191,22 @@ class CLI:
             try:
                 # Process request through inference engine
                 response, thinking_time = self.inference.process_request(user_input)
-                
+
                 # Update spinner with completion message and thinking time
-                live.update(self._create_thinking_spinner(f"(thought for {thinking_time:.1f}s)"))
-                
+                live.update(
+                    self._create_thinking_spinner(f"(thought for {thinking_time:.1f}s)")
+                )
+
                 return response
             except Exception as e:
                 # Update spinner with error message
                 live.update(self._create_thinking_spinner("Request failed"))
-                
+
                 # Log the error
-                self.logger.error(f"Error in handle_request: {str(e)}")
-                
+                self.logger.error(f"Error in handle_request: {e!s}")
+
                 # Return error message
-                return f"Error: {str(e)}"
+                return f"Error: {e!s}"
 
     def run_single_request(self, user_input: str) -> str:
         """
@@ -206,5 +218,7 @@ class CLI:
         Returns:
             Formatted response
         """
-        self.logger.info(f"Running single request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}")
+        self.logger.info(
+            f"Running single request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}"
+        )
         return self.handle_request(user_input)

todo_agent/interface/tools.py

@@ -2,14 +2,14 @@
 Tool definitions and schemas for LLM function calling.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 try:
     from todo_agent.core.todo_manager import TodoManager
     from todo_agent.infrastructure.logger import Logger
 except ImportError:
-    from core.todo_manager import TodoManager
-    from infrastructure.logger import Logger
+    from core.todo_manager import TodoManager  # type: ignore[no-redef]
+    from infrastructure.logger import Logger  # type: ignore[no-redef]
 
 
 class ToolCallHandler:
@@ -36,7 +36,7 @@ class ToolCallHandler:
                         "to avoid asking the user for clarification when you can find the answer yourself."
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
-                }
+                },
             },
             {
                 "type": "function",
@@ -51,7 +51,7 @@ class ToolCallHandler:
                         "to avoid asking the user for clarification when you can find the answer yourself."
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
-                }
+                },
             },
             {
                 "type": "function",
@@ -82,7 +82,7 @@ class ToolCallHandler:
                         },
                         "required": [],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -155,7 +155,7 @@ class ToolCallHandler:
                         },
                         "required": [],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -198,7 +198,7 @@ class ToolCallHandler:
                         },
                         "required": ["description"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -222,7 +222,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -247,7 +247,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number", "new_description"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -271,7 +271,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number", "text"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -295,7 +295,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number", "text"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -323,7 +323,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -348,7 +348,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number", "priority"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -368,7 +368,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -379,7 +379,7 @@ class ToolCallHandler:
                         "an overview, summary, or statistics about their tasks."
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
-                }
+                },
             },
             {
                 "type": "function",
@@ -408,7 +408,7 @@ class ToolCallHandler:
                         },
                         "required": ["task_number", "destination"],
                     },
-                }
+                },
             },
             {
                 "type": "function",
@@ -420,7 +420,7 @@ class ToolCallHandler:
                         "their todo list or archive completed tasks."
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
-                }
+                },
             },
             {
                 "type": "function",
@@ -432,16 +432,15 @@ class ToolCallHandler:
                         "in the list."
                     ),
                     "parameters": {"type": "object", "properties": {}, "required": []},
-                }
+                },
             },
-
         ]
 
     def _format_tool_signature(self, tool_name: str, arguments: Dict[str, Any]) -> str:
         """Format tool signature with parameters for logging."""
         if not arguments:
             return f"{tool_name}()"
-        
+
         # Format parameters as key=value pairs
         param_parts = []
         for key, value in arguments.items():
@@ -450,7 +449,7 @@ class ToolCallHandler:
                 param_parts.append(f"{key}='{value}'")
             else:
                 param_parts.append(f"{key}={value}")
-        
+
         return f"{tool_name}({', '.join(param_parts)})"
 
     def execute_tool(self, tool_call: Dict[str, Any]) -> Dict[str, Any]:
@@ -458,10 +457,11 @@ class ToolCallHandler:
         tool_name = tool_call["function"]["name"]
         arguments = tool_call["function"]["arguments"]
         tool_call_id = tool_call.get("id", "unknown")
-        
+
         # Handle arguments that might be a string (JSON) or already a dict
         if isinstance(arguments, str):
             import json
+
             try:
                 arguments = json.loads(arguments)
                 if self.logger:
@@ -470,10 +470,10 @@ class ToolCallHandler:
                 if self.logger:
                     self.logger.warning(f"Failed to parse JSON arguments: {e}")
                 arguments = {}
-        
+
         # Format tool signature with parameters
         tool_signature = self._format_tool_signature(tool_name, arguments)
-        
+
         # Log function name with signature at INFO level
         if self.logger:
             self.logger.info(f"Executing tool: {tool_signature} (ID: {tool_call_id})")
@@ -486,7 +486,7 @@ class ToolCallHandler:
             self.logger.debug(f"Arguments: {tool_call['function']['arguments']}")
 
         # Map tool names to todo_manager methods
-        method_map = {
+        method_map: Dict[str, Callable[..., Any]] = {
             "list_projects": self.todo_manager.list_projects,
             "list_contexts": self.todo_manager.list_contexts,
             "list_tasks": self.todo_manager.list_tasks,
@@ -515,50 +515,57 @@ class ToolCallHandler:
                 "output": f"ERROR: {error_msg}",
                 "error": True,
                 "error_type": "unknown_tool",
-                "error_details": error_msg
+                "error_details": error_msg,
             }
 
         method = method_map[tool_name]
-        
+
         # Log method call details
         if self.logger:
             self.logger.debug(f"Calling method: {tool_name}")
-        
+
         try:
             result = method(**arguments)
-            
+
             # Log successful output at DEBUG level
             if self.logger:
                 self.logger.debug(f"=== TOOL EXECUTION SUCCESS ===")
                 self.logger.debug(f"Tool: {tool_name}")
                 self.logger.debug(f"Raw result: ====\n{result}\n====")
-                
+
                 # For list results, log the count
                 if isinstance(result, list):
                     self.logger.debug(f"Result count: {len(result)}")
                 # For string results, log the length
                 elif isinstance(result, str):
                     self.logger.debug(f"Result length: {len(result)}")
-                    
-            return {"tool_call_id": tool_call_id, "name": tool_name, "output": result, "error": False}
-                    
+
+            return {
+                "tool_call_id": tool_call_id,
+                "name": tool_name,
+                "output": result,
+                "error": False,
+            }
+
         except Exception as e:
             # Log error details
             if self.logger:
                 self.logger.error(f"=== TOOL EXECUTION FAILED ===")
                 self.logger.error(f"Tool: {tool_name}")
                 self.logger.error(f"Error type: {type(e).__name__}")
-                self.logger.error(f"Error message: {str(e)}")
+                self.logger.error(f"Error message: {e!s}")
                 self.logger.exception(f"Exception details for {tool_name}")
-            
+
             # Return structured error information instead of raising
             error_type = type(e).__name__
             error_message = str(e)
-            
+
             # Provide user-friendly error messages based on error type
             if "FileNotFoundError" in error_type or "todo.sh" in error_message.lower():
                 user_message = f"Todo.sh command failed: {error_message}. Please ensure todo.sh is properly installed and configured."
-            elif "IndexError" in error_type or "task" in error_message.lower() and "not found" in error_message.lower():
+            elif "IndexError" in error_type or (
+                "task" in error_message.lower() and "not found" in error_message.lower()
+            ):
                 user_message = f"Task not found: {error_message}. The task may have been completed or deleted."
             elif "ValueError" in error_type:
                 user_message = f"Invalid input: {error_message}. Please check the task format or parameters."
@@ -566,7 +573,7 @@ class ToolCallHandler:
                 user_message = f"Permission denied: {error_message}. Please check file permissions for todo.txt files."
             else:
                 user_message = f"Operation failed: {error_message}"
-            
+
             return {
                 "tool_call_id": tool_call_id,
                 "name": tool_name,
@@ -574,5 +581,5 @@ class ToolCallHandler:
                 "error": True,
                 "error_type": error_type,
                 "error_details": error_message,
-                "user_message": user_message
+                "user_message": user_message,
             }

todo_agent/main.py

@@ -9,7 +9,7 @@ import sys
 from .interface.cli import CLI
 
 
-def main():
+def main() -> None:
     """Main application entry point."""
     parser = argparse.ArgumentParser(
         description="Todo.sh LLM Agent - Natural language task management",