tunacode-cli 0.0.13__py3-none-any.whl → 0.0.14__py3-none-any.whl

tunacode/cli/commands.py

@@ -138,6 +138,73 @@ class DumpCommand(SimpleCommand):
         await ui.dump_messages(context.state_manager.session.messages)
 
 
+class ThoughtsCommand(SimpleCommand):
+    """Toggle display of agent thoughts."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="thoughts",
+                aliases=["/thoughts"],
+                description="Show or hide agent thought messages",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+        if args:
+            arg = args[0].lower()
+            if arg in {"on", "1", "true"}:
+                state.show_thoughts = True
+            elif arg in {"off", "0", "false"}:
+                state.show_thoughts = False
+            else:
+                await ui.error("Usage: /thoughts [on|off]")
+                return
+        else:
+            state.show_thoughts = not state.show_thoughts
+        status = "ON" if state.show_thoughts else "OFF"
+        await ui.success(f"Thought display {status}")
+
+
+class IterationsCommand(SimpleCommand):
+    """Configure maximum agent iterations for ReAct reasoning."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="iterations",
+                aliases=["/iterations"],
+                description="Set maximum agent iterations for complex reasoning",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+        if args:
+            try:
+                new_limit = int(args[0])
+                if new_limit < 1 or new_limit > 50:
+                    await ui.error("Iterations must be between 1 and 50")
+                    return
+                
+                # Update the user config
+                if "settings" not in state.user_config:
+                    state.user_config["settings"] = {}
+                state.user_config["settings"]["max_iterations"] = new_limit
+                
+                await ui.success(f"Maximum iterations set to {new_limit}")
+                await ui.muted("Higher values allow more complex reasoning but may be slower")
+            except ValueError:
+                await ui.error("Please provide a valid number")
+        else:
+            current = state.user_config.get("settings", {}).get("max_iterations", 15)
+            await ui.info(f"Current maximum iterations: {current}")
+            await ui.muted("Usage: /iterations <number> (1-50)")
+
+
 class ClearCommand(SimpleCommand):
     """Clear screen and message history."""
 
@@ -152,8 +219,127 @@ class ClearCommand(SimpleCommand):
         )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
+        # Patch any orphaned tool calls before clearing
+        from tunacode.core.agents.main import patch_tool_messages
+        patch_tool_messages("Conversation cleared", context.state_manager)
+        
         await ui.clear()
         context.state_manager.session.messages = []
