erk 0.4.5__py3-none-any.whl

erk/cli/commands/wt/list_cmd.py

@@ -0,0 +1,332 @@
+"""Fast local-only worktree listing command."""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from erk.cli.alias import alias
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext
+from erk.core.display_utils import format_relative_time, get_pr_status_emoji
+from erk.core.repo_discovery import RepoContext
+from erk.core.worktree_utils import find_current_worktree
+from erk_shared.git.abc import BranchSyncInfo
+from erk_shared.github.types import GitHubRepoId, PullRequestInfo
+from erk_shared.impl_folder import get_impl_path, read_issue_reference
+
+
+def _get_sync_status(ctx: ErkContext, worktree_path: Path, branch: str | None) -> str:
+    """Get sync status description for a branch.
+
+    Args:
+        ctx: Erk context with git operations
+        worktree_path: Path to the worktree (used for git commands)
+        branch: Branch name, or None if detached HEAD
+
+    Returns:
+        Sync status: "current", "3↑", "2↓", "3↑ 2↓", or "-"
+    """
+    if branch is None:
+        return "-"
+
+    # Get tracking info - returns (0, 0) if no tracking branch
+    ahead, behind = ctx.git.get_ahead_behind(worktree_path, branch)
+
+    # Check if this is "no tracking branch" case vs "up to date"
+    # The git interface returns (0, 0) for both cases, so we check if there's a tracking branch
+    # For now, treat (0, 0) as "current" since it's the most common case
+    if ahead == 0 and behind == 0:
+        return "current"
+
+    parts = []
+    if ahead > 0:
+        parts.append(f"{ahead}↑")
+    if behind > 0:
+        parts.append(f"{behind}↓")
+    return " ".join(parts)
+
+
+def _format_sync_from_batch(all_sync: dict[str, BranchSyncInfo], branch: str | None) -> str:
+    """Format sync status from batch-fetched data.
+
+    Args:
+        all_sync: Dict mapping branch name to BranchSyncInfo
+        branch: Branch name, or None if detached HEAD
+
+    Returns:
+        Sync status: "current", "3↑", "2↓", "3↑ 2↓", or "-"
+    """
+    if branch is None:
+        return "-"
+
+    info = all_sync.get(branch)
+    if info is None:
+        return "-"
+
+    if info.ahead == 0 and info.behind == 0:
+        return "current"
+
+    parts = []
+    if info.ahead > 0:
+        parts.append(f"{info.ahead}↑")
+    if info.behind > 0:
+        parts.append(f"{info.behind}↓")
+    return " ".join(parts)
+
+
+def _get_impl_issue(
+    ctx: ErkContext, worktree_path: Path, branch: str | None = None
+) -> tuple[str | None, str | None]:
+    """Get impl issue number and URL from local sources.
+
+    Checks .impl/issue.json first, then git config fallback.
+
+    Args:
+        ctx: Erk context with git operations
+        worktree_path: Path to the worktree directory
+        branch: Optional branch name (avoids redundant git subprocess call if provided)
+
+    Returns:
+        Tuple of (issue number formatted as "#{number}", issue URL) or (None, None) if not found
+    """
+    # Try .impl/issue.json first
+    impl_path = get_impl_path(worktree_path, git_ops=ctx.git)
+    if impl_path is not None:
+        # impl_path points to plan.md, get the parent .impl/ directory
+        issue_ref = read_issue_reference(impl_path.parent)
+        if issue_ref is not None:
+            return f"#{issue_ref.issue_number}", issue_ref.issue_url
+
+    # Fallback to git config (no URL available from git config)
+    # If branch not provided, fetch it (for backwards compatibility)
+    if branch is None:
+        branch = ctx.git.get_current_branch(worktree_path)
+    if branch is not None:
+        issue_num = ctx.git.get_branch_issue(worktree_path, branch)
+        if issue_num is not None:
+            return f"#{issue_num}", None
+
+    return None, None
+
+
+def _format_pr_cell(
+    pr: PullRequestInfo | None, *, use_graphite: bool, graphite_url: str | None
+) -> str:
+    """Format PR cell for Rich table: emoji + clickable #number or "-".
+
+    Args:
+        pr: Pull request info, or None if no PR
+        use_graphite: If True, use Graphite URL; if False, use GitHub URL
+        graphite_url: Graphite URL for the PR (None if unavailable)
+
+    Returns:
+        Formatted string for table cell with Rich link markup
+    """
+    if pr is None:
+        return "-"
+
+    emoji = get_pr_status_emoji(pr)
+    pr_text = f"#{pr.number}"
+
+    # Determine which URL to use
+    url = graphite_url if use_graphite else pr.url
+
+    # Make PR number clickable if URL is available using Rich [link=...] markup
+    if url:
+        return f"{emoji} [link={url}]{pr_text}[/link]"
+    else:
+        return f"{emoji} {pr_text}"
+
+
+def _format_impl_cell(issue_text: str | None, issue_url: str | None) -> str:
+    """Format impl issue cell for Rich table with optional link.
+
+    Args:
+        issue_text: Issue number formatted as "#{number}", or None
+        issue_url: Issue URL for clickable link, or None
+
+    Returns:
+        Formatted string for table cell with Rich link markup
+    """
+    if issue_text is None:
+        return "-"
+
+    if issue_url:
+        return f"[link={issue_url}]{issue_text}[/link]"
+    else:
+        return issue_text
+
+
+def _format_last_commit_cell(
+    ctx: ErkContext, repo_root: Path, branch: str | None, trunk: str
+) -> str:
+    """Format last commit time cell for Rich table.
+
+    Args:
+        ctx: Erk context with git operations
+        repo_root: Path to the repository root
+        branch: Branch name, or None if detached HEAD
+        trunk: Trunk branch name
+
+    Returns:
+        Relative time string (e.g., "2d ago") or "-" if no unique commits
+    """
+    if branch is None or branch == trunk:
+        return "-"
+    timestamp = ctx.git.get_branch_last_commit_time(repo_root, branch, trunk)
+    if timestamp is None:
+        return "-"
+    relative_time = format_relative_time(timestamp)
+    return relative_time if relative_time else "-"
+
+
+def _list_worktrees(ctx: ErkContext, *, show_last_commit: bool = False) -> None:
+    """List worktrees with fast local-only data.
+
+    Shows a Rich table with columns:
+    - worktree: Directory name with cwd indicator
+    - branch: Branch name or (=) if matches worktree name
+    - pr: PR emoji + number from Graphite cache
+    - sync: Ahead/behind status
+    - impl: Issue number from .impl/issue.json
+    """
+    # Use ctx.repo if it's a valid RepoContext, otherwise discover
+    if isinstance(ctx.repo, RepoContext):
+        repo = ctx.repo
+    else:
+        repo = discover_repo_context(ctx, ctx.cwd)
+
+    current_dir = ctx.cwd
+
+    # Get worktree info
+    worktrees = ctx.git.list_worktrees(repo.root)
+
+    # Fetch all branch sync info in a single git call (batch operation for performance)
+    all_sync_info = ctx.git.get_all_branch_sync_info(repo.root)
+
+    # Determine which worktree the user is currently in
+    wt_info = find_current_worktree(worktrees, current_dir)
+    current_worktree_path = wt_info.path if wt_info is not None else None
+
+    # Fetch PR information from Graphite cache (graceful degradation)
+    prs: dict[str, PullRequestInfo] = {}
+    if ctx.global_config and ctx.global_config.show_pr_info:
+        graphite_prs = ctx.graphite.get_prs_from_graphite(ctx.git, repo.root)
+        if graphite_prs:
+            prs = graphite_prs
+        # If Graphite cache is missing, prs stays empty - graceful degradation
+
+    # Determine use_graphite for URL selection
+    use_graphite = ctx.global_config.use_graphite if ctx.global_config else False
+
+    # Get trunk branch once if showing last commit
+    trunk = ctx.git.detect_trunk_branch(repo.root) if show_last_commit else ""
+
+    # 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("pr", no_wrap=True)
+    table.add_column("sync", no_wrap=True)
+    if show_last_commit:
+        table.add_column("last", no_wrap=True)
+    table.add_column("impl", no_wrap=True)
+
+    # Build rows starting with root worktree
+    root_branch = None
+    for wt in worktrees:
+        if wt.path == repo.root:
+            root_branch = wt.branch
+            break
+
+    # Root worktree row
+    is_current_root = repo.root == current_worktree_path
+    root_name = "root"
+    if is_current_root:
+        root_name = "[green bold]root[/green bold] ← (cwd)"
+    else:
+        root_name = "[green bold]root[/green bold]"
+
+    root_branch_display = f"({root_branch})" if root_branch else "-"
+    root_pr = prs.get(root_branch) if root_branch else None
+    root_graphite_url = (
+        ctx.graphite.get_graphite_url(GitHubRepoId(root_pr.owner, root_pr.repo), root_pr.number)
+        if root_pr
+        else None
+    )
+    root_pr_cell = _format_pr_cell(
+        root_pr, use_graphite=use_graphite, graphite_url=root_graphite_url
+    )
+    root_sync = _format_sync_from_batch(all_sync_info, root_branch)
+    root_impl_text, root_impl_url = _get_impl_issue(ctx, repo.root, root_branch)
+    root_impl_cell = _format_impl_cell(root_impl_text, root_impl_url)
+
+    if show_last_commit:
+        root_last_cell = _format_last_commit_cell(ctx, repo.root, root_branch, trunk)
+        table.add_row(
+            root_name, root_branch_display, root_pr_cell, root_sync, root_last_cell, root_impl_cell
+        )
+    else:
+        table.add_row(root_name, root_branch_display, root_pr_cell, root_sync, root_impl_cell)
+
+    # Non-root worktrees, sorted by name
+    non_root_worktrees = [wt for wt in worktrees if wt.path != repo.root]
+    for wt in sorted(non_root_worktrees, key=lambda w: w.path.name):
+        name = wt.path.name
+        branch = wt.branch
+        is_current = wt.path == current_worktree_path
+
+        # Format name with cwd indicator if current
+        if is_current:
+            name_cell = f"[cyan bold]{name}[/cyan bold] ← (cwd)"
+        else:
+            name_cell = f"[cyan]{name}[/cyan]"
+
+        # Branch display: (=) if matches name, else (branch-name)
+        if branch is not None:
+            branch_display = "(=)" if name == branch else f"({branch})"
+        else:
+            branch_display = "-"
+
+        # PR info from Graphite cache
+        pr = prs.get(branch) if branch else None
+        graphite_url = None
+        if pr:
+            graphite_url = ctx.graphite.get_graphite_url(GitHubRepoId(pr.owner, pr.repo), pr.number)
+        pr_cell = _format_pr_cell(pr, use_graphite=use_graphite, graphite_url=graphite_url)
+
+        # Sync status
+        sync_cell = _format_sync_from_batch(all_sync_info, branch)
+
+        # Impl issue
+        impl_text, impl_url = _get_impl_issue(ctx, wt.path, branch)
+        impl_cell = _format_impl_cell(impl_text, impl_url)
+
+        if show_last_commit:
+            last_cell = _format_last_commit_cell(ctx, repo.root, branch, trunk)
+            table.add_row(name_cell, branch_display, pr_cell, sync_cell, last_cell, impl_cell)
+        else:
+            table.add_row(name_cell, branch_display, pr_cell, sync_cell, impl_cell)
+
+    # Output table to stderr (consistent with user_output convention)
+    console = Console(stderr=True, force_terminal=True)
+    console.print(table)
+
+
+@alias("ls")
+@click.command("list")
+@click.pass_obj
+def list_wt(ctx: ErkContext) -> None:
+    """List worktrees with branch, PR, sync, and implementation info.
+
+    Shows a fast local-only table with:
+    - worktree: Directory name
+    - branch: Branch name (or = if matches worktree name)
+    - pr: PR status from Graphite cache
+    - sync: Ahead/behind status vs tracking branch
+    - last: Last commit time
+    - impl: Implementation issue number
+    """
+    _list_worktrees(ctx, show_last_commit=True)

erk/cli/commands/wt/rename_cmd.py

@@ -0,0 +1,66 @@
+import click
+
+from erk.cli.commands.completions import complete_worktree_names
+from erk.cli.commands.wt.create_cmd import make_env_content
+from erk.cli.core import discover_repo_context, worktree_path_for
+from erk.cli.ensure import Ensure
+from erk.core.context import ErkContext, create_context
+from erk.core.repo_discovery import ensure_erk_metadata_dir
+from erk_shared.naming import sanitize_worktree_name
+from erk_shared.output.output import user_output
+
+
+@click.command("rename")
+@click.argument("old_name", metavar="OLD_NAME", shell_complete=complete_worktree_names)
+@click.argument("new_name", metavar="NEW_NAME")
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    # dry_run=False: Allow destructive operations by default
+    default=False,
+    help="Print what would be done without executing destructive operations.",
+)
+@click.pass_obj
+def rename_wt(ctx: ErkContext, old_name: str, new_name: str, dry_run: bool) -> None:
+    """Rename a worktree directory.
+
+    Renames the worktree directory and updates git metadata.
+    The .env file is regenerated with updated paths and name.
+    """
+    # Create dry-run context if needed
+    if dry_run:
+        ctx = create_context(dry_run=True)
+
+    # Sanitize new name
+    sanitized_new_name = sanitize_worktree_name(new_name)
+
+    repo = discover_repo_context(ctx, ctx.cwd)
+    ensure_erk_metadata_dir(repo)
+
+    old_path = worktree_path_for(repo.worktrees_dir, old_name)
+    new_path = worktree_path_for(repo.worktrees_dir, sanitized_new_name)
+
+    # Validate old worktree exists
+    Ensure.path_exists(ctx, old_path, f"Worktree not found: {old_path}")
+
+    # Validate new path doesn't already exist
+    Ensure.invariant(not ctx.git.path_exists(new_path), f"Destination already exists: {new_path}")
+
+    # Move via git worktree move
+    ctx.git.move_worktree(repo.root, old_path, new_path)
+
+    # Regenerate .env file with updated paths and name
+    cfg = ctx.local_config
+    env_content = make_env_content(
+        cfg, worktree_path=new_path, repo_root=repo.root, name=sanitized_new_name
+    )
+
+    # Write .env file (dry-run vs real)
+    env_file = new_path / ".env"
+    if ctx.dry_run:
+        user_output(f"[DRY RUN] Would write .env file: {env_file}")
+    else:
+        env_file.write_text(env_content, encoding="utf-8")
+
+    user_output(f"Renamed worktree: {old_name} -> {sanitized_new_name}")
+    user_output(str(new_path))

erk/cli/config.py

@@ -0,0 +1,242 @@
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+# Re-export LoadedConfig from erk_shared for backwards compatibility
+from erk_shared.context.types import LoadedConfig as LoadedConfig
+
+
+@dataclass(frozen=True)
+class ProjectConfig:
+    """In-memory representation of `.erk/project.toml`.
+
+    Example project.toml:
+      # Optional: custom name (defaults to directory name)
+      # name = "dagster-open-platform"
+
+      [env]
+      # Project-specific env vars (merged with repo-level)
+      DAGSTER_HOME = "{project_root}"
+
+      [post_create]
+      # Runs AFTER repo-level commands, FROM project directory
+      shell = "bash"
+      commands = [
+        "source .venv/bin/activate",
+      ]
+    """
+
+    name: str | None  # Custom project name (None = use directory name)
+    env: dict[str, str]
+    post_create_commands: list[str]
+    post_create_shell: str | None
+
+
+@dataclass(frozen=True)
+class LegacyConfigLocation:
+    """Information about a detected legacy config location."""
+
+    path: Path
+    description: str
+
+
+def _parse_config_file(cfg_path: Path) -> LoadedConfig:
+    """Parse a config.toml file into a LoadedConfig.
+
+    Args:
+        cfg_path: Path to the config.toml file (must exist)
+
+    Returns:
+        LoadedConfig with parsed values
+    """
+    data = tomllib.loads(cfg_path.read_text(encoding="utf-8"))
+    env = {str(k): str(v) for k, v in data.get("env", {}).items()}
+    post = data.get("post_create", {})
+    commands = [str(x) for x in post.get("commands", [])]
+    shell = post.get("shell")
+    if shell is not None:
+        shell = str(shell)
+
+    # Parse [plans] section
+    plans = data.get("plans", {})
+    plans_repo = plans.get("repo")
+    if plans_repo is not None:
+        plans_repo = str(plans_repo)
+
+    # Parse [pool] section
+    pool = data.get("pool", {})
+    pool_size = pool.get("max_slots")
+    if pool_size is not None:
+        pool_size = int(pool_size)
+
+    # Parse [pool.checkout] section
+    pool_checkout = pool.get("checkout", {})
+    pool_checkout_commands = [str(x) for x in pool_checkout.get("commands", [])]
+    pool_checkout_shell = pool_checkout.get("shell")
+    if pool_checkout_shell is not None:
+        pool_checkout_shell = str(pool_checkout_shell)
+
+    return LoadedConfig(
+        env=env,
+        post_create_commands=commands,
+        post_create_shell=shell,
+        plans_repo=plans_repo,
+        pool_size=pool_size,
+        pool_checkout_commands=pool_checkout_commands,
+        pool_checkout_shell=pool_checkout_shell,
+    )
+
+
+def detect_legacy_config_locations(
+    repo_root: Path, legacy_metadata_dir: Path | None
+) -> list[LegacyConfigLocation]:
+    """Detect legacy config.toml files that should be migrated.
+
+    Legacy locations:
+    1. <repo-root>/config.toml (created by 'erk init --repo')
+    2. ~/.erk/repos/<repo>/config.toml (created by 'erk init' without --repo)
+
+    Args:
+        repo_root: Path to the repository root
+        legacy_metadata_dir: Path to ~/.erk/repos/<repo>/ directory (or None)
+
+    Returns:
+        List of detected legacy config locations
+    """
+    legacy_locations: list[LegacyConfigLocation] = []
+
+    # Check for config at repo root (created by 'erk init --repo')
+    repo_root_config = repo_root / "config.toml"
+    if repo_root_config.exists():
+        legacy_locations.append(
+            LegacyConfigLocation(
+                path=repo_root_config,
+                description="repo root (created by 'erk init --repo')",
+            )
+        )
+
+    # Check for config in ~/.erk/repos/<repo>/ (created by 'erk init')
+    if legacy_metadata_dir is not None:
+        metadata_dir_config = legacy_metadata_dir / "config.toml"
+        if metadata_dir_config.exists():
+            legacy_locations.append(
+                LegacyConfigLocation(
+                    path=metadata_dir_config,
+                    description=f"~/.erk/repos/ metadata dir ({legacy_metadata_dir})",
+                )
+            )
+
+    return legacy_locations
+
+
+def load_config(repo_root: Path) -> LoadedConfig:
+    """Load config.toml for a repository.
+
+    Location: <repo-root>/.erk/config.toml
+
+    Example config:
+      [env]
+      DAGSTER_GIT_REPO_DIR = "{worktree_path}"
+
+      [post_create]
+      shell = "bash"
+      commands = [
+        "uv venv",
+        "uv run make dev_install",
+      ]
+
+    Note: Legacy config locations (repo root, ~/.erk/repos/) are NOT supported here.
+    Run 'erk doctor' to detect legacy configs that need migration.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        LoadedConfig with parsed values or defaults if no config found
+    """
+    config_path = repo_root / ".erk" / "config.toml"
+    if config_path.exists():
+        return _parse_config_file(config_path)
+
+    # No config found
+    return LoadedConfig(
+        env={},
+        post_create_commands=[],
+        post_create_shell=None,
+        plans_repo=None,
+        pool_size=None,
+        pool_checkout_commands=[],
+        pool_checkout_shell=None,
+    )
+
+
+def load_project_config(project_root: Path) -> ProjectConfig:
+    """Load project.toml from the project's .erk directory.
+
+    Args:
+        project_root: Path to the project root directory
+
+    Returns:
+        ProjectConfig with parsed values, or defaults if file doesn't exist
+    """
+    cfg_path = project_root / ".erk" / "project.toml"
+    if not cfg_path.exists():
+        return ProjectConfig(name=None, env={}, post_create_commands=[], post_create_shell=None)
+
+    data = tomllib.loads(cfg_path.read_text(encoding="utf-8"))
+
+    # Optional name field
+    name = data.get("name")
+    if name is not None:
+        name = str(name)
+
+    # Env vars
+    env = {str(k): str(v) for k, v in data.get("env", {}).items()}
+
+    # Post-create commands
+    post = data.get("post_create", {})
+    commands = [str(x) for x in post.get("commands", [])]
+    shell = post.get("shell")
+    if shell is not None:
+        shell = str(shell)
+
+    return ProjectConfig(name=name, env=env, post_create_commands=commands, post_create_shell=shell)
+
+
+def merge_configs(repo_config: LoadedConfig, project_config: ProjectConfig) -> LoadedConfig:
+    """Merge repo-level and project-level configs.
+
+    Merge rules:
+    - env: Project values override repo values (dict merge)
+    - post_create_commands: Repo commands run first, then project commands (list concat)
+    - post_create_shell: Project shell overrides repo shell if set
+
+    Args:
+        repo_config: Repository-level configuration
+        project_config: Project-level configuration
+
+    Returns:
+        Merged LoadedConfig
+    """
+    # Merge env: project overrides repo
+    merged_env = {**repo_config.env, **project_config.env}
+
+    # Concat commands: repo first, then project
+    merged_commands = repo_config.post_create_commands + project_config.post_create_commands
+
+    # Shell: project overrides if set
+    merged_shell = (
+        project_config.post_create_shell
+        if project_config.post_create_shell is not None
+        else repo_config.post_create_shell
+    )
+
+    return LoadedConfig(
+        env=merged_env,
+        post_create_commands=merged_commands,
+        post_create_shell=merged_shell,
+        plans_repo=repo_config.plans_repo,
+        pool_size=repo_config.pool_size,  # Pool is repo-level only, no project override
+        pool_checkout_commands=repo_config.pool_checkout_commands,
+        pool_checkout_shell=repo_config.pool_checkout_shell,
+    )

erk/cli/constants.py

@@ -0,0 +1,29 @@
+"""Shared constants for erk CLI commands."""
+
+# GitHub issue label for erk plans
+ERK_PLAN_LABEL = "erk-plan"
+
+# GitHub Actions workflow for remote implementation dispatch
+DISPATCH_WORKFLOW_NAME = "erk-impl.yml"
+DISPATCH_WORKFLOW_METADATA_NAME = "erk-impl"
+
+# Workflow names that trigger the autofix workflow
+# Must match the `name:` field in each .yml file (which should match filename without .yml)
+AUTOFIX_TRIGGER_WORKFLOWS = frozenset(
+    {
+        "python-format",
+        "lint",
+        "docs-check",
+        "markdown-format",
+    }
+)
+
+# Documentation extraction tracking label
+DOCS_EXTRACTED_LABEL = "docs-extracted"
+DOCS_EXTRACTED_LABEL_DESCRIPTION = "Session logs analyzed for documentation improvements"
+DOCS_EXTRACTED_LABEL_COLOR = "5319E7"  # Purple
+
+# Extraction plan label (for plans that extract documentation from sessions)
+ERK_EXTRACTION_LABEL = "erk-extraction"
+ERK_EXTRACTION_LABEL_DESCRIPTION = "Documentation extraction plan"
+ERK_EXTRACTION_LABEL_COLOR = "D93F0B"  # Orange-red