git-worktree-wrapper 0.1.0__py3-none-any.whl

gww/cli/commands/init.py

@@ -0,0 +1,147 @@
+"""Init commands implementation (config and shell)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from gww.cli.context import CommandContext, CommandExit, exit_on_error
+from gww.config.loader import config_exists, get_default_config
+from gww.utils.shell import (
+    generate_bash_aliases,
+    generate_fish_aliases,
+    generate_zsh_aliases,
+    get_aliases_path,
+    get_installation_instructions,
+    install_aliases,
+    install_completion,
+)
+from gww.utils.xdg import get_config_path
+
+
+@exit_on_error
+def run_init_config(ctx: CommandContext) -> int:
+    """Execute the init config command.
+
+    Args:
+        ctx: Per-invocation command context.
+
+    Returns:
+        Exit code (0 for success, 1 for error).
+    """
+    config_path = get_config_path()
+
+    if config_exists():
+        print(
+            f"Config file already exists at: {config_path}\n"
+            "Not overwriting.",
+            file=sys.stderr,
+        )
+        return 1
+
+    default_content = get_default_config(config_path)
+
+    try:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(default_content)
+    except OSError as e:
+        raise CommandExit(1, f"Error creating config file: {e}") from e
+
+    ctx.say(f"Created config file: {config_path}")
+
+    return 0
+
+
+@exit_on_error
+def run_init_shell(ctx: CommandContext) -> int:
+    """Execute the init shell command.
+
+    Args:
+        ctx: Per-invocation command context.
+
+    Returns:
+        Exit code (0 for success, 1 for error).
+    """
+    if ctx.shell is None:
+        raise CommandExit(1, "Error: Missing shell name.")
+
+    valid_shells = {"bash", "zsh", "fish"}
+    if ctx.shell not in valid_shells:
+        raise CommandExit(
+            1,
+            f"Error: Invalid shell '{ctx.shell}'. "
+            f"Must be one of: {', '.join(sorted(valid_shells))}",
+        )
+
+    try:
+        completion_path = install_completion(ctx.shell)
+    except (ValueError, OSError) as e:
+        raise CommandExit(1, f"Error: {e}") from e
+
+    try:
+        aliases_path = install_aliases(ctx.shell)
+    except (ValueError, OSError) as e:
+        raise CommandExit(1, f"Error: {e}") from e
+
+    if not ctx.quiet:
+        instructions = get_installation_instructions(ctx.shell, completion_path, aliases_path)
+        print(instructions)
+
+    return 0
+
+
+def detect_user_shell() -> str | None:
+    """Return the user's current shell name, or ``None`` if undetectable.
+
+    Reads ``$SHELL`` and extracts the basename (``/bin/bash`` → ``bash``).
+    Returns ``None`` for unknown shells so callers can silently skip
+    staleness checks rather than guess.
+    """
+    shell_path = os.environ.get("SHELL", "")
+    basename = os.path.basename(shell_path)
+    if basename in {"bash", "zsh", "fish"}:
+        return basename
+    return None
+
+
+def warn_if_alias_is_stale(shell: str) -> None:
+    """Warn on stderr if the installed alias file predates the current source.
+
+    Compares the on-disk alias file to what :func:`gww.utils.shell` would
+    generate today. If they differ, prints a one-line reminder to re-run
+    ``gww init shell <shell>``. Silently does nothing when:
+
+    * no alias file exists yet — we don't pester first-time installers;
+    * the file already matches the current generator output.
+
+    Args:
+        shell: Shell name (``"bash"``, ``"zsh"``, or ``"fish"``).
+    """
+    aliases_path = get_aliases_path(shell)
+
+    if shell == "fish":
+        assert isinstance(aliases_path, dict)
+        target = aliases_path["gwa"]
+        if not target.exists():
+            return
+        installed = target.read_text()
+        expected = generate_fish_aliases()["gwa"]
+        location = str(target)
+    else:
+        assert isinstance(aliases_path, Path)
+        if not aliases_path.exists():
+            return
+        installed = aliases_path.read_text()
+        expected = (
+            generate_bash_aliases() if shell == "bash" else generate_zsh_aliases()
+        )
+        location = str(aliases_path)
+
+    if installed != expected:
+        print(
+            f"gww: shell aliases at {location} are out of date — "
+            f"re-run 'gww init shell {shell}' to pick up the latest "
+            f"gwc/gwa/gwr.",
+            file=sys.stderr,
+        )

gww/cli/commands/migrate.py

@@ -0,0 +1,81 @@
+"""Migrate command implementation.
+
+Thin wrapper over :mod:`gww.migration`: the command validates inputs,
+calls the planner, prints the result, and delegates execution to the
+executor. All planning and movement logic lives in the migration package
+where it can be unit-tested directly.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from gww.cli.context import CommandContext, CommandExit, exit_on_error, load_config_or_exit
+from gww.migration import (
+    Blocked,
+    Migration,
+    Mode,
+    collect_repositories,
+    execute,
+    plan_migration,
+)
+
+
+@exit_on_error
+def run_migrate(ctx: CommandContext) -> int:
+    """Execute the migrate command.
+
+    Args:
+        ctx: Per-invocation command context.
+
+    Returns:
+        Exit code (0 for success, 1 for error, 2 for config error).
+    """
+    input_paths = [Path(p).expanduser().resolve() for p in ctx.old_repos]
+
+    for p in input_paths:
+        if not p.exists():
+            raise CommandExit(1, f"Error: Path does not exist: {p}")
+        if not p.is_dir():
+            raise CommandExit(1, f"Error: Not a directory: {p}")
+
+    config = load_config_or_exit()
+
+    repos, input_roots = collect_repositories(input_paths)
+    ctx.verbose_msg(f"Scanning {len(input_paths)} path(s) for repositories...")
+
+    result = plan_migration(
+        repos,
+        config,
+        inplace=ctx.inplace,
+        verbose=ctx.verbose,
+        tags=ctx.tags,
+    )
+
+    if isinstance(result, Blocked):
+        for path in result.destinations:
+            print(f"Error: Destination already exists: {path}", file=sys.stderr)
+        count = len(result.destinations)
+        print(
+            f"Cannot proceed: {count} destination(s) already exist in copy mode",
+            file=sys.stderr,
+        )
+        return 1
+
+    migration: Migration = result
+
+    if not migration.plans and not migration.info_skips and not migration.already_at_target:
+        if not ctx.quiet:
+            print("No repositories to migrate.")
+        return 0
+
+    mode: Mode = "inplace" if ctx.inplace else "copy"
+    return execute(
+        migration,
+        input_roots=input_roots,
+        mode=mode,
+        dry_run=ctx.dry_run,
+        quiet=ctx.quiet,
+        verbose=ctx.verbose,
+    )

