tunacode-cli 0.0.55__py3-none-any.whl → 0.0.57__py3-none-any.whl

tunacode/core/agents/agent_components/node_processor.py

@@ -343,45 +343,50 @@ async def _process_tool_calls(
                             f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
                         )
 
-                        # Enhanced visual feedback for parallel execution
-                        await ui.muted("\n" + "=" * 60)
-                        await ui.muted(
-                            f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
-                        )
-                        await ui.muted("=" * 60)
-
-                        # Display details of what's being executed
-                        for idx, (buffered_part, _) in enumerate(buffered_tasks, 1):
-                            tool_desc = f"  [{idx}] {buffered_part.tool_name}"
-                            if hasattr(buffered_part, "args") and isinstance(
-                                buffered_part.args, dict
-                            ):
-                                if (
-                                    buffered_part.tool_name == "read_file"
-                                    and "file_path" in buffered_part.args
-                                ):
-                                    tool_desc += f" → {buffered_part.args['file_path']}"
-                                elif (
-                                    buffered_part.tool_name == "grep"
-                                    and "pattern" in buffered_part.args
+                        # Enhanced visual feedback for parallel execution (suppress in plan mode)
+                        if not state_manager.is_plan_mode():
+                            await ui.muted("\n" + "=" * 60)
+                            await ui.muted(
+                                f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
+                            )
+                            await ui.muted("=" * 60)
+
+                            # Display details of what's being executed
+                            for idx, (buffered_part, _) in enumerate(buffered_tasks, 1):
+                                tool_desc = f"  [{idx}] {buffered_part.tool_name}"
+                                if hasattr(buffered_part, "args") and isinstance(
+                                    buffered_part.args, dict
                                 ):
-                                    tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
-                                    if "include_files" in buffered_part.args:
+                                    if (
+                                        buffered_part.tool_name == "read_file"
+                                        and "file_path" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → {buffered_part.args['file_path']}"
+                                    elif (
+                                        buffered_part.tool_name == "grep"
+                                        and "pattern" in buffered_part.args
+                                    ):
                                         tool_desc += (
-                                            f", files: '{buffered_part.args['include_files']}'"
+                                            f" → pattern: '{buffered_part.args['pattern']}'"
                                         )
-                                elif (
-                                    buffered_part.tool_name == "list_dir"
-                                    and "directory" in buffered_part.args
-                                ):
-                                    tool_desc += f" → {buffered_part.args['directory']}"
-                                elif (
-                                    buffered_part.tool_name == "glob"
-                                    and "pattern" in buffered_part.args
-                                ):
-                                    tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
-                            await ui.muted(tool_desc)
-                        await ui.muted("=" * 60)
+                                        if "include_files" in buffered_part.args:
+                                            tool_desc += (
+                                                f", files: '{buffered_part.args['include_files']}'"
+                                            )
+                                    elif (
+                                        buffered_part.tool_name == "list_dir"
+                                        and "directory" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → {buffered_part.args['directory']}"
+                                    elif (
+                                        buffered_part.tool_name == "glob"
+                                        and "pattern" in buffered_part.args
+                                    ):
+                                        tool_desc += (
+                                            f" → pattern: '{buffered_part.args['pattern']}'"
+                                        )
+                                await ui.muted(tool_desc)
+                            await ui.muted("=" * 60)
 
                         await execute_tools_parallel(buffered_tasks, tool_callback)
 
@@ -391,10 +396,11 @@ async def _process_tool_calls(
                         )  # Assume 100ms per tool average
                         speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                        await ui.muted(
-                            f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
-                            f"(~{speedup:.1f}x faster than sequential)\n"
-                        )
+                        if not state_manager.is_plan_mode():
+                            await ui.muted(
+                                f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
+                                f"(~{speedup:.1f}x faster than sequential)\n"
+                            )
 
                         # Reset spinner message back to thinking
                         from tunacode.constants import UI_THINKING_MESSAGE

tunacode/core/code_index.py

@@ -3,6 +3,7 @@
 import logging
 import os
 import threading
+import time
 from collections import defaultdict
 from pathlib import Path
 from typing import Dict, List, Optional, Set
@@ -17,6 +18,10 @@ class CodeIndex:
     grep searches that can timeout in large repositories.
     """
 
+    # Singleton instance
+    _instance: Optional["CodeIndex"] = None
+    _instance_lock = threading.RLock()
+
     # Directories to ignore during indexing
     IGNORE_DIRS = {
         ".git",
@@ -121,8 +126,83 @@ class CodeIndex:
         # Cache for directory contents
         self._dir_cache: Dict[Path, List[Path]] = {}
 
+        # Cache freshness tracking
+        self._cache_timestamps: Dict[Path, float] = {}
+        self._cache_ttl = 5.0  # 5 seconds TTL for directory cache
+
         self._indexed = False
 
+    @classmethod
+    def get_instance(cls, root_dir: Optional[str] = None) -> "CodeIndex":
+        """Get the singleton CodeIndex instance.
+
+        Args:
+            root_dir: Root directory to index. Only used on first call.
+
+        Returns:
+            The singleton CodeIndex instance.
+        """
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = cls(root_dir)
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset the singleton instance (for testing)."""
+        with cls._instance_lock:
+            cls._instance = None
+
+    def get_directory_contents(self, path: Path) -> List[str]:
+        """Get cached directory contents if available and fresh.
+
+        Args:
+            path: Directory path to check
+
+        Returns:
+            List of filenames in directory, empty list if not cached/stale
+        """
+        with self._lock:
+            if path not in self._dir_cache:
+                return []
+
+            if not self.is_cache_fresh(path):
+                # Remove stale entry
+                self._dir_cache.pop(path, None)
+                self._cache_timestamps.pop(path, None)
+                return []
+
+            # Return just the filenames, not Path objects
+            return [p.name for p in self._dir_cache[path]]
+
+    def is_cache_fresh(self, path: Path) -> bool:
+        """Check if cached directory data is still fresh.
+
+        Args:
+            path: Directory path to check
+
+        Returns:
+            True if cache is fresh, False if stale or missing
+        """
+        if path not in self._cache_timestamps:
+            return False
+
+        age = time.time() - self._cache_timestamps[path]
+        return age < self._cache_ttl
+
+    def update_directory_cache(self, path: Path, entries: List[str]) -> None:
+        """Update the directory cache with fresh data.
+
+        Args:
+            path: Directory path
+            entries: List of filenames in the directory
+        """
+        with self._lock:
+            # Convert filenames back to Path objects for internal storage
+            self._dir_cache[path] = [Path(path) / entry for entry in entries]
+            self._cache_timestamps[path] = time.time()
+
     def build_index(self, force: bool = False) -> None:
         """Build the file index for the repository.
 
@@ -152,6 +232,7 @@ class CodeIndex:
         self._class_definitions.clear()
         self._function_definitions.clear()
         self._dir_cache.clear()
+        self._cache_timestamps.clear()
 
     def _should_ignore_path(self, path: Path) -> bool:
         """Check if a path should be ignored during indexing."""
@@ -183,8 +264,9 @@ class CodeIndex:
                         self._index_file(entry)
                         file_list.append(entry)
 
-            # Cache directory contents
+            # Cache directory contents with timestamp
             self._dir_cache[directory] = file_list
+            self._cache_timestamps[directory] = time.time()
 
         except PermissionError:
             logger.debug(f"Permission denied: {directory}")
@@ -352,34 +434,6 @@ class CodeIndex:
 
             return sorted(self._all_files)
 
-    def get_directory_contents(self, directory: str) -> List[Path]:
-        """Get cached contents of a directory.
-
-        Args:
-            directory: Directory path relative to root
-
-        Returns:
-            List of file paths in the directory.
-        """
-        with self._lock:
-            if not self._indexed:
-                self.build_index()
-
-            dir_path = self.root_dir / directory
-            if dir_path in self._dir_cache:
-                return [p.relative_to(self.root_dir) for p in self._dir_cache[dir_path]]
-
-            # Fallback to scanning if not in cache
-            results = []
-            for file_path in self._all_files:
-                if str(file_path).startswith(directory + os.sep):
-                    # Only include direct children
-                    relative = str(file_path)[len(directory) + 1 :]
-                    if os.sep not in relative:
-                        results.append(file_path)
-
-            return sorted(results)
-
     def find_imports(self, module_name: str) -> List[Path]:
         """Find files that import a specific module.
 

tunacode/core/state.py

@@ -15,6 +15,8 @@ from tunacode.types import (
     InputSessions,
     MessageHistory,
     ModelName,
+    PlanDoc,
+    PlanPhase,
     SessionId,
     TodoItem,
     ToolName,
@@ -85,6 +87,12 @@ class SessionState:
     iteration_budgets: dict[str, int] = field(default_factory=dict)
     recursive_context_stack: list[dict[str, Any]] = field(default_factory=list)
 
+    # Plan Mode state tracking
+    plan_mode: bool = False
+    plan_phase: Optional[PlanPhase] = None
+    current_plan: Optional[PlanDoc] = None
+    plan_approved: bool = False
+
     def update_token_count(self):
         """Calculates the total token count from messages and files in context."""
         message_contents = [get_message_content(msg) for msg in self.messages]
@@ -167,3 +175,39 @@ class StateManager:
     def reset_session(self) -> None:
         """Reset the session to a fresh state."""
         self._session = SessionState()
+
+    # Plan Mode methods
+    def enter_plan_mode(self) -> None:
+        """Enter plan mode - restricts to read-only operations."""
+        self._session.plan_mode = True
+        self._session.plan_phase = PlanPhase.PLANNING_RESEARCH
+        self._session.current_plan = None
+        self._session.plan_approved = False
+        # Clear agent cache to force recreation with plan mode tools
+        self._session.agents.clear()
+
+    def exit_plan_mode(self, plan: Optional[PlanDoc] = None) -> None:
+        """Exit plan mode with optional plan data."""
+        self._session.plan_mode = False
+        self._session.plan_phase = None
+        self._session.current_plan = plan
+        self._session.plan_approved = False
+        # Clear agent cache to force recreation without plan mode tools
+        self._session.agents.clear()
+
+    def approve_plan(self) -> None:
+        """Mark current plan as approved for execution."""
+        self._session.plan_approved = True
+        self._session.plan_mode = False
+
+    def is_plan_mode(self) -> bool:
+        """Check if currently in plan mode."""
+        return self._session.plan_mode
+
+    def set_current_plan(self, plan: PlanDoc) -> None:
+        """Set the current plan data."""
+        self._session.current_plan = plan
+
+    def get_current_plan(self) -> Optional[PlanDoc]:
+        """Get the current plan data."""
+        return self._session.current_plan

tunacode/core/token_usage/usage_tracker.py

@@ -37,10 +37,10 @@ class UsageTracker(UsageTrackerProtocol):
             # 2. Calculate the cost
             cost = self._calculate_cost(parsed_data)
 
-            # 3. Update the session state
+            # 3. Update the session state (always done to track totals for session cost display)
             self._update_state(parsed_data, cost)
 
-            # 4. Display the summary if enabled
+            # 4. Display detailed per-call summary only if debugging enabled
             if self.state_manager.session.show_thoughts:
                 await self._display_summary()
 

tunacode/core/tool_handler.py

@@ -41,6 +41,14 @@ class ToolHandler:
         Returns:
             bool: True if confirmation is required, False otherwise.
         """
+        # Never confirm present_plan - it has its own approval flow
+        if tool_name == "present_plan":
+            return False
+
+        # Block write tools in plan mode
+        if self.is_tool_blocked_in_plan_mode(tool_name):
+            return True  # Force confirmation for blocked tools
+
         # Skip confirmation for read-only tools
         if is_read_only_tool(tool_name):
             return False
@@ -52,6 +60,18 @@ class ToolHandler:
 
         return not (self.state.session.yolo or tool_name in self.state.session.tool_ignore)
 
+    def is_tool_blocked_in_plan_mode(self, tool_name: ToolName) -> bool:
+        """Check if tool is blocked in plan mode."""
+        if not self.state.is_plan_mode():
+            return False
+
+        # Allow present_plan tool to end planning phase
+        if tool_name == "present_plan":
+            return False
+
+        # Allow read-only tools
+        return not is_read_only_tool(tool_name)
+
     def process_confirmation(self, response: ToolConfirmationResponse, tool_name: ToolName) -> bool:
         """
         Process the confirmation response.