dotman-git 1.0.0__py3-none-any.whl

dot_man/cli/encrypt_cmd.py

@@ -0,0 +1,205 @@
+"""Encryption command for encrypting/decrypting sensitive dotfiles."""
+
+from pathlib import Path
+from typing import Literal
+
+import click
+
+from .. import ui
+from ..encryption import (
+    EncryptionError,
+    EncryptionManager,
+    detect_available_encryption,
+)
+from .common import error, require_init, success, warn
+from .interface import cli as main
+
+
+@main.command("encrypt")
+@click.argument("action", type=click.Choice(["encrypt", "decrypt", "status"]))
+@click.argument("section", required=False)
+@click.option(
+    "--method",
+    "-m",
+    type=click.Choice(["gpg", "age"]),
+    default="gpg",
+    help="Encryption method to use",
+)
+@click.option(
+    "--recipient",
+    "-r",
+    help="Encryption recipient (GPG key ID or AGE recipient)",
+)
+@require_init
+def encrypt_cmd(action: str, section: str | None, method: str, recipient: str | None):
+    """Encrypt or decrypt sensitive dotfile sections.
+
+    Actions:
+      encrypt  - Encrypt a section's files
+      decrypt  - Decrypt a section's files
+      status   - Show encryption status of all sections
+
+    Examples:
+        dot-man encrypt status                # Show encryption status
+        dot-man encrypt encrypt ssh-config   # Encrypt ssh-config section
+        dot-man encrypt decrypt ssh-config   # Decrypt ssh-config section
+        dot-man encrypt encrypt secrets -r age1...  # Use AGE encryption
+    """
+    available = detect_available_encryption()
+    if not available:
+        error(
+            "No encryption tools available. Install GPG or AGE:\n"
+            "  GPG: brew install gpg\n"
+            "  AGE: brew install age",
+            exit_code=1,
+        )
+
+    if method not in available:
+        warn(f"{method} not available. Using {available[0]} instead.")
+        method = available[0]  # type: ignore[assignment]
+
+    if action == "status":
+        _show_encryption_status()
+    elif action == "encrypt":
+        _encrypt_section(section, method, recipient)  # type: ignore[arg-type]
+    elif action == "decrypt":
+        _decrypt_section(section, method, recipient)  # type: ignore[arg-type]
+
+
+def _show_encryption_status():
+    """Show encryption status of all sections."""
+    from ..operations import get_operations
+
+    ops = get_operations()
+
+    ui.console.print("[bold]Encryption Status:[/bold]")
+    ui.console.print()
+
+    has_encrypted = False
+
+    for section_name in ops.get_sections():
+        section = ops.get_section(section_name)
+        if section.encrypted:
+            has_encrypted = True
+            ui.console.print(f"  [green]✓[/green] [{section_name}]")
+            ui.console.print(f"      Method: {section.encryption_method}")
+            if section.encryption_recipient:
+                ui.console.print(f"      Recipient: {section.encryption_recipient}")
+        else:
+            ui.console.print(f"  [dim]-[/dim] [{section_name}] (not encrypted)")
+
+    if not has_encrypted:
+        ui.console.print("[dim]No encrypted sections configured[/dim]")
+        ui.console.print()
+        ui.console.print("To encrypt a section, add to dot-man.toml:")
+        ui.console.print("  [cyan][ssh-config][/cyan]")
+        ui.console.print("  [cyan]encrypted = true[/cyan]")
+        ui.console.print('  [cyan]encryption_method = "gpg"[/cyan]')
+        ui.console.print('  [cyan]encryption_recipient = "your@email.com"[/cyan]')
+
+
+def _encrypt_section(
+    section_name: str | None, method: Literal["gpg", "age"], recipient: str | None
+):
+    """Encrypt a section's files."""
+    if not section_name:
+        error("Section name required for encryption", exit_code=1)
+
+    from ..dotman_config import DotManConfig
+    from ..operations import get_operations
+
+    ops = get_operations()
+    config = DotManConfig()
+
+    assert section_name is not None
+    section = ops.get_section(section_name)
+    if not section:
+        error(f"Section not found: {section_name}", exit_code=1)
+
+    if recipient is None:
+        if section.encryption_recipient:
+            recipient = section.encryption_recipient
+        else:
+            error(
+                "No recipient specified. Use --recipient or set encryption_recipient in config",
+                exit_code=1,
+            )
+
+    ui.console.print(f"[dim]Encrypting section: {section_name}[/dim]")
+
+    enc = EncryptionManager(method)
+
+    for path_str in section.paths:
+        local_path = Path(path_str).expanduser()
+        repo_dir_str = ops.git.repo.working_dir
+        assert repo_dir_str is not None
+        repo_path = section.get_repo_path(local_path, Path(repo_dir_str))
+
+        if not local_path.exists():
+            warn(f"File not found: {local_path}")
+            continue
+
+        encrypted_path = repo_path.with_suffix(repo_path.suffix + ".gpg")
+
+        try:
+            enc.encrypt_file(local_path, encrypted_path, recipient)
+            ui.console.print(f"  [green]✓[/green] Encrypted: {local_path.name}")
+        except EncryptionError as e:
+            warn(f"Failed to encrypt {local_path.name}: {e}")
+
+    config.update_section(
+        section_name,
+        encrypted=True,
+        encryption_method=method,
+        encryption_recipient=recipient,
+    )
+    config.save()
+
+    success(f"Encrypted section '{section_name}'")
+
+
+def _decrypt_section(
+    section_name: str | None, method: Literal["gpg", "age"], recipient: str | None
+):
+    """Decrypt a section's files."""
+    if not section_name:
+        error("Section name required for decryption", exit_code=1)
+
+    from ..dotman_config import DotManConfig
+    from ..operations import get_operations
+
+    ops = get_operations()
+    config = DotManConfig()
+
+    assert section_name is not None
+    section = ops.get_section(section_name)
+    if not section:
+        error(f"Section not found: {section_name}", exit_code=1)
+
+    ui.console.print(f"[dim]Decrypting section: {section_name}[/dim]")
+
+    enc = EncryptionManager(method)
+
+    for path_str in section.paths:
+        local_path = Path(path_str).expanduser()
+        repo_dir_str = ops.git.repo.working_dir
+        assert repo_dir_str is not None
+        repo_path = section.get_repo_path(local_path, Path(repo_dir_str))
+
+        encrypted_path = repo_path.with_suffix(repo_path.suffix + ".gpg")
+
+        if not encrypted_path.exists():
+            warn(f"Encrypted file not found: {encrypted_path}")
+            continue
+
+        try:
+            enc.decrypt_file(encrypted_path, local_path, recipient)
+            ui.console.print(f"  [green]✓[/green] Decrypted: {local_path.name}")
+        except EncryptionError as e:
+            warn(f"Failed to decrypt {local_path.name}: {e}")
+
+    assert section_name is not None
+    config.update_section(section_name, encrypted=False)
+    config.save()
+
+    success(f"Decrypted section '{section_name}'")

