erk 0.4.5__py3-none-any.whl

erk/cli/commands/slot/init_pool_cmd.py

@@ -0,0 +1,157 @@
+"""Slot init-pool command - proactively initialize pool slots."""
+
+import click
+
+from erk.cli.commands.slot.common import (
+    generate_slot_name,
+    get_placeholder_branch_name,
+    get_pool_size,
+    is_slot_initialized,
+)
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext, create_context
+from erk.core.repo_discovery import ensure_erk_metadata_dir
+from erk.core.worktree_pool import (
+    PoolState,
+    SlotInfo,
+    load_pool_state,
+    save_pool_state,
+)
+from erk_shared.output.output import user_output
+
+
+@click.command("init-pool")
+@click.option(
+    "-n",
+    "--count",
+    type=int,
+    help="Number of slots to initialize. Defaults to pool_size from config.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Print what would be done without executing destructive operations.",
+)
+@click.pass_obj
+def slot_init_pool(ctx: ErkContext, count: int | None, *, dry_run: bool) -> None:
+    """Initialize pool slots with worktrees and placeholder branches.
+
+    Pre-creates worktrees with placeholder branches so they're ready for
+    immediate assignment. This makes `erk slot create` faster because it can
+    reuse existing worktrees instead of creating new ones.
+
+    By default, initializes slots up to the configured pool_size. Use -n to
+    specify a different count.
+
+    Examples:
+        erk slot init-pool       # Initialize all slots up to pool_size
+        erk slot init-pool -n 2  # Initialize just 2 slots
+        erk slot init-pool --dry-run  # Preview without executing
+    """
+    if dry_run:
+        ctx = create_context(dry_run=True)
+
+    repo = discover_repo_context(ctx, ctx.cwd)
+    ensure_erk_metadata_dir(repo)
+
+    # Get effective slot count
+    pool_size = get_pool_size(ctx)
+    slot_count = count if count is not None else pool_size
+
+    # Validate slot count
+    if slot_count < 1:
+        user_output("Error: Slot count must be at least 1")
+        raise SystemExit(1) from None
+
+    if slot_count > pool_size:
+        user_output(
+            f"Warning: Requested {slot_count} slots but pool_size is {pool_size}. "
+            f"Initializing {pool_size} slots."
+        )
+        slot_count = pool_size
+
+    # Load or create pool state
+    state = load_pool_state(repo.pool_json_path)
+    if state is None:
+        state = PoolState(
+            version="1.0",
+            pool_size=pool_size,
+            slots=(),
+            assignments=(),
+        )
+
+    # Get trunk branch for placeholder branches
+    trunk = ctx.git.detect_trunk_branch(repo.root)
+    local_branches = ctx.git.list_local_branches(repo.root)
+
+    initialized_count = 0
+    already_initialized_count = 0
+    new_slots: list[SlotInfo] = list(state.slots)
+
+    for slot_num in range(1, slot_count + 1):
+        slot_name = generate_slot_name(slot_num)
+        worktree_path = repo.worktrees_dir / slot_name
+
+        # Check if already initialized
+        if is_slot_initialized(state, slot_name):
+            already_initialized_count += 1
+            continue
+
+        # Get or create placeholder branch
+        placeholder_branch = get_placeholder_branch_name(slot_name)
+        if placeholder_branch is None:
+            user_output(f"Error: Could not generate placeholder branch for {slot_name}")
+            continue
+
+        if placeholder_branch not in local_branches:
+            ctx.git.create_branch(repo.root, placeholder_branch, trunk)
+
+        # Create worktree directory
+        if ctx.dry_run:
+            user_output(f"[DRY RUN] Would create directory: {worktree_path}")
+        else:
+            worktree_path.mkdir(parents=True, exist_ok=True)
+
+        # Create worktree with placeholder branch
+        if not ctx.git.path_exists(worktree_path / ".git"):
+            ctx.git.add_worktree(
+                repo.root,
+                worktree_path,
+                branch=placeholder_branch,
+                ref=None,
+                create_branch=False,
+            )
+
+        # Add to slots list
+        new_slots.append(SlotInfo(name=slot_name, last_objective_issue=None))
+        initialized_count += 1
+        if ctx.dry_run:
+            user_output(f"[DRY RUN] Would initialize {slot_name}")
+        else:
+            user_output(f"  Initialized {slot_name}")
+
+    # Update and save state
+    new_state = PoolState(
+        version=state.version,
+        pool_size=state.pool_size,
+        slots=tuple(new_slots),
+        assignments=state.assignments,
+    )
+    if ctx.dry_run:
+        user_output("[DRY RUN] Would save pool state")
+    else:
+        save_pool_state(repo.pool_json_path, new_state)
+
+    # Report results
+    if initialized_count > 0:
+        if ctx.dry_run:
+            msg = f"[DRY RUN] Would initialize {initialized_count} slots"
+        else:
+            msg = click.style(f"✓ Initialized {initialized_count} slots", fg="green")
+        if already_initialized_count > 0:
+            msg += f" ({already_initialized_count} already existed)"
+        user_output(msg)
+    elif already_initialized_count > 0:
+        user_output(f"All {already_initialized_count} slots already initialized")
+    else:
+        user_output("No slots to initialize")

erk/cli/commands/slot/list_cmd.py

@@ -0,0 +1,228 @@
+"""Slot list command - display unified worktree pool status."""
+
+from typing import Literal
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from erk.cli.alias import alias
+from erk.cli.commands.slot.common import (
+    DEFAULT_POOL_SIZE,
+    generate_slot_name,
+)
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext
+from erk.core.display_utils import format_relative_time
+from erk.core.worktree_pool import PoolState, load_pool_state
+
+SlotStatus = Literal["available", "assigned", "error"]
+SlotReason = Literal["worktree-missing", "branch-mismatch", "-"]
+
+
+def _determine_slot_status(
+    slot_name: str,
+    assigned_slots: set[str],
+    reason: SlotReason,
+) -> SlotStatus:
+    """Determine the status of a worktree slot.
+
+    Args:
+        slot_name: The slot identifier (e.g., "erk-managed-wt-01")
+        assigned_slots: Set of slot names that have assignments in pool.json
+        reason: The reason code from _get_slot_reason (indicates any problems)
+
+    Returns:
+        Status: "assigned" (healthy assignment), "error" (assignment with problem),
+                "available" (can be used)
+    """
+    # If slot has an assignment in pool.json
+    if slot_name in assigned_slots:
+        # Check if there's a problem with the assignment
+        if reason != "-":
+            return "error"
+        return "assigned"
+
+    # No assignment - slot is available
+    return "available"
+
+
+def _get_slot_reason(
+    assigned_branch: str | None,
+    actual_branch: str | None,
+) -> SlotReason:
+    """Determine the reason for slot state.
+
+    Returns a kebab-case reason explaining any issues with the slot:
+    - "worktree-missing": pool.json has assignment but worktree doesn't exist
+    - "branch-mismatch": worktree exists but has different branch than assignment
+    - "-": healthy state (no problem)
+
+    Args:
+        assigned_branch: Branch assigned in pool.json (if any)
+        actual_branch: Actual branch on filesystem (if any)
+
+    Returns:
+        Reason literal explaining any issues
+    """
+    if actual_branch is None:
+        # No worktree on filesystem
+        if assigned_branch is not None:
+            return "worktree-missing"  # pool.json says assigned but no worktree
+        return "-"  # Neither assigned nor exists - healthy available state
+
+    if assigned_branch is None:
+        # Worktree exists but not assigned - healthy available state
+        return "-"
+
+    # Both exist - check if they match
+    if actual_branch == assigned_branch:
+        return "-"  # Healthy - branches match
+    return "branch-mismatch"
+
+
+@alias("ls")
+@click.command("list")
+@click.pass_obj
+def slot_list(ctx: ErkContext) -> None:
+    """List all pool slots with unified status view.
+
+    Shows a table combining pool.json state and filesystem state:
+    - Worktree: The pool worktree name
+    - Branch: Assigned branch or - (available)
+    - Assigned: When the assignment was made (relative time)
+    - Status: available, assigned (healthy), or error (has problem)
+    - Reason: worktree-missing, branch-mismatch, or - (healthy)
+    """
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Load pool state (or use defaults if no state exists)
+    state = load_pool_state(repo.pool_json_path)
+    if state is None:
+        state = PoolState(
+            version="1.0",
+            pool_size=DEFAULT_POOL_SIZE,
+            slots=(),
+            assignments=(),
+        )
+
+    # Build lookup set
+    assigned_slots = {a.slot_name for a in state.assignments}
+
+    # Build lookup of slot_name -> (branch_name, relative_time)
+    assignments_by_slot: dict[str, tuple[str, str]] = {}
+    for assignment in state.assignments:
+        relative_time = format_relative_time(assignment.assigned_at)
+        assignments_by_slot[assignment.slot_name] = (assignment.branch_name, relative_time)
+
+    # Build lookup of slot_name -> last_objective_issue
+    objectives_by_slot: dict[str, int] = {}
+    for slot in state.slots:
+        if slot.last_objective_issue is not None:
+            objectives_by_slot[slot.name] = slot.last_objective_issue
+
+    # Create Rich table
+    table = Table(show_header=True, header_style="bold", box=None)
+    table.add_column("Worktree", style="cyan", no_wrap=True)
+    table.add_column("Branch", style="yellow", no_wrap=True)
+    table.add_column("Objective", no_wrap=True)
+    table.add_column("Assigned", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Reason", no_wrap=True)
+    table.add_column("Changes", no_wrap=True)
+
+    # Track counts for summary
+    assigned_count = 0
+    error_count = 0
+
+    # Add rows for all slots
+    for slot_num in range(1, state.pool_size + 1):
+        slot_name = generate_slot_name(slot_num)
+        worktree_path = repo.worktrees_dir / slot_name
+
+        # Check if worktree exists and get current branch
+        worktree_exists = ctx.git.path_exists(worktree_path)
+
+        actual_branch: str | None = None
+        if worktree_exists:
+            actual_branch = ctx.git.get_current_branch(worktree_path)
+
+        # Get assigned branch info
+        assigned_branch: str | None = None
+        assigned_time = "-"
+        if slot_name in assignments_by_slot:
+            assigned_branch, assigned_time = assignments_by_slot[slot_name]
+
+        # Determine reason for any issues (needed before status)
+        reason = _get_slot_reason(assigned_branch, actual_branch)
+
+        # Determine status (depends on reason)
+        status = _determine_slot_status(slot_name, assigned_slots, reason)
+
+        # Format branch display
+        if status == "available":
+            branch_display = "[dim]-[/dim]"
+            assigned_time = "-"
+        else:
+            # Both "assigned" and "error" show the assigned branch
+            branch_display = assigned_branch if assigned_branch else "-"
+
+        # Format status with color
+        status_map: dict[SlotStatus, str] = {
+            "available": "[dim]available[/dim]",
+            "assigned": "[green]assigned[/green]",
+            "error": "[red]error[/red]",
+        }
+        status_display = status_map[status]
+
+        # Format reason with color (only shown for error states)
+        reason_map: dict[SlotReason, str] = {
+            "worktree-missing": "[red]worktree-missing[/red]",
+            "branch-mismatch": "[red]branch-mismatch[/red]",
+            "-": "[dim]-[/dim]",
+        }
+        reason_display = reason_map[reason]
+
+        # Format changes display
+        changes_display: str
+        if worktree_exists and ctx.git.has_uncommitted_changes(worktree_path):
+            changes_display = "[yellow]dirty[/yellow]"
+        else:
+            changes_display = "[dim]-[/dim]"
+
+        # Format objective display
+        objective_display: str
+        if slot_name in objectives_by_slot:
+            objective_display = f"#{objectives_by_slot[slot_name]}"
+        else:
+            objective_display = "[dim]-[/dim]"
+
+        table.add_row(
+            slot_name,
+            branch_display,
+            objective_display,
+            assigned_time,
+            status_display,
+            reason_display,
+            changes_display,
+        )
+
+        # Track counts
+        if status == "assigned":
+            assigned_count += 1
+        elif status == "error":
+            error_count += 1
+
+    # Output table to stderr (consistent with user_output convention)
+    # Use width=200 to ensure proper display without truncation
+    console = Console(stderr=True, width=200, force_terminal=True)
+    console.print(table)
+
+    # Print summary
+    available_count = state.pool_size - assigned_count - error_count
+    console.print(
+        f"\nPool: {state.pool_size} slots | "
+        f"{available_count} available | "
+        f"{assigned_count} assigned | "
+        f"{error_count} error"
+    )

erk/cli/commands/slot/repair_cmd.py

@@ -0,0 +1,190 @@
+"""Slot repair command - remove stale assignments from pool state."""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.commands.slot.check_cmd import SyncIssue, run_sync_diagnostics
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext
+from erk.core.worktree_pool import (
+    PoolState,
+    SlotAssignment,
+    load_pool_state,
+    save_pool_state,
+)
+from erk_shared.output.output import user_confirm, user_output
+
+# Issue codes that can be auto-repaired by removing the assignment
+AUTO_REPAIRABLE_CODES = frozenset({"orphan-state"})
+
+
+def _extract_slot_name(issue: SyncIssue) -> str:
+    """Extract slot name from issue message.
+
+    Issue messages have format: "Slot <slot-name>: <description>"
+    """
+    return issue.message.split(":")[0].replace("Slot ", "")
+
+
+def _format_remediation(issue: SyncIssue, worktrees_dir: Path) -> list[str]:
+    """Format remediation suggestions for an issue.
+
+    Args:
+        issue: The sync issue
+        worktrees_dir: Path to worktrees directory (for path display)
+
+    Returns:
+        List of remediation command strings
+    """
+    slot_name = _extract_slot_name(issue)
+    worktree_path = worktrees_dir / slot_name
+
+    if issue.code == "branch-mismatch":
+        # Extract expected branch from message: "pool says 'X', git says 'Y'"
+        # Message format: "Slot <slot>: pool says '<expected>', git says '<actual>'"
+        parts = issue.message.split("pool says '")
+        expected_branch = parts[1].split("'")[0] if len(parts) > 1 else "<expected-branch>"
+        return [
+            f"erk slot unassign {slot_name}",
+            f"cd {worktree_path} && git checkout {expected_branch}",
+        ]
+    elif issue.code == "missing-branch":
+        return [f"erk slot unassign {slot_name}"]
+    elif issue.code == "git-registry-missing":
+        return [f"erk slot unassign {slot_name}"]
+    else:
+        return []
+
+
+def find_stale_assignments(
+    state: PoolState,
+    issues: list[SyncIssue],
+) -> list[SlotAssignment]:
+    """Find assignments that can be auto-repaired.
+
+    Args:
+        state: Pool state to check
+        issues: List of sync issues from run_sync_diagnostics
+
+    Returns:
+        List of stale SlotAssignments (orphan-state issues)
+    """
+    # Collect the slot names that have auto-repairable issues
+    stale_slot_names = {
+        _extract_slot_name(issue) for issue in issues if issue.code in AUTO_REPAIRABLE_CODES
+    }
+
+    # Return the actual assignments that are stale
+    return [a for a in state.assignments if a.slot_name in stale_slot_names]
+
+
+def execute_repair(
+    state: PoolState,
+    stale_assignments: list[SlotAssignment],
+) -> PoolState:
+    """Create new pool state with stale assignments removed.
+
+    Args:
+        state: Current pool state
+        stale_assignments: Assignments to remove
+
+    Returns:
+        New PoolState with stale assignments filtered out
+    """
+    stale_slot_names = {a.slot_name for a in stale_assignments}
+    new_assignments = tuple(a for a in state.assignments if a.slot_name not in stale_slot_names)
+
+    return PoolState(
+        version=state.version,
+        pool_size=state.pool_size,
+        slots=state.slots,
+        assignments=new_assignments,
+    )
+
+
+def _display_informational_issues(
+    issues: list[SyncIssue],
+    worktrees_dir: Path,
+) -> None:
+    """Display informational issues that require manual intervention.
+
+    Args:
+        issues: List of non-auto-repairable issues
+        worktrees_dir: Path to worktrees directory (for path display)
+    """
+    informational = [i for i in issues if i.code not in AUTO_REPAIRABLE_CODES]
+    if not informational:
+        return
+
+    user_output("")
+    user_output(f"Found {len(informational)} issue(s) requiring manual intervention:")
+    for issue in informational:
+        user_output(f"  [{click.style(issue.code, fg='yellow')}] {issue.message}")
+        remediation = _format_remediation(issue, worktrees_dir)
+        if remediation:
+            user_output("    Remediation:")
+            for cmd in remediation:
+                user_output(f"      {click.style(cmd, fg='cyan')}")
+
+
+@click.command("repair")
+@click.option("-f", "--force", is_flag=True, help="Skip confirmation prompt")
+@click.pass_obj
+def slot_repair(ctx: ErkContext, force: bool) -> None:
+    """Remove stale assignments from pool state.
+
+    Finds assignments where the worktree directory no longer exists
+    and removes them from pool.json.
+
+    Also displays other issues (like branch-mismatch) that require
+    manual intervention with suggested remediation commands.
+
+    Use --force to skip the confirmation prompt.
+    """
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Load pool state
+    state = load_pool_state(repo.pool_json_path)
+    if state is None:
+        user_output("Error: No pool configured. Run `erk slot create` first.")
+        raise SystemExit(1) from None
+
+    # Run full diagnostics to get all issues
+    all_issues = run_sync_diagnostics(ctx, state, repo.root)
+
+    # Find stale (auto-repairable) assignments
+    stale_assignments = find_stale_assignments(state, all_issues)
+
+    # Display informational issues (non-auto-repairable)
+    _display_informational_issues(all_issues, repo.worktrees_dir)
+
+    if not stale_assignments:
+        if not any(i.code not in AUTO_REPAIRABLE_CODES for i in all_issues):
+            user_output(click.style("✓ No issues found", fg="green"))
+        return
+
+    # Show what will be repaired
+    user_output("")
+    user_output(f"Found {len(stale_assignments)} repairable issue(s):")
+    for assignment in stale_assignments:
+        user_output(
+            f"  - {click.style(assignment.slot_name, fg='cyan')}: "
+            f"branch '{click.style(assignment.branch_name, fg='yellow')}' "
+            f"(worktree missing)"
+        )
+
+    # Prompt for confirmation unless --force
+    if not force:
+        if not user_confirm("\nRemove these stale assignments?", default=True):
+            user_output("Aborted.")
+            return
+
+    # Execute repair
+    new_state = execute_repair(state, stale_assignments)
+    save_pool_state(repo.pool_json_path, new_state)
+
+    user_output("")
+    user_output(
+        click.style("✓ ", fg="green") + f"Removed {len(stale_assignments)} stale assignment(s)"
+    )

erk/cli/commands/stack/__init__.py

@@ -0,0 +1,23 @@
+"""Stack operation commands for managing worktree stacks."""
+
+import click
+
+from erk.cli.alias import register_with_aliases
+from erk.cli.commands.stack.consolidate_cmd import consolidate_stack
+from erk.cli.commands.stack.list_cmd import list_stack
+from erk.cli.commands.stack.move_cmd import move_stack
+from erk.cli.commands.stack.split_old.command import split_cmd as split_stack
+from erk.cli.graphite_command import GraphiteGroup
+
+
+@click.group("stack", cls=GraphiteGroup)
+def stack_group() -> None:
+    """Manage worktree stack operations."""
+    pass
+
+
+# Register subcommands
+stack_group.add_command(consolidate_stack, name="consolidate")
+register_with_aliases(stack_group, list_stack, name="list")
+stack_group.add_command(move_stack, name="move")
+stack_group.add_command(split_stack, name="split")