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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.24
+Version: 0.0.25
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -30,7 +30,6 @@ 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
@@ -45,6 +44,8 @@ Dynamic: license-file
 
 **Your AI-powered CLI coding assistant**
 
+![Demo](demo.gif)
+
 [Quick Start](#quick-start) • [Features](#features) • [Configuration](#configuration) • [Documentation](#documentation)
 
 </div>

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

@@ -8,6 +8,8 @@
 
 **Your AI-powered CLI coding assistant**
 
+![Demo](demo.gif)
+
 [Quick Start](#quick-start) • [Features](#features) • [Configuration](#configuration) • [Documentation](#documentation)
 
 </div>

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

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

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

{tunacode_cli-0.0.24 → tunacode_cli-0.0.25}/src/tunacode/prompts/system.md

@@ -14,17 +14,30 @@ You MUST follow these rules:
 
 You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
 
-* `run_command(command: str)` — Execute any shell command
-* `read_file(filepath: str)` — Read any file
-* `write_file(filepath: str, content: str)` — Create or write any file
-* `update_file(filepath: str, target: str, patch: str)` — Update existing files
+* `run_command(command: str)` — Execute any shell command in the current working directory
+* `read_file(filepath: str)` — Read any file using RELATIVE paths from current directory
+* `write_file(filepath: str, content: str)` — Create or write any file using RELATIVE paths
+* `update_file(filepath: str, target: str, patch: str)` — Update existing files using RELATIVE paths
+
+**IMPORTANT**: All file operations MUST use relative paths from the user's current working directory. NEVER create files in /tmp or use absolute paths.
+
+---
+
+\###Working Directory Rules###
+
+**CRITICAL**: You MUST respect the user's current working directory:
+- **ALWAYS** use relative paths (e.g., `src/main.py`, `./config.json`, `../lib/utils.js`)
+- **NEVER** use absolute paths (e.g., `/tmp/file.txt`, `/home/user/file.py`)
+- **NEVER** change directories with `cd` unless explicitly requested by the user
+- **VERIFY** the current directory with `run_command("pwd")` if unsure
+- **CREATE** files in the current directory or its subdirectories ONLY
 
 ---
 
 \###Mandatory Operating Principles###
 
 1. **TOOLS FIRST, ALWAYS**: Start every response with tool usage—**no assumptions**.
-2. **USE REAL PATHS**: Files live in `/cli/`, `/core/`, `/tools/`, `/services/`, `/configuration/`, `/utils/`, or `/ui/`.
+2. **USE RELATIVE PATHS**: Always work in the current directory. Use relative paths like `src/`, `cli/`, `core/`, `tools/`, etc. NEVER use absolute paths starting with `/`.
 3. **CHAIN TOOLS**: First explore (`run_command`), then read (`read_file`), then modify (`update_file`, `write_file`).
 4. **ACT IMMEDIATELY**: Don’t describe what to do—**just do it**.
 5. **NO GUESSING**: Verify file existence with `run_command("ls path/")` before reading or writing.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.24
+Version: 0.0.25
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -30,7 +30,6 @@ 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
@@ -45,6 +44,8 @@ Dynamic: license-file
 
 **Your AI-powered CLI coding assistant**
 
+![Demo](demo.gif)
+
 [Quick Start](#quick-start) • [Features](#features) • [Configuration](#configuration) • [Documentation](#documentation)
 
 </div>

{tunacode_cli-0.0.24 → tunacode_cli-0.0.25}/src/tunacode_cli.egg-info/SOURCES.txt

@@ -42,7 +42,6 @@ src/tunacode/core/setup/coordinator.py
 src/tunacode/core/setup/environment_setup.py
 src/tunacode/core/setup/git_safety_setup.py
 src/tunacode/prompts/system.md
-src/tunacode/prompts/system.txt
 src/tunacode/services/__init__.py
 src/tunacode/services/mcp.py
 src/tunacode/tools/__init__.py

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

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

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

@@ -4,21 +4,20 @@
 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, AsyncMock
-        from tunacode.core.agents.planner_schema import Task
+        from unittest.mock import patch, MagicMock
         
         # Create state manager
         state = StateManager()
@@ -33,10 +32,10 @@ async def test_orchestrator_planning():
         # Create orchestrator
         orchestrator = OrchestratorAgent(state)
         
-        # Create proper Task objects
+        # Mock the LLM to return a simple plan
         mock_tasks = [
-            Task(id=1, description="Read the file", mutate=False),
-            Task(id=2, description="Update the code", mutate=True)
+            MagicMock(id=1, description="Read the file", mutate=False),
+            MagicMock(id=2, description="Update the code", mutate=True)
         ]
         
         # Capture console output
@@ -46,33 +45,35 @@ 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):
-            # 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)):
+            with patch('tunacode.core.llm.planner.make_plan', return_value=mock_tasks):
                 # Mock the agent execution
                 mock_run = MagicMock()
                 mock_run.result = MagicMock(output="Task completed")
                 
-                with patch.object(orchestrator, '_run_sub_task', new_callable=AsyncMock, return_value=mock_run):
+                with patch.object(orchestrator, '_run_sub_task', return_value=mock_run):
                     # Run orchestrator
                     results = await orchestrator.run("Test request")
                     
                     # Check outputs
-                    assert any("Orchestrator Mode" in out for out in outputs), "Missing orchestrator start message"
+                    assert any("[TARGET] 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("Orchestrator completed" in out for out in outputs), "Missing completion 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!")
         
     except ImportError as e:
-        pytest.skip(f"Skipping integration test due to missing dependencies: {e}")
+        print(f"[WARNING]  Skipping integration test due to missing dependencies: {e}")
+        print("[SUCCESS] Integration test skipped (dependencies not available)")
 
 
-@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
@@ -84,13 +85,36 @@ async def test_architect_mode_check():
     
     # Test the actual condition used in repl.py
     if getattr(state.session, 'architect_mode', False):
-        assert False, "Should not use orchestrator when architect_mode is 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")
     
     # Enable architect mode
     state.session.architect_mode = True
     
-    if not getattr(state.session, 'architect_mode', False):
-        assert False, "Should use orchestrator when architect_mode is 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)
 
 
-# Remove the main() function and if __name__ block since pytest will handle test discovery and execution
+if __name__ == "__main__":
+    asyncio.run(main())

{tunacode_cli-0.0.24 → tunacode_cli-0.0.25}/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,19 +26,25 @@ 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):
@@ -53,21 +59,28 @@ 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"),
@@ -88,6 +101,25 @@ 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)
 
 
-# Remove the main() function and if __name__ block since pytest will handle test discovery and execution
+if __name__ == "__main__":
+    asyncio.run(main())

