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

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

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

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/pyproject.toml

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

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/src/tunacode/cli/commands.py

@@ -258,7 +258,8 @@ class ClearCommand(SimpleCommand):
 
         await ui.clear()
         context.state_manager.session.messages = []
-        await ui.success("Message history cleared")
+        context.state_manager.session.files_in_context.clear()
+        await ui.success("Message history and file context cleared")
 
 
 class FixCommand(SimpleCommand):

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/src/tunacode/cli/repl.py

@@ -9,6 +9,7 @@ import json
 import os
 import subprocess
 from asyncio.exceptions import CancelledError
+from pathlib import Path
 
 from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.application.current import get_app
@@ -164,6 +165,13 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         # Patch any orphaned tool calls from previous requests before proceeding
         patch_tool_messages("Tool execution was interrupted", state_manager)
 
+        # Clear tracking for new request when thoughts are enabled
+        if state_manager.session.show_thoughts:
+            state_manager.session.tool_calls = []
+            # Don't clear files_in_context - keep it cumulative for the session
+            state_manager.session.iteration_count = 0
+            state_manager.session.current_iteration = 0
+
         # Track message start for thoughts display
         start_idx = len(state_manager.session.messages)
 
@@ -177,7 +185,10 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 await ui.error(str(e))
                 return
@@ -199,12 +210,22 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 if not results:
                     # Fallback: show that the request was processed
                     await ui.muted("Request completed")
+
+                # Always show files in context after orchestrator response
+                if state_manager.session.files_in_context:
+                    filenames = [
+                        Path(f).name for f in sorted(state_manager.session.files_in_context)
+                    ]
+                    await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
         else:
             # Expand @file references before sending to the agent
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 await ui.error(str(e))
                 return
@@ -229,9 +250,22 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                     and hasattr(res.result, "output")
                 ):
                     await ui.agent(res.result.output)
+                    # Always show files in context after agent response
+                    if state_manager.session.files_in_context:
+                        # Extract just filenames from full paths for readability
+                        filenames = [
+                            Path(f).name for f in sorted(state_manager.session.files_in_context)
+                        ]
+                        await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
                 else:
                     # Fallback: show that the request was processed
                     await ui.muted("Request completed")
+                    # Show files in context even for empty responses
+                    if state_manager.session.files_in_context:
+                        filenames = [
+                            Path(f).name for f in sorted(state_manager.session.files_in_context)
+                        ]
+                        await ui.muted(f"Files in context: {', '.join(filenames)}")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/src/tunacode/cli/textual_bridge.py

@@ -72,7 +72,10 @@ class TextualAgentBridge:
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    self.state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 return f"Error: {str(e)}"
 

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/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.30}/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.30"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.28 → tunacode_cli-0.0.30}/src/tunacode/core/agents/main.py

@@ -38,6 +38,9 @@ def get_model_messages():
 
 
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+    from tunacode.ui import console as ui
+    from tunacode.utils.token_counter import estimate_tokens
+
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
@@ -45,36 +48,47 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
         state_manager.session.messages.append({"thought": node.thought})
         # Display thought immediately if show_thoughts is enabled
         if state_manager.session.show_thoughts:
-            from tunacode.ui import console as ui
-
-            await ui.muted(f"💭 THOUGHT: {node.thought}")
+            await ui.muted(f"THOUGHT: {node.thought}")
 
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
 
-        # Enhanced ReAct thought processing
+        # Enhanced display when thoughts are enabled
         if state_manager.session.show_thoughts:
             import json
             import re
 
-            from tunacode.ui import console as ui
-
+            # Display LLM response content
             for part in node.model_response.parts:
                 if hasattr(part, "content") and isinstance(part.content, str):
                     content = part.content.strip()
 
+                    # Skip empty content
+                    if not content:
+                        continue
+
+                    # Estimate tokens in this response
+                    token_count = estimate_tokens(content)
+
+                    # Display non-JSON content as LLM response
+                    if not content.startswith('{"thought"'):
+                        # Truncate very long responses for display
+                        display_content = content[:500] + "..." if len(content) > 500 else content
+                        await ui.muted(f"\nRESPONSE: {display_content}")
+                        await ui.muted(f"TOKENS: ~{token_count}")
+
                     # Pattern 1: Inline JSON thoughts {"thought": "..."}
                     thought_pattern = r'\{"thought":\s*"([^"]+)"\}'
                     matches = re.findall(thought_pattern, content)
                     for thought in matches:
