killpy 0.24.1__tar.gz → 0.24.2__tar.gz

{killpy-0.24.1 → killpy-0.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: killpy
-Version: 0.24.1
+Version: 0.24.2
 Summary: List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹.
 Project-URL: Homepage, https://github.com/Tlaloc-Es/killpy
 Project-URL: Documentation, https://tlaloc-es.github.io/killpy/
@@ -587,7 +587,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.1
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.1 → killpy-0.24.2}/README.md

@@ -566,7 +566,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.1
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.1 → killpy-0.24.2}/killpy/__main__.py

@@ -1,4 +1,5 @@
 import logging
+import sys
 from pathlib import Path
 
 import click
@@ -6,7 +7,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from killpy.cleaner import Cleaner
+from killpy.cleaner import Cleaner, CleanerError
 from killpy.cli import TableApp
 from killpy.commands.clean import clean
 from killpy.commands.delete import delete_cmd
@@ -62,17 +63,19 @@ def _run_delete_all(path: Path, excluded: set[str], yes: bool) -> None:
 
     deleted = 0
     freed = 0
+    errors = 0
     for env in envs:
-        size = env.size_bytes
-        if cleaner.delete(env):
-            freed += size
+        try:
+            freed += cleaner.delete(env)
             deleted += 1
-        else:
-            console.print(f"[red]Failed to delete:[/red] {env.path}")
+        except CleanerError as exc:
+            console.print(f"  [red]✗ Failed to delete:[/red] {env.path}: {exc}")
+            errors += 1
 
     console.print(
         f"\n[bold green]Done.[/bold green] Deleted {deleted}/{len(envs)} environment(s), "  # noqa: E501
         f"freed [bold]{format_size(freed)}[/bold]."
+        + (f" [red]{errors} error(s).[/red]" if errors else "")
     )
 
     # Best-effort: update the history record created above with freed bytes.
@@ -81,6 +84,9 @@ def _run_delete_all(path: Path, excluded: set[str], yes: bool) -> None:
     except Exception:  # noqa: BLE001
         pass
 
