git-ssh-sync 0.1.0__py3-none-any.whl

git_ssh_sync/__init__.py

@@ -0,0 +1,3 @@
+"""git-ssh-sync package."""
+
+__version__ = "0.1.0"

git_ssh_sync/branch.py

@@ -0,0 +1,205 @@
+"""Branch state inspection workflow."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.markup import escape
+from rich.table import Table
+
+from git_ssh_sync import git, ssh
+from git_ssh_sync.config import ProjectConfig, get_project, load_config
+from git_ssh_sync.console import console
+from git_ssh_sync.status import _ssh_repo_url
+
+
+class BranchError(RuntimeError):
+    """Raised when branch state cannot be inspected."""
+
+
+@dataclass(frozen=True)
+class BranchRow:
+    """Single branch status row."""
+
+    name: str
+    in_origin: bool
+    in_cache: bool
+    in_work: bool
+    is_current: bool
+    origin_ahead: int | None
+    work_ahead: int | None
+
+
+@dataclass(frozen=True)
+class BranchReport:
+    """Collected branch status for a configured project."""
+
+    project: str
+    current_branch: str
+    rows: tuple[BranchRow, ...]
+
+
+def _clean_output(value: str) -> str:
+    return value.strip()
+
+
+def _split_lines(output: str) -> set[str]:
+    return {line.strip() for line in output.splitlines() if line.strip()}
+
+
+def _branch_names_from_refs(output: str, prefix: str) -> set[str]:
+    names: set[str] = set()
+    for line in output.splitlines():
+        ref = line.strip()
+        if ref.startswith(prefix):
+            names.add(ref.removeprefix(prefix))
+    return names
+
+
+def _local_origin_branches(local_path: Path) -> set[str]:
+    result = git.run_git(
+        ["for-each-ref", "--format=%(refname)", "refs/remotes/origin"],
+        cwd=local_path,
+    )
+    return _branch_names_from_refs(result.stdout, "refs/remotes/origin/") - {"HEAD"}
+
+
+def _remote_cache_branches(project_config: ProjectConfig) -> set[str]:
+    result = ssh.run_remote_git(
+        project_config.dev.host,
+        project_config.dev.cache_path,
+        ["for-each-ref", "--format=%(refname)", "refs/heads"],
+        user=project_config.dev.user,
+    )
+    return _branch_names_from_refs(result.stdout, "refs/heads/")
+
+
+def _remote_work_branches(project_config: ProjectConfig) -> set[str]:
+    result = ssh.run_remote_git(
+        project_config.dev.host,
+        project_config.dev.work_path,
+        ["for-each-ref", "--format=%(refname)", "refs/heads"],
+        user=project_config.dev.user,
+    )
+    return _branch_names_from_refs(result.stdout, "refs/heads/")
+
+
+def _remote_current_branch(project_config: ProjectConfig) -> str:
+    result = ssh.run_remote_git(
+        project_config.dev.host,
+        project_config.dev.work_path,
+        ["branch", "--show-current"],
+        user=project_config.dev.user,
+    )
+    branch = _clean_output(result.stdout)
+    if not branch:
+        raise BranchError("Development work repository is in detached HEAD state.")
+    return branch
+
+
+def _split_ahead_counts(output: str) -> tuple[int, int]:
+    parts = output.split()
+    if len(parts) != 2:
+        raise BranchError(f"Unexpected rev-list output: {output.strip()}")
+    return int(parts[0]), int(parts[1])
+
+
+def _ahead_counts(local_path: Path, branch: str) -> tuple[int | None, int | None]:
+    result = git.rev_list(
+        ["--left-right", "--count", f"origin/{branch}...dev/{branch}"],
+        cwd=local_path,
+    )
+    return _split_ahead_counts(result.stdout)
+
+
+def inspect_branch(project: str) -> BranchReport:
+    """Inspect branch state for a configured project."""
+    app_config = load_config()
+    project_config = get_project(app_config, project)
+    return inspect_project_branch(project, project_config)
+
+
+def inspect_project_branch(project: str, project_config: ProjectConfig) -> BranchReport:
+    """Inspect branch state using an already loaded project configuration."""
+    local_path = Path(project_config.local.repo_path)
+    if not local_path.exists():
+        raise BranchError(f"[local] gateway repository does not exist: {local_path}")
+
+    git.fetch("origin", cwd=local_path)
+    current_branch = _remote_current_branch(project_config)
+    origin_branches = _local_origin_branches(local_path)
+    cache_branches = _remote_cache_branches(project_config)
+    work_branches = _remote_work_branches(project_config)
+
+    dev_repo_url = _ssh_repo_url(
+        host=project_config.dev.host,
+        user=project_config.dev.user,
+        repo_path=project_config.dev.work_path,
+    )
+    for branch in sorted(origin_branches & work_branches):
+        git.fetch(
+            dev_repo_url,
+            [f"refs/heads/{branch}:refs/remotes/dev/{branch}"],
+            cwd=local_path,
+        )
+
+    rows: list[BranchRow] = []
+    for branch in sorted(origin_branches | cache_branches | work_branches):
+        origin_ahead: int | None = None
+        work_ahead: int | None = None
+        if branch in origin_branches and branch in work_branches:
+            origin_ahead, work_ahead = _ahead_counts(local_path, branch)
+        rows.append(
+            BranchRow(
+                name=branch,
+                in_origin=branch in origin_branches,
+                in_cache=branch in cache_branches,
+                in_work=branch in work_branches,
+                is_current=branch == current_branch,
+                origin_ahead=origin_ahead,
+                work_ahead=work_ahead,
+            )
+        )
+    return BranchReport(project=project, current_branch=current_branch, rows=tuple(rows))
+
+
+def _mark(value: bool) -> str:
+    return "yes" if value else "-"
+
+
+def _ahead(value: int | None) -> str:
+    return "-" if value is None else str(value)
+
+
+def print_branch(report: BranchReport) -> None:
+    """Print a Rich-formatted branch report."""
+    console.print(f"Branches for [bold]{escape(report.project)}[/bold]")
+    console.print(f"Current branch: {escape(report.current_branch)}")
+    console.print()
+
+    table = Table(show_header=True)
+    table.add_column("Branch", style="bold")
+    table.add_column("Current", no_wrap=True)
+    table.add_column("Origin", no_wrap=True)
+    table.add_column("Dev cache", no_wrap=True)
+    table.add_column("Work repo", no_wrap=True)
+    table.add_column("Origin ahead", justify="right", no_wrap=True)
+    table.add_column("Work ahead", justify="right", no_wrap=True)
+
+    for row in report.rows:
+        table.add_row(
+            escape(row.name),
+            "*" if row.is_current else "",
+            _mark(row.in_origin),
+            _mark(row.in_cache),
+            _mark(row.in_work),
+            _ahead(row.origin_ahead),
+            _ahead(row.work_ahead),
+        )
+    console.print(table)
+
+
+def branch_project(project: str) -> None:
+    """Inspect and print branch state for a configured project."""
+    print_branch(inspect_branch(project))

git_ssh_sync/cli.py

@@ -0,0 +1,228 @@
+"""Command line interface for git-ssh-sync."""
+
+from typing import Annotated
+
+import typer
+from rich.markup import escape
+
+from git_ssh_sync import __version__
+from git_ssh_sync.branch import BranchError, branch_project
+from git_ssh_sync.clone import CloneError, clone_project
+from git_ssh_sync.config import (
+    ConfigError,
+    ProjectAlreadyExistsError,
+    default_config_path,
+    init_project,
+)
+from git_ssh_sync.console import console
+from git_ssh_sync.doctor import DoctorError, doctor_project
+from git_ssh_sync.errors import CommandExecutionError
+from git_ssh_sync.status import StatusError, status_project
+from git_ssh_sync.sync import SyncError, checkout_project, pull_project, push_project
+
+app = typer.Typer(
+    name="git-ssh-sync",
+    help="Sync Git commits through a local machine over SSH.",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"git-ssh-sync {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def callback(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show the application version and exit.",
+        ),
+    ] = False,
+) -> None:
+    """Sync Git commits through a local machine over SSH."""
+
+
+def _not_implemented(command: str, project: str | None = None) -> None:
+    target = f" for project '{project}'" if project else ""
+    console.print(
+        f"[yellow]{command}[/yellow]{target} is defined, but the sync implementation is not available yet."
+    )
+
+
+@app.command("init")
+def init_command(
+    project: Annotated[str, typer.Argument(help="Project name to register.")],
+    origin: Annotated[
+        str | None,
+        typer.Option(
+            "--origin", help="Origin Git URL, such as git@github.com:org/repo.git."
+        ),
+    ] = None,
+    dev_host: Annotated[
+        str | None,
+        typer.Option("--dev-host", help="Development environment SSH host."),
+    ] = None,
+    dev_user: Annotated[
+        str | None,
+        typer.Option("--dev-user", help="Development environment SSH user."),
+    ] = None,
+    dev_path: Annotated[
+        str | None,
+        typer.Option(
+            "--dev-path", help="Development environment work repository path."
+        ),
+    ] = None,
+    force: Annotated[
+        bool,
+        typer.Option("--force", help="Overwrite an existing project configuration."),
+    ] = False,
+) -> None:
+    """Create a project configuration."""
+    try:
+        project_config = init_project(
+            project,
+            origin=origin,
+            dev_host=dev_host,
+            dev_user=dev_user,
+            dev_work_path=dev_path,
+            force=force,
+        )
+    except ProjectAlreadyExistsError as error:
+        console.print(f"[red]{error}[/red]")
+        raise typer.Exit(code=1) from error
+    except ConfigError as error:
+        console.print(f"[red]{error}[/red]")
+        raise typer.Exit(code=1) from error
+
+    console.print(f"Project '{project}' saved to {default_config_path()}")
+    console.print(f"origin: {project_config.origin}")
+
+
+@app.command("clone")
+def clone_command(
+    project: Annotated[str, typer.Argument(help="Project name to clone.")],
+) -> None:
+    """Clone the project locally and initialize the development environment."""
+    try:
+        clone_project(project)
+    except (ConfigError, CloneError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+    console.print(f"Project '{project}' cloned.")
+
+
+@app.command("status")
+def status_command(
+    project: Annotated[str, typer.Argument(help="Project name to inspect.")],
+) -> None:
+    """Show synchronization state for origin, gateway, and development repositories."""
+    try:
+        status_project(project)
+    except (ConfigError, StatusError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+
+@app.command("branch")
+def branch_command(
+    project: Annotated[str, typer.Argument(help="Project name to inspect.")],
+) -> None:
+    """List branch state across origin, development cache, and work repo."""
+    try:
+        branch_project(project)
+    except (ConfigError, BranchError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+
+@app.command("pull")
+def pull_command(
+    project: Annotated[str, typer.Argument(help="Project name to pull.")],
+) -> None:
+    """Fetch origin changes and fast-forward the current development branch."""
+    try:
+        pull_project(project)
+    except (ConfigError, SyncError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+    console.print(f"Project '{project}' pulled.")
+
+
+@app.command("push")
+def push_command(
+    project: Annotated[str, typer.Argument(help="Project name to push.")],
+) -> None:
+    """Push current development branch commits to origin when it is safe to do so."""
+    try:
+        push_project(project)
+    except (ConfigError, SyncError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+    console.print(f"Project '{project}' pushed.")
+
+
+@app.command("checkout")
+def checkout_command(
+    project: Annotated[str, typer.Argument(help="Project name to update.")],
+    branch: Annotated[
+        str | None,
+        typer.Argument(help="Branch to check out in the development repository."),
+    ] = None,
+    create_branch: Annotated[
+        str | None,
+        typer.Option(
+            "-b",
+            "--create-branch",
+            help="Create and check out a new branch.",
+        ),
+    ] = None,
+    base_branch: Annotated[
+        str | None,
+        typer.Option("--base", help="Create the branch from this branch."),
+    ] = None,
+) -> None:
+    """Switch the development repository to a branch."""
+    target_branch = create_branch or branch
+    if target_branch is None:
+        console.print("[red]Specify a branch or -b <branch>.[/red]")
+        raise typer.Exit(code=2)
+    if base_branch is not None and create_branch is None:
+        console.print("[red]--base can only be used with -b/--create-branch.[/red]")
+        raise typer.Exit(code=2)
+    try:
+        checkout_project(
+            project,
+            target_branch,
+            create=create_branch is not None,
+            base_branch=base_branch,
+        )
+    except (ConfigError, SyncError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+    console.print(f"Project '{project}' checked out {target_branch}.")
+
+
+@app.command("doctor")
+def doctor_command(
+    project: Annotated[str, typer.Argument(help="Project name to diagnose.")],
+) -> None:
+    """Check local, SSH, Git, and repository layout prerequisites."""
+    try:
+        doctor_project(project)
+    except (ConfigError, DoctorError, CommandExecutionError) as error:
+        console.print(f"[red]{escape(str(error))}[/red]")
+        raise typer.Exit(code=1) from error
+
+
+def main() -> None:
+    app()

git_ssh_sync/clone.py

@@ -0,0 +1,92 @@
+"""Project clone workflow."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import quote
+
+from git_ssh_sync import git, ssh
+from git_ssh_sync.config import get_project, load_config
+from git_ssh_sync.errors import CommandExecutionError
+
+
+class CloneError(RuntimeError):
+    """Raised when the clone workflow would overwrite existing data."""
+
+
+def _cache_url(*, host: str, user: str, cache_path: str) -> str:
+    quoted_path = quote(cache_path, safe="/~")
+    return f"ssh://{user}@{host}{quoted_path}"
+
+
+def _ensure_local_missing(path: Path) -> None:
+    if path.exists():
+        raise CloneError(f"[local] path already exists: {path}")
+
+
+def _ensure_remote_missing(*, host: str, user: str, path: str) -> None:
+    result = ssh.run_ssh(host, ["test", "-e", path], user=user, check=False)
+    if result.returncode == 0:
+        raise CloneError(f"[{result.environment}] path already exists: {path}")
+    if result.returncode == 1:
+        return
+    raise CommandExecutionError(
+        environment=result.environment,
+        command=result.command,
+        returncode=result.returncode,
+        cwd=result.cwd,
+        stdout=result.stdout,
+        stderr=result.stderr,
+    )
+
+
+def _remote_parent(path: str) -> str:
+    return str(Path(path).parent)
+
+
+def _local_current_branch(local_path: Path) -> str:
+    result = git.run_git(["branch", "--show-current"], cwd=local_path)
+    branch = result.stdout.strip()
+    if not branch:
+        raise CloneError("Could not determine the cloned repository's current branch.")
+    return branch
+
+
+def clone_project(project: str) -> None:
+    """Clone a configured project and initialize its development repositories."""
+    app_config = load_config()
+    project_config = get_project(app_config, project)
+
+    local_path = Path(project_config.local.repo_path)
+    dev_host = project_config.dev.host
+    dev_user = project_config.dev.user
+    cache_path = project_config.dev.cache_path
+    work_path = project_config.dev.work_path
+
+    _ensure_local_missing(local_path)
+    _ensure_remote_missing(host=dev_host, user=dev_user, path=cache_path)
+    _ensure_remote_missing(host=dev_host, user=dev_user, path=work_path)
+
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    git.run_git(["clone", project_config.origin, str(local_path)])
+    git.fetch("origin", cwd=local_path)
+    branch = _local_current_branch(local_path)
+
+    ssh.run_ssh(dev_host, ["mkdir", "-p", _remote_parent(cache_path)], user=dev_user)
+    ssh.run_ssh(dev_host, ["git", "init", "--bare", cache_path], user=dev_user)
+
+    remote_cache = _cache_url(host=dev_host, user=dev_user, cache_path=cache_path)
+    git.push(
+        remote_cache,
+        [f"refs/remotes/origin/{branch}:refs/heads/{branch}"],
+        cwd=local_path,
+    )
+    if project_config.options.sync_tags:
+        git.push(remote_cache, ["--tags"], cwd=local_path)
+
+    ssh.run_ssh(dev_host, ["mkdir", "-p", _remote_parent(work_path)], user=dev_user)
+    ssh.run_ssh(dev_host, ["git", "clone", cache_path, work_path], user=dev_user)
+    ssh.run_remote_git(
+        dev_host, work_path, ["remote", "rename", "origin", "gitsync"], user=dev_user
+    )
+    ssh.run_remote_git(dev_host, work_path, ["switch", branch], user=dev_user)