-                        await ui.muted(f"💭 REASONING: {thought}")
+                        await ui.muted(f"REASONING: {thought}")
 
                     # Pattern 2: Standalone thought JSON objects
                     try:
                         if content.startswith('{"thought"'):
                             thought_obj = json.loads(content)
                             if "thought" in thought_obj:
-                                await ui.muted(f"💭 REASONING: {thought_obj['thought']}")
+                                await ui.muted(f"REASONING: {thought_obj['thought']}")
                     except (json.JSONDecodeError, KeyError):
                         pass
 
@@ -85,36 +99,86 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
                         if thought not in [m for m in matches]:  # Avoid duplicates
                             # Clean up escaped characters
                             cleaned_thought = thought.replace('\\"', '"').replace("\\n", " ")
-                            await ui.muted(f"💭 REASONING: {cleaned_thought}")
-
-                    # Pattern 4: Text-based reasoning indicators
-                    reasoning_indicators = [
-                        (r"I need to (.+?)\.", "PLANNING"),
-                        (r"Let me (.+?)\.", "ACTION"),
-                        (r"The output shows (.+?)\.", "OBSERVATION"),
-                        (r"Based on (.+?), I should (.+?)\.", "DECISION"),
-                    ]
-
-                    for pattern, label in reasoning_indicators:
-                        indicator_matches = re.findall(pattern, content, re.IGNORECASE)
-                        for match in indicator_matches:
-                            if isinstance(match, tuple):
-                                match_text = " ".join(match)
-                            else:
-                                match_text = match
-                            await ui.muted(f"🎯 {label}: {match_text}")
-                            break  # Only show first match per pattern
+                            await ui.muted(f"REASONING: {cleaned_thought}")
 
         # Check for tool calls and fallback to JSON parsing if needed
         has_tool_calls = False
         for part in node.model_response.parts:
             if part.part_kind == "tool-call" and tool_callback:
                 has_tool_calls = True
+
+                # Display tool call details when thoughts are enabled
+                if state_manager.session.show_thoughts:
+                    await ui.muted(f"\nTOOL: {part.tool_name}")
+                    if hasattr(part, "args"):
+                        # Check if args is a dictionary before accessing keys
+                        if isinstance(part.args, dict):
+                            # Simplify display based on tool type
+                            if part.tool_name == "read_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Reading: {filename}")
+                            elif part.tool_name == "write_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Writing: {filename}")
+                            elif part.tool_name == "update_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Updating: {filename}")
+                            elif (
+                                part.tool_name in ["run_command", "bash"] and "command" in part.args
+                            ):
+                                command = part.args["command"]
+                                # Truncate long commands
+                                display_cmd = (
+                                    command if len(command) <= 60 else command[:57] + "..."
+                                )
+                                await ui.muted(f"Command: {display_cmd}")
+                            else:
+                                # For other tools, show full args but more compact
+                                args_str = json.dumps(part.args, indent=2)
+                                await ui.muted(f"ARGS: {args_str}")
+                        else:
+                            # If args is not a dict (e.g., a string), just display it as is
+                            await ui.muted(f"ARGS: {part.args}")
+
+                # Track this tool call (moved outside thoughts block)
+                state_manager.session.tool_calls.append(
+                    {
+                        "tool": part.tool_name,
+                        "args": part.args if hasattr(part, "args") else {},
+                        "iteration": state_manager.session.current_iteration,
+                    }
+                )
+
+                # Track files if this is read_file (moved outside thoughts block)
+                if (
+                    part.tool_name == "read_file"
+                    and hasattr(part, "args")
+                    and "file_path" in part.args
+                ):
+                    state_manager.session.files_in_context.add(part.args["file_path"])
+                    # Show files in context when thoughts are enabled
+                    if state_manager.session.show_thoughts:
+                        await ui.muted(
+                            f"\nFILES IN CONTEXT: {list(state_manager.session.files_in_context)}"
+                        )
+
                 await tool_callback(part, node)
+
             elif part.part_kind == "tool-return":
                 obs_msg = f"OBSERVATION[{part.tool_name}]: {part.content[:2_000]}"
                 state_manager.session.messages.append(obs_msg)
 
