dotman-git 1.0.0__py3-none-any.whl

dot_man/cli/deploy_cmd.py

@@ -0,0 +1,169 @@
+"""Deploy command for dot-man CLI."""
+
+import subprocess
+
+import click
+from rich.panel import Panel
+
+from .. import ui
+from ..exceptions import DotManError
+from .common import (
+    complete_branches,
+    error,
+    handle_exception,
+    require_init,
+    success,
+    warn,
+)
+from .interface import cli as main
+
+
+@main.command()
+@click.argument("branch", shell_complete=complete_branches)
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+@click.option("--dry-run", is_flag=True, help="Show what would be deployed")
+@require_init
+def deploy(branch: str, force: bool, dry_run: bool):
+    """One-way deployment of a branch configuration.
+
+    Deploys files from the specified branch to your home directory.
+    Unlike 'switch', this does NOT save current local changes first.
+    Typically used for setting up a new machine.
+
+    Example: dot-man deploy main
+    """
+    try:
+        from ..operations import get_operations
+
+        ops = get_operations()
+        git = ops.git
+
+        # Check branch exists
+        if not git.branch_exists(branch):
+            available = ", ".join(git.list_branches())
+            error(f"Branch '{branch}' not found. Available: {available}")
+
+        if not force and not dry_run:
+            ui.console.print(
+                Panel(
+                    "[yellow]WARNING: Deploy will OVERWRITE local files![/yellow]\n\n"
+                    "This will:\n"
+                    f"• Deploy '{branch}' configuration\n"
+                    "• Overwrite existing dotfiles\n"
+                    "• Local changes will be LOST\n\n"
+                    "[dim]Typical use: Setting up a new machine[/dim]",
+                    title="⚠️  Destructive Operation",
+                    border_style="yellow",
+                )
+            )
+
+            if not ui.confirm("Continue?"):
+                ui.info("Aborted.")
+                return
+
+        # Checkout branch
+        if not dry_run:
+            git.checkout(branch)
+            ops.reload_config()
+
+        # Get sections
+        section_names = ops.get_sections()
+        if not section_names:
+            warn("No files configured in this branch")
+            return
+
+        sections = [ops.get_section(name) for name in section_names]
+
+        # Phase 1: Scan
+        if not dry_run:
+            ui.console.print("Scanning for changes...")
+
+        plan = ops.scan_deployable_changes(sections)
+
+        sections_to_process = plan["sections_to_deploy"]
+        pre_hooks = list(dict.fromkeys(plan["pre_hooks"]))
+        post_hooks = list(dict.fromkeys(plan["post_hooks"]))
+        scan_errors = plan["errors"]
+
+        for err in scan_errors:
+            warn(err)
+
+        if not sections_to_process:
+            ui.console.print("[yellow]No changes detected.[/yellow]")
+            return
+
+        # Display Plan / Dry Run
+        if dry_run:
+            ui.console.print(
+                f"\n[bold]Dry Run Summary - {len(sections_to_process)} files to deploy:[/bold]"
+            )
+            for section, local_path, repo_path in sections_to_process:
+                action = "OVERWRITE" if local_path.exists() else "CREATE"
+                ui.console.print(f"  {action}: {local_path}")
+
+            if pre_hooks:
+                ui.console.print("\n[bold]Pre-Hooks:[/bold]")
+                for cmd in pre_hooks:
+                    ui.console.print(f"  [dim]{cmd}[/dim]")
+
+            if post_hooks:
+                ui.console.print("\n[bold]Post-Hooks:[/bold]")
+                for cmd in post_hooks:
+                    ui.console.print(f"  [dim]{cmd}[/dim]")
+            return
+
+        # Confirm
+        ui.console.print(f"Found {len(sections_to_process)} files to deploy.")
+        if not force:
+            if not ui.confirm(f"Deploy {len(sections_to_process)} files?"):
+                ui.info("Aborted.")
+                return
+
+        # Execute Pre-Hooks
+        if pre_hooks:
+            ui.console.print("\n[bold]Running pre-deploy hooks...[/bold]")
+            for cmd in pre_hooks:
+                ui.console.print(f"  Exec: [cyan]{cmd}[/cyan]")
+                try:
+                    subprocess.run(cmd, shell=True, check=False)
+                except Exception as e:
+                    warn(f"Failed to run command '{cmd}': {e}")
+
+        # Phase 2: Execute Deployment (Parallel)
+        ui.console.print("\n[bold]Deploying files...[/bold]")
+        result = ops.execute_deployment_plan(plan)
+
+        deployed = result["deployed"]
+        exec_errors = result["errors"]
+
+        if exec_errors:
+            for err in exec_errors:
+                ui.console.print(f"  [red]Error:[/red] {err}")
+                import logging
+
+                logging.error(f"Deployment error: {err}")
+
+        ui.console.print(f"\nDeployed: {deployed}/{len(sections_to_process)} files.")
+
+        # Execute Post-Hooks
+        if post_hooks:
+            ui.console.print("\n[bold]Running post-deploy hooks...[/bold]")
+            for cmd in post_hooks:
+                ui.console.print(f"  Exec: [cyan]{cmd}[/cyan]")
+                try:
+                    subprocess.run(cmd, shell=True, check=False)
+                except Exception as e:
+                    warn(f"Failed to run command '{cmd}': {e}")
+
+        # Update global config
+        ops.global_config.current_branch = branch
+        ops.global_config.save()
+
+        success(f"Deployment complete! ({deployed} files)")
+
+    except DotManError as e:
+        error(str(e), e.exit_code)
+    except KeyboardInterrupt:
+        handle_exception(KeyboardInterrupt())
+    except Exception as e:
+        handle_exception(e, "Deployment")

