erk 0.4.5__py3-none-any.whl

erk/cli/commands/up.py

@@ -0,0 +1,154 @@
+import click
+
+from erk.cli.activation import render_activation_script
+from erk.cli.commands.navigation_helpers import (
+    activate_worktree,
+    check_clean_working_tree,
+    check_pending_extraction_marker,
+    resolve_up_navigation,
+    unallocate_worktree_and_branch,
+    verify_pr_closed_or_merged,
+)
+from erk.cli.core import discover_repo_context
+from erk.cli.ensure import Ensure
+from erk.cli.graphite_command import GraphiteCommandWithHiddenOptions
+from erk.cli.help_formatter import script_option
+from erk.core.context import ErkContext
+from erk.core.worktree_utils import compute_relative_path_in_worktree
+from erk_shared.output.output import machine_output, user_output
+
+
+@click.command("up", cls=GraphiteCommandWithHiddenOptions)
+@script_option
+@click.option(
+    "--delete-current",
+    is_flag=True,
+    help="Delete current branch and worktree after navigating up",
+)
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    help="Force deletion even if marker exists or PR is open (prompts)",
+)
+@click.pass_obj
+def up_cmd(ctx: ErkContext, script: bool, delete_current: bool, force: bool) -> None:
+    """Move to child branch in worktree stack.
+
+    With shell integration (recommended):
+      erk up
+
+    The shell wrapper function automatically activates the worktree.
+    Run 'erk init --shell' to set up shell integration.
+
+    Without shell integration:
+      source <(erk up --script)
+
+    This will cd to the child branch's worktree, create/activate .venv, and load .env variables.
+    Requires Graphite to be enabled: 'erk config set use_graphite true'
+    """
+    # Validate preconditions upfront (LBYL)
+    Ensure.gh_authenticated(ctx)
+
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Get current branch
+    current_branch = Ensure.not_none(
+        ctx.git.get_current_branch(ctx.cwd), "Not currently on a branch (detached HEAD)"
+    )
+
+    # Get all worktrees for checking if target has a worktree
+    worktrees = ctx.git.list_worktrees(repo.root)
+
+    # Get child branches for ambiguity checks
+    children = ctx.graphite.get_child_branches(ctx.git, repo.root, current_branch)
+
+    # Check for navigation ambiguity when --delete-current is set
+    Ensure.invariant(
+        not (delete_current and len(children) == 0),
+        "Cannot navigate up: already at top of stack. Use 'gt branch delete' to delete this branch",
+    )
+
+    Ensure.invariant(
+        not (delete_current and len(children) > 1),
+        "Cannot navigate up: multiple child branches exist. "
+        "Use 'gt up' to interactively select a branch",
+    )
+
+    # Safety checks before navigation (if --delete-current flag is set)
+    current_worktree_path = None
+    if delete_current:
+        # Store current worktree path for later deletion
+        current_worktree_path = Ensure.not_none(
+            ctx.git.find_worktree_for_branch(repo.root, current_branch),
+            f"Could not find worktree for branch '{current_branch}'",
+        )
+
+        # Validate clean working tree (no uncommitted changes)
+        check_clean_working_tree(ctx)
+
+        # Validate PR is closed or merged on GitHub
+        verify_pr_closed_or_merged(ctx, repo.root, current_branch, force)
+
+        # Check for pending extraction marker
+        check_pending_extraction_marker(current_worktree_path, force)
+
+    # Resolve navigation to get target branch (may auto-create worktree)
+    target_name, was_created = resolve_up_navigation(ctx, repo, current_branch, worktrees)
+
+    # Show creation message if worktree was just created
+    if was_created and not script:
+        user_output(
+            click.style("✓", fg="green")
+            + f" Created worktree for {click.style(target_name, fg='yellow')} and moved to it"
+        )
+
+    # Resolve target branch to actual worktree path
+    target_wt_path = Ensure.not_none(
+        ctx.git.find_worktree_for_branch(repo.root, target_name),
+        f"Branch '{target_name}' has no worktree. This should not happen.",
+    )
+
+    if delete_current and current_worktree_path is not None:
+        # Handle activation inline when cleanup is needed
+        Ensure.path_exists(ctx, target_wt_path, f"Worktree not found: {target_wt_path}")
+
+        if script:
+            # Generate activation script for shell integration
+            activation_script = render_activation_script(
+                worktree_path=target_wt_path,
+                target_subpath=compute_relative_path_in_worktree(worktrees, ctx.cwd),
+                post_cd_commands=None,
+                final_message='echo "Activated worktree: $(pwd)"',
+                comment="work activate-script",
+            )
+            result = ctx.script_writer.write_activation_script(
+                activation_script,
+                command_name="up",
+                comment=f"activate {target_wt_path.name}",
+            )
+            machine_output(str(result.path), nl=False)
+        else:
+            # Show user message for manual navigation
+            user_output(
+                "Shell integration not detected. "
+                "Run 'erk init --shell' to set up automatic activation."
+            )
+            user_output("\nOr use: source <(erk up --script)")
+
+        # Perform cleanup: unallocate worktree (slot-aware) and delete branch
+        unallocate_worktree_and_branch(ctx, repo, current_branch, current_worktree_path)
+
+        # Exit after cleanup
+        raise SystemExit(0)
+    else:
+        # No cleanup needed, use standard activation
+        activate_worktree(
+            ctx=ctx,
+            repo=repo,
+            target_path=target_wt_path,
+            script=script,
+            command_name="up",
+            preserve_relative_path=True,
+            post_cd_commands=None,
+        )

erk/cli/commands/upgrade.py

@@ -0,0 +1,82 @@
+"""Upgrade command for erk tool installation.
+
+Upgrades the user's local erk installation to match the repo's required version.
+"""
+
+import click
+from packaging.version import Version
+
+from erk.cli.core import discover_repo_context
+from erk.cli.subprocess_utils import run_with_error_reporting
+from erk.core.context import ErkContext
+from erk.core.release_notes import get_current_version
+from erk.core.version_check import get_required_version
+
+
+@click.command("upgrade")
+@click.pass_obj
+def upgrade_cmd(ctx: ErkContext) -> None:
+    """Upgrade local erk installation to match repo requirement.
+
+    Reads the required version from .erk/required-erk-uv-tool-version
+    and upgrades if the installed version is older.
+
+    Examples:
+
+    \b
+      # Upgrade erk to match repo requirement
+      erk upgrade
+    """
+    # Find repo context to get repo root
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Read required version from repo
+    required = get_required_version(repo.root)
+    if required is None:
+        click.echo(
+            click.style("Error: ", fg="red")
+            + "No version requirement found in this repo (.erk/required-erk-uv-tool-version)"
+        )
+        raise SystemExit(1)
+
+    # Get installed version
+    installed = get_current_version()
+    installed_ver = Version(installed)
+    required_ver = Version(required)
+
+    # Check if upgrade is needed
+    if installed_ver == required_ver:
+        click.echo(click.style(f"Already up to date ({installed})", fg="green"))
+        return
+
+    if installed_ver > required_ver:
+        click.echo(
+            click.style(f"Already at {installed}", fg="green") + f" (repo requires {required})"
+        )
+        return
+
+    # Upgrade needed: installed < required
+    click.echo(f"Upgrade available: {installed} → {required}")
+    click.echo(click.style("Command: ", dim=True) + "uv tool upgrade erk")
+    click.echo()
+
+    if not click.confirm("Proceed with upgrade?"):
+        click.echo()
+        click.echo(click.style("Manual remediation required:", bold=True))
+        click.echo("  Run: uv tool upgrade erk")
+        click.echo(f"  Or:  uv tool install erk=={required}")
+        raise SystemExit(1)
+
+    click.echo()
+    click.echo("Running uv tool upgrade erk...")
+    run_with_error_reporting(
+        ["uv", "tool", "upgrade", "erk"],
+        error_prefix="Upgrade failed",
+        troubleshooting=[
+            "Ensure uv is installed: curl -LsSf https://astral.sh/uv/install.sh | sh",
+            "Try manual upgrade: uv tool upgrade erk",
+            f"Or install specific version: uv tool install erk=={required}",
+        ],
+    )
+
+    click.echo(click.style(f"Successfully upgraded erk to {required}", fg="green"))

erk/cli/commands/wt/__init__.py

@@ -0,0 +1,29 @@
+"""Worktree management commands."""
+
+import click
+
+from erk.cli.alias import register_with_aliases
+from erk.cli.commands.status import status_cmd
+from erk.cli.commands.wt.checkout_cmd import wt_checkout
+from erk.cli.commands.wt.create_cmd import create_wt
+from erk.cli.commands.wt.current_cmd import current_wt
+from erk.cli.commands.wt.delete_cmd import delete_wt
+from erk.cli.commands.wt.list_cmd import list_wt
+from erk.cli.commands.wt.rename_cmd import rename_wt
+from erk.cli.help_formatter import ErkCommandGroup
+
+
+@click.group("wt", cls=ErkCommandGroup, grouped=False)
+def wt_group() -> None:
+    """Manage git worktrees."""
+    pass
+
+
+# Register subcommands
+register_with_aliases(wt_group, wt_checkout)
+wt_group.add_command(create_wt)
+wt_group.add_command(current_wt)
+wt_group.add_command(delete_wt)
+register_with_aliases(wt_group, list_wt)
+wt_group.add_command(rename_wt)
+wt_group.add_command(status_cmd)

erk/cli/commands/wt/checkout_cmd.py

@@ -0,0 +1,110 @@
+"""Checkout command - navigate directly to a worktree by name."""
+
+import click
+
+from erk.cli.alias import alias
+from erk.cli.commands.completions import complete_worktree_names
+from erk.cli.commands.navigation_helpers import activate_root_repo, activate_worktree
+from erk.cli.core import discover_repo_context
+from erk.cli.ensure import Ensure
+from erk.cli.help_formatter import CommandWithHiddenOptions, script_option
+from erk.core.context import ErkContext
+from erk_shared.output.output import user_output
+
+
+@alias("co")
+@click.command("checkout", cls=CommandWithHiddenOptions)
+@click.argument("worktree_name", shell_complete=complete_worktree_names)
+@script_option
+@click.pass_obj
+def wt_checkout(ctx: ErkContext, worktree_name: str, script: bool) -> None:
+    """Checkout a worktree by name.
+
+    With shell integration (recommended):
+      erk wt co WORKTREE_NAME
+
+    The shell wrapper function automatically activates the worktree.
+    Run 'erk init --shell' to set up shell integration.
+
+    Without shell integration:
+      source <(erk wt co WORKTREE_NAME --script)
+
+    This will cd to the worktree, create/activate .venv, and load .env variables.
+
+    Special keyword:
+      erk wt co root    # Switch to the root repository
+
+    Example:
+      erk wt co feature-work    # Switch to worktree named "feature-work"
+    """
+    # Validate preconditions upfront (LBYL)
+    Ensure.gh_authenticated(ctx)
+
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Special case: "root" navigates to root repository
+    if worktree_name == "root":
+        activate_root_repo(ctx, repo, script, "co", post_cd_commands=None)
+        return  # activate_root_repo raises SystemExit, but explicit return for clarity
+
+    # Get all worktrees for error messages and lookup
+    worktrees = ctx.git.list_worktrees(repo.root)
+
+    # Validate worktree exists
+    worktree_path = repo.worktrees_dir / worktree_name
+
+    if not ctx.git.path_exists(worktree_path):
+        # Show available worktrees (use already-fetched worktrees list)
+        available_names = ["root"]
+        for wt in worktrees:
+            if not wt.is_root:
+                available_names.append(wt.path.name)
+
+        available_list = ", ".join(f"'{name}'" for name in sorted(available_names))
+        user_output(
+            click.style("Error:", fg="red")
+            + f" Worktree '{worktree_name}' not found.\n\n"
+            + f"Available worktrees: {available_list}\n\n"
+            + "Use 'erk list' to see all worktrees with their branches."
+        )
+
+        # Check if the name looks like a branch (contains '/' or matches known branches)
+        if "/" in worktree_name:
+            user_output(
+                "\nHint: It looks like you provided a branch name. "
+                "Use 'erk br co' to switch by branch name."
+            )
+
+        raise SystemExit(1)
+
+    # Get branch info for this worktree (use already-fetched worktrees list)
+    target_worktree = None
+    for wt in worktrees:
+        if wt.path == worktree_path:
+            target_worktree = wt
+            break
+
+    target_worktree = Ensure.not_none(
+        target_worktree, f"Worktree '{worktree_name}' not found in git worktree list"
+    )
+
+    # Always navigate to worktree root and preserve relative path
+    target_path = worktree_path
+
+    # Show worktree and branch info (only in non-script mode)
+    if not script:
+        branch_name = target_worktree.branch or "(detached HEAD)"
+        styled_wt = click.style(worktree_name, fg="cyan", bold=True)
+        styled_branch = click.style(branch_name, fg="yellow")
+        user_output(f"Went to worktree {styled_wt} [{styled_branch}]")
+
+    # Activate the worktree
+    activate_worktree(
+        ctx=ctx,
+        repo=repo,
+        target_path=target_path,
+        script=script,
+        command_name="co",
+        preserve_relative_path=True,
+        post_cd_commands=None,
+    )