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

api/auth.py

@@ -0,0 +1,13 @@
+import jwt
+
+
+def authenticate(username, password):
+    # TODO: Add password hashing
+    if username == "admin" and password == "admin":
+        return generate_token(username)
+    return None
+
+
+def generate_token(username):
+    # TODO: Add expiration
+    return jwt.encode({"user": username}, "secret")

api/users.py

@@ -0,0 +1,8 @@
+from .auth import authenticate
+
+
+class UserManager:
+    def login(self, username, password):
+        token = authenticate(username, password)
+        # TODO: Store session
+        return token

tunacode/__init__.py

@@ -0,0 +1,4 @@
+# Initialize unified logging system on package import
+from tunacode.core.logging import setup_logging
+
+setup_logging()

tunacode/cli/repl.py

@@ -90,6 +90,12 @@ def _parse_args(args) -> ToolArgs:
 
 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):
@@ -249,6 +255,12 @@ 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."""
 
+    # Check for cancellation before starting (only if explicitly set to True)
+    operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+    if operation_cancelled is True:
+        logger.debug("Operation cancelled before processing started")
+        raise CancelledError("Operation was cancelled")
+
     state_manager.session.spinner = await ui.spinner(
         True, state_manager.session.spinner, state_manager
     )
@@ -275,6 +287,12 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             await ui.error(str(e))
             return
 
+        # Check for cancellation before proceeding with agent call (only if explicitly set to True)
+        operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+        if operation_cancelled is True:
+            logger.debug("Operation cancelled before agent processing")
+            raise CancelledError("Operation was cancelled")
+
         enable_streaming = state_manager.session.user_config.get("settings", {}).get(
             "enable_streaming", True
         )
@@ -338,13 +356,13 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             # Always show files in context after agent response
             if state_manager.session.files_in_context:
                 filenames = [Path(f).name for f in sorted(state_manager.session.files_in_context)]
-                await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
+                await ui.muted(f"Files in context: {', '.join(filenames)}")
 
     # --- ERROR HANDLING ---
     except CancelledError:
         await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted(MSG_OPERATION_ABORTED_BY_USER)
+        await ui.muted(MSG_OPERATION_ABORTED)
     except UnexpectedModelBehavior as e:
         error_message = str(e)
         await ui.muted(error_message)
@@ -360,6 +378,9 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     finally:
         await ui.spinner(False, state_manager.session.spinner, state_manager)
         state_manager.session.current_task = None
+        # Reset cancellation flag when task completes (if attribute exists)
+        if hasattr(state_manager.session, "operation_cancelled"):
+            state_manager.session.operation_cancelled = False
 
         if "multiline" in state_manager.session.input_sessions:
             await run_in_terminal(
@@ -460,9 +481,14 @@ async def repl(state_manager: StateManager):
                 await ui.muted(MSG_AGENT_BUSY)
                 continue
 
+            # Reset cancellation flag for new operations (if attribute exists)
+            if hasattr(state_manager.session, "operation_cancelled"):
+                state_manager.session.operation_cancelled = False
+
             state_manager.session.current_task = get_app().create_background_task(
                 process_request(line, state_manager)
             )
+            await state_manager.session.current_task
 
             state_manager.session.update_token_count()
             context_display = get_context_window_display(

tunacode/constants.py

@@ -7,7 +7,8 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.47"
+APP_VERSION = "0.0.49"
+
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode/core/agents/main.py

@@ -6,7 +6,6 @@ Handles agent creation, configuration, and request processing.
 
 import asyncio
 import json
-import logging
 import os
 import re
 from datetime import datetime, timezone
@@ -15,6 +14,8 @@ from typing import Any, Iterator, List, Optional, Tuple
 
 from pydantic_ai import Agent
 
+from tunacode.core.logging.logger import get_logger
+
 # Import streaming types with fallback for older versions
 try:
     from pydantic_ai.messages import (
@@ -30,7 +31,6 @@ except ImportError:
     STREAMING_AVAILABLE = False
 
 from tunacode.constants import READ_ONLY_TOOLS
-from tunacode.core.recursive import RecursiveTaskExecutor
 from tunacode.core.state import StateManager
 from tunacode.core.token_usage.api_response_parser import ApiResponseParser
 from tunacode.core.token_usage.cost_calculator import CostCalculator
@@ -60,7 +60,7 @@ from tunacode.types import (
 )
 
 # Configure logging
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ToolBuffer:
@@ -528,12 +528,12 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 tunacode_content = tunacode_path.read_text(encoding="utf-8")
                 if tunacode_content.strip():
                     # Log that we found TUNACODE.md
-                    print("📄 TUNACODE.md located: Loading context...")
+                    logger.info("📄 TUNACODE.md located: Loading context...")
 
                     system_prompt += "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
             else:
                 # Log that TUNACODE.md was not found
-                print("📄 TUNACODE.md not found: Using default context")
+                logger.info("📄 TUNACODE.md not found: Using default context")
         except Exception as e:
             # Log errors loading TUNACODE.md at debug level
             logger.debug(f"Error loading TUNACODE.md: {e}")
@@ -547,9 +547,8 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 system_prompt += f'\n\n# Current Todo List\n\nYou have existing todos that need attention:\n\n{current_todos}\n\nRemember to check progress on these todos and update them as you work. Use todo("list") to see current status anytime.'
         except Exception as e:
             # Log error but don't fail agent creation
-            import sys
 
-            print(f"Warning: Failed to load todos: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Failed to load todos: {e}")
 
         state_manager.session.agents[model] = Agent(
             model=model,
@@ -763,55 +762,6 @@ async def process_request(
             "fallback_response", True
         )
 
-        # Check if recursive execution is enabled
-        use_recursive = state_manager.session.user_config.get("settings", {}).get(
-            "use_recursive_execution", True
-        )
-        recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
-            "recursive_complexity_threshold", 0.7
-        )
-
-        # Check if recursive execution should be used
-        if use_recursive and state_manager.session.current_recursion_depth == 0:
-            try:
-                # Initialize recursive executor
-                recursive_executor = RecursiveTaskExecutor(
-                    state_manager=state_manager,
-                    max_depth=state_manager.session.max_recursion_depth,
-                    min_complexity_threshold=recursive_threshold,
-                    default_iteration_budget=max_iterations,
-                )
-
-                # Analyze task complexity
-                complexity_result = await recursive_executor.decomposer.analyze_and_decompose(
-                    message
-                )
-
-                if (
-                    complexity_result.should_decompose
-                    and complexity_result.total_complexity >= recursive_threshold
-                ):
-                    if state_manager.session.show_thoughts:
-                        from tunacode.ui import console as ui
-
-                        await ui.muted(
-                            f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
-                        )
-                        await ui.muted(f"Reasoning: {complexity_result.reasoning}")
-                        await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
-
-                    # Execute recursively
-                    success, result, error = await recursive_executor.execute_task(
-                        request=message, parent_task_id=None, depth=0
-                    )
-
-                    # For now, fall back to normal execution
-                    # TODO: Properly integrate recursive execution results
-                    pass
-            except Exception as e:
-                logger.warning(f"Recursive execution failed, falling back to normal: {e}")
-                # Continue with normal execution
-
         from tunacode.configuration.models import ModelRegistry
         from tunacode.core.token_usage.usage_tracker import UsageTracker
 
@@ -910,28 +860,27 @@ async def process_request(
                 buffered_tasks = tool_buffer.flush()
                 start_time = time.time()
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted("\n" + "=" * 60)
-                    await ui.muted(
-                        f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
-                    )
-                    await ui.muted("=" * 60)
+                await ui.muted("\n" + "=" * 60)
+                await ui.muted(
+                    f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
+                )
+                await ui.muted("=" * 60)
 
-                    for idx, (part, node) in enumerate(buffered_tasks, 1):
-                        tool_desc = f"  [{idx}] {part.tool_name}"
-                        if hasattr(part, "args") and isinstance(part.args, dict):
-                            if part.tool_name == "read_file" and "file_path" in part.args:
-                                tool_desc += f" → {part.args['file_path']}"
-                            elif part.tool_name == "grep" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                                if "include_files" in part.args:
-                                    tool_desc += f", files: '{part.args['include_files']}'"
-                            elif part.tool_name == "list_dir" and "directory" in part.args:
-                                tool_desc += f" → {part.args['directory']}"
-                            elif part.tool_name == "glob" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                        await ui.muted(tool_desc)
-                    await ui.muted("=" * 60)
+                for idx, (part, node) in enumerate(buffered_tasks, 1):
+                    tool_desc = f"  [{idx}] {part.tool_name}"
+                    if hasattr(part, "args") and isinstance(part.args, dict):
+                        if part.tool_name == "read_file" and "file_path" in part.args:
+                            tool_desc += f" → {part.args['file_path']}"
+                        elif part.tool_name == "grep" and "pattern" in part.args:
+                            tool_desc += f" → pattern: '{part.args['pattern']}'"
+                            if "include_files" in part.args:
+                                tool_desc += f", files: '{part.args['include_files']}'"
+                        elif part.tool_name == "list_dir" and "directory" in part.args:
+                            tool_desc += f" → {part.args['directory']}"
+                        elif part.tool_name == "glob" and "pattern" in part.args:
+                            tool_desc += f" → pattern: '{part.args['pattern']}'"
+                    await ui.muted(tool_desc)
+                await ui.muted("=" * 60)
 
                 await execute_tools_parallel(buffered_tasks, tool_callback)
 
@@ -939,11 +888,10 @@ async def process_request(
                 sequential_estimate = len(buffered_tasks) * 100
                 speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted(
-                        f"✅ Final batch completed in {elapsed_time:.0f}ms "
-                        f"(~{speedup:.1f}x faster than sequential)\n"
-                    )
+                await ui.muted(
+                    f"✅ Final batch completed in {elapsed_time:.0f}ms "
+                    f"(~{speedup:.1f}x faster than sequential)\n"
+                )
 
             # If we need to add a fallback response, create a wrapper
             if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
@@ -1089,6 +1037,7 @@ async def process_request(
                             f"'{type(self).__name__}' object has no attribute '{name}'"
                         )
 
-            return AgentRunWithState(agent_run)
+        return AgentRunWithState(agent_run)
     except asyncio.CancelledError:
-        raise UserAbortError("User aborted the request.")
+        # When task is cancelled, raise UserAbortError instead
+        raise UserAbortError("Operation was cancelled by user")

tunacode/core/logging/__init__.py

@@ -0,0 +1,29 @@
+import logging
+
+# Custom log level: THOUGHT
+THOUGHT = 25
+logging.addLevelName(THOUGHT, "THOUGHT")
+
+
+def thought(self, message, *args, **kwargs):
+    if self.isEnabledFor(THOUGHT):
+        self._log(THOUGHT, message, args, **kwargs)
+
+
+logging.Logger.thought = thought
+
+
+# RichHandler for UI output (stub, real implementation in handlers.py)
+class RichHandler(logging.Handler):
+    def emit(self, record):
+        # Actual implementation in handlers.py
+        pass
+
+
+def setup_logging(config_path=None):
+    """
+    Set up logging configuration from YAML file.
+    """
+    from .config import LogConfig
+
+    LogConfig.load(config_path)

tunacode/core/logging/config.py

@@ -0,0 +1,28 @@
+import logging
+import logging.config
+import os
+
+import yaml
+
+DEFAULT_CONFIG_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
+)
+
+
+class LogConfig:
+    @staticmethod
+    def load(config_path=None):
+        """
+        Load logging configuration from YAML file and apply it.
+        """
+        path = config_path or DEFAULT_CONFIG_PATH
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Logging config file not found: {path}")
+        with open(path, "r") as f:
+            config = yaml.safe_load(f)
+        logging_config = config.get("logging", config)
+        try:
+            logging.config.dictConfig(logging_config)
+        except Exception as e:
+            print(f"Failed to configure logging: {e}")
+            logging.basicConfig(level=logging.INFO)

tunacode/core/logging/formatters.py

@@ -0,0 +1,48 @@
+import logging
+
+
+class SimpleFormatter(logging.Formatter):
+    """
+    Simple formatter for UI output.
+    """
+
+    def __init__(self):
+        super().__init__("[%(levelname)s] %(message)s")
+
+
+class DetailedFormatter(logging.Formatter):
+    """
+    Detailed formatter for backend text logs.
+    """
+
+    def __init__(self):
+        super().__init__("[%(asctime)s] [%(levelname)s] [%(name)s:%(lineno)d] - %(message)s")
+
+
+try:
+    from pythonjsonlogger import jsonlogger
+
+    class JSONFormatter(jsonlogger.JsonFormatter):
+        """
+        JSON formatter for structured logs.
+        """
+
+        def __init__(self):
+            super().__init__("%(asctime)s %(name)s %(levelname)s %(message)s")
+except ImportError:
+    import json
+
+    class JSONFormatter(logging.Formatter):
+        """
+        Fallback JSON formatter if pythonjsonlogger is not installed.
+        """
+
+        def format(self, record):
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+            }
+            return json.dumps(log_entry)

tunacode/core/logging/handlers.py

@@ -0,0 +1,83 @@
+import json
+import logging
+
+from rich.console import Console
+from rich.text import Text
+
+# Global context for streaming state
+_streaming_context = {"just_finished": False}
+
+
+class RichHandler(logging.Handler):
+    """
+    Handler that outputs logs to the console using rich formatting.
+    """
+
+    level_icons = {
+        "INFO": "",
+        "WARNING": "⚠️",
+        "ERROR": "❌",
+        "CRITICAL": "🚨",
+        "THOUGHT": "🤔",
+        "DEBUG": "",
+    }
+
+    def __init__(self, level=logging.NOTSET):
+        super().__init__(level)
+        self.console = Console()
+
+    def emit(self, record):
+        try:
+            icon = self.level_icons.get(record.levelname, "")
+            timestamp = self.formatTime(record)
+            msg = self.format(record)
+            if icon:
+                output = f"[{timestamp}] {icon} {msg}"
+            else:
+                output = f"[{timestamp}] {msg}"
+
+            # Check if we just finished streaming to avoid extra newlines
+            just_finished_streaming = _streaming_context.get("just_finished", False)
+            if just_finished_streaming:
+                _streaming_context["just_finished"] = False  # Reset after use
+                # Don't add extra newline when transitioning from streaming
+                self.console.print(Text(output), end="\n")
+            else:
+                self.console.print(Text(output))
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime
+
+        ct = datetime.fromtimestamp(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)
+        return ct.strftime("%Y-%m-%d %H:%M:%S")
+
+
+class StructuredFileHandler(logging.FileHandler):
+    """
+    Handler that outputs logs as structured JSON lines.
+    """
+
+    def emit(self, record):
+        try:
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+                "extra_data": getattr(record, "extra", {}),
+            }
+            self.stream.write(json.dumps(log_entry) + "\n")
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime, timezone
+
+        ct = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        return ct.isoformat()

tunacode/core/logging/logger.py

@@ -0,0 +1,8 @@
+import logging
+
+
+def get_logger(name=None):
+    """
+    Get a logger instance with the given name.
+    """
+    return logging.getLogger(name)

tunacode/core/recursive/hierarchy.py

@@ -332,10 +332,11 @@ class TaskHierarchy:
         """Propagate context from one task to another.
 
         Args:
