erk 0.4.5__py3-none-any.whl

erk/cli/commands/exec/group.py

@@ -0,0 +1,164 @@
+"""Static exec group for erk scripts.
+
+This module provides the `erk exec` command group with all scripts
+statically registered.
+"""
+
+import click
+
+# Import and register all scripts
+from erk.cli.commands.exec.scripts.add_reaction_to_comment import (
+    add_reaction_to_comment,
+)
+from erk.cli.commands.exec.scripts.add_remote_execution_note import (
+    add_remote_execution_note,
+)
+from erk.cli.commands.exec.scripts.check_impl import check_impl
+from erk.cli.commands.exec.scripts.ci_update_pr_body import ci_update_pr_body
+from erk.cli.commands.exec.scripts.create_extraction_branch import (
+    create_extraction_branch,
+)
+from erk.cli.commands.exec.scripts.create_extraction_plan import (
+    create_extraction_plan,
+)
+from erk.cli.commands.exec.scripts.create_issue_from_session import (
+    create_issue_from_session,
+)
+from erk.cli.commands.exec.scripts.create_plan_from_context import (
+    create_plan_from_context,
+)
+from erk.cli.commands.exec.scripts.create_worker_impl_from_issue import (
+    create_worker_impl_from_issue,
+)
+from erk.cli.commands.exec.scripts.detect_trunk_branch import detect_trunk_branch
+from erk.cli.commands.exec.scripts.exit_plan_mode_hook import exit_plan_mode_hook
+from erk.cli.commands.exec.scripts.extract_latest_plan import extract_latest_plan
+from erk.cli.commands.exec.scripts.extract_session_from_issue import (
+    extract_session_from_issue,
+)
+from erk.cli.commands.exec.scripts.find_project_dir import find_project_dir
+from erk.cli.commands.exec.scripts.generate_pr_summary import generate_pr_summary
+from erk.cli.commands.exec.scripts.get_closing_text import get_closing_text
+from erk.cli.commands.exec.scripts.get_embedded_prompt import get_embedded_prompt
+from erk.cli.commands.exec.scripts.get_plan_metadata import get_plan_metadata
+from erk.cli.commands.exec.scripts.get_pr_body_footer import get_pr_body_footer
+from erk.cli.commands.exec.scripts.get_pr_discussion_comments import (
+    get_pr_discussion_comments,
+)
+from erk.cli.commands.exec.scripts.get_pr_review_comments import (
+    get_pr_review_comments,
+)
+from erk.cli.commands.exec.scripts.impl_init import impl_init
+from erk.cli.commands.exec.scripts.impl_signal import impl_signal
+from erk.cli.commands.exec.scripts.impl_verify import impl_verify
+from erk.cli.commands.exec.scripts.issue_title_to_filename import (
+    issue_title_to_filename,
+)
+from erk.cli.commands.exec.scripts.list_sessions import list_sessions
+from erk.cli.commands.exec.scripts.mark_impl_ended import mark_impl_ended
+from erk.cli.commands.exec.scripts.mark_impl_started import mark_impl_started
+from erk.cli.commands.exec.scripts.marker import marker
+from erk.cli.commands.exec.scripts.objective_save_to_issue import (
+    objective_save_to_issue,
+)
+from erk.cli.commands.exec.scripts.plan_save_to_issue import plan_save_to_issue
+from erk.cli.commands.exec.scripts.plan_update_issue import plan_update_issue
+from erk.cli.commands.exec.scripts.post_extraction_comment import (
+    post_extraction_comment,
+)
+from erk.cli.commands.exec.scripts.post_or_update_pr_summary import (
+    post_or_update_pr_summary,
+)
+from erk.cli.commands.exec.scripts.post_pr_inline_comment import (
+    post_pr_inline_comment,
+)
+from erk.cli.commands.exec.scripts.post_workflow_started_comment import (
+    post_workflow_started_comment,
+)
+from erk.cli.commands.exec.scripts.preprocess_session import preprocess_session
+from erk.cli.commands.exec.scripts.quick_submit import quick_submit
+from erk.cli.commands.exec.scripts.rebase_with_conflict_resolution import (
+    rebase_with_conflict_resolution,
+)
+from erk.cli.commands.exec.scripts.reply_to_discussion_comment import (
+    reply_to_discussion_comment,
+)
+from erk.cli.commands.exec.scripts.resolve_review_thread import (
+    resolve_review_thread,
+)
+from erk.cli.commands.exec.scripts.session_id_injector_hook import (
+    session_id_injector_hook,
+)
+from erk.cli.commands.exec.scripts.setup_impl_from_issue import (
+    setup_impl_from_issue,
+)
+from erk.cli.commands.exec.scripts.slot_objective import slot_objective
+from erk.cli.commands.exec.scripts.tripwires_reminder_hook import (
+    tripwires_reminder_hook,
+)
+from erk.cli.commands.exec.scripts.update_dispatch_info import update_dispatch_info
+from erk.cli.commands.exec.scripts.user_prompt_hook import user_prompt_hook
+from erk.cli.commands.exec.scripts.validate_plan_content import (
+    validate_plan_content,
+)
+from erk.cli.commands.exec.scripts.wrap_plan_in_metadata_block import (
+    wrap_plan_in_metadata_block,
+)
+
+
+# Create the exec group (hidden from top-level help)
+@click.group(name="exec", hidden=True)
+def exec_group() -> None:
+    """Execute erk workflow scripts."""
+
+
+# Register all commands
+exec_group.add_command(add_reaction_to_comment, name="add-reaction-to-comment")
+exec_group.add_command(add_remote_execution_note, name="add-remote-execution-note")
+exec_group.add_command(check_impl, name="check-impl")
+exec_group.add_command(create_extraction_branch, name="create-extraction-branch")
+exec_group.add_command(create_extraction_plan, name="create-extraction-plan")
+exec_group.add_command(create_issue_from_session, name="create-issue-from-session")
+exec_group.add_command(create_plan_from_context, name="create-plan-from-context")
+exec_group.add_command(create_worker_impl_from_issue, name="create-worker-impl-from-issue")
+exec_group.add_command(detect_trunk_branch, name="detect-trunk-branch")
+exec_group.add_command(exit_plan_mode_hook, name="exit-plan-mode-hook")
+exec_group.add_command(extract_latest_plan, name="extract-latest-plan")
+exec_group.add_command(extract_session_from_issue, name="extract-session-from-issue")
+exec_group.add_command(find_project_dir, name="find-project-dir")
+exec_group.add_command(generate_pr_summary, name="generate-pr-summary")
+exec_group.add_command(get_closing_text, name="get-closing-text")
+exec_group.add_command(get_plan_metadata, name="get-plan-metadata")
+exec_group.add_command(get_embedded_prompt, name="get-embedded-prompt")
+exec_group.add_command(get_pr_body_footer, name="get-pr-body-footer")
+exec_group.add_command(get_pr_discussion_comments, name="get-pr-discussion-comments")
+exec_group.add_command(get_pr_review_comments, name="get-pr-review-comments")
+exec_group.add_command(impl_init, name="impl-init")
+exec_group.add_command(impl_signal, name="impl-signal")
+exec_group.add_command(impl_verify, name="impl-verify")
+exec_group.add_command(issue_title_to_filename, name="issue-title-to-filename")
+exec_group.add_command(list_sessions, name="list-sessions")
+exec_group.add_command(mark_impl_ended, name="mark-impl-ended")
+exec_group.add_command(mark_impl_started, name="mark-impl-started")
+exec_group.add_command(marker, name="marker")
+exec_group.add_command(objective_save_to_issue, name="objective-save-to-issue")
+exec_group.add_command(plan_save_to_issue, name="plan-save-to-issue")
+exec_group.add_command(plan_update_issue, name="plan-update-issue")
+exec_group.add_command(post_extraction_comment, name="post-extraction-comment")
+exec_group.add_command(post_or_update_pr_summary, name="post-or-update-pr-summary")
+exec_group.add_command(post_pr_inline_comment, name="post-pr-inline-comment")
+exec_group.add_command(post_workflow_started_comment, name="post-workflow-started-comment")
+exec_group.add_command(preprocess_session, name="preprocess-session")
+exec_group.add_command(quick_submit, name="quick-submit")
+exec_group.add_command(rebase_with_conflict_resolution, name="rebase-with-conflict-resolution")
+exec_group.add_command(resolve_review_thread, name="resolve-review-thread")
+exec_group.add_command(reply_to_discussion_comment, name="reply-to-discussion-comment")
+exec_group.add_command(session_id_injector_hook, name="session-id-injector-hook")
+exec_group.add_command(setup_impl_from_issue, name="setup-impl-from-issue")
+exec_group.add_command(slot_objective, name="slot-objective")
+exec_group.add_command(tripwires_reminder_hook, name="tripwires-reminder-hook")
+exec_group.add_command(update_dispatch_info, name="update-dispatch-info")
+exec_group.add_command(ci_update_pr_body)
+exec_group.add_command(user_prompt_hook, name="user-prompt-hook")
+exec_group.add_command(validate_plan_content, name="validate-plan-content")
+exec_group.add_command(wrap_plan_in_metadata_block, name="wrap-plan-in-metadata-block")

