tunacode-cli 0.0.54__py3-none-any.whl → 0.0.56__py3-none-any.whl

tunacode/ui/input.py

@@ -76,19 +76,28 @@ async def multiline_input(
 ) -> str:
     """Get multiline input from the user with @file completion and highlighting."""
     kb = create_key_bindings(state_manager)
+
+    # Clear any residual terminal output
+    import sys
+    sys.stdout.flush()
+
+    # Full placeholder with all keyboard shortcuts
     placeholder = formatted_text(
         (
             "<darkgrey>"
             "<bold>Enter</bold> to submit • "
             "<bold>Esc + Enter</bold> for new line • "
             "<bold>Esc twice</bold> to cancel • "
+            "<bold>Shift + Tab</bold> toggle plan mode • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )
     )
-    return await input(
+
+    # Display input area (Plan Mode indicator is handled dynamically in prompt manager)
+    result = await input(
         "multiline",
-        pretext="> ",  # Default prompt
+        pretext="> ",
         key_bindings=kb,
         multiline=True,
         placeholder=placeholder,
@@ -96,3 +105,5 @@ async def multiline_input(
         lexer=FileReferenceLexer(),
         state_manager=state_manager,
     )
+
+    return result

tunacode/ui/keybindings.py

@@ -1,9 +1,7 @@
 """Key binding handlers for TunaCode UI."""
 
 import logging
-import time
 
-from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.key_binding import KeyBindings
 
 from ..core.state import StateManager
@@ -32,38 +30,12 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
 
     @kb.add("escape")
     def _escape(event):
-        """Handle ESC key with double-press logic: first press warns, second cancels."""
-        if not state_manager:
-            logger.debug("Escape key pressed without state manager")
-            return
+        """Handle ESC key - trigger Ctrl+C behavior."""
+        logger.debug("ESC key pressed - simulating Ctrl+C")
 
-        current_time = time.time()
-        session = state_manager.session
-
-        # Reset counter if too much time has passed (3 seconds timeout)
-        if session.last_esc_time and (current_time - session.last_esc_time) > 3.0:
-            session.esc_press_count = 0
-
-        session.esc_press_count = (session.esc_press_count or 0) + 1
-        session.last_esc_time = current_time
-
-        logger.debug(f"ESC key pressed: count={session.esc_press_count}, time={current_time}")
-
-        if session.esc_press_count == 1:
-            # First ESC press - show warning message
-            from ..ui.output import warning
-
-            run_in_terminal(lambda: warning("Hit ESC again within 3 seconds to cancel operation"))
-            logger.debug("First ESC press - showing warning")
-        else:
-            # Second ESC press - cancel operation
-            session.esc_press_count = 0  # Reset counter
-            logger.debug("Second ESC press - initiating cancellation")
-
-            # Mark the session as being cancelled to prevent new operations
-            session.operation_cancelled = True
-
-            current_task = session.current_task
+        # Cancel any active task if present
+        if state_manager and hasattr(state_manager.session, "current_task"):
+            current_task = state_manager.session.current_task
             if current_task and not current_task.done():
                 logger.debug(f"Cancelling current task: {current_task}")
                 try:
@@ -71,12 +43,28 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
                     logger.debug("Task cancellation initiated successfully")
                 except Exception as e:
                     logger.debug(f"Failed to cancel task: {e}")
+
+        # Trigger the same behavior as Ctrl+C by sending the signal
+        import os
+        import signal
+        os.kill(os.getpid(), signal.SIGINT)
+
+    @kb.add("s-tab")  # shift+tab
+    def _toggle_plan_mode(event):
+        """Toggle between Plan Mode and normal mode."""
+        if state_manager:
+            # Toggle the state
+            if state_manager.is_plan_mode():
+                state_manager.exit_plan_mode()
+                logger.debug("Toggled to normal mode via Shift+Tab")
             else:
-                logger.debug(f"No active task to cancel: current_task={current_task}")
+                state_manager.enter_plan_mode()
+                logger.debug("Toggled to Plan Mode via Shift+Tab")
+
+            # Clear the current buffer and refresh the display
+            event.current_buffer.reset()
 
-            # Force exit the current input by raising KeyboardInterrupt
-            # This will be caught by the prompt manager and converted to UserAbortError
-            logger.debug("Raising KeyboardInterrupt to abort current operation")
-            raise KeyboardInterrupt()
+            # Force a refresh of the application without exiting
+            event.app.invalidate()
 
     return kb

tunacode/ui/output.py

@@ -1,5 +1,7 @@
 """Output and display functions for TunaCode UI."""
 
+from typing import Optional
+
 from prompt_toolkit.application import run_in_terminal
 from rich.console import Console
 from rich.padding import Padding
@@ -109,20 +111,39 @@ async def show_update_message(latest_version: str) -> None:
     await update_available(latest_version)
 
 
-async def spinner(show: bool = True, spinner_obj=None, state_manager: StateManager = None):
-    """Manage a spinner display."""
+async def spinner(
+    show: bool = True,
+    spinner_obj=None,
+    state_manager: StateManager = None,
+    message: Optional[str] = None,
+):
+    """Manage a spinner display with dynamic message support.
+
+    Args:
+        show: Whether to show (True) or hide (False) the spinner
+        spinner_obj: Existing spinner object to reuse
+        state_manager: State manager instance for storing spinner
+        message: Optional custom message to display (uses UI_THINKING_MESSAGE if None)
+
+    Returns:
+        The spinner object for further manipulation
+    """
     icon = SPINNER_TYPE
-    message = UI_THINKING_MESSAGE
+    display_message = message or UI_THINKING_MESSAGE
 
     # Get spinner from state manager if available
     if spinner_obj is None and state_manager:
         spinner_obj = state_manager.session.spinner
 
     if not spinner_obj:
-        spinner_obj = await run_in_terminal(lambda: console.status(message, spinner=icon))
+        spinner_obj = await run_in_terminal(lambda: console.status(display_message, spinner=icon))
         # Store it back in state manager if available
         if state_manager:
             state_manager.session.spinner = spinner_obj
+    else:
+        # Update existing spinner message if provided
+        if message and hasattr(spinner_obj, "update"):
+            spinner_obj.update(display_message)
 
     if show:
         spinner_obj.start()
@@ -132,6 +153,20 @@ async def spinner(show: bool = True, spinner_obj=None, state_manager: StateManag
     return spinner_obj
 
 
+async def update_spinner_message(message: str, state_manager: StateManager = None):
+    """Update the spinner message if a spinner is active.
+
+    Args:
+        message: New message to display
+        state_manager: State manager instance containing spinner
+    """
+    if state_manager and state_manager.session.spinner:
+        spinner_obj = state_manager.session.spinner
+        if hasattr(spinner_obj, "update"):
+            # Rich's Status object supports update method
+            await run_in_terminal(lambda: spinner_obj.update(message))
+
+
 def get_context_window_display(total_tokens: int, max_tokens: int) -> str:
     """
     Create a color-coded display for the context window status.

tunacode/ui/panels.py

@@ -1,5 +1,7 @@
 """Panel display functions for TunaCode UI."""
 
+import asyncio
+import time
 from typing import Any, Optional, Union
 
 from rich.box import ROUNDED
@@ -81,11 +83,24 @@ async def agent(text: str, bottom: int = 1) -> None:
 class StreamingAgentPanel:
     """Streaming agent panel using Rich.Live for progressive display."""
 
+    bottom: int
+    title: str
+    content: str
+    live: Optional[Live]
+    _last_update_time: float
+    _dots_task: Optional[asyncio.Task]
+    _dots_count: int
+    _show_dots: bool
+
     def __init__(self, bottom: int = 1):
         self.bottom = bottom
         self.title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
         self.content = ""
         self.live = None
+        self._last_update_time = 0.0
+        self._dots_task = None
+        self._dots_count = 0
+        self._show_dots = False
 
     def _create_panel(self) -> Padding:
         """Create a Rich panel with current content."""
@@ -94,11 +109,19 @@ class StreamingAgentPanel:
 
         from tunacode.constants import UI_THINKING_MESSAGE
 
-        # Handle the default thinking message with Rich markup
+        # Show "Thinking..." only when no content has arrived yet
         if not self.content:
             content_renderable: Union[Text, Markdown] = Text.from_markup(UI_THINKING_MESSAGE)
         else:
-            content_renderable = Markdown(self.content)
+            # Once we have content, show it with optional dots animation
+            display_content = self.content
+            # Add animated dots if we're waiting for more content
+            if self._show_dots:
+                # Cycle through: "", ".", "..", "..."
+                dots_patterns = ["", ".", "..", "..."]
+                dots = dots_patterns[self._dots_count % len(dots_patterns)]
+                display_content = self.content.rstrip() + dots
+            content_renderable = Markdown(display_content)
         panel_obj = Panel(
             Padding(content_renderable, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",
@@ -117,31 +140,85 @@ class StreamingAgentPanel:
             ),
         )
 
+    async def _animate_dots(self):
+        """Animate dots after a pause in streaming."""
+        while True:
+            await asyncio.sleep(0.5)
+            current_time = time.time()
+            # Only show dots after 1 second of no updates
+            if current_time - self._last_update_time > 1.0:
+                self._show_dots = True
+                self._dots_count += 1
+                if self.live:
+                    self.live.update(self._create_panel())
+            else:
+                self._show_dots = False
+                self._dots_count = 0
+
     async def start(self):
         """Start the live streaming display."""
         from .output import console
 
         self.live = Live(self._create_panel(), console=console, refresh_per_second=4)
         self.live.start()
+        self._last_update_time = time.time()
+        # Start the dots animation task
+        self._dots_task = asyncio.create_task(self._animate_dots())
 
     async def update(self, content_chunk: str):
         """Update the streaming display with new content."""
         # Defensive: some providers may yield None chunks intermittently
         if content_chunk is None:
             content_chunk = ""
+            
+        # Filter out plan mode system prompts and tool definitions from streaming
+        if any(phrase in str(content_chunk) for phrase in [
+            "🔧 PLAN MODE",
+            "TOOL EXECUTION ONLY",
+            "planning assistant that ONLY communicates",
+            "namespace functions {",
+            "namespace multi_tool_use {",
+            "You are trained on data up to"
+        ]):
+            return
+            
         # Ensure type safety for concatenation
         self.content = (self.content or "") + str(content_chunk)
+
+        # Reset the update timer when we get new content
+        self._last_update_time = time.time()
+        self._show_dots = False  # Hide dots immediately when new content arrives
+
         if self.live:
             self.live.update(self._create_panel())
 
     async def set_content(self, content: str):
         """Set the complete content (overwrites previous)."""
+        # Filter out plan mode system prompts and tool definitions
+        if any(phrase in str(content) for phrase in [
+            "🔧 PLAN MODE",
+            "TOOL EXECUTION ONLY",
+            "planning assistant that ONLY communicates",
+            "namespace functions {",
+            "namespace multi_tool_use {",
+            "You are trained on data up to"
+        ]):
+            return
+            
         self.content = content
         if self.live:
             self.live.update(self._create_panel())
 
     async def stop(self):
         """Stop the live streaming display."""
+        # Cancel the dots animation task
+        if self._dots_task:
+            self._dots_task.cancel()
+            try:
+                await self._dots_task
+            except asyncio.CancelledError:
+                pass
+
         if self.live:
             # Get the console before stopping the live display
             from .output import console

tunacode/ui/prompt_manager.py

@@ -100,15 +100,32 @@ class PromptManager:
         """
         session = self.get_session(session_key, config)
 
-        # Create a custom prompt that changes based on input
+        # Create a custom prompt that changes based on input and plan mode
         def get_prompt():
+            # Start with the base prompt
+            base_prompt = prompt
+
+            # Add Plan Mode indicator if active
+            if (self.state_manager and
+                self.state_manager.is_plan_mode() and
+                "PLAN MODE ON" not in base_prompt):
+                base_prompt = '<style fg="#40E0D0"><bold>⏸  PLAN MODE ON</bold></style>\n' + base_prompt
+            elif (self.state_manager and
+                  not self.state_manager.is_plan_mode() and
+                  ("⏸" in base_prompt or "PLAN MODE ON" in base_prompt)):
+                # Remove plan mode indicator if no longer in plan mode
+                lines = base_prompt.split("\n")
+                if len(lines) > 1 and ("⏸" in lines[0] or "PLAN MODE ON" in lines[0]):
+                    base_prompt = "\n".join(lines[1:])
+
             # Check if current buffer starts with "!"
             if hasattr(session.app, "current_buffer") and session.app.current_buffer:
                 text = session.app.current_buffer.text
                 if text.startswith("!"):
                     # Use bright yellow background with black text for high visibility
                     return HTML('<style bg="#ffcc00" fg="black"><b> ◆ BASH MODE ◆ </b></style> ')
-            return HTML(prompt) if isinstance(prompt, str) else prompt
+
+            return HTML(base_prompt) if isinstance(base_prompt, str) else base_prompt
 
         try:
             # Get user input with dynamic prompt

tunacode/ui/tool_descriptions.py

@@ -0,0 +1,115 @@
+"""Tool description mappings for user-friendly spinner messages."""
+
+from typing import Dict, Optional
+
+
+def get_tool_description(tool_name: str, args: Optional[Dict] = None) -> str:
+    """
+    Get a human-readable description for a tool execution.
+
+    Args:
+        tool_name: Name of the tool being executed
+        args: Optional tool arguments for more specific descriptions
+
+    Returns:
+        User-friendly description of the tool operation
+    """
+    # Base descriptions for each tool
+    base_descriptions = {
+        # File operations
+        "read_file": "Reading file",
+        "write_file": "Writing file",
+        "update_file": "Updating file",
+        "create_file": "Creating file",
+        "delete_file": "Deleting file",
+        # Directory operations
+        "list_dir": "Listing directory",
+        "create_dir": "Creating directory",
+        "delete_dir": "Deleting directory",
+        # Search operations
+        "grep": "Searching files",
+        "glob": "Finding files",
+        "find_files": "Searching for files",
+        # Code operations
+        "run_command": "Executing command",
+        "bash": "Running shell command",
+        "python": "Executing Python code",
+        # Analysis operations
+        "analyze_code": "Analyzing code",
+        "lint": "Running linter",
+        "format_code": "Formatting code",
+        # Version control
+        "git_status": "Checking git status",
+        "git_diff": "Getting git diff",
+        "git_commit": "Creating git commit",
+        # Testing
+        "run_tests": "Running tests",
+        "test": "Executing tests",
+        # Documentation
+        "generate_docs": "Generating documentation",
+        "update_docs": "Updating documentation",
+        # Default
+        "unknown": "Processing",
+    }
+
+    # Get base description
+    base_desc = base_descriptions.get(tool_name, f"Executing {tool_name}")
+
+    # Add specific details from args if available
+    if args:
+        if tool_name == "read_file" and "file_path" in args:
+            return f"{base_desc}: {args['file_path']}"
+        elif tool_name == "write_file" and "file_path" in args:
+            return f"{base_desc}: {args['file_path']}"
+        elif tool_name == "update_file" and "file_path" in args:
+            return f"{base_desc}: {args['file_path']}"
+        elif tool_name == "list_dir" and "directory" in args:
+            return f"{base_desc}: {args['directory']}"
+        elif tool_name == "grep" and "pattern" in args:
+            pattern = args["pattern"]
+            # Truncate long patterns
+            if len(pattern) > 30:
+                pattern = pattern[:27] + "..."
+            return f"{base_desc} for: {pattern}"
+        elif tool_name == "glob" and "pattern" in args:
+            return f"{base_desc}: {args['pattern']}"
+        elif tool_name == "run_command" and "command" in args:
+            cmd = args["command"]
+            # Truncate long commands
+            if len(cmd) > 40:
+                cmd = cmd[:37] + "..."
+            return f"{base_desc}: {cmd}"
+        elif tool_name == "bash" and "command" in args:
+            cmd = args["command"]
+            if len(cmd) > 40:
+                cmd = cmd[:37] + "..."
+            return f"{base_desc}: {cmd}"
+
+    return base_desc
+
+
+def get_batch_description(tool_count: int, tool_names: Optional[list] = None) -> str:
+    """
+    Get a description for batch tool execution.
+
+    Args:
+        tool_count: Number of tools being executed
+        tool_names: Optional list of tool names for more detail
+
+    Returns:
+        Description of the batch operation
+    """
+    if tool_count == 1:
+        return "Executing 1 tool"
+
+    if tool_names and len(set(tool_names)) == 1:
+        # All tools are the same type
+        tool_type = tool_names[0]
+        if tool_type == "read_file":
+            return f"Reading {tool_count} files in parallel"
+        elif tool_type == "grep":
+            return f"Searching {tool_count} patterns in parallel"
+        elif tool_type == "list_dir":
+            return f"Listing {tool_count} directories in parallel"
+
+    return f"Executing {tool_count} tools in parallel"

tunacode/ui/tool_ui.py

@@ -76,8 +76,9 @@ class ToolUI:
 
         # Show file content on write_file
         elif tool_name == TOOL_WRITE_FILE:
-            markdown_obj = self._create_code_block(args["filepath"], args["content"])
-            return str(markdown_obj)
+            lang = ext_to_lang(args["filepath"])
+            code_block = f"```{lang}\n{args['content']}\n```"
+            return code_block
 
         # Default to showing key and value on new line
         content = ""

tunacode/utils/message_utils.py

@@ -9,11 +9,21 @@ def get_message_content(message: Any) -> str:
         return message
     if isinstance(message, dict):
         if "content" in message:
-            return message["content"]
+            content = message["content"]
+            # Handle nested content structures
+            if isinstance(content, list):
+                return " ".join(get_message_content(item) for item in content)
+            return str(content)
         if "thought" in message:
-            return message["thought"]
+            return str(message["thought"])
     if hasattr(message, "content"):
-        return message.content
+        content = message.content
+        if isinstance(content, list):
+            return " ".join(get_message_content(item) for item in content)
+        return str(content)
     if hasattr(message, "parts"):
-        return " ".join(get_message_content(part) for part in message.parts)
+        parts = message.parts
+        if isinstance(parts, list):
+            return " ".join(get_message_content(part) for part in parts)
+        return str(parts)
     return ""

{tunacode_cli-0.0.54.dist-info → tunacode_cli-0.0.56.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.54
+Version: 0.0.56
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT
@@ -39,6 +39,7 @@ Requires-Dist: vulture>=2.7; extra == "dev"
 Requires-Dist: unimport>=1.0.0; extra == "dev"
 Requires-Dist: autoflake>=2.0.0; extra == "dev"
 Requires-Dist: dead>=1.5.0; extra == "dev"
+Requires-Dist: hatch>=1.6.0; extra == "dev"
 Dynamic: license-file
 
 # TunaCode CLI
@@ -106,7 +107,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models
 
@@ -243,7 +244,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models