dotman-git 1.0.0__py3-none-any.whl

dot_man/cli/add_cmd.py

@@ -0,0 +1,167 @@
+"""Add command for dot-man CLI."""
+
+from pathlib import Path
+
+import click
+
+from .. import ui
+from ..config import DotManConfig, GlobalConfig
+from ..constants import REPO_DIR
+from ..exceptions import DotManError
+from ..files import copy_directory, copy_file
+from .common import error, get_secret_handler, require_init, success, warn
+from .interface import cli as main
+
+
+@main.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option(
+    "--section", "-s", help="Section name (default: auto-generated from path)"
+)
+@click.option(
+    "--repo-base", "-r", help="Base directory in repo (default: section name)"
+)
+@click.option(
+    "--exclude",
+    "-e",
+    multiple=True,
+    help="Patterns to exclude (can be specified multiple times)",
+)
+@click.option(
+    "--include",
+    "-i",
+    multiple=True,
+    help="Patterns to include (can be specified multiple times)",
+)
+@click.option(
+    "--inherits",
+    "-t",
+    multiple=True,
+    help="Templates to inherit from (can be specified multiple times)",
+)
+@click.option("--post-deploy", help="Command to run after deploying")
+@click.option("--pre-deploy", help="Command to run before deploying")
+@require_init
+def add(
+    path: str,
+    section: str | None,
+    repo_base: str | None,
+    exclude: tuple,
+    include: tuple,
+    inherits: tuple,
+    post_deploy: str | None,
+    pre_deploy: str | None,
+):
+    """Add a file or directory to be tracked.
+
+    Adds the specified path to the dot-man.toml configuration and copies
+    the content to the repository.
+
+    Examples:
+        dot-man add ~/.bashrc
+        dot-man add ~/.config/fish --section fish --exclude "*.log"
+        dot-man add ~/.config/hypr --inherits linux-gui --post-deploy "hyprctl reload"
+    """
+    try:
+        local_path = Path(path).expanduser().resolve()
+
+        # Auto-generate section name if not provided
+        if not section:
+            if local_path.is_dir() and str(local_path).startswith(
+                str(Path.home() / ".config")
+            ):
+                section = local_path.name
+            else:
+                section = local_path.stem or local_path.name
+
+        repo_base = repo_base or section
+
+        # Load config
+        global_config = GlobalConfig()
+        global_config.load()
+
+        dotman_config = DotManConfig(global_config=global_config)
+        try:
+            dotman_config.load()
+        except (FileNotFoundError, DotManError):
+            dotman_config.create_default()
+            dotman_config.load()
+
+        # Check for duplicates
+        existing_sections = dotman_config.get_section_names()
+        if section in existing_sections:
+            error(
+                f"Section '{section}' already exists. Use a different --section name."
+            )
+
+        # Convert to home-relative path for config
+        path_str = str(local_path)
+        home = str(Path.home())
+        if path_str.startswith(home):
+            path_str = path_str.replace(home, "~", 1)
+
+        # Add section to config
+        dotman_config.add_section(
+            name=section,
+            paths=[path_str],
+            repo_base=repo_base,
+            exclude=list(exclude) if exclude else None,
+            include=list(include) if include else None,
+            inherits=list(inherits) if inherits else None,
+            post_deploy=post_deploy,
+            pre_deploy=pre_deploy,
+        )
+        dotman_config.save()
+
+        # Copy content to repo
+        repo_dest = REPO_DIR / repo_base
+
+        if local_path.is_file():
+            repo_dest = repo_dest / local_path.name
+            try:
+                secret_handler = get_secret_handler()
+                success_copy, secrets = copy_file(
+                    local_path,
+                    repo_dest,
+                    filter_secrets_enabled=True,
+                    secret_handler=secret_handler,
+                )
+                if success_copy:
+                    success(f"Added file: {local_path}")
+                    ui.console.print(f"  Section: [cyan][{section}][/cyan]")
+                    ui.console.print(f"  Repo path: [dim]{repo_dest}[/dim]")
+                    if secrets:
+                        warn(f"{len(secrets)} secrets were redacted")
+                else:
+                    error(f"Failed to copy file: {local_path}")
+            except (FileNotFoundError, OSError) as e:
+                error(f"Failed to access file {local_path}: {e}")
+            except Exception as e:
+                error(f"Error copying file {local_path}: {e}")
+        else:
+            secret_handler = get_secret_handler()
+            copied, failed, secrets = copy_directory(
+                local_path,
+                repo_dest,
+                filter_secrets_enabled=True,
+                exclude_patterns=list(exclude) if exclude else None,
+                include_patterns=list(include) if include else None,
+                secret_handler=secret_handler,
+            )
+            success(f"Added directory: {local_path}")
+            ui.console.print(f"  Section: [cyan][{section}][/cyan]")
+            ui.console.print(f"  Repo path: [dim]{repo_dest}[/dim]")
+            ui.console.print(f"  Files: {copied} copied, {failed} failed")
+            if secrets:
+                warn(f"{len(secrets)} secrets were redacted")
+
+        if inherits:
+            ui.console.print(f"  Inherits: {', '.join(inherits)}")
+
+        ui.console.print()
+        ui.console.print("[dim]Run 'dot-man switch <branch>' to commit changes.[/dim]")
+
+    except DotManError as e:
+        error(str(e), e.exit_code)
+    except Exception as e:
+        error(f"Failed to add: {e}")