-            from_task: Source task ID
+            from_task: Source task ID (unused, kept for API consistency)
             to_task: Target task ID
             context_update: Context to propagate
         """
+        _ = from_task  # Unused but kept for API consistency
         if to_task in self._execution_contexts:
             self._execution_contexts[to_task].inherited_context.update(context_update)
 

tunacode/core/state.py

@@ -41,6 +41,10 @@ class SessionState:
     input_sessions: InputSessions = field(default_factory=dict)
     current_task: Optional[Any] = None
     todos: list[TodoItem] = field(default_factory=list)
+    # ESC key tracking for double-press functionality
+    esc_press_count: int = 0
+    last_esc_time: Optional[float] = None
+    operation_cancelled: bool = False
     # Enhanced tracking for thoughts display
     files_in_context: set[str] = field(default_factory=set)
     tool_calls: list[dict[str, Any]] = field(default_factory=list)

tunacode/tools/base.py

@@ -8,6 +8,7 @@ from abc import ABC, abstractmethod
 
 from pydantic_ai.exceptions import ModelRetry
 
+from tunacode.core.logging.logger import get_logger
 from tunacode.exceptions import FileOperationError, ToolExecutionError
 from tunacode.types import FilePath, ToolName, ToolResult, UILogger
 
@@ -22,6 +23,7 @@ class BaseTool(ABC):
             ui_logger: UI logger instance for displaying messages
         """
         self.ui = ui_logger