gww/cli/commands/pull.py

@@ -0,0 +1,62 @@
+"""Pull command implementation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from gww.cli.context import (
+    CommandContext,
+    CommandExit,
+    exit_on_error,
+    resolve_source_repo,
+)
+from gww.git.branch import is_main_branch
+from gww.git.repository import (
+    GitCommandError,
+    get_current_branch,
+    is_clean,
+    pull_repository,
+)
+
+
+@exit_on_error
+def run_pull(ctx: CommandContext) -> int:
+    """Execute the pull command.
+
+    Args:
+        ctx: Per-invocation command context.
+
+    Returns:
+        Exit code (0 for success, 1 for error).
+    """
+    source_path = resolve_source_repo(Path.cwd())
+
+    try:
+        current_branch = get_current_branch(source_path)
+    except GitCommandError as e:
+        raise CommandExit(1, f"Error getting current branch: {e}") from e
+
+    if not is_main_branch(current_branch):
+        raise CommandExit(
+            1,
+            f"Error: Source repository must be on 'main' or 'master' branch. "
+            f"Current branch: {current_branch}",
+        )
+
+    if not is_clean(source_path):
+        raise CommandExit(
+            1,
+            "Error: Source repository has uncommitted changes. "
+            "Commit or stash changes first.",
+        )
+
+    ctx.verbose_msg(f"Pulling updates for {source_path}...")
+
+    try:
+        pull_repository(source_path, pass_through_stdout=not ctx.quiet)
+    except GitCommandError as e:
+        raise CommandExit(1, f"Error pulling updates: {e}") from e
+
+    ctx.say(f"Updated source repository: {source_path}")
+
+    return 0

gww/cli/commands/remove.py

@@ -0,0 +1,153 @@
+"""Remove worktree command implementation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from gww.actions import ActionError, MatcherError, apply_actions
+from gww.cli.context import (
+    CommandContext,
+    CommandExit,
+    RuleFailure,
+    exit_on_error,
+    load_config_or_exit,
+    parse_uri_or_exit,
+    print_action_failure_summary,
+    resolve_source_repo,
+)
+from gww.git.repository import (
+    GitCommandError,
+    NotGitRepositoryError,
+    detect_repository,
+    get_source_repository,
+    try_get_current_branch,
+)
+from gww.git.worktree import (
+    WorktreeDirtyError,
+    WorktreeNotFoundError,
+    find_worktree_by_branch,
+    remove_worktree,
+)
+from gww.template.functions import TemplateContext
+
+
+@exit_on_error
+def run_remove(ctx: CommandContext) -> int:
+    """Execute the remove worktree command.
+
+    Resolves the target worktree (by branch or absolute path), runs any
+    ``before_remove`` actions from project rules against the worktree, and
+    finally invokes ``git worktree remove``. A critical ``before_remove``
+    failure aborts before ``git worktree remove`` is called and exits with
+    code 1; a non-critical failure is reported but the remove proceeds.
+
+    Args:
+        ctx: Per-invocation command context.
+
+    Returns:
+        Exit code (0 for success, 1 for runtime/action failure, 2 for config
+        error).
+    """
+    if ctx.branch_or_path is None:
+        raise CommandExit(1, "Error: Missing branch or path.")
+
+    branch_or_path = ctx.branch_or_path
+    is_path = "/" in branch_or_path and Path(branch_or_path).is_absolute()
+
+    if is_path:
+        worktree_path = Path(branch_or_path).resolve()
+
+        try:
+            repo = detect_repository(worktree_path)
+        except NotGitRepositoryError as e:
+            raise CommandExit(1, f"Error: Not a git repository: {worktree_path}") from e
+
+        if not repo.is_worktree:
+            raise CommandExit(1, f"Error: Not a worktree: {worktree_path}")
+
+        try:
+            source_path = get_source_repository(worktree_path)
+        except (NotGitRepositoryError, GitCommandError) as e:
+            raise CommandExit(1, f"Error finding source repository: {e}") from e
+    else:
+        branch = branch_or_path
+        source_path = resolve_source_repo(Path.cwd())
+
+        wt = find_worktree_by_branch(source_path, branch)
+        if not wt:
+            raise CommandExit(1, f"Error: No worktree found for branch '{branch}'")
+        worktree_path = wt.path
+
+    config = load_config_or_exit()
+
+    # Resolve branch + URI for the template context.
+    if is_path:
+        branch = try_get_current_branch(worktree_path)
+    else:
+        branch = branch_or_path
+
+    try:
+        source_repo = detect_repository(source_path)
+    except NotGitRepositoryError:
+        remote_uri_str = None
+    else:
+        remote_uri_str = source_repo.remote_uri
+
+    uri = parse_uri_or_exit(remote_uri_str) if remote_uri_str else None
+
+    if ctx.verbose > 0:
+        if ctx.force:
+            ctx.verbose_msg(f"Force removing worktree: {worktree_path}...")
+        else:
+            ctx.verbose_msg(f"Removing worktree: {worktree_path}...")
+
+    failures: list[RuleFailure] = []
+    if config.actions:
+        context = TemplateContext(
+            uri=uri,
+            branch=branch,
+            source_path=source_path,
+            dest_path=worktree_path,
+            tags=ctx.tags,
+        )
+        try:
+            rule_bundles = apply_actions(
+                config.actions, context, kind="before_remove",
+            )
+        except MatcherError as e:
+            raise CommandExit(2, f"Config error: {e}") from e
+
+        if rule_bundles:
+            ctx.verbose_msg(f"Executing {len(rule_bundles)} rule(s)...")
+            for bundle in rule_bundles:
+                for action in bundle.actions:
+                    try:
+                        action.run(
+                            source_dir=source_path,
+                            target_dir=worktree_path,
+                            pass_through_stdout=not ctx.quiet,
+                        )
+                    except ActionError as e:
+                        failures.append(RuleFailure(bundle, action, e))
+                        if bundle.critical:
+                            break
+
+    if failures:
+        print_action_failure_summary(failures)
+
+    if any(f.bundle.critical for f in failures):
+        raise CommandExit(1, "")
+
+    try:
+        remove_worktree(
+            source_path,
+            worktree_path,
+            force=ctx.force,
+            pass_through_stdout=not ctx.quiet,
+        )
+    except (WorktreeNotFoundError, WorktreeDirtyError, GitCommandError) as e:
+        raise CommandExit(1, f"Error: {e}") from e
+
+    ctx.say(f"Removed worktree: {worktree_path}")
+
+    return 0