erk 0.4.5__py3-none-any.whl

erk/cli/commands/slot/check_cmd.py

@@ -0,0 +1,277 @@
+"""Slot check command - check pool state consistency with disk and git."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import click
+
+from erk.cli.commands.slot.common import generate_slot_name
+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
+from erk_shared.git.abc import Git, WorktreeInfo
+from erk_shared.output.output import user_output
+
+# Type alias for sync issue codes - using Literal for type safety
+SyncIssueCode = Literal[
+    "orphan-state",
+    "orphan-dir",
+    "missing-branch",
+    "branch-mismatch",
+    "git-registry-missing",
+    "untracked-worktree",
+]
+
+
+@dataclass(frozen=True)
+class SyncIssue:
+    """A sync diagnostic issue found during pool state check."""
+
+    code: SyncIssueCode
+    message: str
+
+
+def _find_erk_managed_dirs(worktrees_dir: Path, git: Git) -> set[str]:
+    """Find directories in worktrees_dir matching erk-managed-wt-* pattern.
+
+    Args:
+        worktrees_dir: Path to the worktrees directory
+        git: Git abstraction for path_exists and is_dir checks
+
+    Returns:
+        Set of slot names (e.g., {"erk-managed-wt-01", "erk-managed-wt-02"})
+    """
+    if not git.path_exists(worktrees_dir):
+        return set()
+
+    result: set[str] = set()
+    # Iterate over worktrees_dir contents
+    # Use path_exists to validate before iterdir
+    for entry in worktrees_dir.iterdir():
+        if entry.name.startswith("erk-managed-wt-") and git.is_dir(entry):
+            result.add(entry.name)
+    return result
+
+
+def _get_git_managed_slots(
+    worktrees: list[WorktreeInfo], worktrees_dir: Path
+) -> dict[str, WorktreeInfo]:
+    """Get worktrees that are erk-managed pool slots.
+
+    Args:
+        worktrees: List of all git worktrees
+        worktrees_dir: Path to the worktrees directory
+
+    Returns:
+        Dict mapping slot name to WorktreeInfo for erk-managed slots
+    """
+    result: dict[str, WorktreeInfo] = {}
+    for wt in worktrees:
+        if wt.path.parent == worktrees_dir and wt.path.name.startswith("erk-managed-wt-"):
+            result[wt.path.name] = wt
+    return result
+
+
+def _check_orphan_states(
+    assignments: tuple[SlotAssignment, ...],
+    ctx: ErkContext,
+) -> list[SyncIssue]:
+    """Check for assignments where the worktree directory doesn't exist.
+
+    Args:
+        assignments: Current pool assignments
+        ctx: Erk context (for git.path_exists)
+
+    Returns:
+        List of (issue_type, message) tuples
+    """
+    issues: list[SyncIssue] = []
+    for assignment in assignments:
+        if not ctx.git.path_exists(assignment.worktree_path):
+            issues.append(
+                SyncIssue(
+                    code="orphan-state",
+                    message=f"Slot {assignment.slot_name}: directory does not exist",
+                )
+            )
+    return issues
+
+
+def _check_orphan_dirs(
+    state: PoolState,
+    fs_slots: set[str],
+) -> list[SyncIssue]:
+    """Check for directories that exist on filesystem but not in pool state.
+
+    Args:
+        state: Pool state (to check against known slots)
+        fs_slots: Set of slot names found on filesystem
+
+    Returns:
+        List of (issue_type, message) tuples
+    """
+    # Generate known slots from pool_size (same logic as slot list command)
+    known_slots = {generate_slot_name(i) for i in range(1, state.pool_size + 1)}
+
+    issues: list[SyncIssue] = []
+    for slot_name in fs_slots:
+        if slot_name not in known_slots:
+            issues.append(
+                SyncIssue(
+                    code="orphan-dir",
+                    message=f"Directory {slot_name}: not in pool state",
+                )
+            )
+    return issues
+
+
+def _check_missing_branches(
+    assignments: tuple[SlotAssignment, ...],
+    ctx: ErkContext,
+    repo_root: Path,
+) -> list[SyncIssue]:
+    """Check for assignments where the branch no longer exists in git.
+
+    Args:
+        assignments: Current pool assignments
+        ctx: Erk context (for git.get_branch_head)
+        repo_root: Path to the repository root
+
+    Returns:
+        List of (issue_type, message) tuples
+    """
+    issues: list[SyncIssue] = []
+    for assignment in assignments:
+        # Check if branch exists by getting its head commit
+        if ctx.git.get_branch_head(repo_root, assignment.branch_name) is None:
+            msg = f"Slot {assignment.slot_name}: branch '{assignment.branch_name}' deleted"
+            issues.append(SyncIssue(code="missing-branch", message=msg))
+    return issues
+
+
+def _check_git_worktree_mismatch(
+    state: PoolState,
+    git_slots: dict[str, WorktreeInfo],
+) -> list[SyncIssue]:
+    """Check for mismatches between pool state and git worktree registry.
+
+    Args:
+        state: Pool state (assignments and known slots)
+        git_slots: Dict of slot names to WorktreeInfo from git
+
+    Returns:
+        List of (issue_type, message) tuples
+    """
+    issues: list[SyncIssue] = []
+
+    # Check assignments against git registry
+    for assignment in state.assignments:
+        if assignment.slot_name in git_slots:
+            wt = git_slots[assignment.slot_name]
+            # Check if branch matches
+            if wt.branch != assignment.branch_name:
+                msg = (
+                    f"Slot {assignment.slot_name}: pool says '{assignment.branch_name}', "
+                    f"git says '{wt.branch}'"
+                )
+                issues.append(SyncIssue(code="branch-mismatch", message=msg))
+        else:
+            # Slot is in pool.json but not in git worktree registry
+            issues.append(
+                SyncIssue(
+                    code="git-registry-missing",
+                    message=f"Slot {assignment.slot_name}: not in git worktree registry",
+                )
+            )
+
+    # Check git registry for slots not in pool state
+    # Generate known slots from pool_size (same logic as slot list command)
+    known_slots = {generate_slot_name(i) for i in range(1, state.pool_size + 1)}
+    for slot_name, wt in git_slots.items():
+        if slot_name not in known_slots:
+            msg = f"Slot {slot_name}: in git registry (branch '{wt.branch}') but not in pool state"
+            issues.append(SyncIssue(code="untracked-worktree", message=msg))
+
+    return issues
+
+
+def run_sync_diagnostics(ctx: ErkContext, state: PoolState, repo_root: Path) -> list[SyncIssue]:
+    """Run all sync diagnostics and return issues found.
+
+    Args:
+        ctx: Erk context
+        state: Pool state to check
+        repo_root: Repository root path
+
+    Returns:
+        List of (issue_type, message) tuples
+    """
+    repo = discover_repo_context(ctx, repo_root)
+
+    # Get git worktrees
+    worktrees = ctx.git.list_worktrees(repo.root)
+    git_slots = _get_git_managed_slots(worktrees, repo.worktrees_dir)
+
+    # Get filesystem state
+    fs_slots = _find_erk_managed_dirs(repo.worktrees_dir, ctx.git)
+
+    # Run all checks
+    issues: list[SyncIssue] = []
+    issues.extend(_check_orphan_states(state.assignments, ctx))
+    issues.extend(_check_orphan_dirs(state, fs_slots))
+    issues.extend(_check_missing_branches(state.assignments, ctx, repo.root))
+    issues.extend(_check_git_worktree_mismatch(state, git_slots))
+
+    return issues
+
+
+@click.command("check")
+@click.pass_obj
+def slot_check(ctx: ErkContext) -> None:
+    """Check pool state consistency with disk and git.
+
+    Reports drift between:
+    - Pool state (pool.json)
+    - Filesystem (worktree directories)
+    - Git worktree registry
+
+    This is a diagnostic command - it does not modify anything.
+    """
+    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
+
+    # Get git worktrees
+    worktrees = ctx.git.list_worktrees(repo.root)
+    git_slots = _get_git_managed_slots(worktrees, repo.worktrees_dir)
+
+    # Get filesystem state
+    fs_slots = _find_erk_managed_dirs(repo.worktrees_dir, ctx.git)
+
+    # Run all checks
+    issues: list[SyncIssue] = []
+    issues.extend(_check_orphan_states(state.assignments, ctx))
+    issues.extend(_check_orphan_dirs(state, fs_slots))
+    issues.extend(_check_missing_branches(state.assignments, ctx, repo.root))
+    issues.extend(_check_git_worktree_mismatch(state, git_slots))
+
+    # Print report
+    user_output("Pool Check Report")
+    user_output("================")
+    user_output("")
+    user_output(f"Pool state: {len(state.assignments)} assignments")
+    user_output(f"Git worktrees: {len(worktrees)} registered ({len(git_slots)} erk-managed)")
+    user_output(f"Filesystem: {len(fs_slots)} slot directories")
+    user_output("")
+
+    if issues:
+        user_output("Issues Found:")
+        for issue in issues:
+            user_output(f"  [{issue.code}] {issue.message}")
+    else:
+        user_output(click.style("✓ No issues found", fg="green"))

erk/cli/commands/slot/common.py

@@ -0,0 +1,314 @@
+"""Shared utilities for slot commands."""
+
+import re
+import shutil
+from pathlib import Path
+
+from erk.core.context import ErkContext
+from erk.core.worktree_pool import PoolState, SlotAssignment
+from erk_shared.git.abc import Git
+from erk_shared.output.output import user_confirm, user_output
+
+# Default pool configuration
+DEFAULT_POOL_SIZE = 4
+SLOT_NAME_PREFIX = "erk-managed-wt"
+
+
+def extract_slot_number(slot_name: str) -> str | None:
+    """Extract slot number from slot name.
+
+    Args:
+        slot_name: Slot name like "erk-managed-wt-03"
+
+    Returns:
+        Two-digit slot number (e.g., "03") or None if not in expected format
+    """
+    if not slot_name.startswith(SLOT_NAME_PREFIX + "-"):
+        return None
+    suffix = slot_name[len(SLOT_NAME_PREFIX) + 1 :]
+    if len(suffix) != 2 or not suffix.isdigit():
+        return None
+    return suffix
+
+
+def get_placeholder_branch_name(slot_name: str) -> str | None:
+    """Get placeholder branch name for a slot.
+
+    Args:
+        slot_name: Slot name like "erk-managed-wt-03"
+
+    Returns:
+        Placeholder branch name like "__erk-slot-03-placeholder__",
+        or None if slot_name is not in expected format
+    """
+    slot_number = extract_slot_number(slot_name)
+    if slot_number is None:
+        return None
+    return f"__erk-slot-{slot_number}-placeholder__"
+
+
+def is_placeholder_branch(branch_name: str) -> bool:
+    """Check if a branch name is an erk slot placeholder branch.
+
+    Placeholder branches have the format: __erk-slot-XX-placeholder__
+
+    Args:
+        branch_name: Branch name to check
+
+    Returns:
+        True if branch_name matches the placeholder pattern
+    """
+    return bool(re.match(r"^__erk-slot-\d+-placeholder__$", branch_name))
+
+
+def get_pool_size(ctx: ErkContext) -> int:
+    """Get effective pool size from config or default.
+
+    Args:
+        ctx: Current erk context with local_config
+
+    Returns:
+        Configured pool size or DEFAULT_POOL_SIZE if not set
+    """
+    if ctx.local_config is not None and ctx.local_config.pool_size is not None:
+        return ctx.local_config.pool_size
+    return DEFAULT_POOL_SIZE
+
+
+def generate_slot_name(slot_number: int) -> str:
+    """Generate a slot name from a slot number.
+
+    Args:
+        slot_number: 1-based slot number
+
+    Returns:
+        Formatted slot name like "erk-managed-wt-01"
+    """
+    return f"{SLOT_NAME_PREFIX}-{slot_number:02d}"
+
+
+def find_next_available_slot(state: PoolState, worktrees_dir: Path | None) -> int | None:
+    """Find the next available slot number for on-demand worktree creation.
+
+    This function finds a slot number that is:
+    1. Not currently assigned to a branch (not in state.assignments)
+    2. Not already initialized as a worktree (not in state.slots)
+    3. Does not have an orphaned directory on disk (if worktrees_dir provided)
+
+    This ensures on-demand creation only targets slots where no worktree
+    exists on disk.
+
+    Args:
+        state: Current pool state
+        worktrees_dir: Directory containing worktrees, or None to skip disk check
+
+    Returns:
+        1-based slot number if available, None if pool is full
+    """
+    assigned_slots = {a.slot_name for a in state.assignments}
+    initialized_slots = {s.name for s in state.slots}
+
+    for slot_num in range(1, state.pool_size + 1):
+        slot_name = generate_slot_name(slot_num)
+        if slot_name not in assigned_slots and slot_name not in initialized_slots:
+            # Check if directory exists on disk (orphaned worktree)
+            if worktrees_dir is not None:
+                slot_path = worktrees_dir / slot_name
+                if slot_path.exists():
+                    continue  # Skip - directory exists but not tracked
+            return slot_num
+
+    return None
+
+
+def find_inactive_slot(
+    state: PoolState,
+    git: Git,
+    repo_root: Path,
+) -> tuple[str, Path] | None:
+    """Find an available managed slot for reuse.
+
+    Searches for worktrees that exist but are not assigned.
+    Uses git as source of truth for which worktrees exist.
+    Prefers slots in order (lowest slot number first).
+
+    Args:
+        state: Current pool state
+        git: Git gateway for worktree operations
+        repo_root: Repository root path
+
+    Returns:
+        Tuple of (slot_name, worktree_path) for an available slot,
+        or None if no inactive slot found
+    """
+    assigned_slots = {a.slot_name for a in state.assignments}
+
+    # Get all worktrees from git (source of truth)
+    worktrees = git.list_worktrees(repo_root)
+
+    # Build lookup of slot_name -> worktree_path for managed slots
+    managed_worktrees: dict[str, Path] = {}
+    for wt in worktrees:
+        slot_name = wt.path.name
+        if extract_slot_number(slot_name) is not None:
+            managed_worktrees[slot_name] = wt.path
+
+    # Find first unassigned slot (by slot number order)
+    for slot_num in range(1, state.pool_size + 1):
+        slot_name = generate_slot_name(slot_num)
+        if slot_name in managed_worktrees and slot_name not in assigned_slots:
+            return (slot_name, managed_worktrees[slot_name])
+
+    return None
+
+
+def is_slot_initialized(state: PoolState, slot_name: str) -> bool:
+    """Check if a slot has been initialized.
+
+    Args:
+        state: Current pool state
+        slot_name: Name of the slot to check
+
+    Returns:
+        True if slot is in the initialized slots list
+    """
+    return any(slot.name == slot_name for slot in state.slots)
+
+
+def find_branch_assignment(state: PoolState, branch_name: str) -> SlotAssignment | None:
+    """Find if a branch is already assigned to a slot.
+
+    Args:
+        state: Current pool state
+        branch_name: Branch to search for
+
+    Returns:
+        SlotAssignment if found, None otherwise
+    """
+    for assignment in state.assignments:
+        if assignment.branch_name == branch_name:
+            return assignment
+    return None
+
+
+def find_assignment_by_worktree(state: PoolState, git: Git, cwd: Path) -> SlotAssignment | None:
+    """Find if cwd is within a managed slot using git.
+
+    Uses git to determine the worktree root of cwd, then matches exactly
+    against known slot assignments. This is more reliable than path
+    comparisons which can fail with symlinks, relative paths, etc.
+
+    Args:
+        state: Current pool state
+        git: Git gateway for repository operations
+        cwd: Current working directory
+
+    Returns:
+        SlotAssignment if cwd is within a managed slot, None otherwise
+    """
+    worktree_root = git.get_repository_root(cwd)
+    for assignment in state.assignments:
+        if assignment.worktree_path == worktree_root:
+            return assignment
+    return None
+
+
+def find_oldest_assignment(state: PoolState) -> SlotAssignment | None:
+    """Find the oldest assignment by assigned_at timestamp.
+
+    Args:
+        state: Current pool state
+
+    Returns:
+        The oldest SlotAssignment, or None if no assignments
+    """
+    if not state.assignments:
+        return None
+
+    oldest: SlotAssignment | None = None
+    for assignment in state.assignments:
+        if oldest is None or assignment.assigned_at < oldest.assigned_at:
+            oldest = assignment
+    return oldest
+
+
+def display_pool_assignments(state: PoolState) -> None:
+    """Display current pool assignments to user.
+
+    Args:
+        state: Current pool state
+    """
+    user_output("\nCurrent pool assignments:")
+    for assignment in sorted(state.assignments, key=lambda a: a.assigned_at):
+        slot = assignment.slot_name
+        branch = assignment.branch_name
+        assigned = assignment.assigned_at
+        user_output(f"  {slot}: {branch} (assigned {assigned})")
+    user_output("")
+
+
+def handle_pool_full_interactive(
+    state: PoolState,
+    force: bool,
+    is_tty: bool,
+) -> SlotAssignment | None:
+    """Handle pool-full condition: prompt to unassign oldest or error.
+
+    When the pool is full:
+    - If --force: auto-unassign the oldest assignment
+    - If interactive (TTY): show assignments and prompt user
+    - If non-interactive (no TTY): error with instructions
+
+    Args:
+        state: Current pool state
+        force: If True, auto-unassign oldest without prompting
+        is_tty: Whether running in an interactive terminal
+
+    Returns:
+        SlotAssignment to unassign, or None if user declined/error
+    """
+    oldest = find_oldest_assignment(state)
+    if oldest is None:
+        return None
+
+    if force:
+        user_output(f"Pool is full. --force specified, unassigning oldest: {oldest.branch_name}")
+        return oldest
+
+    if not is_tty:
+        user_output(
+            f"Error: Pool is full ({state.pool_size} slots). "
+            "Use --force to auto-unassign the oldest branch, "
+            "or run `erk slot list` to see assignments."
+        )
+        return None
+
+    # Interactive mode: show assignments and prompt
+    display_pool_assignments(state)
+    user_output(f"Pool is full ({state.pool_size} slots).")
+    user_output(f"Oldest assignment: {oldest.branch_name} ({oldest.slot_name})")
+
+    if user_confirm(f"Unassign '{oldest.branch_name}' to make room?", default=False):
+        return oldest
+
+    user_output("Aborted.")
+    return None
+
+
+def cleanup_worktree_artifacts(worktree_path: Path) -> None:
+    """Remove stale artifacts from a worktree before reuse.
+
+    Cleans up .impl/ and .erk/scratch/ folders which persist across
+    branch switches since they are in .gitignore.
+
+    Args:
+        worktree_path: Path to the worktree to clean up
+    """
+    impl_folder = worktree_path / ".impl"
+    scratch_folder = worktree_path / ".erk" / "scratch"
+
+    if impl_folder.exists():
+        shutil.rmtree(impl_folder)
+
+    if scratch_folder.exists():
+        shutil.rmtree(scratch_folder)