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

tunacode/cli/commands/base.py

@@ -44,12 +44,12 @@ class Command(ABC):
         return CommandCategory.SYSTEM
 
     @abstractmethod
-    async def execute(self, args: CommandArgs, context: CommandContext) -> CommandResult:
+    async def execute(self, _args: CommandArgs, context: CommandContext) -> CommandResult:
         """
         Execute the command.
 
         Args:
-            args: Command arguments (excluding the command name)
+            _args: Command arguments (excluding the command name)
             context: Execution context with state and config
 
         Returns:

tunacode/cli/commands/implementations/__init__.py

@@ -12,7 +12,13 @@ from .debug import (
 )
 from .development import BranchCommand, InitCommand
 from .model import ModelCommand
-from .system import ClearCommand, HelpCommand, RefreshConfigCommand, StreamingCommand, UpdateCommand
+from .system import (
+    ClearCommand,
+    HelpCommand,
+    RefreshConfigCommand,
+    StreamingCommand,
+    UpdateCommand,
+)
 from .todo import TodoCommand
 
 __all__ = [

tunacode/cli/commands/implementations/conversation.py

@@ -40,7 +40,7 @@ class CompactCommand(SimpleCommand):
         result = await process_request(
             summary_prompt,
             context.state_manager,
-            output=False,  # We'll handle the output ourselves
+            False,  # We'll handle the output ourselves
         )
 
         # Extract summary text from result

tunacode/cli/commands/implementations/debug.py

@@ -169,7 +169,7 @@ class ParseToolsCommand(SimpleCommand):
                         # Create tool callback
                         from tunacode.cli.repl import _tool_handler
 
-                        def tool_callback_with_state(part, node):
+                        def tool_callback_with_state(part, _node):
                             return _tool_handler(part, context.state_manager)
 
                         try:

tunacode/cli/commands/implementations/development.py

@@ -72,6 +72,9 @@ If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (
 make sure to include them."""
 
         # Call the agent to analyze and create/update the file
-        await context.process_request(prompt, context.state_manager)
+        if context.process_request:
+            await context.process_request(
+                prompt, context.state_manager.session.current_model, context.state_manager
+            )
 
         return None

tunacode/cli/commands/implementations/template.py

