tunacode-cli 0.0.31__tar.gz → 0.0.33__tar.gz

{tunacode_cli-0.0.31/src/tunacode_cli.egg-info → tunacode_cli-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.31
+Version: 0.0.33
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.31"
+version = "0.0.33"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode/cli/commands.py

@@ -184,8 +184,8 @@ class IterationsCommand(SimpleCommand):
         if args:
             try:
                 new_limit = int(args[0])
-                if new_limit < 1 or new_limit > 50:
-                    await ui.error("Iterations must be between 1 and 50")
+                if new_limit < 1 or new_limit > 100:
+                    await ui.error("Iterations must be between 1 and 100")
                     return
 
                 # Update the user config
@@ -198,9 +198,9 @@ class IterationsCommand(SimpleCommand):
             except ValueError:
                 await ui.error("Please provide a valid number")
         else:
-            current = state.user_config.get("settings", {}).get("max_iterations", 15)
+            current = state.user_config.get("settings", {}).get("max_iterations", 40)
             await ui.info(f"Current maximum iterations: {current}")
-            await ui.muted("Usage: /iterations <number> (1-50)")
+            await ui.muted("Usage: /iterations <number> (1-100)")
 
 
 class ClearCommand(SimpleCommand):

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode/cli/repl.py

@@ -88,12 +88,16 @@ async def _tool_confirm(tool_call, node, state_manager: StateManager):
 
 async def _tool_handler(part, node, state_manager: StateManager):
     """Handle tool execution with separated business logic and UI."""
-    await ui.info(f"Tool({part.tool_name})")
+    # Create tool handler with state first to check if confirmation is needed
+    tool_handler = ToolHandler(state_manager)
+
+    # Only show tool info for tools that require confirmation
+    if tool_handler.should_confirm(part.tool_name):
+        await ui.info(f"Tool({part.tool_name})")
+
     state_manager.session.spinner.stop()
 
     try:
-        # Create tool handler with state
-        tool_handler = ToolHandler(state_manager)
         args = _parse_args(part.args)
 
         # Use a synchronous function in run_in_terminal to avoid async deadlocks

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode/configuration/defaults.py

@@ -18,7 +18,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
     },
     "settings": {
         "max_retries": 10,
-        "max_iterations": 20,
+        "max_iterations": 40,
         "tool_ignore": [TOOL_READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode/constants.py

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

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode/core/agents/main.py

@@ -345,6 +345,11 @@ async def _process_node(
             # Check if ALL tools in this node are read-only
             all_read_only = all(part.tool_name in READ_ONLY_TOOLS for part in tool_parts)
 
+            # TODO: Currently only batches if ALL tools are read-only. Should be updated to use
+            # batch_read_only_tools() function to group consecutive read-only tools and execute
+            # them in parallel even when mixed with write/execute tools. For example:
+            # [read, read, write, read] should execute as: [read||read], [write], [read]
+            # instead of all sequential. The batch_read_only_tools() function exists but is unused.
             if all_read_only and len(tool_parts) > 1 and buffering_callback:
                 # Execute read-only tools in parallel!
                 import time
@@ -651,8 +656,8 @@ async def process_request(
 ) -> AgentRun:
     agent = get_or_create_agent(model, state_manager)
     mh = state_manager.session.messages.copy()
-    # Get max iterations from config (default: 20)
-    max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
+    # Get max iterations from config (default: 40)
+    max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 40)
     fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
         "fallback_response", True
     )

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33/src/tunacode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.31
+Version: 0.0.33
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT

{tunacode_cli-0.0.31 → tunacode_cli-0.0.33}/src/tunacode_cli.egg-info/SOURCES.txt

@@ -5,8 +5,6 @@ README.md
 TUNACODE.md
 pyproject.toml
 setup.py
-src/api/auth.py
-src/api/users.py
 src/tunacode/__init__.py
 src/tunacode/constants.py
 src/tunacode/context.py
@@ -92,11 +90,14 @@ tests/test_characterization_bash.py
 tests/test_characterization_commands_system.py
 tests/test_characterization_glob.py
 tests/test_characterization_grep.py
+tests/test_characterization_grep_performance.py
+tests/test_characterization_iteration_limits.py
 tests/test_characterization_list_dir.py
 tests/test_characterization_read_file.py
 tests/test_characterization_repl_utils.py
 tests/test_characterization_run_command.py
 tests/test_characterization_setup_system.py
+tests/test_characterization_tool_ui_behavior.py
 tests/test_characterization_update_file.py
 tests/test_characterization_utilities.py
 tests/test_characterization_write_file.py
@@ -123,6 +124,7 @@ tests/test_parallel_tool_execution.py
 tests/test_read_only_confirmation.py
 tests/test_tool_categorization.py
 tests/test_tool_combinations.py
+tests/test_tool_handler_ui_messages.py
 tests/test_update_command.py
 tests/test_visual_parallel_feedback.py
 tests/characterization/conftest.py

tunacode_cli-0.0.33/src/tunacode_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+tunacode

tunacode_cli-0.0.33/tests/test_characterization_grep_performance.py

@@ -0,0 +1,287 @@
+"""
+Characterization tests for grep performance behaviors.
+These tests capture the CURRENT performance characteristics and strategy selection of the grep tool.
+"""
+import os
+import sys
+import tempfile
+import pytest
+import time
+from pathlib import Path
+from tunacode.tools.grep import grep
+
+pytestmark = pytest.mark.asyncio
+
+
+class TestGrepPerformanceCharacterization:
+    """Golden-master tests for grep performance behaviors and strategy selection."""
+    
+    def setup_method(self):
+        """Create a temporary directory with test files."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.original_cwd = os.getcwd()
+        os.chdir(self.temp_dir)
+    
+    def teardown_method(self):
+        """Clean up temporary files."""
+        os.chdir(self.original_cwd)
+        import shutil
+        shutil.rmtree(self.temp_dir)
+    
+    async def test_grep_fast_glob_prefilter_performance(self):
+        """Capture performance behavior with fast-glob prefiltering."""
+        # Create many non-matching files
+        for i in range(100):
+            await self._create_file(f"data_{i}.txt", f"data file {i}")
+            await self._create_file(f"log_{i}.log", f"log entry {i}")
+        
+        # Create a few matching Python files
+        for i in range(10):
+            content = f"""import os
+def function_{i}():
+    # TODO: implement feature {i}
+    return {i}
+"""
+            await self._create_file(f"module_{i}.py", content)
+        
+        # Measure time for filtered search
+        start_time = time.time()
+        result = await grep("TODO", include_files="*.py", return_format="string")
+        filtered_time = time.time() - start_time
+        
+        # Verify it found the matches
+        assert "Found" in result
+        assert "TODO" in result
+        lines = result.split("\n")
+        
+        # Check for strategy information (if present)
+        strategy_mentioned = any("strategy" in line.lower() for line in lines)
+        
+        # Filtered search should be relatively fast
+        assert filtered_time < 2.0  # Should complete within 2 seconds
+        assert isinstance(result, str)
+    
+    async def test_grep_no_filter_performance(self):
+        """Capture performance behavior without file filtering."""
+        # Create many files of different types
+        for i in range(50):
+            await self._create_file(f"file_{i}.txt", f"content {i}")
+            await self._create_file(f"script_{i}.py", f"# Python script {i}")
+            await self._create_file(f"config_{i}.json", f'{{"id": {i}}}')
+        
+        # Search without filter
+        start_time = time.time()
+        result = await grep("content", return_format="string")
+        unfiltered_time = time.time() - start_time
+        
+        # Should find matches in txt files
+        assert "Found" in result
+        assert unfiltered_time < 3.0  # Reasonable time limit
+    
+    async def test_grep_complex_glob_patterns(self):
+        """Capture behavior with complex glob patterns like *.{py,js}."""
+        # Create mixed file types
+        for i in range(20):
+            await self._create_file(f"module_{i}.py", f"# TODO: Python task {i}")
+            await self._create_file(f"script_{i}.js", f"// TODO: JavaScript task {i}")
+            await self._create_file(f"data_{i}.txt", f"TODO: Text task {i}")
+        
+        # Search with complex glob
+        result = await grep("TODO", include_files="*.{py,js}", return_format="string")
+        
+        # Should find matches in both .py and .js files
+        assert "Found" in result
+        lines = result.split("\n")
+        
+        # Check if both file types are included
+        py_found = any(".py" in line for line in lines)
+        js_found = any(".js" in line for line in lines)
+        txt_found = any(".txt" in line for line in lines)
+        
+        assert py_found or js_found  # At least one should be found
+        assert not txt_found  # .txt files should be excluded
+    
+    async def test_grep_max_glob_limit(self):
+        """Capture behavior when hitting MAX_GLOB limit."""
+        # Create more files than MAX_GLOB limit (assuming it's around 1000)
+        for i in range(200):  # Create 200 Python files
+            await self._create_file(f"large_set_{i}.py", f"# File {i}\n# SEARCH_ME")
+        
+        # Try to search with glob filter
+        result = await grep("SEARCH_ME", include_files="*.py", return_format="string")
+        
+        # Should still work but might use different strategy
+        assert "Found" in result or "SEARCH_ME" in result
+        
+        # Check if strategy information mentions limits
+        lines = result.split("\n")
+        strategy_line = next((line for line in lines if "strategy" in line.lower()), "")
+        
+        # Capture actual behavior
+        assert isinstance(result, str)
+    
+    async def test_grep_regex_with_prefilter(self):
+        """Capture performance with regex patterns and file filtering."""
+        # Create test files
+        for i in range(30):
+            content = f"""import os
+import sys
+from pathlib import Path
+
+def process_{i}():
+    return Path('/tmp/file_{i}')
+"""
+            await self._create_file(f"processor_{i}.py", content)
+            await self._create_file(f"readme_{i}.md", f"# Documentation {i}\nUse Path objects")
+        
+        # Regex search with filter
+        start_time = time.time()
+        result = await grep(r"import.*Path", use_regex=True, include_files="*.py", return_format="string")
+        regex_time = time.time() - start_time
+        
+        # Should find matches efficiently
+        assert "Found" in result
+        assert regex_time < 2.0
+        
+        # Should only match Python files
+        lines = result.split("\n")
+        assert not any(".md" in line for line in lines)
+    
+    async def test_grep_deeply_nested_structure(self):
+        """Capture behavior with deeply nested directory structures."""
+        # Create nested directories
+        nested_path = Path(".")
+        for i in range(5):  # 5 levels deep
+            nested_path = nested_path / f"level_{i}"
+            nested_path.mkdir(exist_ok=True)
+            await self._create_file(str(nested_path / f"file_{i}.py"), f"# NESTED_PATTERN at level {i}")
+        
+        # Search in nested structure
+        result = await grep("NESTED_PATTERN", return_format="list")
+        
+        # Should find files at all levels
+        assert len(result) >= 5
+        
+        # Check if deeply nested files are found
+        deepest_found = any("level_4" in f for f in result)
+        assert deepest_found
+    
+    async def test_grep_mixed_encodings(self):
+        """Capture behavior with files of different encodings."""
+        # Create files with different content types
+        await self._create_file("utf8.txt", "UTF-8: Hello 世界")
+        await self._create_file("ascii.txt", "ASCII: Hello World")
+        
+        # Some files might have encoding issues
+        Path("latin1.txt").write_bytes("Latin-1: café".encode('latin-1'))
+        
+        # Search for common pattern
+        result = await grep("Hello", return_format="list")
+        
+        # Should handle UTF-8 and ASCII files
+        assert len(result) >= 2
+        assert any("utf8.txt" in f for f in result)
+        assert any("ascii.txt" in f for f in result)
+    
+    async def test_grep_symlinks(self):
+        """Capture behavior with symbolic links."""
+        # Create a real file
+        await self._create_file("original.py", "# SYMLINK_TEST pattern")
+        
+        # Create a symlink (if supported by OS)
+        try:
+            Path("link_to_original.py").symlink_to("original.py")
+            has_symlink = True
+        except (OSError, NotImplementedError):
+            has_symlink = False
+        
+        # Search for pattern
+        result = await grep("SYMLINK_TEST", return_format="list")
+        
+        if has_symlink:
+            # Capture whether symlinks are followed or not
+            assert len(result) >= 1  # At least the original
+            # Record actual behavior regarding symlinks
+        else:
+            assert len(result) == 1  # Just the original
+    
+    async def test_grep_performance_with_large_matches(self):
+        """Capture behavior when many files match the pattern."""
+        # Create many files with the same pattern
+        for i in range(100):
+            await self._create_file(f"match_{i}.txt", f"Line 1\nCOMMON_PATTERN here\nLine 3")
+        
+        # Time the search
+        start_time = time.time()
+        result = await grep("COMMON_PATTERN", return_format="string")
+        many_matches_time = time.time() - start_time
+        
+        # Should complete in reasonable time even with many matches
+        assert many_matches_time < 5.0
+        assert "Found" in result
+        
+        # Check if result mentions match count
+        lines = result.split("\n")
+        first_line = lines[0] if lines else ""
+        assert "100" in first_line or "matches" in first_line.lower()
+    
+    async def test_grep_empty_directory(self):
+        """Capture behavior in empty directories."""
+        # Create empty subdirectory
+        Path("empty_dir").mkdir()
+        
+        # Search in empty directory
+        result = await grep("pattern", path="empty_dir", return_format="list")
+        
+        # Should handle gracefully
+        assert isinstance(result, list)
+        assert len(result) == 0
+    
+    async def test_grep_performance_first_match(self):
+        """Capture first-match deadline behavior."""
+        # Create files where pattern appears later
+        for i in range(50):
+            # Pattern is not in first files
+            content = f"File {i} content\n" * 100 if i < 40 else f"File {i}\nTARGET_PATTERN\nMore content"
+            await self._create_file(f"delayed_{i}.txt", content)
+        
+        # Search should respect deadline
+        start_time = time.time()
+        result = await grep("TARGET_PATTERN", return_format="string")
+        search_time = time.time() - start_time
+        
+        # Should find matches (eventually)
+        assert "Found" in result or "TARGET_PATTERN" in result
+        
+        # Search time might be affected by 3-second deadline
+        assert search_time < 10.0  # Should not take too long
+    
+    async def test_grep_glob_prefilter_file_limit(self):
+        """Capture behavior of MAX_GLOB limit affecting strategy."""
+        # Create exactly at the boundary of MAX_GLOB limit
+        # Assuming MAX_GLOB is 1000 based on the code
+        for i in range(1010):  # Slightly over limit
+            await self._create_file(f"boundary_{i}.py", f"# Test file {i}")
+        
+        # Add one file with our pattern
+        await self._create_file("target.py", "# BOUNDARY_TEST pattern")
+        
+        # Search with glob that would match all Python files
+        result = await grep("BOUNDARY_TEST", include_files="*.py", return_format="string")
+        
+        # Should still find the pattern
+        assert "Found" in result or "BOUNDARY_TEST" in result
+        
+        # Check if strategy differs due to file count
+        lines = result.split("\n")
+        strategy_info = [line for line in lines if "strategy" in line.lower()]
+        
+        # Capture actual strategy selection behavior
+        assert isinstance(result, str)
+    
+    # Helper method
+    async def _create_file(self, filename: str, content: str) -> None:
+        """Helper to create a file with content."""
+        path = Path(filename)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)

tunacode_cli-0.0.33/tests/test_characterization_iteration_limits.py

@@ -0,0 +1,145 @@
+"""
+Characterization tests for iteration limits.
+
+These tests capture the CURRENT behavior of iteration limits in TunaCode.
+This is a golden-master test that documents the existing behavior before
+we make changes to update the defaults.
+
+Current behavior captured:
+- Default max_iterations: 40 (updated from 20)
+- Command limit: 100 (updated from 50)
+- Fallback on line 201 in commands.py shows 40 (was 15, now updated)
+"""
+
+import pytest
+from unittest.mock import Mock, patch, AsyncMock
+
+from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
+from tunacode.cli.commands import IterationsCommand
+from tunacode.types import CommandContext
+from tunacode.core.state import StateManager
+
+class TestIterationLimitsCharacterization:
+    """Golden-master tests for iteration limit behavior."""
+
+    def test_default_max_iterations_is_40(self):
+        """Capture behavior: default max_iterations is set to 40 in DEFAULT_USER_CONFIG."""
+        assert DEFAULT_USER_CONFIG["settings"]["max_iterations"] == 40
+
+    @pytest.mark.asyncio
+    async def test_iterations_command_max_limit_is_100(self):
+        """Capture behavior: /iterations command enforces maximum limit of 100."""
+        # Setup
+        cmd = IterationsCommand()
+        state_manager = Mock(spec=StateManager)
+        state_manager.session = Mock()
+        state_manager.session.user_config = {"settings": {}}
+        
+        context = CommandContext(
+            state_manager=state_manager
+        )
+
+        # Mock UI functions
+        with patch("tunacode.cli.commands.ui.error") as mock_error:
+            # Test trying to set iterations to 101 (above limit)
+            await cmd.execute(["101"], context)
+            
+            # Assert error was shown
+            mock_error.assert_called_once_with("Iterations must be between 1 and 100")
+
+    @pytest.mark.asyncio
+    async def test_iterations_command_accepts_100(self):
+        """Capture behavior: /iterations command accepts exactly 100 as valid."""
+        # Setup
+        cmd = IterationsCommand()
+        state_manager = Mock(spec=StateManager)
+        state_manager.session = Mock()
+        state_manager.session.user_config = {"settings": {}}
+        
+        context = CommandContext(
+            state_manager=state_manager
+        )
+
+        # Mock UI functions
+        with patch("tunacode.cli.commands.ui.success") as mock_success:
+            with patch("tunacode.cli.commands.ui.muted") as mock_muted:
+                # Test setting iterations to 100 (at limit)
+                await cmd.execute(["100"], context)
+                
+                # Assert success was shown
+                mock_success.assert_called_once_with("Maximum iterations set to 100")
+                mock_muted.assert_called_once_with("Higher values allow more complex reasoning but may be slower")
+                
+                # Assert value was set
+                assert state_manager.session.user_config["settings"]["max_iterations"] == 100
+
+    @pytest.mark.asyncio
+    async def test_iterations_command_rejects_0_and_negative(self):
+        """Capture behavior: /iterations command rejects 0 and negative values."""
+        # Setup
+        cmd = IterationsCommand()
+        state_manager = Mock(spec=StateManager)
+        state_manager.session = Mock()
+        state_manager.session.user_config = {"settings": {}}
+        
+        context = CommandContext(
+            state_manager=state_manager
+        )
+
+        # Mock UI functions
+        with patch("tunacode.cli.commands.ui.error") as mock_error:
+            # Test 0
+            await cmd.execute(["0"], context)
+            mock_error.assert_called_with("Iterations must be between 1 and 100")
+            
+            # Reset mock
+            mock_error.reset_mock()
+            
+            # Test negative
+            await cmd.execute(["-5"], context)
+            mock_error.assert_called_with("Iterations must be between 1 and 100")
+
+    @pytest.mark.asyncio
+    async def test_iterations_command_display_shows_default(self):
+        """Capture behavior: /iterations command shows default of 40 when no config exists."""
+        # Setup
+        cmd = IterationsCommand()
+        state_manager = Mock(spec=StateManager)
+        state_manager.session = Mock()
+        state_manager.session.user_config = {}  # No settings
+        
+        context = CommandContext(
+            state_manager=state_manager
+        )
+
+        # Mock UI functions
+        with patch("tunacode.cli.commands.ui.info") as mock_info:
+            with patch("tunacode.cli.commands.ui.muted") as mock_muted:
+                # Test showing current value without args
+                await cmd.execute([], context)
+                
+                # Assert shows 40 as default (matching DEFAULT_USER_CONFIG)
+                mock_info.assert_called_once_with("Current maximum iterations: 40")
+                mock_muted.assert_called_once_with("Usage: /iterations <number> (1-100)")
+
+    def test_process_request_reads_max_iterations_from_config(self):
+        """Document behavior: process_request reads max_iterations from config on line 660."""
+        # This is a documentation test to capture where max_iterations is read
+        # in the process_request function. The actual line is:
+        # max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 40)
+        
+        # The process_request function:
+        # 1. Reads max_iterations from user config settings
+        # 2. Falls back to 40 if not specified
+        # 3. Uses this value to limit iteration count in the agent loop
+        # 4. Breaks the loop when i >= max_iterations
+        pass
+
+    def test_main_agent_reads_max_iterations_on_line_660(self):
+        """Document that main.py reads max_iterations from config on line 660."""
+        # This is a documentation test to capture the specific line where
+        # max_iterations is read. The actual line is:
+        # max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
+        
+        # This confirms the fallback default is 20 when not specified in config
+        pass