+    if errors:
+        sys.exit(1)
+
 
 @click.group(invoke_without_command=True)
 @click.option(

{killpy-0.24.1 → killpy-0.24.2}/killpy/cleaner.py

@@ -11,8 +11,8 @@ Usage::
 The :class:`Cleaner` dispatches to the correct removal strategy based on
 :attr:`~killpy.models.Environment.managed_by`.  Environments with
 ``managed_by="conda"`` are removed via ``conda env remove``;
-``managed_by="pipx"`` via ``pipx uninstall``; all others via
-:func:`shutil.rmtree`.
+``managed_by="pipx"`` via ``pipx uninstall``; ``managed_by="uv"`` via
+``uv tool uninstall``; all others via :func:`shutil.rmtree`.
 """
 
 from __future__ import annotations
@@ -77,6 +77,8 @@ class Cleaner:
                 self._remove_conda(env.name)
             elif env.managed_by == "pipx":
                 self._remove_pipx(env.name)
+            elif env.managed_by == "uv":
+                self._remove_uv_tool(env.name)
             else:
                 self._remove_filesystem(env.path)
         except CleanerError:
@@ -161,3 +163,18 @@ class Cleaner:
             raise CleanerError(
                 f"pipx uninstall failed for '{package_name}': {result.stderr.strip()}"
             )
+
+    @staticmethod
+    def _remove_uv_tool(tool_name: str) -> None:
+        if shutil.which("uv") is None:
+            raise CleanerError("uv not found on PATH")
+        result = subprocess.run(
+            ["uv", "tool", "uninstall", tool_name],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise CleanerError(
+                f"uv tool uninstall failed for '{tool_name}': {result.stderr.strip()}"
+            )

{killpy-0.24.1 → killpy-0.24.2}/killpy/cli.py

@@ -714,8 +714,9 @@ class TableApp(App):
                 )
         self.bell()
 
-    @is_venv_tab
     def delete_environment(self, environment: Environment) -> bool:
+        # Shared helper — no tab gating here: it is called from both the
+        # venv tab (delete actions) and the pipx tab (uninstall action).
         try:
             self.cleaner.delete(environment)
             return True

{killpy-0.24.1 → killpy-0.24.2}/killpy/detectors/artifacts.py

@@ -14,6 +14,10 @@ from killpy.models import Environment
 logger = logging.getLogger(__name__)
 
 _PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
+# Environment internals are not build artifacts: every installed package has
+# a ``site-packages/*.dist-info`` directory whose deletion corrupts the env.
+# Environments are VenvDetector territory.
+_ENV_DIRS: frozenset[str] = frozenset({".venv", "site-packages"})
 _EXACT_NAMES: frozenset[str] = frozenset({"dist", "build"})
 _SUFFIXES: tuple[str, ...] = (".egg-info", ".dist-info")
 
@@ -28,7 +32,10 @@ class ArtifactsDetector(AbstractDetector):
     """Detects Python build artifact directories.
 
     Finds ``dist/``, ``build/``, ``*.egg-info/``, and ``*.dist-info/``
-    directories under the scan root.
+    directories under the scan root.  Virtual environments (``.venv``,
+    any directory containing ``pyvenv.cfg``) and ``site-packages`` trees
+    are skipped: their ``*.dist-info`` entries are package metadata, not
+    build output.
     """
 
     name = "artifacts"
@@ -38,10 +45,14 @@ class ArtifactsDetector(AbstractDetector):
 
     def detect(self, path: Path) -> list[Environment]:
         envs: list[Environment] = []
-        for current_root, directories, _ in os.walk(path, topdown=True):
+        for current_root, directories, files in os.walk(path, topdown=True):
+            if "pyvenv.cfg" in files:
+                # Inside a virtual environment (whatever its name) — skip it.
+                directories[:] = []
+                continue
             pruned = set()
             for d in directories:
-                if d in _PRUNED:
+                if d in _PRUNED or d in _ENV_DIRS:
                     pruned.add(d)
                     continue
                 if _is_artifact_dir(d):

{killpy-0.24.1 → killpy-0.24.2}/killpy/detectors/cache.py

@@ -5,8 +5,8 @@ Covers:
 * ``.mypy_cache``
 * ``.pytest_cache``
 * ``.ruff_cache``
-* Global pip cache  (``~/.cache/pip``)
-* Global uv cache   (``~/.cache/uv``)
+* Global pip cache  (``~/.cache/pip``) — only when inside the scanned path
+* Global uv cache   (``~/.cache/uv``) — only when inside the scanned path
 """
 
 from __future__ import annotations
@@ -33,6 +33,11 @@ _LOCAL_CACHE_DIRS: tuple[str, ...] = (
 # Directories to prune from the walk so we don't descend into them.
 _PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
 
+# Caches inside an environment belong to the environment: VenvDetector
+# already reports the whole tree, so listing them separately double-counts
+# their size in stats/list totals.
+_ENV_DIRS: frozenset[str] = frozenset({".venv", "site-packages"})
+
 
 class CacheDetector(AbstractDetector):
     """Detects local and global Python cache directories."""
@@ -45,18 +50,26 @@ class CacheDetector(AbstractDetector):
     def detect(self, path: Path) -> list[Environment]:
         envs: list[Environment] = []
         envs.extend(self._scan_local(path))
-        envs.extend(self._scan_global())
+        envs.extend(self._scan_global(path))
         return envs
 
     # ------------------------------------------------------------------ #
 
     def _scan_local(self, root: Path) -> list[Environment]:
-        """Walk *root* and collect all known local cache directories."""
+        """Walk *root* and collect all known local cache directories.
+
+        Virtual environments (``.venv``, any directory containing
+        ``pyvenv.cfg``) and ``site-packages`` trees are skipped.
+        """
         results: list[Environment] = []
-        for current_root, directories, _ in os.walk(root, topdown=True):
+        for current_root, directories, files in os.walk(root, topdown=True):
+            if "pyvenv.cfg" in files:
+                # Inside a virtual environment (whatever its name) — skip it.
+                directories[:] = []
+                continue
             prune = set()
             for d in directories:
-                if d in _PRUNED:
+                if d in _PRUNED or d in _ENV_DIRS:
                     prune.add(d)
                     continue
                 if d in _LOCAL_CACHE_DIRS:
@@ -70,19 +83,33 @@ class CacheDetector(AbstractDetector):
             directories[:] = [d for d in directories if d not in prune]
         return results
 
-    def _scan_global(self) -> list[Environment]:
-        """Return global pip and uv cache directories if they exist."""
+    def _scan_global(self, root: Path) -> list[Environment]:
+        """Return global pip/uv cache directories that live under *root*.
+
+        A scan scoped to a project directory (e.g. the pre-commit hooks or
+        ``killpy delete --type cache --path <repo>``) must never surface —
+        and therefore never delete — caches outside that directory.  The
+        global caches are still reported when the scan root contains them
+        (e.g. ``killpy --path ~``).
+        """
+        try:
+            scan_root = root.resolve()
+        except OSError:
+            scan_root = root
         results: list[Environment] = []
         candidates = [
             (Path.home() / ".cache" / "pip", "pip-cache"),
             (Path.home() / ".cache" / "uv", "uv-cache"),
         ]
         for cache_path, tag in candidates:
-            if cache_path.exists():
-                try:
-                    results.append(_make_cache_env(cache_path, tag))
-                except (FileNotFoundError, OSError) as exc:
-                    logger.debug("Skipping global cache %s: %s", cache_path, exc)
+            if not cache_path.exists():
+                continue
+            try:
+                if not cache_path.resolve().is_relative_to(scan_root):
+                    continue
+                results.append(_make_cache_env(cache_path, tag))
+            except (FileNotFoundError, OSError) as exc:
+                logger.debug("Skipping global cache %s: %s", cache_path, exc)
         return results
 
 

killpy-0.24.2/killpy/detectors/uv.py

@@ -0,0 +1,96 @@
+"""Detector for disk space owned by uv itself (tool envs and Pythons)."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+from killpy.detectors.base import AbstractDetector
+from killpy.files import get_total_size
+from killpy.models import Environment
+
+logger = logging.getLogger(__name__)
+
+
+def _uv_data_dir() -> Path:
+    xdg = os.environ.get("XDG_DATA_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".local" / "share"
+    return base / "uv"
+
+
+def _uv_tools_dir() -> Path:
+    override = os.environ.get("UV_TOOL_DIR")
+    return Path(override) if override else _uv_data_dir() / "tools"
+
+
+def _uv_python_dir() -> Path:
+    override = os.environ.get("UV_PYTHON_INSTALL_DIR")
+    return Path(override) if override else _uv_data_dir() / "python"
+
+
+class UvDetector(AbstractDetector):
+    """Detects environments managed by uv itself.
+
+    Covers:
+
+    * Tool environments installed with ``uv tool install`` (uv's pipx
+      equivalent), stored under ``~/.local/share/uv/tools``.  Marked
+      ``managed_by="uv"`` so deletion goes through ``uv tool uninstall``
+      and the ``~/.local/bin`` shims are cleaned up too.
+    * Python versions installed with ``uv python install``, stored under
+      ``~/.local/share/uv/python``.
+
+    ``UV_TOOL_DIR``, ``UV_PYTHON_INSTALL_DIR`` and ``XDG_DATA_HOME`` are
+    honoured.  Project virtualenvs created by ``uv venv`` / ``uv sync``
+    are regular ``pyvenv.cfg`` environments reported by
+    :class:`~killpy.detectors.venv.VenvDetector`, and the global uv cache
+    is reported by the cache detector.  The scan *path* argument is
+    ignored.
+    """
+
+    name = "uv"
+
+    def can_handle(self) -> bool:
+        return (
+            shutil.which("uv") is not None
+            or _uv_tools_dir().exists()
+            or _uv_python_dir().exists()
+        )
+
+    def detect(self, path: Path) -> list[Environment]:  # noqa: ARG002
+        envs: list[Environment] = []
+        envs.extend(self._scan_dir(_uv_tools_dir(), managed_by="uv"))
+        envs.extend(self._scan_dir(_uv_python_dir(), managed_by=None))
+        return envs
+
+    @staticmethod
+    def _scan_dir(root: Path, managed_by: str | None) -> list[Environment]:
+        if not root.exists():
+            return []
+        envs: list[Environment] = []
+        try:
+            for env_dir in root.iterdir():
+                if not env_dir.is_dir():
+                    continue
+                try:
+                    stat = env_dir.stat()
+                    size = get_total_size(env_dir)
+                    mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+                    envs.append(
+                        Environment(
+                            path=env_dir,
+                            name=env_dir.name,
+                            type="uv",
+                            last_accessed=mtime,
+                            size_bytes=size,
+                            managed_by=managed_by,
+                        )
+                    )
+                except (FileNotFoundError, OSError) as exc:
+                    logger.debug("Skipping uv entry %s: %s", env_dir, exc)
+        except OSError as exc:
+            logger.error("Cannot inspect uv dir %s: %s", root, exc)
+        return envs

{killpy-0.24.1 → killpy-0.24.2}/killpy/intelligence/suggestions.py

@@ -9,7 +9,6 @@ from killpy.models import ScoredEnvironment, Suggestion
 
 # Age thresholds in days.
 _HIGH_AGE_ORPHAN_THRESHOLD = 180  # orphan + age >= this → HIGH
-_HIGH_AGE_NO_PROJECT_THRESHOLD = 365  # no project files + age >= this → HIGH
 _MEDIUM_AGE_THRESHOLD = 120  # age >= this → MEDIUM
 _LOW_AGE_THRESHOLD = 120  # age < this → LOW
 
@@ -73,7 +72,6 @@ class SuggestionEngine:
         reasons: list[str],
     ) -> tuple[Literal["HIGH", "MEDIUM", "LOW"], str]:
         is_orphan = scored.is_orphan
-        has_project_files = scored.has_project_files
         is_active_git = (
             scored.git_info is not None
             and scored.git_info.is_git_repo
@@ -86,12 +84,6 @@ class SuggestionEngine:
             reasons.append(f"Not used in {age_days} days")
             return "HIGH", _ACTION_HIGH
 
-        # ── Rule 1b: HIGH — no project files and very old ──────────────────────
-        if not has_project_files and age_days >= _HIGH_AGE_NO_PROJECT_THRESHOLD:
-            reasons.append("Orphan — no project files found nearby")
-            reasons.append(f"Not used in {age_days} days")
-            return "HIGH", _ACTION_HIGH
-
         # ── Rule 2: LOW — active git or very recent ─────────────────────────────
         if is_active_git or age_days < _LOW_AGE_THRESHOLD:
             if is_active_git:

{killpy-0.24.1 → killpy-0.24.2}/killpy/models.py

@@ -39,8 +39,8 @@ class Environment:
         Total size in bytes (recursive directory sum).
     managed_by:
         If not ``None``, the external tool that manages deletion.  Supported
-        values: ``"conda"`` and ``"pipx"``.  When ``None`` deletion is
-        performed via :func:`shutil.rmtree`.
+        values: ``"conda"``, ``"pipx"`` and ``"uv"`` (uv tool environments).
+        When ``None`` deletion is performed via :func:`shutil.rmtree`.
     """
 
     path: Path

{killpy-0.24.1 → killpy-0.24.2}/killpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: killpy
-Version: 0.24.1
+Version: 0.24.2
 Summary: List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹.
 Project-URL: Homepage, https://github.com/Tlaloc-Es/killpy
 Project-URL: Documentation, https://tlaloc-es.github.io/killpy/
@@ -587,7 +587,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.1
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.1 → killpy-0.24.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "killpy"
-version = "0.24.1"
+version = "0.24.2"
 description = "List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹."
 readme = "README.md"
 classifiers = [

killpy-0.24.1/killpy/detectors/uv.py

@@ -1,64 +0,0 @@
-"""Detector for uv-managed virtual environments."""
-
-from __future__ import annotations
-
-import logging
-import os
-import shutil
-from datetime import datetime, timezone
-from pathlib import Path
-
-from killpy.detectors.base import AbstractDetector
-from killpy.files import get_total_size
-from killpy.models import Environment
-
-logger = logging.getLogger(__name__)
-
-_PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
-
-
-class UvDetector(AbstractDetector):
-    """Detects ``.uv`` directories created by `uv venv` inside projects.
-
-    Also reports the global uv cache at ``~/.cache/uv`` – but only when
-    the cache detector is *not* included in the same scan (the scanner
-    handles deduplication by path).
-    """
-
-    name = "uv"
-
-    def can_handle(self) -> bool:
-        return shutil.which("uv") is not None
-
-    def detect(self, path: Path) -> list[Environment]:
-        envs: list[Environment] = []
-        for current_root, directories, _ in os.walk(path, topdown=True):
-            pruned = set()
-            for d in directories:
-                if d in _PRUNED:
-                    pruned.add(d)
-                    continue
-                if d == ".uv":
-                    uv_path = Path(current_root) / d
-                    try:
-                        stat = uv_path.stat()
-                        size = get_total_size(uv_path)
-                        mtime = datetime.fromtimestamp(
-                            stat.st_mtime,
-                            tz=timezone.utc,
-                        )
-                        envs.append(
-                            Environment(
-                                path=uv_path,
-                                name=str(uv_path),
-                                type="uv",
-                                last_accessed=mtime,
-                                size_bytes=size,
-                            )
-                        )
-                    except (FileNotFoundError, OSError) as exc:
-                        logger.debug("Skipping %s: %s", uv_path, exc)
-                    pruned.add(d)
-            directories[:] = [d for d in directories if d not in pruned]
-
-        return envs