tunacode-cli 0.0.50__py3-none-any.whl → 0.0.53__py3-none-any.whl

tunacode/core/agents/utils.py

@@ -35,8 +35,48 @@ def get_agent_tool():
 
 
 def get_model_messages():
+    """
+    Safely retrieve message-related classes from pydantic_ai.
+
+    If the running environment (e.g. our test stubs) does not define
+    SystemPromptPart we create a minimal placeholder so that the rest of the
+    code can continue to work without depending on the real implementation.
+    """
     messages = importlib.import_module("pydantic_ai.messages")
-    return messages.ModelRequest, messages.ToolReturnPart
+
+    # Create minimal fallbacks for missing message part classes
+    # SystemPromptPart
+    if not hasattr(messages, "SystemPromptPart"):
+
+        class SystemPromptPart:  # type: ignore
+            def __init__(self, content: str = "", role: str = "system", part_kind: str = ""):
+                self.content = content
+                self.role = role
+                self.part_kind = part_kind
+
+            def __repr__(self) -> str:  # pragma: no cover
+                return f"SystemPromptPart(content={self.content!r})"
+
+        SystemPromptPart.__module__ = messages.__name__
+        setattr(messages, "SystemPromptPart", SystemPromptPart)
+
+    # UserPromptPart
+    if not hasattr(messages, "UserPromptPart"):
+
+        class UserPromptPart:  # type: ignore
+            def __init__(self, content: str = "", role: str = "user", part_kind: str = ""):
+                self.content = content
+                self.role = role
+                self.part_kind = part_kind
+
+            def __repr__(self) -> str:  # pragma: no cover
+                return f"UserPromptPart(content={self.content!r})"
+
+        UserPromptPart.__module__ = messages.__name__
+        setattr(messages, "UserPromptPart", UserPromptPart)
+
+    # Finally, return the relevant classes so callers can use them directly
+    return messages.ModelRequest, messages.ToolReturnPart, messages.SystemPromptPart
 
 
 async def execute_tools_parallel(
@@ -335,7 +375,7 @@ def patch_tool_messages(
     for tool_call_id, tool_name in list(tool_calls.items()):
         if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
             # Import ModelRequest and ToolReturnPart lazily
-            model_request_cls, tool_return_part_cls = get_model_messages()
+            model_request_cls, tool_return_part_cls, _ = get_model_messages()
             messages.append(
                 model_request_cls(
                     parts=[

tunacode/core/background/manager.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import uuid
 from collections import defaultdict
-from typing import Awaitable, Callable, Dict, List
+from typing import Any, Callable, Coroutine, Dict, List
 
 
 class BackgroundTaskManager:
@@ -15,9 +15,9 @@ class BackgroundTaskManager:
         self.tasks: Dict[str, asyncio.Task] = {}
         self.listeners: Dict[str, List[Callable[[asyncio.Task], None]]] = defaultdict(list)
 
-    def spawn(self, coro: Awaitable, *, name: str | None = None) -> str:
+    def spawn(self, coro: Coroutine[Any, Any, Any], *, name: str | None = None) -> str:
         task_id = name or uuid.uuid4().hex[:8]
-        task = asyncio.create_task(coro, name=task_id)
+        task: asyncio.Task = asyncio.create_task(coro, name=task_id)
         self.tasks[task_id] = task
         task.add_done_callback(self._notify)
         return task_id

tunacode/core/logging/__init__.py

@@ -1,21 +1,22 @@
 import logging
+from typing import Any
 
 # Custom log level: THOUGHT
 THOUGHT = 25
 logging.addLevelName(THOUGHT, "THOUGHT")
 
 
-def thought(self, message, *args, **kwargs):
+def thought(self: logging.Logger, message: str, *args: Any, **kwargs: Any) -> None:
     if self.isEnabledFor(THOUGHT):
         self._log(THOUGHT, message, args, **kwargs)
 
 
-logging.Logger.thought = thought
+setattr(logging.Logger, "thought", thought)
 
 
 # RichHandler for UI output (stub, real implementation in handlers.py)
 class RichHandler(logging.Handler):
-    def emit(self, record):
+    def emit(self, _record):
         # Actual implementation in handlers.py
         pass
 

tunacode/core/logging/config.py

@@ -1,19 +1,38 @@
 import logging
 import logging.config
-import os
-
-import yaml
 
 from tunacode.utils import user_configuration
 
-DEFAULT_CONFIG_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
-)
+# Default logging configuration when none is provided
+DEFAULT_LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "simple": {"format": "[%(levelname)s] %(message)s"},
+        "detailed": {"format": "[%(asctime)s] [%(levelname)s] [%(name)s:%(lineno)d] - %(message)s"},
+    },
+    "handlers": {
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "level": "DEBUG",
+            "formatter": "detailed",
+            "filename": "tunacode.log",
+            "maxBytes": 10485760,  # 10MB
+            "backupCount": 5,
+        }
+    },
+    "root": {"level": "DEBUG", "handlers": ["file"]},
+    "loggers": {
+        "tunacode.ui": {"level": "INFO", "propagate": False},
+        "tunacode.tools": {"level": "DEBUG"},
+        "tunacode.core.agents": {"level": "DEBUG"},
+    },
+}
 
 
 class LogConfig:
     @staticmethod
-    def load(config_path=None):
+    def load(_config_path=None):
         """
         Load logging configuration based on user preferences.
         If logging is disabled (default), use minimal configuration.
@@ -43,15 +62,9 @@ class LogConfig:
                 print(f"Failed to configure custom logging: {e}")
                 logging.basicConfig(level=logging.INFO)
         else:
-            # Use default configuration from YAML file
-            path = config_path or DEFAULT_CONFIG_PATH
-            if not os.path.exists(path):
-                raise FileNotFoundError(f"Logging config file not found: {path}")
-            with open(path, "r") as f:
-                config = yaml.safe_load(f)
-            logging_config = config.get("logging", config)
+            # Use default configuration
             try:
-                logging.config.dictConfig(logging_config)
+                logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
             except Exception as e:
-                print(f"Failed to configure logging: {e}")
+                print(f"Failed to configure default logging: {e}")
                 logging.basicConfig(level=logging.INFO)

tunacode/core/logging/formatters.py

@@ -32,7 +32,7 @@ try:
 except ImportError:
     import json
 
-    class JSONFormatter(logging.Formatter):
+    class JSONFormatter(logging.Formatter):  # type: ignore[no-redef]
         """
         Fallback JSON formatter if pythonjsonlogger is not installed.
         """

tunacode/core/logging/handlers.py

@@ -26,11 +26,29 @@ class RichHandler(logging.Handler):
         super().__init__(level)
         self.console = Console()
 
+    def _safe_str(self, value):
+        """Coerce any value to a safe string representation."""
+        try:
+            if value is None:
+                return ""
+            return str(value)
+        except Exception:
+            return ""
+
     def emit(self, record):
         try:
+            # Defensive normalization of record fields to avoid None propagation
+            record.levelname = self._safe_str(getattr(record, "levelname", "INFO")) or "INFO"
             icon = self.level_icons.get(record.levelname, "")
             timestamp = self.formatTime(record)
+
+            # Ensure message formatting never returns None
             msg = self.format(record)
+            if msg is None:
+                msg = ""
+
+            msg = self._safe_str(msg)
+
             if icon:
                 output = f"[{timestamp}] {icon} {msg}"
             else:
@@ -41,9 +59,9 @@ class RichHandler(logging.Handler):
             if just_finished_streaming:
                 _streaming_context["just_finished"] = False  # Reset after use
                 # Don't add extra newline when transitioning from streaming
-                self.console.print(Text(output), end="\n")
+                self.console.print(Text(self._safe_str(output)), end="\n")
             else:
-                self.console.print(Text(output))
+                self.console.print(Text(self._safe_str(output)))
         except Exception:
             self.handleError(record)
 
@@ -61,15 +79,31 @@ class StructuredFileHandler(logging.FileHandler):
     Handler that outputs logs as structured JSON lines.
     """
 
+    def _coerce_json_safe(self, value):
+        """Ensure values are JSON-serializable and not None."""
+        if value is None:
+            return ""
+        try:
+            json.dumps(value)
+            return value
+        except Exception:
+            try:
+                return str(value)
+            except Exception:
+                return ""
+
     def emit(self, record):
         try:
+            # Normalize fields to avoid None values in JSON
             log_entry = {
                 "timestamp": self.formatTime(record),
-                "level": record.levelname,
-                "name": record.name,
-                "line": record.lineno,
-                "message": record.getMessage(),
-                "extra_data": getattr(record, "extra", {}),
+                "level": self._coerce_json_safe(getattr(record, "levelname", "")),
+                "name": self._coerce_json_safe(getattr(record, "name", "")),
+                "line": int(getattr(record, "lineno", 0) or 0),
+                "message": self._coerce_json_safe(
+                    record.getMessage() if hasattr(record, "getMessage") else ""
+                ),
+                "extra_data": self._coerce_json_safe(getattr(record, "extra", {})),
             }
             self.stream.write(json.dumps(log_entry) + "\n")
             self.flush()

tunacode/core/setup/__init__.py

@@ -4,6 +4,7 @@ from .config_setup import ConfigSetup
 from .coordinator import SetupCoordinator
 from .environment_setup import EnvironmentSetup
 from .git_safety_setup import GitSafetySetup
+from .template_setup import TemplateSetup
 
 __all__ = [
     "BaseSetup",
@@ -12,4 +13,5 @@ __all__ = [
     "EnvironmentSetup",
     "GitSafetySetup",
     "AgentSetup",
+    "TemplateSetup",
 ]

tunacode/core/setup/agent_setup.py

@@ -22,11 +22,11 @@ class AgentSetup(BaseSetup):
     def name(self) -> str:
         return "Agent"
 
-    async def should_run(self, force_setup: bool = False) -> bool:
+    async def should_run(self, _force_setup: bool = False) -> bool:
         """Agent setup should run if an agent is provided."""
         return self.agent is not None
 
-    async def execute(self, force_setup: bool = False) -> None:
+    async def execute(self, _force_setup: bool = False) -> None:
         """Initialize the agent with the current model."""
         if self.agent is not None:
             await ui.info(f"Initializing Agent({self.state_manager.session.current_model})")

tunacode/core/setup/base.py

@@ -22,12 +22,12 @@ class BaseSetup(ABC):
         pass
 
     @abstractmethod
-    async def should_run(self, force_setup: bool = False) -> bool:
+    async def should_run(self, _force_setup: bool = False) -> bool:
         """Determine if this setup step should run."""
         pass
 
     @abstractmethod
-    async def execute(self, force_setup: bool = False) -> None:
+    async def execute(self, _force_setup: bool = False) -> None:
         """Execute the setup step."""
         pass
 

tunacode/core/setup/config_setup.py

@@ -272,17 +272,21 @@ class ConfigSetup(BaseSetup):
             self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
 
         # Apply CLI overrides
-        if self.cli_config.get("key"):
+        if self.cli_config and self.cli_config.get("key"):
             # Ensure env dict exists
             if "env" not in self.state_manager.session.user_config:
                 self.state_manager.session.user_config["env"] = {}
 
             # Determine which API key to set based on the model or baseurl
-            if self.cli_config.get("baseurl") and "openrouter" in self.cli_config["baseurl"]:
+            if (
+                self.cli_config
+                and self.cli_config.get("baseurl")
+                and "openrouter" in self.cli_config["baseurl"]
+            ):
                 self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = (
                     self.cli_config["key"]
                 )
-            elif self.cli_config.get("model"):
+            elif self.cli_config and self.cli_config.get("model"):
                 if "claude" in self.cli_config["model"] or "anthropic" in self.cli_config["model"]:
                     self.state_manager.session.user_config["env"]["ANTHROPIC_API_KEY"] = (
                         self.cli_config["key"]
@@ -301,12 +305,12 @@ class ConfigSetup(BaseSetup):
                         self.cli_config["key"]
                     )
 
-        if self.cli_config.get("baseurl"):
+        if self.cli_config and self.cli_config.get("baseurl"):
             self.state_manager.session.user_config["env"]["OPENAI_BASE_URL"] = self.cli_config[
                 "baseurl"
             ]
 
-        if self.cli_config.get("model"):
+        if self.cli_config and self.cli_config.get("model"):
             model = self.cli_config["model"]
             # Require provider prefix
             if ":" not in model:
@@ -318,7 +322,7 @@ class ConfigSetup(BaseSetup):
 
             self.state_manager.session.user_config["default_model"] = model
 
-        if self.cli_config.get("custom_context_window"):
+        if self.cli_config and self.cli_config.get("custom_context_window"):
             self.state_manager.session.user_config["context_window_size"] = self.cli_config[
                 "custom_context_window"
             ]

tunacode/core/setup/git_safety_setup.py

@@ -32,12 +32,12 @@ class GitSafetySetup(BaseSetup):
         """Return the name of this setup step."""
         return "Git Safety"
 
-    async def should_run(self, force: bool = False) -> bool:
+    async def should_run(self, _force: bool = False) -> bool:
         """Check if we should run git safety setup."""
         # Always run unless user has explicitly disabled it
         return not self.state_manager.session.user_config.get("skip_git_safety", False)
 
-    async def execute(self, force: bool = False) -> None:
+    async def execute(self, _force: bool = False) -> None:
         """Create a safety branch for TunaCode operations."""
         try:
             # Check if git is installed
@@ -123,6 +123,16 @@ class GitSafetySetup(BaseSetup):
                 )
                 # Save preference
                 self.state_manager.session.user_config["skip_git_safety"] = True
+                # Save the updated configuration to disk
+                try:
+                    from tunacode.utils.user_configuration import save_config
+
+                    save_config(self.state_manager)
+                except Exception as e:
+                    # Log the error but don't fail the setup process
+                    import logging
+
+                    logging.warning(f"Failed to save skip_git_safety preference: {e}")
                 return
 
             # Create and checkout the new branch
@@ -132,6 +142,7 @@ class GitSafetySetup(BaseSetup):
                     ["git", "show-ref", "--verify", f"refs/heads/{new_branch}"],
                     capture_output=True,
                     check=False,
+                    text=True,
                 )
 
                 if result.returncode == 0:

