tunacode-cli 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

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 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.constants import (ERROR_UNDO_INIT, UNDO_DISABLED_HOME, 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:
     """
@@ -59,7 +59,7 @@ def init_undo_system(state_manager: StateManager) -> bool:
     home_dir = Path.home()
 
     if cwd == home_dir:
-        ui.warning(UNDO_DISABLED_HOME)
+        print(f"⚠️  {UNDO_DISABLED_HOME}")
         return False
 
     if not is_in_git_project():
@@ -100,11 +100,11 @@ def init_undo_system(state_manager: StateManager) -> bool:
         return True
     except subprocess.TimeoutExpired as e:
         error = GitOperationError(operation="init", message=UNDO_GIT_TIMEOUT, original_error=e)
-        ui.warning(str(error))
+        print(f"⚠️  {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))
+        print(f"⚠️  {ERROR_UNDO_INIT.format(e=e)}")
         return False
 
 
@@ -156,11 +156,11 @@ def commit_for_undo(
         error = GitOperationError(
             operation="commit", message="Git commit timed out", original_error=e
         )
-        ui.warning(str(error))
+        print(f"⚠️  {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}")
+        print(f"⚠️  Error creating undo commit: {e}")
         return False
 
 
@@ -220,17 +220,14 @@ 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(
-            ModelResponse(
-                parts=[
-                    TextPart(
-                        content=(
-                            "The last changes were undone. "
-                            f"Commit message of undone changes: {commit_msg}"
-                        )
-                    )
-                ],
-                kind="response",
-            )
+            {
+                "role": "system",
+                "content": (
+                    f"The last changes were undone. "
+                    f"Commit message of undone changes: {commit_msg}"
+                ),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
         )
 
         return True, "Successfully undid last change"

tunacode/tools/base.py

@@ -1,13 +1,11 @@
 """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.
+for all tools including error handling and UI logging.
 """
 
 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
 
@@ -28,31 +26,25 @@ class BaseTool(ABC):
 
         This method wraps the tool-specific logic with:
         - UI logging of the operation
-        - Exception handling (except ModelRetry and ToolExecutionError)
+        - Exception handling
         - 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
+            ToolExecutionError: Raised for all 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
@@ -76,8 +68,7 @@ class BaseTool(ABC):
             str: Success message describing what was done
 
         Raises:
-            ModelRetry: When the LLM needs guidance
-            Exception: Any other errors will be caught and handled
+            Exception: Any errors will be caught and handled
         """
         pass
 
@@ -148,10 +139,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
@@ -160,13 +151,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:
@@ -179,7 +170,7 @@ class FileBasedTool(BaseTool):
             if self.ui:
                 try:
                     await self.ui.muted("⚠️  Git commit failed - undo functionality limited")
-                except:
+                except Exception:
                     # Even the warning failed, just continue silently
                     pass
 

tunacode/tools/tinyagent_tools.py

@@ -0,0 +1,103 @@
+"""TinyAgent tool implementations with decorators."""
+
+from typing import Optional
+
+from tinyagent.decorators import tool
+
+from tunacode.exceptions import ToolExecutionError
+from tunacode.ui import console as ui
+
+# Import the existing tool classes to reuse their logic
+from .read_file import ReadFileTool
+from .run_command import RunCommandTool
+from .update_file import UpdateFileTool
+from .write_file import WriteFileTool
+
+
+@tool
+async def read_file(filepath: str) -> str:
+    """Read the contents of a file.
+
+    Args:
+        filepath: The path to the file to read.
+
+    Returns:
+        The contents of the file.
+
+    Raises:
+        Exception: If file cannot be read.
+    """
+    tool_instance = ReadFileTool(ui)
+    try:
+        result = await tool_instance.execute(filepath)
+        return result
+    except ToolExecutionError as e:
+        # tinyAgent expects exceptions to be raised, not returned as strings
+        raise Exception(str(e))
+
+
+@tool
+async def write_file(filepath: str, content: str) -> str:
+    """Write content to a file.
+
+    Args:
+        filepath: The path to the file to write.
+        content: The content to write to the file.
+
+    Returns:
+        Success message.
+
+    Raises:
+        Exception: If file cannot be written.
+    """
+    tool_instance = WriteFileTool(ui)
+    try:
+        result = await tool_instance.execute(filepath, content)
+        return result
+    except ToolExecutionError as e:
+        raise Exception(str(e))
+
+
+@tool
+async def update_file(filepath: str, old_content: str, new_content: str) -> str:
+    """Update specific content in a file.
+
+    Args:
+        filepath: The path to the file to update.
+        old_content: The content to find and replace.
+        new_content: The new content to insert.
+
+    Returns:
+        Success message.
+
+    Raises:
+        Exception: If file cannot be updated.
+    """
+    tool_instance = UpdateFileTool(ui)
+    try:
+        result = await tool_instance.execute(filepath, old_content, new_content)
+        return result
+    except ToolExecutionError as e:
+        raise Exception(str(e))
+
+
+@tool
+async def run_command(command: str, timeout: Optional[int] = None) -> str:
+    """Run a shell command.
+
+    Args:
+        command: The command to run.
+        timeout: Optional timeout in seconds.
+
+    Returns:
+        The command output.
+
+    Raises:
+        Exception: If command fails.
+    """
+    tool_instance = RunCommandTool(ui)
+    try:
+        result = await tool_instance.execute(command, timeout)
+        return result
+    except ToolExecutionError as e:
+        raise Exception(str(e))

tunacode/tools/update_file.py

@@ -7,8 +7,6 @@ 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
@@ -36,13 +34,17 @@ class UpdateFileTool(FileBasedTool):
             ToolResult: A message indicating success.
 
         Raises:
-            ModelRetry: If file not found or target not found
+            ToolExecutionError: If file not found or target not found
             Exception: Any file operation errors
         """
         if not os.path.exists(filepath):
-            raise ModelRetry(
-                f"File '{filepath}' not found. Cannot update. "
-                "Verify the filepath or use `write_file` if it's a new file."
+            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,
             )
 
         with open(filepath, "r", encoding="utf-8") as f:
@@ -53,20 +55,28 @@ class UpdateFileTool(FileBasedTool):
             context_lines = 10
             lines = original.splitlines()
             snippet = "\n".join(lines[:context_lines])
-            # 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---"
+            # 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,
             )
 
         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 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."
+            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,
             )
 
         with open(filepath, "w", encoding="utf-8") as f:

tunacode/tools/write_file.py

@@ -7,8 +7,6 @@ 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
@@ -33,15 +31,19 @@ class WriteFileTool(FileBasedTool):
             ToolResult: A message indicating success.
 
         Raises:
-            ModelRetry: If the file already exists
+            ToolExecutionError: If the file already exists
             Exception: Any file writing errors
         """
         # Prevent overwriting existing files with this tool.
         if os.path.exists(filepath):
-            # 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."
+            # 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,
             )
 
         # Create directories if they don't exist

