tunacode-cli 0.0.56__py3-none-any.whl → 0.0.57__py3-none-any.whl

tunacode/tools/todo.py

@@ -4,10 +4,13 @@ This tool allows the AI agent to manage todo items during task execution.
 It provides functionality for creating, updating, and tracking tasks.
 """
 
+import logging
 import uuid
 from datetime import datetime
-from typing import List, Literal, Optional, Union
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Union
 
+import defusedxml.ElementTree as ET
 from pydantic_ai.exceptions import ModelRetry
 
 from tunacode.constants import (
@@ -21,10 +24,114 @@ from tunacode.types import TodoItem, ToolResult, UILogger
 
 from .base import BaseTool
 
+logger = logging.getLogger(__name__)
+
 
 class TodoTool(BaseTool):
     """Tool for managing todo items from the AI agent."""
 
+    def _get_base_prompt(self) -> str:
+        """Load and return the base prompt from XML file.
+
+        Returns:
+            str: The loaded prompt from XML or a default prompt
+        """
+        try:
+            # Load prompt from XML file
+            prompt_file = Path(__file__).parent / "prompts" / "todo_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None:
+                    return description.text.strip()
+        except Exception as e:
+            logger.warning(f"Failed to load XML prompt for todo: {e}")
+
+        # Fallback to default prompt
+        return """Use this tool to create and manage a structured task list"""
+
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for todo tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "todo_prompt.xml"
+            if prompt_file.exists():
+                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": []}
+                    required_fields: List[str] = []
+
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        required = param.get("required", "false").lower() == "true"
+                        param_type = param.find("type")
+                        description = param.find("description")
+
+                        if name and param_type is not None:
+                            prop = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None
+                                else "",
+                            }
+
+                            # Handle array types and nested objects
+                            if param_type.text.strip() == "array":
+                                items = param.find("items")
+                                if items is not None:
+                                    item_type = items.find("type")
+                                    if item_type is not None and item_type.text.strip() == "object":
+                                        # Handle object items
+                                        item_props = {}
+                                        item_properties = items.find("properties")
+                                        if item_properties is not None:
+                                            for item_prop in item_properties.findall("property"):
+                                                prop_name = item_prop.get("name")
+                                                prop_type_elem = item_prop.find("type")
+                                                if prop_name and prop_type_elem is not None:
+                                                    item_props[prop_name] = {
+                                                        "type": prop_type_elem.text.strip()
+                                                    }
+                                        prop["items"] = {"type": "object", "properties": item_props}
+                                    else:
+                                        prop["items"] = {"type": items.text.strip()}
+
+                            schema["properties"][name] = prop
+                            if required:
+                                required_fields.append(name)
+
+                    schema["required"] = required_fields
+                    return schema
+        except Exception as e:
+            logger.warning(f"Failed to load parameters from XML for todo: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "todos": {
+                    "type": "array",
+                    "description": "The updated todo list",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "content": {"type": "string"},
+                            "status": {"type": "string"},
+                        },
+                    },
+                },
+            },
+            "required": ["todos"],
+        }
+
     def __init__(self, state_manager, ui_logger: UILogger | None = None):
         """Initialize the todo tool.
 

tunacode/tools/update_file.py

