tunacode-cli 0.0.28__tar.gz → 0.0.29__tar.gz

{tunacode_cli-0.0.28/src/tunacode_cli.egg-info → tunacode_cli-0.0.29}/PKG-INFO

@@ -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 → tunacode_cli-0.0.29}/pyproject.toml

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

{tunacode_cli-0.0.28 → tunacode_cli-0.0.29}/src/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_cli-0.0.28 → tunacode_cli-0.0.29}/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.28"
+APP_VERSION = "0.0.29"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.28 → tunacode_cli-0.0.29}/src/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_cli-0.0.29/src/tunacode/core/agents/orchestrator.py

@@ -0,0 +1,213 @@
+"""Agent orchestration scaffolding.
+
+This module defines an ``OrchestratorAgent`` class that demonstrates how
+higher level planning and delegation could be layered on top of the existing
+``process_request`` workflow.  The goal is to keep orchestration logic isolated
+from the core agent implementation while reusing all current tooling and state
+handling provided by ``main.process_request``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import itertools
+from typing import List
+
+from ...types import AgentRun, FallbackResponse, ModelName, ResponseState
+from ..llm.planner import make_plan
+from ..state import StateManager
+from . import main as agent_main
+from .planner_schema import Task
+from .readonly import ReadOnlyAgent
+
+
+class OrchestratorAgent:
+    """Plan and run a sequence of sub-agent tasks."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state = state_manager
+
+    async def plan(self, request: str, model: ModelName) -> List[Task]:
+        """Plan tasks for a user request using the planner LLM."""
+
+        return await make_plan(request, model, self.state)
+
+    async def _run_sub_task(self, task: Task, model: ModelName) -> AgentRun:
+        """Execute a single task using an appropriate sub-agent."""
+        from rich.console import Console
+
+        console = Console()
+
+        # Show which task is being executed
+        task_type = "WRITE" if task.mutate else "READ"
+        console.print(f"\n[dim][Task {task.id}] {task_type}[/dim]")
+        console.print(f"[dim]  → {task.description}[/dim]")
+
+        if task.mutate:
+            agent_main.get_or_create_agent(model, self.state)
+            result = await agent_main.process_request(model, task.description, self.state)
+        else:
+            agent = ReadOnlyAgent(model, self.state)
+            result = await agent.process_request(task.description)
+
+        console.print(f"[dim][Task {task.id}] Complete[/dim]")
+        return result
+
+    async def run(self, request: str, model: ModelName | None = None) -> List[AgentRun]:
+        """Plan and execute a user request.
+
+        Parameters
+        ----------
+        request:
+            The high level user request to process.
+        model:
+            Optional model name to use for sub agents.  Defaults to the current
+            session model.
+        """
+        from rich.console import Console
+
+        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]"
+        )
+
+        tasks = await self.plan(request, model)
+
+        # Show execution is starting
+        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:
+                    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)
+                if len(task_list) > 1:
+                    console.print(
+                        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]
+                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]")
+
+        # 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
+        )
+
+        fallback_enabled = self.state.session.user_config.get("settings", {}).get(
+            "fallback_response", True
+        )
+
+        # 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 FallbackRun:
+                def __init__(self, synthesis: str, response_state: ResponseState):
+                    self.result = FallbackResult(synthesis, response_state)
+                    self.response_state = response_state
+
+            response_state.has_final_synthesis = True
+            results.append(FallbackRun(synthesis, response_state))
+
+        return results

{tunacode_cli-0.0.28 → tunacode_cli-0.0.29}/src/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 → tunacode_cli-0.0.29/src/tunacode_cli.egg-info}/PKG-INFO

@@ -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 → tunacode_cli-0.0.29}/tests/test_fallback_responses.py

@@ -51,4 +51,6 @@ async def test_orchestrator_synthesizes_summary():
         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()
+            # Check that fallback response was generated
+            assert "orchestrator completed all tasks" in results[-1].result.output.lower()
+            assert "executed 1/1 tasks" in results[-1].result.output.lower()

tunacode_cli-0.0.28/src/tunacode/core/agents/orchestrator.py

@@ -1,117 +0,0 @@
-"""Agent orchestration scaffolding.
-
-This module defines an ``OrchestratorAgent`` class that demonstrates how
-higher level planning and delegation could be layered on top of the existing
-``process_request`` workflow.  The goal is to keep orchestration logic isolated
-from the core agent implementation while reusing all current tooling and state
-handling provided by ``main.process_request``.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import itertools
-from typing import List
-
-from ...types import AgentRun, ModelName
-from ..llm.planner import make_plan
-from ..state import StateManager
-from . import main as agent_main
-from .planner_schema import Task
-from .readonly import ReadOnlyAgent
-
-
-class OrchestratorAgent:
-    """Plan and run a sequence of sub-agent tasks."""
-
-    def __init__(self, state_manager: StateManager):
-        self.state = state_manager
-
-    async def plan(self, request: str, model: ModelName) -> List[Task]:
-        """Plan tasks for a user request using the planner LLM."""
-
-        return await make_plan(request, model, self.state)
-
-    async def _run_sub_task(self, task: Task, model: ModelName) -> AgentRun:
-        """Execute a single task using an appropriate sub-agent."""
-        from rich.console import Console
-
-        console = Console()
-
-        # Show which task is being executed
-        task_type = "WRITE" if task.mutate else "READ"
-        console.print(f"\n[dim][Task {task.id}] {task_type}[/dim]")
-        console.print(f"[dim]  → {task.description}[/dim]")
-
-        if task.mutate:
-            agent_main.get_or_create_agent(model, self.state)
-            result = await agent_main.process_request(model, task.description, self.state)
-        else:
-            agent = ReadOnlyAgent(model, self.state)
-            result = await agent.process_request(task.description)
-
-        console.print(f"[dim][Task {task.id}] Complete[/dim]")
-        return result
-
-    async def run(self, request: str, model: ModelName | None = None) -> List[AgentRun]:
-        """Plan and execute a user request.
-
-        Parameters
-        ----------
-        request:
-            The high level user request to process.
-        model:
-            Optional model name to use for sub agents.  Defaults to the current
-            session model.
-        """
-        from rich.console import Console
-
-        console = Console()
-        model = model or self.state.session.current_model
-
-        # Show orchestrator is starting
-        console.print(
-            "\n[cyan]Orchestrator Mode: Analyzing request and creating execution plan...[/cyan]"
-        )
-
-        tasks = await self.plan(request, model)
-
-        # Show execution is starting
-        console.print(f"\n[cyan]Executing plan with {len(tasks)} tasks...[/cyan]")
-
-        results: List[AgentRun] = []
-        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))
-            else:
-                # Show parallel execution
-                task_list = list(group)
-                if len(task_list) > 1:
-                    console.print(
-                        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))
-
-        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
-
-            class SynthRun:
-                def __init__(self):
-                    self.result = SynthResult(summary)
-
-            results.append(SynthRun())
-
-        return results