dotx 3.2.1__tar.gz → 3.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.1
+Version: 3.3.0
 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.1 → dotx-3.3.0}/pyproject.toml

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

{dotx-3.2.1 → dotx-3.3.0}/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.2.1 → dotx-3.3.0}/src/dotx/commands/database.py

@@ -152,9 +152,13 @@ def register_commands(app: typer.Typer):
                 if issues:
                     console.print(f"\n[bold cyan]{pkg_name}:[/bold cyan]")
                     for issue in issues:
-                        console.print(f"  [red]✗[/red] {issue["target_path"]}")
-                        console.print(f"    [dim]Issue: {issue["issue"]}[/dim]")
-                        console.print(f"    [dim]Expected: {issue["link_type"]}[/dim]")
+                        console.print(f"  [red]✗[/red] {issue['target_path']}")
+                        console.print(f"    [dim]Issue: {issue['issue']}[/dim]")
+                        console.print(f"    [dim]Expected type: {issue['link_type']}[/dim]")
+                        if "expected" in issue:
+                            console.print(f"    [dim]Expected source: {issue['expected']}[/dim]")
+                        if "actual" in issue:
+                            console.print(f"    [dim]Actual target: {issue['actual']}[/dim]")
                     total_issues += len(issues)
 
             if total_issues == 0:
@@ -409,6 +413,7 @@ def register_commands(app: typer.Typer):
                 with InstallationDB() as db:
                     all_packages = db.get_all_packages()
                     total_would_clean = 0
+                    total_dangling_symlinks = 0
 
                     for pkg_info in all_packages:
                         pkg_root = Path(pkg_info["package_root"])
@@ -416,10 +421,16 @@ def register_commands(app: typer.Typer):
                         orphaned = db.get_orphaned_entries(pkg_root, pkg_name)
                         if orphaned:
                             total_would_clean += len(orphaned)
+                            # Count dangling symlinks that would be removed
+                            dangling = [e for e in orphaned if Path(e["target_path"]).is_symlink()]
+                            total_dangling_symlinks += len(dangling)
                             console.print(f"  {pkg_name}: {len(orphaned)} orphaned entry(ies)")
+                            if dangling and verbose:
+                                for entry in dangling:
+                                    console.print(f"    [dim]Would remove: {entry['target_path']}[/dim]")
 
                     if total_would_clean > 0:
-                        console.print(f"[yellow]Would remove {total_would_clean} orphaned entry(ies).[/yellow]")
+                        console.print(f"[yellow]Would remove {total_would_clean} orphaned DB entry(ies) and {total_dangling_symlinks} dangling symlink(s).[/yellow]")
                     else:
                         console.print("[green]No orphaned entries to clean.[/green]")
 
@@ -462,18 +473,37 @@ def register_commands(app: typer.Typer):
                 console.print("\n[cyan]Cleaning orphaned entries...[/cyan]")
                 all_packages = db.get_all_packages()
                 total_cleaned = 0
+                total_symlinks_removed = 0
 
                 for pkg_info in all_packages:
                     pkg_root = Path(pkg_info["package_root"])
                     pkg_name = pkg_info["package_name"]
+
+                    # Get orphaned entries before cleaning to remove dangling symlinks
+                    orphaned = db.get_orphaned_entries(pkg_root, pkg_name)
+
+                    # Remove dangling symlinks from filesystem
+                    for entry in orphaned:
+                        target_path = Path(entry["target_path"])
+                        if target_path.is_symlink():
+                            try:
+                                target_path.unlink()
+                                total_symlinks_removed += 1
+                                logger.info(f"Removed dangling symlink: {target_path}")
+                                if verbose:
+                                    console.print(f"  [dim]Removed: {target_path}[/dim]")
+                            except OSError as e:
+                                logger.warning(f"Failed to remove symlink {target_path}: {e}")
+
+                    # Clean database entries
                     cleaned = db.clean_orphaned_entries(pkg_root, pkg_name)
                     if cleaned > 0:
                         total_cleaned += cleaned
                         if verbose:
                             console.print(f"  Cleaned {cleaned} orphaned entry(ies) from {pkg_name}")
 
-                if total_cleaned > 0:
-                    console.print(f"[green]✓ Removed {total_cleaned} orphaned entry(ies).[/green]")
+                if total_cleaned > 0 or total_symlinks_removed > 0:
+                    console.print(f"[green]✓ Removed {total_cleaned} orphaned DB entry(ies) and {total_symlinks_removed} dangling symlink(s).[/green]")
                 else:
                     console.print("[green]✓ No orphaned entries found.[/green]")
 

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

@@ -56,10 +56,18 @@ def register_command(app: typer.Typer):
                 if failures:
                     can_install = False
                     console.print(
-                        f"[red]✗ Error: can't install {source_package.name} - would overwrite:[/red]"
+                        f"[red]✗ Error: can't install {source_package.name} - conflicts detected:[/red]"
                     )
                     for plan_node in failures:
-                        console.print(f"  {target_path / plan_node.relative_destination_path}")
+                        dest_path = target_path / plan_node.relative_destination_path
+                        if dest_path.is_symlink():
+                            try:
+                                link_target = dest_path.readlink()
+                                console.print(f"  {dest_path} [dim](symlink → {link_target})[/dim]")
+                            except OSError:
+                                console.print(f"  {dest_path} [dim](broken symlink)[/dim]")
+                        else:
+                            console.print(f"  {dest_path} [dim](existing file)[/dim]")
                     console.print()
 
             if can_install:

{dotx-3.2.1 → dotx-3.3.0}/src/dotx/database.py

@@ -315,12 +315,43 @@ class InstallationDB:
 
         return [dict(row) for row in cursor.fetchall()]
 
+    def _verify_symlink(self, target: Path, source_package_root: Path) -> dict | None:
+        """
+        Verify a symlink points to the correct source.
+
+        Returns an issue dict if there's a problem, None if symlink is correct.
+        """
+        try:
+            link_target = target.readlink()
+            actual_target = target.resolve()
+
+            # Check if it's a broken symlink (target doesn't exist)
+            if not actual_target.exists():
+                return {
+                    "issue": "Broken symlink (target missing)",
+                    "actual": str(link_target),
+                }
+
+            # Check if symlink points under source_package_root
+            try:
+                actual_target.relative_to(source_package_root)
+                return None  # Symlink is correct
+            except ValueError:
+                return {
+                    "issue": "Symlink points to wrong target",
+                    "expected": str(source_package_root),
+                    "actual": str(link_target),
+                }
+        except OSError:
+            return {"issue": "Cannot read symlink target"}
+
     def verify_installations(self, package_root: Path, package_name: str) -> list[dict]:
         """
         Verify installations for a package against filesystem.
 
         Checks if database records match actual filesystem state. Each issue
-        is a dict with keys: target_path, issue (description), and link_type.
+        is a dict with keys: target_path, issue (description), link_type, and
+        optionally expected/actual for symlink target mismatches.
         """
         if not self.conn:
             raise RuntimeError("Database not connected")
@@ -331,29 +362,37 @@ class InstallationDB:
         for install in installations:
             target = Path(install["target_path"])
             link_type = install["link_type"]
+            source_package_root = Path(install["source_package_root"])
 
-            # Check if file exists
-            if not target.exists():
-                issues.append({
-                    "target_path": str(target),
-                    "issue": "File missing (in DB but not on filesystem)",
-                    "link_type": link_type,
-                })
-                continue
-
-            # Check if it's a symlink (for file and directory types)
             if link_type in ("file", "directory"):
                 if not target.is_symlink():
+                    if target.exists():
+                        issue = "Not a symlink (regular file/dir exists instead)"
+                    else:
+                        issue = "Missing (not on filesystem)"
                     issues.append({
                         "target_path": str(target),
-                        "issue": "Not a symlink (should be symlink)",
+                        "issue": issue,
                         "link_type": link_type,
                     })
+                else:
+                    symlink_issue = self._verify_symlink(target, source_package_root)
+                    if symlink_issue:
+                        symlink_issue["target_path"] = str(target)
+                        symlink_issue["link_type"] = link_type
+                        issues.append(symlink_issue)
+
             elif link_type == "created_dir":
-                if not target.is_dir() or target.is_symlink():
+                if not target.exists():
+                    issue = "Missing (not on filesystem)"
+                elif not target.is_dir() or target.is_symlink():
+                    issue = "Not a regular directory (should be created dir)"
+                else:
+                    issue = None
+                if issue:
                     issues.append({
                         "target_path": str(target),
-                        "issue": "Not a regular directory (should be created dir)",
+                        "issue": issue,
                         "link_type": link_type,
                     })
 

{dotx-3.2.1 → dotx-3.3.0}/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")
@@ -147,19 +153,35 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
             # we can't link the whole directory - must CREATE it instead
             if plan[child_relative_source_path].requires_rename:
                 found_children_to_rename = True
-            # Fail if we would overwrite an existing regular file
-            destination_path = (
-                destination_root
-                / plan[child_relative_source_path].relative_destination_path
+            # Fail if we would overwrite an existing file or symlink pointing elsewhere
+            destination_path = resolve_destination(
+                plan[child_relative_source_path].relative_destination_path,
+                destination_root,
+                xdg_mode,
             )
-            if destination_path.exists() and destination_path.is_file():
+            if destination_path.is_symlink():
+                # Symlink exists - only OK if it already points to our source
+                expected_source = (
+                    source_package_root / plan[child_relative_source_path].relative_source_path
+                ).resolve()
+                try:
+                    actual_target = destination_path.resolve()
+                except OSError:
+                    # Broken symlink - treat as conflict
+                    actual_target = None
+                if actual_target == expected_source:
+                    # Already installed correctly - skip it
+                    plan[child_relative_source_path].action = Action.SKIP
+                else:
+                    plan[child_relative_source_path].action = Action.FAIL
+            elif destination_path.exists() and destination_path.is_file():
                 plan[child_relative_source_path].action = Action.FAIL
 
         # Second pass: decide action for current directory based on children and destination state
         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.1 → dotx-3.3.0}/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.1 → dotx-3.3.0}/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.1 → dotx-3.3.0}/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.1 → dotx-3.3.0/src/dotx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.1