@@ -5,14 +5,21 @@ File update tool for agent operations in the TunaCode application.
 Provides targeted file content modification with diff-based updates.
 """
 
+import logging
 import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List
 
+import defusedxml.ElementTree as ET
 from pydantic_ai.exceptions import ModelRetry
 
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class UpdateFileTool(FileBasedTool):
     """Tool for updating existing files by replacing text blocks."""
@@ -21,6 +28,93 @@ class UpdateFileTool(FileBasedTool):
     def tool_name(self) -> str:
         return "Update"
 
+    @lru_cache(maxsize=1)
+    def _get_base_prompt(self) -> str:
+        """Load and return the base prompt from XML file.
+
+        Returns:
+            str: The loaded prompt from XML or a default prompt
+        """
+        try:
+            # Load prompt from XML file
+            prompt_file = Path(__file__).parent / "prompts" / "update_file_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None:
+                    return description.text.strip()
+        except Exception as e:
+            logger.warning(f"Failed to load XML prompt for update_file: {e}")
+
+        # Fallback to default prompt
+        return """Performs exact string replacements in files"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for update_file tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "update_file_prompt.xml"
+            if prompt_file.exists():
+                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": []}
+                    required_fields: List[str] = []
+
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        required = param.get("required", "false").lower() == "true"
+                        param_type = param.find("type")
+                        description = param.find("description")
+
+                        if name and param_type is not None:
+                            prop = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None
+                                else "",
+                            }
+
+                            schema["properties"][name] = prop
+                            if required:
+                                required_fields.append(name)
+
+                    schema["required"] = required_fields
+                    return schema
+        except Exception as e:
+            logger.warning(f"Failed to load parameters from XML for update_file: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to modify",
+                },
+                "old_string": {
+                    "type": "string",
+                    "description": "The text to replace",
+                },
+                "new_string": {
+                    "type": "string",
+                    "description": "The text to replace it with",
+                },
+                "replace_all": {
+                    "type": "boolean",
+                    "description": "Replace all occurences of old_string",
+                },
+            },
+            "required": ["file_path", "old_string", "new_string"],
+        }
+
     async def _execute(self, filepath: str, target: str, patch: str) -> ToolResult:
         """Update an existing file by replacing a target text block with a patch.
 

tunacode/tools/write_file.py

@@ -5,14 +5,21 @@ File writing tool for agent operations in the TunaCode application.
 Provides safe file creation with conflict detection and encoding handling.
 """
 
+import logging
 import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List
 
+import defusedxml.ElementTree as ET
 from pydantic_ai.exceptions import ModelRetry
 
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class WriteFileTool(FileBasedTool):
     """Tool for writing content to new files."""
@@ -21,6 +28,85 @@ class WriteFileTool(FileBasedTool):
     def tool_name(self) -> str:
         return "Write"
 
+    @lru_cache(maxsize=1)
+    def _get_base_prompt(self) -> str:
+        """Load and return the base prompt from XML file.
+
+        Returns:
+            str: The loaded prompt from XML or a default prompt
+        """
+        try:
+            # Load prompt from XML file
+            prompt_file = Path(__file__).parent / "prompts" / "write_file_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None:
+                    return description.text.strip()
+        except Exception as e:
+            logger.warning(f"Failed to load XML prompt for write_file: {e}")
+
+        # Fallback to default prompt
+        return """Writes a file to the local filesystem"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for write_file tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "write_file_prompt.xml"
+            if prompt_file.exists():
+                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": []}
+                    required_fields: List[str] = []
+
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        required = param.get("required", "false").lower() == "true"
+                        param_type = param.find("type")
+                        description = param.find("description")
+
+                        if name and param_type is not None:
+                            prop = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None
+                                else "",
+                            }
+
+                            schema["properties"][name] = prop
+                            if required:
+                                required_fields.append(name)
+
+                    schema["required"] = required_fields
+                    return schema
+        except Exception as e:
+            logger.warning(f"Failed to load parameters from XML for write_file: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to write",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The content to write to the file",
+                },
+            },
+            "required": ["file_path", "content"],
+        }
+
     async def _execute(self, filepath: str, content: str) -> ToolResult:
         """Write content to a new file. Fails if the file already exists.
 

tunacode/types.py

@@ -7,6 +7,9 @@ used throughout the TunaCode codebase.
 
 from dataclasses import dataclass, field
 from datetime import datetime
