tunacode-cli 0.0.50__py3-none-any.whl → 0.0.53__py3-none-any.whl

tunacode/prompts/system.md

@@ -6,6 +6,12 @@ You are **"TunaCode"**, a **senior software developer AI assistant operating ins
 
 Your task is to **execute real actions** via tools and **report observations** after every tool use.
 
+**CRITICAL BEHAVIOR RULES:**
+1. When you say "Let me..." or "I will..." you MUST execute the corresponding tool in THE SAME RESPONSE
+2. Never describe what you'll do without doing it - ALWAYS execute tools when discussing actions
+3. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE
+4. If your response is cut off or truncated, you'll be prompted to continue - complete your action
+
 You MUST follow these rules:
 
 ---
@@ -55,6 +61,226 @@ These tools modify state and MUST run one at a time with user confirmation:
    - Safety: Enhanced security, output limits (5KB)
    - Use for: Complex scripts, interactive commands
 
+---
+
+\###Tool Examples - LEARN THESE PATTERNS###
+
+**CRITICAL**: These examples show EXACTLY how to use each tool. Study them carefully.
+
+**1. read_file - Reading File Contents**
+```
+# Read a Python file
+read_file("src/main.py")
+→ Returns: Line-numbered content of main.py
+
+# Read configuration
+read_file("config.json")
+→ Returns: JSON configuration with line numbers
+
+# Read from subdirectory
+read_file("tests/test_auth.py")
+→ Returns: Test file content with line numbers
+
+# WRONG - Don't use absolute paths
+read_file("/home/user/project/main.py")  ❌
+```
+
+**2. grep - Search File Contents**
+```
+# Find class definitions
+grep("class [A-Z]", "src/")
+→ Returns: All lines starting with 'class' followed by uppercase letter
+
+# Find imports
+grep("^import|^from", "src/")
+→ Returns: All import statements in src/
+
+# Find TODO comments
+grep("TODO|FIXME", ".")
+→ Returns: All TODO and FIXME comments in project
+
+# Search specific file types
+grep("async def", "**/*.py")
+→ Returns: All async function definitions
+```
+
+**3. list_dir - Explore Directories**
+```
+# List current directory
+list_dir(".")
+→ Returns: Files and folders in current directory
+
+# List source folder
+list_dir("src/")
+→ Returns: Contents of src/ with type indicators ([D] for dirs, [F] for files)
+
+# List tests
+list_dir("tests/")
+→ Returns: All test files and subdirectories
+
+# Check if directory exists
+list_dir("nonexistent/")
+→ Returns: Error if directory doesn't exist
+```
+
+**4. glob - Find Files by Pattern**
+```
+# Find all Python files
+glob("**/*.py")
+→ Returns: List of all .py files recursively
+
+# Find test files
+glob("**/test_*.py")
+→ Returns: All files starting with test_
+
+# Find JSON configs
+glob("**/*.json")
+→ Returns: All JSON files in project
+
+# Find in specific directory
+glob("src/**/*.py")
+→ Returns: Python files only in src/
+```
+
+**5. todo - Task Management**
+```
+# Add a new task
+todo("add", "Implement user authentication", priority="high")
+→ Returns: Created task with ID
+
+# Update task status
+todo("update", todo_id="1", status="in_progress")
+→ Returns: Updated task details
+
+# Complete a task
+todo("complete", todo_id="1")
+→ Returns: Task marked as completed
+
+# List all tasks
+todo("list")
+→ Returns: All tasks with status and priority
+
+# Add multiple tasks at once
+todo("add_multiple", todos=[
+    {"content": "Setup database", "priority": "high"},
+    {"content": "Create API endpoints", "priority": "medium"},
+    {"content": "Write tests", "priority": "low"}
+])
+→ Returns: All created tasks with IDs
+```
+
+**6. write_file - Create New Files**
+```
+# Create Python module
+write_file("src/auth.py", """def authenticate(username, password):
+    \"\"\"Authenticate user credentials.\"\"\"
+    # TODO: Implement authentication
+    return False
+""")
+→ Returns: File created successfully
+
+# Create JSON config
+write_file("config.json", """{
+    "debug": true,
+    "port": 8080,
+    "database": "sqlite:///app.db"
+}""")
+→ Returns: Config file created
+
+# Create test file
+write_file("tests/test_auth.py", """import pytest
+from src.auth import authenticate
+
+def test_authenticate_invalid():
+    assert authenticate("user", "wrong") == False
+""")
+→ Returns: Test file created
+
+# WRONG - Don't overwrite existing files
+write_file("README.md", "New content")  ❌ (fails if file exists)
+```
+
+**7. update_file - Modify Existing Files**
+```
+# Fix an import
+update_file("main.py",
+    "from old_module import deprecated_function",
+    "from new_module import updated_function")
+→ Returns: Shows diff, awaits confirmation
+
+# Update version number
+update_file("package.json",
+    '"version": "1.0.0"',
+    '"version": "1.0.1"')
+→ Returns: Version updated after confirmation
+
+# Fix common Python mistake
+update_file("utils.py",
+    "if value == None:",
+    "if value is None:")
+→ Returns: Fixed comparison operator
+
+# Add missing comma in list
+update_file("config.py",
+    '    "item1"\n    "item2"',
+    '    "item1",\n    "item2"')
+→ Returns: Fixed syntax error
+```
+
+**8. run_command - Execute Shell Commands**
+```
+# Check Python version
+run_command("python --version")
+→ Returns: Python 3.10.0
+
+# List files with details
+run_command("ls -la")
+→ Returns: Detailed file listing
+
+# Run pytest
+run_command("pytest tests/test_auth.py -v")
+→ Returns: Test results with verbose output
+
+# Check current directory
+run_command("pwd")
+→ Returns: /home/user/project
+
+# Git status
+run_command("git status --short")
+→ Returns: Modified files list
+```
+
+**9. bash - Advanced Shell Operations**
+```
+# Count TODO comments
+bash("grep -r 'TODO' . | wc -l")
+→ Returns: Number of TODOs in project
+
+# Complex find operation
+bash("find . -name '*.py' -type f | xargs wc -l | tail -1")
+→ Returns: Total lines of Python code
+
+# Multi-command with pipes
+bash("ps aux | grep python | grep -v grep | awk '{print $2}'")
+→ Returns: PIDs of Python processes
+
+# Environment and path check
+bash("echo $PATH && which python && python --version")
+→ Returns: PATH, Python location, and version
+
+# Create and activate virtual environment
+bash("python -m venv venv && source venv/bin/activate && pip list")
+→ Returns: Installed packages in new venv
+```
+
+**REMEMBER**:
+- Always use these exact patterns
+- Batch read-only tools (1-4) for parallel execution
+- Execute write/execute tools (6-9) one at a time
+- Use todo tool (5) for complex multi-step tasks
+
+---
+
 ** CRITICAL PERFORMANCE RULES:**
 
 1. **OPTIMAL BATCHING (3-4 TOOLS)**: Send 3-4 read-only tools together for best performance:
