tunacode-cli 0.0.55__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,
@@ -192,6 +195,61 @@ class SimpleResult:
     output: str
 
 
+# =============================================================================
+# Plan Types
+# =============================================================================
+
+
+class PlanPhase(Enum):
+    """Plan Mode phases."""
+
+    PLANNING_RESEARCH = "research"
+    PLANNING_DRAFT = "draft"
+    PLAN_READY = "ready"
+    REVIEW_DECISION = "review"
+
+
+@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)
+    rollback: Optional[str] = None
+    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")
+        if not self.overview or not self.overview.strip():
+            missing.append("overview")
+        if not self.steps:
+            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
+
+
 # =============================================================================
 # Session and State Types
 # =============================================================================

tunacode/ui/input.py

@@ -76,19 +76,29 @@ async def multiline_input(
 ) -> str:
     """Get multiline input from the user with @file completion and highlighting."""
     kb = create_key_bindings(state_manager)
+
+    # Clear any residual terminal output
+    import sys
+
+    sys.stdout.flush()
+
+    # Full placeholder with all keyboard shortcuts
     placeholder = formatted_text(
         (
             "<darkgrey>"
             "<bold>Enter</bold> to submit • "
             "<bold>Esc + Enter</bold> for new line • "
             "<bold>Esc twice</bold> to cancel • "
+            "<bold>Shift + Tab</bold> toggle plan mode • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )
     )
-    return await input(
+
+    # Display input area (Plan Mode indicator is handled dynamically in prompt manager)
+    result = await input(
         "multiline",
-        pretext="> ",  # Default prompt
+        pretext="> ",
         key_bindings=kb,
         multiline=True,
         placeholder=placeholder,
@@ -96,3 +106,5 @@ async def multiline_input(
         lexer=FileReferenceLexer(),
         state_manager=state_manager,
     )
+
+    return result

tunacode/ui/keybindings.py

@@ -30,8 +30,8 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
 
     @kb.add("escape")
     def _escape(event):
-        """Handle ESC key - raises KeyboardInterrupt for unified abort handling."""
-        logger.debug("ESC key pressed - raising KeyboardInterrupt")
+        """Handle ESC key - trigger Ctrl+C behavior."""
+        logger.debug("ESC key pressed - simulating Ctrl+C")
 
         # Cancel any active task if present
         if state_manager and hasattr(state_manager.session, "current_task"):
@@ -44,7 +44,28 @@ def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
                 except Exception as e:
                     logger.debug(f"Failed to cancel task: {e}")
 
-        # Raise KeyboardInterrupt to trigger unified abort handling in REPL
-        raise KeyboardInterrupt()
+        # 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
+    def _toggle_plan_mode(event):
+        """Toggle between Plan Mode and normal mode."""
+        if state_manager:
+            # Toggle the state
+            if state_manager.is_plan_mode():
+                state_manager.exit_plan_mode()
+                logger.debug("Toggled to normal mode via Shift+Tab")
+            else:
+                state_manager.enter_plan_mode()
+                logger.debug("Toggled to Plan Mode via Shift+Tab")
+
+            # Clear the current buffer and refresh the display
+            event.current_buffer.reset()
+
+            # Force a refresh of the application without exiting
+            event.app.invalidate()
 
     return kb

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,6 +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",
+            ]
+        ):
+            return
+
         # Ensure type safety for concatenation
         self.content = (self.content or "") + str(content_chunk)
 
@@ -182,6 +213,20 @@ 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",
+            ]
+        ):
+            return
+
         self.content = content
         if self.live:
             self.live.update(self._create_panel())

tunacode/ui/prompt_manager.py

@@ -100,15 +100,38 @@ class PromptManager:
         """
         session = self.get_session(session_key, config)
 
-        # Create a custom prompt that changes based on input
+        # Create a custom prompt that changes based on input and plan mode
         def get_prompt():
+            # Start with the base prompt
+            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)
+            ):
+                # 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]):
+                    base_prompt = "\n".join(lines[1:])
+
             # Check if current buffer starts with "!"
             if hasattr(session.app, "current_buffer") and session.app.current_buffer:
                 text = session.app.current_buffer.text
                 if text.startswith("!"):
                     # Use bright yellow background with black text for high visibility
                     return HTML('<style bg="#ffcc00" fg="black"><b> ◆ BASH MODE ◆ </b></style> ')
-            return HTML(prompt) if isinstance(prompt, str) else prompt
+
+            return HTML(base_prompt) if isinstance(base_prompt, str) else base_prompt
 
         try:
             # Get user input with dynamic prompt

tunacode/ui/tool_ui.py

@@ -76,8 +76,9 @@ class ToolUI:
 
         # Show file content on write_file
         elif tool_name == TOOL_WRITE_FILE:
-            markdown_obj = self._create_code_block(args["filepath"], args["content"])
-            return str(markdown_obj)
+            lang = ext_to_lang(args["filepath"])
+            code_block = f"```{lang}\n{args['content']}\n```"
+            return code_block
 
         # Default to showing key and value on new line
         content = ""