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

tunacode/utils/ripgrep.py

@@ -1,17 +1,340 @@
+"""Ripgrep binary management and execution utilities."""
+
+import functools
+import logging
+import os
+import platform
+import shutil
 import subprocess
-from typing import List
+from pathlib import Path
+from typing import List, Optional, Tuple
 
+logger = logging.getLogger(__name__)
 
-def ripgrep(pattern: str, directory: str = ".") -> List[str]:
-    """Return a list of file paths matching a pattern using ripgrep."""
+
+@functools.lru_cache(maxsize=1)
+def get_platform_identifier() -> Tuple[str, str]:
+    """Get the current platform identifier.
+
+    Returns:
+        Tuple of (platform_key, system_name)
+    """
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "linux":
+        if machine in ["x86_64", "amd64"]:
+            return "x64-linux", system
+        elif machine in ["aarch64", "arm64"]:
+            return "arm64-linux", system
+    elif system == "darwin":
+        if machine in ["x86_64", "amd64"]:
+            return "x64-darwin", system
+        elif machine in ["arm64", "aarch64"]:
+            return "arm64-darwin", system
+    elif system == "windows":
+        if machine in ["x86_64", "amd64"]:
+            return "x64-win32", system
+
+    raise ValueError(f"Unsupported platform: {system} {machine}")
+
+
+@functools.lru_cache(maxsize=1)
+def get_ripgrep_binary_path() -> Optional[Path]:
+    """Resolve the path to the ripgrep binary.
+
+    Resolution order:
+    1. Environment variable override (TUNACODE_RIPGREP_PATH)
+    2. System ripgrep (if newer or equal version)
+    3. Bundled ripgrep binary
+    4. None (fallback to Python-based search)
+
+    Returns:
+        Path to ripgrep binary or None if not available
+    """
+    # Check for environment variable override
+    env_path = os.environ.get("TUNACODE_RIPGREP_PATH")
+    if env_path:
+        path = Path(env_path)
+        if path.exists() and path.is_file():
+            logger.debug(f"Using ripgrep from environment variable: {path}")
+            return path
+        else:
+            logger.warning(f"Invalid TUNACODE_RIPGREP_PATH: {env_path}")
+
+    # Check for system ripgrep
+    system_rg = shutil.which("rg")
+    if system_rg:
+        system_rg_path = Path(system_rg)
+        if _check_ripgrep_version(system_rg_path):
+            logger.debug(f"Using system ripgrep: {system_rg_path}")
+            return system_rg_path
+
+    # Check for bundled ripgrep
+    try:
+        platform_key, _ = get_platform_identifier()
+        binary_name = "rg.exe" if platform_key == "x64-win32" else "rg"
+
+        # Look for vendor directory relative to this file
+        vendor_dir = (
+            Path(__file__).parent.parent.parent.parent / "vendor" / "ripgrep" / platform_key
+        )
+        bundled_path = vendor_dir / binary_name
+
+        if bundled_path.exists():
+            logger.debug(f"Using bundled ripgrep: {bundled_path}")
+            return bundled_path
+    except Exception as e:
+        logger.debug(f"Could not find bundled ripgrep: {e}")
+
+    logger.debug("No ripgrep binary found, will use Python fallback")
+    return None
+
+
+def _check_ripgrep_version(rg_path: Path, min_version: str = "13.0.0") -> bool:
+    """Check if ripgrep version meets minimum requirement.
+
+    Args:
+        rg_path: Path to ripgrep binary
+        min_version: Minimum required version
+
+    Returns:
+        True if version is sufficient, False otherwise
+    """
     try:
         result = subprocess.run(
-            ["rg", "--files", "-g", pattern, directory],
+            [str(rg_path), "--version"],
             capture_output=True,
             text=True,
-            check=True,
-            timeout=5,
+            timeout=1,
         )
-        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
-    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
-        return []
+        if result.returncode == 0:
+            # Parse version from output like "ripgrep 14.1.1"
+            version_line = result.stdout.split("\n")[0]
+            version = version_line.split()[-1]
+
+            # Simple version comparison (works for x.y.z format)
+            current = tuple(map(int, version.split(".")))
+            required = tuple(map(int, min_version.split(".")))
+
+            return current >= required
+    except Exception as e:
+        logger.debug(f"Could not check ripgrep version: {e}")
+
+    return False
+
+
+class RipgrepExecutor:
+    """Wrapper for executing ripgrep commands with error handling."""
+
+    def __init__(self, binary_path: Optional[Path] = None):
+        """Initialize the executor.
+
+        Args:
+            binary_path: Optional path to ripgrep binary
+        """
+        self.binary_path = binary_path or get_ripgrep_binary_path()
+        self._use_python_fallback = self.binary_path is None
+
+        if self._use_python_fallback:
+            logger.info("Ripgrep binary not available, using Python fallback")
+
+    def search(
+        self,
+        pattern: str,
+        path: str = ".",
+        *,
+        timeout: int = 10,
+        max_matches: Optional[int] = None,
+        file_pattern: Optional[str] = None,
+        case_insensitive: bool = False,
+        multiline: bool = False,
+        context_before: int = 0,
+        context_after: int = 0,
+        **kwargs,
+    ) -> List[str]:
+        """Execute a ripgrep search.
+
+        Args:
+            pattern: Search pattern (regex)
+            path: Directory or file to search
+            timeout: Maximum execution time in seconds
+            max_matches: Maximum number of matches to return
+            file_pattern: Glob pattern for files to include
+            case_insensitive: Case-insensitive search
+            multiline: Enable multiline mode
+            context_before: Lines of context before match
+            context_after: Lines of context after match
+            **kwargs: Additional ripgrep arguments
+
+        Returns:
+            List of matching lines or file paths
+        """
+        if self._use_python_fallback:
+            return self._python_fallback_search(
+                pattern, path, file_pattern=file_pattern, case_insensitive=case_insensitive
+            )
+
+        try:
+            cmd = [str(self.binary_path)]
+
+            # Add flags
+            if case_insensitive:
+                cmd.append("-i")
+            if multiline:
+                cmd.extend(["-U", "--multiline-dotall"])
+            if context_before > 0:
+                cmd.extend(["-B", str(context_before)])
+            if context_after > 0:
+                cmd.extend(["-A", str(context_after)])
+            if max_matches:
+                cmd.extend(["-m", str(max_matches)])
+            if file_pattern:
+                cmd.extend(["-g", file_pattern])
+
+            # Add pattern and path
+            cmd.extend([pattern, path])
+
+            logger.debug(f"Executing ripgrep: {' '.join(cmd)}")
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            if result.returncode in [0, 1]:  # 0 = matches found, 1 = no matches
+                return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+            else:
+                logger.warning(f"Ripgrep error: {result.stderr}")
+                return []
+
+        except subprocess.TimeoutExpired:
+            logger.warning(f"Ripgrep search timed out after {timeout} seconds")
+            return []
+        except Exception as e:
+            logger.error(f"Ripgrep execution failed: {e}")
+            return self._python_fallback_search(pattern, path, file_pattern=file_pattern)
+
+    def list_files(self, pattern: str, directory: str = ".") -> List[str]:
+        """List files matching a glob pattern using ripgrep.
+
+        Args:
+            pattern: Glob pattern for files
+            directory: Directory to search
+
+        Returns:
+            List of file paths
+        """
+        if self._use_python_fallback:
+            return self._python_fallback_list_files(pattern, directory)
+
+        try:
+            result = subprocess.run(
+                [str(self.binary_path), "--files", "-g", pattern, directory],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        except Exception:
+            return self._python_fallback_list_files(pattern, directory)
+
+    def _python_fallback_search(
+        self,
+        pattern: str,
+        path: str,
+        file_pattern: Optional[str] = None,
+        case_insensitive: bool = False,
+    ) -> List[str]:
+        """Python-based fallback search implementation."""
+        import re
+        from pathlib import Path
+
+        results = []
+        path_obj = Path(path)
+
+        # Compile regex pattern
+        flags = re.IGNORECASE if case_insensitive else 0
+        try:
+            regex = re.compile(pattern, flags)
+        except re.error:
+            logger.error(f"Invalid regex pattern: {pattern}")
+            return []
+
+        # Search files
+        if path_obj.is_file():
+            files = [path_obj]
+        else:
+            glob_pattern = file_pattern or "**/*"
+            files = list(path_obj.glob(glob_pattern))
+
+        for file_path in files:
+            if not file_path.is_file():
+                continue
+
+            try:
+                with file_path.open("r", encoding="utf-8", errors="ignore") as f:
+                    for line_num, line in enumerate(f, 1):
+                        if regex.search(line):
+                            results.append(f"{file_path}:{line_num}:{line.strip()}")
+            except Exception:  # nosec B112 - continue on file read errors is appropriate
+                continue
+
+        return results
+
+    def _python_fallback_list_files(self, pattern: str, directory: str) -> List[str]:
+        """Python-based fallback for listing files."""
+        from pathlib import Path
+
+        try:
+            base_path = Path(directory)
+            return [str(p) for p in base_path.glob(pattern) if p.is_file()]
+        except Exception:
+            return []
+
+
+# Maintain backward compatibility
+def ripgrep(pattern: str, directory: str = ".") -> List[str]:
+    """Return a list of file paths matching a pattern using ripgrep.
+
+    This function maintains backward compatibility with the original implementation.
+    """
+    executor = RipgrepExecutor()
+    return executor.list_files(pattern, directory)
+
+
+# Performance metrics collection
+class RipgrepMetrics:
+    """Collect performance metrics for ripgrep operations."""
+
+    def __init__(self):
+        self.search_count = 0
+        self.total_search_time = 0.0
+        self.fallback_count = 0
+
+    def record_search(self, duration: float, used_fallback: bool = False):
+        """Record a search operation."""
+        self.search_count += 1
+        self.total_search_time += duration
+        if used_fallback:
+            self.fallback_count += 1
+
+    @property
+    def average_search_time(self) -> float:
+        """Get average search time."""
+        if self.search_count == 0:
+            return 0.0
+        return self.total_search_time / self.search_count
+
+    @property
+    def fallback_rate(self) -> float:
+        """Get fallback usage rate."""
+        if self.search_count == 0:
+            return 0.0
+        return self.fallback_count / self.search_count
+
+
+# Global metrics instance
+metrics = RipgrepMetrics()

tunacode/utils/text_utils.py

@@ -66,10 +66,12 @@ def expand_file_refs(text: str) -> Tuple[str, List[str]]:
             - List of absolute paths of files that were successfully expanded.
 
     Raises:
-        ValueError: If a referenced path does not exist.
+        ValueError: If a referenced path does not exist or if attempting to expand
+                   TunaCode's own source directory.
     """
     import os
     import re
+    from pathlib import Path
 
     from tunacode.constants import (
         ERROR_DIR_TOO_LARGE,
@@ -86,6 +88,21 @@ def expand_file_refs(text: str) -> Tuple[str, List[str]]:
     def replacer(match: re.Match) -> str:
         path_spec = match.group(1)
 
+        # Detect if we're expanding TunaCode's own src/ from TunaCode's repo
+        # This prevents accidentally expanding TunaCode's source instead of user's project
+        if path_spec.startswith("src/") or path_spec.startswith("src/**"):
+            cwd = Path.cwd()
+            tunacode_marker = cwd / "src" / "tunacode" / "__init__.py"
+            if tunacode_marker.exists():
+                raise ValueError(
+                    "Error: TunaCode cannot expand file references when running "
+                    "from its own source directory.\n"
+                    "Please run TunaCode from your project directory, not from "
+                    "the TunaCode repository itself.\n"
+                    f"Current directory: {cwd}\n"
+                    "Expected: Your project's root directory"
+                )
+
         is_recursive = path_spec.endswith("/**")
         is_dir = path_spec.endswith("/")
 

tunacode/utils/user_configuration.py

@@ -45,6 +45,10 @@ def load_config() -> Optional[UserConfig]:
             # else, update fast path
             _config_fingerprint = new_fp
             _config_cache = loaded
+
+            # Initialize onboarding defaults for new configurations
+            _ensure_onboarding_defaults(loaded)
+
             return loaded
     except FileNotFoundError:
         return None
@@ -91,3 +95,44 @@ def set_default_model(model_name: ModelName, state_manager: "StateManager") -> b
     except ConfigurationError:
         # Re-raise ConfigurationError to be handled by caller
         raise
+
+
+def _ensure_onboarding_defaults(config: UserConfig) -> None:
+    """Ensure onboarding-related default settings are present in config."""
+    from datetime import datetime
+
+    if "settings" not in config:
+        config["settings"] = {}
+
+    settings = config["settings"]
+
+    # Set tutorial enabled by default for new users
+    if "enable_tutorial" not in settings:
+        settings["enable_tutorial"] = True
+
+    # Set first installation date if not present (for new installs)
+    if "first_installation_date" not in settings:
+        settings["first_installation_date"] = datetime.now().isoformat()
+
+
+def initialize_first_time_user(state_manager: "StateManager") -> None:
+    """Initialize first-time user settings and save configuration."""
+    from datetime import datetime
+
+    # Ensure settings section exists
+    if "settings" not in state_manager.session.user_config:
+        state_manager.session.user_config["settings"] = {}
+
+    settings = state_manager.session.user_config["settings"]
+
+    # Only set installation date if it doesn't exist (true first-time)
+    if "first_installation_date" not in settings:
+        settings["first_installation_date"] = datetime.now().isoformat()
+        settings["enable_tutorial"] = True
+
+        # Save the updated configuration
+        try:
+            save_config(state_manager)
+        except ConfigurationError:
+            # Non-critical error, continue without failing
+            pass

tunacode_cli-0.0.78.6.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: tunacode-cli
+Version: 0.0.78.6
+Summary: Your agentic CLI developer.
+Project-URL: Homepage, https://tunacode.xyz/
+Project-URL: Repository, https://github.com/alchemiststudiosDOTai/tunacode
+Project-URL: Issues, https://github.com/alchemiststudiosDOTai/tunacode/issues
+Project-URL: Documentation, https://github.com/alchemiststudiosDOTai/tunacode#readme
+Author-email: larock22 <noreply@github.com>
+License: MIT
+License-File: LICENSE
+Keywords: agent,automation,cli,development
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: <3.14,>=3.10
+Requires-Dist: click<9.0.0,>=8.3.1
+Requires-Dist: defusedxml
+Requires-Dist: prompt-toolkit<4.0.0,>=3.0.52
+Requires-Dist: pydantic-ai<2.0.0,>=1.18.0
+Requires-Dist: pydantic<3.0.0,>=2.12.4
+Requires-Dist: pygments<3.0.0,>=2.19.2
+Requires-Dist: rich<15.0.0,>=14.2.0
+Requires-Dist: textual
+Requires-Dist: tiktoken<1.0.0,>=0.12.0
+Requires-Dist: typer<0.10.0,>=0.9.0
+Provides-Extra: dev
+Requires-Dist: autoflake>=2.0.0; extra == 'dev'
+Requires-Dist: bandit; extra == 'dev'
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: dead>=1.5.0; extra == 'dev'
+Requires-Dist: hatch>=1.6.0; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: textual-dev; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Requires-Dist: unimport>=1.0.0; extra == 'dev'
+Requires-Dist: vulture>=2.7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# TunaCode CLI
+
+<div align="center">
+
+[![PyPI version](https://badge.fury.io/py/tunacode-cli.svg)](https://badge.fury.io/py/tunacode-cli)
+[![Downloads](https://pepy.tech/badge/tunacode-cli)](https://pepy.tech/project/tunacode-cli)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**AI-powered CLI coding assistant**
+
+![TunaCode Example](assets/tunacode_example.png)
+
+</div>
+
+---
+
+## Quick Install
+
+```bash
+# Option 1: One-line install (Linux/macOS)
+wget -qO- https://raw.githubusercontent.com/alchemiststudiosDOTai/tunacode/master/scripts/install_linux.sh | bash
+
+# Option 2: UV install (recommended)
+uv tool install tunacode-cli
+
+# Option 3: pip install
+pip install tunacode-cli
+```
+
+For detailed installation and configuration instructions, see the [**Getting Started Guide**](documentation/user/getting-started.md).
+
+## Quickstart
+
+```bash
+# 1) Install (choose one)
+uv tool install tunacode-cli  # recommended
+# or: pip install tunacode-cli
+
+# 2) Launch the CLI
+tunacode --wizard   # guided setup (enter an API key, pick a model)
+
+# 3) Try common commands in the REPL
+/help        # see commands
+/model       # explore models and set a default
+/plan        # enter read-only Plan Mode
+```
+
+Tip: You can also skip the wizard and set everything via flags:
+
+```bash
+tunacode --model openai:gpt-4.1 --key sk-your-key
+```
+
+## Development Installation
+
+For contributors and developers who want to work on TunaCode:
+
+```bash
+# Clone the repository
+git clone https://github.com/alchemiststudiosDOTai/tunacode.git
+cd tunacode
+
+# Quick setup (recommended) - uses UV automatically if available
+./scripts/setup_dev_env.sh
+
+# Or manual setup with UV (recommended)
+uv venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+uv pip install -e ".[dev]"
+
+# Alternative: traditional setup
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -e ".[dev]"
+
+# Verify installation
+tunacode --version
+```
+
+See the [Hatch Build System Guide](documentation/development/hatch-build-system.md) for detailed instructions on the development environment.
+
+## Configuration
+
+Choose your AI provider and set your API key. For more details, see the [Configuration Section](documentation/user/getting-started.md#2-configuration) in the Getting Started Guide. For local models (LM Studio, Ollama, etc.), see the [Local Models Setup Guide](documentation/configuration/local-models.md).
+
+### New: Enhanced Model Selection
+
+TunaCode now automatically saves your model selection for future sessions. When you choose a model using `/model <provider:name>`, it will be remembered across restarts.
+
+**If you encounter API key errors**, you can manually create a configuration file that matches the current schema:
+
+```bash
+# Create the config file
+cat > ~/.config/tunacode.json << 'EOF'
+{
+  "default_model": "openai:gpt-4.1",
+  "env": {
+    "OPENAI_API_KEY": "your-openai-api-key-here",
+    "ANTHROPIC_API_KEY": "",
+    "GEMINI_API_KEY": "",
+    "OPENROUTER_API_KEY": ""
+  },
+  "settings": {
+    "enable_streaming": true,
+    "max_iterations": 40,
+    "context_window_size": 200000
+  },
+  "mcpServers": {}
+}
+EOF
+```
+
+Replace the model and API key with your preferred provider and credentials. Examples:
+- `openai:gpt-4.1` (requires OPENAI_API_KEY)
+- `anthropic:claude-4-sonnet-20250522` (requires ANTHROPIC_API_KEY)
+- `google:gemini-2.5-pro` (requires GEMINI_API_KEY)
+
+### ⚠️ Important Notice
+
+I apologize for any recent issues with model selection and configuration. I'm actively working to fix these problems and improve the overall stability of TunaCode. Your patience and feedback are greatly appreciated as I work to make the tool more reliable.
+
+### Recommended Models
+
+Based on extensive testing, these models provide the best performance:
+
+- `google/gemini-2.5-pro` - Excellent for complex reasoning
+- `openai/gpt-4.1` - Strong general-purpose model
+- `deepseek/deepseek-r1-0528` - Great for code generation
+- `openai/gpt-4.1-mini` - Fast and cost-effective
+- `anthropic/claude-4-sonnet-20250522` - Superior context handling
+
+_Note: Formal evaluations coming soon. Any model can work, but these have shown the best results in practice._
+
+## Start Coding
+
+```bash
+tunacode
+```
+
+## Basic Commands
+
+| Command                  | Description            |
+| ------------------------ | ---------------------- |
+| `/help`                  | Show all commands      |
+| `/model <provider:name>` | Switch model           |
+| `/clear`                 | Clear message history  |
+| `/compact`               | Summarize conversation |
+| `/branch <name>`         | Create Git branch      |
+| `/yolo`                  | Skip confirmations     |
+| `!<command>`             | Run shell command      |
+| `exit`                   | Exit TunaCode          |
+
+## Performance
+
+TunaCode leverages parallel execution for read-only operations, achieving **3x faster** file operations:
+
+![Parallel Execution Performance](docs/assets/parrelel_work_3x.png)
+
+Multiple file reads, directory listings, and searches execute concurrently using async I/O, making code exploration significantly faster.
+
+## Features in Development
+
+- **Bug Fixes**: Actively addressing issues - please report any bugs you encounter!
+
+_Note: While the tool is fully functional, we're focusing on stability and core features before optimizing for speed._
+
+## Safety First
+
+⚠️ **Important**: TunaCode can modify your codebase. Always:
+
+- Use Git branches before making changes
+- Review file modifications before confirming
+- Keep backups of important work
+
+## Documentation
+
+For a complete overview of the documentation, see the [**Documentation Hub**](documentation/README.md).
+
+### User Documentation
+
+- [**Getting Started**](documentation/user/getting-started.md) - How to install, configure, and use TunaCode.
+- [**Commands**](documentation/user/commands.md) - A complete list of all available commands.
+
+### Developer Documentation
+
+- **Architecture** (planned) - The overall architecture of the TunaCode application.
+- **Contributing** (planned) - Guidelines for contributing to the project.
+- **Tools** (planned) - How to create and use custom tools.
+- **Testing** (planned) - Information on the testing philosophy and how to run tests.
+
+### Guides
+
+- [**Advanced Configuration**](documentation/configuration/config-file-example.md) - An example of an advanced configuration file.
+
+### Reference
+
+- **Changelog** (planned) - A history of changes to the application.
+- **Roadmap** (planned) - The future direction of the project.
+- **Security** (planned) - Information about the security of the application.
+
+## Links
+
+- [PyPI Package](https://pypi.org/project/tunacode-cli/)
+- [GitHub Repository](https://github.com/alchemiststudiosDOTai/tunacode)
+- [Report Issues](https://github.com/alchemiststudiosDOTai/tunacode/issues)
+
+---
+
+MIT License - see [LICENSE](LICENSE) file