dot_man/cli/audit_cmd.py

@@ -0,0 +1,141 @@
+"""Audit command for dot-man CLI."""
+
+import click
+
+from .. import ui
+from ..constants import REPO_DIR
+from ..core import GitManager
+from ..exceptions import DotManError
+from ..secrets import PermanentRedactGuard, SecretGuard, SecretMatch, SecretScanner
+from .common import error, handle_exception, require_init, success
+from .interface import cli as main
+
+
+@main.command()
+@click.option(
+    "--strict", is_flag=True, help="Exit with error if secrets found (for CI/CD)"
+)
+@click.option("--fix", is_flag=True, help="Automatically redact found secrets")
+@require_init
+def audit(strict: bool, fix: bool):
+    """Scan repository for accidentally committed secrets.
+
+    Scans all files in the repository for API keys, passwords,
+    private keys, and other sensitive data.
+
+    Use --strict in CI/CD pipelines to fail builds if secrets are found.
+    """
+    try:
+        scanner = SecretScanner()
+        guard = SecretGuard()
+        permanent_guard = PermanentRedactGuard()
+
+        ui.console.print("🔒 [bold]Security Audit[/bold]")
+        ui.console.print()
+        ui.console.print(f"Scanning [cyan]{REPO_DIR}[/cyan]...")
+        ui.console.print()
+
+        all_matches = list(scanner.scan_directory(REPO_DIR))
+
+        # Filter out allowed or permanently redacted secrets
+        matches = [
+            match
+            for match in all_matches
+            if not guard.is_allowed(match.file, match.line_content, match.pattern_name)
+            and not permanent_guard.should_redact(
+                match.file, match.line_content, match.pattern_name
+            )
+        ]
+
+        if not matches:
+            success("No secrets detected. Repository is clean!")
+            return
+
+        # Group by severity
+        from typing import Dict, List
+
+        by_severity: Dict[str, List[SecretMatch]] = {}
+        for match in matches:
+            severity = match.severity.value
+            if severity not in by_severity:
+                by_severity[severity] = []
+            by_severity[severity].append(match)
+
+        # Display results
+        severity_order = ["CRITICAL", "HIGH", "MEDIUM", "LOW"]
+        severity_colors = {
+            "CRITICAL": "red",
+            "HIGH": "yellow",
+            "MEDIUM": "blue",
+            "LOW": "dim",
+        }
+
+        for severity in severity_order:
+            if severity not in by_severity:
+                continue
+
+            color = severity_colors[severity]
+            items = by_severity[severity]
+
+            ui.console.print(f"[{color}]{severity}[/{color}] ({len(items)} findings)")
+            ui.console.print("─" * 50)
+
+            for match in items:
+                rel_path = match.file.relative_to(REPO_DIR)
+                ui.console.print(f"  File: [cyan]{rel_path}[/cyan]")
+                ui.console.print(
+                    f"  Line {match.line_number}: {match.line_content[:60]}..."
+                )
+                ui.console.print(f"  Pattern: {match.pattern_name}")
+                ui.console.print()
+
+        # Summary
+        ui.console.print("─" * 50)
+        ui.console.print(
+            f"[bold]Total:[/bold] {len(matches)} secrets in {len(set(m.file for m in matches))} files"
+        )
+        ui.console.print()
+
+        # Recommendations
+        ui.console.print("[bold]Recommendations:[/bold]")
+        ui.console.print(
+            "  1. Enable [cyan]secrets_filter = true[/cyan] for affected files"
+        )
+        ui.console.print("  2. Move credentials to environment variables")
+        ui.console.print("  3. Run [cyan]dot-man audit --fix[/cyan] to auto-redact")
+
+        if fix:
+            ui.console.print()
+            if not ui.confirm("Auto-redact all detected secrets?"):
+                ui.info("Aborted.")
+                return
+
+            # Perform redaction
+            fixed_files = set()
+            for match in matches:
+                if match.file in fixed_files:
+                    continue
+
+                content = match.file.read_text()
+                redacted, count = scanner.redact_content(content)
+                if count > 0:
+                    match.file.write_text(redacted)
+                    fixed_files.add(match.file)
+                    ui.console.print(
+                        f"  [green]✓[/green] Redacted {count} secrets in {match.file.name}"
+                    )
+
+            # Commit changes
+            git = GitManager()
+            git.commit("Security: Auto-redacted secrets detected by audit")
+            success(f"Redacted secrets in {len(fixed_files)} files")
+
+        if strict:
+            error("Secrets detected (strict mode)", exit_code=50)
+
+    except DotManError as e:
+        error(str(e), e.exit_code)
+    except KeyboardInterrupt:
+        handle_exception(KeyboardInterrupt())
+    except Exception as e:
+        handle_exception(e, "Audit")