erk/cli/commands/exec/scripts/AGENTS.md

@@ -0,0 +1,79 @@
+# Exec Script Standards
+
+## Required Pattern: Click Context Dependency Injection
+
+All exec CLI commands in this folder MUST use Click's context system for dependency injection.
+
+### Required Pattern
+
+```python
+import click
+from erk_shared.context.helpers import require_cwd
+
+@click.command(name="my-command")
+@click.pass_context
+def my_command(ctx: click.Context) -> None:
+    """Command description."""
+    cwd = require_cwd(ctx)
+    # Use cwd instead of Path.cwd()
+```
+
+### Why This Pattern?
+
+1. **Testability**: Tests inject dependencies via `obj=ErkContext.for_test(cwd=tmp_path)`
+2. **No monkeypatching**: Tests don't need `monkeypatch.chdir()` or filesystem manipulation
+3. **Explicit dependencies**: All dependencies visible in function signature via context
+4. **Consistency**: All commands follow the same pattern
+
+### Available Helper Functions
+
+From `erk_shared.context.helpers`:
+
+| Helper                   | Returns  | Usage                     |
+| ------------------------ | -------- | ------------------------- |
+| `require_cwd(ctx)`       | `Path`   | Current working directory |
+| `require_repo_root(ctx)` | `Path`   | Repository root path      |
+| `require_git(ctx)`       | `Git`    | Git operations            |
+| `require_github(ctx)`    | `GitHub` | GitHub operations         |
+
+### Anti-Patterns
+
+```python
+# WRONG: bypasses dependency injection
+def my_command() -> None:
+    progress_file = Path.cwd() / ".impl" / "progress.md"
+
+# CORRECT: uses injected path
+@click.pass_context
+def my_command(ctx: click.Context) -> None:
+    cwd = require_cwd(ctx)
+    progress_file = cwd / ".impl" / "progress.md"
+```
+
+## Testing Requirements
+
+Every exec CLI command MUST have tests that use context injection:
+
+```python
+from click.testing import CliRunner
+from erk_shared.context import ErkContext
+
+def test_my_command(tmp_path: Path) -> None:
+    """Test using context injection."""
+    runner = CliRunner()
+    result = runner.invoke(
+        my_command,
+        ["--json"],
+        obj=ErkContext.for_test(cwd=tmp_path),
+    )
+    assert result.exit_code == 0
+```
+
+### Test Location
+
+- Unit tests: `tests/unit/cli/commands/exec/scripts/`
+
+## See Also
+
+- [Kit CLI Dependency Injection Patterns](/docs/learned/kits/dependency-injection.md)
+- [fake-driven-testing skill](/.claude/skills/fake-driven-testing/)