@@ -0,0 +1,132 @@
+"""Template management commands for TunaCode CLI."""
+
+from typing import Optional
+
+from ....templates.loader import TemplateLoader
+from ....types import CommandArgs, CommandContext
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class TemplateCommand(SimpleCommand):
+    """Manage and use templates for pre-approved tools."""
+
+    spec = CommandSpec(
+        name="template",
+        aliases=["/template", "/tpl"],
+        description="Manage and use templates",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
+        """Execute template command with subcommands."""
+        if not args:
+            await self._show_help()
+            return None
+
+        subcommand = args[0]
+
+        if subcommand == "list":
+            await self._list_templates()
+        elif subcommand == "load":
+            if len(args) < 2:
+                await ui.error("Please specify a template name")
+                await ui.muted("Usage: /template load <template-name>")
+                return None
+            await self._load_template(args[1], context)
+        elif subcommand == "create":
+            await self._create_template()
+        elif subcommand == "clear":
+            await self._clear_template(context)
+        else:
+            await ui.error(f"Unknown subcommand: {subcommand}")
+            await self._show_help()
+
+        return None
+
+    async def _show_help(self) -> None:
+        """Show help for template command."""
+        await ui.info("Template management commands:")
+        await ui.muted("  /template list      - List available templates")
+        await ui.muted("  /template load <name> - Load and activate a template")
+        await ui.muted("  /template create    - Create a new template interactively")
+        await ui.muted("  /template clear     - Clear the active template")
+
+    async def _list_templates(self) -> None:
+        """List all available templates."""
+        loader = TemplateLoader()
+        template_names = loader.list_templates()
+
+        if not template_names:
+            await ui.info("No templates found.")
+            await ui.muted("Create one with: /template create")
+            return
+
+        await ui.info("Available templates:")
+        for name in template_names:
+            template = loader.load_template(name)
+            if template:
+                tools_count = len(template.allowed_tools) if template.allowed_tools else 0
+                shortcut_info = f" ({template.shortcut})" if template.shortcut else ""
+                await ui.muted(
+                    f"  • {name}{shortcut_info}: {template.description} ({tools_count} tools)"
+                )
+
+    async def _load_template(self, name: str, context: CommandContext) -> None:
+        """Load and activate a template."""
+        loader = TemplateLoader()
+        template = loader.load_template(name)
+
+        if not template:
+            await ui.error(f"Template '{name}' not found")
+            await ui.muted("Use '/template list' to see available templates")
+            return
+
+        # Set active template in tool handler
+        if hasattr(context.state_manager, "tool_handler") and context.state_manager.tool_handler:
+            context.state_manager.tool_handler.set_active_template(template)
+        else:
+            await ui.error("Tool handler not initialized. Please restart TunaCode.")
+            return
+
+        await ui.success(f"Loaded template: {template.name}")
+        await ui.muted(f"Description: {template.description}")
+
+        if template.shortcut:
+            await ui.muted(f"Shortcut: {template.shortcut}")
+
+        if template.allowed_tools:
+            await ui.info(f"Allowed tools ({len(template.allowed_tools)}):")
+            tools_str = ", ".join(template.allowed_tools)
+            await ui.muted(f"  {tools_str}")
+
+        # Execute the prompt if one is defined
+        if template.prompt:
+            await ui.info("Template has a default prompt:")
+            await ui.muted(f"  {template.prompt}")
+            await ui.muted("Submit this prompt to execute it")
+
+    async def _create_template(self) -> None:
+        """Create a new template interactively."""
+        await ui.info("Interactive template creation is not yet implemented")
+        await ui.muted("Please create templates manually as JSON files in:")
+        await ui.muted("  ~/.config/tunacode/templates/")
+        await ui.muted("")
+        await ui.muted("Example template format:")
+        await ui.muted("{")
+        await ui.muted('  "name": "debug",')
+        await ui.muted('  "description": "Debugging and analysis",')
+        await ui.muted('  "shortcut": "/debug",')
+        await ui.muted('  "prompt": "Debug the following issue: {argument}",')
+        await ui.muted('  "allowed_tools": ["read_file", "grep", "list_dir", "run_command"]')
+        await ui.muted("}")
+
+        # TODO: Implement interactive creation when proper input handling is available
+
+    async def _clear_template(self, context: CommandContext) -> None:
+        """Clear the currently active template."""
+        if hasattr(context.state_manager, "tool_handler") and context.state_manager.tool_handler:
+            context.state_manager.tool_handler.set_active_template(None)
+            await ui.success("Cleared active template")
+        else:
+            await ui.error("Unable to clear template - tool handler not found")

tunacode/cli/commands/registry.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type
 
 from ...exceptions import ValidationError
+from ...templates.loader import TemplateLoader
 from ...types import CommandArgs, CommandContext, ProcessRequestCallback
 from .base import Command, CommandCategory
 
@@ -26,7 +27,9 @@ from .implementations.system import (
     StreamingCommand,
     UpdateCommand,
 )
+from .implementations.template import TemplateCommand
 from .implementations.todo import TodoCommand
+from .template_shortcut import TemplateShortcutCommand
 
 
 @dataclass
@@ -71,6 +74,7 @@ class CommandRegistry:
         }
         self._factory = factory or CommandFactory()
         self._discovered = False
+        self._shortcuts_loaded = False
 
         # Set registry reference in factory dependencies
         self._factory.update_dependencies(command_registry=self)
@@ -120,12 +124,13 @@ class CommandRegistry:
             CompactCommand,
             ModelCommand,
             InitCommand,
+            TemplateCommand,
             TodoCommand,
         ]
 
         # Register all discovered commands
         for command_class in command_classes:
-            self.register_command_class(command_class)
+            self.register_command_class(command_class)  # type: ignore[arg-type]
 
         self._discovered = True
 
@@ -133,6 +138,26 @@ class CommandRegistry:
         """Register all default commands (backward compatibility)."""
         self.discover_commands()
 
+    def load_template_shortcuts(self) -> None:
+        """Load and register template shortcuts dynamically."""
+        if self._shortcuts_loaded:
+            return
+
+        try:
+            loader = TemplateLoader()
+            shortcuts = loader.get_templates_with_shortcuts()
+
+            for shortcut, template in shortcuts.items():
+                # Create a template shortcut command instance
+                shortcut_command = TemplateShortcutCommand(template)
+                self.register(shortcut_command)
+
+            self._shortcuts_loaded = True
+
+        except Exception as e:
+            # Don't fail if templates can't be loaded
+            print(f"Warning: Failed to load template shortcuts: {str(e)}")
+
     def set_process_request_callback(self, callback: ProcessRequestCallback) -> None:
         """Set the process_request callback for commands that need it."""
         # Only update if callback has changed
