tunacode-cli 0.1.21__py3-none-any.whl

tunacode/utils/system/gitignore.py

@@ -0,0 +1,155 @@
+"""
+Module: tunacode.utils.system.gitignore
+
+Provides gitignore pattern matching and file listing with ignore support.
+"""
+
+import fnmatch
+import os
+
+from tunacode.constants import ENV_FILE
+
+# Default ignore patterns if .gitignore is not found
+DEFAULT_IGNORE_PATTERNS = {
+    "node_modules/",
+    "env/",
+    "venv/",
+    ".git/",
+    "build/",
+    "dist/",
+    "__pycache__/",
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    ".DS_Store",
+    "Thumbs.db",
+    ENV_FILE,
+    ".venv",
+    "*.egg-info",
+    ".pytest_cache/",
+    ".coverage",
+    "htmlcov/",
+    ".tox/",
+    "coverage.xml",
+    "*.cover",
+    ".idea/",
+    ".vscode/",
+    "*.swp",
+    "*.swo",
+}
+
+
+def _load_gitignore_patterns(filepath=".gitignore"):
+    """Loads patterns from a .gitignore file."""
+    patterns = set()
+    try:
+        with open(filepath, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    patterns.add(line)
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        print(f"Error reading {filepath}: {e}")
+        return None
+    patterns.add(".git/")
+    return patterns
+
+
+def _is_ignored(rel_path, name, patterns):
+    """
+    Checks if a given relative path or name matches any ignore patterns.
+    Mimics basic .gitignore behavior using fnmatch.
+    """
+    if not patterns:
+        return False
+
+    if name == ".git" or rel_path.startswith(".git/") or "/.git/" in rel_path:
+        return True
+
+    path_parts = rel_path.split(os.sep)
+
+    for pattern in patterns:
+        is_dir_pattern = pattern.endswith("/")
+        match_pattern = pattern.rstrip("/") if is_dir_pattern else pattern
+
+        if match_pattern.startswith("/"):
+            match_pattern = match_pattern.lstrip("/")
+            if fnmatch.fnmatch(rel_path, match_pattern) or fnmatch.fnmatch(
+                rel_path, match_pattern + "/*"
+            ):
+                if is_dir_pattern:
+                    if rel_path == match_pattern or rel_path.startswith(match_pattern + os.sep):
+                        return True
+                else:
+                    return True
+            continue
+
+        if fnmatch.fnmatch(name, match_pattern):
+            if is_dir_pattern:
+                pass
+            else:
+                return True
+
+        if fnmatch.fnmatch(rel_path, match_pattern):
+            return True
+
+        if is_dir_pattern or "/" not in pattern:
+            limit = len(path_parts) if is_dir_pattern else len(path_parts) - 1
+            for i in range(limit):
+                if fnmatch.fnmatch(path_parts[i], match_pattern):
+                    return True
+            if name == path_parts[-1] and fnmatch.fnmatch(name, match_pattern):
+                return True
+
+    return False
+
+
+def list_cwd(max_depth=3):
+    """
+    Lists files in the current working directory up to a specified depth,
+    respecting .gitignore rules or a default ignore list.
+
+    Args:
+        max_depth (int): Maximum directory depth to traverse.
+                         0: only files in the current directory.
+                         1: includes files in immediate subdirectories.
+                         ... Default is 3.
+
+    Returns:
+        list: A sorted list of relative file paths.
+    """
+    ignore_patterns = _load_gitignore_patterns()
+    if ignore_patterns is None:
+        ignore_patterns = DEFAULT_IGNORE_PATTERNS
+
+    file_list = []
+    start_path = "."
+    max_depth = max(0, max_depth)
+
+    for root, dirs, files in os.walk(start_path, topdown=True):
+        rel_root = os.path.relpath(root, start_path)
+        if rel_root == ".":
+            rel_root = ""
+            current_depth = 0
+        else:
+            current_depth = rel_root.count(os.sep) + 1
+
+        if current_depth >= max_depth:
+            dirs[:] = []
+
+        original_dirs = list(dirs)
+        dirs[:] = []
+        for d in original_dirs:
+            dir_rel_path = os.path.join(rel_root, d) if rel_root else d
+            if not _is_ignored(dir_rel_path, d, ignore_patterns):
+                dirs.append(d)
+
+        if current_depth <= max_depth:
+            for f in files:
+                file_rel_path = os.path.join(rel_root, f) if rel_root else f
+                if not _is_ignored(file_rel_path, f, ignore_patterns):
+                    file_list.append(file_rel_path.replace(os.sep, "/"))
+
+    return sorted(file_list)

tunacode/utils/system/paths.py

@@ -0,0 +1,190 @@
+"""
+Module: tunacode.utils.system.paths
+
+Provides path utilities, session management, device identification, and update checking.
+"""
+
+import hashlib
+import os
+import subprocess
+import uuid
+from pathlib import Path
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.constants import DEVICE_ID_FILE, SESSIONS_SUBDIR, TUNACODE_HOME_DIR
+
+
+def get_tunacode_home():
+    """
+    Get the path to the TunaCode home directory (~/.tunacode).
+    Creates it if it doesn't exist.
+
+    Returns:
+        Path: The path to the TunaCode home directory.
+    """
+    home = Path.home() / TUNACODE_HOME_DIR
+    home.mkdir(exist_ok=True)
+    return home
+
+
+def get_session_dir(state_manager):
+    """
+    Get the path to the current session directory.
+
+    Args:
+        state_manager: The StateManager instance containing session info.
+
+    Returns:
+        Path: The path to the current session directory.
+    """
+    session_dir = get_tunacode_home() / SESSIONS_SUBDIR / state_manager.session.session_id
+    session_dir.mkdir(exist_ok=True, parents=True)
+    return session_dir
+
+
+def get_cwd():
+    """Returns the current working directory."""
+    return os.getcwd()
+
+
+def get_project_id() -> str:
+    """
+    Get a project identifier based on the git repository root or cwd.
+
+    Returns:
+        str: A 16-character hash identifying the current project.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        if result.returncode == 0:
+            repo_root = result.stdout.strip()
+            return hashlib.sha256(repo_root.encode()).hexdigest()[:16]
+    except Exception:
+        pass
+    return hashlib.sha256(os.getcwd().encode()).hexdigest()[:16]
+
+
+def get_session_storage_dir() -> Path:
+    """
+    Get the XDG-compliant session storage directory.
+
+    Returns:
+        Path: The directory where session files are stored.
+    """
+    xdg_data = os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local" / "share"))
+    storage_dir = Path(xdg_data) / "tunacode" / "sessions"
+    storage_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+    return storage_dir
+
+
+def get_device_id():
+    """
+    Get the device ID from the ~/.tunacode/device_id file.
+    If the file doesn't exist, generate a new UUID and save it.
+
+    Returns:
+        str: The device ID as a string.
+    """
+    try:
+        tunacode_home = get_tunacode_home()
+        device_id_file = tunacode_home / DEVICE_ID_FILE
+
+        if device_id_file.exists():
+            device_id = device_id_file.read_text().strip()
+            if device_id:
+                return device_id
+
+        device_id = str(uuid.uuid4())
+        device_id_file.write_text(device_id)
+
+        return device_id
+    except Exception as e:
+        print(f"Error getting device ID: {e}")
+        return str(uuid.uuid4())
+
+
+def cleanup_session(state_manager):
+    """
+    Clean up temporary session runtime files after the CLI exits.
+    Session data is preserved in XDG_DATA_HOME for persistence.
+
+    Args:
+        state_manager: The StateManager instance containing session info.
+
+    Returns:
+        bool: True if cleanup was successful, False otherwise.
+    """
+    try:
+        if state_manager.session.session_id is None:
+            return True
+
+        session_dir = get_session_dir(state_manager)
+
+        if session_dir.exists():
+            import shutil
+
+            shutil.rmtree(session_dir)
+
+        return True
+    except Exception as e:
+        print(f"Error cleaning up session: {e}")
+        return False
+
+
+def delete_session_file(project_id: str, session_id: str) -> bool:
+    """
+    Delete a persisted session file.
+
+    Args:
+        project_id: The project identifier.
+        session_id: The session identifier.
+
+    Returns:
+        bool: True if deletion was successful, False otherwise.
+    """
+    try:
+        storage_dir = get_session_storage_dir()
+        session_file = storage_dir / f"{project_id}_{session_id}.json"
+        if session_file.exists():
+            session_file.unlink()
+        return True
+    except Exception as e:
+        print(f"Error deleting session file: {e}")
+        return False
+
+
+def check_for_updates():
+    """
+    Check if there's a newer version of tunacode-cli available on PyPI.
+
+    Returns:
+        tuple: (has_update, latest_version)
+            - has_update (bool): True if a newer version is available
+            - latest_version (str): The latest version available
+    """
+    app_settings = ApplicationSettings()
+    current_version = app_settings.version
+    try:
+        result = subprocess.run(
+            ["pip", "index", "versions", "tunacode-cli"], capture_output=True, text=True, check=True
+        )
+        output = result.stdout
+
+        if "Available versions:" in output:
+            versions_line = output.split("Available versions:")[1].strip()
+            versions = versions_line.split(", ")
+            latest_version = versions[0]
+
+            latest_version = latest_version.strip()
+
+            if latest_version > current_version:
+                return True, latest_version
+
+        return False, current_version
+    except Exception:
+        return False, current_version

tunacode/utils/ui/__init__.py

@@ -0,0 +1,9 @@
+"""UI utilities: completion helpers and data structures."""
+
+from tunacode.utils.ui.file_filter import FileFilter
+from tunacode.utils.ui.helpers import DotDict
+
+__all__ = [
+    "DotDict",
+    "FileFilter",
+]

tunacode/utils/ui/file_filter.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pathspec
+
+from tunacode.constants import AUTOCOMPLETE_MAX_DEPTH, AUTOCOMPLETE_RESULT_LIMIT
+
+DEFAULT_IGNORES = [
+    ".git/",
+    ".venv/",
+    "venv/",
+    "env/",
+    "node_modules/",
+    "__pycache__/",
+    "*.pyc",
+    "*.pyo",
+    "*.egg-info/",
+    ".DS_Store",
+    "Thumbs.db",
+    ".idea/",
+    ".vscode/",
+    "build/",
+    "dist/",
+    "target/",
+    ".env",
+]
+
+
+class FileFilter:
+    """Gitignore-aware file filtering."""
+
+    def __init__(self, root: Path | None = None) -> None:
+        self.root = root or Path(".")
+        self._spec = self._build_spec()
+
+    def _build_spec(self) -> pathspec.PathSpec:
+        patterns = list(DEFAULT_IGNORES)
+        gitignore = self.root / ".gitignore"
+        if gitignore.exists():
+            patterns.extend(gitignore.read_text().splitlines())
+        return pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+    def is_ignored(self, path: Path) -> bool:
+        try:
+            rel = path.relative_to(self.root)
+            return self._spec.match_file(str(rel))
+        except ValueError:
+            return False
+
+    def _parse_prefix(self, prefix: str) -> tuple[Path, str]:
+        """Parse prefix into search path and name filter."""
+        if not prefix:
+            return self.root, ""
+
+        candidate = self.root / prefix
+
+        if candidate.exists() and candidate.is_dir():
+            return candidate, ""
+
+        search_path = candidate.parent
+        name_prefix = Path(prefix).name
+
+        if not search_path.exists():
+            return self.root, ""
+
+        return search_path, name_prefix
+
+    def _matches_prefix(self, path: Path, name_prefix: str, search_path: Path) -> bool:
+        """Check if path matches name prefix filter."""
+        if not name_prefix:
+            return True
+
+        prefix_lower = name_prefix.lower()
+
+        if path.parent == search_path:
+            return path.name.lower().startswith(prefix_lower)
+
+        rel_path = path.relative_to(search_path)
+        return any(prefix_lower in part.lower() for part in rel_path.parts)
+
+    def complete(
+        self,
+        prefix: str = "",
+        limit: int = AUTOCOMPLETE_RESULT_LIMIT,
+        max_depth: int = AUTOCOMPLETE_MAX_DEPTH,
+    ) -> list[str]:
+        """Return filtered file paths matching prefix."""
+        search_path, name_prefix = self._parse_prefix(prefix)
+
+        if not search_path.exists():
+            return []
+
+        results_with_depth: list[tuple[int, str]] = []
+
+        for root_dir, dirs, files in os.walk(str(search_path), topdown=True):
+            root_path = Path(root_dir)
+            rel_root = root_path.relative_to(search_path)
+            current_depth = len(rel_root.parts)
+
+            if current_depth >= max_depth:
+                dirs[:] = []
+
+            dirs[:] = sorted(d for d in dirs if not self.is_ignored(root_path / d))
+
+            for d in dirs:
+                dir_path = root_path / d
+                if not self._matches_prefix(dir_path, name_prefix, search_path):
+                    continue
+
+                rel = dir_path.relative_to(self.root)
+                results_with_depth.append((current_depth, f"{rel}/"))
+
+                if len(results_with_depth) >= limit:
+                    break
+
+            for f in sorted(files):
+                file_path = root_path / f
+                if self.is_ignored(file_path):
+                    continue
+                if not self._matches_prefix(file_path, name_prefix, search_path):
+                    continue
+
+                rel = file_path.relative_to(self.root)
+                results_with_depth.append((current_depth, str(rel)))
+
+                if len(results_with_depth) >= limit:
+                    break
+
+            if len(results_with_depth) >= limit:
+                break
+
+        results_with_depth.sort(key=lambda x: (x[0], x[1]))
+        return [path for _, path in results_with_depth[:limit]]

tunacode/utils/ui/helpers.py

@@ -0,0 +1,24 @@
+"""
+Module: tunacode.utils.ui.helpers
+
+Provides DotDict for dot notation access to dictionary attributes
+and shared UI utility functions.
+"""
+
+from typing import Any
+
+
+class DotDict(dict):
+    """dot.notation access to dictionary attributes"""
+
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__  # type: ignore[assignment]
+    __delattr__ = dict.__delitem__  # type: ignore[assignment]
+
+
+def truncate(value: Any, max_length: int = 50) -> str:
+    """Truncate a value to max_length with ellipsis."""
+    s = str(value)
+    if len(s) <= max_length:
+        return s
+    return s[: max_length - 3] + "..."

tunacode_cli-0.1.21.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: tunacode-cli
+Version: 0.1.21
+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.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.11
+Requires-Dist: click<8.2.0,>=8.1.0
+Requires-Dist: defusedxml
+Requires-Dist: html2text>=2024.2.26
+Requires-Dist: pathspec>=0.12.1
+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: python-levenshtein>=0.21.0
+Requires-Dist: rich<15.0.0,>=14.2.0
+Requires-Dist: ruff>=0.14.0
+Requires-Dist: textual-autocomplete>=4.0.6
+Requires-Dist: textual<5.0.0,>=4.0.0
+Requires-Dist: tiktoken<1.0.0,>=0.12.0
+Requires-Dist: typer>=0.15.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: 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==0.14.9; 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
+
+[![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.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Discord Shield](https://discord.com/api/guilds/1447688577126367346/widget.png?style=shield)](https://discord.gg/TN7Fpynv6H)
+
+A TUI code agent.
+
+> **Note:** Under active development - expect bugs.
+
+
+
+## Interface
+
+![TUI Interface](docs/images/tui.png)
+
+The Textual-based terminal user interface provides a clean, interactive environment for AI-assisted coding, with a design heavily inspired by the classic NeXTSTEP user interface.
+
+## Theme Support
+
+The interface supports multiple themes for different preferences and environments.
+
+![Theme](docs/images/theme.png)
+
+Customize the appearance with built-in themes or create your own color schemes.
+
+## Model Setup
+
+Configure your AI models and settings through the provided setup interface.
+
+![TUI Model Setup](docs/images/tui-model-setup.png)
+
+**Note:** TunaCode has full bash shell access. This tool assumes you know what you're doing. If you're concerned, run it in a sandboxed environment.
+
+## v0.1.1 - Major Rewrite
+
+This release is a complete rewrite with a new Textual-based TUI.
+
+**Upgrading from v1?** The legacy v1 codebase is preserved in the `legacy-v1` branch and will only receive security updates.
+
+## Requirements
+
+- Python 3.11+
+
+## Installation
+
+```bash
+uv tool install tunacode-cli
+```
+
+## Quick Start
+
+1. Run the setup wizard to configure your API key:
+
+```bash
+tunacode --setup
+```
+
+2. Start coding:
+
+```bash
+tunacode
+```
+
+## Configuration
+
+Set your API key as an environment variable or use the setup wizard:
+
+```bash
+export OPENAI_API_KEY="your-key"
+# or
+export ANTHROPIC_API_KEY="your-key"
+```
+
+Config file location: `~/.config/tunacode.json`
+
+## Commands
+
+| Command  | Description                  |
+| -------- | ---------------------------- |
+| /help    | Show available commands      |
+| /model   | Change AI model              |
+| /clear   | Clear conversation history   |
+| /yolo    | Toggle auto-confirm mode     |
+| /branch  | Create and switch git branch |
+| /plan    | Toggle read-only planning    |
+| /theme   | Change UI theme              |
+| /resume  | Load/delete saved sessions   |
+| !<cmd>   | Run shell command            |
+| exit     | Quit tunacode                |
+
+## LSP Integration (Beta)
+
+TunaCode includes experimental Language Server Protocol support for real-time diagnostics. When an LSP server is detected in your PATH, it activates automatically.
+
+**Supported languages:**
+| Language   | LSP Server                    |
+| ---------- | ----------------------------- |
+| Python     | `ruff server`                 |
+| TypeScript | `typescript-language-server`  |
+| JavaScript | `typescript-language-server`  |
+| Go         | `gopls`                       |
+| Rust       | `rust-analyzer`               |
+
+Diagnostics appear in the UI when editing files. This feature is beta - expect rough edges.
+
+## Discord Server
+
+Join our official discord server to receive help, show us how you're using tunacode, and chat about anything LLM.
+
+[<img src="https://discord.com/api/guilds/1447688577126367346/widget.png?style=banner3" alt="Discord Banner 3"/>](https://discord.gg/TN7Fpynv6H)
+
+## License
+
+MIT