+                # Display tool return when thoughts are enabled
+                if state_manager.session.show_thoughts:
+                    # Truncate for display
+                    display_content = (
+                        part.content[:200] + "..." if len(part.content) > 200 else part.content
+                    )
+                    await ui.muted(f"TOOL RESULT: {display_content}")
+
         # If no structured tool calls found, try parsing JSON from text content
         if not has_tool_calls and tool_callback:
             for part in node.model_response.parts:
@@ -276,13 +340,13 @@ async def parse_json_tool_calls(
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.muted(f"🔧 FALLBACK: Executed {tool_name} via JSON parsing")
+                await ui.muted(f"FALLBACK: Executed {tool_name} via JSON parsing")
 
         except Exception as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.error(f"❌ Error executing fallback tool {tool_name}: {str(e)}")
+                await ui.error(f"Error executing fallback tool {tool_name}: {str(e)}")
 
 
 async def extract_and_execute_tool_calls(
@@ -324,13 +388,13 @@ async def extract_and_execute_tool_calls(
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.muted(f"🔧 FALLBACK: Executed {tool_data['tool']} from code block")
+                    await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
 
         except (json.JSONDecodeError, KeyError, Exception) as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.error(f"❌ Error parsing code block tool call: {str(e)}")
+                await ui.error(f"Error parsing code block tool call: {str(e)}")
 
 
 async def process_request(
@@ -349,49 +413,160 @@ async def process_request(
 
     response_state = ResponseState()
 
+    # Reset iteration tracking for this request
+    state_manager.session.iteration_count = 0
+
     async with agent.iter(message, message_history=mh) as agent_run:
         i = 0
         async for node in agent_run:
+            state_manager.session.current_iteration = i + 1
             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
+            state_manager.session.iteration_count = i
 
             # Display iteration progress if thoughts are enabled
-            if state_manager.session.show_thoughts and i > 1:
+            if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.muted(f"🔄 Iteration {i}/{max_iterations}")
+                await ui.muted(f"\nITERATION: {i}/{max_iterations}")
+
+                # Show summary of tools used so far
+                if state_manager.session.tool_calls:
+                    tool_summary = {}
+                    for tc in state_manager.session.tool_calls:
+                        tool_name = tc.get("tool", "unknown")
+                        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+
+                    summary_str = ", ".join(
+                        [f"{name}: {count}" for name, count in tool_summary.items()]
+                    )
+                    await ui.muted(f"TOOLS USED: {summary_str}")
 
             if i >= max_iterations:
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.warning(f"⚠️ Reached maximum iterations ({max_iterations})")
+                    await ui.warning(f"Reached maximum iterations ({max_iterations})")
                 break
 
         # If we need to add a fallback response, create a wrapper
         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:
                 def __init__(self, wrapped_run, fallback_result):
                     self._wrapped = wrapped_run
-                    self.result = fallback_result
+                    self._result = fallback_result
                     self.response_state = response_state
 
-                def __getattr__(self, name):
+                def __getattribute__(self, name):
+                    # Handle special attributes first to avoid conflicts
+                    if name in ["_wrapped", "_result", "response_state"]:
+                        return object.__getattribute__(self, name)
+
+                    # Explicitly handle 'result' to return our fallback result
+                    if name == "result":
+                        return object.__getattribute__(self, "_result")
+
                     # Delegate all other attributes to the wrapped object
-                    return getattr(self._wrapped, name)
+                    try:
+                        return getattr(object.__getattribute__(self, "_wrapped"), name)
+                    except AttributeError:
+                        raise AttributeError(
+                            f"'{type(self).__name__}' object has no attribute '{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
@@ -400,8 +575,17 @@ async def process_request(
                 self._wrapped = wrapped_run
                 self.response_state = response_state
 
-            def __getattr__(self, name):
+            def __getattribute__(self, name):
+                # Handle special attributes first
+                if name in ["_wrapped", "response_state"]:
+                    return object.__getattribute__(self, name)
+
                 # Delegate all other attributes to the wrapped object
-                return getattr(self._wrapped, name)
+                try:
+                    return getattr(object.__getattribute__(self, "_wrapped"), name)
+                except AttributeError:
+                    raise AttributeError(
+                        f"'{type(self).__name__}' object has no attribute '{name}'"
+                    )
 
         return AgentRunWithState(agent_run)