tunacode-cli 0.0.76__py3-none-any.whl → 0.0.76.2__py3-none-any.whl

tunacode/core/agents/utils.py

@@ -3,9 +3,8 @@ import importlib
 import json
 import logging
 import os
-import re
 from collections.abc import Iterator
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any
 
 from tunacode.constants import (
@@ -16,11 +15,8 @@ from tunacode.constants import (
 )
 from tunacode.exceptions import ToolBatchingJSONError
 from tunacode.types import (
-    ErrorMessage,
     StateManager,
     ToolCallback,
-    ToolCallId,
-    ToolName,
 )
 from tunacode.ui import console as ui
 from tunacode.utils.retry import retry_json_parse_async
@@ -267,127 +263,3 @@ async def parse_json_tool_calls(
         except Exception as e:
             if state_manager.session.show_thoughts:
                 await ui.error(f"Error executing fallback tool {tool_name}: {e!s}")
-
-
-async def extract_and_execute_tool_calls(
-    text: str, tool_callback: ToolCallback | None, state_manager: StateManager
-):
-    """Extract tool calls from text content and execute them.
-    Supports multiple formats for maximum compatibility.
-    """
-    if not tool_callback:
-        return
-
-    # 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)
-    remaining_text = re.sub(code_block_pattern, "", text)
-
-    for match in code_matches:
-        try:
-            # Use retry logic for JSON parsing in code blocks
-            tool_data = await retry_json_parse_async(
-                match,
-                max_retries=JSON_PARSE_MAX_RETRIES,
-                base_delay=JSON_PARSE_BASE_DELAY,
-                max_delay=JSON_PARSE_MAX_DELAY,
-            )
-            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:
-                    await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
-
-        except json.JSONDecodeError as e:
-            # After all retries failed
-            logger.error(
-                f"Code block JSON parsing failed after {JSON_PARSE_MAX_RETRIES} retries: {e}"
-            )
-            if state_manager.session.show_thoughts:
-                await ui.error(
-                    f"Failed to parse code block tool JSON after {JSON_PARSE_MAX_RETRIES} retries"
-                )
-            # Raise custom exception for better error handling
-            raise ToolBatchingJSONError(
-                json_content=match,
-                retry_count=JSON_PARSE_MAX_RETRIES,
-                original_error=e,
-            ) from e
-        except (KeyError, Exception) as e:
-            if state_manager.session.show_thoughts:
-                await ui.error(f"Error parsing code block tool call: {e!s}")
-
-    # Format 1: {"tool": "name", "args": {...}}
-    await parse_json_tool_calls(remaining_text, tool_callback, state_manager)
-
-
-def patch_tool_messages(
-    error_message: ErrorMessage = "Tool operation failed",
-    state_manager: StateManager = None,
-):
-    """Find any tool calls without responses and add synthetic error responses for them.
-    Takes an error message to use in the synthesized tool response.
-
-    Ignores tools that have corresponding retry prompts as the model is already
-    addressing them.
-    """
-    if state_manager is None:
-        raise ValueError("state_manager is required for patch_tool_messages")
-
-    messages = state_manager.session.messages
-
-    if not messages:
-        return
-
-    # Map tool calls to their tool returns
-    tool_calls: dict[ToolCallId, ToolName] = {}  # tool_call_id -> tool_name
-    tool_returns: set[ToolCallId] = set()  # set of tool_call_ids with returns
-    retry_prompts: set[ToolCallId] = set()  # set of tool_call_ids with retry prompts
-
-    for message in messages:
-        if hasattr(message, "parts"):
-            for part in message.parts:
-                if (
-                    hasattr(part, "part_kind")
-                    and hasattr(part, "tool_call_id")
-                    and part.tool_call_id
-                ):
-                    if part.part_kind == "tool-call":
-                        tool_calls[part.tool_call_id] = part.tool_name
-                    elif part.part_kind == "tool-return":
-                        tool_returns.add(part.tool_call_id)
-                    elif part.part_kind == "retry-prompt":
-                        retry_prompts.add(part.tool_call_id)
-
-    # Identify orphaned tools (those without responses and not being retried)
-    for tool_call_id, tool_name in list(tool_calls.items()):
-        if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
-            # Import ModelRequest and ToolReturnPart lazily
-            model_request_cls, tool_return_part_cls, _ = get_model_messages()
-            messages.append(
-                model_request_cls(
-                    parts=[
-                        tool_return_part_cls(
-                            tool_name=tool_name,
-                            content=error_message,
-                            tool_call_id=tool_call_id,
-                            timestamp=datetime.now(timezone.utc),
-                            part_kind="tool-return",
-                        )
-                    ],
-                    kind="request",
-                )
-            )

tunacode/core/setup/config_wizard.py

@@ -6,6 +6,7 @@ and keep responsibilities focused.
 
 import json
 from pathlib import Path
+from typing import Dict, Optional
 
 from tunacode.constants import UI_COLORS
 from tunacode.exceptions import ConfigurationError
@@ -20,7 +21,7 @@ class ConfigWizard:
         self.state_manager = state_manager
         self.model_registry = model_registry
         self.config_file = config_file
-        self._wizard_selected_provider = None
+        self._wizard_selected_provider: Optional[Dict[str, str]] = None
 
     async def run_onboarding(self) -> None:
         """Run enhanced wizard-style onboarding process for new users."""

tunacode/core/state.py

@@ -52,6 +52,10 @@ class SessionState:
     input_sessions: InputSessions = field(default_factory=dict)
     current_task: Optional[Any] = None
     todos: list[TodoItem] = field(default_factory=list)
+    # CLAUDE_ANCHOR[react-scratchpad]: Session scratchpad for ReAct tooling
+    react_scratchpad: dict[str, Any] = field(default_factory=lambda: {"timeline": []})
+    react_forced_calls: int = 0
+    react_guidance: list[str] = field(default_factory=list)
     # Operation state tracking
     operation_cancelled: bool = False
     # Enhanced tracking for thoughts display
@@ -174,6 +178,17 @@ class StateManager:
     def clear_todos(self) -> None:
         self._session.todos = []
 
+    # React scratchpad helpers
+    def get_react_scratchpad(self) -> dict[str, Any]:
+        return self._session.react_scratchpad
+
+    def append_react_entry(self, entry: dict[str, Any]) -> None:
+        timeline = self._session.react_scratchpad.setdefault("timeline", [])
+        timeline.append(entry)
+
+    def clear_react_scratchpad(self) -> None:
+        self._session.react_scratchpad = {"timeline": []}
+
     def reset_session(self) -> None:
         """Reset the session to a fresh state."""
         self._session = SessionState()

tunacode/tools/prompts/react_prompt.xml

@@ -0,0 +1,23 @@
+<tool>
+  <description>
+    Record a ReAct-style think/observe timeline, retrieve it, or clear it for the current session.
+  </description>
+  <parameters>
+    <parameter name="action" required="true">
+      <type>string</type>
+      <description>One of think, observe, get, clear.</description>
+    </parameter>
+    <parameter name="thoughts" required="false">
+      <type>string</type>
+      <description>Reasoning text for think entries.</description>
+    </parameter>
+    <parameter name="next_action" required="false">
+      <type>string</type>
+      <description>Planned action to pair with think entries.</description>
+    </parameter>
+    <parameter name="result" required="false">
+      <type>string</type>
+      <description>Observation details for observe entries.</description>
+    </parameter>
+  </parameters>
+</tool>

tunacode/tools/react.py

@@ -0,0 +1,153 @@
+"""Lightweight ReAct-style scratchpad tool."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Literal
+
+import defusedxml.ElementTree as ET
+from pydantic_ai.exceptions import ModelRetry
+
+from tunacode.core.state import StateManager
+from tunacode.types import ToolResult, UILogger
+
+from .base import BaseTool
+
+
+# CLAUDE_ANCHOR[react-tool]: Minimal ReAct scratchpad tool surface
+class ReactTool(BaseTool):
+    """Minimal ReAct scratchpad for tracking think/observe steps."""
+
+    def __init__(self, state_manager: StateManager, ui_logger: UILogger | None = None):
+        super().__init__(ui_logger)
+        self.state_manager = state_manager
+
+    @property
+    def tool_name(self) -> str:
+        return "react"
+
+    async def _execute(
+        self,
+        action: Literal["think", "observe", "get", "clear"],
+        thoughts: str | None = None,
+        next_action: str | None = None,
+        result: str | None = None,
+    ) -> ToolResult:
+        scratchpad = self._ensure_scratchpad()
+
+        if action == "think":
+            if not thoughts:
+                raise ModelRetry("Provide thoughts when using react think action")
+            if not next_action:
+                raise ModelRetry("Specify next_action when recording react thoughts")
+
+            entry = {
+                "type": "think",
+                "thoughts": thoughts,
+                "next_action": next_action,
+            }
+            self.state_manager.append_react_entry(entry)
+            return "Recorded think step"
+
+        if action == "observe":
+            if not result:
+                raise ModelRetry("Provide result when using react observe action")
+
+            entry = {
+                "type": "observe",
+                "result": result,
+            }
+            self.state_manager.append_react_entry(entry)
+            return "Recorded observation"
+
+        if action == "get":
+            timeline = scratchpad.get("timeline", [])
+            if not timeline:
+                return "React scratchpad is empty"
+
+            formatted = [
+                f"{index + 1}. {item['type']}: {self._format_entry(item)}"
+                for index, item in enumerate(timeline)
+            ]
+            return "\n".join(formatted)
+
+        if action == "clear":
+            self.state_manager.clear_react_scratchpad()
+            return "React scratchpad cleared"
+
+        raise ModelRetry("Invalid react action. Use one of: think, observe, get, clear")
+
+    def _format_entry(self, item: Dict[str, Any]) -> str:
+        if item["type"] == "think":
+            return f"thoughts='{item['thoughts']}', next_action='{item['next_action']}'"
+        if item["type"] == "observe":
+            return f"result='{item['result']}'"
+        return str(item)
+
+    def _ensure_scratchpad(self) -> dict[str, Any]:
+        scratchpad = self.state_manager.get_react_scratchpad()
+        scratchpad.setdefault("timeline", [])
+        return scratchpad
+
+    def _get_base_prompt(self) -> str:
+        prompt_file = Path(__file__).parent / "prompts" / "react_prompt.xml"
+        if prompt_file.exists():
+            try:
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None and description.text:
+                    return description.text.strip()
+            except Exception:
+                pass
+        return "Use this tool to record think/observe notes and manage the react scratchpad"
+
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        prompt_file = Path(__file__).parent / "prompts" / "react_prompt.xml"
+        if prompt_file.exists():
+            try:
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                parameters = root.find("parameters")
+                if parameters is not None:
+                    schema: Dict[str, Any] = {
+                        "type": "object",
+                        "properties": {},
+                        "required": ["action"],
+                    }
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        param_type = param.find("type")
+                        description = param.find("description")
+                        if name and param_type is not None:
+                            schema["properties"][name] = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None and description.text
+                                else "",
+                            }
+                    return schema
+            except Exception:
+                pass
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "description": "react operation to perform",
+                },
+                "thoughts": {
+                    "type": "string",
+                    "description": "Thought content for think action",
+                },
+                "next_action": {
+                    "type": "string",
+                    "description": "Planned next action for think action",
+                },
+                "result": {
+                    "type": "string",
+                    "description": "Observation message for observe action",
+                },
+            },
+            "required": ["action"],
+        }