+Version: 3.3.0
 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.1 → dotx-3.3.0}/tests/test_cli.py

@@ -42,9 +42,9 @@ def test_cli_install_conflict_detection(tmp_path):
 
     assert result.exit_code == 0  # CLI doesn't return error code, just refuses
     assert "can't install" in result.output.lower()
-    assert "would overwrite" in result.output.lower()
+    assert "conflicts detected" in result.output.lower()
+    assert "existing file" in result.output.lower()
     assert "Refusing to install" in result.output
-    assert "conflicts detected" in result.output
 
 
 def test_cli_install_with_verbose(tmp_path, isolated_db):
@@ -295,5 +295,97 @@ def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
     # Should clearly indicate dry-run mode
     assert "[DRY RUN]" in result.output
     assert "Would remove" in result.output
+    # Should show the rm command that would be executed
+    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"

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

@@ -117,6 +117,52 @@ def test_verify_not_symlink(tmp_path):
         assert "not a symlink" in issues[0]["issue"].lower()
 
 
+def test_verify_wrong_symlink_target(tmp_path):
+    """Test 'dotx verify' detects symlinks pointing to wrong target."""
+    db_path = tmp_path / "test.db"
+    package = tmp_path / "package"
+    package.mkdir()
+    (package / "dot-bashrc").write_text("# correct source")
+
+    target_file = tmp_path / ".bashrc"
+    # Create symlink pointing to wrong location
+    wrong_target = tmp_path / "wrong-file"
+    wrong_target.write_text("# wrong target")
+    target_file.symlink_to(wrong_target)
+
+    # Record as if it were pointing to package
+    with InstallationDB(db_path) as db:
+        db.record_installation(tmp_path, "package", package, target_file, "file")
+
+    # Verify - should detect wrong target
+    with InstallationDB(db_path) as db:
+        issues = db.verify_installations(tmp_path, "package")
+        assert len(issues) == 1
+        assert "wrong target" in issues[0]["issue"].lower()
+        assert "actual" in issues[0]
+
+
+def test_verify_broken_symlink(tmp_path):
+    """Test 'dotx verify' detects broken symlinks."""
+    db_path = tmp_path / "test.db"
+    package = tmp_path / "package"
+    package.mkdir()
+
+    target_file = tmp_path / ".bashrc"
+    # Create symlink pointing to nonexistent file
+    target_file.symlink_to("/nonexistent/path")
+
+    # Record installation
+    with InstallationDB(db_path) as db:
+        db.record_installation(tmp_path, "package", package, target_file, "file")
+
+    # Verify - should detect broken symlink
+    with InstallationDB(db_path) as db:
+        issues = db.verify_installations(tmp_path, "package")
+        assert len(issues) == 1
+        assert "broken" in issues[0]["issue"].lower()
+
+
 def test_show_package(tmp_path):
     """Test 'dotx show' displays package installation details."""
     db_path = tmp_path / "test.db"
@@ -557,7 +603,7 @@ def test_cli_sync_clean_dry_run(tmp_path, monkeypatch):
 
     assert result.exit_code == 0
     assert "Would clean orphaned entries" in result.output
-    assert "Would remove 1 orphaned entry(ies)" in result.output
+    assert "Would remove 1 orphaned DB entry(ies)" in result.output
     assert "Dry run" in result.output
 
 
@@ -604,7 +650,7 @@ def test_cli_sync_clean(tmp_path, monkeypatch):
 
     assert result.exit_code == 0
     assert "Cleaning orphaned entries" in result.output
-    assert "Removed 1 orphaned entry(ies)" in result.output
+    assert "Removed 1 orphaned DB entry(ies)" in result.output
 
     # Check database now has only 1 entry
     with InstallationDB() as db:

{dotx-3.2.1 → dotx-3.3.0}/tests/test_install.py

@@ -289,6 +289,59 @@ def test_install_normal_file_fail(tmp_path):
     )
 
 
+def test_install_symlink_to_wrong_target_fails(tmp_path):
+    """Test that existing symlink pointing to wrong target is marked FAIL."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a symlink pointing to a different location
+    wrong_target = tmp_path / "wrong_target"
+    wrong_target.write_text("wrong content")
+    (destination_root / file_path).symlink_to(wrong_target)
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.FAIL
+
+
+def test_install_broken_symlink_fails(tmp_path):
+    """Test that existing broken symlink is marked FAIL."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a broken symlink (target doesn't exist)
+    (destination_root / file_path).symlink_to("/nonexistent/path")
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.FAIL
+
+
+def test_install_symlink_to_our_source_skips(tmp_path):
+    """Test that existing symlink pointing to our source is marked SKIP."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a symlink pointing to our source (already installed)
+    (destination_root / file_path).symlink_to(source_package_root / file_path)
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.SKIP
+
+
 def test_install_hidden_file(tmp_path):
     source_package_root = tmp_path / "source"
     destination_root = tmp_path / "dest"
@@ -626,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")