tunacode-cli 0.0.1__py3-none-any.whl

tunacode/services/undo_service.py

@@ -0,0 +1,244 @@
+"""
+Module: tunacode.services.undo_service
+
+Provides Git-based undo functionality for TunaCode operations.
+Manages automatic commits and rollback operations.
+"""
+
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional, Tuple
+
+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
+
+
+def is_in_git_project(directory: Optional[Path] = None) -> bool:
+    """
+    Recursively check if the given directory is inside a git project.
+
+    Args:
+        directory (Path, optional): Directory to check. Defaults to current working directory.
+
+    Returns:
+        bool: True if in a git project, False otherwise
+    """
+    if directory is None:
+        directory = Path.cwd()
+
+    if (directory / ".git").exists():
+        return True
+
+    if directory == directory.parent:
+        return False
+
+    return is_in_git_project(directory.parent)
+
+
+def init_undo_system(state_manager: StateManager) -> bool:
+    """
+    Initialize the undo system by creating a Git repository
+    in the ~/.tunacode/sessions/<session-id> directory.
+
+    Skip initialization if running from home directory or not in a git project.
+
+    Args:
+        state_manager: The StateManager instance.
+
+    Returns:
+        bool: True if the undo system was initialized, False otherwise.
+    """
+    cwd = Path.cwd()
+    home_dir = Path.home()
+
+    if cwd == home_dir:
+        ui.warning(UNDO_DISABLED_HOME)
+        return False
+
+    if not is_in_git_project():
+        # Temporarily use sync print for warnings during init
+        print("⚠️  Not in a git repository - undo functionality will be limited")
+        print("💡 To enable undo functionality, run: git init")
+        print("   File operations will still work, but can't be undone")
+        return False
+
+    # Get the session directory path
+    session_dir = get_session_dir(state_manager)
+    tunacode_git_dir = session_dir / ".git"
+
+    # Check if already initialized
+    if tunacode_git_dir.exists():
+        return True
+
+    # Initialize Git repository
+    try:
+        subprocess.run(
+            ["git", "init", str(session_dir)], capture_output=True, check=True, timeout=5
+        )
+
+        # Make an initial commit
+        git_dir_arg = f"--git-dir={tunacode_git_dir}"
+
+        # Add all files
+        subprocess.run(["git", git_dir_arg, "add", "."], capture_output=True, check=True, timeout=5)
+
+        # Create initial commit
+        subprocess.run(
+            ["git", git_dir_arg, "commit", "-m", UNDO_INITIAL_COMMIT],
+            capture_output=True,
+            check=True,
+            timeout=5,
+        )
+
+        return True
+    except subprocess.TimeoutExpired as e:
+        error = GitOperationError(operation="init", message=UNDO_GIT_TIMEOUT, original_error=e)
+        ui.warning(str(error))
+        return False
+    except Exception as e:
+        error = GitOperationError(operation="init", message=str(e), original_error=e)
+        ui.warning(ERROR_UNDO_INIT.format(e=e))
+        return False
+
+
+def commit_for_undo(
+    message_prefix: str = "tunacode", state_manager: Optional[StateManager] = None
+) -> bool:
+    """
+    Commit the current state to the undo repository.
+
+    Args:
+        message_prefix (str): Prefix for the commit message.
+        state_manager: The StateManager instance.
+
+    Returns:
+        bool: True if the commit was successful, False otherwise.
+    """
+    # Get the session directory and git dir
+    if state_manager is None:
+        raise ValueError("state_manager is required for commit_for_undo")
+    session_dir = get_session_dir(state_manager)
+    tunacode_git_dir = session_dir / ".git"
+
+    if not tunacode_git_dir.exists():
+        return False
+
+    try:
+        git_dir_arg = f"--git-dir={tunacode_git_dir}"
+
+        # Add all files
+        subprocess.run(["git", git_dir_arg, "add", "."], capture_output=True, timeout=5)
+
+        # Create commit with timestamp
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        commit_message = f"{message_prefix} - {timestamp}"
+
+        result = subprocess.run(
+            ["git", git_dir_arg, "commit", "-m", commit_message],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        # Handle case where there are no changes to commit
+        if "nothing to commit" in result.stdout or "nothing to commit" in result.stderr:
+            return False
+
+        return True
+    except subprocess.TimeoutExpired as e:
+        error = GitOperationError(
+            operation="commit", message="Git commit timed out", original_error=e
+        )
+        ui.warning(str(error))
+        return False
+    except Exception as e:
+        error = GitOperationError(operation="commit", message=str(e), original_error=e)
+        ui.warning(f"Error creating undo commit: {e}")
+        return False
+
+
+def perform_undo(state_manager: StateManager) -> Tuple[bool, str]:
+    """
+    Undo the most recent change by resetting to the previous commit.
+    Also adds a system message to the chat history to inform the AI
+    that the last changes were undone.
+
+    Args:
+        state_manager: The StateManager instance.
+
+    Returns:
+        tuple: (bool, str) - Success status and message
+    """
+    # Get the session directory and git dir
+    session_dir = get_session_dir(state_manager)
+    tunacode_git_dir = session_dir / ".git"
+
+    if not tunacode_git_dir.exists():
+        return False, "Undo system not initialized"
+
+    try:
+        git_dir_arg = f"--git-dir={tunacode_git_dir}"
+
+        # Get commit log to check if we have commits to undo
+        result = subprocess.run(
+            ["git", git_dir_arg, "log", "--format=%H", "-n", "2"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+
+        commits = result.stdout.strip().split("\n")
+        if len(commits) < 2:
+            return False, "Nothing to undo"
+
+        # Get the commit message of the commit we're undoing for context
+        commit_msg_result = subprocess.run(
+            ["git", git_dir_arg, "log", "--format=%B", "-n", "1"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+        commit_msg = commit_msg_result.stdout.strip()
+
+        # Perform reset to previous commit
+        subprocess.run(
+            ["git", git_dir_arg, "reset", "--hard", "HEAD~1"],
+            capture_output=True,
+            check=True,
+            timeout=5,
+        )
+
+        # Add a system message to the chat history to inform the AI
+        # about the undo operation
+        state_manager.session.messages.append(
+            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"
+    except subprocess.TimeoutExpired as e:
+        error = GitOperationError(
+            operation="reset", message="Undo operation timed out", original_error=e
+        )
+        return False, str(error)
+    except Exception as e:
+        error = GitOperationError(operation="reset", message=str(e), original_error=e)
+        return False, f"Error performing undo: {e}"

tunacode/setup.py

@@ -0,0 +1,50 @@
+"""
+Module: tunacode.setup
+
+Package setup and metadata configuration for the TunaCode CLI.
+Provides high-level setup functions for initializing the application and its agents.
+"""
+
+from typing import Any, Optional
+
+from tunacode.core.setup import (AgentSetup, ConfigSetup, EnvironmentSetup, GitSafetySetup,
+                                 SetupCoordinator, UndoSetup)
+from tunacode.core.state import StateManager
+
+
+async def setup(run_setup: bool, state_manager: StateManager) -> 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.
+    """
+    coordinator = SetupCoordinator(state_manager)
+
+    # Register setup steps in order
+    coordinator.register_step(ConfigSetup(state_manager))
+    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))
+
+    # Run all setup steps
+    await coordinator.run_setup(force_setup=run_setup)
+
+
+async def setup_agent(agent: Optional[Any], state_manager: StateManager) -> None:
+    """
+    Setup the agent separately.
+
+    This is called from other parts of the codebase when an agent needs to be initialized.
+
+    Args:
+        agent: The agent instance to initialize.
+        state_manager (StateManager): The state manager instance.
+    """
+    if agent is not None:
+        agent_setup = AgentSetup(state_manager, agent)
+        if await agent_setup.should_run():
+            await agent_setup.execute()
+            if not await agent_setup.validate():
+                raise RuntimeError("Agent setup failed validation")

tunacode/tools/base.py

@@ -0,0 +1,244 @@
+"""Base tool class for all Sidekick tools.
+
+This module provides a base class that implements common patterns
+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
+
+
+class BaseTool(ABC):
+    """Base class for all Sidekick tools providing common functionality."""
+
+    def __init__(self, ui_logger: UILogger | None = None):
+        """Initialize the base tool.
+
+        Args:
+            ui_logger: UI logger instance for displaying messages
+        """
+        self.ui = ui_logger
+
+    async def execute(self, *args, **kwargs) -> ToolResult:
+        """Execute the tool with error handling and logging.
+
+        This method wraps the tool-specific logic with:
+        - UI logging of the operation
+        - Exception handling (except ModelRetry and ToolExecutionError)
+        - Consistent error message formatting
+
+        Returns:
+            str: Success message
+
+        Raises:
+            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
+        except Exception as e:
+            # Handle any other exceptions
+            await self._handle_error(e, *args, **kwargs)
+
+    @property
+    @abstractmethod
+    def tool_name(self) -> ToolName:
+        """Return the display name for this tool."""
+        pass
+
+    @abstractmethod
+    async def _execute(self, *args, **kwargs) -> ToolResult:
+        """Implement tool-specific logic here.
+
+        This method should contain the core functionality of the tool.
+
+        Returns:
+            str: Success message describing what was done
+
+        Raises:
+            ModelRetry: When the LLM needs guidance
+            Exception: Any other errors will be caught and handled
+        """
+        pass
+
+    async def _handle_error(self, error: Exception, *args, **kwargs) -> ToolResult:
+        """Handle errors by logging and raising proper exceptions.
+
+        Args:
+            error: The exception that was raised
+            *args, **kwargs: Original arguments for context
+
+        Raises:
+            ToolExecutionError: Always raised with structured error information
+        """
+        # Format error message for display
+        err_msg = f"Error {self._get_error_context(*args, **kwargs)}: {error}"
+        if self.ui:
+            await self.ui.error(err_msg)
+
+        # Raise proper exception instead of returning string
+        raise ToolExecutionError(tool_name=self.tool_name, message=str(error), original_error=error)
+
+    def _format_args(self, *args, **kwargs) -> str:
+        """Format arguments for display in UI logging.
+
+        Override this method to customize how arguments are displayed.
+
+        Returns:
+            str: Formatted argument string
+        """
+        # Collect all arguments
+        all_args = []
+
+        # Add positional arguments
+        for arg in args:
+            if isinstance(arg, str) and len(arg) > 50:
+                # Truncate long strings
+                all_args.append(f"'{arg[:47]}...'")
+            else:
+                all_args.append(repr(arg))
+
+        # Add keyword arguments
+        for key, value in kwargs.items():
+            if isinstance(value, str) and len(value) > 50:
+                all_args.append(f"{key}='{value[:47]}...'")
+            else:
+                all_args.append(f"{key}={repr(value)}")
+
+        return ", ".join(all_args)
+
+    def _get_error_context(self, *args, **kwargs) -> str:
+        """Get context string for error messages.
+
+        Override this method to provide tool-specific error context.
+
+        Returns:
+            str: Context for the error message
+        """
+        return f"in {self.tool_name}"
+
+
+class FileBasedTool(BaseTool):
+    """Base class for tools that work with files.
+
+    Provides common file-related functionality like:
+    - Path validation
+    - File existence checking
+    - Directory creation
+    - 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
+        - Any other error: Silently continues (file operation still succeeds)
+        """
+        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:
+                await self.ui.muted("• Git commit created for undo tracking")
+            elif self.ui:
+                await self.ui.muted("⚠️  Could not create git commit - undo may not work")
+        except Exception:
+            # Silently ignore commit errors - don't break the main file operation
+            # The file operation itself succeeded, we just can't track it for undo
+            if self.ui:
+                try:
+                    await self.ui.muted("⚠️  Git commit failed - undo functionality limited")
+                except:
+                    # Even the warning failed, just continue silently
+                    pass
+
+    def _format_args(self, filepath: FilePath, *args, **kwargs) -> str:
+        """Format arguments with filepath as first argument."""
+        # Always show the filepath first
+        all_args = [repr(filepath)]
+
+        # Add remaining positional arguments
+        for arg in args:
+            if isinstance(arg, str) and len(arg) > 50:
+                all_args.append(f"'{arg[:47]}...'")
+            else:
+                all_args.append(repr(arg))
+
+        # Add keyword arguments
+        for key, value in kwargs.items():
+            if isinstance(value, str) and len(value) > 50:
+                all_args.append(f"{key}='{value[:47]}...'")
+            else:
+                all_args.append(f"{key}={repr(value)}")
+
+        return ", ".join(all_args)
+
+    def _get_error_context(self, filepath: FilePath = None, *args, **kwargs) -> str:
+        """Get error context including file path."""
+        if filepath:
+            return f"handling file '{filepath}'"
+        return super()._get_error_context(*args, **kwargs)
+
+    async def _handle_error(self, error: Exception, *args, **kwargs) -> ToolResult:
+        """Handle file-specific errors.
+
+        Overrides base class to create FileOperationError for file-related issues.
+
+        Raises:
+            ToolExecutionError: Always raised with structured error information
+        """
+        filepath = args[0] if args else kwargs.get("filepath", "unknown")
+
+        # Check if this is a file-related error
+        if isinstance(error, (IOError, OSError, PermissionError, FileNotFoundError)):
+            # Determine the operation based on the tool name
+            operation = self.tool_name.replace("_", " ")
+
+            # Create a FileOperationError
+            file_error = FileOperationError(
+                operation=operation, path=str(filepath), message=str(error), original_error=error
+            )
+
+            # Format error message for display
+            err_msg = str(file_error)
+            if self.ui:
+                await self.ui.error(err_msg)
+
+            # Raise ToolExecutionError with the file error
+            raise ToolExecutionError(
+                tool_name=self.tool_name, message=str(file_error), original_error=file_error
+            )
+
+        # For non-file errors, use the base class handling
+        await super()._handle_error(error, *args, **kwargs)

tunacode/tools/read_file.py

@@ -0,0 +1,89 @@
+"""
+Module: sidekick.tools.read_file
+
+File reading tool for agent operations in the Sidekick application.
+Provides safe file reading with size limits and proper error handling.
+"""
+
+import os
+
+from tunacode.constants import (ERROR_FILE_DECODE, ERROR_FILE_DECODE_DETAILS, ERROR_FILE_NOT_FOUND,
+                                ERROR_FILE_TOO_LARGE, MAX_FILE_SIZE, MSG_FILE_SIZE_LIMIT)
+from tunacode.exceptions import ToolExecutionError
+from tunacode.tools.base import FileBasedTool
+from tunacode.types import FilePath, ToolResult
+from tunacode.ui import console as default_ui
+
+
+class ReadFileTool(FileBasedTool):
+    """Tool for reading file contents."""
+
+    @property
+    def tool_name(self) -> str:
+        return "Read"
+
+    async def _execute(self, filepath: FilePath) -> ToolResult:
+        """Read the contents of a file.
+
+        Args:
+            filepath: The path to the file to read.
+
+        Returns:
+            ToolResult: The contents of the file or an error message.
+
+        Raises:
+            Exception: Any file reading errors
+        """
+        # Add a size limit to prevent reading huge files
+        if os.path.getsize(filepath) > MAX_FILE_SIZE:
+            err_msg = ERROR_FILE_TOO_LARGE.format(filepath=filepath) + MSG_FILE_SIZE_LIMIT
+            if self.ui:
+                await self.ui.error(err_msg)
+            raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=None)
+
+        with open(filepath, "r", encoding="utf-8") as file:
+            content = file.read()
+            return content
+
+    async def _handle_error(self, error: Exception, filepath: FilePath = None) -> ToolResult:
+        """Handle errors with specific messages for common cases.
+
+        Raises:
+            ToolExecutionError: Always raised with structured error information
+        """
+        if isinstance(error, FileNotFoundError):
+            err_msg = ERROR_FILE_NOT_FOUND.format(filepath=filepath)
+        elif isinstance(error, UnicodeDecodeError):
+            err_msg = (
+                ERROR_FILE_DECODE.format(filepath=filepath)
+                + " "
+                + ERROR_FILE_DECODE_DETAILS.format(error=error)
+            )
+        else:
+            # Use parent class handling for other errors
+            await super()._handle_error(error, filepath)
+            return  # super() will raise, this is unreachable
+
+        if self.ui:
+            await self.ui.error(err_msg)
+
+        raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=error)
+
+
+# Create the function that maintains the existing interface
+async def read_file(filepath: FilePath) -> ToolResult:
+    """
+    Read the contents of a file.
+
+    Args:
+        filepath (FilePath): The path to the file to read.
+
+    Returns:
+        ToolResult: The contents of the file or an error message.
+    """
+    tool = ReadFileTool(default_ui)
+    try:
+        return await tool.execute(filepath)
+    except ToolExecutionError as e:
+        # Return error message for pydantic-ai compatibility
+        return str(e)