tunacode/core/setup/template_setup.py

@@ -0,0 +1,75 @@
+"""Module: tunacode.core.setup.template_setup
+
+Template directory initialization for the TunaCode CLI.
+Handles creation of template directories and ensures proper structure.
+"""
+
+import platform
+from pathlib import Path
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+
+
+class TemplateSetup(BaseSetup):
+    """Setup step for template directory structure."""
+
+    def __init__(self, state_manager: StateManager):
+        super().__init__(state_manager)
+        # Use same config directory as main configuration
+        self.config_dir = Path.home() / ".config" / "tunacode"
+        self.template_dir = self.config_dir / "templates"
+
+    @property
+    def name(self) -> str:
+        return "Template Directory"
+
+    async def should_run(self, force_setup: bool = False) -> bool:
+        """Run if template directory doesn't exist or force setup is requested."""
+        return force_setup or not self.template_dir.exists()
+
+    async def execute(self, force_setup: bool = False) -> None:
+        """Create template directory structure."""
+        try:
+            # Create main template directory
+            self.template_dir.mkdir(parents=True, exist_ok=True)
+
+            # Create subdirectories for organization (optional, for future use)
+            subdirs = ["project", "tool", "config"]
+            for subdir in subdirs:
+                subdir_path = self.template_dir / subdir
+                subdir_path.mkdir(exist_ok=True)
+
+            # Set appropriate permissions on Unix-like systems
+            if platform.system() != "Windows":
+                import os
+
+                os.chmod(self.template_dir, 0o755)
+                for subdir in subdirs:
+                    os.chmod(self.template_dir / subdir, 0o755)
+
+            await ui.info(f"Created template directory structure at: {self.template_dir}")
+
+        except PermissionError:
+            await ui.error(
+                f"Permission denied: Cannot create template directory at {self.template_dir}"
+            )
+            raise
+        except OSError as e:
+            await ui.error(f"Failed to create template directory: {str(e)}")
+            raise
+
+    async def validate(self) -> bool:
+        """Validate that template directory exists and is accessible."""
+        if not self.template_dir.exists():
+            return False
+
+        # Check if directory is writable
+        try:
+            test_file = self.template_dir / ".test_write"
+            test_file.touch()
+            test_file.unlink()
+            return True
+        except Exception:
+            return False

