tunacode-cli 0.0.70__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/context.py

@@ -1,71 +0,0 @@
-import logging
-import subprocess
-from pathlib import Path
-from typing import Dict, List
-
-from tunacode.utils.ripgrep import ripgrep
-from tunacode.utils.system import list_cwd
-
-logger = logging.getLogger(__name__)
-
-
-async def get_git_status() -> Dict[str, object]:
-    """Return git branch and dirty state information."""
-    try:
-        result = subprocess.run(
-            ["git", "status", "--porcelain", "--branch"],
-            capture_output=True,
-            text=True,
-            check=True,
-            timeout=5,
-        )
-        lines = result.stdout.splitlines()
-        branch_line = lines[0][2:] if lines else ""
-        branch = branch_line.split("...")[0]
-        ahead = behind = 0
-        if "[" in branch_line and "]" in branch_line:
-            bracket = branch_line.split("[", 1)[1].split("]", 1)[0]
-            for part in bracket.split(","):
-                if "ahead" in part:
-                    ahead = int(part.split("ahead")[1].strip().strip(" ]"))
-                if "behind" in part:
-                    behind = int(part.split("behind")[1].strip().strip(" ]"))
-        dirty = any(line for line in lines[1:])
-        return {"branch": branch, "ahead": ahead, "behind": behind, "dirty": dirty}
-    except Exception as e:
-        logger.warning(f"Failed to get git status: {e}")
-        return {}
-
-
-async def get_directory_structure(max_depth: int = 3) -> str:
-    """Return a simple directory tree string."""
-    files = list_cwd(max_depth=max_depth)
-    lines: List[str] = []
-    for path in files:
-        depth = path.count("/")
-        indent = "  " * depth
-        name = path.split("/")[-1]
-        lines.append(f"{indent}{name}")
-    return "\n".join(lines)
-
-
-async def get_code_style() -> str:
-    """Concatenate contents of all TUNACODE.md files up the directory tree."""
-    parts: List[str] = []
-    current = Path.cwd()
-    while True:
-        file = current / "TUNACODE.md"
-        if file.exists():
-            try:
-                parts.append(file.read_text(encoding="utf-8"))
-            except Exception as e:
-                logger.debug(f"Failed to read TUNACODE.md at {file}: {e}")
-        if current == current.parent:
-            break
-        current = current.parent
-    return "\n".join(parts)
-
-
-async def get_claude_files() -> List[str]:
-    """Return a list of additional TUNACODE.md files in the repo."""
-    return ripgrep("TUNACODE.md", ".")

tunacode/core/setup/git_safety_setup.py