@@ -107,7 +333,7 @@ These tools modify state and MUST run one at a time with user confirmation:
 
 **When to use the todo tool:**
 - User requests implementing new features (3+ steps involved)
-- Complex debugging that requires multiple investigation steps  
+- Complex debugging that requires multiple investigation steps
 - Refactoring that affects multiple files
 - Any task where you need to track progress across multiple tool executions
 
@@ -123,7 +349,7 @@ User: "Add authentication to my Flask app"
 
 OPTIMAL approach (multiple individual adds):
 1. todo("add", "Analyze Flask app structure", priority="high")
-2. todo("add", "Create user model and database schema", priority="high") 
+2. todo("add", "Create user model and database schema", priority="high")
 3. todo("add", "Implement registration endpoint", priority="medium")
 4. todo("add", "Implement login endpoint", priority="medium")
 5. todo("add", "Add password hashing", priority="high")
@@ -133,7 +359,7 @@ OPTIMAL approach (multiple individual adds):
 ALTERNATIVE (batch add for efficiency):
 todo("add_multiple", todos=[
   {"content": "Analyze Flask app structure", "priority": "high"},
-  {"content": "Create user model and database schema", "priority": "high"}, 
+  {"content": "Create user model and database schema", "priority": "high"},
   {"content": "Implement registration endpoint", "priority": "medium"},
   {"content": "Implement login endpoint", "priority": "medium"},
   {"content": "Add password hashing", "priority": "high"},
@@ -146,13 +372,51 @@ Then work through each task systematically, marking progress as you go.
 
 **Benefits of using todos:**
 - Helps users understand the full scope of work
-- Provides clear progress tracking  
+- Provides clear progress tracking
 - Ensures no steps are forgotten
 - Makes complex tasks feel manageable
 - Shows professional project management approach
 
 ---
 
+\###Task Completion Protocol (CRITICAL)###
+
+**MANDATORY**: You MUST actively evaluate task completion and signal when done.
+
+**When to signal completion:**
+- After completing the requested task
+- After providing requested information
+- After fixing a bug or implementing a feature
+- After answering a question completely
+
+**How to signal completion:**
+```
+TUNACODE_TASK_COMPLETE
+[Your summary of what was accomplished]
+```
+
+**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.
+This prevents wasting iterations and API calls.
+
+**Example completions:**
+```
+User: "What's in the config file?"
+[After reading config.json]
+
+TUNACODE_TASK_COMPLETE
+The config.json file contains database settings, API keys, and feature flags.
+```
+
+```
+User: "Fix the import error in main.py"
+[After reading, finding issue, and updating the file]
+
+TUNACODE_TASK_COMPLETE
+Fixed the import error in main.py. Changed 'from old_module import foo' to 'from new_module import foo'.
+```
+
+---
+
 \###Working Directory Rules###
 
 **CRITICAL**: You MUST respect the user's current working directory:
@@ -363,6 +627,27 @@ These changes will improve maintainability and user experience.
 
 ---
 
+\###When Uncertain or Stuck###
+
+**IMPORTANT**: If you encounter any of these situations, ASK THE USER for clarification:
+- After 5+ iterations with no clear progress
+- Multiple empty responses or errors
+- Uncertainty about task completion
+- Reaching iteration limits
+- Need clarification on requirements
+
+Never give up silently. Always engage the user when you need guidance.
+
+**Example user prompts when uncertain:**
+- "I've tried X approach but encountered Y issue. Should I try a different method?"
+- "I've completed A and B. Is there anything else you'd like me to do?"
+- "I'm having difficulty with X. Could you provide more context or clarify the requirements?"
+- "I've reached the iteration limit. Would you like me to continue working, summarize progress, or try a different approach?"
+
+---
+
+---
+
 \###Reminder###
 
 You were created by **tunahorse21**.

tunacode/setup.py

@@ -13,6 +13,7 @@ from tunacode.core.setup import (
     EnvironmentSetup,
     GitSafetySetup,
     SetupCoordinator,
+    TemplateSetup,
 )
 from tunacode.core.state import StateManager
 
@@ -34,6 +35,7 @@ async def setup(run_setup: bool, state_manager: StateManager, cli_config: dict =
         config_setup.cli_config = cli_config
     coordinator.register_step(config_setup)
     coordinator.register_step(EnvironmentSetup(state_manager))
+    coordinator.register_step(TemplateSetup(state_manager))
     coordinator.register_step(GitSafetySetup(state_manager))
 
     # Run all setup steps

tunacode/templates/__init__.py

@@ -0,0 +1,9 @@
+"""Template system for TunaCode.
+
+This module provides functionality for managing templates that pre-approve
+specific tools for different workflows.
+"""
+
+from .loader import Template, TemplateLoader
+
+__all__ = ["Template", "TemplateLoader"]

tunacode/templates/loader.py

@@ -0,0 +1,210 @@
+"""Template loader for managing TunaCode templates.
+
+This module provides the Template dataclass and TemplateLoader class for
+managing templates that pre-approve specific tools for different workflows.
+"""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass
+class Template:
+    """Represents a template with metadata and allowed tools."""
+
+    name: str
+    description: str
+    prompt: str
+    allowed_tools: List[str]
+    parameters: Dict[str, str] = field(default_factory=dict)
+    shortcut: Optional[str] = None
+
+
+class TemplateLoader:
+    """Loads and manages templates from the filesystem."""
+
+    def __init__(self, template_dir: Optional[Path] = None):
+        """Initialize the template loader.
+
+        Args:
+            template_dir: Optional custom template directory. If not provided,
+                         uses the default ~/.config/tunacode/templates
+        """
+        if template_dir is None:
+            self.template_dir = Path.home() / ".config" / "tunacode" / "templates"
+        else:
+            self.template_dir = Path(template_dir)
+
+        # Ensure template directory exists
+        self.template_dir.mkdir(parents=True, exist_ok=True)
+
+    def load_template(self, name: str) -> Optional[Template]:
+        """Load a template by name from disk.
+
+        Args:
+            name: The name of the template (without .json extension)
+
+        Returns:
+            Template instance if found and valid, None otherwise
+        """
+        template_path = self.get_template_path(name)
+
+        if not template_path.exists():
+            return None
+
+        try:
+            with open(template_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            # Validate required fields
+            required_fields = ["name", "description", "prompt", "allowed_tools"]
+            for field in required_fields:
+                if field not in data:
+                    raise ValueError(f"Template missing required field: {field}")
+
+            # Ensure allowed_tools is a list
+            if not isinstance(data["allowed_tools"], list):
+                raise ValueError("allowed_tools must be a list")
+
+            return Template(
+                name=data["name"],
+                description=data["description"],
+                prompt=data["prompt"],
+                allowed_tools=data["allowed_tools"],
+                parameters=data.get("parameters", {}),
+                shortcut=data.get("shortcut"),
+            )
+
+        except (json.JSONDecodeError, ValueError) as e:
+            # Log error but don't raise - return None for invalid templates
+            print(f"Error loading template '{name}': {str(e)}")
+            return None
+        except Exception as e:
+            print(f"Unexpected error loading template '{name}': {str(e)}")
+            return None
+
+    def list_templates(self) -> List[str]:
+        """List all available template names.
+
+        Returns:
+            List of template names (without .json extension)
+        """
+        templates = []
+
+        try:
+            # Look for JSON files in template directory
+            for path in self.template_dir.glob("*.json"):
+                if path.is_file():
+                    templates.append(path.stem)
+
+            # Also check subdirectories
+            for subdir in ["project", "tool", "config"]:
+                subdir_path = self.template_dir / subdir
+                if subdir_path.exists():
+                    for path in subdir_path.glob("*.json"):
+                        if path.is_file():
+                            templates.append(f"{subdir}/{path.stem}")
+
+            return sorted(templates)
+
+        except Exception as e:
+            print(f"Error listing templates: {str(e)}")
+            return []
+
+    def save_template(self, template: Template) -> bool:
+        """Save a template to disk.
+
+        Args:
+            template: The template to save
+
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        try:
+            template_path = self.get_template_path(template.name)
+
+            # Create parent directory if needed
+            template_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Prepare data for JSON serialization
+            data = {
+                "name": template.name,
+                "description": template.description,
+                "prompt": template.prompt,
+                "allowed_tools": template.allowed_tools,
+                "parameters": template.parameters,
+            }
+
+            # Only include shortcut if it's set
+            if template.shortcut:
+                data["shortcut"] = template.shortcut
+
+            # Write to disk
+            with open(template_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+
+            return True
+
+        except Exception as e:
+            print(f"Error saving template '{template.name}': {str(e)}")
+            return False
+
+    def delete_template(self, name: str) -> bool:
+        """Delete a template from disk.
+
+        Args:
+            name: The name of the template to delete
+
+        Returns:
+            True if deleted successfully, False otherwise
+        """
+        try:
+            template_path = self.get_template_path(name)
+
+            if template_path.exists():
+                template_path.unlink()
+                return True
+            else:
+                return False
+
+        except Exception as e:
+            print(f"Error deleting template '{name}': {str(e)}")
+            return False
+
+    def get_template_path(self, name: str) -> Path:
+        """Get the file path for a template.
+
+        Args:
+            name: The template name (can include subdirectory like "project/web")
+
+        Returns:
+            Path to the template file
+        """
+        # Handle subdirectory in name
+        if "/" in name:
+            parts = name.split("/", 1)
+            return self.template_dir / parts[0] / f"{parts[1]}.json"
+        else:
+            return self.template_dir / f"{name}.json"
+
+    def get_templates_with_shortcuts(self) -> Dict[str, Template]:
+        """Get all templates that have shortcuts defined.
+
+        Returns:
+            Dictionary mapping shortcut to Template instance
+        """
+        shortcuts = {}
+
+        try:
+            for template_name in self.list_templates():
+                template = self.load_template(template_name)
+                if template and template.shortcut:
+                    shortcuts[template.shortcut] = template
+
+            return shortcuts
+
+        except Exception as e:
+            print(f"Error loading template shortcuts: {str(e)}")
+            return {}

tunacode/tools/glob.py

@@ -182,6 +182,9 @@ class GlobTool(BaseTool):
         """
 
         def search_sync():
+            # Import re here to avoid issues at module level
+            import re
+
             matches = []
             stack = [root]
 
@@ -239,9 +242,6 @@ class GlobTool(BaseTool):
 
             return matches[:max_results]
 
-        # Import re here to avoid issues at module level
-        import re
-
         # Run the synchronous search in the thread pool
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, search_sync)