dot_man/cli/backup_cmd.py

@@ -0,0 +1,105 @@
+"""Backup command for dot-man CLI."""
+
+import click
+from rich.table import Table
+
+from .. import ui
+from .common import error, require_init, success
+from .interface import cli as main
+
+
+@main.group()
+def backup():
+    """Manage local safety backups."""
+    pass
+
+
+@backup.command("create")
+@click.argument("note", required=False, default="manual")
+@require_init
+def backup_create(note: str):
+    """Create a manual backup snapshot.
+
+    Backups all currently tracked files to a local snapshot.
+    """
+    try:
+        from ..operations import get_operations
+
+        ops = get_operations()
+
+        # Collect all tracked files
+        paths_to_backup = []
+        for section_name in ops.get_sections():
+            section = ops.get_section(section_name)
+            paths_to_backup.extend([p for p in section.paths if p.exists()])
+
+        if not paths_to_backup:
+            ui.warn("No tracked files found to backup.")
+            return
+
+        ui.console.print("[bold]Creating backup...[/bold]")
+        backup_id = ops.backups.create_backup(paths_to_backup, note=note)
+
+        if backup_id:
+            success(f"Backup created: [cyan]{backup_id}[/cyan]")
+        else:
+            ui.warn("Backup created but empty (no files found).")
+
+    except Exception as e:
+        error(f"Failed to create backup: {e}")
+
+
+@backup.command("list")
+@require_init
+def backup_list():
+    """List available backups."""
+    try:
+        from ..operations import get_operations
+
+        ops = get_operations()
+        backups = ops.backups.list_backups()
+
+        if not backups:
+            ui.console.print("[dim]No backups found[/dim]")
+            return
+
+        table = Table(title="Local Backups")
+        table.add_column("ID", style="cyan")
+        table.add_column("Date")
+        table.add_column("Note")
+
+        for b in backups:
+            table.add_row(b["id"], b["date"], b["note"])
+
+        ui.console.print(table)
+
+    except Exception as e:
+        error(f"Failed to list backups: {e}")
+
+
+@backup.command("restore")
+@click.argument("backup_id")
+@click.option("--force", is_flag=True, help="Skip confirmation")
+@require_init
+def backup_restore(backup_id: str, force: bool):
+    """Restore files from a backup snapshot.
+
+    WARNING: This will overwrite current local files with the backup version.
+    """
+    try:
+        from ..operations import get_operations
+
+        ops = get_operations()
+
+        if not force:
+            if not ui.confirm(
+                f"Restore backup '{backup_id}'? This will overwrite local files."
+            ):
+                return
+
+        ui.console.print(f"[bold]Restoring backup {backup_id}...[/bold]")
+        ops.backups.restore_backup(backup_id)
+        success("Backup restored successfully!")
+
+    except Exception as e:
+        error(f"Failed to restore backup: {e}")

