tunacode-cli 0.0.70__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/ui/panels.py

@@ -2,15 +2,14 @@
 
 import asyncio
 import time
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union
 
-from rich.box import ROUNDED
-from rich.live import Live
-from rich.markdown import Markdown
-from rich.padding import Padding
-from rich.panel import Panel
-from rich.pretty import Pretty
-from rich.table import Table
+if TYPE_CHECKING:
+    from rich.markdown import Markdown
+    from rich.padding import Padding
+    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 (
@@ -45,11 +44,44 @@ from .output import print
 
 colors = DotDict(UI_COLORS)
 
+RenderableContent = Union["Text", "Markdown"]
+
+_rich_components: Optional[Mapping[str, Any]] = None
+
+
+def get_rich_components() -> Mapping[str, Any]:
+    """Get Rich components lazily with caching."""
+
+    global _rich_components
+    if _rich_components is not None:
+        return _rich_components
+
+    from rich.box import ROUNDED
+    from rich.live import Live
+    from rich.markdown import Markdown
+    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
+
+    _rich_components = {
+        "ROUNDED": ROUNDED,
+        "Live": Live,
+        "Markdown": Markdown,
+        "Padding": Padding,
+        "Panel": Panel,
+        "Pretty": Pretty,
+        "Table": Table,
+        "Text": Text,
+    }
+    return _rich_components
+
 
 @create_sync_wrapper
 async def panel(
     title: str,
-    text: Union[str, Markdown, Pretty, Table],
+    text: Union[str, "Markdown", "Pretty", "Table"],
     top: int = DEFAULT_PANEL_PADDING["top"],
     right: int = DEFAULT_PANEL_PADDING["right"],
     bottom: int = DEFAULT_PANEL_PADDING["bottom"],
@@ -58,26 +90,35 @@ async def panel(
     **kwargs: Any,
 ) -> None:
     """Display a rich panel with modern styling."""
+    rich = get_rich_components()
     border_style = border_style or kwargs.get("style") or colors.border
 
-    panel_obj = Panel(
-        Padding(text, (0, 1, 0, 1)),
+    panel_obj = rich["Panel"](
+        rich["Padding"](text, (0, 1, 0, 1)),
         title=f"[bold]{title}[/bold]",
         title_align="left",
         border_style=border_style,
         padding=(0, 1),
-        box=ROUNDED,  # Use ROUNDED box style
+        box=rich["ROUNDED"],  # Use ROUNDED box style
     )
 
-    final_padding = Padding(panel_obj, (top, right, bottom, left))
+    final_padding = rich["Padding"](panel_obj, (top, right, bottom, left))
 
     await print(final_padding, **kwargs)
 
 
 async def agent(text: str, bottom: int = 1) -> None:
     """Display an agent panel with modern styling."""
+    rich = get_rich_components()
     title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
-    await panel(title, Markdown(text), bottom=bottom, border_style=colors.primary)
+    await panel(title, rich["Markdown"](text), bottom=bottom, border_style=colors.primary)
+
+
+async def batch(text: str, bottom: int = 1) -> None:
+    """Display a parallel batch execution panel with green styling."""
+    rich = get_rich_components()
+    title = "[bold green]Parallel Execution[/bold green]"
+    await panel(title, rich["Markdown"](text), bottom=bottom, border_style="green")
 
 
 class StreamingAgentPanel:
@@ -86,13 +127,13 @@ class StreamingAgentPanel:
     bottom: int
     title: str
     content: str
-    live: Optional[Live]
+    live: Optional[Any]
     _last_update_time: float
     _dots_task: Optional[asyncio.Task]
     _dots_count: int
     _show_dots: bool
 
-    def __init__(self, bottom: int = 1):
+    def __init__(self, bottom: int = 1, debug: bool = False):
         self.bottom = bottom
         self.title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
         self.content = ""
@@ -101,14 +142,31 @@ class StreamingAgentPanel:
         self._dots_task = None
         self._dots_count = 0
         self._show_dots = True  # Start with dots enabled for "Thinking..."
-
-    def _create_panel(self) -> Padding:
+        # Debug/diagnostic instrumentation (printed after stop to avoid Live interference)
+        self._debug_enabled = debug
+        self._debug_events: list[str] = []
+        self._update_count: int = 0
+        self._first_update_done: bool = False
+        self._dots_tick_count: int = 0
+        self._max_logged_dots: int = 10
+
+    def _log_debug(self, label: str, **data: Any) -> None:
+        if not self._debug_enabled:
+            return
+        try:
+            ts = time.perf_counter_ns()
+        except Exception:
+            ts = 0
+        payload = ", ".join(f"{k}={repr(v)}" for k, v in data.items()) if data else ""
+        line = f"[ui] {label} ts_ns={ts}{(' ' + payload) if payload else ''}"
+        self._debug_events.append(line)
+
+    def _create_panel(self) -> "Padding":
         """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
 
+        rich = get_rich_components()
+
         # Show "Thinking..." only when no content has arrived yet
         if not self.content:
             # Apply dots animation to "Thinking..." message too
@@ -119,7 +177,7 @@ class StreamingAgentPanel:
                 dots_patterns = ["", ".", "..", "..."]
                 dots = dots_patterns[self._dots_count % len(dots_patterns)]
                 thinking_msg = base_msg + dots
-            content_renderable: Union[Text, Markdown] = Text.from_markup(thinking_msg)
+            content_renderable: RenderableContent = rich["Text"].from_markup(thinking_msg)
         else:
             # Once we have content, show it with optional dots animation
             display_content = self.content
@@ -129,16 +187,16 @@ class StreamingAgentPanel:
                 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)),
+            content_renderable = rich["Markdown"](display_content)
+        panel_obj = rich["Panel"](
+            rich["Padding"](content_renderable, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",
             title_align="left",
             border_style=colors.primary,
             padding=(0, 1),
-            box=ROUNDED,
+            box=rich["ROUNDED"],
         )
-        return Padding(
+        return rich["Padding"](
             panel_obj,
             (
                 DEFAULT_PANEL_PADDING["top"],
@@ -159,6 +217,14 @@ class StreamingAgentPanel:
             if current_time - self._last_update_time > delay_threshold:
                 self._show_dots = True
                 self._dots_count += 1
+                # Log only a few initial ticks to avoid noise
+                if (
+                    self._debug_enabled
+                    and not self.content
+                    and self._dots_tick_count < self._max_logged_dots
+                ):
+                    self._dots_tick_count += 1
+                    self._log_debug("dots_tick", n=self._dots_count)
                 if self.live:
                     self.live.update(self._create_panel())
             else:
@@ -169,10 +235,13 @@ class StreamingAgentPanel:
 
     async def start(self):
         """Start the live streaming display."""
-        from .output import console
+        from .output import get_console
 
-        self.live = Live(self._create_panel(), console=console, refresh_per_second=4)
+        rich = get_rich_components()
+
+        self.live = rich["Live"](self._create_panel(), console=get_console(), refresh_per_second=4)
         self.live.start()
+        self._log_debug("start")
         # For "Thinking...", set time in past to trigger dots immediately
         if not self.content:
             self._last_update_time = time.time() - 0.4  # Triggers dots on first cycle
@@ -187,46 +256,80 @@ class StreamingAgentPanel:
         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)
+        # Filter out system prompts and tool definitions from streaming
+        # Use more precise filtering to avoid false positives
+        content_str = str(content_chunk).strip()
+        if content_str and any(
+            content_str.startswith(phrase) or phrase in content_str
             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
 
+        # Special handling for the training data phrase - filter only if it's a complete
+        # system message
+        if "You are trained on data up to" in content_str and len(content_str) > 50:
+            # Only filter if this looks like a complete system message, not user content
+            if (
+                content_str.startswith("You are trained on data up to")
+                or "The current date is" in content_str
+            ):
+                return
+
         # Ensure type safety for concatenation
-        self.content = (self.content or "") + str(content_chunk)
+        incoming = str(content_chunk)
+        # First-chunk diagnostics
+        is_first_chunk = (not self.content) and bool(incoming)
+        if is_first_chunk:
+            self._log_debug(
+                "first_chunk_received",
+                chunk_repr=incoming[:5],
+                chunk_len=len(incoming),
+            )
+        self.content = (self.content or "") + incoming
 
         # 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
+        # Hide dots immediately when new content arrives
+        if self._show_dots:
+            self._log_debug("disable_dots_called")
+        self._show_dots = False
 
         if self.live:
+            # Log timing around the first two live.update() calls
+            self._update_count += 1
+            if self._update_count <= 2:
+                self._log_debug("live_update.start", update_index=self._update_count)
             self.live.update(self._create_panel())
+            if self._update_count <= 2:
+                self._log_debug("live_update.end", update_index=self._update_count)
 
     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)
+        # Use more precise filtering to avoid false positives
+        content_str = str(content).strip()
+        if content_str and any(
+            content_str.startswith(phrase) or phrase in content_str
             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
 
+        # Special handling for the training data phrase - filter only if it's a complete
+        # system message
+        if "You are trained on data up to" in content_str and len(content_str) > 50:
+            # Only filter if this looks like a complete system message, not user content
+            if (
+                content_str.startswith("You are trained on data up to")
+                or "The current date is" in content_str
+            ):
+                return
+
         self.content = content
         if self.live:
             self.live.update(self._create_panel())
@@ -240,6 +343,8 @@ class StreamingAgentPanel:
                 await self._dots_task
             except asyncio.CancelledError:
                 pass
+            finally:
+                self._log_debug("dots_task_cancelled")
 
         if self.live:
             # Get the console before stopping the live display
@@ -263,6 +368,23 @@ class StreamingAgentPanel:
 
             self.live = None
 
+        # Emit debug diagnostics after Live has been stopped (to avoid interference)
+        if self._debug_enabled:
+            from .output import print as ui_print
+
+            # Summarize UI buffer state
+            ui_prefix = "[debug]"
+            ui_buffer_first5 = repr((self.content or "")[:5])
+            total_len = len(self.content or "")
+            lines = [
+                f"{ui_prefix} ui_buffer_first5={ui_buffer_first5} total_len={total_len}",
+            ]
+            # Include recorded event lines
+            lines.extend(self._debug_events)
+            # Flush lines to console
+            for line in lines:
+                await ui_print(line)
+
 
 async def agent_streaming(content_stream, bottom: int = 1):
     """Display an agent panel with streaming content updates.
@@ -290,14 +412,15 @@ async def error(text: str) -> None:
 
 async def dump_messages(messages_list=None, state_manager: StateManager = None) -> None:
     """Display message history panel."""
+    rich = get_rich_components()
     if messages_list is None and state_manager:
         # Get messages from state manager
-        messages = Pretty(state_manager.session.messages)
+        messages = rich["Pretty"](state_manager.session.messages)
     elif messages_list is not None:
-        messages = Pretty(messages_list)
+        messages = rich["Pretty"](messages_list)
     else:
         # No messages available
-        messages = Pretty([])
+        messages = rich["Pretty"]([])
     await panel(PANEL_MESSAGE_HISTORY, messages, style=colors.muted)
 
 
@@ -313,7 +436,8 @@ async def models(state_manager: StateManager = None) -> None:
 
 async def help(command_registry=None) -> None:
     """Display the available commands organized by category."""
-    table = Table(show_header=False, box=None, padding=(0, 2, 0, 0))
+    rich = get_rich_components()
+    table = rich["Table"](show_header=False, box=None, padding=(0, 2, 0, 0))
     table.add_column("Command", style=f"bold {colors.primary}", justify="right", min_width=18)
     table.add_column("Description", style=colors.muted)
 
@@ -373,7 +497,7 @@ async def help(command_registry=None) -> None:
 
 @create_sync_wrapper
 async def tool_confirm(
-    title: str, content: Union[str, Markdown], filepath: Optional[str] = None
+    title: str, content: Union[str, "Markdown"], filepath: Optional[str] = None
 ) -> None:
     """Display a tool confirmation panel."""
     bottom_padding = 0 if filepath else 1

tunacode/ui/path_heuristics.py

@@ -0,0 +1,91 @@
+"""Shared heuristics for prioritizing and skipping project paths."""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Sequence
+
+# CLAUDE_ANCHOR[key=0b3f320e] Cross-ecosystem skip directory defaults for FileReferenceCompleter
+DEFAULT_SKIP_DIRECTORY_NAMES: Sequence[str] = (
+    ".git",
+    ".hg",
+    ".svn",
+    ".idea",
+    ".vscode",
+    ".venv",
+    "venv",
+    ".uv_cache",
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    "target",
+    # CLAUDE_ANCHOR[key=6fd59413] Skip list includes __pycache__ to avoid noisy
+    # Python build artifacts
+    "vendor",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    "coverage",
+    ".cache",
+    # CLAUDE_ANCHOR[key=2bcebd52] Skip heuristic checks every path component to prune
+    # nested junk directories
+)
+
+DEFAULT_PRIORITY_PREFIXES: Sequence[str] = (
+    "src",
+    "app",
+    "lib",
+    "cmd",
+    "pkg",
+    "internal",
+    "include",
+    "components",
+    "tests",
+    "test",
+    "spec",
+    "examples",
+    "docs",
+    "documentation",
+)
+
+
+def prioritize_roots(roots: Iterable[str]) -> List[str]:
+    """Order project roots so high-signal directories surface first."""
+
+    ordered: List[str] = []
+    seen = set()
+
+    for root in roots:
+        if root == "." and root not in seen:
+            ordered.append(root)
+            seen.add(root)
+
+    for prefix in DEFAULT_PRIORITY_PREFIXES:
+        for root in roots:
+            if root in seen:
+                continue
+            normalized = root.replace("\\", "/")
+            if normalized == prefix or normalized.startswith(f"{prefix}/"):
+                ordered.append(root)
+                seen.add(root)
+
+    for root in roots:
+        if root in seen:
+            continue
+        ordered.append(root)
+        seen.add(root)
+
+    return ordered
+
+
+def should_skip_directory(path: str) -> bool:
+    """Return True when any component of the path matches skip heuristics."""
+
+    if not path or path == ".":
+        return False
+
+    normalized = path.replace("\\", "/")
+    components = normalized.split("/")
+    return any(component in DEFAULT_SKIP_DIRECTORY_NAMES for component in components)

tunacode/ui/prompt_manager.py

@@ -100,30 +100,11 @@ class PromptManager:
         """
         session = self.get_session(session_key, config)
 
-        # Create a custom prompt that changes based on input and plan mode
+        # Create a custom prompt that changes based on input
         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

tunacode/ui/tool_ui.py

@@ -25,6 +25,11 @@ if TYPE_CHECKING:
 class ToolUI:
     """Handles tool confirmation UI presentation."""
 
+    REJECTION_FEEDBACK_SESSION = "tool_rejection_feedback"
+    REJECTION_GUIDANCE_PROMPT = (
+        "  Describe what the agent should do instead (leave blank to skip): "
+    )
+
     def __init__(self):
         self.colors = DotDict(UI_COLORS)
 
@@ -133,10 +138,14 @@ class ToolUI:
 
         if resp == "2":
             return ToolConfirmationResponse(approved=True, skip_future=True)
-        elif resp == "3":
-            return ToolConfirmationResponse(approved=False, abort=True)
-        else:
-            return ToolConfirmationResponse(approved=True)
+        if resp == "3":
+            instructions = await self._prompt_rejection_feedback(state_manager)
+            return ToolConfirmationResponse(
+                approved=False,
+                abort=True,
+                instructions=instructions,
+            )
+        return ToolConfirmationResponse(approved=True)
 
     def show_sync_confirmation(self, request: ToolConfirmationRequest) -> ToolConfirmationResponse:
         """
@@ -189,10 +198,23 @@ class ToolUI:
 
         if resp == "2":
             return ToolConfirmationResponse(approved=True, skip_future=True)
-        elif resp == "3":
-            return ToolConfirmationResponse(approved=False, abort=True)
-        else:
-            return ToolConfirmationResponse(approved=True)
+        if resp == "3":
+            instructions = self._prompt_rejection_feedback_sync()
+            return ToolConfirmationResponse(approved=False, abort=True, instructions=instructions)
+        return ToolConfirmationResponse(approved=True)
+
+    async def _prompt_rejection_feedback(self, state_manager: Optional["StateManager"]) -> str:
+        guidance = await ui.input(
+            session_key=self.REJECTION_FEEDBACK_SESSION,
+            pretext=self.REJECTION_GUIDANCE_PROMPT,
+            state_manager=state_manager,
+        )
+        return guidance.strip() if guidance else ""
+
+    def _prompt_rejection_feedback_sync(self) -> str:
+        guidance = input(self.REJECTION_GUIDANCE_PROMPT).strip()
+        ui.console.print()
+        return guidance
 
     async def log_mcp(self, title: str, args: ToolArgs) -> None:
         """

tunacode/utils/api_key_validation.py

@@ -0,0 +1,93 @@
+"""
+Module: tunacode.utils.api_key_validation
+
+Utilities for validating API keys are configured for the selected model.
+"""
+
+from typing import Optional, Tuple
+
+from tunacode.types import UserConfig
+
+
+def get_required_api_key_for_model(model: str) -> Tuple[Optional[str], str]:
+    """
+    Determine which API key is required for a given model.
+
+    Args:
+        model: Model identifier in format "provider:model-name"
+
+    Returns:
+        Tuple of (api_key_name, provider_name) or (None, "unknown") if no specific key required
+    """
+    if not model or ":" not in model:
+        return None, "unknown"
+
+    provider = model.split(":")[0].lower()
+
+    # Map providers to their required API keys
+    provider_key_map = {
+        "openrouter": ("OPENROUTER_API_KEY", "OpenRouter"),
+        "openai": ("OPENAI_API_KEY", "OpenAI"),
+        "anthropic": ("ANTHROPIC_API_KEY", "Anthropic"),
+        "google": ("GEMINI_API_KEY", "Google"),
+        "google-gla": ("GEMINI_API_KEY", "Google"),
+        "gemini": ("GEMINI_API_KEY", "Google"),
+    }
+
+    return provider_key_map.get(provider, (None, provider))
+
+
+def validate_api_key_for_model(model: str, user_config: UserConfig) -> Tuple[bool, Optional[str]]:
+    """
+    Check if the required API key exists for the given model.
+
+    Args:
+        model: Model identifier in format "provider:model-name"
+        user_config: User configuration containing env variables
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    api_key_name, provider_name = get_required_api_key_for_model(model)
+
+    if not api_key_name:
+        # No specific API key required (might be custom endpoint)
+        return True, None
+
+    env_config = user_config.get("env", {})
+    api_key = env_config.get(api_key_name, "").strip()
+
+    if not api_key:
+        return False, (
+            f"No API key found for {provider_name}.\n"
+            f"Please run 'tunacode --setup' to configure your API key."
+        )
+
+    return True, None
+
+
+def get_configured_providers(user_config: UserConfig) -> list[str]:
+    """
+    Get list of providers that have API keys configured.
+
+    Args:
+        user_config: User configuration containing env variables
+
+    Returns:
+        List of provider names that have API keys set
+    """
+    env_config = user_config.get("env", {})
+    configured = []
+
+    provider_map = {
+        "OPENROUTER_API_KEY": "openrouter",
+        "OPENAI_API_KEY": "openai",
+        "ANTHROPIC_API_KEY": "anthropic",
+        "GEMINI_API_KEY": "google",
+    }
+
+    for key_name, provider in provider_map.items():
+        if env_config.get(key_name, "").strip():
+            configured.append(provider)
+
+    return configured