erk/cli/commands/exec/scripts/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

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

@@ -0,0 +1,5 @@
+"""Erk exec scripts module.
+
+This module contains all the CLI scripts available via `erk exec <command>`.
+Each script is a Click command that can be invoked directly.
+"""

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

@@ -0,0 +1,69 @@
+"""Add a reaction to a PR/issue comment to mark it as addressed.
+
+This exec command adds a reaction (typically +1) to a PR discussion comment
+to indicate the comment has been addressed.
+
+Usage:
+    erk exec add-reaction-to-comment --comment-id 12345
+    erk exec add-reaction-to-comment --comment-id 12345 --reaction "+1"
+    erk exec add-reaction-to-comment --comment-id 12345 --reaction "eyes"
+
+Output:
+    JSON with success status
+
+Exit Codes:
+    0: Always (even on error, to support || true pattern)
+    1: Context not initialized
+
+Examples:
+    $ erk exec add-reaction-to-comment --comment-id 12345
+    {"success": true, "comment_id": 12345, "reaction": "+1"}
+
+    $ erk exec add-reaction-to-comment --comment-id 12345 --reaction "rocket"
+    {"success": true, "comment_id": 12345, "reaction": "rocket"}
+"""
+
+import json
+
+import click
+
+from erk.cli.script_output import exit_with_error
+from erk_shared.context.helpers import require_issues as require_github_issues
+from erk_shared.context.helpers import require_repo_root
+from erk_shared.github.checks import GitHubChecks
+from erk_shared.non_ideal_state import GitHubAPIFailed
+
+
+@click.command(name="add-reaction-to-comment")
+@click.option("--comment-id", required=True, type=int, help="Numeric comment ID")
+@click.option(
+    "--reaction",
+    default="+1",
+    help="Reaction type: +1, -1, laugh, confused, heart, hooray, rocket, eyes",
+)
+@click.pass_context
+def add_reaction_to_comment(ctx: click.Context, comment_id: int, reaction: str) -> None:
+    """Add a reaction to a PR/issue comment.
+
+    Takes a numeric comment ID (from get-pr-discussion-comments output) and
+    adds a reaction to mark the comment as addressed. Default reaction is +1.
+
+    The GitHub API is idempotent - adding the same reaction twice returns
+    the existing reaction.
+    """
+    # Get dependencies from context
+    repo_root = require_repo_root(ctx)
+    github_issues = require_github_issues(ctx)
+
+    # Add the reaction (exits on failure)
+    reaction_result = GitHubChecks.add_reaction(github_issues, repo_root, comment_id, reaction)
+    if isinstance(reaction_result, GitHubAPIFailed):
+        exit_with_error(reaction_result.error_type, reaction_result.message)
+
+    result = {
+        "success": True,
+        "comment_id": comment_id,
+        "reaction": reaction,
+    }
+    click.echo(json.dumps(result, indent=2))
+    raise SystemExit(0)

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