dot_man/cli/export_cmd.py

@@ -0,0 +1,146 @@
+"""Export command for exporting dotfiles to portable formats."""
+
+import json
+import os
+import tarfile
+import zipfile
+from pathlib import Path
+
+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("export")
+@click.argument("format", type=click.Choice(["tar", "zip", "json"]))
+@click.argument("output", type=click.Path())
+@click.option(
+    "--branch",
+    "-b",
+    default=None,
+    help="Export specific branch (default: current branch)",
+)
+@click.option(
+    "--include-secrets",
+    is_flag=True,
+    help="Include decrypted secrets in export (WARNING: not secure)",
+)
+@require_init
+def export_cmd(format: str, output: str, branch: str | None, include_secrets: bool):
+    """Export dotfiles to a portable archive format.
+
+    Supported formats:
+      tar  - Tar archive (.tar.gz)
+      zip  - Zip archive (.zip)
+      json - JSON manifest with file contents
+
+    Examples:
+        dot-man export tar backup.tar.gz           # Export as tar.gz
+        dot-man export zip dots.zip                # Export as zip
+        dot-man export json manifest.json          # Export as JSON
+        dot-man export tar archive.tar.gz --branch work  # Export specific branch
+    """
+    from ..operations import get_operations
+
+    ops = get_operations()
+    current_branch = branch or ops.current_branch
+
+    ui.console.print(f"[dim]Exporting branch: {current_branch}[/dim]")
+
+    if format == "tar":
+        _export_tar(output, current_branch, include_secrets)
+    elif format == "zip":
+        _export_zip(output, current_branch, include_secrets)
+    elif format == "json":
+        _export_json(output, current_branch, include_secrets)
+
+
+def _export_tar(output: str, branch: str, include_secrets: bool):
+    """Export to tar.gz archive."""
+    output_path = Path(output).expanduser().resolve()
+
+    if not str(output_path).endswith((".tar.gz", ".tgz")):
+        output_path = output_path.with_suffix(".tar.gz")
+
+    ui.console.print(f"[dim]Creating tar archive: {output_path}[/dim]")
+
+    try:
+        with tarfile.open(output_path, "w:gz") as tar:
+            tar.add(REPO_DIR, arcname="dotman-export")
+
+        success(f"Exported to {output_path}")
+    except Exception as e:
+        error(f"Export failed: {e}", exit_code=1)
+
+
+def _export_zip(output: str, branch: str, include_secrets: bool):
+    """Export to zip archive."""
+    output_path = Path(output).expanduser().resolve()
+
+    if not str(output_path).endswith(".zip"):
+        output_path = output_path.with_suffix(".zip")
+
+    ui.console.print(f"[dim]Creating zip archive: {output_path}[/dim]")
+
+    try:
+        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for root, dirs, files in os.walk(REPO_DIR):
+                for file in files:
+                    file_path = Path(root) / file
+                    arcname = file_path.relative_to(REPO_DIR)
+                    zipf.write(file_path, arcname)
+
+        success(f"Exported to {output_path}")
+    except Exception as e:
+        error(f"Export failed: {e}", exit_code=1)
+
+
+def _export_json(output: str, branch: str, include_secrets: bool):
+    """Export to JSON manifest."""
+    output_path = Path(output).expanduser().resolve()
+
+    if not str(output_path).endswith(".json"):
+        output_path = output_path.with_suffix(".json")
+
+    ui.console.print(f"[dim]Creating JSON manifest: {output_path}[/dim]")
+
+    from ..operations import get_operations
+
+    ops = get_operations()
+    manifest: dict = {
+        "version": "1.0",
+        "branch": branch,
+        "exported_at": str(Path().home()),
+        "files": [],  # type: ignore[list-item]
+    }
+
+    for section_name in ops.get_sections():
+        section = ops.get_section(section_name)
+        for path_str in section.paths:
+            path = Path(path_str).expanduser()
+            if path.exists():
+                file_entry = {
+                    "section": section_name,
+                    "local_path": str(path),
+                    "repo_path": str(path_str),
+                }
+
+                if include_secrets:
+                    try:
+                        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                            file_entry["content"] = f.read()
+                    except Exception:
+                        pass
+
+                manifest["files"].append(file_entry)
+
+    try:
+        with open(output_path, "w") as f:
+            json.dump(manifest, f, indent=2)
+
+        success(f"Exported {len(manifest['files'])} files to {output_path}")
+    except Exception as e:
+        error(f"Export failed: {e}", exit_code=1)