dot_man/cli/discover_cmd.py

@@ -0,0 +1,105 @@
+"""Discover command for auto-detecting existing dotfiles."""
+
+import click
+
+from .. import ui
+from ..config_detector import ConfigDetector
+from .common import require_init
+from .interface import cli as main
+
+
+@main.command("discover")
+@click.option(
+    "--include-extended/--no-extended",
+    default=True,
+    help="Include extended configs (VS Code, Sublime, etc.)",
+)
+@click.option(
+    "--add",
+    is_flag=True,
+    help="Automatically add detected configs to dot-man.toml",
+)
+@require_init
+def discover_cmd(include_extended: bool, add: bool):
+    """Auto-detect existing dotfiles on your system.
+
+    Scans common locations for popular configuration files and directories,
+    then offers to add them to dot-man for tracking.
+
+    Examples:
+        dot-man discover                  # Show all detected dotfiles
+        dot-man discover --no-extended    # Only common configs
+        dot-man discover --add            # Auto-add to config
+    """
+    ui.console.print("[bold]🔍 Scanning for dotfiles...[/bold]")
+    ui.console.print()
+
+    detected = ConfigDetector.detect_popular_configs(include_extended=include_extended)
+    detected.extend(ConfigDetector.detect_quickshell_configs())
+
+    if not detected:
+        ui.console.print("[yellow]No dotfiles detected on this system.[/yellow]")
+        return
+
+    ui.console.print(f"[bold]Found {len(detected)} configurations:[/bold]")
+    ui.console.print()
+
+    for config in detected:
+        exists = "✓" if config["paths"] else "?"
+        hook = f" ({config['default_hook']})" if config["default_hook"] else ""
+        ui.console.print(f"  [{exists}] {config['display_name']}")
+        ui.console.print(f"       [{config['section_name']}]{hook}")
+        for path in config["paths"]:
+            ui.console.print(f"       {path}")
+
+    if add:
+        _add_detected_configs(detected)
+    else:
+        ui.console.print()
+        ui.console.print(
+            "[dim]Tip: Use --add to automatically add these to dot-man.toml[/dim]"
+        )
+
+
+def _add_detected_configs(detected: list):
+    """Add detected configs to dot-man.toml."""
+    from ..dotman_config import DotManConfig
+    from ..operations import get_operations
+
+    config = DotManConfig()
+    ops = get_operations()
+    added_count = 0
+
+    for conf in detected:
+        section_name = conf["section_name"]
+
+        if section_name in ops.get_sections():
+            continue
+
+        try:
+            config.add_section(
+                name=section_name,
+                paths=conf["paths"],
+            )
+
+            if conf["default_hook"]:
+                config.update_section(
+                    section_name,
+                    post_deploy=conf["default_hook"],
+                )
+
+            added_count += 1
+            ui.console.print(f"  [green]✓[/green] Added: {section_name}")
+        except Exception as e:
+            ui.console.print(f"  [red]✗[/red] Failed to add {section_name}: {e}")
+
+    config.save()
+
+    if added_count > 0:
+        ui.console.print()
+        ui.success(f"Added {added_count} sections to dot-man.toml")
+        ui.console.print("[dim]Run 'dot-man status' to see your tracked files[/dim]")
+    else:
+        ui.console.print(
+            "[dim]No new sections to add (already tracked or duplicates)[/dim]"
+        )

