pipu-cli 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

pipu_cli/__init__.py

@@ -1,7 +1,7 @@
 import logging
 from .config import LOG_LEVEL
 
-__version__ = '0.2.0'
+__version__ = '0.2.1'
 
 
 # Configure logging

pipu_cli/cache.py

@@ -1,15 +1,18 @@
-"""Package metadata caching for pipu.
+"""Package version caching for pipu.
 
-This module provides caching of package version information to speed up
+This module provides caching of latest package versions from PyPI to speed up
 repeated runs of pipu. The cache is per-environment, identified by the
 Python executable path, making it compatible with venv, conda, mise, etc.
+
+The cache stores only the latest available versions - constraint resolution
+is performed at upgrade time with the current installed package state.
 """
 
 import hashlib
 import json
 import logging
 import sys
-from dataclasses import dataclass, field, asdict
+from dataclasses import dataclass, asdict
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Any
@@ -22,24 +25,15 @@ from pipu_cli.config import DEFAULT_CACHE_TTL, CACHE_BASE_DIR
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class CachedPackage:
-    """Cached information about a single package."""
-    name: str
-    installed_version: str
-    latest_version: str
-    is_upgradable: bool
-    is_editable: bool
-    checked_at: str  # ISO format timestamp
-
-
 @dataclass
 class CacheData:
-    """Complete cache data structure."""
+    """Cache data structure - stores latest versions from PyPI."""
     environment_id: str
     python_executable: str
     updated_at: str  # ISO format timestamp
-    packages: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    include_prereleases: bool
+    # Maps package name (lowercase) to latest version string
+    latest_versions: Dict[str, str]
 
 
 def get_environment_id() -> str:
@@ -52,7 +46,6 @@ def get_environment_id() -> str:
     :returns: Short hash identifying the environment
     """
     executable = sys.executable
-    # Create a short hash of the executable path
     hash_obj = hashlib.sha256(executable.encode())
     return hash_obj.hexdigest()[:12]
 
@@ -99,17 +92,19 @@ def load_cache() -> Optional[CacheData]:
             environment_id=data["environment_id"],
             python_executable=data["python_executable"],
             updated_at=data["updated_at"],
-            packages=data.get("packages", {})
+            include_prereleases=data.get("include_prereleases", False),
+            latest_versions=data.get("latest_versions", {})
         )
     except (json.JSONDecodeError, KeyError, TypeError) as e:
         logger.debug(f"Failed to load cache: {e}")
         return None
 
 
-def save_cache(packages: Dict[str, Dict[str, Any]]) -> Path:
-    """Save package data to the cache.
+def save_cache(latest_versions: Dict[str, str], include_prereleases: bool = False) -> Path:
+    """Save latest version data to the cache.
 
-    :param packages: Dictionary mapping package names to their cached info
+    :param latest_versions: Dictionary mapping package names (lowercase) to latest version strings
+    :param include_prereleases: Whether prereleases were included in version check
     :returns: Path to the saved cache file
     """
     cache_dir = get_cache_dir()
@@ -121,7 +116,8 @@ def save_cache(packages: Dict[str, Dict[str, Any]]) -> Path:
         environment_id=get_environment_id(),
         python_executable=sys.executable,
         updated_at=datetime.now(timezone.utc).isoformat(),
-        packages=packages
+        include_prereleases=include_prereleases,
+        latest_versions=latest_versions
     )
 
     with open(cache_path, 'w') as f:
@@ -143,7 +139,6 @@ def is_cache_fresh(ttl_seconds: int = DEFAULT_CACHE_TTL) -> bool:
 
     try:
         updated_at = datetime.fromisoformat(cache.updated_at)
-        # Ensure updated_at is timezone-aware
         if updated_at.tzinfo is None:
             updated_at = updated_at.replace(tzinfo=timezone.utc)
 
@@ -237,61 +232,6 @@ def clear_all_caches() -> int:
     return count
 
 
-def get_cached_package(name: str) -> Optional[Dict[str, Any]]:
-    """Get cached data for a specific package.
-
-    :param name: Package name (case-insensitive)
-    :returns: Package cache data or None
-    """
-    cache = load_cache()
-    if cache is None:
-        return None
-
-    # Normalize name for lookup
-    name_lower = name.lower()
-    return cache.packages.get(name_lower)
-
-
-def build_cache_from_results(
-    installed_packages: List[Any],
-    latest_versions: Dict[Any, Any],
-    upgradable_packages: List[Any]
-) -> Dict[str, Dict[str, Any]]:
-    """Build cache data from pipu's package analysis results.
-
-    :param installed_packages: List of InstalledPackage objects
-    :param latest_versions: Dict mapping InstalledPackage to LatestVersionInfo
-    :param upgradable_packages: List of UpgradePackageInfo objects
-    :returns: Dictionary suitable for save_cache()
-    """
-    # Create lookup for upgradable packages
-    upgradable_names = {pkg.name.lower() for pkg in upgradable_packages}
-
-    packages = {}
-    now = datetime.now(timezone.utc).isoformat()
-
-    for installed in installed_packages:
-        name_lower = installed.name.lower()
-
-        # Find latest version if available
-        latest_version = None
-        for inst_pkg, latest_info in latest_versions.items():
-            if inst_pkg.name.lower() == name_lower:
-                latest_version = str(latest_info.version)
-                break
-
-        packages[name_lower] = {
-            "name": installed.name,
-            "installed_version": str(installed.version),
-            "latest_version": latest_version or str(installed.version),
-            "is_upgradable": name_lower in upgradable_names,
-            "is_editable": installed.is_editable,
-            "checked_at": now
-        }
-
-    return packages
-
-
 def get_cache_info() -> Dict[str, Any]:
     """Get information about the current cache.
 