dot_man/cli/branch_cmd.py

@@ -0,0 +1,103 @@
+"""Branch command for dot-man CLI."""
+
+import click
+from rich.table import Table
+
+from .. import ui
+from ..config import GlobalConfig
+from ..core import GitManager
+from ..exceptions import DotManError
+from .common import complete_branches, error, handle_exception, require_init, success
+from .interface import cli as main
+
+
+@main.group()
+def branch():
+    """Manage configuration branches."""
+    pass
+
+
+@branch.command("list")
+@require_init
+def branch_list():
+    """List all configuration branches."""
+    try:
+        git = GitManager()
+        global_config = GlobalConfig()
+        global_config.load()
+
+        current = global_config.current_branch
+        branches = git.list_branches()
+
+        if not branches:
+            ui.console.print("[dim]No branches found[/dim]")
+            return
+
+        table = Table(title="Branches")
+        table.add_column("Branch")
+        table.add_column("Active")
+
+        for b in branches:
+            active = "[green]✓[/green]" if b == current else ""
+            style = "bold" if b == current else ""
+            table.add_row(f"[{style}]{b}[/{style}]" if style else b, active)
+
+        ui.console.print(table)
+
+    except KeyboardInterrupt:
+        handle_exception(KeyboardInterrupt())
+    except Exception as e:
+        handle_exception(e, "Branch list")
+
+
+@branch.command("delete")
+@click.argument("name", shell_complete=complete_branches)
+@click.option("--force", "-f", is_flag=True, help="Force delete without confirmation")
+@require_init
+def branch_delete(name: str, force: bool):
+    """Delete a configuration branch."""
+    try:
+        git = GitManager()
+        global_config = GlobalConfig()
+        global_config.load()
+
+        if name == global_config.current_branch:
+            branches = git.list_branches()
+            available = [b for b in branches if b != name]
+            error(
+                f"Cannot delete the active branch '{name}'.\n"
+                f"  💡 Switch to another branch first: dot-man navigate <branch>\n"
+                f"  Available branches: {', '.join(available) if available else '(none)'}"
+            )
+
+        if not git.branch_exists(name):
+            error(f"Branch '{name}' not found")
+
+        if not force:
+            if not ui.confirm(f"Delete branch '{name}'? This cannot be undone"):
+                ui.info("Aborted.")
+                return
+
+        git.delete_branch(name, force=force)
+        success(f"Deleted branch '{name}'")
+
+    except DotManError as e:
+        from ..exceptions import BranchNotMergedError
+
+        if isinstance(e, BranchNotMergedError):
+            if ui.confirm(f"Branch '{name}' is not fully merged. Force delete?"):
+                try:
+                    git.delete_branch(name, force=True)  # type: ignore
+                    success(f"Deleted branch '{name}'")
+                    return
+                except Exception as e2:
+                    error(f"Failed to force delete: {e2}")
+            else:
+                ui.info("Aborted.")
+                return
+
+        error(str(e), e.exit_code)
+    except KeyboardInterrupt:
+        handle_exception(KeyboardInterrupt())
+    except Exception as e:
+        handle_exception(e, "Branch delete")