@@ -0,0 +1,68 @@
+"""Add remote execution note to PR body.
+
+This exec command appends a remote execution tracking note to a PR body.
+Used by GitHub Actions workflows to track workflow runs that executed against a PR.
+
+Usage:
+    erk exec add-remote-execution-note --pr-number 123 --run-id 456 --run-url https://...
+
+Output:
+    Success message on stdout
+
+Exit Codes:
+    0: Success
+    1: Error (missing arguments, gh command failed)
+
+Examples:
+    $ erk exec add-remote-execution-note \\
+        --pr-number 1895 \\
+        --run-id 12345678 \\
+        --run-url https://github.com/owner/repo/actions/runs/12345678
+
+    Added remote execution note to PR #1895
+"""
+
+import click
+
+from erk_shared.context.helpers import require_github, require_repo_root
+from erk_shared.github.pr_footer import build_remote_execution_note
+
+
+@click.command(name="add-remote-execution-note")
+@click.option("--pr-number", type=int, required=True, help="PR number to update")
+@click.option("--run-id", type=str, required=True, help="Workflow run ID")
+@click.option("--run-url", type=str, required=True, help="Full URL to workflow run")
+@click.pass_context
+def add_remote_execution_note(
+    ctx: click.Context, pr_number: int, run_id: str, run_url: str
+) -> None:
+    """Add remote execution tracking note to PR body.
+
+    Fetches the current PR body, appends a remote execution note with the
+    workflow run link, and updates the PR. This creates a history of all
+    workflow runs that executed against the PR.
+
+    Args:
+        ctx: Click context with GitHub interface
+        pr_number: The PR number to update
+        run_id: The GitHub Actions workflow run ID
+        run_url: Full URL to the workflow run
+    """
+    github = require_github(ctx)
+    repo_root = require_repo_root(ctx)
+
+    # Get current PR body
+    current_body = github.get_pr_body(repo_root, pr_number)
+    if current_body is None:
+        current_body = ""
+
+    # Build the remote execution note
+    remote_note = build_remote_execution_note(run_id, run_url)
+
+    # Append note to body
+    new_body = f"{current_body}{remote_note}"
+
+    # Update PR body
+    github.update_pr_body(repo_root, pr_number, new_body)
+
+    click.echo(f"Added remote execution note to PR #{pr_number}")

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