@@ -300,7 +240,7 @@ def get_cache_info() -> Dict[str, Any]:
     cache = load_cache()
     cache_path = get_cache_path()
 
-    info = {
+    info: Dict[str, Any] = {
         "exists": cache is not None,
         "path": str(cache_path),
         "environment_id": get_environment_id(),
@@ -309,8 +249,27 @@ def get_cache_info() -> Dict[str, Any]:
 
     if cache:
         info["updated_at"] = cache.updated_at
-        info["package_count"] = len(cache.packages)
-        info["age_seconds"] = get_cache_age_seconds()
-        info["age_human"] = format_cache_age(info["age_seconds"])
+        info["package_count"] = len(cache.latest_versions)
+        info["include_prereleases"] = cache.include_prereleases
+        age_seconds = get_cache_age_seconds()
+        info["age_seconds"] = age_seconds
+        info["age_human"] = format_cache_age(age_seconds)
 
     return info
+
+
+def build_version_cache(
+    latest_versions: Dict[Any, Any]
+) -> Dict[str, str]:
+    """Build cache data from pipu's version check results.
+
+    :param latest_versions: Dict mapping InstalledPackage to Package with latest version
+    :returns: Dictionary mapping package names (lowercase) to latest version strings
+    """
+    result: Dict[str, str] = {}
+
+    for installed_pkg, latest_pkg in latest_versions.items():
+        name_lower = installed_pkg.name.lower()
+        result[name_lower] = str(latest_pkg.version)
+
+    return result

pipu_cli/cli.py

@@ -13,13 +13,16 @@ from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskPr
 from rich.table import Table
 
 from pipu_cli.package_management import (
+    Package,
     inspect_installed_packages,
     get_latest_versions,
     get_latest_versions_parallel,
     resolve_upgradable_packages,
     resolve_upgradable_packages_with_reasons,
     install_packages,
+    reinstall_editable_packages,
 )
+from packaging.version import Version
 from pipu_cli.pretty import (
     print_upgradable_packages_table,
     print_upgrade_results,
@@ -34,7 +37,7 @@ from pipu_cli.cache import (
     is_cache_fresh,
     load_cache,
     save_cache,
-    build_cache_from_results,
+    build_version_cache,
     get_cache_info,
     format_cache_age,
     get_cache_age_seconds,
@@ -122,6 +125,8 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
     packages and stores it locally. This speeds up subsequent upgrade
     commands by avoiding repeated network requests.
 
+    Constraint resolution is performed at upgrade time, not during update.
+
     [bold]Examples:[/bold]
       pipu update              Update cache with defaults
       pipu update --parallel 4 Update with parallel requests
@@ -154,7 +159,7 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
     try:
         # Step 1: Inspect installed packages
         if output != "json":
-            console.print("[bold]Step 1/3:[/bold] Inspecting installed packages...")
+            console.print("[bold]Step 1/2:[/bold] Inspecting installed packages...")
 
         step1_start = time.time()
         if output != "json":
@@ -184,9 +189,9 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
                 console.print("[yellow]No packages found.[/yellow]")
             sys.exit(0)
 
-        # Step 2: Check for updates
+        # Step 2: Fetch latest versions from PyPI and save to cache
         if output != "json":
-            console.print("\n[bold]Step 2/3:[/bold] Fetching latest versions...")
+            console.print("\n[bold]Step 2/2:[/bold] Fetching latest versions from PyPI...")
 
         step2_start = time.time()
         if output != "json":
@@ -199,7 +204,7 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
             ) as progress:
                 task = progress.add_task("Checking packages...", total=len(installed_packages))
 
-                def update_progress(current, total):
+                def update_progress(current: int, total: int) -> None:
                     progress.update(task, completed=current)
 
                 if parallel > 1:
@@ -223,45 +228,29 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
                 )
         step2_time = time.time() - step2_start
 
-        num_updates = len(latest_versions)
-        if output != "json":
-            console.print(f"  Found {num_updates} packages with newer versions available")
-            if debug:
-                console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
+        # Build and save cache (only latest versions, no constraint resolution)
+        cache_data = build_version_cache(latest_versions)
+        cache_path = save_cache(cache_data, include_prereleases=pre)
 
-        # Step 3: Resolve and cache
-        if output != "json":
-            console.print("\n[bold]Step 3/3:[/bold] Resolving constraints and saving cache...")
-
-        step3_start = time.time()
-        all_upgradable = resolve_upgradable_packages(latest_versions, installed_packages)
-        upgradable_packages = [pkg for pkg in all_upgradable if pkg.upgradable]
-        step3_time = time.time() - step3_start
-
-        # Build and save cache
-        cache_data = build_cache_from_results(installed_packages, latest_versions, upgradable_packages)
-        cache_path = save_cache(cache_data)
-
-        num_upgradable = len(upgradable_packages)
+        num_with_updates = len(latest_versions)
 
         if output == "json":
             result = {
                 "status": "success",
                 "packages_checked": num_installed,
-                "packages_with_updates": num_updates,
-                "packages_upgradable": num_upgradable,
+                "packages_with_updates": num_with_updates,
                 "cache_path": str(cache_path)
             }
             print(json.dumps(result, indent=2))
         else:
-            console.print(f"  {num_upgradable} packages can be safely upgraded")
+            console.print(f"  Cached {num_with_updates} packages with updates available")
             if debug:
-                console.print(f"  [dim]Time: {step3_time:.2f}s[/dim]")
+                console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
                 console.print(f"  [dim]Cache saved to: {cache_path}[/dim]")
 
-            console.print("\n[bold green]Package list updated![/bold green] Run [cyan]pipu upgrade[/cyan] to upgrade your packages.")
+            console.print("\n[bold green]Cache updated![/bold green] Run [cyan]pipu upgrade[/cyan] to upgrade your packages.")
 
-            total_time = step1_time + step2_time + step3_time
+            total_time = step1_time + step2_time
             if debug:
                 console.print(f"[dim]Total time: {total_time:.2f}s[/dim]")
 
@@ -460,55 +449,39 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                 console.print("[yellow]No packages found.[/yellow]")
             sys.exit(0)
 
-        # Step 2: Check for updates (from cache or network)
+        # Step 2: Get latest versions (from cache or network)
         if output != "json":
             if use_cache:
                 console.print("\n[bold]Step 2/5:[/bold] Loading cached version data...")
             else:
-                console.print("\n[bold]Step 2/5:[/bold] Checking for updates...")
+                console.print("\n[bold]Step 2/5:[/bold] Fetching latest versions from PyPI...")
 
         step2_start = time.time()
         latest_versions: dict = {}
+        cache_was_used = False
 
         if use_cache:
-            # Load from cache
+            # Load latest versions from cache (skip PyPI queries entirely)
             cache_data = load_cache()
-            if cache_data and cache_data.packages:
-                # Reconstruct latest_versions from cache
-                # We need to fetch fresh for accurate constraint resolution
-                # Cache is mainly to avoid the slow PyPI queries
-                if output != "json":
-                    with Progress(
-                        TextColumn("[progress.description]{task.description}"),
-                        BarColumn(),
-                        TaskProgressColumn(),
-                        console=console,
-                        transient=True
-                    ) as progress:
-                        task = progress.add_task("Checking packages...", total=len(installed_packages))
-
-                        def update_progress(current, total):
-                            progress.update(task, completed=current)
-
-                        if parallel > 1:
-                            latest_versions = get_latest_versions_parallel(
-                                installed_packages, timeout=timeout, include_prereleases=pre,
-                                max_workers=parallel, progress_callback=update_progress
-                            )
-                        else:
-                            latest_versions = get_latest_versions(
-                                installed_packages, timeout=timeout, include_prereleases=pre,
-                                progress_callback=update_progress
-                            )
-                else:
-                    if parallel > 1:
-                        latest_versions = get_latest_versions_parallel(
-                            installed_packages, timeout=timeout, include_prereleases=pre, max_workers=parallel
-                        )
-                    else:
-                        latest_versions = get_latest_versions(
-                            installed_packages, timeout=timeout, include_prereleases=pre
-                        )
+            if cache_data and cache_data.latest_versions:
+                # Reconstruct latest_versions dict from cache
+                # Maps InstalledPackage -> Package with latest version
+                for installed_pkg in installed_packages:
+                    name_lower = installed_pkg.name.lower()
+                    if name_lower in cache_data.latest_versions:
+                        cached_version = cache_data.latest_versions[name_lower]
+                        try:
+                            latest_ver = Version(cached_version)
+                            # Only include if it's actually newer
+                            if latest_ver > installed_pkg.version:
+                                latest_pkg = Package(
+                                    name=installed_pkg.name,
+                                    version=latest_ver
+                                )
+                                latest_versions[installed_pkg] = latest_pkg
+                        except Exception:
+                            pass  # Skip invalid versions
+                cache_was_used = True
             else:
                 use_cache = False
 
@@ -524,7 +497,7 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                 ) as progress:
                     task = progress.add_task("Checking packages...", total=len(installed_packages))
 
-                    def update_progress(current, total):
+                    def update_progress(current: int, total: int) -> None:
                         progress.update(task, completed=current)
 
                     if parallel > 1:
@@ -547,11 +520,18 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                         installed_packages, timeout=timeout, include_prereleases=pre
                     )
 
+            # Update cache with fresh data
+            if cache_enabled:
+                version_cache = build_version_cache(latest_versions)
+                save_cache(version_cache, include_prereleases=pre)
+
         step2_time = time.time() - step2_start
 
         num_updates = len(latest_versions)
         if output != "json":
             console.print(f"  Found {num_updates} packages with newer versions available")
+            if cache_was_used:
+                console.print("  [dim](from cache)[/dim]")
             if debug:
                 console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
 
@@ -578,11 +558,6 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
 
         step3_time = time.time() - step3_start
 
-        # Update cache with fresh data (if we fetched from network)
-        if not use_cache and cache_enabled:
-            cache_data = build_cache_from_results(installed_packages, latest_versions, upgradable_packages)
-            save_cache(cache_data)
-
         # Apply exclusions
         excluded_names = set()
         if exclude:
@@ -667,9 +642,14 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                 console.print("[yellow]Upgrade cancelled.[/yellow]")
                 sys.exit(0)
 
+        # Separate editable and non-editable packages
+        editable_packages = [pkg for pkg in can_upgrade if pkg.is_editable]
+        non_editable_packages = [pkg for pkg in can_upgrade if not pkg.is_editable]
+
         # Step 5: Install packages
         if output != "json":
-            console.print("\n[bold]Step 5/5:[/bold] Upgrading packages...\n")
+            total_to_upgrade = len(non_editable_packages) + len(editable_packages)
+            console.print(f"[bold]Step 5/5:[/bold] Upgrading {total_to_upgrade} package(s)...\n")
         step5_start = time.time()
 
         # Save state for potential rollback
@@ -681,12 +661,31 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
         save_state(pre_upgrade_packages, "Pre-upgrade state")
 
         stream = ConsoleStream(console) if output != "json" else None
-        results = install_packages(
-            can_upgrade,
-            output_stream=stream,
-            timeout=300,
-            version_constraints=package_constraints if package_constraints else None
-        )
+        results = []
+
+        # First, upgrade non-editable packages via pip install --upgrade
+        if non_editable_packages:
+            if output != "json":
+                console.print(f"Upgrading {len(non_editable_packages)} regular package(s)...\n")
+            regular_results = install_packages(
+                non_editable_packages,
+                output_stream=stream,
+                timeout=300,
+                version_constraints=package_constraints if package_constraints else None
+            )
+            results.extend(regular_results)
+
+        # Then, reinstall editable packages to update their versions
+        if editable_packages:
+            if output != "json":
+                console.print(f"\nReinstalling {len(editable_packages)} editable package(s)...\n")
+            editable_results = reinstall_editable_packages(
+                editable_packages,
+                output_stream=stream,
+                timeout=300
+            )
+            results.extend(editable_results)
+
         step5_time = time.time() - step5_start
 
         # Update requirements file if requested

pipu_cli/config_file.py

@@ -1,6 +1,5 @@
 """Configuration file support for pipu."""
 
-import os
 from pathlib import Path
 from typing import Dict, Any, Optional
 

pipu_cli/package_management.py

@@ -54,6 +54,7 @@ class InstalledPackage(Package):
     """Information about an installed package."""
     constrained_dependencies: Dict[str, str] = field(default_factory=dict, hash=False, compare=False)
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -62,6 +63,7 @@ class UpgradePackageInfo(Package):
     upgradable: bool
     latest_version: Version
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -70,6 +72,7 @@ class UpgradedPackage(Package):
     upgraded: bool
     previous_version: Version
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -78,6 +81,7 @@ class BlockedPackageInfo(Package):
     latest_version: Version
     blocked_by: List[str]  # List of "package_name (constraint)" strings
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
@@ -115,8 +119,9 @@ def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
                     logger.warning(f"Invalid version for {package_name}: {dist.version}. Skipping.")
                     continue
 
-                # Check if package is editable
+                # Check if package is editable and get its location
                 is_editable = canonical_name in editable_packages
+                editable_location = editable_packages.get(canonical_name) if is_editable else None
 
                 # Extract constrained dependencies
                 constrained_dependencies = _extract_constrained_dependencies(dist)
@@ -126,6 +131,7 @@ def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
                     name=package_name,
                     version=package_version,
                     is_editable=is_editable,
+                    editable_location=editable_location,
                     constrained_dependencies=constrained_dependencies
                 )
 
@@ -788,7 +794,8 @@ def resolve_upgradable_packages(
             version=installed_pkg.version,
             upgradable=can_upgrade,
             latest_version=latest_version,
-            is_editable=installed_pkg.is_editable
+            is_editable=installed_pkg.is_editable,
+            editable_location=installed_pkg.editable_location
         ))
 
     return result
@@ -891,7 +898,8 @@ def resolve_upgradable_packages_with_reasons(
                 version=installed_pkg.version,
                 upgradable=True,
                 latest_version=latest_version,
-                is_editable=installed_pkg.is_editable
+                is_editable=installed_pkg.is_editable,
+                editable_location=installed_pkg.editable_location
             ))
         elif is_actual_upgrade:
             # Blocked package
@@ -901,7 +909,8 @@ def resolve_upgradable_packages_with_reasons(
                 version=installed_pkg.version,
                 latest_version=latest_version,
                 blocked_by=reasons,
-                is_editable=installed_pkg.is_editable
+                is_editable=installed_pkg.is_editable,
+                editable_location=installed_pkg.editable_location
             ))
 
     return upgradable, blocked
@@ -1035,7 +1044,8 @@ def install_packages(
                     version=pkg.version,
                     upgraded=False,
                     previous_version=pkg.version,
-                    is_editable=pkg.is_editable
+                    is_editable=pkg.is_editable,
+                    editable_location=pkg.editable_location
                 )
                 for pkg in packages_to_upgrade
             ]
@@ -1078,7 +1088,8 @@ def install_packages(
                     version=current_version,
                     upgraded=True,
                     previous_version=previous_version,
-                    is_editable=pkg_info.is_editable
+                    is_editable=pkg_info.is_editable,
+                    editable_location=pkg_info.editable_location
                 )
                 results.append(upgraded_pkg)
                 logger.info(f"Successfully upgraded {pkg_info.name} from {previous_version} to {current_version}")
@@ -1090,7 +1101,8 @@ def install_packages(
                     version=actual_version,
                     upgraded=False,
                     previous_version=previous_version,
-                    is_editable=pkg_info.is_editable
+                    is_editable=pkg_info.is_editable,
+                    editable_location=pkg_info.editable_location
                 )
                 results.append(upgraded_pkg)
                 logger.info(f"Package {pkg_info.name} was not upgraded (still at {actual_version})")
@@ -1119,7 +1131,8 @@ def install_packages(
                 version=pkg.version,
                 upgraded=False,
                 previous_version=pkg.version,
-                is_editable=pkg.is_editable
+                is_editable=pkg.is_editable,
+                editable_location=pkg.editable_location
             )
             for pkg in packages_to_upgrade
         ]
@@ -1139,7 +1152,139 @@ def install_packages(
                 version=pkg.version,
                 upgraded=False,
                 previous_version=pkg.version,
-                is_editable=pkg.is_editable
+                is_editable=pkg.is_editable,
+                editable_location=pkg.editable_location
             )
             for pkg in packages_to_upgrade
         ]
+
+
+def reinstall_editable_packages(
+    editable_packages: List[UpgradePackageInfo],
+    output_stream: Optional[OutputStream] = None,
+    timeout: int = 300,
+) -> List[UpgradedPackage]:
+    """
+    Reinstall editable packages to update their version metadata.
+
+    Uses `pip install --config-settings editable_mode=compat -e <path>` to reinstall
+    each editable package. This updates the package version in the environment
+    while maintaining the editable install.
+
+    :param editable_packages: List of UpgradePackageInfo objects for editable packages
+    :param output_stream: Optional stream implementing write() and flush() for live progress updates
+    :param timeout: Timeout in seconds for each installation (default: 300)
+    :returns: List of UpgradedPackage objects with upgrade status
+    """
+    if not editable_packages:
+        return []
+
+    results = []
+
+    for pkg in editable_packages:
+        if not pkg.editable_location:
+            logger.warning(f"Editable package {pkg.name} has no location, skipping")
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            continue
+
+        if output_stream:
+            output_stream.write(f"Reinstalling editable package: {pkg.name} from {pkg.editable_location}\n")
+            output_stream.flush()
+
+        cmd = [
+            sys.executable, '-m', 'pip', 'install',
+            '--config-settings', 'editable_mode=compat',
+            '-e', pkg.editable_location
+        ]
+
+        try:
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1
+            )
+
+            # Read output
+            stdout, stderr = process.communicate(timeout=timeout)
+            returncode = process.returncode
+
+            if output_stream and stdout:
+                output_stream.write(stdout)
+            if output_stream and stderr:
+                output_stream.write(stderr)
+            if output_stream:
+                output_stream.flush()
+
+            if returncode == 0:
+                # Get the new version after reinstall
+                env = get_default_environment()
+                canonical_name = canonicalize_name(pkg.name)
+                new_version = pkg.version  # Default to old version
+
+                for dist in env.iter_all_distributions():
+                    dist_name = dist.metadata.get("name", "")
+                    if canonicalize_name(dist_name) == canonical_name:
+                        try:
+                            new_version = Version(str(dist.version))
+                        except InvalidVersion:
+                            pass
+                        break
+
+                results.append(UpgradedPackage(
+                    name=pkg.name,
+                    version=new_version,
+                    upgraded=new_version > pkg.version,
+                    previous_version=pkg.version,
+                    is_editable=True,
+                    editable_location=pkg.editable_location
+                ))
+                logger.info(f"Reinstalled editable package {pkg.name}: {pkg.version} -> {new_version}")
+            else:
+                results.append(UpgradedPackage(
+                    name=pkg.name,
+                    version=pkg.version,
+                    upgraded=False,
+                    previous_version=pkg.version,
+                    is_editable=True,
+                    editable_location=pkg.editable_location
+                ))
+                logger.warning(f"Failed to reinstall editable package {pkg.name}")
+
+        except subprocess.TimeoutExpired:
+            if output_stream:
+                output_stream.write(f"ERROR: Timeout reinstalling {pkg.name}\n")
+                output_stream.flush()
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            logger.error(f"Timeout reinstalling editable package {pkg.name}")
+
+        except Exception as e:
+            if output_stream:
+                output_stream.write(f"ERROR: Failed to reinstall {pkg.name}: {e}\n")
+                output_stream.flush()
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            logger.error(f"Error reinstalling editable package {pkg.name}: {e}")
+
+    return results