+
+# Plan types will be defined below
+from enum import Enum
 from pathlib import Path
 from typing import (
     Any,
@@ -21,9 +24,6 @@ from typing import (
     Union,
 )
 
-# Plan types will be defined below
-from enum import Enum
-
 # Try to import pydantic-ai types if available
 try:
     from pydantic_ai import Agent
@@ -202,6 +202,7 @@ class SimpleResult:
 
 class PlanPhase(Enum):
     """Plan Mode phases."""
+
     PLANNING_RESEARCH = "research"
     PLANNING_DRAFT = "draft"
     PLAN_READY = "ready"
@@ -211,14 +212,14 @@ class PlanPhase(Enum):
 @dataclass
 class PlanDoc:
     """Structured plan document with all required sections."""
-    
+
     # Required sections
     title: str
     overview: str
     steps: List[str]
     files_to_modify: List[str]
     files_to_create: List[str]
-    
+
     # Optional but recommended sections
     risks: List[str] = field(default_factory=list)
     tests: List[str] = field(default_factory=list)
@@ -226,16 +227,16 @@ class PlanDoc:
     open_questions: List[str] = field(default_factory=list)
     success_criteria: List[str] = field(default_factory=list)
     references: List[str] = field(default_factory=list)
-    
+
     def validate(self) -> Tuple[bool, List[str]]:
         """
         Validate the plan document.
-        
+
         Returns:
             tuple: (is_valid, list_of_missing_sections)
         """
         missing = []
-        
+
         # Check required fields
         if not self.title or not self.title.strip():
             missing.append("title")
@@ -245,7 +246,7 @@ class PlanDoc:
             missing.append("steps")
         if not self.files_to_modify and not self.files_to_create:
             missing.append("files_to_modify or files_to_create")
-            
+
         return len(missing) == 0, missing
 
 

tunacode/ui/input.py

@@ -79,6 +79,7 @@ async def multiline_input(
 
     # Clear any residual terminal output
     import sys
+
     sys.stdout.flush()
 
     # Full placeholder with all keyboard shortcuts

tunacode/ui/keybindings.py

@@ -47,6 +47,7 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
         # Trigger the same behavior as Ctrl+C by sending the signal
         import os
         import signal
+
         os.kill(os.getpid(), signal.SIGINT)
 
     @kb.add("s-tab")  # shift+tab

tunacode/ui/panels.py

@@ -100,7 +100,7 @@ class StreamingAgentPanel:
         self._last_update_time = 0.0
         self._dots_task = None
         self._dots_count = 0
-        self._show_dots = False
+        self._show_dots = True  # Start with dots enabled for "Thinking..."
 
     def _create_panel(self) -> Padding:
         """Create a Rich panel with current content."""
@@ -111,7 +111,15 @@ class StreamingAgentPanel:
 
         # Show "Thinking..." only when no content has arrived yet
         if not self.content:
-            content_renderable: Union[Text, Markdown] = Text.from_markup(UI_THINKING_MESSAGE)
+            # Apply dots animation to "Thinking..." message too
+            thinking_msg = UI_THINKING_MESSAGE
+            if self._show_dots:
+                # Remove the existing ... from the message and add animated dots
+                base_msg = thinking_msg.replace("...", "")
+                dots_patterns = ["", ".", "..", "..."]
+                dots = dots_patterns[self._dots_count % len(dots_patterns)]
+                thinking_msg = base_msg + dots
+            content_renderable: Union[Text, Markdown] = Text.from_markup(thinking_msg)
         else:
             # Once we have content, show it with optional dots animation
             display_content = self.content
@@ -143,17 +151,21 @@ class StreamingAgentPanel:
     async def _animate_dots(self):
         """Animate dots after a pause in streaming."""
         while True:
-            await asyncio.sleep(0.5)
+            await asyncio.sleep(0.2)  # Faster animation cycle
             current_time = time.time()
-            # Only show dots after 1 second of no updates
-            if current_time - self._last_update_time > 1.0:
+            # Use shorter delay for initial "Thinking..." phase
+            delay_threshold = 0.3 if not self.content else 1.0
+            # Show dots after the delay threshold
+            if current_time - self._last_update_time > delay_threshold:
                 self._show_dots = True
                 self._dots_count += 1
                 if self.live:
                     self.live.update(self._create_panel())
             else:
-                self._show_dots = False
-                self._dots_count = 0
+                # Only reset if we have content (keep dots for initial "Thinking...")
+                if self.content:
+                    self._show_dots = False
+                    self._dots_count = 0
 
     async def start(self):
         """Start the live streaming display."""
@@ -161,7 +173,11 @@ class StreamingAgentPanel:
 
         self.live = Live(self._create_panel(), console=console, refresh_per_second=4)
         self.live.start()
-        self._last_update_time = time.time()
+        # For "Thinking...", set time in past to trigger dots immediately
+        if not self.content:
+            self._last_update_time = time.time() - 0.4  # Triggers dots on first cycle
+        else:
+            self._last_update_time = time.time()
         # Start the dots animation task
         self._dots_task = asyncio.create_task(self._animate_dots())
 
@@ -170,18 +186,21 @@ class StreamingAgentPanel:
         # Defensive: some providers may yield None chunks intermittently
         if content_chunk is None:
             content_chunk = ""
-            
+
         # Filter out plan mode system prompts and tool definitions from streaming
-        if any(phrase in str(content_chunk) for phrase in [
-            "🔧 PLAN MODE",
-            "TOOL EXECUTION ONLY",
-            "planning assistant that ONLY communicates",
-            "namespace functions {",
-            "namespace multi_tool_use {",
-            "You are trained on data up to"
-        ]):
+        if any(
+            phrase in str(content_chunk)
+            for phrase in [
+                "🔧 PLAN MODE",
+                "TOOL EXECUTION ONLY",
+                "planning assistant that ONLY communicates",
+                "namespace functions {",
+                "namespace multi_tool_use {",
+                "You are trained on data up to",
+            ]
+        ):
             return
-            
+
         # Ensure type safety for concatenation
         self.content = (self.content or "") + str(content_chunk)
 
@@ -195,16 +214,19 @@ class StreamingAgentPanel:
     async def set_content(self, content: str):
         """Set the complete content (overwrites previous)."""
         # Filter out plan mode system prompts and tool definitions
-        if any(phrase in str(content) for phrase in [
-            "🔧 PLAN MODE",
-            "TOOL EXECUTION ONLY",
-            "planning assistant that ONLY communicates",
-            "namespace functions {",
-            "namespace multi_tool_use {",
-            "You are trained on data up to"
-        ]):
+        if any(
+            phrase in str(content)
+            for phrase in [
+                "🔧 PLAN MODE",
+                "TOOL EXECUTION ONLY",
+                "planning assistant that ONLY communicates",
+                "namespace functions {",
+                "namespace multi_tool_use {",
+                "You are trained on data up to",
+            ]
+        ):
             return
-            
+
         self.content = content
         if self.live:
             self.live.update(self._create_panel())

tunacode/ui/prompt_manager.py

@@ -106,13 +106,19 @@ class PromptManager:
             base_prompt = prompt
 
             # Add Plan Mode indicator if active
-            if (self.state_manager and
-                self.state_manager.is_plan_mode() and
-                "PLAN MODE ON" not in base_prompt):
-                base_prompt = '<style fg="#40E0D0"><bold>⏸  PLAN MODE ON</bold></style>\n' + base_prompt
-            elif (self.state_manager and
-                  not self.state_manager.is_plan_mode() and
-                  ("⏸" in base_prompt or "PLAN MODE ON" in base_prompt)):
+            if (
+                self.state_manager
+                and self.state_manager.is_plan_mode()
+                and "PLAN MODE ON" not in base_prompt
+            ):
+                base_prompt = (
+                    '<style fg="#40E0D0"><bold>⏸  PLAN MODE ON</bold></style>\n' + base_prompt
+                )
+            elif (
+                self.state_manager
+                and not self.state_manager.is_plan_mode()
+                and ("⏸" in base_prompt or "PLAN MODE ON" in base_prompt)
+            ):
                 # Remove plan mode indicator if no longer in plan mode
                 lines = base_prompt.split("\n")
                 if len(lines) > 1 and ("⏸" in lines[0] or "PLAN MODE ON" in lines[0]):