tunacode-cli 0.0.28__py3-none-any.whl → 0.0.29__py3-none-any.whl

tunacode/configuration/defaults.py

@@ -22,6 +22,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "tool_ignore": [TOOL_READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,
+        "fallback_verbosity": "normal",  # Options: minimal, normal, detailed
     },
     "mcpServers": {},
 }

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.28"
+APP_VERSION = "0.0.29"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode/core/agents/main.py

@@ -375,10 +375,91 @@ async def process_request(
         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
+
+            # Extract context from the agent run
+            tool_calls_summary = []
+            files_modified = set()
+            commands_run = []
+
+            # Analyze message history for context
+            for msg in state_manager.session.messages:
+                if hasattr(msg, "parts"):
+                    for part in msg.parts:
+                        if hasattr(part, "part_kind") and part.part_kind == "tool-call":
+                            tool_name = getattr(part, "tool_name", "unknown")
+                            tool_calls_summary.append(tool_name)
+
+                            # Track specific operations
+                            if tool_name in ["write_file", "update_file"] and hasattr(part, "args"):
+                                if "file_path" in part.args:
+                                    files_modified.add(part.args["file_path"])
+                            elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
+                                if "command" in part.args:
+                                    commands_run.append(part.args["command"])
+
+            # Build fallback response with context
             fallback = FallbackResponse(
                 summary="Reached maximum iterations without producing a final response.",
-                progress=f"{i}/{max_iterations} iterations completed",
+                progress=f"Completed {i} iterations (limit: {max_iterations})",
+            )
+
+            # Get verbosity setting
+            verbosity = state_manager.session.user_config.get("settings", {}).get(
+                "fallback_verbosity", "normal"
+            )
+
+            if verbosity in ["normal", "detailed"]:
+                # Add what was attempted
+                if tool_calls_summary:
+                    tool_counts = {}
+                    for tool in tool_calls_summary:
+                        tool_counts[tool] = tool_counts.get(tool, 0) + 1
+
+                    fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
+                    for tool, count in sorted(tool_counts.items()):
+                        fallback.issues.append(f"  • {tool}: {count}x")
+
+                if verbosity == "detailed":
+                    if files_modified:
+                        fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
+                        for f in sorted(files_modified)[:5]:  # Limit to 5 files
+                            fallback.issues.append(f"  • {f}")
+                        if len(files_modified) > 5:
+                            fallback.issues.append(f"  • ... and {len(files_modified) - 5} more")
+
+                    if commands_run:
+                        fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
+                        for cmd in commands_run[:3]:  # Limit to 3 commands
+                            # Truncate long commands
+                            display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
+                            fallback.issues.append(f"  • {display_cmd}")
+                        if len(commands_run) > 3:
+                            fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
+
+            # Add helpful next steps
+            fallback.next_steps.append(
+                "The task may be too complex - try breaking it into smaller steps"
             )
+            fallback.next_steps.append("Check the output above for any errors or partial progress")
+            if files_modified:
+                fallback.next_steps.append("Review modified files to see what changes were made")
+
+            # Create comprehensive output
+            output_parts = [fallback.summary, ""]
+
+            if fallback.progress:
+                output_parts.append(f"Progress: {fallback.progress}")
+
+            if fallback.issues:
+                output_parts.append("\nWhat happened:")
+                output_parts.extend(fallback.issues)
+
+            if fallback.next_steps:
+                output_parts.append("\nSuggested next steps:")
+                for step in fallback.next_steps:
+                    output_parts.append(f"  • {step}")
+
+            comprehensive_output = "\n".join(output_parts)
 
             # Create a wrapper object that mimics AgentRun with the required attributes
             class AgentRunWrapper:
@@ -391,7 +472,7 @@ async def process_request(
                     # Delegate all other attributes to the wrapped object
                     return getattr(self._wrapped, name)
 
-            return AgentRunWrapper(agent_run, SimpleResult(fallback.summary))
+            return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
 
         # For non-fallback cases, we still need to handle the response_state
         # Create a minimal wrapper just to add response_state

tunacode/core/agents/orchestrator.py

@@ -13,7 +13,7 @@ import asyncio
 import itertools
 from typing import List
 
-from ...types import AgentRun, ModelName
+from ...types import AgentRun, FallbackResponse, ModelName, ResponseState
 from ..llm.planner import make_plan
 from ..state import StateManager
 from . import main as agent_main
@@ -69,6 +69,9 @@ class OrchestratorAgent:
         console = Console()
         model = model or self.state.session.current_model
 
+        # Track response state across all sub-tasks
+        response_state = ResponseState()
+
         # Show orchestrator is starting
         console.print(
             "\n[cyan]Orchestrator Mode: Analyzing request and creating execution plan...[/cyan]"
@@ -80,10 +83,28 @@ class OrchestratorAgent:
         console.print(f"\n[cyan]Executing plan with {len(tasks)} tasks...[/cyan]")
 
         results: List[AgentRun] = []
+        task_progress = []
+
         for mutate_flag, group in itertools.groupby(tasks, key=lambda t: t.mutate):
             if mutate_flag:
                 for t in group:
-                    results.append(await self._run_sub_task(t, model))
+                    result = await self._run_sub_task(t, model)
+                    results.append(result)
+
+                    # Track task progress
+                    task_progress.append(
+                        {
+                            "task": t,
+                            "completed": True,
+                            "had_output": hasattr(result, "result")
+                            and result.result
+                            and getattr(result.result, "output", None),
+                        }
+                    )
+
+                    # Check if this task produced user-visible output
+                    if hasattr(result, "response_state"):
+                        response_state.has_user_response |= result.response_state.has_user_response
             else:
                 # Show parallel execution
                 task_list = list(group)
@@ -92,26 +113,101 @@ class OrchestratorAgent:
                         f"\n[dim][Parallel Execution] Running {len(task_list)} read-only tasks concurrently...[/dim]"
                     )
                 coros = [self._run_sub_task(t, model) for t in task_list]
-                results.extend(await asyncio.gather(*coros))
+                parallel_results = await asyncio.gather(*coros)
+                results.extend(parallel_results)
+
+                # Track parallel task progress
+                for t, result in zip(task_list, parallel_results):
+                    task_progress.append(
+                        {
+                            "task": t,
+                            "completed": True,
+                            "had_output": hasattr(result, "result")
+                            and result.result
+                            and getattr(result.result, "output", None),
+                        }
+                    )
+
+                    # Check if this task produced user-visible output
+                    if hasattr(result, "response_state"):
+                        response_state.has_user_response |= result.response_state.has_user_response
 
         console.print("\n[green]Orchestrator completed all tasks successfully![/green]")
 
-        has_output = any(
+        # Check if we need a fallback response
+        has_any_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)
+        fallback_enabled = self.state.session.user_config.get("settings", {}).get(
+            "fallback_response", True
+        )
 
-            class SynthResult:
-                def __init__(self, output: str):
+        # Use has_any_output as the primary check since response_state might not be set for all agents
+        if not has_any_output and fallback_enabled:
+            # Generate a detailed fallback response
+            completed_count = sum(1 for tp in task_progress if tp["completed"])
+            output_count = sum(1 for tp in task_progress if tp["had_output"])
+
+            fallback = FallbackResponse(
+                summary="Orchestrator completed all tasks but no final response was generated.",
+                progress=f"Executed {completed_count}/{len(tasks)} tasks successfully",
+            )
+
+            # Add task details based on verbosity
+            verbosity = self.state.session.user_config.get("settings", {}).get(
+                "fallback_verbosity", "normal"
+            )
+
+            if verbosity in ["normal", "detailed"]:
+                # List what was done
+                if task_progress:
+                    fallback.issues.append(f"Tasks executed: {completed_count}")
+                    if output_count == 0:
+                        fallback.issues.append("No tasks produced visible output")
+
+                    if verbosity == "detailed":
+                        # Add task descriptions
+                        for i, tp in enumerate(task_progress, 1):
+                            task_type = "WRITE" if tp["task"].mutate else "READ"
+                            status = "✓" if tp["completed"] else "✗"
+                            fallback.issues.append(
+                                f"{status} Task {i} [{task_type}]: {tp['task'].description}"
+                            )
+
+            # Suggest next steps
+            fallback.next_steps.append("Review the task execution above for any errors")
+            fallback.next_steps.append(
+                "Try running individual tasks separately for more detailed output"
+            )
+
+            # Create synthesized response
+            synthesis_parts = [fallback.summary, ""]
+
+            if fallback.progress:
+                synthesis_parts.append(f"Progress: {fallback.progress}")
+
+            if fallback.issues:
+                synthesis_parts.append("\nDetails:")
+                synthesis_parts.extend(f"  • {issue}" for issue in fallback.issues)
+
+            if fallback.next_steps:
+                synthesis_parts.append("\nNext steps:")
+                synthesis_parts.extend(f"  • {step}" for step in fallback.next_steps)
+
+            synthesis = "\n".join(synthesis_parts)
+
+            class FallbackResult:
+                def __init__(self, output: str, response_state: ResponseState):
                     self.output = output
+                    self.response_state = response_state
 
-            class SynthRun:
-                def __init__(self):
-                    self.result = SynthResult(summary)
+            class FallbackRun:
+                def __init__(self, synthesis: str, response_state: ResponseState):
+                    self.result = FallbackResult(synthesis, response_state)
+                    self.response_state = response_state
 
-            results.append(SynthRun())
+            response_state.has_final_synthesis = True
+            results.append(FallbackRun(synthesis, response_state))
 
         return results

tunacode/core/agents/readonly.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from ...tools.grep import grep
 from ...tools.read_file import read_file
-from ...types import AgentRun, ModelName
+from ...types import AgentRun, ModelName, ResponseState
 from ..state import StateManager
 
 if TYPE_CHECKING:
@@ -42,10 +42,24 @@ class ReadOnlyAgent:
     async def process_request(self, request: str) -> AgentRun:
         """Process a request using only read-only tools."""
         agent = self._get_agent()
+        response_state = ResponseState()
 
         # Use iter() like main.py does to get the full run context
         async with agent.iter(request) as agent_run:
-            async for _ in agent_run:
-                pass  # Let it complete
+            async for node in agent_run:
+                # Check if this node produced user-visible output
+                if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
+                    if node.result.output:
+                        response_state.has_user_response = True
 
-        return agent_run
+        # Wrap the agent run to include response_state
+        class AgentRunWithState:
+            def __init__(self, wrapped_run):
+                self._wrapped = wrapped_run
+                self.response_state = response_state
+
+            def __getattr__(self, name):
+                # Delegate all other attributes to the wrapped object
+                return getattr(self._wrapped, name)
+
+        return AgentRunWithState(agent_run)

{tunacode_cli-0.0.28.dist-info → tunacode_cli-0.0.29.dist-info}/METADATA

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

{tunacode_cli-0.0.28.dist-info → tunacode_cli-0.0.29.dist-info}/RECORD

@@ -1,5 +1,5 @@
 tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=br_qbqbT1sFcUxA2mpTclUyQn-jsVMr2hrsReyBP8Rc,3799
+tunacode/constants.py,sha256=yChcPTCk4tc0Q1JArwWxIZ2Zxi9S-vLgKiBOdMml6eI,3799
 tunacode/context.py,sha256=6sterdRvPOyG3LU0nEAXpBsEPZbO3qtPyTlJBi-_VXE,2612
 tunacode/exceptions.py,sha256=_Dyj6cC0868dMABekdQHXCg5XhucJumbGUMXaSDzgB4,2645
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,17 +12,17 @@ tunacode/cli/repl.py,sha256=sXtRHYameAlMjlee82ix8P2JjRyWLrdFfHwxfaMKPb8,13722
 tunacode/cli/textual_app.py,sha256=14-Nt0IIETmyHBrNn9uwSF3EwCcutwTp6gdoKgNm0sY,12593
 tunacode/cli/textual_bridge.py,sha256=CTuf5Yjg5occQa7whyopS_erbJdS2UpWqaX_TVJ2D2A,6140
 tunacode/configuration/__init__.py,sha256=MbVXy8bGu0yKehzgdgZ_mfWlYGvIdb1dY2Ly75nfuPE,17
-tunacode/configuration/defaults.py,sha256=9JqGMdKsCT1uCmNVydXHEP1gsvqSMDSEbe8DUZcV_KI,723
+tunacode/configuration/defaults.py,sha256=oLgmHprB3cTaFvT9dn_rgg206zoj09GRXRbI7MYijxA,801
 tunacode/configuration/models.py,sha256=XPobkLM_TzKTuMIWhK-svJfGRGFT9r2LhKEM6rv6QHk,3756
 tunacode/configuration/settings.py,sha256=lm2ov8rG1t4C5JIXMOhIKik5FAsjpuLVYtFmnE1ZQ3k,995
 tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/state.py,sha256=n1claG-gVVDMBCCS8cDmgas4XbKLJJwKRc-8CtXeTS8,1376
 tunacode/core/tool_handler.py,sha256=OKx7jM8pml6pSEnoARu33_uBY8awJBqvhbVeBn6T4ow,1804
 tunacode/core/agents/__init__.py,sha256=TiXwymGRNMuOqQaRLpNCAt7bZArg8rkadIRs4Nw21SQ,275
-tunacode/core/agents/main.py,sha256=bfm_TS1Z9rpy3phIUb7d1lLbYK99xJwrtBy4PWPSEOE,16673
-tunacode/core/agents/orchestrator.py,sha256=t_eXtCO_QkIz687uT88RpDCmaE0-UkrUaczuTEJOrYQ,4154
+tunacode/core/agents/main.py,sha256=FCExe7pQ57z-GQh9p1RHEgaxHdMotJS21htdnHB-VK0,20612
+tunacode/core/agents/orchestrator.py,sha256=SSJyd4O_WZzcI5zygoUx1nhzRpfT6DrPsp2XtK2UVzY,8607
 tunacode/core/agents/planner_schema.py,sha256=pu2ehQVALjiJ5HJD7EN6xuZHCknsrXO9z0xHuVdlKW8,345
-tunacode/core/agents/readonly.py,sha256=NOPfqPWu53fJy77k5uqwKWmZ6yzqnDOZpBeQjGy0AG8,1624
+tunacode/core/agents/readonly.py,sha256=jOG3CF5G1y9k4sBn7ChXN1GXWbmB_0pFGcaMMI4iaLs,2325
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
 tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -67,9 +67,9 @@ tunacode/utils/ripgrep.py,sha256=AXUs2FFt0A7KBV996deS8wreIlUzKOlAHJmwrcAr4No,583
 tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,11381
 tunacode/utils/text_utils.py,sha256=B9M1cuLTm_SSsr15WNHF6j7WdLWPvWzKZV0Lvfgdbjg,2458
 tunacode/utils/user_configuration.py,sha256=IGvUH37wWtZ4M5xpukZEWYhtuKKyKcl6DaeObGXdleU,2610
-tunacode_cli-0.0.28.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.28.dist-info/METADATA,sha256=QAmjxfmzJELeyebnE3H5wCkgGILFP7COYWRcKkl6JFA,3619
-tunacode_cli-0.0.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.28.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.28.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.28.dist-info/RECORD,,
+tunacode_cli-0.0.29.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.29.dist-info/METADATA,sha256=QAJvK_x13W-wzNNNLr0WmSo3Xo1kHuskr3N9OFSGZxc,3619
+tunacode_cli-0.0.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.29.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.29.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
+tunacode_cli-0.0.29.dist-info/RECORD,,