erk 0.4.5__py3-none-any.whl

erk/data/github/workflows/erk-impl.yml

@@ -0,0 +1,251 @@
+name: erk-impl
+run-name: "${{ inputs.issue_number }}:${{ inputs.distinct_id }}"
+
+on:
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: "GitHub issue number to implement"
+        required: true
+        type: string
+      submitted_by:
+        description: "GitHub username of the person who submitted the issue"
+        required: true
+        type: string
+      distinct_id:
+        description: "Unique identifier for run discovery (base36)"
+        required: true
+        type: string
+      issue_title:
+        description: "Issue title for workflow run display"
+        required: true
+        type: string
+      branch_name:
+        description: "Branch name for implementation (created by submit command)"
+        required: true
+        type: string
+      pr_number:
+        description: "PR number for implementation (created by submit command)"
+        required: true
+        type: string
+      model_name:
+        description: "Claude model to use for implementation"
+        required: false
+        type: string
+        default: "claude-sonnet-4-5"
+
+concurrency:
+  group: implement-issue-${{ github.event.inputs.issue_number }}
+  cancel-in-progress: true
+
+jobs:
+  implement:
+    runs-on: ubuntu-latest
+    timeout-minutes: 180
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.ERK_QUEUE_GH_PAT }}
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.14"
+
+      - name: Install Claude Code
+        uses: ./.github/actions/setup-claude-code
+
+      - name: Setup remaining tools
+        run: |
+          npm install -g prettier
+          cd $GITHUB_WORKSPACE
+          uv tool install -e . --with-editable ./packages/erk-shared
+
+      - name: Configure git
+        env:
+          SUBMITTED_BY: ${{ inputs.submitted_by }}
+        run: |
+          git config user.name "$SUBMITTED_BY"
+          git config user.email "${SUBMITTED_BY}@users.noreply.github.com"
+
+      - name: Detect trunk branch
+        id: trunk
+        run: |
+          result=$(erk exec detect-trunk-branch)
+          echo "trunk_branch=$(echo "$result" | jq -r '.trunk_branch')" >> $GITHUB_OUTPUT
+
+      - name: Set branch and PR from inputs
+        id: find_pr
+        run: |
+          echo "branch_name=${{ inputs.branch_name }}" >> $GITHUB_OUTPUT
+          echo "pr_number=${{ inputs.pr_number }}" >> $GITHUB_OUTPUT
+          echo "pr_exists=true" >> $GITHUB_OUTPUT
+          echo "Using branch: ${{ inputs.branch_name }}"
+          echo "Using PR: #${{ inputs.pr_number }}"
+
+      - name: Checkout implementation branch
+        env:
+          BRANCH_NAME: ${{ steps.find_pr.outputs.branch_name }}
+          ISSUE_NUMBER: ${{ inputs.issue_number }}
+          SUBMITTED_BY: ${{ inputs.submitted_by }}
+          GH_TOKEN: ${{ github.token }}
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          git fetch origin "$BRANCH_NAME"
+          git checkout "$BRANCH_NAME"
+          rm -rf .worker-impl
+          erk exec create-worker-impl-from-issue "$ISSUE_NUMBER"
+          if [ $? -ne 0 ]; then
+            gh issue comment "$ISSUE_NUMBER" --body "Could not fetch plan content for issue #$ISSUE_NUMBER."
+            exit 1
+          fi
+          git config user.name "$SUBMITTED_BY"
+          git config user.email "$SUBMITTED_BY@users.noreply.github.com"
+          git add .worker-impl
+          if [[ -n $(git status --porcelain) ]]; then
+            git commit -m "Update plan for issue #$ISSUE_NUMBER (rerun)"
+            git push origin "$BRANCH_NAME"
+          fi
+          echo "Checked out branch: $BRANCH_NAME"
+
+      - name: Post workflow started comment
+        env:
+          ISSUE_NUMBER: ${{ inputs.issue_number }}
+          BRANCH_NAME: ${{ steps.find_pr.outputs.branch_name }}
+          PR_NUMBER: ${{ inputs.pr_number }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          erk exec post-workflow-started-comment \
+            --issue-number "$ISSUE_NUMBER" \
+            --branch-name "$BRANCH_NAME" \
+            --pr-number "$PR_NUMBER" \
+            --run-id "${{ github.run_id }}" \
+            --run-url "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" \
+            --repository "${{ github.repository }}"
+
+      - name: Add remote execution note to PR
+        env:
+          PR_NUMBER: ${{ inputs.pr_number }}
+          GH_TOKEN: ${{ github.token }}
+          WORKFLOW_RUN_ID: ${{ github.run_id }}
+          WORKFLOW_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          erk exec add-remote-execution-note \
+            --pr-number "$PR_NUMBER" \
+            --run-id "$WORKFLOW_RUN_ID" \
+            --run-url "$WORKFLOW_RUN_URL"
+
+      - name: Set up implementation folder
+        run: |
+          cp -r .worker-impl .impl
+          echo "Copied .worker-impl/ to .impl/"
+          cat > .impl/run-info.json <<EOF
+          {
+            "run_id": "${{ github.run_id }}",
+            "run_url": "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+          }
+          EOF
+          echo "Created .impl/run-info.json"
+
+      - name: Run implementation
+        id: implement
+        run: |
+          set +e
+          claude --print \
+            --model ${{ inputs.model_name }} \
+            --output-format stream-json \
+            --dangerously-skip-permissions \
+            --verbose \
+            "/erk:plan-implement"
+          EXIT_CODE=$?
+          echo "exit_code=$EXIT_CODE" >> $GITHUB_OUTPUT
+          if [ $EXIT_CODE -eq 0 ]; then
+            echo "implementation_success=true" >> $GITHUB_OUTPUT
+          else
+            echo "implementation_success=false" >> $GITHUB_OUTPUT
+          fi
+          if [ -d .worker-impl/ ]; then
+            rm -rf .worker-impl/
+            echo "Removed .worker-impl/ before submission"
+          fi
+          exit 0
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GH_TOKEN: ${{ github.token }}
+          PR_NUMBER: ${{ inputs.pr_number }}
+
+      - name: Submit branch with proper commit message
+        id: submit
+        continue-on-error: true
+        if: steps.implement.outputs.implementation_success == 'true'
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GH_TOKEN: ${{ github.token }}
+          ISSUE_NUMBER: ${{ inputs.issue_number }}
+          BRANCH_NAME: ${{ steps.find_pr.outputs.branch_name }}
+          SUBMITTED_BY: ${{ inputs.submitted_by }}
+        run: |
+          git config user.name "$SUBMITTED_BY"
+          git config user.email "$SUBMITTED_BY@users.noreply.github.com"
+          claude --print \
+            --model ${{ inputs.model_name }} \
+            --output-format stream-json \
+            --dangerously-skip-permissions \
+            --verbose \
+            "/erk:git-pr-push Implement issue #$ISSUE_NUMBER"
+          echo "impl_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+
+      - name: Handle merge conflicts if push failed
+        id: handle_conflicts
+        if: steps.submit.outcome == 'failure'
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          erk exec rebase-with-conflict-resolution \
+            --trunk-branch "${{ steps.trunk.outputs.trunk_branch }}" \
+            --branch-name "${{ steps.find_pr.outputs.branch_name }}" \
+            --model "${{ inputs.model_name }}"
+
+      - name: Mark PR ready for review
+        if: steps.implement.outputs.implementation_success == 'true' && (steps.submit.outcome == 'success' || steps.handle_conflicts.outcome == 'success')
+        env:
+          GH_TOKEN: ${{ github.token }}
+          BRANCH_NAME: ${{ steps.find_pr.outputs.branch_name }}
+        run: |
+          gh pr ready "$BRANCH_NAME"
+          echo "PR marked ready for review"
+
+      - name: Update PR body with implementation summary
+        continue-on-error: true
+        if: steps.implement.outputs.implementation_success == 'true' && (steps.submit.outcome == 'success' || steps.handle_conflicts.outcome == 'success')
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          erk exec ci-update-pr-body \
+            --issue-number "${{ inputs.issue_number }}" \
+            --run-id "${{ github.run_id }}" \
+            --run-url "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+
+      - name: Trigger CI workflows
+        if: steps.implement.outputs.implementation_success == 'true' && (steps.submit.outcome == 'success' || steps.handle_conflicts.outcome == 'success')
+        env:
+          BRANCH_NAME: ${{ steps.find_pr.outputs.branch_name }}
+          SUBMITTED_BY: ${{ inputs.submitted_by }}
+        run: |
+          git config user.name "$SUBMITTED_BY"
+          git config user.email "$SUBMITTED_BY@users.noreply.github.com"
+          git commit --allow-empty -m "Trigger CI workflows"
+          git push origin "$BRANCH_NAME"
+          echo "CI workflows triggered via push event"

erk/hooks/__init__.py

@@ -0,0 +1 @@
+"""Hook utilities for erk CLI."""

erk/hooks/decorators.py

@@ -0,0 +1,319 @@
+"""Decorators for hook commands."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import io
+import json
+import os
+import sys
+import traceback
+from collections.abc import Callable
+from contextlib import redirect_stderr, redirect_stdout
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, TypeVar, cast
+
+if TYPE_CHECKING:
+    import click
+
+from erk_shared.context.types import NoRepoSentinel
+from erk_shared.hooks.logging import (
+    MAX_STDERR_BYTES,
+    MAX_STDIN_BYTES,
+    MAX_STDOUT_BYTES,
+    truncate_string,
+    write_hook_log,
+)
+from erk_shared.hooks.types import HookExecutionLog, HookExitStatus, classify_exit_code
+from erk_shared.scratch.scratch import get_scratch_dir
+
+F = TypeVar("F", bound=Callable[..., None])
+
+
+@dataclass(frozen=True)
+class HookContext:
+    """Context injected into hooks by the @logged_hook decorator.
+
+    This dataclass consolidates common derived values that hooks need,
+    eliminating duplicated code across hook implementations.
+
+    Attributes:
+        session_id: Claude session ID from stdin JSON, or None if not available.
+        repo_root: Path to the git repository root.
+        scratch_dir: Session-scoped scratch directory, or None if no session_id.
+        is_erk_project: True if repo_root/.erk directory exists.
+    """
+
+    session_id: str | None
+    repo_root: Path
+    scratch_dir: Path | None
+    is_erk_project: bool
+
+
+def _read_stdin_once() -> str:
+    """Read stdin if available, returning empty string if not.
+
+    This is a one-time read - stdin cannot be read again after this.
+    """
+    if sys.stdin.isatty():
+        return ""
+    return sys.stdin.read()
+
+
+def _extract_session_id(stdin_data: str) -> str | None:
+    """Extract session_id from stdin JSON if present.
+
+    Args:
+        stdin_data: Raw stdin content
+
+    Returns:
+        session_id if found in JSON, None otherwise
+    """
+    if not stdin_data.strip():
+        return None
+    data = json.loads(stdin_data)
+    return data.get("session_id")
+
+
+def _build_hook_context(
+    session_id: str | None,
+    repo_root: Path,
+) -> HookContext:
+    """Build HookContext with derived values.
+
+    Args:
+        session_id: Claude session ID from stdin JSON, or None.
+        repo_root: Path to the git repository root.
+
+    Returns:
+        HookContext with all derived values computed.
+    """
+    is_erk_project = (repo_root / ".erk").is_dir()
+
+    scratch_dir: Path | None = None
+    if session_id is not None:
+        scratch_dir = get_scratch_dir(session_id, repo_root=repo_root)
+
+    return HookContext(
+        session_id=session_id,
+        repo_root=repo_root,
+        scratch_dir=scratch_dir,
+        is_erk_project=is_erk_project,
+    )
+
+
+def _extract_repo_root_from_click_context(args: tuple) -> Path | None:
+    """Extract repo_root from Click context if available.
+
+    Looks for ctx.obj with a repo attribute that has a root path.
+    Handles NoRepoSentinel by returning None.
+
+    Args:
+        args: Positional arguments passed to the wrapped function.
+
+    Returns:
+        Path to repo root if found, None otherwise.
+    """
+    # First arg should be Click context if @click.pass_context was used
+    if not args:
+        return None
+
+    ctx = args[0]
+
+    # Check if it's a Click context with our ErkContext in obj
+    if not hasattr(ctx, "obj"):
+        return None
+
+    obj = ctx.obj
+    if obj is None:
+        return None
+
+    if not hasattr(obj, "repo"):
+        return None
+
+    repo = obj.repo
+    if isinstance(repo, NoRepoSentinel):
+        return None
+
+    if not hasattr(repo, "root"):
+        return None
+
+    return repo.root
+
+
+def _function_accepts_hook_ctx(func: Callable) -> bool:
+    """Check if a function signature accepts hook_ctx parameter.
+
+    Args:
+        func: The function to inspect.
+
+    Returns:
+        True if function has a hook_ctx parameter.
+    """
+    sig = inspect.signature(func)
+    return "hook_ctx" in sig.parameters
+
+
+def logged_hook(func: F) -> F:
+    """Decorator that logs hook execution for health monitoring.
+
+    This decorator MUST be applied BEFORE @project_scoped so that logging
+    happens even when the hook exits early due to project scope.
+
+    The decorator:
+    1. Reads ERK_HOOK_ID from environment
+    2. Captures stdin (contains session_id in JSON from Claude Code)
+    3. Redirects stdout/stderr to capture output
+    4. Records timing and exit status
+    5. Writes log on exit (success or failure)
+    6. Re-emits captured output to real stdout/stderr
+    7. Injects HookContext if function signature accepts hook_ctx parameter
+
+    Environment variables:
+        ERK_HOOK_ID: Hook identifier (e.g., "session-id-injector-hook")
+
+    Usage:
+        @click.command()
+        @click.pass_context
+        @logged_hook
+        def my_hook(ctx: click.Context, *, hook_ctx: HookContext) -> None:
+            if not hook_ctx.is_erk_project:
+                return
+            click.echo(f"Session: {hook_ctx.session_id}")
+    """
+    # Check once at decoration time whether function accepts hook_ctx
+    accepts_hook_ctx = _function_accepts_hook_ctx(func)
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Read environment variables
+        hook_id = os.environ.get("ERK_HOOK_ID", "unknown")
+
+        # Capture stdin before hook reads it
+        stdin_data = _read_stdin_once()
+        session_id: str | None = None
+        try:
+            session_id = _extract_session_id(stdin_data)
+        except (json.JSONDecodeError, KeyError, TypeError):
+            pass
+
+        # Replace stdin with a StringIO containing the captured data
+        # so the hook can still read it
+        original_stdin = sys.stdin
+        sys.stdin = io.StringIO(stdin_data)
+
+        # Build HookContext if function accepts it and we can extract repo_root
+        if accepts_hook_ctx:
+            repo_root = _extract_repo_root_from_click_context(args)
+            if repo_root is not None:
+                hook_ctx = _build_hook_context(session_id, repo_root)
+                kwargs["hook_ctx"] = hook_ctx
+
+        # Capture stdout/stderr
+        stdout_buffer = io.StringIO()
+        stderr_buffer = io.StringIO()
+
+        # Record start time
+        started_at = datetime.now(UTC)
+        exit_code = 0
+        exit_status = HookExitStatus.SUCCESS
+        error_message: str | None = None
+
+        try:
+            with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+                func(*args, **kwargs)
+        except SystemExit as e:
+            # Click raises SystemExit on exit
+            exit_code = e.code if isinstance(e.code, int) else 1
+            exit_status = classify_exit_code(exit_code)
+        except Exception as e:
+            # Uncaught exception
+            exit_code = 1
+            exit_status = HookExitStatus.EXCEPTION
+            error_message = f"{type(e).__name__}: {e}"
+            # Write traceback to stderr buffer
+            stderr_buffer.write(traceback.format_exc())
+        finally:
+            # Restore stdin
+            sys.stdin = original_stdin
+
+            # Record end time
+            ended_at = datetime.now(UTC)
+            duration_ms = int((ended_at - started_at).total_seconds() * 1000)
+
+            # Get captured output
+            stdout_content = stdout_buffer.getvalue()
+            stderr_content = stderr_buffer.getvalue()
+
+            # Create log entry
+            log = HookExecutionLog(
+                kit_id="erk",  # All hooks are now in erk
+                hook_id=hook_id,
+                session_id=session_id,
+                started_at=started_at.isoformat(),
+                ended_at=ended_at.isoformat(),
+                duration_ms=duration_ms,
+                exit_code=exit_code,
+                exit_status=exit_status,
+                stdout=truncate_string(stdout_content, MAX_STDOUT_BYTES),
+                stderr=truncate_string(stderr_content, MAX_STDERR_BYTES),
+                stdin_context=truncate_string(stdin_data, MAX_STDIN_BYTES),
+                error_message=error_message,
+            )
+
+            # Write log (only if we have a session_id)
+            write_hook_log(log)
+
+            # Re-emit captured output
+            sys.stdout.write(stdout_content)
+            sys.stderr.write(stderr_content)
+
+        # Re-raise SystemExit if hook exited with non-zero
+        if exit_code != 0:
+            raise SystemExit(exit_code)
+
+    # Cast wrapper to F - functools.wraps preserves the signature semantics
+    return cast(F, wrapper)
+
+
+def hook_command(name: str | None = None) -> Callable[[Callable[..., None]], click.Command]:
+    """Combined decorator for hook commands.
+
+    This decorator combines @click.command, @click.pass_context, and @logged_hook
+    into a single decorator, reducing boilerplate in hook implementations.
+
+    Args:
+        name: Optional command name. If not provided, Click will infer from function name.
+
+    Usage:
+        @hook_command(name="my-hook")
+        def my_hook(ctx: click.Context, *, hook_ctx: HookContext) -> None:
+            if not hook_ctx.is_erk_project:
+                return
+            click.echo(f"Session: {hook_ctx.session_id}")
+
+    Equivalent to:
+        @click.command(name="my-hook")
+        @click.pass_context
+        @logged_hook
+        def my_hook(ctx: click.Context, *, hook_ctx: HookContext) -> None:
+            ...
+    """
+    # Inline import to avoid circular dependency at module load time
+    import click
+
+    def decorator(func: Callable[..., None]) -> click.Command:
+        # Apply decorators in reverse order (innermost first)
+        # 1. @logged_hook (innermost - applied first)
+        wrapped = logged_hook(func)
+        # 2. @click.pass_context
+        wrapped = click.pass_context(wrapped)
+        # 3. @click.command (outermost - applied last)
+        if name is not None:
+            return click.command(name=name)(wrapped)
+        return click.command()(wrapped)
+
+    return decorator

erk/status/__init__.py

@@ -0,0 +1,8 @@
+"""Status command implementation.
+
+Import from submodules:
+- orchestrator: StatusOrchestrator
+- models.status_data: StatusData, GitStatus, etc.
+- collectors: StatusCollector, GitStatusCollector, etc.
+- renderers.simple: SimpleRenderer
+"""

erk/status/collectors/__init__.py

@@ -0,0 +1,9 @@
+"""Status information collectors.
+
+Import from submodules:
+- base: StatusCollector
+- git: GitStatusCollector
+- github: GitHubPRCollector
+- graphite: GraphiteStackCollector
+- impl: PlanFileCollector
+"""

erk/status/collectors/base.py

@@ -0,0 +1,52 @@
+"""Base class for status information collectors."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from erk.core.context import ErkContext
+
+
+class StatusCollector(ABC):
+    """Base class for status information collectors.
+
+    Each collector is responsible for gathering a specific type of status
+    information (git, PR, dependencies, etc.) and returning it in a structured
+    format.
+
+    Collectors should handle their own errors gracefully and return None
+    if information cannot be collected.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Name identifier for this collector."""
+        ...
+
+    @abstractmethod
+    def is_available(self, ctx: ErkContext, worktree_path: Path) -> bool:
+        """Check if this collector can run in the given worktree.
+
+        Args:
+            ctx: Erk context with operations
+            worktree_path: Path to the worktree
+
+        Returns:
+            True if collector can gather information, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    def collect(self, ctx: ErkContext, worktree_path: Path, repo_root: Path) -> Any:
+        """Collect status information from worktree.
+
+        Args:
+            ctx: Erk context with operations
+            worktree_path: Path to the worktree
+            repo_root: Path to repository root
+
+        Returns:
+            Collected status data or None if collection fails
+        """
+        ...