tunacode/types.py

@@ -1,8 +1,8 @@
 """
-Centralized type definitions for Sidekick CLI.
+Centralized type definitions for TunaCode CLI.
 
 This module contains all type aliases, protocols, and type definitions
-used throughout the Sidekick codebase.
+used throughout the TunaCode codebase.
 """
 
 from dataclasses import dataclass

tunacode/ui/completers.py

@@ -10,54 +10,117 @@ from ..cli.commands import CommandRegistry
 
 
 class CommandCompleter(Completer):
-    """Completer for slash commands."""
-    
+    """Completer for slash commands and their arguments."""
+
     def __init__(self, command_registry: Optional[CommandRegistry] = None):
         self.command_registry = command_registry
-    
+        self._model_selector = None
+
     def get_completions(
         self, document: Document, complete_event: CompleteEvent
     ) -> Iterable[Completion]:
-        """Get completions for slash commands."""
+        """Get completions for slash commands and model names."""
         # Get the text before cursor
         text = document.text_before_cursor
-        
+
+        # Check if we're completing model names after /model or /m command
+        if self._should_complete_model_names(text):
+            yield from self._get_model_completions(document, text)
+            return
+
         # Check if we're at the start of a line or after whitespace
-        if text and not text.isspace() and text[-1] != '\n':
+        if text and not text.isspace() and text[-1] != "\n":
             # Only complete commands at the start of input or after a newline