@@ -161,6 +186,8 @@ class CommandRegistry:
         """
         # Ensure commands are discovered
         self.discover_commands()
+        # Load template shortcuts
+        self.load_template_shortcuts()
 
         parts = command_text.split()
         if not parts:

tunacode/cli/commands/template_shortcut.py

@@ -0,0 +1,93 @@
+"""Template shortcut command base class for dynamic template-based commands."""
+
+from typing import List, Optional
+
+from ...templates.loader import Template
+from ...types import CommandArgs, CommandContext
+from ...ui import console as ui
+from .base import Command, CommandCategory
+
+
+class TemplateShortcutCommand(Command):
+    """Base class for template shortcut commands that auto-load templates and process arguments."""
+
+    def __init__(self, template: Template):
+        """Initialize with a specific template.
+
+        Args:
+            template: The template instance this shortcut represents
+        """
+        self.template = template
+        self._name = template.shortcut.lstrip("/") if template.shortcut else template.name
+        self._aliases = [template.shortcut] if template.shortcut else []
+        self._description = f"{template.description} (Template: {template.name})"
+
+    @property
+    def name(self) -> str:
+        """The primary name of the command."""
+        return self._name
+
+    @property
+    def aliases(self) -> List[str]:
+        """Alternative names for the command."""
+        return self._aliases
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        return self._description
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return CommandCategory.DEVELOPMENT
+
+    async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
+        """Execute the template shortcut command.
+
+        Args:
+            args: Command arguments passed by the user
+            context: Command execution context
+
+        Returns:
+            Optional string result
+        """
+        # Set the template as active in the tool handler
+        if hasattr(context.state_manager, "tool_handler") and context.state_manager.tool_handler:
+            context.state_manager.tool_handler.set_active_template(self.template)
+        else:
+            await ui.error("Tool handler not initialized. Please restart TunaCode.")
+            return None
+
+        # Show template activation
+        await ui.success(f"Activated template: {self.template.name}")
+        if self.template.allowed_tools:
+            await ui.muted(f"Auto-approved tools: {', '.join(self.template.allowed_tools)}")
+
+        # Process the prompt with arguments
+        if self.template.prompt:
+            # Join all arguments as a single string
+            argument = " ".join(args) if args else ""
+
+            # Substitute {argument} placeholder in the prompt
+            prompt = self.template.prompt.replace("{argument}", argument)
+
+            # If there are additional parameters, substitute them too
+            if self.template.parameters:
+                for key, value in self.template.parameters.items():
+                    placeholder = f"{{{key}}}"
+                    prompt = prompt.replace(placeholder, value)
+
+            # Show the expanded prompt
+            await ui.info("Executing prompt:")
+            await ui.muted(f"  {prompt}")
+
+            # Execute the prompt via process_request
+            if context.process_request:
+                await context.process_request(
+                    prompt, context.state_manager.session.current_model, context.state_manager
+                )
+        else:
+            await ui.muted("Template activated. No default prompt defined.")
+
+        return None

tunacode/cli/main.py

@@ -12,6 +12,7 @@ import typer
 from tunacode.cli.repl import repl
 from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.state import StateManager
+from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import UserAbortError
 from tunacode.setup import setup
 from tunacode.ui import console as ui
@@ -60,6 +61,11 @@ def main(
 
         try:
             await setup(run_setup, state_manager, cli_config)
+
+            # Initialize ToolHandler after setup
+            tool_handler = ToolHandler(state_manager)
+            state_manager.set_tool_handler(tool_handler)
+
             await repl(state_manager)
         except (KeyboardInterrupt, UserAbortError):
             update_task.cancel()

tunacode/cli/repl.py

@@ -9,7 +9,6 @@ Handles user input, command processing, and agent interaction in an interactive
 # IMPORTS AND DEPENDENCIES
 # ============================================================================
 
-import json
 import logging
 import os
 import subprocess
@@ -23,28 +22,23 @@ from pydantic_ai.exceptions import UnexpectedModelBehavior
 from tunacode.constants import DEFAULT_CONTEXT_WINDOW
 from tunacode.core.agents import main as agent
 from tunacode.core.agents.main import patch_tool_messages
-from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.ui import console as ui
 from tunacode.ui.output import get_context_window_display
-from tunacode.ui.tool_ui import ToolUI
 from tunacode.utils.security import CommandSecurityError, safe_subprocess_run
 
-from ..types import CommandContext, CommandResult, StateManager, ToolArgs
+from ..types import CommandContext, CommandResult, StateManager
 from .commands import CommandRegistry
 
 # ============================================================================
 # MODULE-LEVEL CONSTANTS AND CONFIGURATION
 # ============================================================================
-
-_tool_ui = ToolUI()
+from .repl_components import attempt_tool_recovery, display_agent_output, tool_handler
+from .repl_components.output_display import MSG_REQUEST_COMPLETED
 
 MSG_OPERATION_ABORTED = "Operation aborted."
-MSG_OPERATION_ABORTED_BY_USER = "Operation aborted by user."
 MSG_TOOL_INTERRUPTED = "Tool execution was interrupted"
 MSG_REQUEST_CANCELLED = "Request cancelled"
-MSG_REQUEST_COMPLETED = "Request completed"
-MSG_JSON_RECOVERY = "Recovered using JSON tool parsing"
 MSG_SESSION_ENDED = "Session ended. Happy coding!"
 MSG_AGENT_BUSY = "Agent is busy, press Ctrl+C to interrupt."
 MSG_HIT_CTRL_C = "Hit Ctrl+C again to exit"
@@ -54,92 +48,8 @@ DEFAULT_SHELL = "bash"
 # Configure logging
 logger = logging.getLogger(__name__)
 
-# ============================================================================
-# UTILITY FUNCTIONS
-# ============================================================================
-
-
-def _parse_args(args) -> ToolArgs:
-    """
-    Parse tool arguments from a JSON string or dictionary.
-
-    Args:
-        args (str or dict): A JSON-formatted string or a dictionary containing tool arguments.
-
-    Returns:
-        dict: The parsed arguments.
-
-    Raises:
-        ValueError: If 'args' is not a string or dictionary, or if the string is not valid JSON.
-    """
-    if isinstance(args, str):
-        try:
-            return json.loads(args)
-        except json.JSONDecodeError:
-            raise ValidationError(f"Invalid JSON: {args}")
-    elif isinstance(args, dict):
-        return args
-    else:
-        raise ValidationError(f"Invalid args type: {type(args)}")
-
-
-# ============================================================================
-# TOOL EXECUTION AND CONFIRMATION HANDLERS
-# ============================================================================
-
-
-async def _tool_handler(part, state_manager: StateManager):
-    """Handle tool execution with separated business logic and UI."""
-    # Check for cancellation before tool execution (only if explicitly set to True)
-    operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
-    if operation_cancelled is True:
-        logger.debug("Tool execution cancelled")
-        raise CancelledError("Operation was cancelled")
-
-    tool_handler = ToolHandler(state_manager)
-
-    if tool_handler.should_confirm(part.tool_name):
-        await ui.info(f"Tool({part.tool_name})")
-
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.stop()
-
-    streaming_panel = None
-    if state_manager.session.is_streaming_active and hasattr(
-        state_manager.session, "streaming_panel"
-    ):
-        streaming_panel = state_manager.session.streaming_panel
-        if streaming_panel and tool_handler.should_confirm(part.tool_name):
-            await streaming_panel.stop()
-
-    try:
-        args = _parse_args(part.args)
-
-        def confirm_func():
-            if not tool_handler.should_confirm(part.tool_name):
-                return False
-            request = tool_handler.create_confirmation_request(part.tool_name, args)
-
-            response = _tool_ui.show_sync_confirmation(request)
-
-            if not tool_handler.process_confirmation(response, part.tool_name):
-                return True  # Abort
-            return False  # Continue
-
-        should_abort = await run_in_terminal(confirm_func)
-
-        if should_abort:
-            raise UserAbortError("User aborted.")
-
-    except UserAbortError:
-        patch_tool_messages(MSG_OPERATION_ABORTED_BY_USER, state_manager)
-        raise
-    finally:
-        if streaming_panel and tool_handler.should_confirm(part.tool_name):
-            await streaming_panel.start()
-
-        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-            state_manager.session.spinner.start()
+# The _parse_args function has been moved to repl_components.command_parser
+# The _tool_handler function has been moved to repl_components.tool_executor
 
 
 # ============================================================================
@@ -169,82 +79,13 @@ async def _handle_command(command: str, state_manager: StateManager) -> CommandR
         return await _command_registry.execute(command, context)
     except ValidationError as e:
         await ui.error(str(e))
+        return None
 
 
-# ============================================================================
-# ERROR RECOVERY
-# ============================================================================
-
-
-async def _attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bool:
-    """
-    Attempt to recover from tool calling failures using guard clauses.
+# The _attempt_tool_recovery function has been moved to repl_components.error_recovery
 
