dotx 3.3.0__tar.gz → 3.3.2__tar.gz

{dotx-3.3.0/src/dotx.egg-info → dotx-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.3.0
+Version: 3.3.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT

{dotx-3.3.0 → dotx-3.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotx"
-version = "3.3.0"
+version = "3.3.2"
 description = "A command-line tool to install a link-farm to your dotfiles"
 authors = [
     { name = "Wolf", email = "Wolf@zv.cx" }

{dotx-3.3.0 → dotx-3.3.2}/src/dotx/commands/database.py

@@ -85,7 +85,7 @@ def register_commands(app: typer.Typer):
             packages = db.get_all_packages()
 
             if not packages:
-                console.print("[yellow]No packages installed.[/yellow]")
+                console.print("[yellow]No packages in database. Run `dotx sync --package-root <dir>` to rebuild from existing symlinks.[/yellow]")
                 return
 
             if as_commands:
@@ -100,17 +100,30 @@ def register_commands(app: typer.Typer):
                 table.add_column("Package", style="cyan", no_wrap=True)
                 table.add_column("Files", justify="right", style="magenta")
                 table.add_column("Last Install", style="green")
+                table.add_column("Status", style="green")
 
+                missing_count = 0
                 for pkg in packages:
                     # Show full package path (package_root / package_name) as documented
-                    package_path = str(Path(pkg["package_root"]) / pkg["package_name"])
+                    package_path = Path(pkg["package_root"]) / pkg["package_name"]
                     file_count = str(pkg["file_count"])
                     latest = _format_timestamp(pkg["latest_install"])
-                    table.add_row(package_path, file_count, latest)
+
+                    # Check if source still exists
+                    if package_path.exists():
+                        status = "[green]✓[/green]"
+                    else:
+                        status = "[yellow]⚠ source missing[/yellow]"
+                        missing_count += 1
+
+                    table.add_row(str(package_path), file_count, latest, status)
 
                 console.print()
                 console.print(table)
-                console.print(f"\n[bold]Total: {len(packages)} package(s)[/bold]\n")
+                console.print(f"\n[bold]Total: {len(packages)} package(s)[/bold]")
+                if missing_count > 0:
+                    console.print(f"[yellow]⚠ {missing_count} package(s) have missing source directories. Run `dotx verify` for details.[/yellow]")
+                console.print()
 
         logger.info("list finished")
 

{dotx-3.3.0 → dotx-3.3.2}/src/dotx/commands/install_cmd.py

@@ -99,11 +99,18 @@ def register_command(app: typer.Typer):
                 if total_dirs:
                     summary_parts.append(f"{total_dirs} dir(s)")
 
-                summary = " and ".join(summary_parts) if summary_parts else "nothing"
-                if is_dry_run(ctx):
-                    console.print(f"\n[yellow][DRY RUN] Would install {summary} from {len(sources)} package(s)[/yellow]")
+                if summary_parts:
+                    summary = " and ".join(summary_parts)
+                    if is_dry_run(ctx):
+                        console.print(f"\n[yellow][DRY RUN] Would install {summary} from {len(sources)} package(s)[/yellow]")
+                    else:
+                        console.print(f"\n[green]✓ Installed {summary} from {len(sources)} package(s)[/green]")
                 else:
-                    console.print(f"\n[green]✓ Installed {summary} from {len(sources)} package(s)[/green]")
+                    # Empty package(s) - nothing to install
+                    if is_dry_run(ctx):
+                        console.print(f"\n[yellow][DRY RUN] Would install nothing from {len(sources)} package(s) (nothing to record in database)[/yellow]")
+                    else:
+                        console.print(f"\n[green]✓ Installed nothing from {len(sources)} package(s) (nothing to record in database)[/green]")
             else:
                 console.print("[red]✗ Refusing to install - conflicts detected[/red]")
 

dotx-3.3.2/src/dotx/commands/uninstall_cmd.py

@@ -0,0 +1,155 @@
+"""Uninstall command for dotx CLI."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from loguru import logger
+from rich.console import Console
+
+from dotx.commands.progress import execute_plans_with_progress
+from dotx.database import InstallationDB
+from dotx.options import is_dry_run, is_verbose_mode
+from dotx.plan import Action, Plan, extract_plan, log_extracted_plan
+from dotx.uninstall import plan_uninstall
+
+
+def _uninstall_from_database(
+    package_path: Path,
+    db: InstallationDB,
+    console: Console,
+    dry_run: bool,
+    verbose: bool,
+) -> int:
+    """
+    Uninstall a package using database records when source directory is missing.
+
+    Returns the number of symlinks removed.
+    """
+    package_root = package_path.parent
+    package_name = package_path.name
+
+    installations = db.get_installations(package_root, package_name)
+
+    if not installations:
+        console.print(f"[yellow]No installations found for {package_name}[/yellow]")
+        return 0
+
+    removed_count = 0
+
+    for entry in installations:
+        target_path = Path(entry["target_path"])
+
+        if dry_run:
+            if target_path.is_symlink():
+                console.print(f"  rm {target_path}")
+                removed_count += 1
+            elif verbose:
+                console.print(f"  [dim]skip (not a symlink): {target_path}[/dim]")
+        else:
+            if target_path.is_symlink():
+                try:
+                    target_path.unlink()
+                    db.remove_installation(target_path)
+                    removed_count += 1
+                    if verbose:
+                        console.print(f"  Removed: {target_path}")
+                except OSError as e:
+                    logger.warning(f"Failed to remove {target_path}: {e}")
+            else:
+                # Not a symlink - just remove from database
+                db.remove_installation(target_path)
+                if verbose:
+                    console.print(f"  [dim]Cleaned db entry (not a symlink): {target_path}[/dim]")
+
+    return removed_count
+
+
+def register_command(app: typer.Typer):
+    """Register the uninstall command with the Typer app."""
+
+    @app.command()
+    def uninstall(
+        ctx: typer.Context,
+        sources: Annotated[
+            list[Path],
+            typer.Argument(
+                help="Source package directories to uninstall (can be deleted)",
+            ),
+        ],
+    ):
+        """
+        Uninstall source packages from target directory.
+
+        If the source package directory still exists, uninstalls by scanning it.
+        If the source has been deleted, uninstalls using database records.
+        """
+        logger.info("uninstall starting")
+        console = Console()
+        verbose = is_verbose_mode(ctx)
+        dry_run = is_dry_run(ctx)
+
+        # Get target from options
+        target_path = Path(ctx.obj.get("TARGET", Path.home())) if ctx.obj else Path.home()
+
+        if not sources:
+            logger.info("uninstall finished (no sources)")
+            return
+
+        # Partition sources using set math
+        sources_set = set(sources)
+        existing_sources = {s for s in sources_set if s.exists() and s.is_dir()}
+        missing_sources = sources_set - existing_sources
+
+        total_removed = 0
+
+        # Handle existing sources with plan-based uninstall
+        if existing_sources:
+            plans: list[tuple[Path, Plan]] = []
+            for source_package in existing_sources:
+                plan: Plan = plan_uninstall(source_package, target_path)
+                log_extracted_plan(
+                    plan,
+                    description=f"Actual plan to uninstall {source_package}",
+                    actions_to_extract={Action.UNLINK},
+                )
+                plans.append((source_package, plan))
+
+            with InstallationDB() as db:
+                execute_plans_with_progress(
+                    plans,
+                    target_path,
+                    {Action.UNLINK},
+                    "Uninstalling",
+                    console,
+                    verbose,
+                    db,
+                )
+
+            total_removed += sum(
+                len(extract_plan(plan, {Action.UNLINK}))
+                for _, plan in plans
+            )
+
+        # Handle missing sources with database-based uninstall
+        if missing_sources:
+            if dry_run:
+                console.print("\n[yellow][DRY RUN] Would execute the equivalent of:[/yellow]")
+
+            with InstallationDB() as db:
+                for source_package in missing_sources:
+                    if verbose or dry_run:
+                        console.print(f"\n[cyan]Uninstalling {source_package.name} (source deleted)...[/cyan]")
+
+                    removed = _uninstall_from_database(
+                        source_package, db, console, dry_run, verbose
+                    )
+                    total_removed += removed
+
+        # Show summary
+        if dry_run:
+            console.print(f"\n[yellow][DRY RUN] Would remove {total_removed} symlink(s) from {len(sources)} package(s)[/yellow]")
+        else:
+            console.print(f"\n[green]✓ Removed {total_removed} symlink(s) from {len(sources)} package(s)[/green]")
+
+        logger.info("uninstall finished")

{dotx-3.3.0 → dotx-3.3.2/src/dotx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.3.0
+Version: 3.3.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT

{dotx-3.3.0 → dotx-3.3.2}/tests/test_cli.py

@@ -389,3 +389,69 @@ def test_cli_xdg_mode_install_and_uninstall_roundtrip(tmp_path, monkeypatch, iso
 
     # File should be removed (not accessible anymore)
     assert not config_file.exists(), "File should be removed after uninstall"
+
+
+def test_cli_uninstall_with_deleted_source(tmp_path, isolated_db):
+    """Test that uninstall works even when source package has been deleted."""
+    import shutil
+
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create source files
+    (source / "file1.txt").write_text("content1")
+    (source / "file2.txt").write_text("content2")
+
+    runner = CliRunner()
+
+    # Install the package
+    result = runner.invoke(app, [f"--target={target}", "install", str(source)])
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # Verify files are installed
+    assert (target / "file1.txt").is_symlink()
+    assert (target / "file2.txt").is_symlink()
+
+    # Delete the source package
+    shutil.rmtree(source)
+    assert not source.exists()
+
+    # Uninstall should still work using database (use --verbose to see "source deleted" message)
+    result = runner.invoke(app, [f"--target={target}", "--verbose", "uninstall", str(source)])
+    assert result.exit_code == 0, f"Uninstall failed: {result.output}"
+    assert "source deleted" in result.output.lower()
+
+    # Symlinks should be removed (not just broken)
+    assert not (target / "file1.txt").is_symlink()
+    assert not (target / "file2.txt").is_symlink()
+
+
+def test_cli_uninstall_deleted_source_dry_run(tmp_path, isolated_db):
+    """Test dry-run uninstall with deleted source shows correct output."""
+    import shutil
+
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create and install
+    (source / "file1.txt").write_text("content")
+
+    runner = CliRunner()
+    result = runner.invoke(app, [f"--target={target}", "install", str(source)])
+    assert result.exit_code == 0
+
+    # Delete source
+    shutil.rmtree(source)
+
+    # Dry-run uninstall
+    result = runner.invoke(app, [f"--target={target}", "--dry-run", "uninstall", str(source)])
+    assert result.exit_code == 0
+    assert "[DRY RUN]" in result.output
+    assert "rm" in result.output
+
+    # Symlink should still exist after dry-run (even though it's broken)
+    assert (target / "file1.txt").is_symlink()

{dotx-3.3.0 → dotx-3.3.2}/tests/test_cli_database.py

@@ -301,7 +301,7 @@ def test_cli_list_no_packages(tmp_path, monkeypatch):
     result = runner.invoke(app, ["list"])
 
     assert result.exit_code == 0
-    assert "No packages installed" in result.output
+    assert "No packages in database" in result.output
 
 
 def test_cli_list_with_packages(tmp_path, monkeypatch):
@@ -866,3 +866,44 @@ def test_list_shows_correct_package_names_after_install(tmp_path, monkeypatch):
     result = runner.invoke(app, ["list"])
     assert result.exit_code == 0, f"list failed: {result.output}"
     assert "2 package(s)" in result.output  # Should show 2 packages
+
+
+def test_cli_list_shows_missing_source_status(tmp_path, monkeypatch):
+    """Test 'dotx list' shows status indicator when source package is missing."""
+    import shutil
+
+    # Override XDG_DATA_HOME
+    data_dir = tmp_path / "config"
+    data_dir.mkdir()
+    monkeypatch.setenv("XDG_DATA_HOME", str(data_dir))
+
+    # Create and install packages
+    source1 = tmp_path / "source1"
+    source1.mkdir()
+    (source1 / "file1").write_text("content")
+
+    source2 = tmp_path / "source2"
+    source2.mkdir()
+    (source2 / "file2").write_text("content")
+
+    target = tmp_path / "target"
+    target.mkdir()
+
+    runner = CliRunner()
+
+    # Install both packages
+    result = runner.invoke(app, [f"--target={target}", "install", str(source1)])
+    assert result.exit_code == 0
+    result = runner.invoke(app, [f"--target={target}", "install", str(source2)])
+    assert result.exit_code == 0
+
+    # Delete one source package
+    shutil.rmtree(source1)
+    assert not source1.exists()
+
+    # List packages - should show warning for missing source
+    result = runner.invoke(app, ["list"])
+    assert result.exit_code == 0
+    # The warning message at the bottom should be visible
+    assert "1 package(s) have missing source directories" in result.output
+    assert "dotx verify" in result.output

dotx-3.3.0/src/dotx/commands/uninstall_cmd.py

@@ -1,75 +0,0 @@
-"""Uninstall command for dotx CLI."""
-
-from pathlib import Path
-from typing import Annotated
-
-import typer
-from loguru import logger
-from rich.console import Console
-
-from dotx.commands.progress import execute_plans_with_progress
-from dotx.database import InstallationDB
-from dotx.options import is_dry_run, is_verbose_mode
-from dotx.plan import Action, Plan, extract_plan, log_extracted_plan
-from dotx.uninstall import plan_uninstall
-
-
-def register_command(app: typer.Typer):
-    """Register the uninstall command with the Typer app."""
-
-    @app.command()
-    def uninstall(
-        ctx: typer.Context,
-        sources: Annotated[
-            list[Path],
-            typer.Argument(
-                help="Source package directories to uninstall",
-                exists=True,
-                file_okay=False,
-                dir_okay=True,
-                readable=True,
-            ),
-        ],
-    ):
-        """Uninstall source packages from target directory."""
-        logger.info("uninstall starting")
-        console = Console()
-        verbose = is_verbose_mode(ctx)
-
-        # Get target from options
-        target_path = Path(ctx.obj.get("TARGET", Path.home())) if ctx.obj else Path.home()
-
-        if sources:
-            plans: list[tuple[Path, Plan]] = []
-            for source_package in sources:
-                plan: Plan = plan_uninstall(source_package, target_path)
-                log_extracted_plan(
-                    plan,
-                    description=f"Actual plan to uninstall {source_package}",
-                    actions_to_extract={Action.UNLINK},
-                )
-                plans.append((source_package, plan))
-
-            # Open database and execute all plans with progress
-            with InstallationDB() as db:
-                execute_plans_with_progress(
-                    plans,
-                    target_path,
-                    {Action.UNLINK},
-                    "Uninstalling",
-                    console,
-                    verbose,
-                    db,
-                )
-
-            # Show summary
-            total_removed = sum(
-                len(extract_plan(plan, {Action.UNLINK}))
-                for _, plan in plans
-            )
-            if is_dry_run(ctx):
-                console.print(f"\n[yellow][DRY RUN] Would remove {total_removed} symlink(s) from {len(sources)} package(s)[/yellow]")
-            else:
-                console.print(f"\n[green]✓ Removed {total_removed} symlink(s) from {len(sources)} package(s)[/green]")
-
-        logger.info("uninstall finished")