tunacode-cli 0.0.41__py3-none-any.whl → 0.0.43__py3-none-any.whl

tunacode/ui/panels.py

@@ -86,7 +86,10 @@ class StreamingAgentPanel:
 
     def _create_panel(self) -> Panel:
         """Create a Rich panel with current content."""
-        markdown_content = Markdown(self.content or "Thinking...")
+        # Use the UI_THINKING_MESSAGE constant instead of hardcoded text
+        from tunacode.constants import UI_THINKING_MESSAGE
+
+        markdown_content = Markdown(self.content or UI_THINKING_MESSAGE)
         panel_obj = Panel(
             Padding(markdown_content, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",

tunacode/ui/recursive_progress.py

@@ -0,0 +1,380 @@
+"""Module: tunacode.ui.recursive_progress
+
+Visual feedback and progress tracking UI for recursive task execution.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from rich.columns import Columns
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from rich.table import Table
+from rich.tree import Tree
+
+from tunacode.core.recursive.budget import BudgetManager
+from tunacode.core.recursive.executor import TaskNode
+from tunacode.core.recursive.hierarchy import TaskHierarchy
+
+
+class RecursiveProgressUI:
+    """UI components for visualizing recursive execution progress."""
+
+    def __init__(self, console: Optional[Console] = None):
+        """Initialize the progress UI.
+
+        Args:
+            console: Rich console instance (creates new if not provided)
+        """
+        self.console = console or Console()
+        self.progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+            console=self.console,
+        )
+        self._task_progress_map: Dict[str, TaskID] = {}
+        self._live: Optional[Live] = None
+
+    def start_live_display(self) -> None:
+        """Start live display for real-time updates."""
+        if not self._live:
+            self._live = Live(
+                self.get_dashboard(),
+                console=self.console,
+                refresh_per_second=2,
+                vertical_overflow="visible",
+            )
+            self._live.start()
+
+    def stop_live_display(self) -> None:
+        """Stop the live display."""
+        if self._live:
+            self._live.stop()
+            self._live = None
+
+    def update_task_progress(
+        self, task_id: str, description: str, completed: int, total: int
+    ) -> None:
+        """Update progress for a specific task.
+
+        Args:
+            task_id: Task identifier
+            description: Task description
+            completed: Number of completed iterations
+            total: Total iterations
+        """
+        if task_id not in self._task_progress_map:
+            # Create new progress task
+            progress_id = self.progress.add_task(description, total=total, completed=completed)
+            self._task_progress_map[task_id] = progress_id
+        else:
+            # Update existing task
+            progress_id = self._task_progress_map[task_id]
+            self.progress.update(
+                progress_id, description=description, completed=completed, total=total
+            )
+
+    def display_task_hierarchy(self, hierarchy: TaskHierarchy) -> Tree:
+        """Create a tree visualization of task hierarchy.
+
+        Args:
+            hierarchy: TaskHierarchy instance
+
+        Returns:
+            Rich Tree object
+        """
+        tree = Tree("🎯 Task Hierarchy", guide_style="blue")
+
+        # Find root tasks
+        all_tasks = hierarchy._tasks
+        root_tasks = [task_id for task_id in all_tasks if hierarchy.get_parent(task_id) is None]
+
+        def build_tree_node(parent_node: Tree, task_id: str, depth: int = 0):
+            """Recursively build tree nodes."""
+            task = hierarchy.get_task(task_id)
+            if not task:
+                return
+
+            # Determine status icon
+            status = task.get("status", "pending")
+            icon = {"completed": "✅", "failed": "❌", "in_progress": "🔄", "pending": "⏳"}.get(
+                status, "❓"
+            )
+
+            # Create node label
+            title = task.get("title", "Untitled")[:50]
+            label = f"{icon} [{task_id}] {title}"
+
+            # Add progress if in progress
+            if status == "in_progress":
+                label += " [yellow](running)[/yellow]"
+
+            # Add node to tree
+            node = parent_node.add(label)
+
+            # Add children
+            children = hierarchy.get_children(task_id)
+            for child_id in children:
+                build_tree_node(node, child_id, depth + 1)
+
+        # Build tree from roots
+        for root_id in root_tasks:
+            build_tree_node(tree, root_id)
+
+        return tree
+
+    def display_budget_status(self, budget_manager: BudgetManager) -> Table:
+        """Create a table showing budget allocation and usage.
+
+        Args:
+            budget_manager: BudgetManager instance
+
+        Returns:
+            Rich Table object
+        """
+        table = Table(title="💰 Budget Status", show_header=True, header_style="bold cyan")
+        table.add_column("Task ID", style="dim", width=12)
+        table.add_column("Allocated", justify="right")
+        table.add_column("Used", justify="right")
+        table.add_column("Remaining", justify="right")
+        table.add_column("Utilization", justify="right")
+        table.add_column("Status", justify="center")
+
+        summary = budget_manager.get_budget_summary()
+
+        for task_id, details in summary["task_details"].items():
+            utilization = details["utilization"]
+
+            # Color code utilization
+            if utilization > 0.9:
+                util_color = "red"
+                status = "⚠️ High"
+            elif utilization > 0.7:
+                util_color = "yellow"
+                status = "📊 Normal"
+            else:
+                util_color = "green"
+                status = "✅ Good"
+
+            table.add_row(
+                task_id[:8] + "...",
+                str(details["allocated"]),
+                str(details["consumed"]),
+                str(details["remaining"]),
+                f"[{util_color}]{utilization:.1%}[/{util_color}]",
+                status,
+            )
+
+        # Add summary row
+        table.add_section()
+        table.add_row(
+            "TOTAL",
+            str(summary["allocated_budget"]),
+            str(summary["consumed_budget"]),
+            str(summary["available_budget"]),
+            f"{summary['utilization_rate']:.1%}",
+            "📈",
+        )
+
+        return table
+
+    def display_execution_stack(self, stack: List[str]) -> Panel:
+        """Display current execution stack.
+
+        Args:
+            stack: List of task IDs in execution order
+
+        Returns:
+            Rich Panel object
+        """
+        if not stack:
+            content = "[dim]No tasks in execution[/dim]"
+        else:
+            # Show stack with depth indicators
+            lines = []
+            for i, task_id in enumerate(stack):
+                indent = "  " * i
+                arrow = "└─" if i == len(stack) - 1 else "├─"
+                lines.append(f"{indent}{arrow} {task_id}")
+            content = "\n".join(lines)
+
+        return Panel(content, title="📚 Execution Stack", border_style="green")
+
+    def display_task_details(self, task_node: TaskNode) -> Panel:
+        """Display detailed information about a task.
+
+        Args:
+            task_node: TaskNode instance
+
+        Returns:
+            Rich Panel object
+        """
+        details = Table(show_header=False, box=None, padding=0)
+        details.add_column("Property", style="bold cyan")
+        details.add_column("Value")
+
+        details.add_row("Title", task_node.title or "Untitled")
+        details.add_row("Status", f"[yellow]{task_node.status}[/yellow]")
+        details.add_row("Complexity", f"{task_node.complexity_score:.2f}")
+        details.add_row("Depth", str(task_node.depth))
+        details.add_row("Budget", f"{task_node.iteration_budget} iterations")
+
+        if task_node.subtasks:
+            details.add_row("Subtasks", f"{len(task_node.subtasks)} tasks")
+
+        if task_node.error:
+            details.add_row("Error", f"[red]{task_node.error}[/red]")
+
+        return Panel(details, title=f"🔍 Task Details: {task_node.id[:8]}...", border_style="blue")
+
+    def get_dashboard(
+        self,
+        hierarchy: Optional[TaskHierarchy] = None,
+        budget_manager: Optional[BudgetManager] = None,
+        current_task: Optional[TaskNode] = None,
+        execution_stack: Optional[List[str]] = None,
+    ) -> Panel:
+        """Create a comprehensive dashboard view.
+
+        Args:
+            hierarchy: Optional TaskHierarchy instance
+            budget_manager: Optional BudgetManager instance
+            current_task: Optional current TaskNode
+            execution_stack: Optional execution stack
+
+        Returns:
+            Rich Panel containing the dashboard
+        """
+        components = []
+
+        # Add progress bars
+        components.append(Panel(self.progress, title="⏳ Task Progress", border_style="green"))
+
+        # Add hierarchy tree if available
+        if hierarchy:
+            components.append(self.display_task_hierarchy(hierarchy))
+
+        # Add budget status if available
+        if budget_manager:
+            components.append(self.display_budget_status(budget_manager))
+
+        # Add execution stack if available
+        if execution_stack is not None:
+            components.append(self.display_execution_stack(execution_stack))
+
+        # Add current task details if available
+        if current_task:
+            components.append(self.display_task_details(current_task))
+
+        # Arrange components in columns
+        if len(components) > 2:
+            # Use columns for better layout
+            left_col = components[: len(components) // 2]
+            right_col = components[len(components) // 2 :]
+
+            content = Columns(
+                ["\n\n".join(str(c) for c in left_col), "\n\n".join(str(c) for c in right_col)],
+                equal=True,
+                expand=True,
+            )
+        else:
+            content = "\n\n".join(str(c) for c in components)
+
+        return Panel(
+            content,
+            title="🔄 Recursive Execution Dashboard",
+            subtitle=f"Updated: {datetime.now().strftime('%H:%M:%S')}",
+            border_style="bold blue",
+        )
+
+    async def show_completion_summary(
+        self,
+        total_tasks: int,
+        completed_tasks: int,
+        failed_tasks: int,
+        total_time: float,
+        total_iterations: int,
+    ) -> None:
+        """Display a summary when execution completes.
+
+        Args:
+            total_tasks: Total number of tasks
+            completed_tasks: Number of completed tasks
+            failed_tasks: Number of failed tasks
+            total_time: Total execution time in seconds
+            total_iterations: Total iterations used
+        """
+        summary = Table(title="📊 Execution Summary", show_header=True, header_style="bold green")
+        summary.add_column("Metric", style="cyan")
+        summary.add_column("Value", justify="right")
+
+        summary.add_row("Total Tasks", str(total_tasks))
+        summary.add_row("Completed", f"[green]{completed_tasks}[/green]")
+        summary.add_row("Failed", f"[red]{failed_tasks}[/red]")
+        summary.add_row("Success Rate", f"{(completed_tasks / total_tasks) * 100:.1f}%")
+        summary.add_row("Total Time", f"{total_time:.2f}s")
+        summary.add_row("Total Iterations", str(total_iterations))
+        summary.add_row("Avg Time/Task", f"{total_time / total_tasks:.2f}s")
+
+        self.console.print("\n")
+        self.console.print(summary)
+        self.console.print("\n")
+
+        # Show completion message
+        if failed_tasks == 0:
+            self.console.print("[bold green]✅ All tasks completed successfully![/bold green]")
+        else:
+            self.console.print(
+                f"[bold yellow]⚠️ Completed with {failed_tasks} failures[/bold yellow]"
+            )
+
+
+# Convenience functions for integration
+async def show_recursive_progress(
+    console: Console, message: str, task_id: Optional[str] = None, depth: int = 0
+) -> None:
+    """Show progress message for recursive execution.
+
+    Args:
+        console: Rich console instance
+        message: Progress message
+        task_id: Optional task ID
+        depth: Recursion depth
+    """
+    indent = "  " * depth
+    prefix = f"[dim][{task_id[:8]}...][/dim]" if task_id else ""
+
+    console.print(f"{indent}🔄 {prefix} {message}")
+
+
+async def show_task_completion(
+    console: Console, task_id: str, success: bool, depth: int = 0
+) -> None:
+    """Show task completion status.
+
+    Args:
+        console: Rich console instance
+        task_id: Task ID
+        success: Whether task succeeded
+        depth: Recursion depth
+    """
+    indent = "  " * depth
+    icon = "✅" if success else "❌"
+    status = "completed" if success else "failed"
+    color = "green" if success else "red"
+
+    console.print(f"{indent}{icon} Task [{task_id[:8]}...] [{color}]{status}[/{color}]")

tunacode/ui/tool_ui.py

@@ -2,6 +2,7 @@
 Tool confirmation UI components, separated from business logic.
 """
 
+from rich.box import ROUNDED
 from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.panel import Panel
@@ -111,9 +112,9 @@ class ToolUI:
         if request.filepath:
             await ui.usage(f"File: {request.filepath}")
 
-        await ui.print("  1. Yes (default)")
-        await ui.print("  2. Yes, and don't ask again for commands like this")
-        await ui.print(f"  3. No, and tell {APP_NAME} what to do differently")
+        await ui.print("  [1] Yes (default)")
+        await ui.print("  [2] Yes, and don't ask again for commands like this")
+        await ui.print(f"  [3] No, and tell {APP_NAME} what to do differently")
         resp = (
             await ui.input(
                 session_key="tool_confirm",
@@ -146,10 +147,27 @@ class ToolUI:
         # Display styled confirmation panel using direct console output
         # Avoid using sync wrappers that might create event loop conflicts
         panel_obj = Panel(
-            Padding(content, 1), title=title, title_align="left", border_style=self.colors.warning
+            Padding(content, (0, 1, 0, 1)),
+            title=title,
+            title_align="left",
+            border_style=self.colors.warning,
+            padding=(0, 1),
+            box=ROUNDED,
         )
         # Add consistent spacing above panels
-        ui.console.print(Padding(panel_obj, (1, 0, 0, 0)))
+        from .constants import DEFAULT_PANEL_PADDING
+
+        ui.console.print(
+            Padding(
+                panel_obj,
+                (
+                    DEFAULT_PANEL_PADDING["top"],
+                    DEFAULT_PANEL_PADDING["right"],
+                    DEFAULT_PANEL_PADDING["bottom"],
+                    DEFAULT_PANEL_PADDING["left"],
+                ),
+            )
+        )
 
         if request.filepath:
             ui.console.print(f"File: {request.filepath}", style=self.colors.muted)
@@ -160,7 +178,7 @@ class ToolUI:
         resp = input("  Choose an option [1/2/3]: ").strip() or "1"
 
         # Add spacing after user choice for better readability
-        print()
+        ui.console.print()
 
         if resp == "2":
             return ToolConfirmationResponse(approved=True, skip_future=True)

tunacode/ui/utils.py

@@ -1,3 +1,3 @@
 from rich.console import Console as RichConsole
 
-console = RichConsole()
+console = RichConsole(force_terminal=True, legacy_windows=False)

tunacode/utils/retry.py

@@ -0,0 +1,163 @@
+"""Retry utilities for handling transient failures."""
+
+import asyncio
+import functools
+import json
+import logging
+import time
+from typing import Any, Callable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def retry_on_json_error(
+    max_retries: int = 10,
+    base_delay: float = 0.1,
+    max_delay: float = 5.0,
+    logger_name: Optional[str] = None,
+) -> Callable:
+    """Decorator to retry function calls that fail with JSON parsing errors.
+
+    Implements exponential backoff with configurable parameters.
+
+    Args:
+        max_retries: Maximum number of retry attempts (default: 10)
+        base_delay: Initial delay between retries in seconds (default: 0.1)
+        max_delay: Maximum delay between retries in seconds (default: 5.0)
+        logger_name: Logger name for retry logging (default: uses module logger)
+
+    Returns:
+        Decorated function that retries on JSONDecodeError
+    """
+    retry_logger = logging.getLogger(logger_name) if logger_name else logger
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            last_exception = None
+
+            for attempt in range(max_retries + 1):
+                try:
+                    return await func(*args, **kwargs)
+                except json.JSONDecodeError as e:
+                    last_exception = e
+
+                    if attempt == max_retries:
+                        # Final attempt failed
+                        retry_logger.error(f"JSON parsing failed after {max_retries} retries: {e}")
+                        raise
+
+                    # Calculate delay with exponential backoff
+                    delay = min(base_delay * (2**attempt), max_delay)
+
+                    retry_logger.warning(
+                        f"JSON parsing error (attempt {attempt + 1}/{max_retries + 1}): {e}. "
+                        f"Retrying in {delay:.2f}s..."
+                    )
+
+                    await asyncio.sleep(delay)
+
+            # Should never reach here, but just in case
+            if last_exception:
+                raise last_exception
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs) -> Any:
+            last_exception = None
+
+            for attempt in range(max_retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                except json.JSONDecodeError as e:
+                    last_exception = e
+
+                    if attempt == max_retries:
+                        # Final attempt failed
+                        retry_logger.error(f"JSON parsing failed after {max_retries} retries: {e}")
+                        raise
+
+                    # Calculate delay with exponential backoff
+                    delay = min(base_delay * (2**attempt), max_delay)
+
+                    retry_logger.warning(
+                        f"JSON parsing error (attempt {attempt + 1}/{max_retries + 1}): {e}. "
+                        f"Retrying in {delay:.2f}s..."
+                    )
+
+                    time.sleep(delay)
+
+            # Should never reach here, but just in case
+            if last_exception:
+                raise last_exception
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+def retry_json_parse(
+    json_string: str,
+    max_retries: int = 10,
+    base_delay: float = 0.1,
+    max_delay: float = 5.0,
+) -> Any:
+    """Parse JSON with automatic retry on failure.
+
+    Args:
+        json_string: JSON string to parse
+        max_retries: Maximum number of retry attempts
+        base_delay: Initial delay between retries in seconds
+        max_delay: Maximum delay between retries in seconds
+
+    Returns:
+        Parsed JSON object
+
+    Raises:
+        json.JSONDecodeError: If parsing fails after all retries
+    """
+
+    @retry_on_json_error(
+        max_retries=max_retries,
+        base_delay=base_delay,
+        max_delay=max_delay,
+    )
+    def _parse():
+        return json.loads(json_string)
+
+    return _parse()
+
+
+async def retry_json_parse_async(
+    json_string: str,
+    max_retries: int = 10,
+    base_delay: float = 0.1,
+    max_delay: float = 5.0,
+) -> Any:
+    """Asynchronously parse JSON with automatic retry on failure.
+
+    Args:
+        json_string: JSON string to parse
+        max_retries: Maximum number of retry attempts
+        base_delay: Initial delay between retries in seconds
+        max_delay: Maximum delay between retries in seconds
+
+    Returns:
+        Parsed JSON object
+
+    Raises:
+        json.JSONDecodeError: If parsing fails after all retries
+    """
+
+    @retry_on_json_error(
+        max_retries=max_retries,
+        base_delay=base_delay,
+        max_delay=max_delay,
+    )
+    async def _parse():
+        return json.loads(json_string)
+
+    return await _parse()

{tunacode_cli-0.0.41.dist-info → tunacode_cli-0.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.41
+Version: 0.0.43
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -25,6 +25,8 @@ Requires-Dist: pydantic-ai[logfire]==0.2.6
 Requires-Dist: pygments==2.19.1
 Requires-Dist: rich==14.0.0
 Requires-Dist: tiktoken>=0.5.2
+Requires-Dist: dspy-ai>=0.1.0
+Requires-Dist: python-dotenv>=1.0.0
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: ruff; extra == "dev"