-    Returns:
-        bool: True if recovery was successful, False otherwise
-    """
-    error_str = str(e).lower()
-    tool_keywords = ["tool", "function", "call", "schema"]
-    if not any(keyword in error_str for keyword in tool_keywords):
-        return False
 
-    if not state_manager.session.messages:
-        return False
-
-    last_msg = state_manager.session.messages[-1]
-    if not hasattr(last_msg, "parts"):
-        return False
-
-    for part in last_msg.parts:
-        if not hasattr(part, "content") or not isinstance(part.content, str):
-            continue
-
-        try:
-            from tunacode.core.agents.main import extract_and_execute_tool_calls
-
-            def tool_callback_with_state(part, node):
-                return _tool_handler(part, state_manager)
-
-            await extract_and_execute_tool_calls(
-                part.content, tool_callback_with_state, state_manager
-            )
-
-            await ui.warning(f" {MSG_JSON_RECOVERY}")
-            return True
-
-        except Exception as e:
-            logger.debug(f"Failed to check triple quotes: {e}")
-            continue
-
-    return False
-
-
-# ============================================================================
-# AGENT OUTPUT DISPLAY
-# ============================================================================
-
-
-async def _display_agent_output(res, enable_streaming: bool) -> None:
-    """Display agent output using guard clauses to flatten nested conditionals."""
-    if enable_streaming:
-        return
-
-    if not hasattr(res, "result") or res.result is None or not hasattr(res.result, "output"):
-        await ui.muted(MSG_REQUEST_COMPLETED)
-        return
-
-    output = res.result.output
-
-    if not isinstance(output, str):
-        return
-
-    if output.strip().startswith('{"thought"'):
-        return
-
-    if '"tool_uses"' in output:
-        return
-
-    await ui.agent(output)
+# The _display_agent_output function has been moved to repl_components.output_display
 
 
 # ============================================================================
@@ -254,6 +95,14 @@ async def _display_agent_output(res, enable_streaming: bool) -> None:
 
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
     """Process input using the agent, handling cancellation safely."""
+    import uuid
+
+    # Generate a unique ID for this request for correlated logging
+    request_id = str(uuid.uuid4())
+    logger.debug(
+        "Processing new request", extra={"request_id": request_id, "input_text": text[:100]}
+    )
+    state_manager.session.request_id = request_id
 
     # Check for cancellation before starting (only if explicitly set to True)
     operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
@@ -274,8 +123,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 
         start_idx = len(state_manager.session.messages)
 
-        def tool_callback_with_state(part, node):
-            return _tool_handler(part, state_manager)
+        def tool_callback_with_state(part, _node):
+            return tool_handler(part, state_manager)
 
         try:
             from tunacode.utils.text_utils import expand_file_refs
@@ -313,8 +162,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                     await streaming_panel.update(content)
 
                 res = await agent.process_request(
-                    state_manager.session.current_model,
                     text,
+                    state_manager.session.current_model,
                     state_manager,
                     tool_callback=tool_callback_with_state,
                     streaming_callback=streaming_callback,
@@ -326,8 +175,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         else:
             # Use normal agent processing
             res = await agent.process_request(
-                state_manager.session.current_model,
                 text,
+                state_manager.session.current_model,
                 state_manager,
                 tool_callback=tool_callback_with_state,
             )
@@ -351,7 +200,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 await ui.muted(MSG_REQUEST_COMPLETED)
             else:
                 # Use the dedicated function for displaying agent output
-                await _display_agent_output(res, enable_streaming)
+                await display_agent_output(res, enable_streaming)
 
             # Always show files in context after agent response
             if state_manager.session.files_in_context:
@@ -369,7 +218,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         patch_tool_messages(error_message, state_manager)
     except Exception as e:
         # Try tool recovery for tool-related errors
-        if await _attempt_tool_recovery(e, state_manager):
+        if await attempt_tool_recovery(e, state_manager):
             return  # Successfully recovered
 
         agent_error = AgentError(f"Agent processing failed: {str(e)}")
@@ -439,7 +288,13 @@ async def repl(state_manager: StateManager):
                 action = await _handle_command(line, state_manager)
                 if action == "restart":
                     break
-                continue
+                elif isinstance(action, str) and action:
+                    # If the command returned a string (e.g., from template shortcut),
+                    # process it as a prompt
+                    line = action
+                    # Fall through to process as normal text
+                else:
+                    continue
 
             if line.startswith("!"):
                 command = line[1:].strip()