tunacode-cli 0.0.48__py3-none-any.whl → 0.0.49__py3-none-any.whl

tunacode/ui/console.py

@@ -9,29 +9,26 @@ from rich.markdown import Markdown
 # Import and re-export all functions from specialized modules
 from .input import formatted_text, input, multiline_input
 from .keybindings import create_key_bindings
+
+# Unified UI logger compatibility layer
+from .logging_compat import ui_logger
 from .output import (
     banner,
     clear,
-    info,
     line,
     muted,
     print,
     spinner,
-    success,
     sync_print,
     update_available,
     usage,
     version,
-    warning,
 )
-
-# Patch banner to use sync fast version
 from .panels import (
     StreamingAgentPanel,
     agent,
     agent_streaming,
     dump_messages,
-    error,
     help,
     models,
     panel,
@@ -42,6 +39,28 @@ from .panels import (
 from .prompt_manager import PromptConfig, PromptManager
 from .validators import ModelValidator
 
+
+# Async wrappers for UI logging
+async def info(message: str) -> None:
+    await ui_logger.info(message)
+
+
+async def warning(message: str) -> None:
+    await ui_logger.warning(message)
+
+
+async def error(message: str) -> None:
+    await ui_logger.error(message)
+
+
+async def debug(message: str) -> None:
+    await ui_logger.debug(message)
+
+
+async def success(message: str) -> None:
+    await ui_logger.success(message)
+
+
 # Create console object for backward compatibility
 console = RichConsole(force_terminal=True, legacy_windows=False)
 
@@ -68,22 +87,24 @@ __all__ = [
     "banner",
     "clear",
     "console",
-    "info",
     "line",
     "muted",
     "print",
     "spinner",
-    "success",
     "sync_print",
     "update_available",
     "usage",
     "version",
+    # Unified logging wrappers
+    "info",
     "warning",
+    "error",
+    "debug",
+    "success",
     # From panels module
     "agent",
     "agent_streaming",
     "dump_messages",
-    "error",
     "help",
     "models",
     "panel",

tunacode/ui/input.py

@@ -75,12 +75,13 @@ 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()
+    kb = create_key_bindings(state_manager)
     placeholder = formatted_text(
         (
             "<darkgrey>"
             "<bold>Enter</bold> to submit • "
             "<bold>Esc + Enter</bold> for new line • "
+            "<bold>Esc twice</bold> to cancel • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )

tunacode/ui/keybindings.py

@@ -1,9 +1,17 @@
 """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
+
+logger = logging.getLogger(__name__)
 
-def create_key_bindings() -> KeyBindings:
+
+def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
     """Create and configure key bindings for the UI."""
     kb = KeyBindings()
 
@@ -22,4 +30,53 @@ def create_key_bindings() -> KeyBindings:
         """Insert a newline when escape then enter is pressed."""
         event.current_buffer.insert_text("\n")
 
+    @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
+
+        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 += 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
+            if current_task and not current_task.done():
+                logger.debug(f"Cancelling current task: {current_task}")
+                try:
+                    current_task.cancel()
+                    logger.debug("Task cancellation initiated successfully")
+                except Exception as e:
+                    logger.debug(f"Failed to cancel task: {e}")
+            else:
+                logger.debug(f"No active task to cancel: current_task={current_task}")
+
+            # 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()
+
     return kb

tunacode/ui/logging_compat.py

@@ -0,0 +1,44 @@
+"""
+UILogger compatibility layer for unified logging.
+
+Implements the UILogger protocol using the unified logging system,
+preserving UI formatting and behavior for all log levels.
+"""
+
+from tunacode.core.logging.logger import get_logger
+from tunacode.types import UILogger
+
+
+class UnifiedUILogger(UILogger):
+    """
+    UILogger implementation that routes all UI log calls through the unified logging system.
+    Preserves UI conventions for info, error, warning, debug, and success.
+    """
+
+    def __init__(self, name: str = "ui"):
+        self.logger = get_logger(name)
+
+    async def info(self, message: str) -> None:
+        # Standard info log
+        self.logger.info(message)
+
+    async def error(self, message: str) -> None:
+        # Standard error log
+        self.logger.error(message)
+
+    async def warning(self, message: str) -> None:
+        # Standard warning log
+        self.logger.warning(message)
+
+    async def debug(self, message: str) -> None:
+        # Standard debug log
+        self.logger.debug(message)
+
+    async def success(self, message: str) -> None:
+        # "Success" is a UI convention; log as info with a marker for UI formatting
+        # Add a special prefix or extra field for downstream handlers/formatters
+        self.logger.info(f"[SUCCESS] {message}", extra={"ui_success": True})
+
+
+# Singleton instance for convenience
+ui_logger: UILogger = UnifiedUILogger()

tunacode/ui/output.py

@@ -18,6 +18,7 @@ from tunacode.utils.token_counter import format_token_count
 
 from .constants import SPINNER_TYPE
 from .decorators import create_sync_wrapper
+from .logging_compat import ui_logger
 
 # Create console with explicit settings to ensure ANSI codes work properly
 console = Console(force_terminal=True, legacy_windows=False)
@@ -54,18 +55,18 @@ async def line() -> None:
 
 
 async def info(text: str) -> None:
-    """Print an informational message."""
-    await print(f"[{colors.primary}]●[/{colors.primary}] {text}", style=colors.muted)
+    """Unified logging: informational message."""
+    await ui_logger.info(text)
 
 
 async def success(message: str) -> None:
-    """Print a success message."""
-    await print(f"[{colors.success}]✓[/{colors.success}] {message}")
+    """Unified logging: success message."""
+    await ui_logger.success(message)
 
 
 async def warning(text: str) -> None:
-    """Print a warning message."""
-    await print(f"[{colors.warning}]⚠[/{colors.warning}] {text}")
+    """Unified logging: warning message."""
+    await ui_logger.warning(text)
 
 
 async def muted(text: str) -> None:

tunacode/ui/panels.py

@@ -30,7 +30,6 @@ from tunacode.constants import (
     DESC_MODEL_SWITCH,
     DESC_YOLO,
     PANEL_AVAILABLE_COMMANDS,
-    PANEL_ERROR,
     PANEL_MESSAGE_HISTORY,
     PANEL_MODELS,
     UI_COLORS,
@@ -87,11 +86,17 @@ class StreamingAgentPanel:
     def _create_panel(self) -> Panel:
         """Create a Rich panel with current content."""
         # Use the UI_THINKING_MESSAGE constant instead of hardcoded text
+        from rich.text import Text
+
         from tunacode.constants import UI_THINKING_MESSAGE
 
-        markdown_content = Markdown(self.content or UI_THINKING_MESSAGE)
+        # Handle the default thinking message with Rich markup
+        if not self.content:
+            content_renderable = Text.from_markup(UI_THINKING_MESSAGE)
+        else:
+            content_renderable = Markdown(self.content)
         panel_obj = Panel(
-            Padding(markdown_content, (0, 1, 0, 1)),
+            Padding(content_renderable, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",
             title_align="left",
             border_style=colors.primary,
@@ -130,7 +135,25 @@ class StreamingAgentPanel:
     async def stop(self):
         """Stop the live streaming display."""
         if self.live:
+            # Get the console before stopping the live display
+            from .output import console
+
+            # Stop the live display
             self.live.stop()
+
+            # Comprehensive cleanup to prevent extra lines
+            console.print("", end="")  # Reset the current line without newline
+            if hasattr(console, "file") and hasattr(console.file, "flush"):
+                console.file.flush()  # Ensure output is flushed
+
+            # Mark that we just finished streaming (for output control)
+            try:
+                from tunacode.core.logging.handlers import _streaming_context
+
+                _streaming_context["just_finished"] = True
+            except ImportError:
+                pass  # If we can't import, continue without the optimization
+
             self.live = None
 
 
@@ -152,8 +175,10 @@ async def agent_streaming(content_stream, bottom: int = 1):
 
 
 async def error(text: str) -> None:
-    """Display an error panel."""
-    await panel(PANEL_ERROR, text, style=colors.error)
+    """Unified logging: error message."""
+    from .logging_compat import ui_logger
+
+    await ui_logger.error(text)
 
 
 async def dump_messages(messages_list=None, state_manager: StateManager = None) -> None: