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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.24
+Version: 0.0.26
 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.26}/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.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.24"
+version = "0.0.26"
 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.26}/src/tunacode/configuration/defaults.py

@@ -21,6 +21,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "max_iterations": 20,
         "tool_ignore": [TOOL_READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
+        "fallback_response": True,
     },
     "mcpServers": {},
 }

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/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.26"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/src/tunacode/core/agents/main.py

@@ -18,8 +18,8 @@ from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
 from tunacode.tools.update_file import update_file
 from tunacode.tools.write_file import write_file
-from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
-                            ToolCallId, ToolName)
+from tunacode.types import (AgentRun, ErrorMessage, FallbackResponse, ModelName, PydanticAgent,
+                            ResponseState, SimpleResult, ToolCallback, ToolCallId, ToolName)
 
 
 # Lazy import for Agent and Tool
@@ -343,11 +343,19 @@ async def process_request(
     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)
+    fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
+        "fallback_response", True
+    )
+
+    response_state = ResponseState()
 
     async with agent.iter(message, message_history=mh) as agent_run:
         i = 0
         async for node in agent_run:
             await _process_node(node, tool_callback, state_manager)
+            if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
+                if node.result.output:
+                    response_state.has_user_response = True
             i += 1
 
             # Display iteration progress if thoughts are enabled
@@ -362,5 +370,14 @@ async def process_request(
 
                     await ui.warning(f"⚠️ Reached maximum iterations ({max_iterations})")
                 break
+        if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
+            patch_tool_messages("Task incomplete", state_manager=state_manager)
+            response_state.has_final_synthesis = True
+            fallback = FallbackResponse(
+                summary="Reached maximum iterations without producing a final response.",
+                progress=f"{i}/{max_iterations} iterations completed",
+            )
 
+            agent_run.result = SimpleResult(fallback.summary)
+        agent_run.response_state = response_state
         return agent_run

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/src/tunacode/core/agents/orchestrator.py

@@ -96,4 +96,20 @@ class OrchestratorAgent:
 
         console.print("\n[green]Orchestrator completed all tasks successfully![/green]")
 
+        has_output = any(
+            hasattr(r, "result") and r.result and getattr(r.result, "output", None) for r in results
+        )
+
+        if results and not has_output:
+            lines = [f"Task {i + 1} completed" for i in range(len(results))]
+            summary = "\n".join(lines)
+
+            class SynthResult:
+                def __init__(self, output: str):
+                    self.output = output
+
+            synth_run = type("SynthRun", (), {})()
+            synth_run.result = SynthResult(summary)
+            results.append(synth_run)
+
         return results

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/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.26}/src/tunacode/types.py

@@ -5,7 +5,7 @@ This module contains all type aliases, protocols, and type definitions
 used throughout the TunaCode codebase.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Protocol, Tuple, Union
 
@@ -134,6 +134,32 @@ AgentRun = Any  # pydantic_ai.RunContext or similar
 AgentConfig = Dict[str, Any]
 AgentName = str
 
+
+@dataclass
+class ResponseState:
+    """Track whether a user visible response was produced."""
+
+    has_user_response: bool = False
+    has_final_synthesis: bool = False
+
+
+@dataclass
+class FallbackResponse:
+    """Structure for synthesized fallback responses."""
+
+    summary: str
+    progress: str = ""
+    issues: List[str] = field(default_factory=list)
+    next_steps: List[str] = field(default_factory=list)
+
+
+@dataclass
+class SimpleResult:
+    """Simple result container for agent responses."""
+
+    output: str
+
+
 # =============================================================================
 # Session and State Types
 # =============================================================================

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/src/tunacode/ui/output.py

@@ -17,12 +17,19 @@ console = Console()
 colors = DotDict(UI_COLORS)
 
 BANNER = """[bold cyan]
-████████╗██╗   ██╗███╗   ██╗ █████╗  ██████╗ ██████╗ ██████╗ ███████╗
-╚══██╔══╝██║   ██║████╗  ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝
-   ██║   ██║   ██║██╔██╗ ██║███████║██║     ██║   ██║██║  ██║█████╗
-   ██║   ██║   ██║██║╚██╗██║██╔══██║██║     ██║   ██║██║  ██║██╔══╝
-   ██║   ╚██████╔╝██║ ╚████║██║  ██║╚██████╗╚██████╔╝██████╔╝███████╗
-   ╚═╝    ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+████████╗██╗   ██╗███╗   ██╗ █████╗
+╚══██╔══╝██║   ██║████╗  ██║██╔══██╗
+   ██║   ██║   ██║██╔██╗ ██║███████║
+   ██║   ██║   ██║██║╚██╗██║██╔══██║
+   ██║   ╚██████╔╝██║ ╚████║██║  ██║
+   ╚═╝    ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝
+
+ ██████╗ ██████╗ ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██║     ██║   ██║██║  ██║█████╗
+██║     ██║   ██║██║  ██║██╔══╝
+╚██████╗╚██████╔╝██████╔╝███████╗
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
 [/bold cyan]
 
 ● Caution: This tool can modify your codebase - always use git branches"""

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26/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.26
 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.26}/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
@@ -86,6 +85,7 @@ tests/test_architect_integration.py
 tests/test_architect_simple.py
 tests/test_background_manager.py
 tests/test_config_setup_async.py
+tests/test_fallback_responses.py
 tests/test_fast_glob_search.py
 tests/test_file_reference_expansion.py
 tests/test_json_tool_parsing.py

{tunacode_cli-0.0.24 → tunacode_cli-0.0.26}/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.26}/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.26}/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.26/tests/test_fallback_responses.py

@@ -0,0 +1,54 @@
+import pytest
+from unittest.mock import patch, MagicMock
+
+from tunacode.core.state import StateManager
+from tunacode.core.agents import main as agent_main
+from tunacode.core.agents.orchestrator import OrchestratorAgent
+
+class DummyNode:
+    pass
+
+class FakeAgentRun:
+    def __init__(self, nodes):
+        self._nodes = nodes
+        self.result = None
+    def __aiter__(self):
+        async def gen():
+            for n in self._nodes:
+                yield n
+        return gen()
+    async def __aenter__(self):
+        return self
+    async def __aexit__(self, exc_type, exc, tb):
+        pass
+
+class FakeAgent:
+    def __init__(self, nodes):
+        self._nodes = nodes
+    def iter(self, message, message_history=None):
+        return FakeAgentRun(self._nodes)
+
+@pytest.mark.asyncio
+async def test_process_request_generates_fallback():
+    state = StateManager()
+    state.session.user_config = {
+        "settings": {"max_iterations": 3, "fallback_response": True}
+    }
+    nodes = [DummyNode() for _ in range(5)]
+    with patch("tunacode.core.agents.main.get_or_create_agent", return_value=FakeAgent(nodes)):
+        res = await agent_main.process_request("model", "test", state)
+        assert hasattr(res, "result")
+        assert "maximum iterations" in res.result.output.lower()
+
+@pytest.mark.asyncio
+async def test_orchestrator_synthesizes_summary():
+    state = StateManager()
+    orch = OrchestratorAgent(state)
+    tasks = [MagicMock(id=1, description="task", mutate=True)]
+    fake_run = MagicMock()
+    fake_run.result = None
+    with patch.object(orch, "plan", return_value=tasks):
+        with patch.object(orch, "_run_sub_task", return_value=fake_run):
+            results = await orch.run("req")
+            assert len(results) == 2
+            assert "task 1" in results[-1].result.output.lower()