-            last_newline = text.rfind('\n')
-            line_start = text[last_newline + 1:] if last_newline >= 0 else text
-            
+            last_newline = text.rfind("\n")
+            line_start = text[last_newline + 1 :] if last_newline >= 0 else text  # noqa: E203
+
             # Skip if not at the beginning of a line
-            if line_start and not line_start.startswith('/'):
+            if line_start and not line_start.startswith("/"):
                 return
-        
+
         # Get the word before cursor
         word_before_cursor = document.get_word_before_cursor(WORD=True)
-        
+
         # Only complete if word starts with /
-        if not word_before_cursor.startswith('/'):
+        if not word_before_cursor.startswith("/"):
             return
-            
+
         # Get command names from registry
         if self.command_registry:
             command_names = self.command_registry.get_command_names()
         else:
             # Fallback list of commands
-            command_names = ['/help', '/clear', '/dump', '/yolo', '/undo', 
-                           '/branch', '/compact', '/model', '/init']
-        
+            command_names = [
+                "/help",
+                "/clear",
+                "/dump",
+                "/yolo",
+                "/undo",
+                "/branch",
+                "/compact",
+                "/model",
+                "/m",
+                "/init",
+            ]
+
         # Get the partial command (without /)
         partial = word_before_cursor[1:].lower()
-        
+
         # Yield completions for matching commands
         for cmd in command_names:
-            if cmd.startswith('/') and cmd[1:].lower().startswith(partial):
+            if cmd.startswith("/") and cmd[1:].lower().startswith(partial):
                 yield Completion(
                     text=cmd,
                     start_position=-len(word_before_cursor),
                     display=cmd,
-                    display_meta='command'
+                    display_meta="command",
+                )
+
+    def _should_complete_model_names(self, text: str) -> bool:
+        """Check if we should complete model names."""
+        # Look for /model or /m command followed by space
+        import re
+
+        pattern = r"(?:^|\n)\s*(?:/model|/m)\s+\S*$"
+        return bool(re.search(pattern, text))
+
+    def _get_model_completions(self, document: Document, text: str) -> Iterable[Completion]:
+        """Get completions for model names."""
+        # Lazy import and cache
+        if self._model_selector is None:
+            try:
+                from ..cli.model_selector import ModelSelector
+
+                self._model_selector = ModelSelector()
+            except ImportError:
+                return
+
+        # Get the partial model name
+        word_before_cursor = document.get_word_before_cursor(WORD=True)
+        partial = word_before_cursor.lower()
+
+        # Yield model short names and indices
+        seen = set()
+        for i, model in enumerate(self._model_selector.models):
+            # Complete by index
+            index_str = str(i)
+            if index_str.startswith(partial) and index_str not in seen:
+                seen.add(index_str)
+                yield Completion(
+                    text=index_str,
+                    start_position=-len(word_before_cursor),
+                    display=f"{index_str} - {model.display_name}",
+                    display_meta=model.provider.value[2],
+                )
+
+            # Complete by short name
+            if model.short_name.lower().startswith(partial) and model.short_name not in seen:
+                seen.add(model.short_name)
+                yield Completion(
+                    text=model.short_name,
+                    start_position=-len(word_before_cursor),
+                    display=f"{model.short_name} - {model.display_name}",
+                    display_meta=model.provider.value[2],
                 )
 
 
@@ -70,14 +133,14 @@ class FileReferenceCompleter(Completer):
         """Get completions for @file references."""
         # Get the word before cursor
         word_before_cursor = document.get_word_before_cursor(WORD=True)