@@ -0,0 +1,152 @@
+"""Check .impl/ folder structure and validate prerequisites.
+
+This exec command validates that .impl/ folder has required files
+(plan.md, progress.md) and checks for optional GitHub issue tracking.
+
+Usage:
+    erk exec check-impl
+    erk exec check-impl --dry-run
+
+Output:
+    JSON with validation status and tracking info (dry-run mode)
+    Instructions for implementation (normal mode)
+
+Exit Codes:
+    0: Success
+    1: Validation error
+
+Examples:
+    $ erk exec check-impl --dry-run
+    {"valid": true, "has_issue_tracking": true, "plan_length": 1234}
+
+    $ erk exec check-impl
+    Plan loaded from .impl/plan.md
+    GitHub tracking: ENABLED (issue #123)
+    ...
+"""
+
+import json
+from pathlib import Path
+from typing import NoReturn
+
+import click
+
+from erk_shared.impl_folder import read_issue_reference
+
+
+def _error(msg: str) -> NoReturn:
+    """Output error message and exit with code 1."""
+    click.echo(f"❌ Error: {msg}", err=True)
+    raise SystemExit(1)
+
+
+def _validate_impl_folder() -> Path:
+    """Validate .impl/ folder exists and has required files.
+
+    Returns:
+        Path to .impl/ directory
+
+    Raises:
+        SystemExit: If validation fails
+    """
+    impl_dir = Path.cwd() / ".impl"
+
+    if not impl_dir.exists():
+        _error("No .impl/ folder found in current directory")
+
+    plan_file = impl_dir / "plan.md"
+    if not plan_file.exists():
+        _error("No plan.md found in .impl/ folder")
+
+    progress_file = impl_dir / "progress.md"
+    if not progress_file.exists():
+        _error("No progress.md found in .impl/ folder")
+
+    return impl_dir
+
+
+def _get_issue_reference(impl_dir: Path, *, silent: bool = False) -> dict[str, int | str] | None:
+    """Get issue reference if available, None if not (non-fatal).
+
+    Args:
+        impl_dir: Path to .impl/ directory
+        silent: If True, don't print info message when tracking disabled
+
+    Returns:
+        Dict with issue_number and issue_url, or None if not available
+    """
+    issue_ref = read_issue_reference(impl_dir)
+
+    if issue_ref is None:
+        # Not an error - just means no GitHub tracking
+        if not silent:
+            click.echo(
+                "ℹ️  No issue reference found - GitHub progress tracking disabled",
+                err=True,
+            )
+        return None
+
+    return {
+        "issue_number": issue_ref.issue_number,
+        "issue_url": issue_ref.issue_url,
+    }
+
+
+def _execute_plan(plan_content: str, issue_info: dict[str, int | str] | None) -> None:
+    """Display plan execution instructions.
+
+    Args:
+        plan_content: Content of plan.md
+        issue_info: Issue info dict or None
+    """
+    if issue_info:
+        tracking_msg = f"GitHub tracking: ENABLED (issue #{issue_info['issue_number']})"
+    else:
+        tracking_msg = "GitHub tracking: DISABLED (no issue.json)"
+
+    msg = f"""
+Plan loaded from .impl/plan.md
+
+{tracking_msg}
+
+To implement:
+  claude --permission-mode acceptEdits "/erk:plan-implement"
+
+The /erk:plan-implement slash command will:
+  1. Execute implementation steps
+  2. Update progress.md as steps complete"""
+
+    if issue_info:
+        msg += f"\n  3. Post progress to GitHub issue #{issue_info['issue_number']}"
+
+    click.echo(msg)
+
+
+@click.command(name="check-impl")
+@click.option("--dry-run", is_flag=True, help="Validate and output JSON")
+def check_impl(dry_run: bool) -> None:
+    """Check .impl/ folder structure and validate prerequisites.
+
+    Validates that .impl/ folder exists with required files (plan.md, progress.md).
+    Checks for optional issue.json to enable GitHub progress tracking.
+
+    In dry-run mode, outputs JSON with validation status.
+    In normal mode, outputs instructions for running the implementation.
+    """
+    impl_dir = _validate_impl_folder()
+    # In dry-run mode, suppress info messages to keep JSON output clean
+    issue_info = _get_issue_reference(impl_dir, silent=dry_run)
+
+    plan_file = impl_dir / "plan.md"
+    plan_content = plan_file.read_text(encoding="utf-8")
+
+    if dry_run:
+        result = {
+            "valid": True,
+            "has_issue_tracking": issue_info is not None,
+            "plan_length": len(plan_content),
+        }
+        click.echo(json.dumps(result))
+        return
+
+    _execute_plan(plan_content, issue_info)