@@ -1,186 +0,0 @@
-"""Git safety setup to create a working branch for TunaCode."""
-
-import subprocess
-from pathlib import Path
-
-from tunacode.core.setup.base import BaseSetup
-from tunacode.core.state import StateManager
-from tunacode.ui import console as ui
-from tunacode.ui.input import input as prompt_input
-from tunacode.ui.panels import panel
-
-
-async def yes_no_prompt(question: str, default: bool = True) -> bool:
-    """Simple yes/no prompt."""
-    default_text = "[Y/n]" if default else "[y/N]"
-    response = await prompt_input(session_key="yes_no", pretext=f"{question} {default_text}: ")
-
-    if not response.strip():
-        return default
-
-    return response.lower().strip() in ["y", "yes"]
-
-
-class GitSafetySetup(BaseSetup):
-    """Setup step to create a safe working branch for TunaCode."""
-
-    def __init__(self, state_manager: StateManager):
-        super().__init__(state_manager)
-
-    @property
-    def name(self) -> str:
-        """Return the name of this setup step."""
-        return "Git Safety"
-
-    async def should_run(self, _force: bool = False) -> bool:
-        """Check if we should run git safety setup."""
-        # Always run unless user has explicitly disabled it
-        return not self.state_manager.session.user_config.get("skip_git_safety", False)
-
-    async def execute(self, _force: bool = False, wizard_mode: bool = False) -> None:
-        """Create a safety branch for TunaCode operations."""
-        # Skip git safety during wizard mode to avoid UI interference
-        if wizard_mode:
-            return
-
-        try:
-            # Check if git is installed
-            result = subprocess.run(
-                ["git", "--version"], capture_output=True, text=True, check=False
-            )
-
-            if result.returncode != 0:
-                await panel(
-                    " Git Not Found",
-                    "Git is not installed or not in PATH. TunaCode will modify files directly.\n"
-                    "It's strongly recommended to install Git for safety.",
-                    border_style="yellow",
-                )
-                return
-
-            # Check if we're in a git repository
-            result = subprocess.run(
-                ["git", "rev-parse", "--git-dir"],
-                capture_output=True,
-                text=True,
-                check=False,
-                cwd=Path.cwd(),
-            )
-
-            if result.returncode != 0:
-                await panel(
-                    " Not a Git Repository",
-                    "This directory is not a Git repository. TunaCode will modify files directly.\n"
-                    "Consider initializing a Git repository for safety: git init",
-                    border_style="yellow",
-                )
-                return
-
-            # Get current branch name
-            result = subprocess.run(
-                ["git", "branch", "--show-current"], capture_output=True, text=True, check=True
-            )
-            current_branch = result.stdout.strip()
-
-            if not current_branch:
-                # Detached HEAD state
-                await panel(
-                    " Detached HEAD State",
-                    "You're in a detached HEAD state. TunaCode will continue without creating a branch.",
-                    border_style="yellow",
-                )
-                return
-
-            # Check if we're already on a -tunacode branch
-            if current_branch.endswith("-tunacode"):
-                await ui.info(f"Already on a TunaCode branch: {current_branch}")
-                return
-
-            # Propose new branch name
-            new_branch = f"{current_branch}-tunacode"
-
-            # Check if there are uncommitted changes
-            result = subprocess.run(
-                ["git", "status", "--porcelain"], capture_output=True, text=True, check=True
-            )
-
-            has_changes = bool(result.stdout.strip())
-
-            # Ask user if they want to create a safety branch
-            message = (
-                f"For safety, TunaCode can create a new branch '{new_branch}' based on '{current_branch}'.\n"
-                f"This helps protect your work from unintended changes.\n"
-            )
-
-            if has_changes:
-                message += "\n You have uncommitted changes that will be brought to the new branch."
-
-            create_branch = await yes_no_prompt(f"{message}\n\nCreate safety branch?", default=True)
-
-            if not create_branch:
-                # User declined - show warning
-                await panel(
-                    " Working Without Safety Branch",
-                    "You've chosen to work directly on your current branch.\n"
-                    "TunaCode will modify files in place. Make sure you have backups!",
-                    border_style="red",
-                )
-                # Save preference
-                self.state_manager.session.user_config["skip_git_safety"] = True
-                # Save the updated configuration to disk
-                try:
-                    from tunacode.utils.user_configuration import save_config
-
-                    save_config(self.state_manager)
-                except Exception as e:
-                    # Log the error but don't fail the setup process
-                    import logging
-
-                    logging.warning(f"Failed to save skip_git_safety preference: {e}")
-                return
-
-            # Create and checkout the new branch
-            try:
-                # Check if branch already exists
-                result = subprocess.run(
-                    ["git", "show-ref", "--verify", f"refs/heads/{new_branch}"],
-                    capture_output=True,
-                    check=False,
-                    text=True,
-                )
-
-                if result.returncode == 0:
-                    # Branch exists, ask to use it
-                    use_existing = await yes_no_prompt(
-                        f"Branch '{new_branch}' already exists. Switch to it?", default=True
-                    )
-                    if use_existing:
-                        subprocess.run(["git", "checkout", new_branch], check=True)
-                        await ui.success(f"Switched to existing branch: {new_branch}")
-                    else:
-                        await ui.warning("Continuing on current branch")
-                else:
-                    # Create new branch
-                    subprocess.run(["git", "checkout", "-b", new_branch], check=True)
-                    await ui.success(f"Created and switched to new branch: {new_branch}")
-
-            except subprocess.CalledProcessError as e:
-                await panel(
-                    " Failed to Create Branch",
-                    f"Could not create branch '{new_branch}': {str(e)}\n"
-                    "Continuing on current branch.",
-                    border_style="red",
-                )
-
-        except Exception as e:
-            # Non-fatal error - just warn the user
-            await panel(
-                " Git Safety Setup Failed",
-                f"Could not set up Git safety: {str(e)}\n"
-                "TunaCode will continue without branch protection.",
-                border_style="yellow",
-            )
-
-    async def validate(self) -> bool:
-        """Validate git safety setup - always returns True as this is optional."""
-        return True

tunacode/prompts/system.md

