tunacode-cli 0.0.23__tar.gz → 0.0.24__tar.gz

{tunacode_cli-0.0.23/src/tunacode_cli.egg-info → tunacode_cli-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.23
+Version: 0.0.24
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -30,6 +30,7 @@ Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: textual-dev; extra == "dev"
 Dynamic: license-file
@@ -131,6 +132,24 @@ Dynamic: license-file
 pip install tunacode-cli
 ```
 
+#### Development Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/larock22/tunacode.git
+cd tunacode
+
+# Run the setup script
+./scripts/setup_dev_env.sh
+
+# Or manually:
+python3 -m venv venv
+source venv/bin/activate
+pip install -e ".[dev]"
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development setup.
+
 #### One-line Install (Linux/macOS)
 
 ```bash

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/README.md

@@ -95,6 +95,24 @@
 pip install tunacode-cli
 ```
 
+#### Development Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/larock22/tunacode.git
+cd tunacode
+
+# Run the setup script
+./scripts/setup_dev_env.sh
+
+# Or manually:
+python3 -m venv venv
+source venv/bin/activate
+pip install -e ".[dev]"
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development setup.
+
 #### One-line Install (Linux/macOS)
 
 ```bash

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.23"
+version = "0.0.24"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"
@@ -42,6 +42,7 @@ dev = [
     "flake8",
     "isort",
     "pytest",
+    "pytest-asyncio",
     "pytest-cov",
     "textual-dev",
 ]

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/src/tunacode/cli/main.py

@@ -14,6 +14,7 @@ from tunacode.core.state import StateManager
 from tunacode.setup import setup
 from tunacode.ui import console as ui
 from tunacode.utils.system import check_for_updates
+from tunacode.exceptions import UserAbortError
 
 app_settings = ApplicationSettings()
 app = typer.Typer(help="🐟 TunaCode - Your AI-powered development assistant")
@@ -49,6 +50,9 @@ def main(
         try:
             await setup(run_setup, state_manager, cli_config)
             await repl(state_manager)
+        except (KeyboardInterrupt, UserAbortError):
+            update_task.cancel()
+            return
         except Exception as e:
             from tunacode.exceptions import ConfigurationError
 

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/src/tunacode/cli/repl.py

@@ -282,6 +282,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 
 async def repl(state_manager: StateManager):
     action = None
+    ctrl_c_pressed = False
 
     # Professional startup information
     await ui.muted(f"• Model: {state_manager.session.current_model}")
@@ -294,12 +295,18 @@ async def repl(state_manager: StateManager):
         while True:
             try:
                 line = await ui.multiline_input(state_manager, _command_registry)
-            except (EOFError, KeyboardInterrupt):
-                break
+            except UserAbortError:
+                if ctrl_c_pressed:
+                    break
+                ctrl_c_pressed = True
+                await ui.warning("Hit Ctrl+C again to exit")
+                continue
 
             if not line:
                 continue
 
+            ctrl_c_pressed = False
+
             if line.lower() in ["exit", "quit"]:
                 break
 

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/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.23"
+APP_VERSION = "0.0.24"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24/src/tunacode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.23
+Version: 0.0.24
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -30,6 +30,7 @@ Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: textual-dev; extra == "dev"
 Dynamic: license-file
@@ -131,6 +132,24 @@ Dynamic: license-file
 pip install tunacode-cli
 ```
 
+#### Development Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/larock22/tunacode.git
+cd tunacode
+
+# Run the setup script
+./scripts/setup_dev_env.sh
+
+# Or manually:
+python3 -m venv venv
+source venv/bin/activate
+pip install -e ".[dev]"
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development setup.
+
 #### One-line Install (Linux/macOS)
 
 ```bash

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/src/tunacode_cli.egg-info/requires.txt

@@ -10,5 +10,6 @@ black
 flake8
 isort
 pytest
+pytest-asyncio
 pytest-cov
 textual-dev

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/tests/test_architect_integration.py

@@ -4,20 +4,21 @@
 import asyncio
 import sys
 import os
+import pytest
 
 # Add src to path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
 
 
+@pytest.mark.asyncio
 async def test_orchestrator_planning():
     """Test that orchestrator actually creates and shows a plan."""
-    print("\n[TEST] Testing orchestrator planning output...")
-    
     try:
         from tunacode.core.agents.orchestrator import OrchestratorAgent
         from tunacode.core.state import StateManager
         from tunacode.types import ModelName
-        from unittest.mock import patch, MagicMock
+        from unittest.mock import patch, MagicMock, AsyncMock
+        from tunacode.core.agents.planner_schema import Task
         
         # Create state manager
         state = StateManager()
@@ -32,10 +33,10 @@ async def test_orchestrator_planning():
         # Create orchestrator
         orchestrator = OrchestratorAgent(state)
         
-        # Mock the LLM to return a simple plan
+        # Create proper Task objects
         mock_tasks = [
-            MagicMock(id=1, description="Read the file", mutate=False),
-            MagicMock(id=2, description="Update the code", mutate=True)
+            Task(id=1, description="Read the file", mutate=False),
+            Task(id=2, description="Update the code", mutate=True)
         ]
         
         # Capture console output
@@ -45,35 +46,33 @@ async def test_orchestrator_planning():
             if args:
                 outputs.append(str(args[0]))
         
+        # Mock the Agent class to avoid API key requirement
+        mock_agent_instance = MagicMock()
+        mock_agent_instance.run = AsyncMock(return_value=MagicMock(data=mock_tasks))
+        
         with patch('rich.console.Console.print', side_effect=capture_print):
-            with patch('tunacode.core.llm.planner.make_plan', return_value=mock_tasks):
+            # Mock get_agent_tool to return our mock Agent class
+            with patch('tunacode.core.agents.main.get_agent_tool', return_value=(MagicMock(return_value=mock_agent_instance), None)):
                 # Mock the agent execution
                 mock_run = MagicMock()
                 mock_run.result = MagicMock(output="Task completed")
                 
-                with patch.object(orchestrator, '_run_sub_task', return_value=mock_run):
+                with patch.object(orchestrator, '_run_sub_task', new_callable=AsyncMock, return_value=mock_run):
                     # Run orchestrator
                     results = await orchestrator.run("Test request")
                     
                     # Check outputs
-                    assert any("[TARGET] Orchestrator Mode" in out for out in outputs), "Missing orchestrator start message"
+                    assert any("Orchestrator Mode" in out for out in outputs), "Missing orchestrator start message"
                     assert any("Executing plan" in out for out in outputs), "Missing execution message"
-                    assert any("[SUCCESS] Orchestrator completed" in out for out in outputs), "Missing completion message"
-                    
-                    print("[PASS] Orchestrator displayed planning messages")
-                    print("[PASS] Orchestrator completed successfully")
-                    
-        print("[SUCCESS] Orchestrator planning test PASSED!")
+                    assert any("Orchestrator completed" in out for out in outputs), "Missing completion message"
         
     except ImportError as e:
-        print(f"[WARNING]  Skipping integration test due to missing dependencies: {e}")
-        print("[SUCCESS] Integration test skipped (dependencies not available)")
+        pytest.skip(f"Skipping integration test due to missing dependencies: {e}")
 
 
+@pytest.mark.asyncio
 async def test_architect_mode_check():
     """Test the actual check in repl.py for architect mode."""
-    print("\n[TEST] Testing architect mode check in process_request...")
-    
     # Simulate the check from repl.py
     class MockSession:
         architect_mode = False
@@ -85,36 +84,13 @@ async def test_architect_mode_check():
     
     # Test the actual condition used in repl.py
     if getattr(state.session, 'architect_mode', False):
-        print("[FAIL] Should not use orchestrator when architect_mode is False")
-        assert False
-    else:
-        print("[PASS] Correctly skipping orchestrator when architect_mode is False")
+        assert False, "Should not use orchestrator when architect_mode is False"
     
     # Enable architect mode
     state.session.architect_mode = True
     
-    if getattr(state.session, 'architect_mode', False):
-        print("[PASS] Correctly using orchestrator when architect_mode is True")
-    else:
-        print("[FAIL] Should use orchestrator when architect_mode is True")
-        assert False
-    
-    print("[SUCCESS] Architect mode check test PASSED!")
-
-
-async def main():
-    """Run integration tests."""
-    print("=" * 60)
-    print("ARCHITECT MODE INTEGRATION TESTS")
-    print("=" * 60)
-    
-    await test_architect_mode_check()
-    await test_orchestrator_planning()
-    
-    print("\n" + "=" * 60)
-    print("[SUCCESS] ALL INTEGRATION TESTS COMPLETED!")
-    print("=" * 60)
+    if not getattr(state.session, 'architect_mode', False):
+        assert False, "Should use orchestrator when architect_mode is True"
 
 
-if __name__ == "__main__":
-    asyncio.run(main())
+# Remove the main() function and if __name__ block since pytest will handle test discovery and execution

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/tests/test_architect_simple.py

@@ -4,15 +4,15 @@
 import asyncio
 import sys
 import os
+import pytest
 
 # Add src to path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
 
 
+@pytest.mark.asyncio
 async def test_architect_toggle():
     """Test that architect mode can be toggled."""
-    print("\n[TEST] Testing architect mode toggle...")
-    
     # Create a minimal state object
     class MockSession:
         def __init__(self):
@@ -26,25 +26,19 @@ async def test_architect_toggle():
     
     # Test initial state
     assert not hasattr(state.session, 'architect_mode') or state.session.architect_mode is False
-    print("[PASS] Initial state: architect_mode is OFF")
     
     # Toggle ON
     state.session.architect_mode = not getattr(state.session, 'architect_mode', False)
     assert state.session.architect_mode is True
-    print("[PASS] After toggle: architect_mode is ON")
     
     # Toggle OFF
     state.session.architect_mode = not state.session.architect_mode
     assert state.session.architect_mode is False
-    print("[PASS] After second toggle: architect_mode is OFF")
-    
-    print("[SUCCESS] Architect toggle test PASSED!")
 
 
+@pytest.mark.asyncio
 async def test_orchestrator_routing():
     """Test that process_request routes to orchestrator when architect_mode is ON."""
-    print("\n[TEST] Testing orchestrator routing...")
-    
     # Test the routing logic without actual imports
     class MockSession:
         def __init__(self):
@@ -59,28 +53,21 @@ async def test_orchestrator_routing():
     
     # Test routing decision
     if getattr(state.session, 'architect_mode', False):
-        print("[PASS] Architect mode ON - Would use orchestrator")
         assert state.session.architect_mode is True
     else:
-        print("[FAIL] Architect mode OFF - Would use normal agent")
         assert False, "Should have used orchestrator"
     
     # Test with architect_mode OFF
     state.session.architect_mode = False
     if getattr(state.session, 'architect_mode', False):
-        print("[FAIL] Architect mode ON - Would use orchestrator")
         assert False, "Should have used normal agent"
     else:
-        print("[PASS] Architect mode OFF - Would use normal agent")
         assert state.session.architect_mode is False
-    
-    print("[SUCCESS] Orchestrator routing test PASSED!")
 
 
+@pytest.mark.asyncio
 async def test_command_parsing():
     """Test architect command argument parsing."""
-    print("\n[TEST] Testing architect command parsing...")
-    
     # Test various command inputs
     test_cases = [
         (["on"], True, "Explicit ON"),
@@ -101,25 +88,6 @@ async def test_command_parsing():
             result = None
         
         assert result == expected, f"Failed for {desc}"
-        print(f"[PASS] {desc}: correctly parsed as {expected}")
-    
-    print("[SUCCESS] Command parsing test PASSED!")
-
-
-async def main():
-    """Run all tests."""
-    print("=" * 60)
-    print("ARCHITECT MODE TESTS")
-    print("=" * 60)
-    
-    await test_architect_toggle()
-    await test_orchestrator_routing()
-    await test_command_parsing()
-    
-    print("\n" + "=" * 60)
-    print("[SUCCESS] ALL TESTS PASSED!")
-    print("=" * 60)
 
 
-if __name__ == "__main__":
-    asyncio.run(main())
+# Remove the main() function and if __name__ block since pytest will handle test discovery and execution

tunacode_cli-0.0.24/tests/test_fast_glob_search.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+Simple test for fast-glob prefilter search functionality
+"""
+import asyncio
+import sys
+import os
+import tempfile
+from pathlib import Path
+import pytest
+
+# Add src to path so we can import tunacode modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+def test_fast_glob_import():
+    """Test that fast_glob function can be imported"""
+    from tunacode.tools.grep import fast_glob
+    assert fast_glob is not None
+
+def test_fast_glob_basic_functionality():
+    """Test basic fast_glob functionality with real files"""
+    from tunacode.tools.grep import fast_glob
+    
+    # Use current directory which has Python files
+    root = Path(".")
+    
+    # Test finding Python files
+    python_files = fast_glob(root, "*.py")
+    
+    assert len(python_files) > 0, "Should find at least some Python files"
+    assert all(str(f).endswith('.py') for f in python_files), "All results should be .py files"
+    
+    # Test specific pattern
+    test_files = fast_glob(root, "test_*.py")
+    assert len(test_files) >= 2, "Should find our test files"  # At least test_react_thoughts.py and this file
+
+def test_fast_glob_multiple_extensions():
+    """Test fast_glob with multiple extensions pattern"""
+    from tunacode.tools.grep import fast_glob
+    
+    root = Path(".")
+    
+    # Test multiple extensions pattern
+    code_files = fast_glob(root, "*.{py,md}")
+    
+    assert len(code_files) > 0, "Should find Python and Markdown files"
+    
+    py_files = [f for f in code_files if str(f).endswith('.py')]
+    md_files = [f for f in code_files if str(f).endswith('.md')]
+    
+    assert len(py_files) > 0, "Should find some Python files"
+    assert len(md_files) > 0, "Should find some Markdown files"
+
+def test_parallel_grep_import():
+    """Test that ParallelGrep class can be imported"""
+    from tunacode.tools.grep import ParallelGrep, grep
+    assert ParallelGrep is not None
+    assert grep is not None
+
+@pytest.mark.asyncio
+async def test_grep_search_integration():
+    """Test that grep function works with fast-glob prefilter"""
+    from tunacode.tools.grep import grep
+    
+    # Test searching for a pattern we know exists
+    result = await grep("import", ".", include_files="*.py", max_results=5)
+    
+    assert isinstance(result, str), "grep should return a string"
+    assert "Found" in result or "No matches" in result, "Result should indicate search status"
+    
+    # If we found matches, check they contain our search pattern
+    if "Found" in result:
+        assert "Strategy:" in result, "Result should show which strategy was used"
+        assert "Candidates:" in result, "Result should show candidate count"
+
+@pytest.mark.asyncio
+async def test_smart_strategy_selection():
+    """Test that smart strategy selection works based on candidate count"""
+    from tunacode.tools.grep import ParallelGrep
+    
+    # Create grep tool instance
+    grep_tool = ParallelGrep()
+    
+    # Test with very specific pattern (should find few files)
+    result_few = await grep_tool._execute(
+        "test_", ".", include_files="test_*.py", search_type="smart", max_results=10
+    )
+    
+    # Should use python strategy for small sets
+    assert "Strategy: python" in result_few, "Should use python strategy for small candidate sets"
+    
+    # Test with broader pattern (more files)
+    result_many = await grep_tool._execute(
+        "import", ".", include_files="*.py", search_type="smart", max_results=10
+    )
+    
+    # Should show some strategy was selected
+    assert "Strategy:" in result_many, "Should show strategy selection"
+
+def test_bounded_results():
+    """Test that results are properly bounded by MAX_GLOB"""
+    from tunacode.tools.grep import fast_glob, MAX_GLOB
+    
+    root = Path(".")
+    
+    # Test that we don't exceed MAX_GLOB even with broad pattern
+    all_files = fast_glob(root, "*")
+    
+    assert len(all_files) <= MAX_GLOB, f"Results should be bounded by MAX_GLOB ({MAX_GLOB})"
+
+# Remove the main() function and if __name__ block since pytest will handle test discovery and execution

{tunacode_cli-0.0.23 → tunacode_cli-0.0.24}/tests/test_orchestrator_planning_visibility.py

@@ -4,14 +4,18 @@
 import asyncio
 import sys
 import os
+import pytest
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
 
+@pytest.mark.asyncio
 async def test_planning_visibility():
     """Test that planning steps are visible in orchestrator output."""
     from tunacode.core.agents.orchestrator import OrchestratorAgent
     from tunacode.core.state import StateManager
     from tunacode.types import ModelName
+    from unittest.mock import patch, MagicMock, AsyncMock
+    from tunacode.core.agents.planner_schema import Task
     
     # Create state manager
     state = StateManager()
@@ -37,20 +41,24 @@ async def test_planning_visibility():
     Then create a new file called feature.py with a simple function.
     """
     
-    print("=== Testing Orchestrator Planning Visibility ===\n")
-    print(f"Request: {test_request.strip()}\n")
+    # Create proper Task objects
+    mock_tasks = [
+        Task(id=1, description="Read README.md", mutate=False),
+        Task(id=2, description="Create feature.py", mutate=True)
+    ]
     
-    try:
-        # Run the orchestrator
-        results = await orchestrator.run(test_request)
-        
-        print(f"\n=== Orchestrator completed with {len(results)} results ===")
+    # Mock the Agent class to avoid API key requirement
+    mock_agent_instance = MagicMock()
+    mock_agent_instance.run = AsyncMock(return_value=MagicMock(data=mock_tasks))
+    
+    # Mock get_agent_tool to return our mock Agent class
+    with patch('tunacode.core.agents.main.get_agent_tool', return_value=(MagicMock(return_value=mock_agent_instance), None)):
+        # Mock the agent execution
+        mock_run = MagicMock()
+        mock_run.result = MagicMock(output="Task completed")
         
-    except Exception as e:
-        print(f"\nError during orchestration: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-if __name__ == "__main__":
-    asyncio.run(test_planning_visibility())
+        with patch.object(orchestrator, '_run_sub_task', new_callable=AsyncMock, return_value=mock_run):
+            # Run the orchestrator
+            results = await orchestrator.run(test_request)
+            
+            assert len(results) == len(mock_tasks), f"Expected {len(mock_tasks)} results, got {len(results)}"

tunacode_cli-0.0.24/tests/test_react_thoughts.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Simple test for ReAct thoughts functionality
+"""
+import asyncio
+import sys
+import os
+import pytest
+
+# Add src to path so we can import tunacode modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+def test_thoughts_command_import():
+    """Test that ThoughtsCommand can be imported without errors"""
+    from tunacode.cli.commands import ThoughtsCommand
+    assert ThoughtsCommand is not None
+
+def test_session_state_thoughts():
+    """Test that SessionState has show_thoughts attribute"""
+    from tunacode.core.state import SessionState
+    
+    # Create a session state
+    session = SessionState()
+    
+    # Check default value
+    assert hasattr(session, 'show_thoughts'), "SessionState missing show_thoughts attribute"
+    assert session.show_thoughts == False, "Default show_thoughts should be False"
+    
+    # Test setting the value
+    session.show_thoughts = True
+    assert session.show_thoughts == True, "show_thoughts should be settable to True"
+    
+    session.show_thoughts = False
+    assert session.show_thoughts == False, "show_thoughts should be settable to False"
+
+@pytest.mark.asyncio
+async def test_agent_thought_processing():
+    """Test that agent can process thought messages"""
+    from tunacode.core.agents.main import _process_node
+    from tunacode.core.state import StateManager
+    
+    # Create a mock state manager
+    state_manager = StateManager()
+    
+    # Create a mock node with thought
+    class MockNode:
+        def __init__(self, thought_text):
+            self.thought = thought_text
+    
+    # Test processing a node with a thought
+    node_with_thought = MockNode("This is a test thought")
+    
+    # This should not raise an error
+    await _process_node(node_with_thought, None, state_manager)
+    
+    # Check that thought was added to messages
+    messages = state_manager.session.messages
+    thought_messages = [msg for msg in messages if isinstance(msg, dict) and "thought" in msg]
+    
+    assert len(thought_messages) > 0, "Thought message should be added to session messages"
+    assert thought_messages[0]["thought"] == "This is a test thought", "Thought content should match"
+
+@pytest.mark.asyncio
+async def test_thoughts_command_functionality():
+    """Test ThoughtsCommand execute method"""
+    from tunacode.cli.commands import ThoughtsCommand, CommandContext
+    from tunacode.core.state import StateManager
+    
+    # Create command and context
+    command = ThoughtsCommand()
+    state_manager = StateManager()
+    context = CommandContext(state_manager=state_manager)
+    
+    # Test initial state
+    assert state_manager.session.show_thoughts == False, "Initial state should be False"
+    
+    # Test toggle with no args (should toggle)
+    await command.execute([], context)
+    assert state_manager.session.show_thoughts == True, "Should toggle to True"
+    
+    await command.execute([], context)
+    assert state_manager.session.show_thoughts == False, "Should toggle back to False"
+    
+    # Test explicit on
+    await command.execute(["on"], context)
+    assert state_manager.session.show_thoughts == True, "Should set to True with 'on'"
+    
+    # Test explicit off
+    await command.execute(["off"], context)
+    assert state_manager.session.show_thoughts == False, "Should set to False with 'off'"
+
+# Remove the main() function and if __name__ block since pytest will handle test discovery and execution