tunacode-cli 0.1.21__py3-none-any.whl

tunacode/tools/grep_components/pattern_matcher.py

@@ -0,0 +1,158 @@
+"""
+Pattern matching functionality for the grep tool.
+"""
+
+import re
+from pathlib import Path
+from typing import Protocol
+
+from .search_result import SearchConfig, SearchResult
+
+
+class MatchLike(Protocol):
+    def start(self) -> int: ...
+
+    def end(self) -> int: ...
+
+
+class SimpleMatch:
+    """Simple match object for non-regex searches."""
+
+    def __init__(self, start_pos: int, end_pos: int):
+        self._start = start_pos
+        self._end = end_pos
+
+    def start(self) -> int:
+        return self._start
+
+    def end(self) -> int:
+        return self._end
+
+
+class PatternMatcher:
+    """Handles pattern matching and relevance scoring for search results."""
+
+    @staticmethod
+    def search_file(
+        file_path: Path,
+        pattern: str,
+        regex_pattern: re.Pattern | None,
+        config: SearchConfig,
+    ) -> list[SearchResult]:
+        """Search a single file for the pattern."""
+        try:
+            with file_path.open("r", encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+
+            results: list[SearchResult] = []
+            for i, line in enumerate(lines):
+                line = line.rstrip("\n\r")
+
+                # Search for pattern
+                if regex_pattern:
+                    matches: list[MatchLike] = list(regex_pattern.finditer(line))
+                else:
+                    # Simple string search
+                    search_line = line if config.case_sensitive else line.lower()
+                    search_pattern = pattern if config.case_sensitive else pattern.lower()
+
+                    matches = []
+                    start = 0
+                    while True:
+                        pos = search_line.find(search_pattern, start)
+                        if pos == -1:
+                            break
+
+                        match = SimpleMatch(pos, pos + len(search_pattern))
+                        matches.append(match)
+                        start = pos + 1
+
+                # Create results for each match
+                for match in matches:
+                    # Get context lines
+                    context_start = max(0, i - config.context_lines)
+                    context_end = min(len(lines), i + config.context_lines + 1)
+
+                    context_before = [lines[j].rstrip("\n\r") for j in range(context_start, i)]
+                    context_after = [lines[j].rstrip("\n\r") for j in range(i + 1, context_end)]
+
+                    # Calculate relevance score
+                    relevance = PatternMatcher.calculate_relevance(
+                        str(file_path), line, pattern, match
+                    )
+
+                    result = SearchResult(
+                        file_path=str(file_path),
+                        line_number=i + 1,
+                        line_content=line,
+                        match_start=match.start(),
+                        match_end=match.end(),
+                        context_before=context_before,
+                        context_after=context_after,
+                        relevance_score=relevance,
+                    )
+                    results.append(result)
+
+            return results
+
+        except Exception:
+            return []
+
+    @staticmethod
+    def calculate_relevance(file_path: str, line: str, pattern: str, match: MatchLike) -> float:
+        """Calculate relevance score for a search result."""
+        score = 0.0
+
+        # Base score
+        score += 1.0
+
+        # Boost for exact matches
+        if pattern.lower() in line.lower():
+            score += 0.5
+
+        # Boost for matches at word boundaries
+        if match.start() == 0 or not line[match.start() - 1].isalnum():
+            score += 0.3
+
+        # Boost for certain file types
+        if file_path.endswith((".py", ".js", ".ts", ".java", ".cpp", ".c")):
+            score += 0.2
+
+        # Boost for matches in comments or docstrings
+        stripped_line = line.strip()
+        if stripped_line.startswith(("#", "//", "/*", '"""', "'''")):
+            score += 0.1
+
+        return score
+
+    @staticmethod
+    def parse_ripgrep_output(output: str) -> list[SearchResult]:
+        """Parse ripgrep JSON output into SearchResult objects."""
+        import json
+
+        results = []
+        for line in output.strip().split("\n"):
+            if not line:
+                continue
+
+            try:
+                data = json.loads(line)
+                if data.get("type") != "match":
+                    continue
+
+                match_data = data["data"]
+                result = SearchResult(
+                    file_path=match_data["path"]["text"],
+                    line_number=match_data["line_number"],
+                    line_content=match_data["lines"]["text"].rstrip("\n\r"),
+                    match_start=match_data["submatches"][0]["start"],
+                    match_end=match_data["submatches"][0]["end"],
+                    context_before=[],  # Ripgrep context handling would go here
+                    context_after=[],
+                    relevance_score=1.0,
+                )
+                results.append(result)
+            except (json.JSONDecodeError, KeyError):
+                continue
+
+        return results

tunacode/tools/grep_components/result_formatter.py

@@ -0,0 +1,87 @@
+"""
+Extended result formatter with multiple output modes for flexible presentation.
+Result formatting functionality for the grep tool.
+"""
+
+from .search_result import SearchConfig, SearchResult
+
+
+class ResultFormatter:
+    """Handles formatting of search results for display with multiple output modes."""
+
+    @staticmethod
+    def format_results(
+        results: list[SearchResult],
+        pattern: str,
+        config: SearchConfig,
+        output_mode: str = "content",
+    ) -> str:
+        """Format search results for display.
+
+        Args:
+            results: List of search results
+            pattern: Search pattern
+            config: Search configuration
+            output_mode: Output format mode:
+                - "content": Show matching lines with context (default)
+                - "files_with_matches": Show only file paths
+                - "count": Show match counts per file
+                - "json": JSON format for programmatic use
+
+        Returns:
+            Formatted string based on output mode
+        """
+        if not results:
+            return f"No matches found for pattern: {pattern}"
+
+        if output_mode == "files_with_matches":
+            return ResultFormatter._format_files_only(results, pattern)
+        elif output_mode == "count":
+            return ResultFormatter._format_count(results, pattern)
+        elif output_mode == "json":
+            return ResultFormatter._format_json(results, pattern)
+        else:  # Default to "content"
+            return ResultFormatter._format_content(results, pattern, config)
+
+    @staticmethod
+    def _format_content(results: list[SearchResult], pattern: str, config: SearchConfig) -> str:
+        """Format results with content grouped by file."""
+        output = [f"Found {len(results)} matches"]
+
+        current_file = ""
+        for result in results:
+            if current_file != result.file_path:
+                if current_file:
+                    output.append("")
+                current_file = result.file_path
+                output.append(f"{result.file_path}:")
+
+            output.append(f"  {result.line_number}: {result.line_content}")
+
+        return "\n".join(output)
+
+    @staticmethod
+    def _format_files_only(results: list[SearchResult], pattern: str) -> str:
+        """Format results showing only file paths."""
+        files = sorted(set(r.file_path for r in results))
+        return "\n".join(files)
+
+    @staticmethod
+    def _format_count(results: list[SearchResult], pattern: str) -> str:
+        """Format results showing match counts per file."""
+        file_counts: dict[str, int] = {}
+        for result in results:
+            file_counts[result.file_path] = file_counts.get(result.file_path, 0) + 1
+
+        sorted_counts = sorted(file_counts.items(), key=lambda x: (-x[1], x[0]))
+        return "\n".join(f"{count} {path}" for path, count in sorted_counts)
+
+    @staticmethod
+    def _format_json(results: list[SearchResult], pattern: str) -> str:
+        """Format results as JSON."""
+        import json
+
+        json_results = [
+            {"file": r.file_path, "line": r.line_number, "content": r.line_content} for r in results
+        ]
+        return json.dumps(json_results)

tunacode/tools/grep_components/search_result.py

@@ -0,0 +1,34 @@
+"""
+Search result and configuration data structures for the grep tool.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchResult:
+    """Represents a single search match with context."""
+
+    file_path: str
+    line_number: int
+    line_content: str
+    match_start: int
+    match_end: int
+    context_before: list[str]
+    context_after: list[str]
+    relevance_score: float = 0.0
+
+
+@dataclass
+class SearchConfig:
+    """Configuration for search operations."""
+
+    case_sensitive: bool = False
+    use_regex: bool = False
+    max_results: int = 50
+    context_lines: int = 2
+    include_patterns: list[str] | None = None
+    exclude_patterns: list[str] | None = None
+    max_file_size: int = 1024 * 1024  # 1MB
+    timeout_seconds: int = 30
+    first_match_deadline: float = 3.0  # Timeout for finding first match

tunacode/tools/list_dir.py

@@ -0,0 +1,205 @@
+"""Directory listing tool with recursive tree view for agent operations."""
+
+import asyncio
+import os
+from pathlib import Path
+
+from tunacode.tools.decorators import base_tool
+
+IGNORE_PATTERNS = [
+    "node_modules/",
+    "__pycache__/",
+    ".git/",
+    "dist/",
+    "build/",
+    "target/",
+    "vendor/",
+    "bin/",
+    "obj/",
+    ".idea/",
+    ".vscode/",
+    ".zig-cache/",
+    "zig-out/",
+    ".coverage/",
+    "coverage/",
+    "tmp/",
+    "temp/",
+    ".cache/",
+    "cache/",
+    "logs/",
+    ".venv/",
+    "venv/",
+    "env/",
+    ".ruff_cache/",
+    ".pytest_cache/",
+    ".mypy_cache/",
+    "*.egg-info/",
+    ".eggs/",
+]
+
+IGNORE_PATTERNS_COUNT = len(IGNORE_PATTERNS)
+
+LIMIT = 100
+
+
+def _should_ignore(path: str, ignore_patterns: list[str]) -> bool:
+    """Check if path matches any ignore pattern."""
+    for pattern in ignore_patterns:
+        if pattern.endswith("/"):
+            # Directory pattern
+            dir_name = pattern.rstrip("/")
+            if f"/{dir_name}/" in f"/{path}/" or path.startswith(f"{dir_name}/"):
+                return True
+        elif "*" in pattern:
+            # Glob pattern (simple suffix match)
+            suffix = pattern.replace("*", "")
+            if path.endswith(suffix):
+                return True
+    return False
+
+
+def _collect_files(
+    root: Path,
+    max_files: int,
+    show_hidden: bool,
+    ignore_patterns: list[str],
+) -> list[str]:
+    """Recursively collect files up to limit, respecting ignore patterns."""
+    files: list[str] = []
+    root_str = str(root)
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        rel_dir = os.path.relpath(dirpath, root_str)
+        if rel_dir == ".":
+            rel_dir = ""
+
+        # Filter directories in-place to prevent descending into ignored dirs
+        dirnames[:] = [
+            d
+            for d in dirnames
+            if (show_hidden or not d.startswith("."))
+            and not _should_ignore(f"{rel_dir}/{d}".lstrip("/") + "/", ignore_patterns)
+        ]
+        dirnames.sort()
+
+        # Collect files
+        for filename in sorted(filenames):
+            if not show_hidden and filename.startswith("."):
+                continue
+
+            rel_path = f"{rel_dir}/{filename}".lstrip("/") if rel_dir else filename
+            if _should_ignore(rel_path, ignore_patterns):
+                continue
+
+            files.append(rel_path)
+            if len(files) >= max_files:
+                return files
+
+    return files
+
+
+TREE_BRANCH = "├── "
+TREE_LAST = "└── "
+TREE_PIPE = "│   "
+TREE_SPACE = "    "
+
+
+def _render_tree(base_name: str, files: list[str]) -> tuple[str, int, int]:
+    """Build tree structure with connectors from file list.
+
+    Returns: (tree_output, file_count, dir_count)
+    """
+    dirs: set[str] = set()
+    files_by_dir: dict[str, list[str]] = {}
+
+    for file in files:
+        dir_path = os.path.dirname(file)
+        parts = dir_path.split("/") if dir_path else []
+
+        for i in range(len(parts) + 1):
+            parent = "/".join(parts[:i]) if i > 0 else "."
+            dirs.add(parent)
+
+        key = dir_path if dir_path else "."
+        if key not in files_by_dir:
+            files_by_dir[key] = []
+        files_by_dir[key].append(os.path.basename(file))
+
+    file_count = len(files)
+    dir_count = len(dirs) - 1  # exclude root "."
+
+    def render_dir(dir_path: str, prefix: str) -> str:
+        output = ""
+        parent_match = "" if dir_path == "." else dir_path
+        child_dirs = sorted(d for d in dirs if d != dir_path and os.path.dirname(d) == parent_match)
+        child_files = sorted(files_by_dir.get(dir_path, []))
+
+        items: list[tuple[str, bool]] = []  # (name, is_dir)
+        for d in child_dirs:
+            items.append((os.path.basename(d), True))
+        for f in child_files:
+            items.append((f, False))
+
+        for i, (name, is_dir) in enumerate(items):
+            is_last = i == len(items) - 1
+            connector = TREE_LAST if is_last else TREE_BRANCH
+            child_prefix = prefix + (TREE_SPACE if is_last else TREE_PIPE)
+
+            if is_dir:
+                full_path = f"{parent_match}/{name}".lstrip("/") if parent_match else name
+                output += f"{prefix}{connector}{name}/\n"
+                output += render_dir(full_path, child_prefix)
+            else:
+                output += f"{prefix}{connector}{name}\n"
+
+        return output
+
+    return f"{base_name}/\n" + render_dir(".", ""), file_count, dir_count
+
+
+@base_tool
+async def list_dir(
+    directory: str = ".",
+    max_files: int = LIMIT,
+    show_hidden: bool = False,
+    ignore: list[str] | None = None,
+) -> str:
+    """List directory contents as a recursive tree.
+
+    Args:
+        directory: The path to the directory to list (defaults to current directory).
+        max_files: Maximum number of files to return (default: 100).
+        show_hidden: Whether to include hidden files/directories (default: False).
+        ignore: Additional glob patterns to ignore (default: None).
+
+    Returns:
+        Compact tree view of directory contents.
+    """
+    dir_path = Path(directory).resolve()
+
+    if not dir_path.exists():
+        raise FileNotFoundError(f"Directory not found: {dir_path}")
+
+    if not dir_path.is_dir():
+        raise NotADirectoryError(f"Not a directory: {dir_path}")
+
+    # Combine default and custom ignore patterns
+    ignore_patterns = list(IGNORE_PATTERNS)
+    if ignore:
+        ignore_patterns.extend(ignore)
+
+    # Collect files in background thread
+    files = await asyncio.to_thread(
+        _collect_files, dir_path, max_files, show_hidden, ignore_patterns
+    )
+
+    if not files:
+        return f"{dir_path.name}/\n0 files  0 dirs"
+
+    tree_output, file_count, dir_count = _render_tree(dir_path.name, files)
+    summary = f"{file_count} files  {dir_count} dirs"
+
+    if len(files) >= max_files:
+        summary += " (truncated)"
+
+    return f"{summary}\n{tree_output}"

tunacode/tools/prompts/bash_prompt.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Execute bash commands. Use for git, npm, docker, and system operations.
+- Quote paths with spaces: cd "/path with spaces"
+- Chain commands with &amp;&amp; or ;
+- Prefer Grep/Glob/Read tools over grep/find/cat commands
+- Optional timeout in milliseconds (default 120000, max 600000)
+    </description>
+</tool_prompt>

tunacode/tools/prompts/glob_prompt.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Fast file pattern matching. Supports glob patterns like "**/*.py" or "src/**/*.ts".
+Returns matching file paths sorted by modification time.
+    </description>
+</tool_prompt>

tunacode/tools/prompts/grep_prompt.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Fast content search using ripgrep. Supports regex patterns.
+- Use output_mode "files_with_matches" for file paths only (most efficient)
+- Use output_mode "content" for matching lines
+- Use output_mode "count" for match counts per file
+- Filter with glob parameter (e.g., "*.py")
+    </description>
+</tool_prompt>

tunacode/tools/prompts/list_dir_prompt.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+List files and directories. Requires absolute path.
+Prefer Glob/Grep when you know what to search for.
+    </description>
+</tool_prompt>

tunacode/tools/prompts/read_file_prompt.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Read file contents. Requires absolute filepath.
+- Reads up to 2000 lines by default
+- Use offset/limit for large files
+- Can read images and PDFs
+    </description>
+</tool_prompt>

tunacode/tools/prompts/todoclear_prompt.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Clear the current todo list.
+
+Use this tool when:
+- Starting a new, unrelated task set
+- All tasks are completed and you want a clean slate
+
+Returns a confirmation message when the list is cleared.
+    </description>
+</tool_prompt>

tunacode/tools/prompts/todoread_prompt.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Read the current todo list to check task status and progress.
+
+Use this tool to:
+- Review current task state before starting work
+- Check which tasks are pending, in progress, or completed
+- Verify task completion status
+
+Returns formatted list with status indicators:
+- [ ] pending
+- [>] in_progress
+- [x] completed
+    </description>
+</tool_prompt>

tunacode/tools/prompts/todowrite_prompt.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Create or update the task list for tracking progress during complex operations.
+
+When to use:
+- Complex multi-step tasks (3+ steps)
+- User provides multiple tasks (numbered or comma-separated)
+- After receiving new instructions to capture requirements
+- When starting work on a task (mark as in_progress)
+- After completing a task (mark as completed)
+
+When NOT to use:
+- Single, straightforward tasks
+- Trivial tasks under 3 steps
+- Purely conversational or informational requests
+
+Schema:
+- content: Task description in imperative form (e.g., "Fix the bug")
+- status: "pending" | "in_progress" | "completed"
+- activeForm: Present continuous form (e.g., "Fixing the bug")
+
+Rules:
+- Only ONE task should be in_progress at a time
+- Mark tasks completed IMMEDIATELY after finishing
+- Never mark incomplete work as completed
+    </description>
+</tool_prompt>

tunacode/tools/prompts/update_file_prompt.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Replace text in a file. Provide old_string and new_string.
+- old_string must match exactly and be unique in the file
+- Use replace_all=true to replace all occurrences
+- Read the file first before editing
+    </description>
+</tool_prompt>

tunacode/tools/prompts/web_fetch_prompt.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Fetch web content from a URL and return as readable text.
+- Converts HTML pages to plain text for easier reading
+- Blocks localhost and private IP addresses for security
+- Maximum content size: 5MB
+- Default timeout: 60 seconds
+Use for fetching documentation, API references, or web resources.
+    </description>
+</tool_prompt>

tunacode/tools/prompts/write_file_prompt.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tool_prompt>
+    <description>
+Write content to a file. Creates or overwrites.
+Requires absolute filepath. Read existing files first before overwriting.
+    </description>
+</tool_prompt>