tunacode-cli 0.0.76.1__py3-none-any.whl → 0.0.76.3__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/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"],
+        }

tunacode/ui/completers.py

@@ -11,6 +11,8 @@ from prompt_toolkit.completion import (
 )
 from prompt_toolkit.document import Document
 
+from ..utils.fuzzy_utils import find_fuzzy_matches
+
 if TYPE_CHECKING:
     from ..cli.commands import CommandRegistry
     from ..utils.models_registry import ModelInfo, ModelsRegistry
@@ -73,7 +75,12 @@ class FileReferenceCompleter(Completer):
     def get_completions(
         self, document: Document, _complete_event: CompleteEvent
     ) -> Iterable[Completion]:
-        """Get completions for @file references."""
+        """Get completions for @file references.
+
+        Favors file matches before directory matches and supports fuzzy
+        matching for near-miss filenames. Order:
+          exact files > fuzzy files > exact dirs > fuzzy dirs
+        """
         # Get the word before cursor
         word_before_cursor = document.get_word_before_cursor(WORD=True)
 
@@ -94,34 +101,75 @@ class FileReferenceCompleter(Completer):
             dir_path = "."
             prefix = path_part
 
-        # Get matching files
+        # If prefix itself is an existing directory (without trailing slash),
+        # treat it as browsing inside that directory
+        candidate_dir = os.path.join(dir_path, prefix) if dir_path != "." else prefix
+        if prefix and os.path.isdir(candidate_dir) and not path_part.endswith("/"):
+            dir_path = candidate_dir
+            prefix = ""
+
+        # Get matching files with fuzzy support
         try:
             if os.path.exists(dir_path) and os.path.isdir(dir_path):
-                for item in sorted(os.listdir(dir_path)):
-                    if item.startswith(prefix):
-                        full_path = os.path.join(dir_path, item) if dir_path != "." else item
-
-                        # Skip hidden files unless explicitly requested
-                        if item.startswith(".") and not prefix.startswith("."):
-                            continue
-
-                        # Add / for directories
-                        if os.path.isdir(full_path):
-                            display = item + "/"
-                            completion = full_path + "/"
-                        else:
-                            display = item
-                            completion = full_path
-
-                        # Calculate how much to replace
-                        start_position = -len(path_part)
-
-                        yield Completion(
-                            text=completion,
-                            start_position=start_position,
-                            display=display,
-                            display_meta="dir" if os.path.isdir(full_path) else "file",
-                        )
+                items = sorted(os.listdir(dir_path))
+
+                # Separate files vs dirs; skip hidden unless explicitly requested
+                show_hidden = prefix.startswith(".")
+                files: List[str] = []
+                dirs: List[str] = []
+                for item in items:
+                    if item.startswith(".") and not show_hidden:
+                        continue
+                    full_item_path = os.path.join(dir_path, item) if dir_path != "." else item
+                    if os.path.isdir(full_item_path):
+                        dirs.append(item)
+                    else:
+                        files.append(item)
+
+                # Exact prefix matches (case-insensitive)
+                prefix_lower = prefix.lower()
+                exact_files = [f for f in files if f.lower().startswith(prefix_lower)]
+                exact_dirs = [d for d in dirs if d.lower().startswith(prefix_lower)]
+
+                # Fuzzy matches (exclude items already matched exactly)
+                fuzzy_file_candidates = [f for f in files if f not in exact_files]
+                fuzzy_dir_candidates = [d for d in dirs if d not in exact_dirs]
+
+                fuzzy_files = (
+                    find_fuzzy_matches(prefix, fuzzy_file_candidates, n=10, cutoff=0.75)
+                    if prefix
+                    else []
+                )
+                fuzzy_dirs = (
+                    find_fuzzy_matches(prefix, fuzzy_dir_candidates, n=10, cutoff=0.75)
+                    if prefix
+                    else []
+                )
+
+                # Compose ordered results
+                ordered: List[tuple[str, str]] = (
+                    [("file", name) for name in exact_files]
+                    + [("file", name) for name in fuzzy_files]
+                    + [("dir", name) for name in exact_dirs]
+                    + [("dir", name) for name in fuzzy_dirs]
+                )
+
+                start_position = -len(path_part)
+                for kind, name in ordered:
+                    full_path = os.path.join(dir_path, name) if dir_path != "." else name
+                    if kind == "dir":
+                        display = name + "/"
+                        completion_text = full_path + "/"
+                    else:
+                        display = name
+                        completion_text = full_path
+
+                    yield Completion(
+                        text=completion_text,
+                        start_position=start_position,
+                        display=display,
+                        display_meta="dir" if kind == "dir" else "file",
+                    )
         except (OSError, PermissionError):
             # Silently ignore inaccessible directories
             pass

tunacode/utils/fuzzy_utils.py

@@ -0,0 +1,33 @@
+"""Shared fuzzy matching utilities.
+
+Minimal helper to provide consistent fuzzy matching behavior across
+components (commands, file completers, etc.) without introducing new
+dependencies. Reuses difflib.get_close_matches with a default cutoff of 0.75
+matching the command registry behavior.
+"""
+
+from difflib import get_close_matches
+from typing import List, Sequence
+
+
+def find_fuzzy_matches(
+    query: str,
+    choices: Sequence[str],
+    *,
+    n: int = 5,
+    cutoff: float = 0.75,
+) -> List[str]:
+    """Return up to ``n`` fuzzy matches from ``choices`` for ``query``.
+
+    The return order is the order produced by ``difflib.get_close_matches``.
+    Matching is case-insensitive; original casing is preserved in the result.
+    """
+    if not query or not choices:
+        return []
+
+    # Map lower-case to original to do case-insensitive matching while
+    # returning original items.
+    lower_to_original = {c.lower(): c for c in choices}
+    candidates = list(lower_to_original.keys())
+    matches_lower = get_close_matches(query.lower(), candidates, n=n, cutoff=cutoff)
+    return [lower_to_original[m] for m in matches_lower]