+        self.logger = get_logger(self.__class__.__name__)
 
     async def execute(self, *args, **kwargs) -> ToolResult:
         """Execute the tool with error handling and logging.
@@ -39,14 +41,17 @@ class BaseTool(ABC):
             ToolExecutionError: Raised for all other errors with structured information
         """
         try:
+            msg = f"{self.tool_name}({self._format_args(*args, **kwargs)})"
             if self.ui:
-                await self.ui.info(f"{self.tool_name}({self._format_args(*args, **kwargs)})")
+                await self.ui.info(msg)
+            self.logger.info(msg)
             result = await self._execute(*args, **kwargs)
             return result
         except ModelRetry as e:
             # Log as warning and re-raise for pydantic-ai
             if self.ui:
                 await self.ui.warning(str(e))
+            self.logger.warning(f"ModelRetry: {e}")
             raise
         except ToolExecutionError:
             # Already properly formatted, just re-raise
@@ -90,6 +95,7 @@ class BaseTool(ABC):
         err_msg = f"Error {self._get_error_context(*args, **kwargs)}: {error}"
         if self.ui:
             await self.ui.error(err_msg)
+        self.logger.error(err_msg)
 
         # Raise proper exception instead of returning string
         raise ToolExecutionError(tool_name=self.tool_name, message=str(error), original_error=error)

