erk 0.4.5__py3-none-any.whl

erk/cli/commands/project/__init__.py

@@ -0,0 +1,16 @@
+"""Project management commands."""
+
+import click
+
+from erk.cli.commands.project.init_cmd import init_project
+from erk.cli.help_formatter import ErkCommandGroup
+
+
+@click.group("project", cls=ErkCommandGroup, grouped=False)
+def project_group() -> None:
+    """Manage project or projects (within a monorepo)."""
+    pass
+
+
+# Register subcommands
+project_group.add_command(init_project)

erk/cli/commands/project/init_cmd.py

@@ -0,0 +1,91 @@
+"""Project init command - initialize a project in the current directory."""
+
+import click
+
+from erk.cli.core import discover_repo_context
+from erk.core.context import ErkContext
+from erk_shared.output.output import user_output
+
+# Template for project.toml
+PROJECT_TOML_TEMPLATE = """\
+# Project configuration for erk
+# This file identifies this directory as an erk project within a monorepo.
+
+# Optional: custom project name (defaults to directory name)
+# name = "{project_name}"
+
+[env]
+# Project-specific environment variables (merged with repo-level config)
+# These variables are available in .env files created for worktrees
+# Example:
+# DAGSTER_HOME = "{{project_root}}"
+
+[post_create]
+# Commands to run after worktree creation, FROM the project directory
+# These run AFTER repo-level post_create commands
+# shell = "bash"
+# commands = [
+#   "source .venv/bin/activate",
+# ]
+"""
+
+
+@click.command("init")
+@click.pass_obj
+def init_project(ctx: ErkContext) -> None:
+    """Initialize a project in the current directory.
+
+    Creates a .erk/project.toml file that identifies this directory as
+    a project within a monorepo. When worktrees are created from this
+    project context, erk will:
+
+    - Record the project path in worktrees.toml
+    - Navigate to the project subdirectory on `erk wt co`
+    - Merge project-level config with repo-level config
+    - Run project-specific post_create commands
+
+    Example:
+        cd /code/internal/python_modules/my-project
+        erk project init
+    """
+    # Validate we're in a git repo
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # Don't allow init at repo root (check before project.toml to give clearer error)
+    if ctx.cwd.resolve() == repo.root.resolve():
+        user_output(
+            click.style("Error: ", fg="red") + "Cannot initialize project at repository root.\n"
+            "Projects are subdirectories within a repo. "
+            "Use `erk init` for repository-level configuration."
+        )
+        raise SystemExit(1)
+
+    # Check if project.toml already exists
+    project_toml_path = ctx.cwd / ".erk" / "project.toml"
+    if ctx.git.path_exists(project_toml_path):
+        user_output(
+            click.style("Error: ", fg="red") + f"Project already initialized: {project_toml_path}"
+        )
+        raise SystemExit(1)
+
+    # Create .erk directory and project.toml
+    erk_dir = ctx.cwd / ".erk"
+    erk_dir.mkdir(parents=True, exist_ok=True)
+
+    project_name = ctx.cwd.name
+    content = PROJECT_TOML_TEMPLATE.format(project_name=project_name)
+    project_toml_path.write_text(content, encoding="utf-8")
+
+    # Calculate path from repo root for display
+    path_from_repo = ctx.cwd.relative_to(repo.root)
+
+    user_output(
+        click.style("✓ ", fg="green")
+        + f"Initialized project: {click.style(project_name, fg='cyan', bold=True)}"
+    )
+    user_output(f"  Location: {path_from_repo}")
+    user_output(f"  Config: {project_toml_path}")
+    user_output("")
+    user_output("Next steps:")
+    user_output(f"  1. Edit {project_toml_path} to configure project settings")
+    user_output("  2. Create a worktree from this project: erk wt create <name>")

erk/cli/commands/run/__init__.py

@@ -0,0 +1,17 @@
+"""Run management commands."""
+
+import click
+
+from erk.cli.commands.run.list_cmd import list_runs
+from erk.cli.commands.run.logs_cmd import logs_run
+
+
+@click.group("run")
+def run_group() -> None:
+    """View GitHub Actions workflow runs for plan implementations."""
+    pass
+
+
+# Register subcommands
+run_group.add_command(list_runs)
+run_group.add_command(logs_run)

erk/cli/commands/run/list_cmd.py

@@ -0,0 +1,189 @@
+"""List workflow runs command."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from erk.cli.commands.plan.list_cmd import format_pr_cell, select_display_pr
+from erk.cli.commands.run.shared import extract_issue_number
+from erk.cli.constants import DISPATCH_WORKFLOW_NAME
+from erk.cli.core import discover_repo_context
+from erk.cli.ensure import Ensure
+from erk.core.context import ErkContext
+from erk.core.display_utils import (
+    format_submission_time,
+    format_workflow_outcome,
+    format_workflow_run_id,
+)
+from erk_shared.github.emoji import format_checks_cell
+from erk_shared.github.parsing import github_repo_location_from_url
+from erk_shared.github.types import GitHubRepoId
+from erk_shared.output.output import user_output
+
+
+def _list_runs(ctx: ErkContext, show_all: bool = False) -> None:
+    """List workflow runs in a run-centric table view."""
+    # Validate preconditions upfront (LBYL)
+    Ensure.gh_authenticated(ctx)
+
+    # Discover repository context
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    # 1. Fetch workflow runs from dispatch workflow
+    runs = ctx.github.list_workflow_runs(repo.root, DISPATCH_WORKFLOW_NAME)
+
+    # Handle empty state
+    if not runs:
+        user_output("No workflow runs found")
+        return
+
+    # Filter out runs without plans unless --show-legacy flag is set
+    if not show_all:
+        runs = [run for run in runs if extract_issue_number(run.display_title) is not None]
+        if not runs:
+            user_output("No runs with plans found. Use --show-legacy to see all runs.")
+            return
+
+    # 2. Extract issue numbers from display_title (format: "123:abc456")
+    issue_numbers: list[int] = []
+    for run in runs:
+        issue_num = extract_issue_number(run.display_title)
+        if issue_num is not None:
+            issue_numbers.append(issue_num)
+
+    # 3. Fetch issues for titles (using issues interface)
+    issues = ctx.issues.list_issues(repo.root, labels=["erk-plan"])
+    issue_map = {issue.number: issue for issue in issues}
+
+    # Second filtering pass - remove runs where we can't display title
+    if not show_all:
+        filtered_runs = []
+        for run in runs:
+            issue_num = extract_issue_number(run.display_title)
+            if issue_num is None:
+                continue  # Already filtered, but defensive check
+
+            # Filter if issue not found
+            if issue_num not in issue_map:
+                continue
+
+            # Filter if title is empty
+            issue = issue_map[issue_num]
+            if not issue.title or not issue.title.strip():
+                continue
+
+            filtered_runs.append(run)
+
+        runs = filtered_runs
+
+        # Show message if ALL runs filtered
+        if not runs:
+            user_output("No runs with plans found. Use --show-legacy to see all runs.")
+            return
+
+    # Extract location from first issue URL (needed for API calls and links)
+    location = None
+    if issues:
+        location = github_repo_location_from_url(repo.root, issues[0].url)
+
+    # 4. Batch fetch PRs linked to issues
+    pr_linkages: dict[int, list] = {}
+    if issue_numbers and location is not None:
+        pr_linkages = ctx.github.get_prs_linked_to_issues(location, issue_numbers)
+
+    # Determine use_graphite for URL selection
+    use_graphite = ctx.global_config.use_graphite if ctx.global_config else False
+
+    # 5. Build table
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("run-id", style="cyan", no_wrap=True)
+    table.add_column("status", no_wrap=True, width=14)
+    table.add_column("submitted", no_wrap=True, width=11)
+    table.add_column("plan", no_wrap=True)
+    table.add_column("title", no_wrap=True)
+    table.add_column("pr", no_wrap=True)
+    table.add_column("chks", no_wrap=True)
+
+    for run in runs:
+        issue_num = extract_issue_number(run.display_title)
+
+        # Format run-id with link
+        workflow_url = None
+        if location is not None:
+            workflow_url = f"https://github.com/{location.repo_id.owner}/{location.repo_id.repo}/actions/runs/{run.run_id}"
+        run_id_cell = format_workflow_run_id(run, workflow_url)
+
+        # Format status
+        status_cell = format_workflow_outcome(run)
+
+        # Format submission time
+        submitted_cell = format_submission_time(run.created_at)
+
+        # Handle legacy runs where we can't parse the issue number
+        # Show "X" to indicate "can't parse" vs "-" for "no data"
+        if issue_num is None:
+            # Legacy format - can't extract issue linkage
+            plan_cell = "[dim]X[/dim]"
+            title_cell = "[dim]X[/dim]"
+            pr_cell = "[dim]X[/dim]"
+            checks_cell = "[dim]X[/dim]"
+        else:
+            # New format - have issue number, try to get data
+            issue_url = None
+            if location is not None:
+                issue_url = f"https://github.com/{location.repo_id.owner}/{location.repo_id.repo}/issues/{issue_num}"
+            # Make plan number clickable
+            if issue_url:
+                plan_cell = f"[link={issue_url}][cyan]#{issue_num}[/cyan][/link]"
+            else:
+                plan_cell = f"[cyan]#{issue_num}[/cyan]"
+
+            # Get title from issue map
+            if issue_num in issue_map:
+                issue = issue_map[issue_num]
+
+                title = issue.title
+                # Truncate to 50 characters
+                if len(title) > 50:
+                    title = title[:47] + "..."
+                title_cell = title
+            else:
+                title_cell = "[dim]-[/dim]"
+
+            # Format PR column
+            pr_cell = "-"
+            checks_cell = "-"
+            if issue_num in pr_linkages:
+                prs = pr_linkages[issue_num]
+                selected_pr = select_display_pr(prs)
+                if selected_pr is not None:
+                    graphite_url = ctx.graphite.get_graphite_url(
+                        GitHubRepoId(selected_pr.owner, selected_pr.repo), selected_pr.number
+                    )
+                    pr_cell = format_pr_cell(
+                        selected_pr, use_graphite=use_graphite, graphite_url=graphite_url
+                    )
+                    checks_cell = format_checks_cell(selected_pr)
+
+        table.add_row(
+            run_id_cell,
+            status_cell,
+            submitted_cell,
+            plan_cell,
+            title_cell,
+            pr_cell,
+            checks_cell,
+        )
+
+    # Output table to stderr (consistent with user_output convention)
+    console = Console(stderr=True, width=200, force_terminal=True)
+    console.print(table)
+    console.print()  # Add blank line after table
+
+
+@click.command("list")
+@click.option("--show-legacy", is_flag=True, help="Show all runs including legacy runs.")
+@click.pass_obj
+def list_runs(ctx: ErkContext, show_legacy: bool) -> None:
+    """List GitHub Actions workflow runs for plan implementations."""
+    _list_runs(ctx, show_legacy)

erk/cli/commands/run/logs_cmd.py

@@ -0,0 +1,54 @@
+"""View workflow run logs command."""
+
+import click
+
+from erk.cli.core import discover_repo_context
+from erk.cli.ensure import Ensure
+from erk.core.context import ErkContext
+from erk_shared.output.output import user_output
+
+
+@click.command("logs")
+@click.argument("run_id", required=False)
+@click.pass_obj
+def logs_run(ctx: ErkContext, run_id: str | None) -> None:
+    """View logs for a workflow run.
+
+    If RUN_ID is not provided, shows logs for the most recent run
+    on the current branch.
+    """
+    # Validate preconditions upfront (LBYL)
+    Ensure.gh_authenticated(ctx)
+
+    # Discover repository context
+    repo = discover_repo_context(ctx, ctx.cwd)
+
+    if run_id is None:
+        # Auto-detect: find most recent run for current branch
+        current_branch = Ensure.not_none(
+            ctx.git.get_current_branch(ctx.cwd), "Could not determine current branch"
+        )
+
+        runs = ctx.github.list_workflow_runs(repo.root, "implement-plan.yml", limit=50)
+        branch_runs = [r for r in runs if r.branch == current_branch]
+
+        if not branch_runs:
+            user_output(
+                f"No workflow runs found for branch: {click.style(current_branch, fg='yellow')}"
+            )
+            raise SystemExit(1)
+
+        # Most recent is first (list_workflow_runs returns newest first)
+        run_id = branch_runs[0].run_id
+        user_output(
+            f"Showing logs for run {click.style(run_id, fg='cyan')} "
+            f"on branch {click.style(current_branch, fg='yellow')}\n"
+        )
+
+    try:
+        log_output = ctx.github.get_run_logs(repo.root, run_id)
+        # Direct output - logs go to stdout for piping
+        click.echo(log_output)
+    except RuntimeError as e:
+        click.echo(click.style("Error: ", fg="red") + str(e), err=True)
+        raise SystemExit(1) from None

erk/cli/commands/run/shared.py

@@ -0,0 +1,19 @@
+"""Shared utilities for run commands."""
+
+
+def extract_issue_number(display_title: str | None) -> int | None:
+    """Extract issue number from display_title format '123:abc456'.
+
+    Handles:
+    - New format: "123:abc456" → 123
+    - Old format: "Issue title [abc123]" → None (no colon at start)
+    - None or empty → None
+    """
+    if not display_title or ":" not in display_title:
+        return None
+    parts = display_title.split(":", 1)
+    # Validate that the first part is a number
+    first_part = parts[0].strip()
+    if not first_part.isdigit():
+        return None
+    return int(first_part)

erk/cli/commands/shell_integration.py

@@ -0,0 +1,29 @@
+import click
+
+from erk.cli.shell_integration.handler import (
+    PASSTHROUGH_MARKER,
+    ShellIntegrationResult,
+    handle_shell_request,
+)
+from erk_shared.output.output import machine_output
+
+
+@click.command(
+    "__shell",
+    hidden=True,
+    add_help_option=False,
+    context_settings={"ignore_unknown_options": True, "allow_interspersed_args": False},
+)
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def hidden_shell_cmd(args: tuple[str, ...]) -> None:
+    """Unified entry point for shell integration wrappers."""
+    result: ShellIntegrationResult = handle_shell_request(args)
+
+    if result.passthrough:
+        machine_output(PASSTHROUGH_MARKER)
+        raise SystemExit(result.exit_code)
+
+    if result.script:
+        machine_output(result.script, nl=False)
+
+    raise SystemExit(result.exit_code)

erk/cli/commands/slot/__init__.py

@@ -0,0 +1,23 @@
+"""Slot infrastructure management commands."""
+
+import click
+
+from erk.cli.alias import register_with_aliases
+from erk.cli.commands.slot.check_cmd import slot_check
+from erk.cli.commands.slot.init_pool_cmd import slot_init_pool
+from erk.cli.commands.slot.list_cmd import slot_list
+from erk.cli.commands.slot.repair_cmd import slot_repair
+from erk.cli.help_formatter import ErkCommandGroup
+
+
+@click.group("slot", cls=ErkCommandGroup, grouped=False)
+def slot_group() -> None:
+    """Manage worktree pool slots (infrastructure only)."""
+    pass
+
+
+# Register subcommands
+slot_group.add_command(slot_check)
+slot_group.add_command(slot_init_pool)
+slot_group.add_command(slot_repair)
+register_with_aliases(slot_group, slot_list)