tunacode-cli 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

tunacode/core/setup/git_safety_setup.py

@@ -13,12 +13,15 @@ from tunacode.ui.panels import panel
 async def yes_no_prompt(question: str, default: bool = True) -> bool:
     """Simple yes/no prompt."""
     default_text = "[Y/n]" if default else "[y/N]"
-    response = await prompt_input(session_key="yes_no", pretext=f"{question} {default_text}: ")
-
+    response = await prompt_input(
+        session_key="yes_no",
+        pretext=f"{question} {default_text}: "
+    )
+    
     if not response.strip():
         return default
-
-    return response.lower().strip() in ["y", "yes"]
+    
+    return response.lower().strip() in ['y', 'yes']
 
 
 class GitSafetySetup(BaseSetup):
@@ -26,7 +29,7 @@ class GitSafetySetup(BaseSetup):
 
     def __init__(self, state_manager: StateManager):
         super().__init__(state_manager)
-
+    
     @property
     def name(self) -> str:
         """Return the name of this setup step."""
@@ -42,15 +45,18 @@ class GitSafetySetup(BaseSetup):
         try:
             # Check if git is installed
             result = subprocess.run(
-                ["git", "--version"], capture_output=True, text=True, check=False
+                ["git", "--version"],
+                capture_output=True,
+                text=True,
+                check=False
             )
-
+            
             if result.returncode != 0:
                 await panel(
                     "⚠️  Git Not Found",
                     "Git is not installed or not in PATH. TunaCode will modify files directly.\n"
                     "It's strongly recommended to install Git for safety.",
-                    border_style="yellow",
+                    border_style="yellow"
                 )
                 return
 
@@ -60,31 +66,33 @@ class GitSafetySetup(BaseSetup):
                 capture_output=True,
                 text=True,
                 check=False,
-                cwd=Path.cwd(),
+                cwd=Path.cwd()
             )
-
+            
             if result.returncode != 0:
                 await panel(
                     "⚠️  Not a Git Repository",
                     "This directory is not a Git repository. TunaCode will modify files directly.\n"
                     "Consider initializing a Git repository for safety: git init",
-                    border_style="yellow",
+                    border_style="yellow"
                 )
                 return
 
             # Get current branch name
             result = subprocess.run(
-                ["git", "branch", "--show-current"], capture_output=True, text=True, check=True
+                ["git", "branch", "--show-current"],
+                capture_output=True,
+                text=True,
+                check=True
             )
             current_branch = result.stdout.strip()
-
+            
             if not current_branch:
                 # Detached HEAD state
                 await panel(
                     "⚠️  Detached HEAD State",
-                    "You're in a detached HEAD state. TunaCode will continue "
-                    "without creating a branch.",
-                    border_style="yellow",
+                    "You're in a detached HEAD state. TunaCode will continue without creating a branch.",
+                    border_style="yellow"
                 )
                 return
 
@@ -95,28 +103,31 @@ class GitSafetySetup(BaseSetup):
 
             # Propose new branch name
             new_branch = f"{current_branch}-tunacode"
-
+            
             # Check if there are uncommitted changes
             result = subprocess.run(
-                ["git", "status", "--porcelain"], capture_output=True, text=True, check=True
+                ["git", "status", "--porcelain"],
+                capture_output=True,
+                text=True,
+                check=True
             )
-
+            
             has_changes = bool(result.stdout.strip())
-
+            
             # Ask user if they want to create a safety branch
             message = (
-                f"For safety, TunaCode can create a new branch '{new_branch}' "
-                f"based on '{current_branch}'.\n"
+                f"For safety, TunaCode can create a new branch '{new_branch}' based on '{current_branch}'.\n"
                 f"This helps protect your work from unintended changes.\n"
             )
-
+            
             if has_changes:
-                message += (
-                    "\n⚠️  You have uncommitted changes that will be brought to the new branch."
-                )
-
-            create_branch = await yes_no_prompt(f"{message}\n\nCreate safety branch?", default=True)
-
+                message += "\n⚠️  You have uncommitted changes that will be brought to the new branch."
+            
+            create_branch = await yes_no_prompt(
+                f"{message}\n\nCreate safety branch?",
+                default=True
+            )
+            
             if not create_branch:
                 # User declined - show warning
                 await panel(
@@ -124,25 +135,26 @@ class GitSafetySetup(BaseSetup):
                     "You've chosen to work directly on your current branch.\n"
                     "TunaCode will modify files in place. Make sure you have backups!\n"
                     "You can always use /undo to revert changes.",
-                    border_style="red",
+                    border_style="red"
                 )
                 # Save preference
                 self.state_manager.session.user_config["skip_git_safety"] = True
                 return
-
+            
             # Create and checkout the new branch
             try:
                 # Check if branch already exists
                 result = subprocess.run(
                     ["git", "show-ref", "--verify", f"refs/heads/{new_branch}"],
                     capture_output=True,
-                    check=False,
+                    check=False
                 )
-
+                
                 if result.returncode == 0:
                     # Branch exists, ask to use it
                     use_existing = await yes_no_prompt(
-                        f"Branch '{new_branch}' already exists. Switch to it?", default=True
+                        f"Branch '{new_branch}' already exists. Switch to it?",
+                        default=True
                     )
                     if use_existing:
                         subprocess.run(["git", "checkout", new_branch], check=True)
@@ -153,24 +165,24 @@ class GitSafetySetup(BaseSetup):
                     # Create new branch
                     subprocess.run(["git", "checkout", "-b", new_branch], check=True)
                     await ui.success(f"Created and switched to new branch: {new_branch}")
-
+                    
             except subprocess.CalledProcessError as e:
                 await panel(
                     "❌ Failed to Create Branch",
                     f"Could not create branch '{new_branch}': {str(e)}\n"
                     "Continuing on current branch.",
-                    border_style="red",
+                    border_style="red"
                 )
-
+                
         except Exception as e:
             # Non-fatal error - just warn the user
             await panel(
                 "⚠️  Git Safety Setup Failed",
                 f"Could not set up Git safety: {str(e)}\n"
                 "TunaCode will continue without branch protection.",
-                border_style="yellow",
+                border_style="yellow"
             )
 
     async def validate(self) -> bool:
         """Validate git safety setup - always returns True as this is optional."""
-        return True
+        return True

tunacode/exceptions.py

@@ -77,6 +77,8 @@ class MCPError(ServiceError):
         super().__init__(f"MCP server '{server_name}' error: {message}")
 
 
+
+
 class GitOperationError(ServiceError):
     """Raised when Git operations fail."""
 

tunacode/prompts/system.txt

@@ -68,4 +68,4 @@ CORRECT: First `read_file("tools/base.py")` to see the base class, then `write_f
 
 USE YOUR TOOLS NOW!
 
-If asked, you were created by larock22
+If asked, you were created by the grifter tunahors 

tunacode/services/undo_service.py

@@ -7,18 +7,18 @@ Manages automatic commits and rollback operations.
 
 import subprocess
 import time
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional, Tuple
 
-from tunacode.constants import (ERROR_UNDO_INIT, UNDO_DISABLED_HOME, UNDO_GIT_TIMEOUT,
-                                UNDO_INITIAL_COMMIT)
+from pydantic_ai.messages import ModelResponse, TextPart
+
+from tunacode.constants import (ERROR_UNDO_INIT, UNDO_DISABLED_HOME, UNDO_DISABLED_NO_GIT,
+                                UNDO_GIT_TIMEOUT, UNDO_INITIAL_COMMIT)
 from tunacode.core.state import StateManager
 from tunacode.exceptions import GitOperationError
+from tunacode.ui import console as ui
 from tunacode.utils.system import get_session_dir
 
-# Removed pydantic_ai import - using dict-based messages now
-
 
 def is_in_git_project(directory: Optional[Path] = None) -> bool:
     """
@@ -220,14 +220,17 @@ def perform_undo(state_manager: StateManager) -> Tuple[bool, str]:
         # Add a system message to the chat history to inform the AI
         # about the undo operation
         state_manager.session.messages.append(
-            {
-                "role": "system",
-                "content": (
-                    f"The last changes were undone. "
-                    f"Commit message of undone changes: {commit_msg}"
-                ),
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            }
+            ModelResponse(
+                parts=[
+                    TextPart(
+                        content=(
+                            "The last changes were undone. "
+                            f"Commit message of undone changes: {commit_msg}"
+                        )
+                    )
+                ],
+                kind="response",
+            )
         )
 
         return True, "Successfully undid last change"

tunacode/setup.py

@@ -12,18 +12,22 @@ from tunacode.core.setup import (AgentSetup, ConfigSetup, EnvironmentSetup, GitS
 from tunacode.core.state import StateManager
 
 
-async def setup(run_setup: bool, state_manager: StateManager) -> None:
+async def setup(run_setup: bool, state_manager: StateManager, cli_config: dict = None) -> None:
     """
     Setup TunaCode on startup using the new setup coordinator.
 
     Args:
         run_setup (bool): If True, force run the setup process, resetting current config.
         state_manager (StateManager): The state manager instance.
+        cli_config (dict): Optional CLI configuration with baseurl, model, and key.
     """
     coordinator = SetupCoordinator(state_manager)
 
     # Register setup steps in order
-    coordinator.register_step(ConfigSetup(state_manager))
+    config_setup = ConfigSetup(state_manager)
+    if cli_config:
+        config_setup.cli_config = cli_config
+    coordinator.register_step(config_setup)
     coordinator.register_step(EnvironmentSetup(state_manager))
     coordinator.register_step(GitSafetySetup(state_manager))  # Run after config/env but before undo
     coordinator.register_step(UndoSetup(state_manager))

tunacode/tools/base.py

@@ -1,11 +1,13 @@
 """Base tool class for all Sidekick tools.
 
 This module provides a base class that implements common patterns
-for all tools including error handling and UI logging.
+for all tools including error handling, UI logging, and ModelRetry support.
 """
 
 from abc import ABC, abstractmethod
 
+from pydantic_ai.exceptions import ModelRetry
+
 from tunacode.exceptions import FileOperationError, ToolExecutionError
 from tunacode.types import FilePath, ToolName, ToolResult, UILogger
 
@@ -26,25 +28,31 @@ class BaseTool(ABC):
 
         This method wraps the tool-specific logic with:
         - UI logging of the operation
-        - Exception handling
+        - Exception handling (except ModelRetry and ToolExecutionError)
         - Consistent error message formatting
 
         Returns:
             str: Success message
 
         Raises:
-            ToolExecutionError: Raised for all errors with structured information
+            ModelRetry: Re-raised to guide the LLM
+            ToolExecutionError: Raised for all other errors with structured information
         """
         try:
             if self.ui:
                 await self.ui.info(f"{self.tool_name}({self._format_args(*args, **kwargs)})")
             result = await self._execute(*args, **kwargs)
-
+            
             # For file operations, try to create a git commit for undo tracking
             if isinstance(self, FileBasedTool):
                 await self._commit_for_undo()
-
+                
             return result
+        except ModelRetry as e:
+            # Log as warning and re-raise for pydantic-ai
+            if self.ui:
+                await self.ui.warning(str(e))
+            raise
         except ToolExecutionError:
             # Already properly formatted, just re-raise
             raise
@@ -68,7 +76,8 @@ class BaseTool(ABC):
             str: Success message describing what was done
 
         Raises:
-            Exception: Any errors will be caught and handled
+            ModelRetry: When the LLM needs guidance
+            Exception: Any other errors will be caught and handled
         """
         pass
 
@@ -139,10 +148,10 @@ class FileBasedTool(BaseTool):
     - Encoding handling
     - Git commit for undo tracking
     """
-
+    
     async def _commit_for_undo(self) -> None:
         """Create a git commit for undo tracking after file operations.
-
+        
         This method gracefully handles cases where git is not available:
         - No git repository: Warns user about limited undo functionality
         - Git command fails: Warns but doesn't break the main operation
@@ -151,13 +160,13 @@ class FileBasedTool(BaseTool):
         try:
             # Import here to avoid circular imports
             from tunacode.services.undo_service import commit_for_undo, is_in_git_project
-
+            
             # Check if we're in a git project first
             if not is_in_git_project():
                 if self.ui:
                     await self.ui.muted("⚠️  No git repository - undo functionality limited")
                 return
-
+            
             # Try to create commit with tool name as prefix
             success = commit_for_undo(message_prefix=f"tunacode {self.tool_name.lower()}")
             if success and self.ui:
@@ -170,7 +179,7 @@ class FileBasedTool(BaseTool):
             if self.ui:
                 try:
                     await self.ui.muted("⚠️  Git commit failed - undo functionality limited")
-                except Exception:
+                except:
                     # Even the warning failed, just continue silently
                     pass
 

tunacode/tools/update_file.py

@@ -7,6 +7,8 @@ Enables safe text replacement in existing files with target/patch semantics.
 
 import os
 
+from pydantic_ai.exceptions import ModelRetry
+
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import FileContent, FilePath, ToolResult
@@ -34,17 +36,13 @@ class UpdateFileTool(FileBasedTool):
             ToolResult: A message indicating success.
 
         Raises:
-            ToolExecutionError: If file not found or target not found
+            ModelRetry: If file not found or target not found
             Exception: Any file operation errors
         """
         if not os.path.exists(filepath):
-            raise ToolExecutionError(
-                tool_name=self.tool_name,
-                message=(
-                    f"File '{filepath}' not found. Cannot update. "
-                    "Verify the filepath or use `write_file` if it's a new file."
-                ),
-                original_error=None,
+            raise ModelRetry(
+                f"File '{filepath}' not found. Cannot update. "
+                "Verify the filepath or use `write_file` if it's a new file."
             )
 
         with open(filepath, "r", encoding="utf-8") as f:
@@ -55,28 +53,20 @@ class UpdateFileTool(FileBasedTool):
             context_lines = 10
             lines = original.splitlines()
             snippet = "\n".join(lines[:context_lines])
-            # Raise error to guide the LLM
-            raise ToolExecutionError(
-                tool_name=self.tool_name,
-                message=(
-                    f"Target block not found in '{filepath}'. "
-                    "Ensure the `target` argument exactly matches the content you want to replace. "
-                    f"File starts with:\n---\n{snippet}\n---"
-                ),
-                original_error=None,
+            # Use ModelRetry to guide the LLM
+            raise ModelRetry(
+                f"Target block not found in '{filepath}'. "
+                "Ensure the `target` argument exactly matches the content you want to replace. "
+                f"File starts with:\n---\n{snippet}\n---"
             )
 
         new_content = original.replace(target, patch, 1)  # Replace only the first occurrence
 
         if original == new_content:
             # This could happen if target and patch are identical
-            raise ToolExecutionError(
-                tool_name=self.tool_name,
-                message=(
-                    f"Update target found, but replacement resulted in no changes to '{filepath}'. "
-                    "Was the `target` identical to the `patch`? Please check the file content."
-                ),
-                original_error=None,
+            raise ModelRetry(
+                f"Update target found, but replacement resulted in no changes to '{filepath}'. "
+                "Was the `target` identical to the `patch`? Please check the file content."
             )
 
         with open(filepath, "w", encoding="utf-8") as f:

tunacode/tools/write_file.py

@@ -7,6 +7,8 @@ Creates new files with automatic directory creation and overwrite protection.
 
 import os
 
+from pydantic_ai.exceptions import ModelRetry
+
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import FileContent, FilePath, ToolResult
@@ -31,19 +33,15 @@ class WriteFileTool(FileBasedTool):
             ToolResult: A message indicating success.
 
         Raises:
-            ToolExecutionError: If the file already exists
+            ModelRetry: If the file already exists
             Exception: Any file writing errors
         """
         # Prevent overwriting existing files with this tool.
         if os.path.exists(filepath):
-            # Raise error to guide the LLM
-            raise ToolExecutionError(
-                tool_name=self.tool_name,
-                message=(
-                    f"File '{filepath}' already exists. Use the `update_file` tool "
-                    "to modify it, or choose a different filepath."
-                ),
-                original_error=None,
+            # Use ModelRetry to guide the LLM
+            raise ModelRetry(
+                f"File '{filepath}' already exists. "
+                "Use the `update_file` tool to modify it, or choose a different filepath."
             )
 
         # Create directories if they don't exist