tunacode/types.py

@@ -13,7 +13,7 @@ from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Prot
 # Try to import pydantic-ai types if available
 try:
     from pydantic_ai import Agent
-    from pydantic_ai.messages import ModelRequest, ModelResponse, ToolReturnPart
+    from pydantic_ai.messages import ModelRequest, ToolReturnPart
 
     PydanticAgent = Agent
     MessagePart = Union[ToolReturnPart, Any]

tunacode/ui/completers.py

@@ -17,7 +17,7 @@ class CommandCompleter(Completer):
         self.command_registry = command_registry
 
     def get_completions(
-        self, document: Document, complete_event: CompleteEvent
+        self, document: Document, _complete_event: CompleteEvent
     ) -> Iterable[Completion]:
         """Get completions for slash commands."""
         # Get the text before cursor
@@ -65,7 +65,7 @@ class FileReferenceCompleter(Completer):
     """Completer for @file references that provides file path suggestions."""
 
     def get_completions(
-        self, document: Document, complete_event: CompleteEvent
+        self, document: Document, _complete_event: CompleteEvent
     ) -> Iterable[Completion]:
         """Get completions for @file references."""
         # Get the word before cursor

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

@@ -81,7 +81,7 @@ async def multiline_input(
             "<darkgrey>"
             "<bold>Enter</bold> to submit • "
             "<bold>Esc + Enter</bold> for new line • "
-            "<bold>Esc</bold> to cancel • "
+            "<bold>Esc twice</bold> to cancel • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )

tunacode/ui/keybindings.py

@@ -1,7 +1,9 @@
 """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
@@ -30,12 +32,51 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
 
     @kb.add("escape")
     def _escape(event):
-        """Immediately interrupts the current operation."""
-        current_task = state_manager.session.current_task if state_manager else None
-        if current_task and not current_task.done():
-            logger.debug("Interrupting current task")
-            current_task.cancel()
+        """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:
-            logger.debug("Escape key pressed outside task context")
+            # 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

@@ -9,7 +9,6 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.pretty import Pretty
 from rich.table import Table
-from rich.text import Text
 
 from tunacode.configuration.models import ModelRegistry
 from tunacode.constants import (
@@ -31,7 +30,6 @@ from tunacode.constants import (
     DESC_MODEL_SWITCH,
     DESC_YOLO,
     PANEL_AVAILABLE_COMMANDS,
-    PANEL_ERROR,
     PANEL_MESSAGE_HISTORY,
     PANEL_MODELS,
     UI_COLORS,
@@ -88,17 +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
 
-        # If no content, show thinking message with Rich markup
+        # Handle the default thinking message with Rich markup
         if not self.content:
-            content_to_display = Text.from_markup(UI_THINKING_MESSAGE)
+            content_renderable = Text.from_markup(UI_THINKING_MESSAGE)
         else:
-            # Normal content is markdown
-            content_to_display = Markdown(self.content)
-
+            content_renderable = Markdown(self.content)
         panel_obj = Panel(
-            Padding(content_to_display, (0, 1, 0, 1)),
+            Padding(content_renderable, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",
             title_align="left",
             border_style=colors.primary,
@@ -137,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
 
 
@@ -159,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:

tunacode/utils/security.py

@@ -3,13 +3,14 @@ Security utilities for safe command execution and input validation.
 Provides defensive measures against command injection attacks.
 """
 
-import logging
 import re
 import shlex
 import subprocess
 from typing import List, Optional
 
-logger = logging.getLogger(__name__)
+from tunacode.core.logging.logger import get_logger
+
+logger = get_logger(__name__)
 
 # Dangerous shell metacharacters that indicate potential injection
 DANGEROUS_CHARS = [

{tunacode_cli-0.0.47.dist-info → tunacode_cli-0.0.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.47
+Version: 0.0.49
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: textual-dev; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Dynamic: license-file
 
-# TunaCode
+# TunaCode CLI
 
 <div align="center">
 

{tunacode_cli-0.0.47.dist-info → tunacode_cli-0.0.49.dist-info}/RECORD

@@ -1,13 +1,15 @@
-tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=833fgfAmkcJmU1RmSYDhGCOzoU-eUMdgbcfBBwUQOZ4,5168
+api/auth.py,sha256=_ysF1RCXvtJR1S35lbYQZexES1lif4J6VVzEyqNK74Q,303
+api/users.py,sha256=WRcy1Vsr4cEC8CW2qeN3XrA9EMyIk47ufpMyvQ4nLuw,193
+tunacode/__init__.py,sha256=yUul8igNYMfUrHnYfioIGAqvrH8b5BKiO_pt1wVnmd0,119
+tunacode/constants.py,sha256=oxUB7zL0wk998eBXu9xV85PKp18FtYSbHlqxRy8TtbI,5169
 tunacode/context.py,sha256=_gXVCyjU052jlyRAl9tklZSwl5U_zI_EIX8XN87VVWE,2786
 tunacode/exceptions.py,sha256=oDO1SVKOgjcKIylwqdbqh_g5my4roU5mB9Nv4n_Vb0s,3877
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/setup.py,sha256=XPt4eAK-qcIZQv64jGZ_ryxcImDwps9OmXjJfIS1xcs,1899
-tunacode/types.py,sha256=Czq7jYXHq7fZQtyqkCN5_7eEu1wyYUcB50C6v3sTWDw,8188
+tunacode/types.py,sha256=y8jqLvdSDdi2Y4YECVG2uctpBjjBh9MJ4w1EDEZdYf0,8173
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
 tunacode/cli/main.py,sha256=erP6jNXcxVQOVn8sm6uNaLEAYevniVXl6Sem872mW68,2755
-tunacode/cli/repl.py,sha256=rSsUievdOdTkxzHNIEgUHbuWbk0ki78743Wz5hVFe9s,18917
+tunacode/cli/repl.py,sha256=jg2lnr-ZuYUKiSIJBDR9uFsIP7b_gBA6EoxMDgTSwCw,20385
 tunacode/cli/commands/__init__.py,sha256=zmE9JcJ9Qd2xJhgdS4jMDJOoZsrAZmL5MAFxbKkk7F8,1670
 tunacode/cli/commands/base.py,sha256=GxUuDsDSpz0iXryy8MrEw88UM3C3yxL__kDK1QhshoA,2517
 tunacode/cli/commands/registry.py,sha256=XVuLpp5S4Fw7GfIZfLrVZFo4jMLMNmYNpYN7xWgXyOk,8223
@@ -24,20 +26,25 @@ tunacode/configuration/models.py,sha256=buH8ZquvcYI3OQBDIZeJ08cu00rSCeNABtUwl3VQ
 tunacode/configuration/settings.py,sha256=KoN0u6GG3Hh_TWt02D_wpRfbACYri3gCDTXHtJfHl2w,994
 tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,15661
-tunacode/core/state.py,sha256=2lsDgq0uIIc_MnXPE9SG_1fYFBDWWlgqgqm2Ik1iFBs,5599
+tunacode/core/state.py,sha256=gYFP6MIwlfYLxT6NFvqkJ3tEHkdxGdexunwXZwmRv0E,5762
 tunacode/core/tool_handler.py,sha256=BPjR013OOO0cLXPdLeL2FDK0ixUwOYu59FfHdcdFhp4,2277
 tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
-tunacode/core/agents/main.py,sha256=BRy3joJnn4GpUW47PyhiKK1JLMSamlK7wDMLwAGzSG0,47441
+tunacode/core/agents/main.py,sha256=htxekWzljg0nrbY3xf6PApxsBHUMOSQxVaDGxP0GwUs,44968
 tunacode/core/agents/utils.py,sha256=7kJAiUlkyWO3-b4T07XsGgycVrcNhv3NEPLdaktBnP4,12847
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
 tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/core/logging/__init__.py,sha256=pGr3EXxS4Yyz6Gasqg-m9fUENWnnbyaQqMaxR56WW4c,635
+tunacode/core/logging/config.py,sha256=EC5JLPq6JcF-zYNxJ6ZTizrxttY3Jp56zb8TGTWaUjQ,845
+tunacode/core/logging/formatters.py,sha256=lDex7P5eFzu-r9VEMshohj1zxWqANWSS581CJoMp-HA,1210
+tunacode/core/logging/handlers.py,sha256=SxmgH7yWc8bbCKcDeBtkbkHJy5saRqbIoDoTQh4jiYQ,2538
+tunacode/core/logging/logger.py,sha256=9RjRuX0GoUojRJ8WnJGQPFdXiluiJMCoFmvc8xEioB8,142
 tunacode/core/recursive/__init__.py,sha256=S9_dN0faJqam3Pnaum9PRC8Hd90bpES8syFgAD8-QbI,446
 tunacode/core/recursive/aggregator.py,sha256=KlWajEyT8OokWeY6ZwQ4EsVu05V4KeH3o2cYUz-Ce1Y,15725
 tunacode/core/recursive/budget.py,sha256=0wY6xSrZKmudUwthwX1mlcF5yat2_y3fNu5shX_IzvA,14131
 tunacode/core/recursive/decomposer.py,sha256=k8rgaPEMMb2mZ9W0m_Yg0oEBqbYpqDnK0zyTkx6eTPs,14550
 tunacode/core/recursive/executor.py,sha256=7taFsjYjSfL8OUQLM1ZVn9Xix7YoputFBAZSo9tDtDM,16646
-tunacode/core/recursive/hierarchy.py,sha256=67tdDCKB5mTSn6VIwm-knEHB_VKUkeljFdwH62U5chE,15648
+tunacode/core/recursive/hierarchy.py,sha256=YKYIt1APsZviVmhjxfQ9p441rVkfEHRcmuh3cFV-vqU,15744
 tunacode/core/setup/__init__.py,sha256=lzdpY6rIGf9DDlDBDGFvQZaSOQeFsNglHbkpq1-GtU8,376
 tunacode/core/setup/agent_setup.py,sha256=trELO8cPnWo36BBnYmXDEnDPdhBg0p-VLnx9A8hSSSQ,1401
 tunacode/core/setup/base.py,sha256=cbyT2-xK2mWgH4EO17VfM_OM2bj0kT895NW2jSXbe3c,968
@@ -52,7 +59,7 @@ tunacode/prompts/system.md,sha256=hXpjZ8Yiv2Acr2_6EmC2uOklP8FbmvyYR9oais-1KLk,16
 tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
 tunacode/services/mcp.py,sha256=R48X73KQjQ9vwhBrtbWHSBl-4K99QXmbIhh5J_1Gezo,3046
 tunacode/tools/__init__.py,sha256=ECBuUWWF1JjHW42CCceaPKgVTQyuljbz3RlhuA2fe2s,314
-tunacode/tools/base.py,sha256=TF71ZE66-W-7GLY8QcPpPJ5CVjod6FHL1caBOTCssvU,7044
+tunacode/tools/base.py,sha256=DhlanZZZxU2JJaBOwwyGFKMUcoCWR_CzLuwVeSXC0Go,7297
 tunacode/tools/bash.py,sha256=mgZqugfDFevZ4BETuUv90pzXvtq7qKGUGFiuDxzmytk,8766
 tunacode/tools/glob.py,sha256=TSgVK79ewZgGw8ucYkkiHgVqRgkw-wZrhP8j52nm_gQ,10334
 tunacode/tools/grep.py,sha256=jboEVA2ATv0YI8zg9dF89emZ_HWy2vVtsQ_-hDhlr7g,26337
@@ -64,15 +71,16 @@ tunacode/tools/todo.py,sha256=bVbohgwKqvvTe8efxXrMZDQU8vdk4E3jF9Cj38dRq7k,12727
 tunacode/tools/update_file.py,sha256=bW1MhTzRjBDjJzqQ6A1yCVEbkr1oIqtEC8uqcg_rfY4,3957
 tunacode/tools/write_file.py,sha256=prL6u8XOi9ZyPU-YNlG9YMLbSLrDJXDRuDX73ncXh-k,2699
 tunacode/ui/__init__.py,sha256=aRNE2pS50nFAX6y--rSGMNYwhz905g14gRd6g4BolYU,13
-tunacode/ui/completers.py,sha256=Jx1zyCESwdm_4ZopvCBtb0bCJF-bRy8aBWG2yhPQtDc,4878
-tunacode/ui/console.py,sha256=icb7uYrV8XmZg9glreEy5MrvDkmrKxbf_ZkNqElN1uE,2120
+tunacode/ui/completers.py,sha256=40wkF1nqG9HNVmP8MRWEPya0zV6GbyFXAuT-k7uXmxg,4880
+tunacode/ui/console.py,sha256=wLiJ9cVrWHS0zNadqbcXnsg0T2wj4xLACg17YAYLmU4,2574
 tunacode/ui/constants.py,sha256=A76B_KpM8jCuBYRg4cPmhi8_j6LLyWttO7_jjv47r3w,421
 tunacode/ui/decorators.py,sha256=e2KM-_pI5EKHa2M045IjUe4rPkTboxaKHXJT0K3461g,1914
-tunacode/ui/input.py,sha256=x_7G9VVdvydpEk2kcyG-OBKND5lL5ADbiGcDXF1n5UA,3014
-tunacode/ui/keybindings.py,sha256=tn0q0eRw72j8xPWX0673Xc-vmwlvFEyuhy3C451ntfE,1233
+tunacode/ui/input.py,sha256=NCZlj5qzNPy0gsSeGKeDNdAOMKZVGph8Z-UBXhX-Sbk,3020
+tunacode/ui/keybindings.py,sha256=ACUofGGs3xFvrNWi1cQ_Tkyy0lhIrZAEIOPlK6vZFVY,3014
 tunacode/ui/lexers.py,sha256=tmg4ic1enyTRLzanN5QPP7D_0n12YjX_8ZhsffzhXA4,1340
-tunacode/ui/output.py,sha256=51O0VHajte4dXHK5Az5SSP4IOb2q5SbCwvqdAoxyg7c,5665
-tunacode/ui/panels.py,sha256=dBZEVIJqliWreY-hz6HpW5rdBmPOJZ6sPrv8KQ3eNhk,8570
+tunacode/ui/logging_compat.py,sha256=5v6lcjVaG1CxdY1Zm9FAGr9H7Sy-tP6ihGfhP-5YvAY,1406
+tunacode/ui/output.py,sha256=vXfkPfQWmQzkmfGkY6snAk7auLgN8E7XEGUc-YVjTlM,5604
+tunacode/ui/panels.py,sha256=usGbzBDZdBY2pS2zHdlY0s5NKf9AUw7llOHKWoaNIlU,9307
 tunacode/ui/prompt_manager.py,sha256=U2cntB34vm-YwOj3gzFRUK362zccrz8pigQfpxr5sv8,4650
 tunacode/ui/recursive_progress.py,sha256=V0dGpJWt19TVArOYcQ3Lki8cR3ZepFT6iGwnChSFhFI,12906
 tunacode/ui/tool_ui.py,sha256=qp1aZUpLO5UOdJziY8tw0URC8gjoWoSKdGu5y2wuTUU,7013
@@ -86,14 +94,14 @@ tunacode/utils/import_cache.py,sha256=q_xjJbtju05YbFopLDSkIo1hOtCx3DOTl3GQE5FFDg
 tunacode/utils/message_utils.py,sha256=kM6VSS2Dudjplie009khHgmIRjDoBUzv6tvHcYNDAAE,586
 tunacode/utils/retry.py,sha256=AHdUzY6m-mwlT4OPXdtWWMAafL_NeS7JAMORGyM8c5k,4931
 tunacode/utils/ripgrep.py,sha256=AXUs2FFt0A7KBV996deS8wreIlUzKOlAHJmwrcAr4No,583
-tunacode/utils/security.py,sha256=e_zo9VmcOKFjgFMr9GOBIFhAmND4PBlJZgY7zqnsGjI,6548
+tunacode/utils/security.py,sha256=i3eGKg4o-qY2S_ObTlEaHO93q14iBfiPXR5O7srHn58,6579
 tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,11381
 tunacode/utils/text_utils.py,sha256=6YBD9QfkDO44-6jxnwRWIpmfIifPG-NqMzy_O2NAouc,7277
 tunacode/utils/token_counter.py,sha256=lLbkrNUraRQn5RMhwnGurqq1RHFDyn4AaFhruONWIxo,2690
 tunacode/utils/user_configuration.py,sha256=Ilz8dpGVJDBE2iLWHAPT0xR8D51VRKV3kIbsAz8Bboc,3275
-tunacode_cli-0.0.47.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.47.dist-info/METADATA,sha256=oHfTMPtEUgbgVd7Nm0bb39wAKAuPKRHskBpZmDnBxMM,5902
-tunacode_cli-0.0.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.47.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.47.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.47.dist-info/RECORD,,
+tunacode_cli-0.0.49.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.49.dist-info/METADATA,sha256=YdmUijOV5ybOmyMWEYJHEtAWpVur1dhi8ezMKKS81BM,5906
+tunacode_cli-0.0.49.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.49.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.49.dist-info/top_level.txt,sha256=GuU751acRvOhM5yLKFW0-gBg62JGh5zycDSq4tRFOYE,13
+tunacode_cli-0.0.49.dist-info/RECORD,,

{tunacode_cli-0.0.47.dist-info → tunacode_cli-0.0.49.dist-info}/top_level.txt

@@ -1 +1,2 @@
+api
 tunacode