dotx 3.2.0__tar.gz → 3.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.0
+Version: 3.2.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -58,6 +58,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

{dotx-3.2.0 → dotx-3.2.2}/README.md

@@ -30,6 +30,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

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

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

{dotx-3.2.0 → dotx-3.2.2}/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.0 → dotx-3.2.2}/src/dotx/commands/install_cmd.py

@@ -10,7 +10,7 @@ from rich.console import Console
 from dotx.commands.progress import execute_plans_with_progress
 from dotx.database import InstallationDB
 from dotx.install import plan_install
-from dotx.options import is_verbose_mode
+from dotx.options import is_dry_run, is_verbose_mode
 from dotx.plan import Action, Plan, extract_plan, log_extracted_plan
 
 
@@ -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:
@@ -92,7 +100,10 @@ def register_command(app: typer.Typer):
                     summary_parts.append(f"{total_dirs} dir(s)")
 
                 summary = " and ".join(summary_parts) if summary_parts else "nothing"
-                console.print(f"\n[green]✓ Installed {summary} from {len(sources)} package(s)[/green]")
+                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("[red]✗ Refusing to install - conflicts detected[/red]")
 

{dotx-3.2.0 → dotx-3.2.2}/src/dotx/commands/uninstall_cmd.py

@@ -9,7 +9,7 @@ from rich.console import Console
 
 from dotx.commands.progress import execute_plans_with_progress
 from dotx.database import InstallationDB
-from dotx.options import is_verbose_mode
+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
 
@@ -67,6 +67,9 @@ def register_command(app: typer.Typer):
                 len(extract_plan(plan, {Action.UNLINK}))
                 for _, plan in plans
             )
-            console.print(f"\n[green]✓ Removed {total_removed} symlink(s) from {len(sources)} package(s)[/green]")
+            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")

{dotx-3.2.0 → dotx-3.2.2}/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.0 → dotx-3.2.2}/src/dotx/install.py

@@ -147,12 +147,27 @@ 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
+            # Fail if we would overwrite an existing file or symlink pointing elsewhere
             destination_path = (
                 destination_root
                 / plan[child_relative_source_path].relative_destination_path
             )
-            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
@@ -193,8 +208,9 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
                 plan=plan,
             )
             logger.debug(f"Directory {relative_destination_root_path} matches always-create pattern, will CREATE")
-        else:
+        elif plan[relative_root_path].action != Action.CREATE:
             # Directory doesn't exist and has no rename conflicts - we can link it
+            # But only if it wasn't already marked CREATE by a descendant's mark_all_ancestors
             plan[relative_root_path].action = Action.LINK
 
         # Third pass: mark children based on what we decided for this directory

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

@@ -183,11 +183,12 @@ def execute_plan(
     # This does duplicate the loop code, but avoids thousands of repeated is_dry_run() calls
     # in installations with many files.
     if is_dry_run():
+        print("[DRY RUN] Would execute the equivalent of:")
         for step in steps:
             command = build_shell_command(step)
             if command is not None:
                 logger.info(command)
-                print(command)
+                print(f"  {command}")
     else:
         for step in steps:
             command = build_shell_command(step)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.0
+Version: 3.2.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -58,6 +58,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

{dotx-3.2.0 → dotx-3.2.2}/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):
@@ -246,3 +246,56 @@ def test_options_functions():
     result = runner.invoke(app, ["--verbose", "--debug", "--dry-run", "debug"])
 
     assert len(result.output) == 0
+
+
+def test_cli_install_dry_run_shows_indicator(tmp_path):
+    """Test install with --dry-run clearly indicates dry-run mode in output."""
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create source file
+    (source / "file1").write_text("content1")
+
+    runner = CliRunner()
+
+    # Install with --dry-run
+    result = runner.invoke(app, [f"--target={target}", "--dry-run", "install", str(source)])
+
+    assert result.exit_code == 0
+    # Should clearly indicate dry-run mode
+    assert "[DRY RUN]" in result.output
+    assert "Would install" in result.output
+    # File should NOT actually be created
+    assert not (target / "file1").exists()
+
+
+def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
+    """Test uninstall with --dry-run clearly indicates dry-run mode in output."""
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create and install source file
+    (source / "file1").write_text("content1")
+
+    runner = CliRunner()
+
+    # First install for real
+    result = runner.invoke(app, [f"--target={target}", "install", str(source)])
+    assert result.exit_code == 0
+    assert (target / "file1").exists()
+
+    # Uninstall with --dry-run
+    result = runner.invoke(app, [f"--target={target}", "--dry-run", "uninstall", str(source)])
+
+    assert result.exit_code == 0
+    # 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()

{dotx-3.2.0 → dotx-3.2.2}/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.0 → dotx-3.2.2}/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"
@@ -543,3 +596,86 @@ def test_install_renamed_dir_inside_renamed_dir(tmp_path):
         Action.LINK, True, dir2_path, Path(".SIMPLE-DIR1/.SIMPLE-DIR2"), True
     )
     assert plan[file_path].action == Action.SKIP
+
+
+def test_install_deep_nesting_with_renamed_leaf(tmp_path):
+    """
+    Test that deeply nested directories with a renamed file at the leaf install correctly.
+
+    This tests the fix for a bug where:
+    - Deep directory structure: a/b/c/d/e/f/dot-deepfile
+    - The leaf file needs renaming (dot-deepfile -> .deepfile)
+    - Directory f gets marked CREATE (because child needs renaming)
+    - All parent directories should also be CREATE (via mark_all_ancestors)
+
+    Bug was: parent dirs were overwritten to LINK when processed bottom-up,
+    causing FileExistsError when we tried to CREATE f under a symlinked parent.
+
+    Fix: preserve CREATE if already set by a descendant's mark_all_ancestors.
+    """
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+
+    # Create deep nesting: a/b/c/d/e/f/dot-deepfile
+    deep_path = Path("a/b/c/d/e/f")
+    file_path = deep_path / "dot-deepfile"
+    (source_package_root / deep_path).mkdir(parents=True)
+    (source_package_root / file_path).write_text("deep content")
+
+    plan = plan_install(source_package_root, destination_root)
+
+    # All directories should be CREATE (to support the renamed file at the leaf)
+    for part_count in range(1, 7):  # a, b, c, d, e, f
+        parts = ["a", "b", "c", "d", "e", "f"][:part_count]
+        subdir_path = Path("/".join(parts))
+        assert plan[subdir_path].action == Action.CREATE, f"{subdir_path} should be CREATE"
+
+    # The file should be LINK with renaming
+    assert plan[file_path].action == Action.LINK
+    assert plan[file_path].requires_rename
+    assert plan[file_path].relative_destination_path == Path("a/b/c/d/e/f/.deepfile")
+
+
+def test_install_deep_nesting_execute(tmp_path, isolated_db):
+    """
+    Test that deeply nested directories with renamed leaf actually install without error.
+
+    This is an integration test that verifies the full install flow works,
+    not just the planning phase.
+    """
+    from typer.testing import CliRunner
+
+    from dotx.cli import app
+
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+
+    # Create deep nesting: a/b/c/d/e/f/dot-deepfile
+    deep_path = Path("a/b/c/d/e/f")
+    file_path = deep_path / "dot-deepfile"
+    (source_package_root / deep_path).mkdir(parents=True)
+    (source_package_root / file_path).write_text("deep content")
+
+    runner = CliRunner()
+
+    # Execute install via CLI - should not raise an error
+    result = runner.invoke(app, [f"--target={destination_root}", "install", str(source_package_root)])
+
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # Verify: all directories should be real directories (CREATE), not symlinks
+    for part_count in range(1, 7):
+        parts = ["a", "b", "c", "d", "e", "f"][:part_count]
+        dir_path = destination_root / "/".join(parts)
+        assert dir_path.is_dir(), f"{dir_path} should be a directory"
+        assert not dir_path.is_symlink(), f"{dir_path} should NOT be a symlink"
+
+    # The file should be a symlink with the renamed name (.deepfile, not dot-deepfile)
+    deep_file_dest = destination_root / "a/b/c/d/e/f/.deepfile"
+    assert deep_file_dest.is_symlink()
+    assert deep_file_dest.exists()
+    assert deep_file_dest.read_text() == "deep content"