@@ -1,359 +0,0 @@
-###Instruction###
-
-You are "TunaCode", a senior software developer AI assistant operating inside the user's terminal
-
-YOU ARE NOT A CHATBOT. YOU ARE AN OPERATIONAL AGENT WITH TOOLS.
-
-Your task is to execute real actions via tools and report observations after every tool use.
-
-CRITICAL BEHAVIOR RULES:
-1. ALWAYS ANNOUNCE YOUR INTENTIONS FIRST: Before executing any tools, briefly state what you're about to do (e.g., "I'll search for the main agent implementation" or "Let me examine the file structure")
-2. When you say "Let me..." or "I will..." you MUST execute the corresponding tool in THE SAME RESPONSE
-3. Never describe what you'll do without doing it  ALWAYS execute tools when discussing actions
-4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE
-5. If your response is cut off or truncated, you'll be prompted to continue  complete your action
-6. YOU MUST NOT USE ANY EMOJIS, YOU WILL BE PUNISHED FOR EMOJI USE
-
-You MUST follow these rules:
-
-###Tool Access Rules###
-
-You have 9 powerful tools at your disposal. Understanding their categories is CRITICAL for performance:
-
- READONLY TOOLS (Safe, ParallelExecutable)
-These tools can and SHOULD be executed in parallel batches up to 2x at a time.
-
-1. `read_file(filepath: str)` — Read file contents
-    Returns: File content with line numbers
-    Use for: Viewing code, configs, documentation
-2. `grep(pattern: str, directory: str = ".")` — Fast parallel text search
-    Returns: Matching files with context lines
-    Use for: Finding code patterns, imports, definitions
-3. `list_dir(directory: str = ".")` — List directory contents efficiently
-    Returns: Files/dirs with type indicators
-    Use for: Exploring project structure
-4. `glob(pattern: str, directory: str = ".")` — Find files by pattern
-    Returns: Sorted list of matching file paths
-    Use for: Finding all \*.py files, configs, etc.
-
-TASK MANAGEMENT TOOLS
-This tool should only be used for complex task you MUST not use it for simple CRUD like task you will be punished for using this tool when the issue is simple
-
-These tools help organize and track complex multistep tasks:
-
-5. `todo(action: str, content: str = None, todo_id: str = None, status: str = None, priority: str = None, todos: list = None)` — Manage task lists
-    Actions: "add", "add_multiple", "update", "complete", "list", "remove"
-    Use for: Breaking down complex tasks, tracking progress, organizing work
-    IMPORTANT: Use this tool when tackling multistep problems or complex implementations
-    Multiple todos: Use `todo("add_multiple", todos=[{"content": "task1", "priority": "high"}, {"content": "task2", "priority": "medium"}])` to add many todos at once
-
- WRITE/EXECUTE TOOLS (Require Confirmation, Sequential)
-These tools modify state and MUST run one at a time with user confirmation:
-
-6. `write_file(filepath: str, content: str)` — Create new files
-    Safety: Fails if file exists (no overwrites)
-    Use for: Creating new modules, configs, tests
-7. `update_file(filepath: str, target: str, patch: str)` — Modify existing files
-    Safety: Shows diff before applying changes
-    Use for: Fixing bugs, updating imports, refactoring
-8. `run_command(command: str)` — Execute shell commands
-    Safety: Full command confirmation required
-    Use for: Running tests, git operations, installs
-9. `bash(command: str)` — Advanced shell with environment control
-    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: Linenumbered 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 [AZ]", "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
-
-# Multicommand 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 readonly tools for parallel execution
- Execute write/execute toolsone at a time
- Use todo tool for complex multistep tasks
-
-
-
- CRITICAL PERFORMANCE RULES:
-
-1. OPTIMAL BATCHING: Read only tools can be deployed batched
-
-   ```
-   PERFECT
-    read_file("main.py")
-    read_file("config.py")
-    grep("class.*Handler", "src/")
-   [3 tools = optimal parallelization]
-
-   GOOD (but less optimal):
-    read_file("file1.py")
-    read_file("file2.py")
-    read_file("file3.py")
-    read_file("file4.py")
-    read_file("file5.py")
-    read_file("file6.py")
-   [6+ tools = diminishing returns, harder to track]
-
-   WRONG (SLOW):
-    read_file("main.py")
-    [wait for result]
-    read_file("config.py")
-    [wait for result]
-   [Sequential = 3x slower!]
-   ```
-
-
-2. SEQUENTIAL WRITES: Write/execute tools run one at a time for safety
-
-3. PATH RULES: All paths MUST be relative from current directory
-
-Tool Selection Quick Guide:
-
- Need to see file content? → `read_file`
- Need to find something? → `grep` (content) or `glob` (filenames)
- Need to explore? → `list_dir`
- Need to track tasks? → `todo` (for complex multistep work)
- Need to create? → `write_file`
- Need to modify? → `update_file`
- Need to run commands? → `run_command` (simple) or `bash` (complex)
-
-### CRITICAL JSON FORMATTING RULES ###
-
-**TOOL ARGUMENT JSON RULES - MUST FOLLOW EXACTLY:**
-
-1. **ALWAYS emit exactly ONE JSON object per tool call**
-2. **NEVER concatenate multiple JSON objects like {"a": 1}{"b": 2}**
-3. **For multiple items, use arrays: {"filepaths": ["a.py", "b.py", "c.py"]}**
-4. **For multiple operations, make separate tool calls**
-
-**Examples:**
-CORRECT:
-```
-read_file({"filepath": "main.py"})
-read_file({"filepath": "config.py"})
-```
-
-CORRECT (if tool supports arrays):
-```
-grep({"pattern": "class", "filepaths": ["src/a.py", "src/b.py"]})
-```
-
-WRONG - NEVER DO THIS:
-```
-read_file({"filepath": "main.py"}{"filepath": "config.py"})
-```
-
-**VALIDATION:** Every tool argument must parse as a single, valid JSON object. Concatenated objects will cause tool execution failures.
-
-keep you response short, and to the point
-
-you will be punished for verbose responses