dot_man/cli/clean_cmd.py

@@ -0,0 +1,97 @@
+"""Clean command for dot-man CLI."""
+
+import click
+
+from .. import ui
+from ..constants import REPO_DIR
+from .common import error, require_init, success
+from .interface import cli as main
+
+
+@main.command("clean")
+@click.option("--backups", is_flag=True, help="Clean old backups")
+@click.option("--orphans", is_flag=True, help="Clean orphaned files from repo")
+@click.option("--all", "clean_all", is_flag=True, help="Clean both backups and orphans")
+@click.option(
+    "--keep", type=int, default=0, help="Number of backups to keep (default 0)"
+)
+@click.option("--force", is_flag=True, help="Skip confirmation")
+@click.option("--dry-run", is_flag=True, help="Preview what would be deleted")
+@require_init
+def clean(
+    backups: bool, orphans: bool, clean_all: bool, keep: int, force: bool, dry_run: bool
+):
+    """Clean stale backups and orphaned files.
+
+    Removes old backups and files in the repository that are no longer tracked
+    by any configuration section.
+    """
+    if not (backups or orphans or clean_all):
+        ui.warn("Please specify what to clean: --backups, --orphans, or --all")
+        return
+
+    try:
+        from ..operations import get_operations
+
+        ops = get_operations()
+
+        # 1. Clean Backups
+        if backups or clean_all:
+            ui.console.print("[bold]Checking backups...[/bold]")
+            if dry_run:
+                # Preview backups to delete
+                all_backups = ops.backups.list_backups()
+                if len(all_backups) > keep:
+                    to_delete = all_backups[keep:]
+                    ui.console.print(
+                        f"[bold]Backups to be deleted ({len(to_delete)}):[/bold]",
+                        style="red",
+                    )
+                    for b in to_delete:
+                        ui.console.print(f"  - {b['id']} ({b['note']})")
+                else:
+                    ui.console.print("  No backups to clean.")
+            else:
+                current_backups_count = len(ops.backups.list_backups())
+                if current_backups_count > keep:
+                    if force or ui.confirm(
+                        f"Clean up backups (keeping {keep} newest)?"
+                    ):
+                        deleted = ops.backups.clean_backups(keep=keep)
+                        if deleted > 0:
+                            success(f"Deleted {deleted} old backups.")
+                        else:
+                            ui.console.print("No backups cleaned.")
+                else:
+                    ui.console.print("  No backups to clean.")
+
+        # 2. Clean Orphans
+        if orphans or clean_all:
+            ui.console.print("[bold]Checking for orphaned files...[/bold]")
+            orphaned_files = ops.get_orphaned_files()
+
+            if not orphaned_files:
+                ui.console.print("  No orphaned files found.")
+                return
+
+            if dry_run:
+                ui.console.print(
+                    f"[bold]Orphaned files to be deleted ({len(orphaned_files)}):[/bold]",
+                    style="red",
+                )
+                for p in orphaned_files:
+                    # Show path relative to repo
+                    try:
+                        rel_path = p.relative_to(REPO_DIR)
+                        ui.console.print(f"  - {rel_path}")
+                    except ValueError:
+                        ui.console.print(f"  - {p.name}")
+            else:
+                if force or ui.confirm(
+                    f"Found {len(orphaned_files)} orphaned files. Delete them?"
+                ):
+                    deleted_files = ops.clean_orphaned_files(dry_run=False)
+                    success(f"Deleted {len(deleted_files)} orphaned files.")
+
+    except Exception as e:
+        error(f"Failed to clean: {e}")