dotman-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{dotman_cli-0.3.0/src/dotman_cli.egg-info → dotman_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotman-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: One more dot file manager but an interesting and easy to use one.
 Author: Nimit Bhardwaj
 License: MIT
@@ -155,6 +155,7 @@ packages:
 | `dotman deploy [packages]`   | Deploy dotfiles (create symlinks)              |
 | `dotman undeploy [packages]` | Remove deployed symlinks                       |
 | `dotman status [packages]`   | Show status of deployed dotfiles               |
+| `dotman diff [packages]`     | Diff deployed files against what deploy would write (exit 1 on drift) |
 | `dotman list`                | List all available packages                    |
 | `dotman absorb [packages]`   | Absorb unmanaged files from target directories |
 | `dotman watch`               | Watch for file changes and deploy automatically |
@@ -170,6 +171,8 @@ packages:
 ### Options
 
 - `--config-dir, -c` - Override the config directory (default: `.dotman/` in current directory or `DOTMAN_CONFIG_DIR` env var)
+- `--repo, -r` - Use a registered repository. With no flag and no dotman repo in the current directory, the default registered repository is used, so `dotman status` works from anywhere
+- `--backup-dir` - Override `settings.backup_dir` (relative paths are relative to the repo)
 - `--dry-run, -n` - Preview changes without applying them
 - `--force, -f` - Overwrite existing files (with backup)
 - Specific packages can be passed to commands for targeted operations
@@ -220,7 +223,7 @@ packages:
           - ".git/**" # Ignore git directories
 ```
 
-The `absorb_ignore` field accepts a list of regex patterns that are matched against the full file path. If a file matches any pattern, it will be skipped during absorption.
+Each `absorb_ignore` entry is tried as a glob against the path relative to the target (and the file name), then as a regex against the full path. If a file matches any pattern, it is skipped during absorption.
 
 ## Doctor Configuration
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/README.md

@@ -134,6 +134,7 @@ packages:
 | `dotman deploy [packages]`   | Deploy dotfiles (create symlinks)              |
 | `dotman undeploy [packages]` | Remove deployed symlinks                       |
 | `dotman status [packages]`   | Show status of deployed dotfiles               |
+| `dotman diff [packages]`     | Diff deployed files against what deploy would write (exit 1 on drift) |
 | `dotman list`                | List all available packages                    |
 | `dotman absorb [packages]`   | Absorb unmanaged files from target directories |
 | `dotman watch`               | Watch for file changes and deploy automatically |
@@ -149,6 +150,8 @@ packages:
 ### Options
 
 - `--config-dir, -c` - Override the config directory (default: `.dotman/` in current directory or `DOTMAN_CONFIG_DIR` env var)
+- `--repo, -r` - Use a registered repository. With no flag and no dotman repo in the current directory, the default registered repository is used, so `dotman status` works from anywhere
+- `--backup-dir` - Override `settings.backup_dir` (relative paths are relative to the repo)
 - `--dry-run, -n` - Preview changes without applying them
 - `--force, -f` - Overwrite existing files (with backup)
 - Specific packages can be passed to commands for targeted operations
@@ -199,7 +202,7 @@ packages:
           - ".git/**" # Ignore git directories
 ```
 
-The `absorb_ignore` field accepts a list of regex patterns that are matched against the full file path. If a file matches any pattern, it will be skipped during absorption.
+Each `absorb_ignore` entry is tried as a glob against the path relative to the target (and the file name), then as a regex against the full path. If a file matches any pattern, it is skipped during absorption.
 
 ## Doctor Configuration
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Environment :: Console",
     "License :: OSI Approved :: MIT License",
 ]