dot_man/cli/doctor_cmd.py

@@ -0,0 +1,229 @@
+"""Doctor command for dot-man CLI - diagnostics and health checks."""
+
+import os
+import shutil
+
+from .. import ui
+from ..constants import DOT_MAN_DIR, DOT_MAN_TOML, GLOBAL_TOML, REPO_DIR
+from .common import error, require_init, success
+from .interface import cli as main
+
+
+@main.command("doctor")
+@require_init
+def doctor():
+    """Run diagnostics and health checks.
+
+    Checks the dot-man installation for common issues:
+    git availability, repository integrity, configuration validity,
+    file permissions, and remote connectivity.
+    """
+    from ..operations import get_operations
+
+    checks_passed = 0
+    checks_failed = 0
+    checks_warned = 0
+
+    def check_pass(label: str, detail: str = "") -> None:
+        nonlocal checks_passed
+        checks_passed += 1
+        msg = f"[success]✓[/success] {label}"
+        if detail:
+            msg += f" [dim]({detail})[/dim]"
+        ui.console.print(msg)
+
+    def check_fail(label: str, detail: str = "") -> None:
+        nonlocal checks_failed
+        checks_failed += 1
+        msg = f"[error]✗[/error] {label}"
+        if detail:
+            msg += f" [dim]({detail})[/dim]"
+        ui.console.print(msg)
+
+    def check_warn(label: str, detail: str = "") -> None:
+        nonlocal checks_warned
+        checks_warned += 1
+        msg = f"[warning]⚠[/warning] {label}"
+        if detail:
+            msg += f" [dim]({detail})[/dim]"
+        ui.console.print(msg)
+
+    ui.console.print("[bold]dot-man doctor[/bold]")
+    ui.console.print()
+
+    # 1. Git availability
+    ui.console.print("[bold]System[/bold]")
+    git_path = shutil.which("git")
+    if git_path:
+        import subprocess
+
+        result = subprocess.run(
+            ["git", "--version"], capture_output=True, text=True, timeout=5
+        )
+        version = result.stdout.strip() if result.returncode == 0 else "unknown"
+        check_pass("Git installed", version)
+    else:
+        check_fail("Git not found", "Install git and ensure it's in PATH")
+
+    # 2. Python version
+    import sys
+
+    py_version = (
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    )
+    if sys.version_info >= (3, 9):
+        check_pass("Python version", py_version)
+    else:
+        check_fail("Python version too old", f"{py_version} (requires 3.9+)")
+
+    ui.console.print()
+
+    # 3. Repository checks
+    ui.console.print("[bold]Repository[/bold]")
+    if DOT_MAN_DIR.exists():
+        check_pass("Config directory exists", str(DOT_MAN_DIR))
+    else:
+        check_fail("Config directory missing", "Run 'dot-man init'")
+
+    if REPO_DIR.exists():
+        check_pass("Repository directory exists", str(REPO_DIR))
+    else:
+        check_fail("Repository directory missing", "Run 'dot-man init'")
+
+    # Check .git directory
+    git_dir = REPO_DIR / ".git"
+    if git_dir.exists():
+        check_pass("Git repository initialized")
+    else:
+        check_fail("No .git directory in repo", "Repository may be corrupted")
+
+    # Check repo permissions
+    if REPO_DIR.exists():
+        if os.access(REPO_DIR, os.R_OK | os.W_OK):
+            check_pass("Repository permissions", "read/write OK")
+        else:
+            check_fail("Repository permissions", "Cannot read/write to repo directory")
+
+    ui.console.print()
+
+    # 4. Configuration checks
+    ui.console.print("[bold]Configuration[/bold]")
+
+    if GLOBAL_TOML.exists():
+        check_pass("Global config exists", str(GLOBAL_TOML))
+    else:
+        check_warn("No global config", "Will use defaults")
+
+    if DOT_MAN_TOML.exists():
+        check_pass("dot-man.toml exists", str(DOT_MAN_TOML))
+        # Try to parse it
+        try:
+            ops = get_operations()
+            sections = ops.get_sections()
+            check_pass("Config is valid", f"{len(sections)} section(s)")
+        except Exception as e:
+            check_fail("Config parse error", str(e))
+    else:
+        check_warn("No dot-man.toml", "Run 'dot-man config create' or 'dot-man edit'")
+
+    ui.console.print()
+
+    # 5. Branch checks
+    ui.console.print("[bold]Branches[/bold]")
+    try:
+        ops = get_operations()
+        current = ops.current_branch
+        check_pass("Current branch", current)
+
+        branches = ops.git.list_branches()
+        check_pass("Available branches", ", ".join(branches) if branches else "none")
+    except Exception as e:
+        check_fail("Branch check failed", str(e))
+
+    ui.console.print()
+
+    # 6. Remote checks
+    ui.console.print("[bold]Remote[/bold]")
+    try:
+        ops = get_operations()
+        remote_url = ops.global_config.remote_url
+        if remote_url:
+            check_pass("Remote configured", remote_url)
+        else:
+            check_warn("No remote configured", "Run 'dot-man setup' to configure")
+    except Exception as e:
+        check_warn("Could not check remote", str(e))
+
+    ui.console.print()
+
+    # 7. Tracked files check
+    ui.console.print("[bold]Tracked Files[/bold]")
+    try:
+        ops = get_operations()
+        missing_count = 0
+        total_paths = 0
+        for section_name in ops.get_sections():
+            section = ops.get_section(section_name)
+            for p in section.paths:
+                total_paths += 1
+                if not p.exists():
+                    missing_count += 1
+                    check_warn(f"Missing: {p}", f"section '{section_name}'")
+
+        if missing_count == 0 and total_paths > 0:
+            check_pass("All tracked paths exist", f"{total_paths} path(s)")
+        elif total_paths == 0:
+            check_warn("No paths tracked", "Add files with 'dot-man add'")
+    except Exception as e:
+        check_fail("File check failed", str(e))
+
+    # 8. Orphaned files
+    try:
+        ops = get_operations()
+        orphans = ops.get_orphaned_files()
+        if orphans:
+            check_warn(
+                f"{len(orphans)} orphaned file(s) in repo",
+                "Run 'dot-man clean --orphans' to remove",
+            )
+        else:
+            check_pass("No orphaned files")
+    except Exception as e:
+        check_warn("Could not check orphans", str(e))
+
+    # 9. Backup check
+    try:
+        ops = get_operations()
+        backup_list = ops.backups.list_backups()
+        if backup_list:
+            check_pass("Backups available", f"{len(backup_list)} backup(s)")
+        else:
+            check_warn(
+                "No backups",
+                "Backups are created automatically before destructive operations",
+            )
+    except Exception as e:
+        check_warn("Could not check backups", str(e))
+
+    ui.console.print()
+
+    # Summary
+    ui.console.print("[bold]Summary[/bold]")
+    total = checks_passed + checks_failed + checks_warned
+    ui.console.print(
+        f"  [success]{checks_passed}[/success] passed, "
+        f"[warning]{checks_warned}[/warning] warnings, "
+        f"[error]{checks_failed}[/error] failed "
+        f"[dim]({total} checks)[/dim]"
+    )
+
+    if checks_failed == 0:
+        ui.console.print()
+        success("dot-man is healthy!")
+    else:
+        ui.console.print()
+        error(
+            f"{checks_failed} check(s) failed. See above for details.",
+            exit_code=0,
+        )
+        raise SystemExit(1)