{pipu_cli-0.2.0.dist-info → pipu_cli-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipu-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: A cute Python package updater
 Author-email: Scott Arne Johnson <scott.arne.johnson@gmail.com>
 License-Expression: MIT

pipu_cli-0.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+pipu_cli/__init__.py,sha256=DYhOEmnqarSXQjteuoviNNHqmkBb1xyBh7E49IDBJzs,1191
+pipu_cli/cache.py,sha256=d5BOItcJSlNfPEnYb4tbMmntzIDjWIl1ZUb5Xo5bJiQ,8243
+pipu_cli/cli.py,sha256=kj1ANOl_s-Ac02ZR-NLLREnM2_Av__KqMMBYr3cS2sY,34761
+pipu_cli/config.py,sha256=lixyWhJBz5GqdyRIygc4g5Wzc94HPC4sVFCgeINtQtw,1542
+pipu_cli/config_file.py,sha256=0vJbaDS4WDR4RRYA8gKLDtQRi-Stzm9a85qjmnNCqys,2186
+pipu_cli/output.py,sha256=9g64hxHIXxJlq0mmhRwZnbPMMGPpTfSRkH90rc-QPjA,3510
+pipu_cli/package_management.py,sha256=TXATyeu0RmoRbN1nsDKhZCwlnrZGgj-lK5GnL7opoh8,50661
+pipu_cli/pretty.py,sha256=6qBohKDtocm6vJc2rtH9RLgvvHYJiaGMnmhs6QyC0kE,9293
+pipu_cli/requirements.py,sha256=zbh7XwxD9he_5csJitEGT0NfiE4qbXPw_-JSDuHv4G8,2665
+pipu_cli/rollback.py,sha256=gL9ueYtAKDoALqRfJE2S5gnw1Id5QBLaPC1UL_WjzzY,2980
+pipu_cli-0.2.1.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
+pipu_cli-0.2.1.dist-info/METADATA,sha256=G39M3WDHd-oYkPEm4-pBTF6rlPNYIjUrKr717DyByVY,11919
+pipu_cli-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pipu_cli-0.2.1.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
+pipu_cli-0.2.1.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
+pipu_cli-0.2.1.dist-info/RECORD,,

pipu_cli-0.2.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-pipu_cli/__init__.py,sha256=oN3HVmBGVKNTLG_Ut4GZrH1W3EfUrK_MJqZQ1NIwOnc,1191
-pipu_cli/cache.py,sha256=kQa1GrrDcCT_CcJuMPX79BLBrcB55NArtxQTzzwyNOE,9199
-pipu_cli/cli.py,sha256=W1LNlo3zbO11x-AiFJHJY1Z2eFSNIVcnECLANNgPnwY,34807
-pipu_cli/config.py,sha256=lixyWhJBz5GqdyRIygc4g5Wzc94HPC4sVFCgeINtQtw,1542
-pipu_cli/config_file.py,sha256=2X2UqtJQV7M-czNTx_Hqu-rWLKkK7cn8l8kZ4HNbBkM,2196
-pipu_cli/output.py,sha256=9g64hxHIXxJlq0mmhRwZnbPMMGPpTfSRkH90rc-QPjA,3510
-pipu_cli/package_management.py,sha256=p4m7o5W-RZu4wOZMiU5Sp6WvvnZ2SbUoCIXqYIT3yQU,44822
-pipu_cli/pretty.py,sha256=6qBohKDtocm6vJc2rtH9RLgvvHYJiaGMnmhs6QyC0kE,9293
-pipu_cli/requirements.py,sha256=zbh7XwxD9he_5csJitEGT0NfiE4qbXPw_-JSDuHv4G8,2665
-pipu_cli/rollback.py,sha256=gL9ueYtAKDoALqRfJE2S5gnw1Id5QBLaPC1UL_WjzzY,2980
-pipu_cli-0.2.0.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
-pipu_cli-0.2.0.dist-info/METADATA,sha256=ZArCxjCSlgfz4uTSYb0Szpa3_fOjpOJqaNYxjLHF_jU,11919
-pipu_cli-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pipu_cli-0.2.0.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
-pipu_cli-0.2.0.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
-pipu_cli-0.2.0.dist-info/RECORD,,