-version = "0.3.0"
+version = "0.4.0"
 description = "One more dot file manager but an interesting and easy to use one."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -74,6 +74,8 @@ section-order = ["future", "standard-library", "third-party", "first-party", "lo
 combine-as-imports = true
 
 [tool.mypy]
+# select.kqueue only exists in the darwin stubs; check as darwin everywhere
+platform = "darwin"
 warn_return_any = true
 warn_unused_configs = true
 warn_redundant_casts = true

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/__init__.py

@@ -5,6 +5,7 @@ from dotman.cli.commands import (
     add_repository,
     clone,
     deploy,
+    diff,
     doctor,
     history,
     init,
@@ -24,7 +25,6 @@ from dotman.cli_utils import (
     app,
     console,
     get_config,
-    get_repository_option,
     repo_app,
 )
 
@@ -35,13 +35,13 @@ __all__ = [
     "console",
     "doctor",
     "get_config",
-    "get_repository_option",
     "repo_app",
     "init",
     "clone",
     "push",
     "pull",
     "deploy",
+    "diff",
     "undeploy",
     "status",
     "list_packages",

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/__init__.py

@@ -5,6 +5,7 @@ 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.diff import diff
 from dotman.cli.commands.doctor import doctor
 from dotman.cli.commands.init import init
 from dotman.cli.commands.pull import pull
@@ -28,6 +29,7 @@ __all__ = [
     "clean",
     "clone",
     "deploy",
+    "diff",
     "doctor",
     "history",
     "init",

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/absorb.py

@@ -1,5 +1,6 @@
 """Absorb command for dotman CLI."""
 
+import fnmatch
 import re
 from pathlib import Path
 from typing import Annotated
@@ -10,10 +11,21 @@ from dotman.cli_utils import app, console, get_config
 from dotman.core.link_manager import LinkManager
 
 
+def _is_ignored(pattern: str, path: Path, relative: Path) -> bool:
+    """Match a pattern as a glob on the relative path, or a regex on the full path."""
+    if fnmatch.fnmatch(str(relative), pattern) or fnmatch.fnmatch(path.name, pattern):
+        return True
+    try:
+        return re.search(pattern, str(path)) is not None
+    except re.error:
+        return False
+
+
 def _should_skip_file(
     target_file: Path,
     absorb_ignore: list[str] | None,
     dest_file: Path,
+    relative: Path | None = None,
 ) -> tuple[bool, str]:
     """Check if a file should be skipped during absorption.
 
@@ -24,8 +36,9 @@ def _should_skip_file(
         return True, "symlink"
     if target_file.name.endswith(".j2"):
         return True, "template"
+    relative = relative or Path(target_file.name)
     if absorb_ignore and any(
-        re.search(pattern, str(target_file)) for pattern in absorb_ignore
+        _is_ignored(pattern, target_file, relative) for pattern in absorb_ignore
     ):
         return True, "ignored"
     if dest_file.exists():
@@ -94,9 +107,8 @@ def absorb_changes(
         console.print("[red]Dotman is not initialized. Run 'dotman init' first.[/red]")
         raise typer.Exit(1)
 
-    packages_to_absorb = packages or config.get_enabled_packages()
     # Sort for deterministic behavior (first package wins conflicts)
-    packages_to_absorb.sort()
+    packages_to_absorb = sorted(packages or config.get_enabled_packages())
 
     package_objs = []
     for package_name in packages_to_absorb:
@@ -138,7 +150,7 @@ def absorb_changes(
                     dest_file = source / relative_path
 
                     should_skip, _ = _should_skip_file(
-                        target_file, absorb_ignore, dest_file
+                        target_file, absorb_ignore, dest_file, relative_path
                     )
                     if should_skip:
                         continue

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/deploy.py

@@ -10,8 +10,6 @@ from dotman.cli_utils import app, console, get_config
 from dotman.core.exceptions import (
     DotmanError,
     HookExecutionError,
-    LinkExistsError,
-    LinkTargetMissingError,
     MissingDependencyError,
 )
 from dotman.core.link_manager import LinkManager, LinkStatus
@@ -44,17 +42,13 @@ def deploy(
         str | None,
         typer.Option("--backup-dir", help="Override backup directory"),
     ] = None,
-    template_suffix: Annotated[
-        str | None,
-        typer.Option("--template-suffix", help="Override template suffix"),
-    ] = None,
     repo_name: Annotated[
         str | None,
         typer.Option("--repo", "-r", help="Repository name"),
     ] = None,
 ) -> None:
     """Deploy dotfiles by creating symlinks."""
-    config = get_config(config_dir, backup_dir, template_suffix, repo_name)
+    config = get_config(config_dir, backup_dir, repo_name)
 
     if repo_name:
         console.print(f"[cyan]Using repository: {repo_name}[/cyan]")
@@ -86,6 +80,7 @@ def deploy(
 
     deployment_id = str(uuid.uuid4())[:8]
     deployed_files: list[DeployedFile] = []
+    failed = False
 
     if dry_run:
         console.print("[cyan]Dry run mode - no changes will be made[/cyan]")
@@ -126,6 +121,7 @@ def deploy(
                             f"  [yellow]Skipping package '{pkg_name}'...[/yellow]"
                         )
                         skip_package = True
+                        failed = True
                         break
 
         if skip_package:
@@ -136,57 +132,39 @@ def deploy(
             target = Path(file_mapping.target).expanduser()
 
             try:
-                is_template = link_manager.is_template_file(source)
-
-                if is_template:
-                    if not dry_run:
-                        template_engine.render_file(source, variables, target)
-                        console.print(f"  [green]Rendered:[/green] {target}")
-                    else:
-                        console.print(f"  [cyan]Would render:[/cyan] {target}")
+                results = link_manager.create_link(
+                    source, target, force, dry_run, template_engine, variables
+                )
+            except DotmanError as e:
+                console.print(f"  [red]Error:[/red] {e}")
+                failed = True
+                continue
 
-                    deployed_files.append(
-                        DeployedFile(
-                            source=str(source),
-                            target=str(target),
-                            is_template=True,
-                        )
-                    )
+            for result in results:
+                if result.status != LinkStatus.LINKED:
+                    continue
+                is_template = link_manager.is_template_file(result.source)
+                if dry_run:
+                    console.print(f"  [cyan]{result.message}[/cyan]")
+                elif is_template:
+                    console.print(f"  [green]Rendered:[/green] {result.target}")
                 else:
-                    results = link_manager.create_link(
-                        source, target, force, dry_run, template_engine, variables
+                    console.print(
+                        f"  [green]Linked:[/green] {result.target} -> {result.source}"
+                    )
+                if result.backed_up:
+                    console.print(
+                        f"    [yellow]Backed up to:[/yellow] {result.backed_up}"
                     )
-                    for result in results:
-                        if result.status == LinkStatus.LINKED:
-                            if dry_run:
-                                console.print(f"  [cyan]{result.message}[/cyan]")
-                            else:
-                                console.print(
-                                    f"  [green]Linked:[/green]"
-                                    f" {result.target} -> {result.source}"
-                                )
-                            if result.backed_up:
-                                console.print(
-                                    f"    [yellow]Backed"
-                                    f" up to:[/yellow] {result.backed_up}"
-                                )
-
-                            deployed_files.append(
-                                DeployedFile(
-                                    source=str(result.source),
-                                    target=str(result.target),
-                                    is_template=False,
-                                    backup_path=str(result.backed_up)
-                                    if result.backed_up
-                                    else None,
-                                )
-                            )
-            except LinkExistsError as e:
-                console.print(f"  [red]Error:[/red] {e}")
-            except LinkTargetMissingError as e:
-                console.print(f"  [red]Error:[/red] {e}")
-            except DotmanError as e:
-                console.print(f"  [red]Error:[/red] {e}")
+
+                deployed_files.append(
+                    DeployedFile(
+                        source=str(result.source),
+                        target=str(result.target),
+                        is_template=is_template,
+                        backup_path=str(result.backed_up) if result.backed_up else None,
+                    )
+                )
 
         if pkg.hooks.post_deploy:
             target_dir = None
@@ -232,6 +210,10 @@ def deploy(
     else:
         console.print("\n[green]Deploy complete![/green]")
 
+    if failed:
+        console.print("[red]Some files failed to deploy (see errors above).[/red]")
+        raise typer.Exit(1)
+
 
 @app.command()
 def undeploy(

dotman_cli-0.4.0/src/dotman/cli/commands/diff.py

@@ -0,0 +1,93 @@
+"""Diff command for dotman CLI."""
+
+import difflib
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.syntax import Syntax
+
+from dotman.cli_utils import app, console, get_config
+from dotman.core.exceptions import DotmanError
+from dotman.core.link_manager import LinkManager
+from dotman.core.template_engine import TemplateEngine
+
+
+@app.command()
+def diff(
+    packages: Annotated[
+        list[str] | None,
+        typer.Argument(help="Packages to diff (default: all enabled)"),
+    ] = None,
+    config_dir: Annotated[
+        Path | None,
+        typer.Option("--config-dir", "-c", help="The path of config directory"),
+    ] = None,
+    repo_name: Annotated[
+        str | None,
+        typer.Option("--repo", "-r", help="Repository name"),
+    ] = None,
+) -> None:
+    """Show what deploy would change in rendered templates and conflicting files.
+
+    Exits with 1 when differences are found, so it can be used in scripts.
+    """
+    config = get_config(config_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)
+
+    link_manager = LinkManager(config.backup_dir)
+    template_engine = TemplateEngine()
+    found = False
+
+    for pkg_name in packages or config.get_enabled_packages():
+        pkg = config.get_package(pkg_name)
+        if not pkg:
+            console.print(f"[yellow]Package '{pkg_name}' not found, skipping.[/yellow]")
+            continue
+        variables = config.get_merged_variables(pkg_name)
+
+        for file_mapping in pkg.files:
+            source = config.dotfiles_dir / file_mapping.source
+            target = Path(file_mapping.target).expanduser()
+            if source.is_dir():
+                pairs = [
+                    (f, link_manager.derive_target(f, source, target))
+                    for f in source.rglob("*")
+                    if f.is_file()
+                ]
+            else:
+                pairs = [(source, target)]
+
+            for source_file, file_target in pairs:
+                # Symlinks and missing targets have no content to compare
+                if file_target.is_symlink() or not file_target.is_file():
+                    continue
+                try:
+                    if link_manager.is_template_file(source_file):
+                        wanted = template_engine.render_file(source_file, variables)
+                    else:
+                        wanted = source_file.read_text()
+                    current = file_target.read_text()
+                except (DotmanError, OSError, UnicodeDecodeError) as e:
+                    console.print(f"[red]Cannot diff {file_target}:[/red] {e}")
+                    continue
+
+                lines = list(
+                    difflib.unified_diff(
+                        current.splitlines(keepends=True),
+                        wanted.splitlines(keepends=True),
+                        fromfile=str(file_target),
+                        tofile=str(source_file),
+                    )
+                )
+                if lines:
+                    found = True
+                    console.print(Syntax("".join(lines), "diff", theme="ansi_dark"))
+
+    if not found:
+        console.print("[green]No differences.[/green]")
+        return
+    raise typer.Exit(1)

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/history.py

@@ -140,54 +140,44 @@ def rollback(
 
         console.print(f"Processing: {target}")
 
-        if deployed_file.is_template:
-            if target.exists():
-                if not dry_run:
-                    target.unlink()
+        # Templates are regular files we wrote; links must still be symlinks.
+        # A real file where a link used to be belongs to the user: leave it.
+        ours = target.is_file() if deployed_file.is_template else target.is_symlink()
+        if ours:
+            if not dry_run:
+                target.unlink()
+                console.print(f"  [green]Removed: {target}[/green]")
+            else:
+                console.print(f"  [cyan]Would remove: {target}[/cyan]")
+            success_count += 1
+        elif target.exists():
+            console.print(
+                f"  [yellow]Not a dotman-managed file, leaving it: {target}[/yellow]"
+            )
+            skipped_count += 1
+            continue
+        else:
+            console.print(f"  [yellow]Already removed: {target}[/yellow]")
+            skipped_count += 1
+
+        if backup_path and Path(backup_path).exists():
+            if not dry_run:
+                if history_manager.restore_from_backup(Path(backup_path), target):
                     console.print(
-                        f"  [green]Removed rendered template: {target}[/green]"
+                        f"  [green]Restored from backup: {backup_path}[/green]"
                     )
+                    history_manager.cleanup_backup(Path(backup_path))
                 else:
                     console.print(
-                        f"  [cyan]Would remove rendered template: {target}[/cyan]"
+                        f"  [red]Failed to restore from backup: {backup_path}[/red]"
                     )
-                success_count += 1
+                    fail_count += 1
             else:
-                console.print(f"  [yellow]Already removed: {target}[/yellow]")
-                skipped_count += 1
-        else:
-            if target.is_symlink() or target.exists():
-                if not dry_run:
-                    if target.is_symlink():
-                        target.unlink()
-                    elif target.is_file():
-                        target.unlink()
-                    console.print(f"  [green]Removed symlink: {target}[/green]")
-                else:
-                    console.print(f"  [cyan]Would remove symlink: {target}[/cyan]")
-                success_count += 1
-            else:
-                console.print(f"  [yellow]Already removed: {target}[/yellow]")
-                skipped_count += 1
-
-            if backup_path and Path(backup_path).exists():
-                if not dry_run:
-                    if history_manager.restore_from_backup(Path(backup_path), target):
-                        console.print(
-                            f"  [green]Restored from backup: {backup_path}[/green]"
-                        )
-                        history_manager.cleanup_backup(Path(backup_path))
-                    else:
-                        console.print(
-                            f"  [red]Failed to restore from backup: {backup_path}[/red]"
-                        )
-                        fail_count += 1
-                else:
-                    console.print(
-                        f"  [cyan]Would restore from backup: {backup_path}[/cyan]"
-                    )
-            elif backup_path:
-                console.print(f"  [yellow]Backup not found: {backup_path}[/yellow]")
+                console.print(
+                    f"  [cyan]Would restore from backup: {backup_path}[/cyan]"
+                )
+        elif backup_path:
+            console.print(f"  [yellow]Backup not found: {backup_path}[/yellow]")
 
     console.print("\n[bold]Rollback summary:[/bold]")
     console.print(f"  Processed: {success_count}")

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/init.py

@@ -1,12 +1,13 @@
 """Init command for dotman CLI."""
 
+import os
 from pathlib import Path
 from typing import Annotated
 
 import typer
 
-from dotman.cli_utils import app, console, get_config
-from dotman.core.config import get_repo_manager
+from dotman.cli_utils import app, console
+from dotman.core.config import Config, get_repo_manager
 from dotman.managers import RemoteManager
 
 
@@ -23,10 +24,13 @@ def init(
 ) -> None:
     """Initialize dotman configuration in the current directory.
 
-    Creates a .dotman/ folder with global.yaml and local.yaml configs.
+    Creates a .dotman/ folder with config.yaml and local.yaml configs.
     Run this from your dotfiles repository root.
     """
-    config = get_config(config_dir=config_dir)
+    # Not get_config(): that falls back to the default repo, init must not.
+    config = Config(
+        config_dir or Path(os.environ.get("DOTMAN_CONFIG_DIR") or Path.cwd())
+    )
 
     if config.is_initialized():
         console.print("[yellow]Dotman is already initialized.[/yellow]")

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/push.py

@@ -70,11 +70,7 @@ def push(
     try:
         remote_url = remote_manager.get_remote_url(remote_name)
 
-        has_changes = (
-            remote_manager.has_staged_changes() or remote_manager.has_unstaged_changes()
-        )
-
-        if not has_changes:
+        if not remote_manager.has_changes():
             console.print("[yellow]No changes to commit.[/yellow]")
             raise typer.Exit(0)
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/repo.py

@@ -96,9 +96,10 @@ def remove_repository(
     """
     repo_manager = get_repo_manager()
 
-    repo = repo_manager.get_repository(name)
-    if not repo:
-        console.print(f"[red]Repository '{name}' not found.[/red]")
+    try:
+        repo = repo_manager.get_repository(name)
+    except RepositoryNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
         raise typer.Exit(1)
 
     if not force:

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/status.py

@@ -44,6 +44,7 @@ def status(
         return
 
     link_manager = LinkManager(config.backup_dir)
+    template_engine = TemplateEngine()
 
     table = Table(title="Dotman Status")
     table.add_column("Package", style="cyan")
@@ -66,55 +67,26 @@ def status(
             table.add_row(pkg_name, "-", "[yellow]Not found[/yellow]")
             continue
 
+        variables = config.get_merged_variables(pkg_name)
         for file_mapping in pkg.files:
             source = config.dotfiles_dir / file_mapping.source
             target = Path(file_mapping.target).expanduser()
 
             if source.is_dir():
-                for source_file in source.rglob("*"):
-                    if source_file.is_file():
-                        relative_path = source_file.relative_to(source)
-                        file_target = target / relative_path
-
-                        display_target = file_target
-                        if link_manager.is_template_file(source_file):
-                            display_target = link_manager.get_template_target(
-                                file_target
-                            )
-
-                        variables = None
-                        template_engine_instance = None
-                        if link_manager.is_template_file(source_file):
-                            variables = config.get_merged_variables(pkg_name)
-                            template_engine_instance = TemplateEngine()
-
-                        link_status = link_manager.get_link_status(
-                            source_file,
-                            file_target,
-                            template_engine_instance,
-                            variables,
-                        )
-
-                        status_str = status_styles.get(
-                            link_status, str(link_status.value)
-                        )
-                        table.add_row(pkg_name, str(display_target), status_str)
+                pairs = [
+                    (f, link_manager.derive_target(f, source, target))
+                    for f in source.rglob("*")
+                    if f.is_file()
+                ]
             else:
-                display_target = target
-                if link_manager.is_template_file(source):
-                    display_target = link_manager.get_template_target(target)
-
-                variables = None
-                template_engine_instance = None
-                if link_manager.is_template_file(source):
-                    variables = config.get_merged_variables(pkg_name)
-                    template_engine_instance = TemplateEngine()
+                pairs = [(source, target)]
 
+            for source_file, file_target in pairs:
                 link_status = link_manager.get_link_status(
-                    source, target, template_engine_instance, variables
+                    source_file, file_target, template_engine, variables
                 )
                 status_str = status_styles.get(link_status, str(link_status.value))
-                table.add_row(pkg_name, str(display_target), status_str)
+                table.add_row(pkg_name, str(file_target), status_str)
 
     console.print(table)
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli/commands/watch.py

@@ -137,7 +137,7 @@ def watch(
                 dry_run=dry_run,
                 config_dir=config_dir,
                 backup_dir=backup_dir,
-                template_suffix=None,
+                repo_name=repo_name,
             )
 
         if once:
@@ -197,7 +197,7 @@ def watch(
                         dry_run=dry_run,
                         config_dir=config_dir,
                         backup_dir=backup_dir,
-                        template_suffix=None,
+                        repo_name=repo_name,
                     )
 
                     deploy_scheduled = False

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/cli_utils.py

@@ -2,13 +2,13 @@
 
 import os
 from pathlib import Path
-from typing import Annotated
 
 import typer
 from rich.console import Console
 
 from dotman import __version__
 from dotman.core.config import Config, get_repo_manager
+from dotman.core.exceptions import DotmanError
 
 console = Console()
 
@@ -27,32 +27,24 @@ repo_app = typer.Typer(
 def get_config(
     config_dir: Path | None = None,
     backup_dir: str | None = None,
-    template_suffix: str | None = None,
     repo_name: str | None = None,
 ) -> Config:
-    """Get the configuration instance."""
-    if config_dir is None:
-        if os.environ.get("DOTMAN_CONFIG_DIR"):
-            config_dir = Path(os.environ["DOTMAN_CONFIG_DIR"])
+    """Resolve which dotfiles repository to use and load its configuration.
 
+    Priority: --repo > --config-dir > $DOTMAN_CONFIG_DIR > cwd, and if cwd is
+    not a dotman repo, the default registered repository.
+    """
     if repo_name is not None:
-        repo_manager = get_repo_manager()
-        repo_config = repo_manager.get_repository(repo_name)
-        config_dir = repo_config.path
-
-    repo_dir = config_dir if config_dir is not None else Path.cwd()
-
-    return Config(repo_dir, repo_name=repo_name)
-
-
-def get_repository_option() -> Annotated[
-    str | None,
-    typer.Option(
-        "--repo", "-r", help="Repository name (uses default if not specified)"
-    ),
-]:
-    """Repository option for CLI commands."""
-    return None
+        config_dir = get_repo_manager().get_repository(repo_name).path
+    elif config_dir is None and os.environ.get("DOTMAN_CONFIG_DIR"):
+        config_dir = Path(os.environ["DOTMAN_CONFIG_DIR"])
+    elif config_dir is None and not Config(Path.cwd()).is_initialized():
+        try:
+            config_dir = get_repo_manager().get_repository(None).path
+        except DotmanError:
+            pass
+
+    return Config(config_dir or Path.cwd(), repo_name=repo_name, backup_dir=backup_dir)
 
 
 @app.callback(invoke_without_command=True)

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/core/config.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel, Field
 
 from dotman.core.exceptions import (
     CircularDependencyError,
+    CircularIncludeError,
+    ConfigIncludeNotFoundError,
     ConfigNotFoundError,
     ConfigParseError,
     MissingDependencyError,
@@ -79,6 +81,15 @@ class LocalConfig(BaseModel):
     file_overrides: dict[str, dict[str, str]] = Field(default_factory=dict)
 
 
+def _merge_config(base: dict[str, Any], overlay: dict[str, Any]) -> None:
+    """Merge overlay into base; mapping sections merge one level deep."""
+    for key, value in overlay.items():
+        if isinstance(value, dict) and isinstance(base.get(key), dict):
+            base[key] = {**base[key], **value}
+        else:
+            base[key] = value
+
+
 def get_repo_manager(registry_dir: Path | None = None) -> RepoManager:
     """Get the repository manager instance.
 
@@ -114,7 +125,12 @@ def get_config_for_repo(
 class Config:
     """Main configuration class that merges global and local configs."""
 
-    def __init__(self, repo_dir: Path | None = None, repo_name: str | None = None):
+    def __init__(
+        self,
+        repo_dir: Path | None = None,
+        repo_name: str | None = None,
+        backup_dir: str | None = None,
+    ):
         """Initialize config for a dotfiles repository.
 
         Args:
@@ -122,9 +138,11 @@ class Config:
             Defaults to current working directory.
                       Config files are stored in repo_dir/.dotman/
             repo_name: Optional name of the repository (for display purposes)
+            backup_dir: Optional override for settings.backup_dir
         """
         self.repo_dir = repo_dir or Path.cwd()
         self.repo_name = repo_name
+        self._backup_dir_override = backup_dir
         self.dotman_dir = self.repo_dir / ".dotman"
         self.config_path = self.dotman_dir / "config.yaml"
         self.local_config_path = self.dotman_dir / "local.yaml"
@@ -157,10 +175,40 @@ class Config:
         except yaml.YAMLError as e:
             raise ConfigParseError(f"Error parsing {path}: {e}") from e
 
+    def _load_with_includes(
+        self, path: Path, stack: tuple[Path, ...] = ()
+    ) -> dict[str, Any]:
+        """Load a YAML file, merging its `includes` underneath it.
+
+        Includes resolve relative to the including file; later includes win
+        over earlier ones and the including file wins over all of them.
+
+        Raises:
+            CircularIncludeError: If a file includes itself, directly or not
+            ConfigIncludeNotFoundError: If an included file does not exist
+        """
+        path = path.resolve()
+        if path in stack:
+            chain = " -> ".join(p.name for p in (*stack, path))
+            raise CircularIncludeError(f"Circular reference detected: {chain}")
+
+        data = self._load_yaml(path)
+        merged: dict[str, Any] = {}
+        for include in data.pop("includes", None) or []:
+            include_path = (path.parent / Path(include).expanduser()).resolve()
+            if not include_path.exists():
+                raise ConfigIncludeNotFoundError(
+                    f"Included file not found: {include_path} (from {path})"
+                )
+            included = self._load_with_includes(include_path, (*stack, path))
+            _merge_config(merged, included)
+        _merge_config(merged, data)
+        return merged
+
     def _load_global_config(self) -> GlobalConfig:
         """Load the global configuration."""
         try:
-            data = self._load_yaml(self.config_path)
+            data = self._load_with_includes(self.config_path)
             return GlobalConfig(**data)
         except ConfigNotFoundError:
             return GlobalConfig()
@@ -185,8 +233,9 @@ class Config:
 
     @property
     def backup_dir(self) -> Path:
-        """Get the backup directory path."""
-        return self.dotman_dir / "backups"
+        """Get the backup directory path (relative paths are repo-relative)."""
+        backup_dir = self._backup_dir_override or self.settings.backup_dir
+        return self.repo_dir / Path(backup_dir).expanduser()
 
     def get_enabled_packages(self) -> list[str]:
         """Get list of packages enabled in local config."""

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/core/link_manager.py

@@ -1,6 +1,7 @@
 """Symlink management for Dotman."""
 
 import shutil
+import uuid
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
@@ -112,14 +113,13 @@ class LinkManager:
         # Check if source is a template file
         if self.is_template_file(source):
             # For template files, we check if the rendered file exists
-            template_target = self.get_template_target(target)
-            if not template_target.exists():
+            if not target.exists():
                 return LinkStatus.NOT_DEPLOYED
 
             # If template_engine is provided, compare content
             if template_engine is not None:
                 is_synced, _ = self.compare_content(
-                    source, template_target, variables or {}, template_engine
+                    source, target, variables or {}, template_engine
                 )
                 return LinkStatus.MODIFIED if not is_synced else LinkStatus.SYNCED
 
@@ -167,6 +167,18 @@ class LinkManager:
             )
         ]
 
+    def derive_target(
+        self, source_file: Path, source_dir: Path, target_dir: Path
+    ) -> Path:
+        """Map a file inside a source directory to its target path.
+
+        Templates found inside directories drop their .j2 suffix.
+        """
+        target_file = target_dir / source_file.relative_to(source_dir)
+        if self.is_template_file(source_file):
+            return self.get_template_target(target_file)
+        return target_file
+
     def _create_links_recursive(
         self,
         source_dir: Path,
@@ -182,8 +194,7 @@ class LinkManager:
         for source_file in source_dir.rglob("*"):
             if source_file.is_file():
                 # Calculate relative path and target location
-                relative_path = source_file.relative_to(source_dir)
-                target_file = target_dir / relative_path
+                target_file = self.derive_target(source_file, source_dir, target_dir)
 
                 result = self._create_single_link(
                     source_file, target_file, force, dry_run, template_engine, variables
@@ -202,27 +213,33 @@ class LinkManager:
         variables: dict[str, Any] | None = None,
     ) -> LinkResult:
         """Create a single symlink from target to source."""
-        # Handle template files by rendering them first (no symlink for templates)
+        # Handle template files by rendering them (no symlink for templates)
         if template_engine and self.is_template_file(source):
-            target_file = self.get_template_target(target)
             try:
-                if not dry_run:
-                    # Render the template to the target location
-                    template_engine.render_file(source, variables or {}, target_file)
+                if dry_run:
                     return LinkResult(
                         source=source,
-                        target=target_file,
+                        target=target,
                         status=LinkStatus.LINKED,
-                        message=f"Rendered template: {target_file}",
+                        message=f"Would render template: {target}",
                     )
-                else:
-                    return LinkResult(
-                        source=source,
-                        target=target_file,
-                        status=LinkStatus.LINKED,
-                        message=f"Would render template: {target_file}",
-                    )
-            except Exception as e:
+                rendered = template_engine.render_file(source, variables or {})
+                backed_up = None
+                if target.is_symlink():
+                    # Writing would go through the link into the repo
+                    target.unlink()
+                elif target.exists() and target.read_text() != rendered:
+                    backed_up = self._backup_file(target)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_text(rendered)
+                return LinkResult(
+                    source=source,
+                    target=target,
+                    status=LinkStatus.LINKED,
+                    message=f"Rendered template: {target}",
+                    backed_up=backed_up,
+                )
+            except (OSError, TemplateRenderError) as e:
                 raise TemplateRenderError(
                     f"Failed to render template {source}: {e}"
                 ) from e
@@ -295,7 +312,7 @@ class LinkManager:
         """Backup a file before replacing it."""
         self.backup_dir.mkdir(parents=True, exist_ok=True)
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        backup_name = f"{path.name}.{timestamp}"
+        backup_name = f"{path.name}.{timestamp}.{uuid.uuid4().hex[:6]}"
         backup_path = self.backup_dir / backup_name
         shutil.move(str(path), str(backup_path))
         return backup_path
@@ -324,8 +341,7 @@ class LinkManager:
 
         for source_file in source_dir.rglob("*"):
             if source_file.is_file():
-                relative_path = source_file.relative_to(source_dir)
-                target_file = target_dir / relative_path
+                target_file = self.derive_target(source_file, source_dir, target_dir)
 
                 result = self._remove_single_link(source_file, target_file, dry_run)
                 results.append(result)

dotman_cli-0.4.0/src/dotman/main.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""Dotman - A dotfile manager for symlinks and templates."""
+
+import sys
+
+from dotman.cli import app, console
+from dotman.core.exceptions import DotmanError
+
+
+def main() -> None:
+    """Entry point for the dotman CLI."""
+    try:
+        app()
+    except DotmanError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/managers/history.py

@@ -197,8 +197,5 @@ class HistoryManager:
 
     def cleanup_backup(self, backup_path: Path, dry_run: bool = False) -> None:
         """Remove a backup file after successful restoration."""
-        if backup_path.exists():
-            if not dry_run:
-                backup_path.unlink()
-            elif backup_path.exists():
-                backup_path.unlink()
+        if backup_path.exists() and not dry_run:
+            backup_path.unlink()

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/managers/remote.py

@@ -149,7 +149,13 @@ class RemoteManager:
         if not target_dir.exists():
             raise RemoteCloneError(f"Clone failed: {target_dir} was not created")
 
-        self._run_git_command(["lfs", "install"], cwd=target_dir)
+        if auth_token:
+            # The token was embedded in the URL; keep it out of .git/config
+            self._run_git_command(
+                ["remote", "set-url", "origin", url], cwd=target_dir, check=False
+            )
+        # git-lfs is optional: a missing binary must not fail a finished clone
+        self._run_git_command(["lfs", "install"], cwd=target_dir, check=False)
 
         return target_dir
 
@@ -324,6 +330,15 @@ class RemoteManager:
         result = self._run_git_command(["diff", "--quiet"], check=False)
         return result.returncode != 0
 
+    def has_changes(self) -> bool:
+        """Check for staged, unstaged, or untracked changes.
+
+        Returns:
+            True if `git add -A` would have something to commit
+        """
+        result = self._run_git_command(["status", "--porcelain"])
+        return bool(cast(str, result.stdout).strip())
+
     def add_remote(self, name: str, url: str) -> None:
         """Add a remote to the repository.
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman/managers/watcher.py

@@ -468,6 +468,10 @@ def create_watcher() -> FileSystemWatcher:
         A FileSystemWatcher instance appropriate for the current platform
     """
     if sys.platform == "linux":
+        try:
+            import inotify.adapters  # noqa: F401
+        except ImportError:
+            return PollingWatcher()
         return InotifyWatcher()
     elif sys.platform == "darwin":
         return KqueueWatcher()

{dotman_cli-0.3.0 → dotman_cli-0.4.0/src/dotman_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotman-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: One more dot file manager but an interesting and easy to use one.
 Author: Nimit Bhardwaj
 License: MIT
@@ -155,6 +155,7 @@ packages:
 | `dotman deploy [packages]`   | Deploy dotfiles (create symlinks)              |
 | `dotman undeploy [packages]` | Remove deployed symlinks                       |
 | `dotman status [packages]`   | Show status of deployed dotfiles               |
+| `dotman diff [packages]`     | Diff deployed files against what deploy would write (exit 1 on drift) |
 | `dotman list`                | List all available packages                    |
 | `dotman absorb [packages]`   | Absorb unmanaged files from target directories |
 | `dotman watch`               | Watch for file changes and deploy automatically |
@@ -170,6 +171,8 @@ packages:
 ### Options
 
 - `--config-dir, -c` - Override the config directory (default: `.dotman/` in current directory or `DOTMAN_CONFIG_DIR` env var)
+- `--repo, -r` - Use a registered repository. With no flag and no dotman repo in the current directory, the default registered repository is used, so `dotman status` works from anywhere
+- `--backup-dir` - Override `settings.backup_dir` (relative paths are relative to the repo)
 - `--dry-run, -n` - Preview changes without applying them
 - `--force, -f` - Overwrite existing files (with backup)
 - Specific packages can be passed to commands for targeted operations
@@ -220,7 +223,7 @@ packages:
           - ".git/**" # Ignore git directories
 ```
 
-The `absorb_ignore` field accepts a list of regex patterns that are matched against the full file path. If a file matches any pattern, it will be skipped during absorption.
+Each `absorb_ignore` entry is tried as a glob against the path relative to the target (and the file name), then as a regex against the full path. If a file matches any pattern, it is skipped during absorption.
 
 ## Doctor Configuration
 

{dotman_cli-0.3.0 → dotman_cli-0.4.0}/src/dotman_cli.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ 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/diff.py
 src/dotman/cli/commands/doctor.py
 src/dotman/cli/commands/history.py
 src/dotman/cli/commands/init.py

dotman_cli-0.3.0/src/dotman/main.py

@@ -1,13 +0,0 @@
-#!/usr/bin/env python3
-"""Dotman - A dotfile manager for symlinks and templates."""
-
-from dotman.cli import app
-
-
-def main() -> None:
-    """Entry point for the dotman CLI."""
-    app()
-
-
-if __name__ == "__main__":
-    main()