dot_man/cli/import_cmd.py

@@ -0,0 +1,315 @@
+"""Import command for migrating from other dotfile managers."""
+
+import shutil
+from pathlib import Path
+
+import click
+
+from .. import ui
+from ..core import GitManager
+from .common import error, require_init, warn
+from .interface import cli as main
+
+
+@main.command("import")
+@click.argument("source", type=click.Choice(["chezmoi", "yadm", "stow", "all"]))
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(),
+    default=None,
+    help="Custom source path (default: auto-detect)",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be imported without importing",
+)
+@require_init
+def import_cmd(source: str, path: str | None, dry_run: bool):
+    """Import dotfiles from other dotfile managers.
+
+    Supported sources:
+      chezmoi   - Import from chezmoi managed dotfiles
+      yadm      - Import from yadm managed dotfiles
+      stow      - Import from GNU Stow packages
+      all       - Auto-detect and import from any supported source
+
+    Examples:
+        dot-man import chezmoi           # Import from chezmoi
+        dot-man import yadm              # Import from yadm
+        dot-man import stow               # Import from Stow packages
+        dot-man import all --dry-run      # Auto-detect and preview
+    """
+    git = GitManager()
+
+    if source == "all":
+        _import_all(path, dry_run, git)
+    elif source == "chezmoi":
+        _import_chezmoi(path, dry_run, git)
+    elif source == "yadm":
+        _import_yadm(path, dry_run, git)
+    elif source == "stow":
+        _import_stow(path, dry_run, git)
+
+
+def _import_all(custom_path: str | None, dry_run: bool, git: GitManager):
+    """Auto-detect and import from any supported source."""
+    sources_found = []
+
+    chezmoi_path = _detect_chezmoi()
+    if chezmoi_path:
+        sources_found.append(("chezmoi", chezmoi_path))
+
+    yadm_path = _detect_yadm()
+    if yadm_path:
+        sources_found.append(("yadm", yadm_path))
+
+    stow_path = _detect_stow()
+    if stow_path:
+        sources_found.append(("stow", stow_path))
+
+    if not sources_found:
+        error(
+            "No dotfile manager sources detected. Use --path to specify a custom path.",
+            exit_code=1,
+        )
+
+    ui.console.print("[bold]Detected dotfile sources:[/bold]")
+    for src, src_path in sources_found:
+        ui.console.print(f"  • {src}: {src_path}")
+
+    if dry_run:
+        ui.console.print("\n[dim]Dry-run mode - no changes will be made[/dim]")
+        return
+
+    for src, src_path in sources_found:
+        ui.console.print(f"\n[bold]Importing from {src}...[/bold]")
+        if src == "chezmoi":
+            _import_chezmoi(src_path, False, git)
+        elif src == "yadm":
+            _import_yadm(src_path, False, git)
+        elif src == "stow":
+            _import_stow(src_path, False, git)
+
+
+def _detect_chezmoi() -> str | None:
+    """Detect chezmoi source directory."""
+    home = Path.home()
+
+    chezmoi_dirs = [
+        home / ".local" / "share" / "chezmoi",
+        home / ".config" / "chezmoi",
+        home / "Library" / "Application Support" / "chezmoi",  # macOS
+    ]
+
+    for d in chezmoi_dirs:
+        if d.exists() and (d / ".git").exists() or any(d.iterdir()):
+            return str(d)
+
+    return None
+
+
+def _detect_yadm() -> str | None:
+    """Detect yadm managed dotfiles."""
+    home = Path.home()
+
+    yadm_paths = [
+        home / ".yadm.git",
+        home / ".config" / "yadm" / "repo.git",
+    ]
+
+    for p in yadm_paths:
+        if p.exists():
+            return str(home / ".yadm")
+
+    return None
+
+
+def _detect_stow() -> str | None:
+    """Detect GNU Stow packages in common locations."""
+    home = Path.home()
+
+    stow_locations = [
+        home / "dotfiles",
+        home / ".dotfiles",
+        home / "dotfiles" / ".git",
+        home / ".dotfiles" / ".git",
+    ]
+
+    for p in stow_locations:
+        if p.exists():
+            packages = [
+                d for d in p.iterdir() if d.is_dir() and not d.name.startswith(".")
+            ]
+            if packages:
+                return str(p)
+
+    return None
+
+
+def _import_chezmoi(source_path: str | None, dry_run: bool, git: GitManager):
+    """Import from chezmoi."""
+    if source_path is None:
+        source_path = _detect_chezmoi()
+        if source_path is None:
+            error(
+                "chezmoi source not found. Install chezmoi first or use --path.",
+                exit_code=1,
+            )
+    assert source_path is not None
+
+    source = Path(source_path).expanduser().resolve()
+
+    if not source.exists():
+        error(f"Source path does not exist: {source}", exit_code=1)
+
+    ui.console.print(f"[dim]Importing from chezmoi: {source}[/dim]")
+
+    files_imported = 0
+
+    for item in source.rglob("*"):
+        if item.is_file():
+            rel_path = item.relative_to(source)
+
+            if rel_path.name.startswith("."):
+                dest_path = Path.home() / f".{rel_path.name}"
+            else:
+                dest_path = Path.home() / ".config" / str(rel_path)
+
+            if source.name == "chezmoi":
+                src_path = item
+            else:
+                src_path = item
+
+            if dry_run:
+                ui.console.print(f"  [dim]Would import: {src_path} → {dest_path}[/dim]")
+            else:
+                try:
+                    dest_path.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(src_path, dest_path)
+                    files_imported += 1
+                except Exception as e:
+                    warn(f"Failed to import {src_path}: {e}")
+
+    if dry_run:
+        ui.success(f"Would import {files_imported} files from chezmoi")
+    else:
+        ui.success(f"Imported {files_imported} files from chezmoi")
+
+        commit_msg = "Import dotfiles from chezmoi"
+        git.add_all()
+        git.commit(commit_msg)
+
+
+def _import_yadm(source_path: str | None, dry_run: bool, git: GitManager):
+    """Import from yadm."""
+    if source_path is None:
+        source_path = _detect_yadm()
+        if source_path is None:
+            error(
+                "yadm source not found. Install yadm first or use --path.", exit_code=1
+            )
+    assert source_path is not None
+
+    source = Path(source_path).expanduser().resolve()
+
+    if not source.exists():
+        error(f"Source path does not exist: {source}", exit_code=1)
+
+    ui.console.print(f"[dim]Importing from yadm: {source}[/dim]")
+
+    files_imported = 0
+
+    for item in source.rglob("*"):
+        if item.is_file() and not item.name.endswith(".git"):
+            rel_path = item.relative_to(source)
+
+            dest_path = Path.home() / rel_path.name
+            if dest_path.exists():
+                continue
+
+            if dry_run:
+                ui.console.print(f"  [dim]Would import: {item} → {dest_path}[/dim]")
+            else:
+                try:
+                    dest_path.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(item, dest_path)
+                    files_imported += 1
+                except Exception as e:
+                    warn(f"Failed to import {item}: {e}")
+
+    if dry_run:
+        ui.success(f"Would import {files_imported} files from yadm")
+    else:
+        ui.success(f"Imported {files_imported} files from yadm")
+
+        commit_msg = "Import dotfiles from yadm"
+        git.add_all()
+        git.commit(commit_msg)
+
+
+def _import_stow(source_path: str | None, dry_run: bool, git: GitManager):
+    """Import from GNU Stow packages."""
+    if source_path is None:
+        source_path = _detect_stow()
+        if source_path is None:
+            error("Stow packages not found. Use --path to specify.", exit_code=1)
+    assert source_path is not None
+
+    source = Path(source_path).expanduser().resolve()
+
+    if not source.exists():
+        error(f"Source path does not exist: {source}", exit_code=1)
+
+    ui.console.print(f"[dim]Importing from Stow: {source}[/dim]")
+
+    packages = [
+        d for d in source.iterdir() if d.is_dir() and not d.name.startswith(".")
+    ]
+
+    if not packages:
+        error("No Stow packages found in source directory", exit_code=1)
+
+    ui.console.print(
+        f"[dim]Found {len(packages)} packages: {', '.join([p.name for p in packages])}[/dim]"
+    )
+
+    files_imported = 0
+
+    for package in packages:
+        for item in package.rglob("*"):
+            if item.is_file():
+                rel_path = item.relative_to(package)
+
+                if rel_path.parts[0].startswith("."):
+                    dest_path = Path.home() / "/".join(rel_path.parts)
+                else:
+                    dest_path = (
+                        Path.home()
+                        / f".{rel_path.parts[0]}"
+                        / "/".join(rel_path.parts[1:])
+                    )
+
+                if dry_run:
+                    ui.console.print(f"  [dim]Would import: {item} → {dest_path}[/dim]")
+                else:
+                    try:
+                        dest_path.parent.mkdir(parents=True, exist_ok=True)
+                        shutil.copy2(item, dest_path)
+                        files_imported += 1
+                    except Exception as e:
+                        warn(f"Failed to import {item}: {e}")
+
+    if dry_run:
+        ui.success(
+            f"Would import {files_imported} files from {len(packages)} Stow packages"
+        )
+    else:
+        ui.success(
+            f"Imported {files_imported} files from {len(packages)} Stow packages"
+        )
+
+        commit_msg = f"Import dotfiles from {len(packages)} Stow packages"
+        git.add_all()
+        git.commit(commit_msg)