+        await ui.success("Message history cleared")
+
+
+class FixCommand(SimpleCommand):
+    """Fix orphaned tool calls that cause API errors."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="fix",
+                aliases=["/fix"],
+                description="Fix orphaned tool calls causing API errors",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.core.agents.main import patch_tool_messages
+        
+        # Count current messages
+        before_count = len(context.state_manager.session.messages)
+        
+        # Patch orphaned tool calls
+        patch_tool_messages("Tool call resolved by /fix command", context.state_manager)
+        
+        # Count after patching
+        after_count = len(context.state_manager.session.messages)
+        patched_count = after_count - before_count
+        
+        if patched_count > 0:
+            await ui.success(f"Fixed {patched_count} orphaned tool call(s)")
+            await ui.muted("You can now continue the conversation normally")
+        else:
+            await ui.info("No orphaned tool calls found")
+
+
+class ParseToolsCommand(SimpleCommand):
+    """Parse and execute JSON tool calls from the last response."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="parsetools",
+                aliases=["/parsetools"],
+                description="Parse JSON tool calls from last response when structured calling fails",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.core.agents.main import extract_and_execute_tool_calls
+        
+        # Find the last model response in messages
+        messages = context.state_manager.session.messages
+        if not messages:
+            await ui.error("No message history found")
+            return
+        
+        # Look for the most recent response with text content
+        found_content = False
+        for msg in reversed(messages):
+            if hasattr(msg, 'parts'):
+                for part in msg.parts:
+                    if hasattr(part, 'content') and isinstance(part.content, str):
+                        # Create tool callback
+                        from tunacode.cli.repl import _tool_handler
+                        def tool_callback_with_state(part, node):
+                            return _tool_handler(part, node, context.state_manager)
+                        
+                        try:
+                            await extract_and_execute_tool_calls(
+                                part.content, 
+                                tool_callback_with_state, 
+                                context.state_manager
+                            )
+                            await ui.success("JSON tool parsing completed")
+                            found_content = True
+                            return
+                        except Exception as e:
+                            await ui.error(f"Failed to parse tools: {str(e)}")
+                            return
+        
+        if not found_content:
+            await ui.error("No parseable content found in recent messages")
+
+
+class RefreshConfigCommand(SimpleCommand):
+    """Refresh configuration from defaults."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="refresh",
+                aliases=["/refresh"],
+                description="Refresh configuration from defaults (useful after updates)",
+                category=CommandCategory.SYSTEM,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
+        
+        # Update current session config with latest defaults
+        for key, value in DEFAULT_USER_CONFIG.items():
+            if key not in context.state_manager.session.user_config:
+                context.state_manager.session.user_config[key] = value
+            elif isinstance(value, dict):
+                # Merge dict values, preserving user overrides
+                for subkey, subvalue in value.items():
+                    if subkey not in context.state_manager.session.user_config[key]:
+                        context.state_manager.session.user_config[key][subkey] = subvalue
+        
+        # Show updated max_iterations
+        max_iterations = context.state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
+        await ui.success(f"Configuration refreshed - max iterations: {max_iterations}")
 
 
 class TunaCodeCommand(SimpleCommand):
@@ -232,7 +418,6 @@ class HelpCommand(SimpleCommand):
         await ui.help(self._command_registry)
 
 
-
 class BranchCommand(SimpleCommand):
     """Create and switch to a new git branch."""
 
@@ -247,8 +432,8 @@ class BranchCommand(SimpleCommand):
         )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
-        import subprocess
         import os
+        import subprocess
 
         if not args:
             await ui.error("Usage: /branch <branch-name>")
@@ -332,14 +517,16 @@ class ModelCommand(SimpleCommand):
 
         # Get the model name from args
         model_name = args[0]
-        
+
         # Check if provider prefix is present
         if ":" not in model_name:
             await ui.error("Model name must include provider prefix")
             await ui.muted("Format: provider:model-name")
-            await ui.muted("Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash")
+            await ui.muted(
+                "Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash"
+            )
             return None
-        
+
         # No validation - user is responsible for correct model names
         await ui.warning("Model set without validation - verify the model name is correct")
 
@@ -416,8 +603,7 @@ class CommandRegistry:
         category_commands = self._categories[command.category]
         # Remove any existing instance of this command class
         self._categories[command.category] = [
-            cmd for cmd in category_commands 
-            if cmd.__class__ != command.__class__
+            cmd for cmd in category_commands if cmd.__class__ != command.__class__
         ]
         # Add the new instance
         self._categories[command.category].append(command)
@@ -436,7 +622,12 @@ class CommandRegistry:
         command_classes = [
             YoloCommand,
             DumpCommand,
+            ThoughtsCommand,
+            IterationsCommand,
             ClearCommand,
+            FixCommand,
+            ParseToolsCommand,
+            RefreshConfigCommand,
             HelpCommand,
             BranchCommand,
             # TunaCodeCommand,  # TODO: Temporarily disabled
@@ -459,7 +650,7 @@ class CommandRegistry:
         # Only update if callback has changed
         if self._factory.dependencies.process_request_callback == callback:
             return
-            
+
         self._factory.update_dependencies(process_request_callback=callback)
 
         # Re-register CompactCommand with new dependency if already registered
@@ -494,10 +685,10 @@ class CommandRegistry:
         if command_name in self._commands:
             command = self._commands[command_name]
             return await command.execute(args, context)
-        
+
         # Try partial matching
         matches = self.find_matching_commands(command_name)
-        
+
         if not matches:
             raise ValidationError(f"Unknown command: {command_name}")
         elif len(matches) == 1:
@@ -513,10 +704,10 @@ class CommandRegistry:
     def find_matching_commands(self, partial_command: str) -> List[str]:
         """
         Find all commands that start with the given partial command.
-        
+
         Args:
             partial_command: The partial command to match