-        
+
         # Check if we're in an @file reference
         if not word_before_cursor.startswith("@"):
             return
-            
+
         # Get the path part after @
         path_part = word_before_cursor[1:]  # Remove @
-        
+
         # Determine directory and prefix
         if "/" in path_part:
             # Path includes directory
@@ -87,18 +150,18 @@ class FileReferenceCompleter(Completer):
             # Just filename, search in current directory
             dir_path = "."
             prefix = path_part
-            
+
         # Get matching files
         try:
             if os.path.exists(dir_path) and os.path.isdir(dir_path):
                 for item in sorted(os.listdir(dir_path)):
                     if item.startswith(prefix):
                         full_path = os.path.join(dir_path, item) if dir_path != "." else item
-                        
+
                         # Skip hidden files unless explicitly requested
                         if item.startswith(".") and not prefix.startswith("."):
                             continue
-                            
+
                         # Add / for directories
                         if os.path.isdir(full_path):
                             display = item + "/"
@@ -106,15 +169,15 @@ class FileReferenceCompleter(Completer):
                         else:
                             display = item
                             completion = full_path
-                            
+
                         # Calculate how much to replace
                         start_position = -len(path_part)
-                        
+
                         yield Completion(
                             text=completion,
                             start_position=start_position,
                             display=display,
-                            display_meta="dir" if os.path.isdir(full_path) else "file"
+                            display_meta="dir" if os.path.isdir(full_path) else "file",
                         )
         except (OSError, PermissionError):
             # Silently ignore inaccessible directories
@@ -123,7 +186,9 @@ class FileReferenceCompleter(Completer):
 
 def create_completer(command_registry: Optional[CommandRegistry] = None) -> Completer:
     """Create a merged completer for both commands and file references."""
-    return merge_completers([
-        CommandCompleter(command_registry),
-        FileReferenceCompleter(),
-    ])
+    return merge_completers(
+        [
+            CommandCompleter(command_registry),
+            FileReferenceCompleter(),
+        ]
+    )

tunacode/ui/input.py

@@ -4,10 +4,9 @@ from typing import Optional
 
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.styles import Style
 from prompt_toolkit.validation import Validator
 
-from tunacode.constants import UI_COLORS, UI_PROMPT_PREFIX
+from tunacode.constants import UI_PROMPT_PREFIX
 from tunacode.core.state import StateManager
 
 from .completers import create_completer
@@ -72,7 +71,9 @@ async def input(
     return await manager.get_input(session_key, pretext, config)
 
 
-async def multiline_input(state_manager: Optional[StateManager] = None, command_registry=None) -> str:
+async def multiline_input(
+    state_manager: Optional[StateManager] = None, command_registry=None
+) -> str:
     """Get multiline input from the user with @file completion and highlighting."""
     kb = create_key_bindings()
     placeholder = formatted_text(
@@ -85,11 +86,11 @@ async def multiline_input(state_manager: Optional[StateManager] = None, command_
         )
     )
     return await input(
-        "multiline", 
-        key_bindings=kb, 
-        multiline=True, 
+        "multiline",
+        key_bindings=kb,
+        multiline=True,
         placeholder=placeholder,
         completer=create_completer(command_registry),
         lexer=FileReferenceLexer(),
-        state_manager=state_manager
+        state_manager=state_manager,
     )

tunacode/ui/keybindings.py

@@ -7,8 +7,6 @@ def create_key_bindings() -> KeyBindings:
     """Create and configure key bindings for the UI."""
     kb = KeyBindings()
 
-    
-
     @kb.add("enter")
     def _submit(event):
         """Submit the current buffer."""
@@ -18,7 +16,7 @@ def create_key_bindings() -> KeyBindings:
     def _newline(event):
         """Insert a newline character."""
         event.current_buffer.insert_text("\n")
-    
+
     @kb.add("escape", "enter")
     def _escape_enter(event):
         """Insert a newline when escape then enter is pressed."""