tunacode_cli-0.0.25/tests/test_fast_glob_search.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Simple test for fast-glob prefilter search functionality
+"""
+import asyncio
+import sys
+import os
+import tempfile
+from pathlib import Path
+
+# 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"""
+    try:
+        from tunacode.tools.grep import fast_glob
+        print("✓ fast_glob import successful")
+        return True
+    except ImportError as e:
+        print(f"✗ fast_glob import failed: {e}")
+        return False
+
+def test_fast_glob_basic_functionality():
+    """Test basic fast_glob functionality with real files"""
+    try:
+        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
+        
+        print(f"✓ fast_glob found {len(python_files)} Python files and {len(test_files)} test files")
+        return True
+        
+    except Exception as e:
+        print(f"✗ fast_glob basic functionality test failed: {e}")
+        return False
+
+def test_fast_glob_multiple_extensions():
+    """Test fast_glob with multiple extensions pattern"""
+    try:
+        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"
+        
+        print(f"✓ fast_glob multiple extensions: {len(py_files)} .py + {len(md_files)} .md = {len(code_files)} total")
+        return True
+        
+    except Exception as e:
+        print(f"✗ fast_glob multiple extensions test failed: {e}")
+        return False
+
+def test_parallel_grep_import():
+    """Test that ParallelGrep class can be imported"""
+    try:
+        from tunacode.tools.grep import ParallelGrep, grep
+        print("✓ ParallelGrep and grep import successful")
+        return True
+    except ImportError as e:
+        print(f"✗ ParallelGrep import failed: {e}")
+        return False
+
+def test_grep_search_integration():
+    """Test that grep function works with fast-glob prefilter"""
+    try:
+        from tunacode.tools.grep import grep
+        
+        # Test searching for a pattern we know exists
+        result = asyncio.run(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"
+        
+        print("✓ grep search integration works")
+        return True
+        
+    except Exception as e:
+        print(f"✗ grep search integration test failed: {e}")
+        return False
+
+def test_smart_strategy_selection():
+    """Test that smart strategy selection works based on candidate count"""
+    try:
+        from tunacode.tools.grep import ParallelGrep
+        
+        # Create grep tool instance
+        grep_tool = ParallelGrep()
+        
+        # Test with very specific pattern (should find few files)
+        result_few = asyncio.run(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 = asyncio.run(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"
+        
+        print("✓ Smart strategy selection works")
+        return True
+        
+    except Exception as e:
+        print(f"✗ Smart strategy selection test failed: {e}")
+        return False
+
+def test_bounded_results():
+    """Test that results are properly bounded by MAX_GLOB"""
+    try:
+        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})"
+        
+        print(f"✓ Results properly bounded: {len(all_files)} <= {MAX_GLOB}")
+        return True
+        
+    except Exception as e:
+        print(f"✗ Bounded results test failed: {e}")
+        return False
+
+def main():
+    """Run all fast-glob search tests"""
+    print("Testing fast-glob prefilter search functionality...")
+    print("=" * 60)
+    
+    tests = [
+        test_fast_glob_import,
+        test_fast_glob_basic_functionality,
+        test_fast_glob_multiple_extensions,
+        test_parallel_grep_import,
+        test_grep_search_integration,
+        test_smart_strategy_selection,
+        test_bounded_results,
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test in tests:
+        if test():
+            passed += 1
+        print()
+    
+    print("=" * 60)
+    print(f"Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All fast-glob search tests PASSED!")
+        return 0
+    else:
+        print("❌ Some tests FAILED!")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -4,18 +4,14 @@
 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()
@@ -41,24 +37,20 @@ async def test_planning_visibility():
     Then create a new file called feature.py with a simple function.
     """
     
-    # Create proper Task objects
-    mock_tasks = [
-        Task(id=1, description="Read README.md", mutate=False),
-        Task(id=2, description="Create feature.py", mutate=True)
-    ]
+    print("=== Testing Orchestrator Planning Visibility ===\n")
+    print(f"Request: {test_request.strip()}\n")
     
-    # 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")
+    try:
+        # Run the orchestrator
+        results = await orchestrator.run(test_request)
+        
+        print(f"\n=== Orchestrator completed with {len(results)} results ===")
         
-        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)}"
+    except Exception as e:
+        print(f"\nError during orchestration: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(test_planning_visibility())