erk 0.4.5__py3-none-any.whl

erk/cli/commands/exec/scripts/ci_update_pr_body.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""Update PR body with AI-generated summary and footer.
+
+This command generates a PR summary from the diff using Claude, then updates
+the PR body with the summary, optional workflow link, and standardized footer.
+
+This combines generate-pr-summary + footer construction + gh pr edit in one step,
+replacing ~30 lines of bash in GitHub Actions workflows.
+
+Usage:
+    erk exec ci-update-pr-body \\
+        --issue-number 123 \\
+        [--run-id 456789] \\
+        [--run-url https://github.com/owner/repo/actions/runs/456789]
+
+Output:
+    JSON object with success status
+
+Exit Codes:
+    0: Success (PR body updated)
+    1: Error (no PR for branch, empty diff, Claude failure, or GitHub API failed)
+
+Examples:
+    $ erk exec ci-update-pr-body --issue-number 123
+    {
+      "success": true,
+      "pr_number": 789
+    }
+
+    $ erk exec ci-update-pr-body \\
+        --issue-number 123 \\
+        --run-id 456789 \\
+        --run-url https://github.com/owner/repo/actions/runs/456789
+    {
+      "success": true,
+      "pr_number": 789
+    }
+"""
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Literal
+
+import click
+
+from erk.cli.config import load_config
+from erk_shared.context.helpers import (
+    require_git,
+    require_github,
+    require_prompt_executor,
+    require_repo_root,
+)
+from erk_shared.gateway.gt.prompts import COMMIT_MESSAGE_SYSTEM_PROMPT, truncate_diff
+from erk_shared.git.abc import Git
+from erk_shared.github.abc import GitHub
+from erk_shared.github.pr_footer import build_pr_body_footer, build_remote_execution_note
+from erk_shared.github.types import PRNotFound
+from erk_shared.prompt_executor import PromptExecutor
+
+
+@dataclass(frozen=True)
+class UpdateSuccess:
+    """Success result when PR body is updated."""
+
+    success: bool
+    pr_number: int
+
+
+@dataclass(frozen=True)
+class UpdateError:
+    """Error result when PR body update fails."""
+
+    success: bool
+    error: Literal[
+        "pr-not-found",
+        "empty-diff",
+        "diff-fetch-failed",
+        "claude-execution-failed",
+        "claude-empty-output",
+        "github-api-failed",
+    ]
+    message: str
+    stderr: str | None
+
+
+def _build_prompt(diff_content: str, current_branch: str, parent_branch: str) -> str:
+    """Build prompt for PR summary generation.
+
+    Note: We deliberately do NOT include commit messages here. The commit messages
+    may contain info about .worker-impl/ deletions that don't appear in the final PR diff.
+    """
+    context_section = f"""## Context
+
+- Current branch: {current_branch}
+- Parent branch: {parent_branch}"""
+
+    return f"""{COMMIT_MESSAGE_SYSTEM_PROMPT}
+
+{context_section}
+
+## Diff
+
+```diff
+{diff_content}
+```
+
+Generate a commit message for this diff:"""
+
+
+def _build_pr_body(
+    summary: str,
+    pr_number: int,
+    issue_number: int,
+    run_id: str | None,
+    run_url: str | None,
+    plans_repo: str | None,
+) -> str:
+    """Build the full PR body with summary, optional workflow link, and footer.
+
+    Args:
+        summary: AI-generated PR summary
+        pr_number: PR number for checkout instructions
+        issue_number: Issue number to close on merge
+        run_id: Optional workflow run ID
+        run_url: Optional workflow run URL
+        plans_repo: Target repo in "owner/repo" format for cross-repo plans
+
+    Returns:
+        Formatted PR body markdown
+    """
+    parts = [f"## Summary\n\n{summary}"]
+
+    # Add workflow link if provided
+    if run_id is not None and run_url is not None:
+        parts.append(build_remote_execution_note(run_id, run_url))
+
+    # Add footer with checkout instructions
+    parts.append(
+        build_pr_body_footer(pr_number=pr_number, issue_number=issue_number, plans_repo=plans_repo)
+    )
+
+    return "\n".join(parts)
+
+
+def _update_pr_body_impl(
+    git: Git,
+    github: GitHub,
+    executor: PromptExecutor,
+    repo_root: Path,
+    issue_number: int,
+    run_id: str | None,
+    run_url: str | None,
+    plans_repo: str | None,
+) -> UpdateSuccess | UpdateError:
+    """Implementation of PR body update.
+
+    Args:
+        git: Git interface
+        github: GitHub interface
+        executor: PromptExecutor for Claude
+        repo_root: Repository root path
+        issue_number: Issue number to close on merge
+        run_id: Optional workflow run ID
+        run_url: Optional workflow run URL
+        plans_repo: Target repo in "owner/repo" format for cross-repo plans
+
+    Returns:
+        UpdateSuccess on success, UpdateError on failure
+    """
+    # Get current branch
+    current_branch = git.get_current_branch(repo_root)
+    if current_branch is None:
+        return UpdateError(
+            success=False,
+            error="pr-not-found",
+            message="Could not determine current branch",
+            stderr=None,
+        )
+
+    # Get PR for branch
+    pr_result = github.get_pr_for_branch(repo_root, current_branch)
+    if isinstance(pr_result, PRNotFound):
+        return UpdateError(
+            success=False,
+            error="pr-not-found",
+            message=f"No PR found for branch {current_branch}",
+            stderr=None,
+        )
+
+    pr_number = pr_result.number
+
+    # Get PR diff
+    try:
+        pr_diff = github.get_pr_diff(repo_root, pr_number)
+    except RuntimeError as e:
+        return UpdateError(
+            success=False,
+            error="diff-fetch-failed",
+            message=f"Failed to get PR diff: {e}",
+            stderr=None,
+        )
+
+    if not pr_diff.strip():
+        return UpdateError(
+            success=False,
+            error="empty-diff",
+            message="PR diff is empty",
+            stderr=None,
+        )
+
+    # Truncate diff if needed
+    diff_content, _was_truncated = truncate_diff(pr_diff)
+
+    # Get parent branch for context
+    parent_branch = git.detect_trunk_branch(repo_root)
+
+    # Generate summary using Claude
+    prompt = _build_prompt(diff_content, current_branch, parent_branch)
+    result = executor.execute_prompt(prompt, model="haiku", cwd=repo_root)
+
+    # Separate failure modes for better diagnostics
+    if not result.success:
+        stderr_preview = result.error[:500] if result.error else None
+        return UpdateError(
+            success=False,
+            error="claude-execution-failed",
+            message="Claude CLI returned non-zero exit code",
+            stderr=stderr_preview,
+        )
+
+    # Check for empty output (success=True but no content)
+    if not result.output or not result.output.strip():
+        stderr_preview = result.error[:500] if result.error else None
+        return UpdateError(
+            success=False,
+            error="claude-empty-output",
+            message="Claude returned empty output (check API quota, rate limits, or token)",
+            stderr=stderr_preview,
+        )
+
+    # Build full PR body
+    pr_body = _build_pr_body(result.output, pr_number, issue_number, run_id, run_url, plans_repo)
+
+    # Update PR body
+    try:
+        github.update_pr_body(repo_root, pr_number, pr_body)
+    except RuntimeError as e:
+        return UpdateError(
+            success=False,
+            error="github-api-failed",
+            message=f"Failed to update PR: {e}",
+            stderr=None,
+        )
+
+    return UpdateSuccess(success=True, pr_number=pr_number)
+
+
+@click.command(name="ci-update-pr-body")
+@click.option("--issue-number", type=int, required=True, help="Issue number to close on merge")
+@click.option("--run-id", type=str, default=None, help="Optional workflow run ID")
+@click.option("--run-url", type=str, default=None, help="Optional workflow run URL")
+@click.pass_context
+def ci_update_pr_body(
+    ctx: click.Context,
+    issue_number: int,
+    run_id: str | None,
+    run_url: str | None,
+) -> None:
+    """Update PR body with AI-generated summary and footer.
+
+    Generates a summary from the PR diff using Claude, then updates the PR body
+    with the summary, optional workflow link, and standardized footer with
+    checkout instructions.
+    """
+    git = require_git(ctx)
+    github = require_github(ctx)
+    executor = require_prompt_executor(ctx)
+    repo_root = require_repo_root(ctx)
+
+    # Load config to get plans_repo
+    config = load_config(repo_root)
+    plans_repo = config.plans_repo
+
+    result = _update_pr_body_impl(
+        git, github, executor, repo_root, issue_number, run_id, run_url, plans_repo
+    )
+
+    # Output JSON result
+    click.echo(json.dumps(asdict(result), indent=2))
+
+    # Exit with error code if update failed
+    if isinstance(result, UpdateError):
+        raise SystemExit(1)

erk/cli/commands/exec/scripts/create_extraction_branch.py

@@ -0,0 +1,138 @@
+"""Create and push a branch for extraction documentation.
+
+Usage:
+    erk exec create-extraction-branch \
+        --issue-number 123 \
+        --trunk-branch master
+
+This command:
+1. Checks out the trunk branch
+2. Pulls latest changes
+3. Creates a new branch named extraction-docs-{issue_number}
+4. Pushes the branch with upstream tracking
+
+Output:
+    JSON with success status and branch_name
+"""
+
+import json
+from pathlib import Path
+
+import click
+
+from erk_shared.context.helpers import require_git, require_repo_root
+
+
+@click.command(name="create-extraction-branch")
+@click.option(
+    "--issue-number",
+    type=int,
+    required=True,
+    help="GitHub issue number",
+)
+@click.option(
+    "--trunk-branch",
+    type=str,
+    required=True,
+    help="Name of trunk branch (main/master)",
+)
+@click.pass_context
+def create_extraction_branch(
+    ctx: click.Context,
+    issue_number: int,
+    trunk_branch: str,
+) -> None:
+    """Create and push a branch for extraction documentation.
+
+    Creates a new branch from the trunk branch for implementing
+    documentation extraction from a GitHub issue.
+    """
+    git = require_git(ctx)
+    repo_root = require_repo_root(ctx)
+    cwd = Path.cwd()
+
+    branch_name = f"extraction-docs-P{issue_number}"
+
+    # Check if branch already exists locally
+    local_branches = git.list_local_branches(repo_root)
+    if branch_name in local_branches:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"Branch {branch_name} already exists locally",
+                }
+            )
+        )
+        raise SystemExit(1)
+
+    # Checkout trunk branch
+    try:
+        git.checkout_branch(cwd, trunk_branch)
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"Failed to checkout {trunk_branch}: {e}",
+                }
+            )
+        )
+        raise SystemExit(1) from e
+
+    # Pull latest from trunk
+    try:
+        git.pull_branch(repo_root, "origin", trunk_branch, ff_only=True)
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"Failed to pull {trunk_branch}: {e}",
+                }
+            )
+        )
+        raise SystemExit(1) from e
+
+    # Create and checkout new branch
+    try:
+        git.create_branch(cwd, branch_name, trunk_branch)
+        git.checkout_branch(cwd, branch_name)
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"Failed to create branch {branch_name}: {e}",
+                }
+            )
+        )
+        raise SystemExit(1) from e
+
+    # Push with upstream tracking
+    try:
+        git.push_to_remote(cwd, "origin", branch_name, set_upstream=True)
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"Failed to push branch {branch_name}: {e}",
+                }
+            )
+        )
+        raise SystemExit(1) from e
+
+    click.echo(
+        json.dumps(
+            {
+                "success": True,
+                "branch_name": branch_name,
+                "issue_number": issue_number,
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    create_extraction_branch()

erk/cli/commands/exec/scripts/create_extraction_plan.py

@@ -0,0 +1,242 @@
+"""Create extraction plan issue from file or content with proper metadata.
+
+Usage (new - preferred):
+    erk exec create-extraction-plan \
+        --plan-content="# Plan Title..." \
+        --session-id="abc123" \
+        --extraction-session-ids="abc123,def456"
+
+Usage (legacy - file path):
+    erk exec create-extraction-plan \
+        --plan-file=".erk/scratch/<session-id>/extraction-plan.md" \
+        --source-plan-issues="123,456" \
+        --extraction-session-ids="abc123,def456"
+
+The --plan-content option is preferred because it:
+1. Automatically writes to .erk/scratch/<session-id>/extraction-plan.md
+2. Prevents agents from accidentally using /tmp/
+
+This command:
+1. Creates GitHub issue with erk-plan + erk-extraction labels
+2. Sets plan_type: extraction in plan-header metadata
+3. Includes source_plan_issues and extraction_session_ids for tracking
+
+Output:
+    JSON with success status, issue_number, and issue_url
+"""
+
+import json
+from pathlib import Path
+
+import click
+
+from erk_shared.context.helpers import (
+    require_cwd,
+    require_repo_root,
+)
+from erk_shared.context.helpers import (
+    require_issues as require_github_issues,
+)
+from erk_shared.github.plan_issues import create_plan_issue
+from erk_shared.scratch.markers import PENDING_EXTRACTION_MARKER, delete_marker
+from erk_shared.scratch.scratch import write_scratch_file
+
+
+@click.command(name="create-extraction-plan")
+@click.option(
+    "--plan-file",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Path to plan file to create issue from (use --plan-content instead)",
+)
+@click.option(
+    "--plan-content",
+    type=str,
+    default=None,
+    help="Plan content to create issue from (preferred over --plan-file)",
+)
+@click.option(
+    "--session-id",
+    type=str,
+    default=None,
+    help="Session ID for scratch directory (required with --plan-content)",
+)
+@click.option(
+    "--source-plan-issues",
+    type=str,
+    default="",
+    help="Comma-separated list of source plan issue numbers (e.g., '123,456')",
+)
+@click.option(
+    "--extraction-session-ids",
+    type=str,
+    default="",
+    help="Comma-separated list of session IDs that were analyzed (e.g., 'abc123,def456')",
+)
+@click.pass_context
+def create_extraction_plan(
+    ctx: click.Context,
+    plan_file: Path | None,
+    plan_content: str | None,
+    session_id: str | None,
+    source_plan_issues: str,
+    extraction_session_ids: str,
+) -> None:
+    """Create extraction plan issue from content or file with proper metadata.
+
+    Reads plan content from --plan-content or --plan-file and creates a GitHub issue with:
+    - erk-plan and erk-extraction labels
+    - plan_type: extraction in metadata
+    - Source tracking information
+
+    When using --plan-content, the content is automatically written to
+    .erk/scratch/<session-id>/extraction-plan.md
+    """
+    # Get required context
+    github = require_github_issues(ctx)
+    repo_root = require_repo_root(ctx)
+    cwd = require_cwd(ctx)
+
+    # Validate options: must provide either --plan-content or --plan-file
+    if plan_content is None and plan_file is None:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": "Must provide either --plan-content or --plan-file",
+                }
+            )
+        )
+        raise SystemExit(1)
+
+    if plan_content is not None and plan_file is not None:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": "Cannot provide both --plan-content and --plan-file",
+                }
+            )
+        )
+        raise SystemExit(1)
+
+    # Handle --plan-content: requires --session-id, writes to scratch
+    if plan_content is not None:
+        if session_id is None:
+            click.echo(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": "--session-id is required when using --plan-content",
+                    }
+                )
+            )
+            raise SystemExit(1)
+
+        # Write to scratch directory
+        scratch_path = write_scratch_file(
+            plan_content,
+            session_id=session_id,
+            suffix=".md",
+            prefix="extraction-plan-",
+            repo_root=repo_root,
+        )
+        content = plan_content.strip()
+    else:
+        # Handle --plan-file: read content from file
+        # plan_file is guaranteed to be not None here
+        assert plan_file is not None  # for type checker
+        content = plan_file.read_text(encoding="utf-8").strip()
+        scratch_path = None
+
+    if not content:
+        click.echo(json.dumps({"success": False, "error": "Empty plan content"}))
+        raise SystemExit(1)
+
+    # Parse source plan issues
+    source_issues: list[int] = []
+    if source_plan_issues:
+        for part in source_plan_issues.split(","):
+            part = part.strip()
+            if part:
+                try:
+                    source_issues.append(int(part))
+                except ValueError as e:
+                    click.echo(
+                        json.dumps(
+                            {
+                                "success": False,
+                                "error": f"Invalid issue number: {part}",
+                            }
+                        )
+                    )
+                    raise SystemExit(1) from e
+
+    # Parse session IDs
+    session_ids: list[str] = []
+    if extraction_session_ids:
+        for part in extraction_session_ids.split(","):
+            part = part.strip()
+            if part:
+                session_ids.append(part)
+
+    # Validate: at least one session ID must be provided
+    if not session_ids:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": "At least one extraction_session_id is required",
+                }
+            )
+        )
+        raise SystemExit(1)
+
+    # Use consolidated create_plan_issue for the entire workflow
+    result = create_plan_issue(
+        github_issues=github,
+        repo_root=repo_root,
+        plan_content=content,
+        title=None,
+        plan_type="extraction",
+        extra_labels=None,
+        title_suffix=None,
+        source_plan_issues=source_issues if source_issues else None,
+        extraction_session_ids=session_ids,
+        source_repo=None,
+        objective_issue=None,
+    )
+
+    if not result.success:
+        if result.issue_number is not None:
+            # Partial success - issue created but comment failed
+            click.echo(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": result.error,
+                        "issue_number": result.issue_number,
+                        "issue_url": result.issue_url,
+                    }
+                )
+            )
+        else:
+            click.echo(json.dumps({"success": False, "error": result.error}))
+        raise SystemExit(1)
+
+    # Delete pending extraction marker since extraction is complete
+    delete_marker(cwd, PENDING_EXTRACTION_MARKER)
+
+    # Output success
+    output: dict[str, object] = {
+        "success": True,
+        "issue_number": result.issue_number,
+        "issue_url": result.issue_url,
+        "title": result.title,
+        "plan_type": "extraction",
+        "source_plan_issues": source_issues,
+        "extraction_session_ids": session_ids,
+    }
+    if scratch_path is not None:
+        output["scratch_path"] = str(scratch_path)
+    click.echo(json.dumps(output))