erk 0.4.5__py3-none-any.whl

erk/cli/commands/stack/move_cmd.py

@@ -0,0 +1,309 @@
+"""Move branches between worktrees with explicit source specification."""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.commands.completions import complete_worktree_names
+from erk.cli.core import discover_repo_context, worktree_path_for
+from erk.cli.ensure import Ensure
+from erk.core.context import ErkContext
+from erk.core.repo_discovery import ensure_erk_metadata_dir
+from erk.core.worktree_utils import (
+    MoveOperationType,
+    determine_move_operation,
+    find_worktree_containing_path,
+    find_worktree_with_branch,
+    get_worktree_branch,
+)
+from erk_shared.output.output import user_confirm, user_output
+
+
+def _resolve_current_worktree(ctx: ErkContext, repo_root: Path) -> Path:
+    """Find worktree containing current directory.
+
+    Raises SystemExit if not in a git repository or not in any worktree.
+    """
+    Ensure.not_none(ctx.git.get_git_common_dir(ctx.cwd), "Not in a git repository")
+
+    cwd = ctx.cwd.resolve()
+    worktrees = ctx.git.list_worktrees(repo_root)
+    wt_path = find_worktree_containing_path(worktrees, cwd)
+    if wt_path is None:
+        user_output(
+            f"Error: Current directory ({cwd}) is not in any worktree.\n"
+            f"Either run this from within a worktree, or use --worktree or "
+            f"--branch to specify the source."
+        )
+        raise SystemExit(1)
+    return wt_path
+
+
+def resolve_source_worktree(
+    ctx: ErkContext,
+    repo_root: Path,
+    *,
+    current: bool,
+    branch: str | None,
+    worktree: str | None,
+    worktrees_dir: Path,
+) -> Path:
+    """Determine source worktree from flags.
+
+    Defaults to current worktree if no flags provided.
+    Raises SystemExit if multiple flags specified or if source cannot be resolved.
+    """
+    # Count how many source flags are specified
+    flag_count = sum([current, branch is not None, worktree is not None])
+
+    if flag_count > 1:
+        user_output("Error: Only one of --current, --branch, or --worktree can be specified")
+        raise SystemExit(1)
+
+    if flag_count == 0 or current:
+        # Default to current worktree (either no flags or --current explicitly set)
+        return _resolve_current_worktree(ctx, repo_root)
+
+    if branch:
+        # Find worktree containing this branch
+        worktrees = ctx.git.list_worktrees(repo_root)
+        wt = Ensure.not_none(
+            find_worktree_with_branch(worktrees, branch),
+            f"Branch '{branch}' not found in any worktree",
+        )
+        return wt
+
+    if worktree:
+        # Resolve worktree name to path
+        wt_path = worktree_path_for(worktrees_dir, worktree)
+        # Validate that the worktree exists
+        Ensure.path_exists(ctx, wt_path, f"Worktree '{worktree}' does not exist")
+        return wt_path
+
+    user_output("Error: Invalid state - no source specified")
+    raise SystemExit(1)
+
+
+def detect_operation_type(
+    source_wt: Path, target_wt: Path, ctx: ErkContext, repo_root: Path
+) -> MoveOperationType:
+    """Determine whether to move, swap, or create based on target existence.
+
+    Returns MoveOperationType enum value.
+    """
+    worktrees = ctx.git.list_worktrees(repo_root)
+    operation = determine_move_operation(worktrees, source_wt, target_wt)
+    return operation.operation_type
+
+
+def execute_move(
+    ctx: ErkContext,
+    repo_root: Path,
+    source_wt: Path,
+    target_wt: Path,
+    fallback_ref: str,
+    *,
+    force: bool,
+) -> None:
+    """Execute move operation (target doesn't exist or is in detached HEAD).
+
+    Moves the branch from source to target, then switches source to fallback_ref.
+    """
+    # Validate source has a branch
+    worktrees = ctx.git.list_worktrees(repo_root)
+    source_branch = Ensure.not_none(
+        get_worktree_branch(worktrees, source_wt), "Source worktree is in detached HEAD state"
+    )
+
+    # Check for uncommitted changes in source
+    if ctx.git.has_uncommitted_changes(source_wt) and not force:
+        user_output(
+            f"Error: Uncommitted changes in source worktree '{source_wt.name}'.\n"
+            f"Commit, stash, or use --force to override."
+        )
+        raise SystemExit(1)
+
+    target_exists = ctx.git.path_exists(target_wt)
+
+    # To move branch from source to target, we need to avoid having the same branch
+    # checked out in two places simultaneously. Strategy:
+    # 1. Detach HEAD in source worktree (frees up source_branch)
+    # 2. Create/checkout source_branch in target worktree
+    # 3. Checkout fallback_ref in source worktree
+    user_output(f"Moving '{source_branch}' from '{source_wt.name}' to '{target_wt.name}'")
+    ctx.git.checkout_detached(source_wt, source_branch)
+
+    if target_exists:
+        # Target exists - check for uncommitted changes
+        if ctx.git.has_uncommitted_changes(target_wt) and not force:
+            user_output(
+                f"Error: Uncommitted changes in target worktree '{target_wt.name}'.\n"
+                f"Commit, stash, or use --force to override."
+            )
+            raise SystemExit(1)
+
+        # Checkout branch in existing target
+        ctx.git.checkout_branch(target_wt, source_branch)
+    else:
+        # Create new worktree with branch
+        ctx.git.add_worktree(
+            repo_root, target_wt, branch=source_branch, ref=None, create_branch=False
+        )
+
+    # Check if fallback_ref is already checked out elsewhere, and detach it if needed
+    fallback_wt = ctx.git.is_branch_checked_out(repo_root, fallback_ref)
+    if fallback_wt is not None and fallback_wt.resolve() != source_wt.resolve():
+        # Fallback branch is checked out in another worktree, detach it first
+        ctx.git.checkout_detached(fallback_wt, fallback_ref)
+
+    # Switch source to fallback branch
+    ctx.git.checkout_branch(source_wt, fallback_ref)
+
+    user_output(f"✓ Moved '{source_branch}' from '{source_wt.name}' to '{target_wt.name}'")
+
+
+def execute_swap(
+    ctx: ErkContext,
+    repo_root: Path,
+    source_wt: Path,
+    target_wt: Path,
+    *,
+    force: bool,
+) -> None:
+    """Execute swap operation (both worktrees exist with branches).
+
+    Swaps the branches between source and target worktrees.
+    """
+    worktrees = ctx.git.list_worktrees(repo_root)
+    source_branch = get_worktree_branch(worktrees, source_wt)
+    target_branch = get_worktree_branch(worktrees, target_wt)
+
+    if source_branch is None or target_branch is None:
+        user_output("Error: Both worktrees must have branches checked out for swap")
+        raise SystemExit(1)
+
+    # Check for uncommitted changes
+    if ctx.git.has_uncommitted_changes(source_wt) or ctx.git.has_uncommitted_changes(target_wt):
+        if not force:
+            user_output(
+                "Error: Uncommitted changes detected in one or more worktrees.\n"
+                "Commit, stash, or use --force to override."
+            )
+            raise SystemExit(1)
+
+    # Confirm swap unless --force
+    if not force:
+        user_output("This will swap branches between worktrees:")
+        user_output(f"  '{source_wt.name}': '{source_branch}' → '{target_branch}'")
+        user_output(f"  '{target_wt.name}': '{target_branch}' → '{source_branch}'")
+        if not user_confirm("Continue?", default=False):
+            user_output("Swap cancelled")
+            raise SystemExit(0)
+
+    user_output(f"Swapping branches between '{source_wt.name}' and '{target_wt.name}'")
+
+    # To swap branches between worktrees, we need to avoid having the same branch
+    # checked out in two places simultaneously. Strategy:
+    # 1. Detach HEAD in source worktree (frees up source_branch)
+    # 2. Checkout source_branch in target worktree
+    # 3. Checkout target_branch in source worktree
+    ctx.git.checkout_detached(source_wt, source_branch)
+    ctx.git.checkout_branch(target_wt, source_branch)
+    ctx.git.checkout_branch(source_wt, target_branch)
+
+    user_output(f"✓ Swapped '{source_branch}' ↔ '{target_branch}'")
+
+
+@click.command("move")
+@click.option("--current", is_flag=True, help="Use current worktree as source")
+@click.option("--branch", help="Auto-detect worktree containing this branch")
+@click.option("--worktree", help="Use specific worktree as source")
+@click.option("--ref", default="main", help="Fallback branch for source after move (default: main)")
+@click.option("-f", "--force", is_flag=True, help="Skip confirmation prompts")
+@click.argument("target", required=True, shell_complete=complete_worktree_names)
+@click.pass_obj
+def move_stack(
+    ctx: ErkContext,
+    current: bool,
+    branch: str | None,
+    worktree: str | None,
+    ref: str,
+    force: bool,
+    target: str,
+) -> None:
+    """Move branches between worktrees with explicit source specification.
+
+    Examples:
+
+        \b
+        # Move current branch back to repository root
+        erk move root
+
+        \b
+        # Move from current worktree to new worktree
+        erk move target-wt
+
+        \b
+        # Move from current worktree (explicit)
+        erk move --current target-wt
+
+        \b
+        # Auto-detect source from branch name
+        erk move --branch feature-x new-wt
+
+        \b
+        # Move from specific source to target
+        erk move --worktree old-wt new-wt
+
+        \b
+        # Swap branches between current and another worktree
+        erk move --current existing-wt
+
+        \b
+        # Force operation without prompts (for scripts)
+        erk move --current target-wt --force
+
+        \b
+        # Specify custom fallback branch
+        erk move --current new-wt --ref develop
+    """
+    # Discover repository context
+    repo = discover_repo_context(ctx, ctx.cwd)
+    ensure_erk_metadata_dir(repo)
+
+    # Resolve source worktree
+    source_wt = resolve_source_worktree(
+        ctx,
+        repo.root,
+        current=current,
+        branch=branch,
+        worktree=worktree,
+        worktrees_dir=repo.worktrees_dir,
+    )
+
+    # Resolve target worktree path
+    # Special case: "root" refers to the main repository root (not current worktree)
+    if target == "root":
+        # main_repo_root is always set by RepoContext.__post_init__, but ty doesn't know
+        target_wt = repo.main_repo_root if repo.main_repo_root else repo.root
+    else:
+        target_wt = worktree_path_for(repo.worktrees_dir, target)
+
+    # Validate source and target are different
+    if source_wt.resolve() == target_wt.resolve():
+        user_output("Error: Source and target worktrees are the same")
+        raise SystemExit(1)
+
+    # Detect operation type
+    operation_type = detect_operation_type(source_wt, target_wt, ctx, repo.root)
+
+    # Execute operation
+    if operation_type == MoveOperationType.SWAP:
+        execute_swap(ctx, repo.root, source_wt, target_wt, force=force)
+    else:
+        # Auto-detect default branch if using 'main' default and it doesn't exist
+        if ref == "main":
+            detected_default = ctx.git.detect_trunk_branch(repo.root)
+            ref = detected_default
+
+        execute_move(ctx, repo.root, source_wt, target_wt, ref, force=force)

erk/cli/commands/stack/split_old/README.md

@@ -0,0 +1,64 @@
+# Split Command
+
+The split command creates individual worktrees for each branch in a Graphite stack, implementing the ephemeral worktree pattern. It's the inverse of the consolidate command.
+
+## Overview
+
+Split takes a consolidated worktree (where multiple branches exist in one worktree via `gt stack checkout`) and creates individual worktrees for each branch. This allows parallel development across multiple branches in a stack.
+
+## Module Structure
+
+- `command.py` - CLI entry point, validation, and orchestration
+- `plan.py` - Models, planning logic, and worktree creation
+- `display.py` - Output formatting and user interaction
+
+## Key Concepts
+
+### Exclusions
+
+The split command automatically excludes:
+
+- **Trunk branch** (main/master) - stays in the root worktree
+- **Current branch** - already checked out, can't have duplicate worktrees
+- **Existing worktrees** - idempotent operation, preserves existing worktrees
+
+### Stack Filtering
+
+- `--up` - Split only upstack (current branch to leaf)
+- `--down` - Split only downstack (trunk to current branch)
+- Default - Split entire stack (trunk to leaf)
+
+## Workflow Phases
+
+1. **Validation** - Check flags, trunk availability, uncommitted changes
+2. **Discovery** - Get Graphite stack branches
+3. **Filtering** - Apply --up/--down filters
+4. **Planning** - Identify branches needing worktrees
+5. **Preview** - Show what will be created
+6. **Confirmation** - User approval (unless --force or --dry-run)
+7. **Execution** - Create worktrees
+8. **Results** - Display what was created
+
+## Usage Examples
+
+```bash
+# Split full stack into worktrees
+erk split
+
+# Split only upstack branches
+erk split --up
+
+# Preview without creating
+erk split --dry-run
+
+# Skip confirmation
+erk split --force
+```
+
+## Integration
+
+The split command integrates with:
+
+- **Graphite** - Uses gt to determine stack structure
+- **Git worktrees** - Creates standard git worktrees
+- **Erks directory** - Places worktrees in `.erks/`

erk/cli/commands/stack/split_old/__init__.py

@@ -0,0 +1,5 @@
+"""Split command subpackage - split stacks into individual worktrees.
+
+Import from command submodule:
+- command: split_cmd
+"""

erk/cli/commands/stack/split_old/command.py

@@ -0,0 +1,233 @@
+"""Split command - CLI entry point, validation, and orchestration."""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.commands.stack.split_old.display import (
+    confirm_split,
+    display_creation_preview,
+    display_results,
+    display_stack_preview,
+)
+from erk.cli.commands.stack.split_old.plan import (
+    create_split_plan,
+    execute_split_plan,
+    get_stack_branches,
+)
+from erk.cli.core import discover_repo_context
+from erk.cli.graphite_command import GraphiteCommand
+from erk.core.context import ErkContext
+from erk_shared.naming import sanitize_worktree_name
+from erk_shared.output.output import user_output
+
+# Validation functions
+
+
+def validate_flags(up: bool, down: bool) -> None:
+    """Validate that --up and --down are not used together.
+
+    Raises:
+        SystemExit: If both flags are set
+    """
+    if up and down:
+        user_output(click.style("❌ Error: Cannot use --up and --down together", fg="red"))
+        user_output(
+            "Use either --up (split upstack) or --down (split downstack) or neither (full stack)"
+        )
+        raise SystemExit(1)
+
+
+def validate_trunk_branch(trunk_branch: str | None) -> None:
+    """Validate trunk branch is available.
+
+    Raises:
+        SystemExit: If trunk branch cannot be determined
+    """
+    if not trunk_branch:
+        user_output(click.style("❌ Error: Cannot determine trunk branch", fg="red"))
+        user_output("Initialize repository or configure trunk branch")
+        raise SystemExit(1)
+
+
+def check_uncommitted_changes(
+    ctx: ErkContext,
+    current_worktree: Path,
+    force: bool,
+    dry_run: bool,
+) -> None:
+    """Check for uncommitted changes unless --force or --dry-run.
+
+    Raises:
+        SystemExit: If uncommitted changes detected
+    """
+    if not force and not dry_run:
+        if ctx.git.has_uncommitted_changes(current_worktree):
+            user_output(click.style("❌ Error: Uncommitted changes detected", fg="red", bold=True))
+            user_output("\nCommit or stash changes before running split")
+            raise SystemExit(1)
+
+
+# Stack filtering
+
+
+def apply_stack_filter(
+    stack_branches: list[str],
+    current_branch: str | None,
+    up: bool,
+    down: bool,
+) -> list[str]:
+    """Apply --up or --down filters to determine which branches to split.
+
+    Args:
+        stack_branches: Full stack from trunk to leaf
+        current_branch: Currently checked out branch (None if detached)
+        up: If True, only split upstack (current to leaf)
+        down: If True, only split downstack (trunk to current)
+
+    Returns:
+        Filtered list of branches to split
+
+    Notes:
+        - If both up and down are False, returns full stack
+        - If current_branch is None, filters have no effect
+        - If current_branch is not in stack, returns empty list
+    """
+    if up and current_branch is not None:
+        # Only split upstack (from current to leaf)
+        if current_branch in stack_branches:
+            current_index = stack_branches.index(current_branch)
+            return stack_branches[current_index:]
+        else:
+            # Current branch not in stack, split nothing
+            return []
+    elif down and current_branch is not None:
+        # Only split downstack (from trunk to current)
+        if current_branch in stack_branches:
+            current_index = stack_branches.index(current_branch)
+            return stack_branches[: current_index + 1]
+        else:
+            # Current branch not in stack, split nothing
+            return []
+    else:
+        # Split entire stack
+        return stack_branches
+
+
+# Main CLI command
+
+
+@click.command("split", cls=GraphiteCommand)
+@click.option("-f", "--force", is_flag=True, help="Skip confirmation prompt")
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Show what worktrees would be created without executing",
+)
+@click.option(
+    "--up",
+    is_flag=True,
+    help="Only split upstack (current branch to leaf). Default is entire stack.",
+)
+@click.option(
+    "--down",
+    is_flag=True,
+    help="Only split downstack (trunk to current branch). Default is entire stack.",
+)
+@click.pass_obj
+def split_cmd(
+    ctx: ErkContext,
+    force: bool,
+    dry_run: bool,
+    up: bool,
+    down: bool,
+) -> None:
+    """Split a stack into individual worktrees per branch.
+
+    This is the inverse of consolidate - it creates individual worktrees for each
+    branch in the stack (except trunk and the current branch).
+
+    By default, splits the full stack (trunk to leaf). With --up or --down, splits
+    only a portion of the stack.
+
+    This command is useful after consolidating branches for operations like
+    'gt restack', allowing you to return to the ephemeral worktree pattern.
+
+    \b
+    Examples:
+      # Split full stack into individual worktrees (default)
+      $ erk split
+
+      # Split only upstack (current to leaf)
+      $ erk split --up
+
+      # Split only downstack (trunk to current)
+      $ erk split --down
+
+      # Preview changes without executing
+      $ erk split --dry-run
+
+      # Skip confirmation prompt
+      $ erk split --force
+
+    Notes:
+    - Trunk branch (main/master) stays in root worktree
+    - Current branch cannot get its own worktree (already checked out)
+    - Existing worktrees are preserved (idempotent operation)
+    - Creates worktrees in the .erks directory
+    """
+    # 1. Validate input flags
+    validate_flags(up, down)
+
+    # 2. Gather repository context
+    current_worktree = ctx.cwd
+    current_branch = ctx.git.get_current_branch(current_worktree)
+    repo = discover_repo_context(ctx, current_worktree)
+    trunk_branch = ctx.trunk_branch
+    validate_trunk_branch(trunk_branch)
+    # After validation, trunk_branch is guaranteed to be non-None
+    assert trunk_branch is not None  # Type narrowing for mypy/ty
+
+    # 3. Get stack branches
+    stack_branches = get_stack_branches(ctx, repo.root, current_branch, trunk_branch)
+
+    # 4. Apply stack filters
+    stack_to_split = apply_stack_filter(stack_branches, current_branch, up, down)
+
+    # 5. Safety checks
+    check_uncommitted_changes(ctx, current_worktree, force, dry_run)
+
+    # 6. Create split plan
+    all_worktrees = ctx.git.list_worktrees(repo.root)
+    plan = create_split_plan(
+        stack_branches=stack_to_split,
+        trunk_branch=trunk_branch,
+        current_branch=current_branch,
+        all_worktrees=all_worktrees,
+        worktrees_dir=repo.worktrees_dir,
+        sanitize_worktree_name=sanitize_worktree_name,
+        source_worktree_path=current_worktree,
+        repo_root=repo.root,
+    )
+
+    # 7. Display preview
+    display_stack_preview(stack_to_split, trunk_branch, current_branch, plan)
+    display_creation_preview(plan, dry_run)
+
+    # Early exit if nothing to do
+    if not plan.branches_to_split:
+        return
+
+    # 8. Get user confirmation
+    confirm_split(force, dry_run)
+
+    # 9. Execute or simulate
+    user_output("")
+    if dry_run:
+        results = [(branch, plan.target_paths[branch]) for branch in plan.branches_to_split]
+    else:
+        results = execute_split_plan(plan, ctx.git)
+
+    # 10. Display results
+    display_results(results, dry_run)