tunacode/core/state.py

@@ -6,7 +6,7 @@ Handles user preferences, conversation history, and runtime state.
 
 import uuid
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from tunacode.types import (
     DeviceId,
@@ -21,6 +21,9 @@ from tunacode.types import (
 from tunacode.utils.message_utils import get_message_content
 from tunacode.utils.token_counter import estimate_tokens
 
+if TYPE_CHECKING:
+    from tunacode.core.tool_handler import ToolHandler
+
 
 @dataclass
 class SessionState:
@@ -91,11 +94,19 @@ class SessionState:
 class StateManager:
     def __init__(self):
         self._session = SessionState()
+        self._tool_handler: Optional["ToolHandler"] = None
 
     @property
     def session(self) -> SessionState:
         return self._session
 
+    @property
+    def tool_handler(self) -> Optional["ToolHandler"]:
+        return self._tool_handler
+
+    def set_tool_handler(self, handler: "ToolHandler") -> None:
+        self._tool_handler = handler
+
     def add_todo(self, todo: TodoItem) -> None:
         self._session.todos.append(todo)
 
@@ -112,7 +123,7 @@ class StateManager:
     def push_recursive_context(self, context: dict[str, Any]) -> None:
         """Push a new context onto the recursive execution stack."""
         self._session.recursive_context_stack.append(context)
-        self._session.current_recursion_depth += 1
+        self._session.current_recursion_depth = (self._session.current_recursion_depth or 0) + 1
 
     def pop_recursive_context(self) -> Optional[dict[str, Any]]:
         """Pop the current context from the recursive execution stack."""

tunacode/core/token_usage/api_response_parser.py

@@ -35,9 +35,13 @@ class ApiResponseParser:
 
         # The pydantic-ai Usage object standardizes keys to 'request_tokens'
         # and 'response_tokens'. We access them as attributes.
+        # Ensure None values are converted to 0
+        prompt_tokens = getattr(usage, "request_tokens", 0)
+        completion_tokens = getattr(usage, "response_tokens", 0)
+
         parsed_data = {
-            "prompt_tokens": getattr(usage, "request_tokens", 0),
-            "completion_tokens": getattr(usage, "response_tokens", 0),
+            "prompt_tokens": prompt_tokens if prompt_tokens is not None else 0,
+            "completion_tokens": completion_tokens if completion_tokens is not None else 0,
             "model_name": actual_model_name,
         }
 

tunacode/core/token_usage/usage_tracker.py

@@ -46,7 +46,11 @@ class UsageTracker(UsageTrackerProtocol):
 
         except Exception as e:
             if self.state_manager.session.show_thoughts:
+                import traceback
+
                 await ui.error(f"Error during cost calculation: {e}")
+                # Log the full traceback for debugging
+                await ui.debug(f"Traceback: {traceback.format_exc()}")
 
     def _calculate_cost(self, parsed_data: dict) -> float:
         """Calculates the cost for the given parsed data."""
@@ -81,15 +85,35 @@ class UsageTracker(UsageTrackerProtocol):
         if session.session_total_usage is None:
             session.session_total_usage = {"prompt_tokens": 0, "completion_tokens": 0, "cost": 0.0}
 
+        # Normalize values defensively to avoid None propagation
+        try:
+            prompt_tokens = int(prompt_tokens or 0)
+        except (TypeError, ValueError):
+            prompt_tokens = 0
+        try:
+            completion_tokens = int(completion_tokens or 0)
+        except (TypeError, ValueError):
+            completion_tokens = 0
+        try:
+            cost = float(cost or 0.0)
+        except (TypeError, ValueError):
+            cost = 0.0
+
         # Update last call usage
         session.last_call_usage["prompt_tokens"] = prompt_tokens
         session.last_call_usage["completion_tokens"] = completion_tokens
         session.last_call_usage["cost"] = cost
 
-        # Accumulate session totals
-        session.session_total_usage["prompt_tokens"] += prompt_tokens
-        session.session_total_usage["completion_tokens"] += completion_tokens
-        session.session_total_usage["cost"] += cost
+        # Accumulate session totals with normalization
+        session.session_total_usage["prompt_tokens"] = (
+            int(session.session_total_usage.get("prompt_tokens", 0) or 0) + prompt_tokens
+        )
+        session.session_total_usage["completion_tokens"] = (
+            int(session.session_total_usage.get("completion_tokens", 0) or 0) + completion_tokens
+        )
+        session.session_total_usage["cost"] = (
+            float(session.session_total_usage.get("cost", 0.0) or 0.0) + cost
+        )
 
     async def _display_summary(self):
         """Formats and prints the usage summary to the console."""
@@ -106,9 +130,15 @@ class UsageTracker(UsageTrackerProtocol):
         last_cost = session.last_call_usage["cost"]
         session_cost = session.session_total_usage["cost"]
 
+        # Ensure tokens are not None before arithmetic operations
+        prompt_safe = prompt if prompt is not None else 0
+        completion_safe = completion if completion is not None else 0
+        last_cost_safe = last_cost if last_cost is not None else 0.0
+        session_cost_safe = session_cost if session_cost is not None else 0.0
+
         usage_summary = (
-            f"[ Tokens: {prompt + completion:,} (P: {prompt:,}, C: {completion:,}) | "
-            f"Cost: ${last_cost:.4f} | "
-            f"Session Total: ${session_cost:.4f} ]"
+            f"[ Tokens: {prompt_safe + completion_safe:,} (P: {prompt_safe:,}, C: {completion_safe:,}) | "
+            f"Cost: ${last_cost_safe:.4f} | "
+            f"Session Total: ${session_cost_safe:.4f} ]"
         )
         await ui.muted(usage_summary)

tunacode/core/tool_handler.py

@@ -2,9 +2,17 @@
 Tool handling business logic, separated from UI concerns.
 """
 
+from typing import Optional
+
 from tunacode.constants import READ_ONLY_TOOLS
 from tunacode.core.state import StateManager
-from tunacode.types import ToolArgs, ToolConfirmationRequest, ToolConfirmationResponse, ToolName
+from tunacode.templates.loader import Template
+from tunacode.types import (
+    ToolArgs,
+    ToolConfirmationRequest,
+    ToolConfirmationResponse,
+    ToolName,
+)
 
 
 class ToolHandler:
@@ -12,6 +20,16 @@ class ToolHandler:
 
     def __init__(self, state_manager: StateManager):
         self.state = state_manager
+        self.active_template: Optional[Template] = None
+
+    def set_active_template(self, template: Optional[Template]) -> None:
+        """
+        Set the currently active template.
+
+        Args:
+            template: The template to activate, or None to clear the active template.
+        """
+        self.active_template = template
 
     def should_confirm(self, tool_name: ToolName) -> bool:
         """
@@ -27,6 +45,11 @@ class ToolHandler:
         if is_read_only_tool(tool_name):
             return False
 
+        # Check if tool is allowed by active template
+        if self.active_template and self.active_template.allowed_tools:
+            if tool_name in self.active_template.allowed_tools:
+                return False
+
         return not (self.state.session.yolo or tool_name in self.state.session.tool_ignore)
 
     def process_confirmation(self, response: ToolConfirmationResponse, tool_name: ToolName) -> bool: