dotx 2.0.4__tar.gz → 2.1.0__tar.gz

{dotx-2.0.4/src/dotx.egg-info → dotx-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 2.0.4
+Version: 2.1.0
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -22,6 +22,7 @@ License-File: LICENSE
 Requires-Dist: click>=8.1.7
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: pathspec>=0.12.1
+Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.1
 Dynamic: license-file
 

{dotx-2.0.4 → dotx-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotx"
-version = "2.0.4"
+version = "2.1.0"
 description = "A command-line tool to install a link-farm to your dotfiles"
 authors = [
     { name = "Wolf", email = "Wolf@zv.cx" }
@@ -24,6 +24,7 @@ dependencies = [
     "click>=8.1.7",
     "loguru>=0.7.0",
     "pathspec>=0.12.1",
+    "rich>=13.9.4",
     "typer>=0.15.1",
 ]
 

{dotx-2.0.4 → dotx-2.1.0}/src/dotx/cli.py

@@ -21,11 +21,15 @@ from typing import Annotated, Optional
 import click
 import typer
 from loguru import logger
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.table import Table
+from rich.panel import Panel
 
 from dotx import __version__, __homepage__
 from dotx.database import InstallationDB
 from dotx.install import plan_install
-from dotx.options import set_option
+from dotx.options import set_option, is_verbose_mode
 from dotx.plan import Action, Plan, execute_plan, extract_plan, log_extracted_plan
 from dotx.uninstall import plan_uninstall
 
@@ -128,6 +132,8 @@ def install(
 ):
     """Install source packages to target directory."""
     logger.info("install 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()
@@ -148,20 +154,64 @@ def install(
             failures = extract_plan(plan, {Action.FAIL})
             if failures:
                 can_install = False
-                typer.echo(
-                    f"Error: can't install {source_package} because it would overwrite:"
+                console.print(
+                    f"[red]✗ Error: can't install {source_package.name} - would overwrite:[/red]"
                 )
                 for plan_node in failures:
-                    typer.echo(f"{target_path / plan_node.relative_destination_path}")
-                typer.echo()
+                    console.print(f"  {target_path / plan_node.relative_destination_path}")
+                console.print()
 
         if can_install:
-            # Open database and execute all plans
+            # Count total actions
+            total_actions = sum(
+                len(extract_plan(plan, {Action.LINK, Action.CREATE}))
+                for _, plan in plans
+            )
+
+            # Open database and execute all plans with progress
             with InstallationDB() as db:
-                for source_package, plan in plans:
-                    execute_plan(source_package, target_path, plan, db)
+                if verbose:
+                    # Verbose: show each file
+                    for source_package, plan in plans:
+                        console.print(f"[cyan]Installing {source_package.name}...[/cyan]")
+                        for node in extract_plan(plan, {Action.LINK, Action.CREATE}):
+                            console.print(f"  {node.relative_destination_path}")
+                        execute_plan(source_package, target_path, plan, db)
+                else:
+                    # Default: show progress bar
+                    with Progress(
+                        SpinnerColumn(),
+                        TextColumn("[progress.description]{task.description}"),
+                        BarColumn(),
+                        TaskProgressColumn(),
+                        console=console,
+                    ) as progress:
+                        task = progress.add_task("Installing...", total=total_actions)
+                        for source_package, plan in plans:
+                            progress.update(task, description=f"Installing {source_package.name}...")
+                            execute_plan(source_package, target_path, plan, db)
+                            progress.advance(task, len(extract_plan(plan, {Action.LINK, Action.CREATE})))
+
+            # Show summary
+            total_files = sum(
+                len(extract_plan(plan, {Action.LINK}))
+                for _, plan in plans
+            )
+            total_dirs = sum(
+                len(extract_plan(plan, {Action.CREATE}))
+                for _, plan in plans
+            )
+
+            summary_parts = []
+            if total_files:
+                summary_parts.append(f"{total_files} file(s)")
+            if total_dirs:
+                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]")
         else:
-            typer.echo("Refusing to install anything because of previous failures.")
+            console.print("[red]✗ Refusing to install - conflicts detected[/red]")
 
     logger.info("install finished")
 
@@ -182,6 +232,8 @@ def uninstall(
 ):
     """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()
@@ -197,10 +249,42 @@ def uninstall(
             )
             plans.append((source_package, plan))
 
-        # Open database and execute all plans
+        # Count total actions
+        total_actions = sum(
+            len(extract_plan(plan, {Action.UNLINK}))
+            for _, plan in plans
+        )
+
+        # Open database and execute all plans with progress
         with InstallationDB() as db:
-            for source_package, plan in plans:
-                execute_plan(source_package, target_path, plan, db)
+            if verbose:
+                # Verbose: show each file
+                for source_package, plan in plans:
+                    console.print(f"[cyan]Uninstalling {source_package.name}...[/cyan]")
+                    for node in extract_plan(plan, {Action.UNLINK}):
+                        console.print(f"  {node.relative_destination_path}")
+                    execute_plan(source_package, target_path, plan, db)
+            else:
+                # Default: show progress bar
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    TaskProgressColumn(),
+                    console=console,
+                ) as progress:
+                    task = progress.add_task("Uninstalling...", total=total_actions)
+                    for source_package, plan in plans:
+                        progress.update(task, description=f"Uninstalling {source_package.name}...")
+                        execute_plan(source_package, target_path, plan, db)
+                        progress.advance(task, len(extract_plan(plan, {Action.UNLINK})))
+
+        # Show summary
+        total_removed = sum(
+            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]")
 
     logger.info("uninstall finished")
 
@@ -214,35 +298,39 @@ def list_installed(
 ):
     """List all installed packages."""
     logger.info("list starting")
+    console = Console()
 
     with InstallationDB() as db:
         packages = db.get_all_packages()
 
         if not packages:
-            typer.echo("No packages installed.")
+            console.print("[yellow]No packages installed.[/yellow]")
             return
 
         if as_commands:
-            # Output as dotx install commands
+            # Output as dotx install commands (plain text, no formatting)
             for pkg in packages:
                 typer.echo(f"dotx install {pkg['package_name']}")
         else:
-            # Output as table
-            typer.echo("\nInstalled Packages:")
-            typer.echo("-" * 80)
-            typer.echo(f"{'Package':<50} {'Files':<10} {'Last Install':<20}")
-            typer.echo("-" * 80)
+            # Output as rich table
+            table = Table(title="Installed Packages", show_header=True, header_style="bold cyan")
+            table.add_column("Package", style="cyan", no_wrap=True)
+            table.add_column("Files", justify="right", style="magenta")
+            table.add_column("Last Install", style="green")
+
             for pkg in packages:
                 package_name = Path(pkg["package_name"]).name
-                file_count = pkg["file_count"]
+                file_count = str(pkg["file_count"])
                 latest = (
                     pkg["latest_install"][:19]
                     if pkg["latest_install"]
-                    else "unknown"
+                    else "[dim]unknown[/dim]"
                 )
-                typer.echo(f"{package_name:<50} {file_count:<10} {latest:<20}")
-            typer.echo("-" * 80)
-            typer.echo(f"Total: {len(packages)} package(s)\n")
+                table.add_row(package_name, file_count, latest)
+
+            console.print()
+            console.print(table)
+            console.print(f"\n[bold]Total: {len(packages)} package(s)[/bold]\n")
 
     logger.info("list finished")
 
@@ -262,6 +350,7 @@ def verify(
 ):
     """Verify installations against filesystem."""
     logger.info("verify starting")
+    console = Console()
 
     with InstallationDB() as db:
         if package:
@@ -275,24 +364,24 @@ def verify(
             ]
 
         if not packages_to_verify:
-            typer.echo("No packages to verify.")
+            console.print("[yellow]No packages to verify.[/yellow]")
             return
 
         total_issues = 0
         for pkg in packages_to_verify:
             issues = db.verify_installations(pkg)
             if issues:
-                typer.echo(f"\n{pkg}:")
+                console.print(f"\n[bold cyan]{pkg.name}:[/bold cyan]")
                 for issue in issues:
-                    typer.echo(f"  {issue['target_path']}")
-                    typer.echo(f"    Issue: {issue['issue']}")
-                    typer.echo(f"    Expected type: {issue['link_type']}")
+                    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]")
                 total_issues += len(issues)
 
         if total_issues == 0:
-            typer.echo("✓ All installations verified successfully.")
+            console.print("[green]✓ All installations verified successfully.[/green]")
         else:
-            typer.echo(f"\n⚠ Found {total_issues} issue(s).")
+            console.print(f"\n[yellow]⚠ Found {total_issues} issue(s).[/yellow]")
 
     logger.info("verify finished")
 
@@ -312,29 +401,78 @@ def show(
 ):
     """Show detailed installation information for a package."""
     logger.info("show starting")
+    console = Console()
 
     with InstallationDB() as db:
         installations = db.get_installations(package)
 
         if not installations:
-            typer.echo(f"No installations found for {package}")
+            console.print(f"[yellow]No installations found for {package.name}[/yellow]")
             return
 
-        typer.echo(f"\nPackage: {package}")
-        typer.echo(f"Installed files: {len(installations)}")
-        typer.echo("\nInstallations:")
-        typer.echo("-" * 80)
+        # Create info panel
+        info = f"[bold cyan]Package:[/bold cyan] {package}\n"
+        info += f"[bold cyan]Installed files:[/bold cyan] {len(installations)}"
+
+        panel = Panel(info, title="Package Information", border_style="cyan")
+        console.print()
+        console.print(panel)
+
+        # Create table for installations
+        table = Table(show_header=True, header_style="bold magenta", box=None)
+        table.add_column("Target Path", style="cyan", no_wrap=False, overflow="fold")
+        table.add_column("Type", style="yellow")
+        table.add_column("Installed At", style="green")
 
         for install in installations:
-            typer.echo(f"\n  Target: {install['target_path']}")
-            typer.echo(f"  Type:   {install['link_type']}")
-            typer.echo(f"  When:   {install['installed_at']}")
+            table.add_row(
+                str(install['target_path']),
+                install['link_type'],
+                install['installed_at'][:19] if install['installed_at'] else "unknown"
+            )
 
-        typer.echo("-" * 80)
+        console.print()
+        console.print(table)
+        console.print()
 
     logger.info("show finished")
 
 
+def _scan_symlinks(path: Path, max_depth: int, progress: Progress, task_id) -> list[tuple[Path, bool]]:
+    """
+    Scan a directory for symlinks up to a maximum depth.
+
+    Returns list of (symlink_path, is_dir) tuples.
+    """
+    symlinks = []
+
+    def _walk_limited(directory: Path, current_depth: int):
+        """Recursively walk directory up to max_depth."""
+        if current_depth > max_depth:
+            return
+
+        try:
+            for item in directory.iterdir():
+                # Update progress
+                progress.update(task_id, advance=1)
+
+                if item.is_symlink():
+                    is_dir = item.is_dir()  # Check if symlink points to directory
+                    symlinks.append((item, is_dir))
+                    # Don't descend into symlinked directories
+                    continue
+
+                # Recurse into regular directories
+                if item.is_dir() and not item.is_symlink():
+                    _walk_limited(item, current_depth + 1)
+
+        except (PermissionError, OSError) as e:
+            logger.debug(f"Skipping {directory}: {e}")
+
+    _walk_limited(path, 0)
+    return symlinks
+
+
 @app.command()
 def sync(
     ctx: click.Context,
@@ -342,37 +480,77 @@ def sync(
         bool,
         typer.Option("--dry-run", help="Show what would be added without modifying the database"),
     ] = False,
+    max_depth: Annotated[
+        Optional[int],
+        typer.Option(help="Maximum depth to scan (default: 1 for home, 3 for config)"),
+    ] = None,
+    scan_paths: Annotated[
+        Optional[list[Path]],
+        typer.Option(help="Additional paths to scan"),
+    ] = None,
+    simple: Annotated[
+        bool,
+        typer.Option(help="Simple scan: only home directory depth 1, skip ~/.config"),
+    ] = False,
 ):
-    """Rebuild database from filesystem (scan for existing symlinks)."""
+    """
+    Rebuild database from filesystem (scan for existing symlinks).
+
+    By default, scans:
+    - Top-level of home directory (depth=1)
+    - All of ~/.config (depth=3)
+
+    Use --simple to only scan home directory at depth 1.
+    Use --max-depth to override default depth for all paths.
+    Use --scan-paths to add additional directories to scan.
+    """
     logger.info("sync starting")
+    console = Console()
 
     # Get target from options
     target_path = Path(ctx.obj.get("TARGET", Path.home())) if ctx.obj else Path.home()
 
-    # Scan filesystem for symlinks
+    # Determine scan strategy
+    scan_configs = []
+
+    if simple:
+        # Simple mode: just top-level of home
+        scan_configs.append((target_path, max_depth or 1))
+    else:
+        # Smart mode: top-level home + full ~/.config
+        scan_configs.append((target_path, max_depth or 1))
+        config_path = target_path / ".config"
+        if config_path.exists() and config_path.is_dir():
+            scan_configs.append((config_path, max_depth or 3))
+
+    # Add any user-specified paths
+    if scan_paths:
+        for path in scan_paths:
+            scan_configs.append((path, max_depth or 3))
+
+    # Scan filesystem for symlinks with progress
     symlinks = []
-    for root, dirs, files in target_path.walk():
-        # Check if directories are symlinks
-        for dirname in dirs[:]:
-            dirpath = root / dirname
-            if dirpath.is_symlink():
-                symlinks.append((dirpath, True))  # (path, is_dir)
-                # Don't descend into symlinked directories
-                dirs.remove(dirname)
-
-        # Check if files are symlinks
-        for filename in files:
-            filepath = root / filename
-            if filepath.is_symlink():
-                symlinks.append((filepath, False))  # (path, is_dir)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        scan_task = progress.add_task("Scanning for symlinks...", total=None)
+
+        for scan_path, depth in scan_configs:
+            progress.update(scan_task, description=f"Scanning {scan_path.name}...")
+            symlinks.extend(_scan_symlinks(scan_path, depth, progress, scan_task))
+
+    console.print(f"[green]✓[/green] Found {len(symlinks)} symlink(s)")
 
     if not symlinks:
-        typer.echo("No symlinks found in target directory.")
+        console.print("[yellow]No symlinks found.[/yellow]")
         logger.info("sync finished - no symlinks found")
         return
 
-    typer.echo(f"Found {len(symlinks)} symlink(s) in {target_path}")
-
     # Group symlinks by their resolved source parent directory (package)
     packages = {}
     unknown = []
@@ -397,23 +575,23 @@ def sync(
             unknown.append((link_path, None, is_dir))
 
     # Show what was found
-    typer.echo(f"\nDiscovered {len(packages)} potential package(s):")
+    console.print(f"\n[bold]Discovered {len(packages)} potential package(s):[/bold]")
     for package_root, links in packages.items():
-        typer.echo(f"\n  {package_root}")
-        typer.echo(f"    {len(links)} symlink(s)")
+        console.print(f"  [cyan]{package_root}[/cyan]")
+        console.print(f"    {len(links)} symlink(s)")
 
     if unknown:
-        typer.echo(f"\n  Unknown/broken: {len(unknown)} symlink(s)")
+        console.print(f"  [yellow]Unknown/broken: {len(unknown)} symlink(s)[/yellow]")
 
     if dry_run:
-        typer.echo("\nDry run - no database changes made.")
+        console.print("\n[yellow]Dry run - no database changes made.[/yellow]")
         logger.info("sync finished - dry run")
         return
 
     # Ask for confirmation
-    typer.echo("\nThis will rebuild the database with the discovered installations.")
+    console.print("\n[bold]This will rebuild the database with the discovered installations.[/bold]")
     if not typer.confirm("Continue?"):
-        typer.echo("Cancelled.")
+        console.print("[yellow]Cancelled.[/yellow]")
         logger.info("sync finished - cancelled by user")
         return
 
@@ -434,7 +612,7 @@ def sync(
                 total_recorded += 1
                 logger.debug(f"Recorded {link_path} -> {package_root}")
 
-        typer.echo(f"\n✓ Recorded {total_recorded} installation(s) in database.")
+        console.print(f"\n[green]✓ Recorded {total_recorded} installation(s) in database.[/green]")
 
     logger.info("sync finished")
 

{dotx-2.0.4 → dotx-2.1.0/src/dotx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 2.0.4
+Version: 2.1.0
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -22,6 +22,7 @@ License-File: LICENSE
 Requires-Dist: click>=8.1.7
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: pathspec>=0.12.1
+Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.1
 Dynamic: license-file
 

{dotx-2.0.4 → dotx-2.1.0}/src/dotx.egg-info/requires.txt

@@ -1,4 +1,5 @@
 click>=8.1.7
 loguru>=0.7.0
 pathspec>=0.12.1
+rich>=13.9.4
 typer>=0.15.1

{dotx-2.0.4 → dotx-2.1.0}/tests/test_cli_database.py

@@ -430,8 +430,9 @@ def test_cli_show_package(tmp_path, monkeypatch):
     assert result.exit_code == 0
     assert "Package:" in result.output
     assert "Installed files: 2" in result.output
-    assert str(target / "file1") in result.output
-    assert str(target / "file2") in result.output
+    # Rich may wrap long paths, so just check for the filenames
+    assert "file1" in result.output
+    assert "file2" in result.output
 
 
 def test_cli_show_nonexistent_package(tmp_path, monkeypatch):