-            
+
         Returns:
             List of matching command names
         """
@@ -534,11 +725,11 @@ class CommandRegistry:
             return False
 
         command_name = parts[0].lower()
-        
+
         # Check exact match first
         if command_name in self._commands:
             return True
-            
+
         # Check partial match
         return len(self.find_matching_commands(command_name)) > 0
 

tunacode/cli/repl.py

@@ -167,10 +167,14 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             await ui.error(str(e))
             return
 
+        # Patch any orphaned tool calls from previous requests before proceeding
+        patch_tool_messages("Tool execution was interrupted", state_manager)
+        
         # Create a partial function that includes state_manager
         def tool_callback_with_state(part, node):
             return _tool_handler(part, node, state_manager)
 
+        start_idx = len(state_manager.session.messages)
         res = await agent.process_request(
             state_manager.session.current_model,
             text,
@@ -178,7 +182,17 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             tool_callback=tool_callback_with_state,
         )
         if output:
-            await ui.agent(res.result.output)
+            if state_manager.session.show_thoughts:
+                new_msgs = state_manager.session.messages[start_idx:]
+                for msg in new_msgs:
+                    if isinstance(msg, dict) and "thought" in msg:
+                        await ui.muted(f"THOUGHT: {msg['thought']}")
+            # Check if result exists and has output
+            if hasattr(res, 'result') and res.result is not None and hasattr(res.result, 'output'):
+                await ui.agent(res.result.output)
+            else:
+                # Fallback: show that the request was processed
+                await ui.muted("Request completed")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:
@@ -188,6 +202,31 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         await ui.muted(error_message)
         patch_tool_messages(error_message, state_manager)
     except Exception as e:
+        # Check if this might be a tool calling failure that we can recover from
+        error_str = str(e).lower()
+        if any(keyword in error_str for keyword in ['tool', 'function', 'call', 'schema']):
+            # Try to extract and execute tool calls from the last response
+            if state_manager.session.messages:
+                last_msg = state_manager.session.messages[-1]
+                if hasattr(last_msg, 'parts'):
+                    for part in last_msg.parts:
+                        if hasattr(part, 'content') and isinstance(part.content, str):
+                            from tunacode.core.agents.main import extract_and_execute_tool_calls
+                            try:
+                                # Create a partial function that includes state_manager
+                                def tool_callback_with_state(part, node):
+                                    return _tool_handler(part, node, state_manager)
+                                    
+                                await extract_and_execute_tool_calls(
+                                    part.content, 
+                                    tool_callback_with_state, 
+                                    state_manager
+                                )
+                                await ui.warning("🔧 Recovered using JSON tool parsing")
+                                return  # Successfully recovered
+                            except Exception:
+                                pass  # Fallback failed, continue with normal error handling
+        
         # Wrap unexpected exceptions in AgentError for better tracking
         agent_error = AgentError(f"Agent processing failed: {str(e)}")
         agent_error.__cause__ = e  # Preserve the original exception chain
@@ -210,7 +249,7 @@ async def repl(state_manager: StateManager):
     await ui.muted(f"• Model: {state_manager.session.current_model}")
     await ui.success("Ready to assist with your development")
     await ui.line()
-    
+
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
 
     async with instance.run_mcp_servers():

tunacode/configuration/defaults.py

@@ -18,6 +18,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
     },
     "settings": {
         "max_retries": 10,
+        "max_iterations": 20,
         "tool_ignore": [TOOL_READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
     },

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

tunacode/core/agents/main.py

@@ -4,6 +4,8 @@ Main agent functionality and coordination for the TunaCode CLI.
 Handles agent creation, configuration, and request processing.
 """
 
+import json
+import re
 from datetime import datetime, timezone
 from typing import Optional
 
@@ -13,32 +15,125 @@ from pydantic_ai.messages import ModelRequest, ToolReturnPart
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
+from tunacode.tools.grep import grep
 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,
+    ModelName,
+    PydanticAgent,
+    ToolCallback,
+    ToolCallId,
+    ToolName,
+)
 
 
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
+    if hasattr(node, "thought") and node.thought:
+        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}")
+
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
+        
+        # Enhanced ReAct thought processing
+        if state_manager.session.show_thoughts:
+            from tunacode.ui import console as ui
+            import json
+            import re
+            
+            for part in node.model_response.parts:
+                if hasattr(part, 'content') and isinstance(part.content, str):
+                    content = part.content.strip()
+                    
+                    # 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}")
+                        
+                    # 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']}")
+                    except (json.JSONDecodeError, KeyError):
+                        pass
+                    
+                    # Pattern 3: Multi-line thoughts with context
+                    multiline_pattern = r'\{"thought":\s*"([^"]+(?:\\.[^"]*)*?)"\}'
+                    multiline_matches = re.findall(multiline_pattern, content, re.DOTALL)
+                    for thought in multiline_matches:
+                        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
+        
+        # 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
                 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)
