dotx 3.2.2__tar.gz → 3.3.1__tar.gz

{dotx-3.2.2/src/dotx.egg-info → dotx-3.3.1}/PKG-INFO

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

{dotx-3.2.2 → dotx-3.3.1}/pyproject.toml

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

{dotx-3.2.2 → dotx-3.3.1}/src/dotx/cli.py

@@ -68,13 +68,20 @@ def main(
     target: Annotated[
         Path | None,
         typer.Option(
-            help="Where to install (defaults to $HOME)",
+            help="Where to install (defaults to $HOME). Mutually exclusive with --xdg.",
             exists=True,
             file_okay=False,
             dir_okay=True,
             writable=True,
         ),
     ] = None,
+    xdg: Annotated[
+        bool,
+        typer.Option(
+            "--xdg/--no-xdg",
+            help="Use XDG Base Directory paths (.config→$XDG_CONFIG_HOME, etc). Mutually exclusive with --target.",
+        ),
+    ] = False,
     dry_run: Annotated[
         bool,
         typer.Option("--dry-run/--no-dry-run", help="Just echo; don't actually (un)install"),
@@ -91,6 +98,10 @@ def main(
     """
     configure_logging(debug, verbose, log)
 
+    # Check mutual exclusivity
+    if xdg and target is not None:
+        raise typer.BadParameter("--xdg and --target are mutually exclusive")
+
     # Store options in context for commands to access
     ctx.ensure_object(dict)
     if target:
@@ -101,6 +112,7 @@ def main(
     set_option("DEBUG", debug, ctx)
     set_option("VERBOSE", verbose, ctx)
     set_option("DRYRUN", dry_run, ctx)
+    set_option("XDG", xdg, ctx)
 
     if log:
         set_option("LOG", log, ctx)

dotx-3.3.1/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.2.2 → dotx-3.3.1}/src/dotx/install.py

@@ -23,6 +23,7 @@ from loguru import logger
 
 from dotx.hierarchy import HierarchicalPatternMatcher
 from dotx.ignore import IgnoreRules
+from dotx.options import is_xdg_mode
 from dotx.plan import (
     Action,
     Plan,
@@ -30,6 +31,7 @@ from dotx.plan import (
     log_extracted_plan,
     mark_all_ancestors,
     mark_immediate_children,
+    resolve_destination,
 )
 
 
@@ -99,9 +101,13 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
     already exists at the destination, which must be created, renamed, linked, or already exist in a way that causes
     a failure.
 
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are resolved to their
+    respective XDG Base Directory paths when checking for existing files.
+
     Returns: a `Plan` with all the information needed to complete an install, or to fail
     """
     plan: Plan = plan_install_paths(source_package_root)
+    xdg_mode = is_xdg_mode()
 
     # Load always-create patterns to determine which directories must be real (never symlinked)
     always_create_matcher = HierarchicalPatternMatcher(".always-create")
@@ -148,9 +154,10 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
             if plan[child_relative_source_path].requires_rename:
                 found_children_to_rename = True
             # Fail if we would overwrite an existing file or symlink pointing elsewhere
-            destination_path = (
-                destination_root
-                / plan[child_relative_source_path].relative_destination_path
+            destination_path = resolve_destination(
+                plan[child_relative_source_path].relative_destination_path,
+                destination_root,
+                xdg_mode,
             )
             if destination_path.is_symlink():
                 # Symlink exists - only OK if it already points to our source
@@ -174,7 +181,7 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
         if current_root_path == source_package_root:
             # Package root always EXISTS (it's the target directory)
             plan[relative_root_path].action = Action.EXISTS
-        elif (destination_root / relative_destination_root_path).exists():
+        elif resolve_destination(relative_destination_root_path, destination_root, xdg_mode).exists():
             # Directory already exists at destination - merge into it
             # This takes precedence over always-create because we can't create what exists
             plan[relative_root_path].action = Action.EXISTS

{dotx-3.2.2 → dotx-3.3.1}/src/dotx/options.py

@@ -4,6 +4,7 @@ This module provides convenience functions for accessing user-data on the associ
 Note: typer is built on click, so we use click.Context for type annotations.
 """
 
+from pathlib import Path
 from typing import Any
 
 import click
@@ -36,7 +37,8 @@ def get_option(option: str, default_for_option: Any = None, ctx: click.Context |
     """
     if ctx is None:
         # Typer uses click under the hood, so we can use click's get_current_context
-        ctx = click.get_current_context()
+        # Use silent=True to return None instead of raising when no context exists
+        ctx = click.get_current_context(silent=True)
     if ctx is not None and ctx.obj is not None and option in ctx.obj:
         return ctx.obj[option]
     return default_for_option
@@ -55,3 +57,28 @@ def is_debug_mode(ctx: click.Context | None = None) -> bool:
 def is_dry_run(ctx: click.Context | None = None) -> bool:
     """Check if dry-run mode is enabled."""
     return get_option("DRYRUN", False, ctx)
+
+
+def is_xdg_mode(ctx: click.Context | None = None) -> bool:
+    """Check if XDG mode is enabled."""
+    return get_option("XDG", False, ctx)
+
+
+def get_xdg_paths() -> dict[str, Path]:
+    """
+    Get XDG Base Directory paths with defaults.
+
+    Returns a dict mapping destination prefixes to their XDG paths:
+    - ".config" → $XDG_CONFIG_HOME (default ~/.config)
+    - ".local/share" → $XDG_DATA_HOME (default ~/.local/share)
+    - ".cache" → $XDG_CACHE_HOME (default ~/.cache)
+    """
+    import os
+
+    home = Path.home()
+
+    return {
+        ".config": Path(os.environ.get("XDG_CONFIG_HOME", home / ".config")),
+        ".local/share": Path(os.environ.get("XDG_DATA_HOME", home / ".local/share")),
+        ".cache": Path(os.environ.get("XDG_CACHE_HOME", home / ".cache")),
+    }

{dotx-3.2.2 → dotx-3.3.1}/src/dotx/plan.py

@@ -34,7 +34,7 @@ from typing import TYPE_CHECKING
 from loguru import logger
 
 from dotx.database import NoOpDB
-from dotx.options import is_dry_run
+from dotx.options import is_dry_run, is_xdg_mode, get_xdg_paths
 
 if TYPE_CHECKING:
     from dotx.database import InstallationDB
@@ -91,6 +91,33 @@ class PlanNode:
 Plan = dict[Path, PlanNode]
 
 
+def resolve_destination(relative_path: Path, default_root: Path, xdg_mode: bool = False) -> Path:
+    """
+    Resolve the absolute destination path, respecting XDG mode.
+
+    In normal mode: default_root / relative_path
+    In XDG mode: redirects .config/*, .local/share/*, .cache/* to XDG directories
+    """
+    if not xdg_mode:
+        return default_root / relative_path
+
+    path_str = str(relative_path)
+    xdg_paths = get_xdg_paths()
+
+    # Check XDG prefixes in order of specificity (longer first)
+    for prefix in sorted(xdg_paths.keys(), key=len, reverse=True):
+        if path_str == prefix:
+            # Exact match - return the XDG dir itself
+            return xdg_paths[prefix]
+        if path_str.startswith(prefix + "/"):
+            # Path under XDG dir - remap it
+            suffix = path_str[len(prefix) + 1:]
+            return xdg_paths[prefix] / suffix
+
+    # No XDG prefix match - use default (HOME)
+    return default_root / relative_path
+
+
 def execute_plan(
     source_package_root: Path,
     destination_root: Path,
@@ -104,18 +131,28 @@ def execute_plan(
     links, or unlinks files using pathlib native functions.
 
     If a database is provided, records installations (CREATE, LINK) and removals (UNLINK).
+
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are redirected
+    to their respective XDG Base Directory paths.
     """
     # Use NoOpDB if no database provided
     working_db = db if db is not None else NoOpDB()
 
+    # Check XDG mode
+    xdg_mode = is_xdg_mode()
+
     # Extract package info for database tracking
     package_root = source_package_root.parent
     package_name = source_package_root.name
 
+    def get_destination(step: PlanNode) -> Path:
+        """Get the absolute destination path, respecting XDG mode."""
+        return resolve_destination(step.relative_destination_path, destination_root, xdg_mode)
+
     def build_shell_command(step: PlanNode):
         """Print the shell command corresponding to exactly one `PlanNode`"""
         command = None
-        destination = destination_root / step.relative_destination_path
+        destination = get_destination(step)
         source = (source_package_root / step.relative_source_path).resolve()
         try:
             source = source.relative_to(destination.parent)
@@ -147,7 +184,7 @@ def execute_plan(
 
         Records installations and removals in database.
         """
-        destination = destination_root / step.relative_destination_path
+        destination = get_destination(step)
         source = (source_package_root / step.relative_source_path).resolve()
         try:
             source = source.relative_to(destination.parent)

{dotx-3.2.2 → dotx-3.3.1}/src/dotx/uninstall.py

@@ -11,7 +11,8 @@ Exported functions:
 import os
 from pathlib import Path
 
-from dotx.plan import Action, Plan, mark_all_descendents
+from dotx.options import is_xdg_mode
+from dotx.plan import Action, Plan, mark_all_descendents, resolve_destination
 from dotx.install import plan_install_paths
 
 
@@ -19,9 +20,13 @@ def plan_uninstall(source_package_root: Path, destination_root: Path) -> Plan:
     """
     Create a plan to uninstall files from destination_root that link to source_package_root.
 
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are resolved to their
+    respective XDG Base Directory paths when checking for symlinks to remove.
+
     Returns: a `Plan` with actions set to UNLINK for symlinks pointing to the source package
     """
     plan: Plan = plan_install_paths(source_package_root)
+    xdg_mode = is_xdg_mode()
 
     for current_root, _, child_files in os.walk(source_package_root):
         current_root_path = Path(current_root)
@@ -36,15 +41,18 @@ def plan_uninstall(source_package_root: Path, destination_root: Path) -> Plan:
             child_relative_source_path = relative_root_path / child
             if child_relative_source_path not in plan:
                 continue
-            destination_path = (
-                destination_root
-                / plan[child_relative_source_path].relative_destination_path
+            destination_path = resolve_destination(
+                plan[child_relative_source_path].relative_destination_path,
+                destination_root,
+                xdg_mode,
             )
             if destination_path.is_symlink():
                 plan[child_relative_source_path].action = Action.UNLINK
 
-        destination_path = (
-            destination_root / plan[relative_root_path].relative_destination_path
+        destination_path = resolve_destination(
+            plan[relative_root_path].relative_destination_path,
+            destination_root,
+            xdg_mode,
         )
         action = None
         if not destination_path.exists():

{dotx-3.2.2 → dotx-3.3.1/src/dotx.egg-info}/PKG-INFO

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

{dotx-3.2.2 → dotx-3.3.1}/tests/test_cli.py

@@ -299,3 +299,159 @@ def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
     assert "rm" in result.output
     # File should still exist after dry-run
     assert (target / "file1").exists()
+
+
+def test_cli_xdg_and_target_mutually_exclusive(tmp_path, isolated_db):
+    """Test that --xdg and --target cannot be used together."""
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "file1").write_text("content")
+
+    runner = CliRunner()
+
+    # Try to use both --xdg and --target
+    result = runner.invoke(app, ["--xdg", f"--target={tmp_path}", "install", str(source)])
+
+    assert result.exit_code != 0
+    assert "mutually exclusive" in result.output.lower()
+
+
+def _has_symlink_ancestor(path: Path) -> bool:
+    """Check if any ancestor of path is a symlink."""
+    for parent in path.parents:
+        if parent.is_symlink():
+            return True
+    return path.is_symlink()
+
+
+def test_cli_xdg_mode_install_to_xdg_paths(tmp_path, monkeypatch, isolated_db):
+    """Test that --xdg mode installs .config files to XDG_CONFIG_HOME."""
+    source = tmp_path / "source"
+    source.mkdir()
+
+    # Create .config/app directory with config file
+    config_dir = source / "dot-config" / "myapp"
+    config_dir.mkdir(parents=True)
+    (config_dir / "config.toml").write_text("setting = true")
+
+    # Set custom XDG_CONFIG_HOME
+    custom_config = tmp_path / "custom-config"
+    custom_config.mkdir()
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(custom_config))
+
+    runner = CliRunner()
+
+    # Install with --xdg mode
+    result = runner.invoke(app, ["--xdg", "install", str(source)])
+
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # File should be accessible at XDG path
+    config_file = custom_config / "myapp" / "config.toml"
+    assert config_file.exists(), "config.toml should be accessible at XDG path"
+
+    # File should be connected to source via symlink (either directly or via ancestor)
+    assert _has_symlink_ancestor(config_file), "File or ancestor should be a symlink"
+
+    # Content should match source
+    assert config_file.read_text() == "setting = true"
+
+
+def test_cli_xdg_mode_install_and_uninstall_roundtrip(tmp_path, monkeypatch, isolated_db):
+    """Test that --xdg mode works for both install and uninstall."""
+    source = tmp_path / "source"
+    source.mkdir()
+
+    # Create .config/app directory with config file
+    config_dir = source / "dot-config" / "myapp"
+    config_dir.mkdir(parents=True)
+    (config_dir / "config.toml").write_text("setting = true")
+
+    # Set custom XDG_CONFIG_HOME
+    custom_config = tmp_path / "custom-config"
+    custom_config.mkdir()
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(custom_config))
+
+    runner = CliRunner()
+
+    # Install with --xdg mode
+    result = runner.invoke(app, ["--xdg", "install", str(source)])
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # Verify file is installed and accessible
+    config_file = custom_config / "myapp" / "config.toml"
+    assert config_file.exists(), "File should be accessible at XDG path"
+    assert _has_symlink_ancestor(config_file), "File or ancestor should be a symlink"
+
+    # Uninstall with --xdg mode
+    result = runner.invoke(app, ["--xdg", "uninstall", str(source)])
+    assert result.exit_code == 0, f"Uninstall failed: {result.output}"
+
+    # 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.2.2 → dotx-3.3.1}/tests/test_install.py

@@ -679,3 +679,91 @@ def test_install_deep_nesting_execute(tmp_path, isolated_db):
     assert deep_file_dest.is_symlink()
     assert deep_file_dest.exists()
     assert deep_file_dest.read_text() == "deep content"
+
+
+# --- XDG Mode Tests ---
+
+
+def test_resolve_destination_no_xdg():
+    """Test that resolve_destination without XDG mode just joins paths."""
+    from dotx.plan import resolve_destination
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config/app/config.toml")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=False)
+
+    assert result == Path("/home/user/.config/app/config.toml")
+
+
+def test_resolve_destination_xdg_config(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .config paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_CONFIG_HOME
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config/app/config.toml")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/config/app/config.toml")
+
+
+def test_resolve_destination_xdg_data(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .local/share paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_DATA_HOME
+    monkeypatch.setenv("XDG_DATA_HOME", "/custom/data")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".local/share/app/data.db")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/data/app/data.db")
+
+
+def test_resolve_destination_xdg_cache(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .cache paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_CACHE_HOME
+    monkeypatch.setenv("XDG_CACHE_HOME", "/custom/cache")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".cache/app/cache.db")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/cache/app/cache.db")
+
+
+def test_resolve_destination_xdg_non_xdg_path(monkeypatch):
+    """Test that paths not matching XDG prefixes still use default_root in XDG mode."""
+    from dotx.plan import resolve_destination
+
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".bashrc")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/home/user/.bashrc")
+
+
+def test_resolve_destination_xdg_exact_match(monkeypatch):
+    """Test that exact XDG prefix paths resolve to XDG directory itself."""
+    from dotx.plan import resolve_destination
+
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/config")

dotx-3.2.2/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")