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

tunacode/core/recursive/hierarchy.py

@@ -0,0 +1,488 @@
+"""Module: tunacode.core.recursive.hierarchy
+
+Hierarchical task management system for maintaining parent-child relationships and execution state.
+"""
+
+import logging
+from collections import defaultdict, deque
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TaskExecutionContext:
+    """Context information for task execution."""
+
+    task_id: str
+    parent_id: Optional[str] = None
+    depth: int = 0
+    inherited_context: Dict[str, Any] = field(default_factory=dict)
+    local_context: Dict[str, Any] = field(default_factory=dict)
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+    def get_full_context(self) -> Dict[str, Any]:
+        """Get merged context (inherited + local)."""
+        return {**self.inherited_context, **self.local_context}
+
+
+@dataclass
+class TaskRelationship:
+    """Represents a relationship between tasks."""
+
+    parent_id: str
+    child_id: str
+    relationship_type: str = "subtask"  # subtask, dependency, etc.
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class TaskHierarchy:
+    """Manages hierarchical task relationships and execution state."""
+
+    def __init__(self):
+        """Initialize the task hierarchy manager."""
+        # Core data structures
+        self._tasks: Dict[str, Dict[str, Any]] = {}
+        self._parent_to_children: Dict[str, List[str]] = defaultdict(list)
+        self._child_to_parent: Dict[str, str] = {}
+        self._task_dependencies: Dict[str, Set[str]] = defaultdict(set)
+        self._reverse_dependencies: Dict[str, Set[str]] = defaultdict(set)
+        self._execution_contexts: Dict[str, TaskExecutionContext] = {}
+        self._execution_order: List[str] = []
+        self._completed_tasks: Set[str] = set()
+        self._failed_tasks: Set[str] = set()
+
+    def add_task(
+        self,
+        task_id: str,
+        task_data: Dict[str, Any],
+        parent_id: Optional[str] = None,
+        dependencies: Optional[List[str]] = None,
+    ) -> bool:
+        """Add a task to the hierarchy.
+
+        Args:
+            task_id: Unique identifier for the task
+            task_data: Task information (title, description, etc.)
+            parent_id: Optional parent task ID
+            dependencies: Optional list of task IDs this task depends on
+
+        Returns:
+            True if task was added successfully, False otherwise
+        """
+        if task_id in self._tasks:
+            logger.warning(f"Task {task_id} already exists")
+            return False
+
+        # Store task data
+        self._tasks[task_id] = {
+            "id": task_id,
+            "parent_id": parent_id,
+            "created_at": datetime.now(),
+            **task_data,
+        }
+
+        # Set up parent-child relationships
+        if parent_id:
+            if parent_id not in self._tasks:
+                logger.error(f"Parent task {parent_id} does not exist")
+                return False
+
+            self._parent_to_children[parent_id].append(task_id)
+            self._child_to_parent[task_id] = parent_id
+
+        # Set up dependencies
+        if dependencies:
+            for dep_id in dependencies:
+                if dep_id not in self._tasks:
+                    logger.warning(f"Dependency {dep_id} does not exist yet")
+                self.add_dependency(task_id, dep_id)
+
+        logger.debug(f"Added task {task_id} to hierarchy")
+        return True
+
+    def add_dependency(self, task_id: str, depends_on: str) -> bool:
+        """Add a dependency relationship between tasks.
+
+        Args:
+            task_id: Task that has the dependency
+            depends_on: Task that must complete first
+
+        Returns:
+            True if dependency was added, False if it would create a cycle
+        """
+        # Check if adding this would create a cycle
+        if self._would_create_cycle(task_id, depends_on):
+            logger.error(f"Adding dependency {task_id} -> {depends_on} would create a cycle")
+            return False
+
+        self._task_dependencies[task_id].add(depends_on)
+        self._reverse_dependencies[depends_on].add(task_id)
+        return True
+
+    def remove_dependency(self, task_id: str, depends_on: str) -> bool:
+        """Remove a dependency relationship.
+
+        Args:
+            task_id: Task that has the dependency
+            depends_on: Task to remove from dependencies
+
+        Returns:
+            True if dependency was removed
+        """
+        if depends_on in self._task_dependencies.get(task_id, set()):
+            self._task_dependencies[task_id].remove(depends_on)
+            self._reverse_dependencies[depends_on].discard(task_id)
+            return True
+        return False
+
+    def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """Get task information.
+
+        Args:
+            task_id: Task identifier
+
+        Returns:
+            Task data or None if not found
+        """
+        return self._tasks.get(task_id)
+
+    def get_children(self, parent_id: str) -> List[str]:
+        """Get all direct children of a task.
+
+        Args:
+            parent_id: Parent task ID
+
+        Returns:
+            List of child task IDs
+        """
+        return self._parent_to_children.get(parent_id, []).copy()
+
+    def get_parent(self, task_id: str) -> Optional[str]:
+        """Get the parent of a task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Parent task ID or None
+        """
+        return self._child_to_parent.get(task_id)
+
+    def get_ancestors(self, task_id: str) -> List[str]:
+        """Get all ancestors of a task (parent, grandparent, etc.).
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            List of ancestor IDs from immediate parent to root
+        """
+        ancestors = []
+        current = self._child_to_parent.get(task_id)
+
+        while current:
+            ancestors.append(current)
+            current = self._child_to_parent.get(current)
+
+        return ancestors
+
+    def get_depth(self, task_id: str) -> int:
+        """Get the depth of a task in the hierarchy.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Depth (0 for root tasks)
+        """
+        return len(self.get_ancestors(task_id))
+
+    def get_dependencies(self, task_id: str) -> Set[str]:
+        """Get tasks that must complete before this task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Set of dependency task IDs
+        """
+        return self._task_dependencies.get(task_id, set()).copy()
+
+    def get_dependents(self, task_id: str) -> Set[str]:
+        """Get tasks that depend on this task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Set of dependent task IDs
+        """
+        return self._reverse_dependencies.get(task_id, set()).copy()
+
+    def can_execute(self, task_id: str) -> bool:
+        """Check if a task can be executed (all dependencies met).
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            True if task can be executed
+        """
+        if task_id not in self._tasks:
+            return False
+
+        # Check if all dependencies are completed
+        dependencies = self._task_dependencies.get(task_id, set())
+        return all(dep in self._completed_tasks for dep in dependencies)
+
+    def get_executable_tasks(self) -> List[str]:
+        """Get all tasks that can currently be executed.
+
+        Returns:
+            List of task IDs that have all dependencies met
+        """
+        executable = []
+
+        for task_id in self._tasks:
+            if (
+                task_id not in self._completed_tasks
+                and task_id not in self._failed_tasks
+                and self.can_execute(task_id)
+            ):
+                executable.append(task_id)
+
+        return executable
+
+    def mark_completed(self, task_id: str, result: Any = None) -> None:
+        """Mark a task as completed.
+
+        Args:
+            task_id: Task ID
+            result: Optional result data
+        """
+        if task_id in self._tasks:
+            self._completed_tasks.add(task_id)
+            self._tasks[task_id]["status"] = "completed"
+            self._tasks[task_id]["result"] = result
+            self._tasks[task_id]["completed_at"] = datetime.now()
+
+            # Update execution context if exists
+            if task_id in self._execution_contexts:
+                self._execution_contexts[task_id].completed_at = datetime.now()
+
+    def mark_failed(self, task_id: str, error: str) -> None:
+        """Mark a task as failed.
+
+        Args:
+            task_id: Task ID
+            error: Error message
+        """
+        if task_id in self._tasks:
+            self._failed_tasks.add(task_id)
+            self._tasks[task_id]["status"] = "failed"
+            self._tasks[task_id]["error"] = error
+            self._tasks[task_id]["failed_at"] = datetime.now()
+
+    def create_execution_context(
+        self, task_id: str, parent_context: Optional[Dict[str, Any]] = None
+    ) -> TaskExecutionContext:
+        """Create an execution context for a task.
+
+        Args:
+            task_id: Task ID
+            parent_context: Optional parent context to inherit
+
+        Returns:
+            New execution context
+        """
+        parent_id = self._child_to_parent.get(task_id)
+        depth = self.get_depth(task_id)
+
+        context = TaskExecutionContext(
+            task_id=task_id,
+            parent_id=parent_id,
+            depth=depth,
+            inherited_context=parent_context or {},
+            started_at=datetime.now(),
+        )
+
+        self._execution_contexts[task_id] = context
+        self._execution_order.append(task_id)
+
+        return context
+
+    def get_execution_context(self, task_id: str) -> Optional[TaskExecutionContext]:
+        """Get the execution context for a task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Execution context or None
+        """
+        return self._execution_contexts.get(task_id)
+
+    def propagate_context(
+        self, from_task: str, to_task: str, context_update: Dict[str, Any]
+    ) -> None:
+        """Propagate context from one task to another.
+
+        Args:
+            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)
+
+    def aggregate_child_results(self, parent_id: str) -> Dict[str, Any]:
+        """Aggregate results from all children of a task.
+
+        Args:
+            parent_id: Parent task ID
+
+        Returns:
+            Aggregated results dictionary
+        """
+        children = self._parent_to_children.get(parent_id, [])
+
+        results = {"completed": [], "failed": [], "pending": [], "aggregated_data": {}}
+
+        for child_id in children:
+            child_task = self._tasks.get(child_id, {})
+            status = child_task.get("status", "pending")
+
+            if status == "completed":
+                results["completed"].append({"id": child_id, "result": child_task.get("result")})
+            elif status == "failed":
+                results["failed"].append({"id": child_id, "error": child_task.get("error")})
+            else:
+                results["pending"].append(child_id)
+
+        return results
+
+    def get_execution_path(self, task_id: str) -> List[str]:
+        """Get the full execution path from root to this task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            List of task IDs from root to this task
+        """
+        ancestors = self.get_ancestors(task_id)
+        ancestors.reverse()  # Root to task order
+        ancestors.append(task_id)
+        return ancestors
+
+    def _would_create_cycle(self, task_id: str, depends_on: str) -> bool:
+        """Check if adding a dependency would create a cycle.
+
+        Args:
+            task_id: Task that would have the dependency
+            depends_on: Task it would depend on
+
+        Returns:
+            True if this would create a cycle
+        """
+        # BFS to check if we can reach task_id from depends_on
+        visited = set()
+        queue = deque([depends_on])
+
+        while queue:
+            current = queue.popleft()
+            if current == task_id:
+                return True
+
+            if current in visited:
+                continue
+
+            visited.add(current)
+
+            # Add all tasks that depend on current
+            for dependent in self._reverse_dependencies.get(current, []):
+                if dependent not in visited:
+                    queue.append(dependent)
+
+        return False
+
+    def get_topological_order(self) -> List[str]:
+        """Get a valid execution order respecting all dependencies.
+
+        Returns:
+            List of task IDs in valid execution order
+        """
+        # Kahn's algorithm for topological sort
+        in_degree = {}
+        for task_id in self._tasks:
+            in_degree[task_id] = len(self._task_dependencies.get(task_id, set()))
+
+        queue = deque([task_id for task_id, degree in in_degree.items() if degree == 0])
+        order = []
+
+        while queue:
+            current = queue.popleft()
+            order.append(current)
+
+            # Reduce in-degree for all dependents
+            for dependent in self._reverse_dependencies.get(current, []):
+                in_degree[dependent] -= 1
+                if in_degree[dependent] == 0:
+                    queue.append(dependent)
+
+        # If we couldn't process all tasks, there's a cycle
+        if len(order) != len(self._tasks):
+            logger.error("Dependency cycle detected")
+            # Return partial order
+            remaining = [t for t in self._tasks if t not in order]
+            order.extend(remaining)
+
+        return order
+
+    def visualize_hierarchy(self, show_dependencies: bool = True) -> str:
+        """Generate a text visualization of the task hierarchy.
+
+        Args:
+            show_dependencies: Whether to show dependency relationships
+
+        Returns:
+            String representation of the hierarchy
+        """
+        lines = []
+
+        # Find root tasks (no parent)
+        roots = [task_id for task_id in self._tasks if task_id not in self._child_to_parent]
+
+        def build_tree(task_id: str, prefix: str = "", is_last: bool = True):
+            task = self._tasks[task_id]
+            status = task.get("status", "pending")
+
+            # Build current line
+            connector = "└── " if is_last else "├── "
+            status_icon = "✓" if status == "completed" else "✗" if status == "failed" else "○"
+            line = f"{prefix}{connector}[{status_icon}] {task_id}: {task.get('title', 'Untitled')[:50]}"
+
+            # Add dependencies if requested
+            if show_dependencies:
+                deps = self._task_dependencies.get(task_id, set())
+                if deps:
+                    line += f" (deps: {', '.join(deps)})"
+
+            lines.append(line)
+
+            # Process children
+            children = self._parent_to_children.get(task_id, [])
+            for i, child_id in enumerate(children):
+                extension = "    " if is_last else "│   "
+                build_tree(child_id, prefix + extension, i == len(children) - 1)
+
+        # Build tree for each root
+        for i, root_id in enumerate(roots):
+            build_tree(root_id, "", i == len(roots) - 1)
+
+        return "\n".join(lines) if lines else "Empty hierarchy"

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)
@@ -68,6 +72,13 @@ class SessionState:
             "cost": 0.0,
         }
     )
+    # Recursive execution tracking
+    current_recursion_depth: int = 0
+    max_recursion_depth: int = 5
+    parent_task_id: Optional[str] = None
+    task_hierarchy: dict[str, Any] = field(default_factory=dict)
+    iteration_budgets: dict[str, int] = field(default_factory=dict)
+    recursive_context_stack: list[dict[str, Any]] = field(default_factory=list)
 
     def update_token_count(self):
         """Calculates the total token count from messages and files in context."""
@@ -98,6 +109,40 @@ class StateManager:
                     todo.completed_at = datetime.now()
                 break
 
+    def push_recursive_context(self, context: dict[str, Any]) -> None:
+        """Push a new context onto the recursive execution stack."""
+        self._session.recursive_context_stack.append(context)
+        self._session.current_recursion_depth += 1
+
+    def pop_recursive_context(self) -> Optional[dict[str, Any]]:
+        """Pop the current context from the recursive execution stack."""
+        if self._session.recursive_context_stack:
+            self._session.current_recursion_depth = max(
+                0, self._session.current_recursion_depth - 1
+            )
+            return self._session.recursive_context_stack.pop()
+        return None
+
+    def set_task_iteration_budget(self, task_id: str, budget: int) -> None:
+        """Set the iteration budget for a specific task."""
+        self._session.iteration_budgets[task_id] = budget
+
+    def get_task_iteration_budget(self, task_id: str) -> int:
+        """Get the iteration budget for a specific task."""
+        return self._session.iteration_budgets.get(task_id, 10)  # Default to 10
+
+    def can_recurse_deeper(self) -> bool:
+        """Check if we can recurse deeper without exceeding limits."""
+        return self._session.current_recursion_depth < self._session.max_recursion_depth
+
+    def reset_recursive_state(self) -> None:
+        """Reset all recursive execution state."""
+        self._session.current_recursion_depth = 0
+        self._session.parent_task_id = None
+        self._session.task_hierarchy.clear()
+        self._session.iteration_budgets.clear()
+        self._session.recursive_context_stack.clear()
+
     def remove_todo(self, todo_id: str) -> None:
         self._session.todos = [todo for todo in self._session.todos if todo.id != todo_id]
 

tunacode/exceptions.py

@@ -114,3 +114,26 @@ class TooBroadPatternError(ToolExecutionError):
             f"Pattern '{pattern}' is too broad - no matches found within {timeout_seconds}s. "
             "Please use a more specific pattern.",
         )
+
+
+class ToolBatchingJSONError(TunaCodeError):
+    """Raised when JSON parsing fails during tool batching after all retries are exhausted."""
+
+    def __init__(
+        self,
+        json_content: str,
+        retry_count: int,
+        original_error: OriginalError = None,
+    ):
+        self.json_content = json_content
+        self.retry_count = retry_count
+        self.original_error = original_error
+
+        # Truncate JSON content for display if too long
+        display_content = json_content[:100] + "..." if len(json_content) > 100 else json_content
+
+        super().__init__(
+            f"The model is having issues with tool batching. "
+            f"JSON parsing failed after {retry_count} retries. "
+            f"Invalid JSON: {display_content}"
+        )

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