+        
+        # 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:
+                if hasattr(part, 'content') and isinstance(part.content, str):
+                    await extract_and_execute_tool_calls(part.content, tool_callback, state_manager)
 
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     if model not in state_manager.session.agents:
         max_retries = state_manager.session.user_config["settings"]["max_retries"]
+        
+        # Load system prompt
+        import os
+        from pathlib import Path
+        prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.txt"
+        try:
+            with open(prompt_path, "r", encoding="utf-8") as f:
+                system_prompt = f.read().strip()
+        except FileNotFoundError:
+            system_prompt = None
+        
         state_manager.session.agents[model] = Agent(
             model=model,
+            system_prompt=system_prompt,
             tools=[
                 Tool(bash, max_retries=max_retries),
+                Tool(grep, max_retries=max_retries),
                 Tool(read_file, max_retries=max_retries),
                 Tool(run_command, max_retries=max_retries),
                 Tool(update_file, max_retries=max_retries),
@@ -107,6 +202,110 @@ def patch_tool_messages(
             )
 
 
+async def parse_json_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+    """
+    Parse JSON tool calls from text when structured tool calling fails.
+    Fallback for when API providers don't support proper tool calling.
+    """
+    if not tool_callback:
+        return
+    
+    # Pattern for JSON tool calls: {"tool": "tool_name", "args": {...}}
+    # Find potential JSON objects and parse them
+    potential_jsons = []
+    brace_count = 0
+    start_pos = -1
+    
+    for i, char in enumerate(text):
+        if char == '{':
+            if brace_count == 0:
+                start_pos = i
+            brace_count += 1
+        elif char == '}':
+            brace_count -= 1
+            if brace_count == 0 and start_pos != -1:
+                potential_json = text[start_pos:i+1]
+                try:
+                    parsed = json.loads(potential_json)
+                    if isinstance(parsed, dict) and 'tool' in parsed and 'args' in parsed:
+                        potential_jsons.append((parsed['tool'], parsed['args']))
+                except json.JSONDecodeError:
+                    pass
+                start_pos = -1
+    
+    matches = potential_jsons
+    
+    for tool_name, args in matches:
+        try:
+            # Create a mock tool call object
+            class MockToolCall:
+                def __init__(self, tool_name: str, args: dict):
+                    self.tool_name = tool_name
+                    self.args = args
+                    self.tool_call_id = f"fallback_{datetime.now().timestamp()}"
+            
+            class MockNode:
+                pass
+            
+            # Execute the tool through the callback
+            mock_call = MockToolCall(tool_name, args)
+            mock_node = MockNode()
+            
+            await tool_callback(mock_call, mock_node)
+            
+            if state_manager.session.show_thoughts:
+                from tunacode.ui import console as ui
+                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)}")
+
+
+async def extract_and_execute_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+    """
+    Extract tool calls from text content and execute them.
+    Supports multiple formats for maximum compatibility.
+    """
+    if not tool_callback:
+        return
+    
+    # Format 1: {"tool": "name", "args": {...}}
+    await parse_json_tool_calls(text, tool_callback, state_manager)
+    
+    # Format 2: Tool calls in code blocks
+    code_block_pattern = r'```json\s*(\{(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*"tool"(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*\})\s*```'
+    code_matches = re.findall(code_block_pattern, text, re.MULTILINE | re.DOTALL)
+    
+    for match in code_matches:
+        try:
+            tool_data = json.loads(match)
+            if 'tool' in tool_data and 'args' in tool_data:
+                class MockToolCall:
+                    def __init__(self, tool_name: str, args: dict):
+                        self.tool_name = tool_name
+                        self.args = args
+                        self.tool_call_id = f"codeblock_{datetime.now().timestamp()}"
+                
+                class MockNode:
+                    pass
+                
+                mock_call = MockToolCall(tool_data['tool'], tool_data['args'])
+                mock_node = MockNode()
+                
+                await tool_callback(mock_call, mock_node)
+                
+                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")
+                    
+        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)}")
+
+
 async def process_request(
     model: ModelName,
     message: str,
@@ -115,7 +314,24 @@ async def process_request(
 ) -> AgentRun:
     agent = get_or_create_agent(model, state_manager)
     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)
+    
     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)
+            i += 1
+            
+            # Display iteration progress if thoughts are enabled
+            if state_manager.session.show_thoughts and i > 1:
+                from tunacode.ui import console as ui
+                await ui.muted(f"🔄 Iteration {i}/{max_iterations}")
+            
+            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})")
+                break
+                
         return agent_run