dotman-cli 0.2.7__tar.gz → 0.2.9__tar.gz

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotman-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: One more dot file manager but an interesting and easy to use one.
 Author: Nimit Bhardwaj
 License: MIT

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Environment :: Console",
     "License :: OSI Approved :: MIT License",
 ]
-version = "0.2.7"
+version = "0.2.9"
 description = "One more dot file manager but an interesting and easy to use one."
 readme = "README.md"
 requires-python = ">=3.12"

dotman_cli-0.2.9/src/dotman/__init__.py

@@ -0,0 +1,5 @@
+"""dotman - A dotfile manager using symlinks and templates."""
+
+from importlib.metadata import version
+
+__version__ = version("dotman-cli")

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/src/dotman/cli/commands/__init__.py

@@ -2,6 +2,7 @@
 
 from dotman.cli.commands import history as history_mod
 from dotman.cli.commands.absorb import absorb_changes
+from dotman.cli.commands.clean import clean
 from dotman.cli.commands.clone import clone
 from dotman.cli.commands.deploy import deploy, undeploy
 from dotman.cli.commands.init import init
@@ -23,6 +24,7 @@ rollback = history_mod.rollback
 __all__ = [
     "absorb_changes",
     "add_repository",
+    "clean",
     "clone",
     "deploy",
     "history",

dotman_cli-0.2.9/src/dotman/cli/commands/clean.py

@@ -0,0 +1,195 @@
+"""Clean commands for dotman CLI."""
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.tree import Tree
+
+from dotman.cli_utils import app, console, get_config
+
+
+def find_empty_dirs(root: Path) -> list[Path]:
+    """Find all empty directories under the given root directory.
+
+    Args:
+        root: The root directory to search for empty directories.
+
+    Returns:
+        A list of Path objects pointing to empty directories, sorted.
+    """
+    empty_dirs: list[Path] = []
+
+    for dirpath, dirnames, filenames in os.walk(root, topdown=True):
+        if dirpath != str(root) and not dirnames and not filenames:
+            empty_dirs.append(Path(dirpath))
+
+    empty_dirs.sort()
+    return empty_dirs
+
+
+def find_orphaned_symlinks(root: Path) -> list[Path]:
+    """Find all orphaned symlinks under the given root directory.
+
+    Args:
+        root: The root directory to search for orphaned symlinks.
+
+    Returns:
+        A list of Path objects pointing to orphaned symlinks.
+    """
+    orphaned: list[Path] = []
+
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+        for name in (*dirnames, *filenames):
+            path = Path(dirpath) / name
+
+            if path.is_symlink():
+                try:
+                    resolved = path.resolve()
+                    if not resolved.exists():
+                        orphaned.append(path)
+                except (OSError, RuntimeError):
+                    orphaned.append(path)
+
+    return orphaned
+
+
+@app.command(name="clean")
+def clean(
+    packages: Annotated[
+        list[str] | None,
+        typer.Argument(help="Packages to clean (default: all)"),
+    ] = None,
+    config_dir: Annotated[
+        Path | None,
+        typer.Option("--config-dir", "-c", help="The path of config directory"),
+    ] = None,
+    backup_dir: Annotated[
+        str | None,
+        typer.Option("--backup-dir", help="Override backup directory"),
+    ] = None,
+    repo_name: Annotated[
+        str | None,
+        typer.Option("--repo", "-r", help="Repository name"),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run", "-n", help="Show what would be removed without removing"
+        ),
+    ] = False,
+) -> None:
+    """Clean up deployment artifacts and temporary files."""
+    config = get_config(config_dir, backup_dir, repo_name=repo_name)
+
+    if not config.is_initialized():
+        console.print("[red]Dotman is not initialized. Run 'dotman init' first.[/red]")
+        raise typer.Exit(1)
+
+    packages_to_clean = packages or config.get_enabled_packages()
+
+    if not packages_to_clean:
+        console.print("[yellow]No packages to clean.[/yellow]")
+        return
+
+    orphaned_symlinks: dict[str, list[Path]] = {}
+    empty_dirs: dict[str, list[Path]] = {}
+
+    for pkg_name in packages_to_clean:
+        pkg = config.get_package(pkg_name)
+        if not pkg:
+            console.print(
+                f"[yellow]Package '{pkg_name}' not found in config, skipping.[/yellow]"
+            )
+            continue
+
+        for file_mapping in pkg.files:
+            target = Path(file_mapping.target).expanduser()
+
+            if target.is_dir():
+                target_dir = target
+                if target_dir.exists():
+                    orphaned = find_orphaned_symlinks(target_dir)
+                    empty = find_empty_dirs(target_dir)
+
+                    if orphaned:
+                        orphaned_symlinks[pkg_name] = orphaned
+                    if empty:
+                        empty_dirs[pkg_name] = empty
+            elif target.is_file() or target.exists() or target.is_symlink():
+                # For file targets, check if the file itself is an orphaned symlink
+                if target.is_symlink():
+                    try:
+                        if not target.resolve().exists():
+                            orphaned_symlinks.setdefault(pkg_name, []).append(target)
+                    except (OSError, RuntimeError):
+                        orphaned_symlinks.setdefault(pkg_name, []).append(target)
+
+    total_orphaned = sum(len(v) for v in orphaned_symlinks.values())
+    total_empty = sum(len(v) for v in empty_dirs.values())
+
+    if total_orphaned == 0 and total_empty == 0:
+        console.print("[green]No orphaned symlinks or empty directories found.[/green]")
+        return
+
+    tree = Tree("Cleanup Summary")
+
+    if orphaned_symlinks:
+        orphaned_tree = tree.add(f"Orphaned Symlinks ({total_orphaned})")
+        for pkg_name, paths in orphaned_symlinks.items():
+            pkg_tree = orphaned_tree.add(f"[cyan]{pkg_name}[/cyan]")
+            for path in paths:
+                pkg_tree.add(f"[red]{path}[/red]")
+
+    if empty_dirs:
+        empty_tree = tree.add(f"Empty Directories ({total_empty})")
+        for pkg_name, dirs in empty_dirs.items():
+            pkg_tree = empty_tree.add(f"[cyan]{pkg_name}[/cyan]")
+            for dir_path in dirs:
+                pkg_tree.add(f"[yellow]{dir_path}[/yellow]")
+
+    console.print(tree)
+
+    if dry_run:
+        console.print("[cyan]Dry run mode - no changes will be made[/cyan]")
+
+    if not dry_run and not typer.confirm("Proceed with cleanup?"):
+        console.print("[yellow]Cleanup cancelled.[/yellow]")
+        raise typer.Exit(0)
+
+    removed_orphaned = 0
+    removed_empty = 0
+
+    for pkg_name, paths in orphaned_symlinks.items():
+        for path in paths:
+            try:
+                if dry_run:
+                    console.print(f"  [cyan]Would remove:[/cyan] {path}")
+                else:
+                    path.unlink()
+                    removed_orphaned += 1
+                    console.print(f"  [green]Removed:[/green] {path}")
+            except OSError as e:
+                console.print(f"  [red]Failed to remove {path}: {e}[/red]")
+
+    for pkg_name, dirs in empty_dirs.items():
+        for dir_path in sorted(dirs, reverse=True):
+            try:
+                if dry_run:
+                    console.print(f"  [cyan]Would remove:[/cyan] {dir_path}")
+                else:
+                    dir_path.rmdir()
+                    removed_empty += 1
+                    console.print(f"  [green]Removed:[/green] {dir_path}")
+            except OSError as e:
+                console.print(f"  [yellow]Could not remove {dir_path}: {e}[/yellow]")
+
+    if dry_run:
+        console.print("\n[cyan]Dry run complete - no changes were made[/cyan]")
+    else:
+        console.print("\n[green]Clean complete![/green]")
+        console.print(
+            f"[dim]Removed {removed_orphaned} orphaned symlinks"
+            f" and {removed_empty} empty directories.[/dim]"
+        )

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/src/dotman/cli_utils.py

@@ -7,6 +7,7 @@ from typing import Annotated
 import typer
 from rich.console import Console
 
+from dotman import __version__
 from dotman.core.config import Config, get_repo_manager
 
 console = Console()
@@ -54,4 +55,14 @@ def get_repository_option() -> Annotated[
     return None
 
 
+@app.callback(invoke_without_command=True)
+def version_callback(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Show version"),
+) -> None:
+    if version:
+        console.print(__version__)
+        raise typer.Exit(0)
+
+
 app.add_typer(repo_app)

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/src/dotman_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotman-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: One more dot file manager but an interesting and easy to use one.
 Author: Nimit Bhardwaj
 License: MIT

{dotman_cli-0.2.7 → dotman_cli-0.2.9}/src/dotman_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/dotman/main.py
 src/dotman/cli/__init__.py
 src/dotman/cli/commands/__init__.py
 src/dotman/cli/commands/absorb.py
+src/dotman/cli/commands/clean.py
 src/dotman/cli/commands/clone.py
 src/dotman/cli/commands/deploy.py
 src/dotman/cli/commands/history.py

dotman_cli-0.2.7/src/dotman/__init__.py

@@ -1,3 +0,0 @@
-"""dotman - A dotfile manager using symlinks and templates."""
-
-__version__ = "0.1.0"