dot_man/cli/edit_cmd.py

@@ -0,0 +1,177 @@
+"""Edit command for dot-man CLI."""
+
+from pathlib import Path
+
+import click
+import questionary
+
+from .. import ui
+from ..config import GlobalConfig
+from ..constants import DOT_MAN_TOML, GLOBAL_TOML, REPO_DIR
+from ..exceptions import DotManError
+from .common import error, require_init, success, warn
+from .interface import cli as main
+
+
+@main.command()
+@click.option("--editor", help="Editor to use (default: config or $VISUAL or $EDITOR)")
+@click.option("--global", "edit_global", is_flag=True, help="Edit global configuration")
+@click.option(
+    "--raw", is_flag=True, help="Use raw text editor instead of interactive TUI"
+)
+@require_init
+def edit(editor: str | None, edit_global: bool, raw: bool):
+    """Open the configuration file in your text editor.
+
+    By default, opens the dot-man.toml file for the current branch.
+    Use --global to edit the global configuration.
+    """
+    try:
+        from ..interactive import (
+            custom_style,
+            run_global_wizard,
+            run_section_wizard,
+            run_templates_wizard,
+        )
+
+        # Determine target file path
+        if edit_global:
+            target = GLOBAL_TOML
+            desc = "global configuration"
+        else:
+            target = REPO_DIR / DOT_MAN_TOML
+            desc = "dot-man.toml"
+
+        # If --raw flag, skip interactive mode
+        if raw:
+            if not target.exists():
+                error(f"Configuration file not found: {target}")
+            _open_raw_editor(target, desc, editor)
+            return
+
+        # Interactive Mode
+        from ..operations import get_operations
+
+        try:
+            ops = get_operations()
+
+            while True:
+                ops.reload_config()
+                sections = ops.get_sections()
+
+                choices = []
+                choices.append(
+                    questionary.Choice("⚙️  Global Configuration", value="global")
+                )
+
+                if sections:
+                    choices.append(questionary.Separator("--- Sections ---"))
+                    for name in sections:
+                        choices.append(
+                            questionary.Choice(f"📄 {name}", value=f"section:{name}")
+                        )
+                else:
+                    choices.append(questionary.Separator("--- No Sections ---"))
+
+                choices.append(questionary.Separator("--- Actions ---"))
+                choices.append(
+                    questionary.Choice("➕ Add New Section", value="add_new")
+                )
+                choices.append(
+                    questionary.Choice("📝 Edit Templates", value="templates")
+                )
+                choices.append(
+                    questionary.Choice("📝 Open Raw File (Advanced)", value="raw")
+                )
+                choices.append(
+                    questionary.Choice("🚪 Quit", value="quit", shortcut_key="q")
+                )
+
+                selection = questionary.select(
+                    "What would you like to configure?",
+                    choices=choices,
+                    use_shortcuts=True,
+                    style=custom_style,
+                ).ask()
+
+                if not selection or selection == "quit":
+                    break
+
+                if selection == "global":
+                    run_global_wizard(ops.global_config)
+
+                elif selection == "raw":
+                    _open_raw_editor(target, desc, editor)
+                    break
+
+                elif selection == "add_new":
+                    path_str = questionary.path(
+                        "Path to file or directory:", style=custom_style
+                    ).ask()
+                    if path_str:
+                        try:
+                            path = Path(path_str).expanduser()
+                            if not path.exists():
+                                warn(f"Path does not exist: {path}")
+                                continue
+
+                            section_name = questionary.text(
+                                "Section Name:", default=path.stem, style=custom_style
+                            ).ask()
+                            if section_name:
+                                from .add_cmd import add
+
+                                ctx = click.get_current_context()
+                                ctx.invoke(
+                                    add,
+                                    path=str(path),
+                                    section=section_name,
+                                    repo_base=None,
+                                    exclude=(),
+                                    include=(),
+                                    inherits=(),
+                                    post_deploy=None,
+                                    pre_deploy=None,
+                                )
+                                ui.console.print()
+                                ui.console.print("Press Enter to continue...")
+                                input()
+                        except Exception as e:
+                            warn(f"Error adding section: {e}")
+
+                elif selection == "templates":
+                    run_templates_wizard(ops.dotman_config)
+
+                elif selection.startswith("section:"):
+                    section_name = selection.split(":", 1)[1]
+                    run_section_wizard(ops.dotman_config, section_name)
+
+        except KeyboardInterrupt:
+            return
+        except Exception as e:
+            warn(f"Interactive menu error: {e}")
+            ui.console.print("Falling back to raw editor...")
+            _open_raw_editor(target, desc, editor)
+
+    except DotManError as e:
+        error(str(e), e.exit_code)
+
+
+def _open_raw_editor(target: Path, desc: str, editor: str | None = None):
+    """Helper to open raw editor."""
+    from ..utils import get_editor, open_in_editor
+
+    global_config = GlobalConfig()
+    try:
+        global_config.load()
+        config_editor = global_config.editor
+    except (FileNotFoundError, DotManError):
+        config_editor = None
+
+    editor_cmd = editor or config_editor or get_editor()
+    ui.console.print(f"Opening {desc} in [cyan]{editor_cmd}[/cyan]...")
+
+    if not open_in_editor(target, editor_cmd):
+        error(f"Editor '{editor_cmd}' exited with error")
+
+    success(f"Edited {desc}")