erk 0.4.5__py3-none-any.whl

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

@@ -0,0 +1,32 @@
+"""Quick commit all changes and submit with Graphite CLI command."""
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+
+import click
+
+from erk_shared.gateway.gt.cli import render_events
+from erk_shared.gateway.gt.operations.quick_submit import execute_quick_submit
+from erk_shared.gateway.gt.real import RealGtKit
+from erk_shared.gateway.gt.types import QuickSubmitError
+
+
+@click.command("quick-submit")
+def quick_submit() -> None:
+    """Quick commit all changes and submit with Graphite.
+
+    Stages all changes, commits with "update" message if there are changes,
+    then runs gt submit. This is a fast iteration shortcut.
+
+    For proper commit messages, use the pr-submit command instead.
+    """
+    cwd = Path.cwd()
+    ops = RealGtKit(cwd)
+    result = render_events(execute_quick_submit(ops, cwd))
+
+    # Output JSON result
+    click.echo(json.dumps(asdict(result), indent=2))
+
+    if isinstance(result, QuickSubmitError):
+        raise SystemExit(1)

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

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Rebase onto trunk and resolve conflicts with Claude.
+
+This command handles merge conflicts during CI workflows by:
+1. Fetching the trunk branch
+2. Checking if the current branch is behind
+3. Starting a rebase
+4. Using Claude to resolve any conflicts
+5. Force pushing after successful rebase
+
+Usage:
+    erk exec rebase-with-conflict-resolution \
+        --trunk-branch master \
+        --branch-name feature-branch \
+        --model claude-sonnet-4-5
+
+Output:
+    JSON object with success status
+
+Exit Codes:
+    0: Success (rebase completed and pushed, or already up-to-date)
+    1: Error (conflict resolution failed after max attempts)
+
+Examples:
+    $ erk exec rebase-with-conflict-resolution --trunk-branch main --branch-name my-feature
+    {
+      "success": true,
+      "action": "rebased",
+      "commits_behind": 3
+    }
+
+    $ erk exec rebase-with-conflict-resolution --trunk-branch main --branch-name my-feature
+    {
+      "success": true,
+      "action": "already-up-to-date",
+      "commits_behind": 0
+    }
+"""
+
+import json
+import subprocess
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Literal
+
+import click
+
+
+@dataclass(frozen=True)
+class RebaseSuccess:
+    """Success result for rebase operation."""
+
+    success: bool
+    action: Literal["rebased", "already-up-to-date"]
+    commits_behind: int
+
+
+@dataclass(frozen=True)
+class RebaseError:
+    """Error result when rebase fails."""
+
+    success: bool
+    error: Literal["fetch-failed", "rebase-failed", "push-failed"]
+    message: str
+
+
+def _get_commits_behind(trunk_branch: str) -> int | None:
+    """Get number of commits behind trunk branch.
+
+    Returns:
+        Number of commits behind, or None if command fails.
+    """
+    result = subprocess.run(
+        ["git", "rev-list", "--count", f"HEAD..origin/{trunk_branch}"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    count_str = result.stdout.strip()
+    if not count_str.isdigit():
+        return None
+    return int(count_str)
+
+
+def _is_rebase_in_progress() -> bool:
+    """Check if a rebase is currently in progress."""
+    git_dir = Path(".git")
+    return (git_dir / "rebase-merge").is_dir() or (git_dir / "rebase-apply").is_dir()
+
+
+def _invoke_claude_for_conflicts(model: str) -> bool:
+    """Invoke Claude to fix merge conflicts.
+
+    Returns:
+        True if Claude invocation succeeded (exit code 0).
+    """
+    prompt = (
+        "Fix all merge conflicts in this repository. "
+        "For each conflicted file, read it, resolve the conflict markers appropriately, "
+        "and save the file. After fixing all conflicts, stage the resolved files with "
+        "'git add' and then run 'git rebase --continue' to continue the rebase."
+    )
+    result = subprocess.run(
+        [
+            "claude",
+            "--print",
+            "--model",
+            model,
+            "--output-format",
+            "stream-json",
+            "--dangerously-skip-permissions",
+            "--verbose",
+            prompt,
+        ],
+        capture_output=False,  # Let output stream to stdout/stderr
+        check=False,  # We check returncode explicitly below
+    )
+    return result.returncode == 0
+
+
+def _rebase_with_conflict_resolution_impl(
+    trunk_branch: str,
+    branch_name: str,
+    model: str,
+    max_attempts: int,
+) -> RebaseSuccess | RebaseError:
+    """Rebase onto trunk and resolve conflicts with Claude.
+
+    Args:
+        trunk_branch: Trunk branch to rebase onto (e.g., 'main', 'master')
+        branch_name: Current branch name for force push
+        model: Claude model to use for conflict resolution
+        max_attempts: Maximum number of conflict resolution attempts
+
+    Returns:
+        RebaseSuccess on success, RebaseError on failure
+    """
+    # Fetch trunk branch
+    fetch_result = subprocess.run(
+        ["git", "fetch", "origin", trunk_branch],
+        capture_output=True,
+        text=True,
+        check=False,  # We check returncode explicitly below
+    )
+    if fetch_result.returncode != 0:
+        return RebaseError(
+            success=False,
+            error="fetch-failed",
+            message=f"Failed to fetch origin/{trunk_branch}: {fetch_result.stderr}",
+        )
+
+    # Check if behind
+    commits_behind = _get_commits_behind(trunk_branch)
+    if commits_behind is None:
+        return RebaseError(
+            success=False,
+            error="fetch-failed",
+            message="Failed to determine commits behind trunk",
+        )
+
+    if commits_behind == 0:
+        return RebaseSuccess(
+            success=True,
+            action="already-up-to-date",
+            commits_behind=0,
+        )
+
+    # Start rebase (may fail with conflicts, which is expected)
+    subprocess.run(
+        ["git", "rebase", f"origin/{trunk_branch}"],
+        capture_output=True,
+        text=True,
+        check=False,  # Conflicts expected - we check _is_rebase_in_progress()
+    )
+
+    # Loop while rebase has conflicts
+    attempt = 0
+    while _is_rebase_in_progress() and attempt < max_attempts:
+        attempt += 1
+        # Invoke Claude to fix conflicts
+        _invoke_claude_for_conflicts(model)
+
+    # Check if rebase completed
+    if _is_rebase_in_progress():
+        # Abort rebase and return error
+        subprocess.run(["git", "rebase", "--abort"], capture_output=True, check=False)
+        return RebaseError(
+            success=False,
+            error="rebase-failed",
+            message=f"Failed to resolve conflicts after {max_attempts} attempts",
+        )
+
+    # Force push after successful rebase
+    push_result = subprocess.run(
+        ["git", "push", "-f", "origin", branch_name],
+        capture_output=True,
+        text=True,
+        check=False,  # We check returncode explicitly below
+    )
+    if push_result.returncode != 0:
+        return RebaseError(
+            success=False,
+            error="push-failed",
+            message=f"Failed to force push: {push_result.stderr}",
+        )
+
+    return RebaseSuccess(
+        success=True,
+        action="rebased",
+        commits_behind=commits_behind,
+    )
+
+
+@click.command(name="rebase-with-conflict-resolution")
+@click.option(
+    "--trunk-branch",
+    required=True,
+    help="Trunk branch to rebase onto (e.g., 'main', 'master')",
+)
+@click.option(
+    "--branch-name",
+    required=True,
+    help="Current branch name for force push",
+)
+@click.option(
+    "--model",
+    default="claude-sonnet-4-5",
+    help="Claude model to use for conflict resolution",
+)
+@click.option(
+    "--max-attempts",
+    default=5,
+    type=int,
+    help="Maximum number of conflict resolution attempts",
+)
+def rebase_with_conflict_resolution(
+    trunk_branch: str,
+    branch_name: str,
+    model: str,
+    max_attempts: int,
+) -> None:
+    """Rebase onto trunk and resolve conflicts with Claude.
+
+    This command is designed for CI workflows where push may fail due to
+    branch divergence. It fetches the trunk branch, rebases onto it,
+    and uses Claude to resolve any merge conflicts.
+    """
+    result = _rebase_with_conflict_resolution_impl(
+        trunk_branch=trunk_branch,
+        branch_name=branch_name,
+        model=model,
+        max_attempts=max_attempts,
+    )
+
+    click.echo(json.dumps(asdict(result), indent=2))
+
+    if isinstance(result, RebaseError):
+        raise SystemExit(1)

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

@@ -0,0 +1,173 @@
+"""Reply to a PR discussion comment with a blockquote and action summary.
+
+This exec command posts a reply to a discussion comment that:
+1. Quotes the original comment with author attribution
+2. Includes an action summary explaining what was done
+3. Adds a reaction to the original comment
+
+Usage:
+    erk exec reply-to-discussion-comment --comment-id 12345 --reply "Action taken: ..."
+    erk exec reply-to-discussion-comment --comment-id 12345 --pr 789 --reply "..."
+
+Output:
+    JSON with success status and reply details
+
+Exit Codes:
+    0: Success
+    1: Error (comment not found, API failure, etc.)
+
+Examples:
+    $ erk exec reply-to-discussion-comment --comment-id 12345 --reply "Fixed typo in docs"
+    {"success": true, "comment_id": 12345, "reply_id": 67890}
+"""
+
+import json
+from datetime import UTC, datetime
+
+import click
+
+from erk.cli.script_output import exit_with_error
+from erk_shared.context.helpers import (
+    get_current_branch,
+    require_github,
+    require_repo_root,
+)
+from erk_shared.context.helpers import (
+    require_issues as require_github_issues,
+)
+from erk_shared.github.checks import GitHubChecks
+from erk_shared.non_ideal_state import (
+    BranchDetectionFailed,
+    GitHubAPIFailed,
+    NoPRForBranch,
+    PRNotFoundError,
+)
+
+
+def _format_reply(author: str, url: str, body: str, action_summary: str) -> str:
+    """Format a reply with blockquote of original comment and action summary.
+
+    Args:
+        author: Original comment author's GitHub login
+        url: URL to the original comment
+        body: Body of the original comment
+        action_summary: Description of action taken
+
+    Returns:
+        Formatted markdown reply
+    """
+    # Quote the original comment (truncate if very long)
+    quoted_lines = body.strip().split("\n")
+    if len(quoted_lines) > 10:
+        # Truncate long comments
+        quoted_body = "\n".join(quoted_lines[:10]) + "\n> ..."
+    else:
+        quoted_body = body.strip()
+
+    # Add blockquote prefix to each line
+    quoted = "\n".join(f"> {line}" for line in quoted_body.split("\n"))
+
+    # Get current timestamp
+    now = datetime.now(UTC).strftime("%Y-%m-%d %I:%M %p UTC")
+
+    return f"""> **@{author}** [commented]({url}):
+{quoted}
+
+{action_summary}
+
+---
+<sub>Addressed via `/erk:pr-address` at {now}</sub>"""
+
+
+@click.command(name="reply-to-discussion-comment")
+@click.option("--comment-id", required=True, type=int, help="Numeric comment ID to reply to")
+@click.option("--pr", type=int, default=None, help="PR number (defaults to current branch's PR)")
+@click.option("--reply", required=True, help="Action summary text (what was done)")
+@click.pass_context
+def reply_to_discussion_comment(
+    ctx: click.Context, comment_id: int, pr: int | None, reply: str
+) -> None:
+    """Reply to a PR discussion comment with quote and action summary.
+
+    Fetches the original comment to get its author and body, then posts a
+    formatted reply quoting the original with your action summary. Also adds
+    a +1 reaction to the original comment.
+    """
+    # Get dependencies from context
+    repo_root = require_repo_root(ctx)
+    github = require_github(ctx)
+    github_issues = require_github_issues(ctx)
+
+    # Get PR details - either from current branch or specified PR number
+    if pr is None:
+        branch_result = GitHubChecks.branch(get_current_branch(ctx))
+        if isinstance(branch_result, BranchDetectionFailed):
+            exit_with_error(branch_result.error_type, branch_result.message)
+        # Type narrowing: exit_with_error returns NoReturn, so branch_result is str
+        assert not isinstance(branch_result, BranchDetectionFailed)
+        branch = branch_result
+
+        pr_result = GitHubChecks.pr_for_branch(github, repo_root, branch)
+        if isinstance(pr_result, NoPRForBranch):
+            exit_with_error(pr_result.error_type, pr_result.message)
+        assert not isinstance(pr_result, NoPRForBranch)
+        pr_details = pr_result
+    else:
+        pr_result = GitHubChecks.pr_by_number(github, repo_root, pr)
+        if isinstance(pr_result, PRNotFoundError):
+            exit_with_error(pr_result.error_type, pr_result.message)
+        assert not isinstance(pr_result, PRNotFoundError)
+        pr_details = pr_result
+
+    # Fetch all discussion comments to find the one we're replying to
+    comments_result = GitHubChecks.issue_comments(github_issues, repo_root, pr_details.number)
+    if isinstance(comments_result, GitHubAPIFailed):
+        exit_with_error(comments_result.error_type, comments_result.message)
+    assert not isinstance(comments_result, GitHubAPIFailed)
+
+    # Find the comment by ID
+    target_comment = None
+    for comment in comments_result:
+        if comment.id == comment_id:
+            target_comment = comment
+            break
+
+    if target_comment is None:
+        exit_with_error(
+            "comment-not-found",
+            f"Comment ID {comment_id} not found in PR #{pr_details.number} discussion",
+        )
+    # Type narrowing: target_comment is not None after the check above
+    assert target_comment is not None
+
+    # Format the reply
+    reply_body = _format_reply(
+        author=target_comment.author,
+        url=target_comment.url,
+        body=target_comment.body,
+        action_summary=reply,
+    )
+
+    # Post the reply as a new comment
+    try:
+        reply_comment_id = github_issues.add_comment(repo_root, pr_details.number, reply_body)
+    except RuntimeError as e:
+        exit_with_error("github-api-error", f"Failed to post reply: {e}")
+
+    # Add reaction to original comment
+    reaction_result = GitHubChecks.add_reaction(github_issues, repo_root, comment_id, "+1")
+    if isinstance(reaction_result, GitHubAPIFailed):
+        # Non-fatal: reply was posted, just log warning
+        click.echo(
+            f"Warning: Reply posted but failed to add reaction: {reaction_result.message}",
+            err=True,
+        )
+
+    result = {
+        "success": True,
+        "comment_id": comment_id,
+        "reply_id": reply_comment_id,
+        "pr_number": pr_details.number,
+    }
+    click.echo(json.dumps(result, indent=2))
+    raise SystemExit(0)

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

@@ -0,0 +1,170 @@
+"""Resolve a PR review thread via GraphQL mutation.
+
+This exec command resolves a single PR review thread and outputs
+JSON with the result. Optionally adds a reply comment before resolving.
+
+Usage:
+    erk exec resolve-review-thread --thread-id "PRRT_xxxx"
+    erk exec resolve-review-thread --thread-id "PRRT_xxxx" --comment "Resolved via ..."
+
+Output:
+    JSON with success status
+
+Exit Codes:
+    0: Always (even on error, to support || true pattern)
+    1: Context not initialized
+
+Examples:
+    $ erk exec resolve-review-thread --thread-id "PRRT_abc123"
+    {"success": true, "thread_id": "PRRT_abc123"}
+
+    $ erk exec resolve-review-thread --thread-id "PRRT_abc123" --comment "Fixed"
+    {"success": true, "thread_id": "PRRT_abc123", "comment_added": true}
+
+    $ erk exec resolve-review-thread --thread-id "invalid"
+    {"success": false, "error_type": "resolution_failed", "message": "..."}
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, TypeVar
+
+import click
+
+from erk_shared.context.helpers import require_github, require_repo_root
+
+if TYPE_CHECKING:
+    from erk_shared.github.abc import GitHub
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class ResolveThreadSuccess:
+    """Success response for thread resolution."""
+
+    success: bool
+    thread_id: str
+    comment_added: bool = False
+
+
+@dataclass(frozen=True)
+class ResolveThreadError:
+    """Error response for thread resolution."""
+
+    success: bool
+    error_type: str
+    message: str
+
+
+def _format_resolution_comment(comment: str) -> str:
+    """Format a resolution comment with timestamp and source attribution.
+
+    Args:
+        comment: The user-provided comment text
+
+    Returns:
+        Formatted comment with timestamp and /erk:pr-address attribution
+    """
+    timestamp = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z")
+    return f"{comment}\n\n_Addressed via `/erk:pr-address` at {timestamp}_"
+
+
+def _ensure_not_error(result: T | ResolveThreadError) -> T:
+    """Ensure result is not an error, otherwise output JSON and exit.
+
+    Provides type narrowing: takes `T | ResolveThreadError` and returns `T`.
+
+    Args:
+        result: Value that may be a ResolveThreadError
+
+    Returns:
+        The value unchanged if not an error (with narrowed type T)
+
+    Raises:
+        SystemExit: If result is ResolveThreadError (with exit code 0)
+    """
+    if isinstance(result, ResolveThreadError):
+        click.echo(json.dumps(asdict(result), indent=2))
+        raise SystemExit(0)
+    return result
+
+
+def _add_comment_if_provided(
+    github: GitHub,
+    repo_root: Path,
+    thread_id: str,
+    comment: str | None,
+) -> bool | ResolveThreadError:
+    """Add a comment to the thread if provided.
+
+    Returns:
+        True/False for comment_added status, or ResolveThreadError on failure
+    """
+    if comment is None:
+        return False
+
+    formatted_comment = _format_resolution_comment(comment)
+    try:
+        return github.add_review_thread_reply(repo_root, thread_id, formatted_comment)
+    except RuntimeError as e:
+        return ResolveThreadError(
+            success=False,
+            error_type="comment-failed",
+            message=f"Failed to add comment: {e}",
+        )
+
+
+@click.command(name="resolve-review-thread")
+@click.option("--thread-id", required=True, help="GraphQL node ID of the thread to resolve")
+@click.option("--comment", default=None, help="Optional comment to add before resolving")
+@click.pass_context
+def resolve_review_thread(ctx: click.Context, thread_id: str, comment: str | None) -> None:
+    """Resolve a PR review thread.
+
+    Takes a GraphQL node ID (from get-pr-review-comments output) and
+    marks the thread as resolved. Optionally adds a reply comment first.
+
+    THREAD_ID: GraphQL node ID of the review thread
+    """
+    # Get dependencies from context
+    repo_root = require_repo_root(ctx)
+    github = require_github(ctx)
+
+    # Add comment first if provided
+    comment_added = _ensure_not_error(
+        _add_comment_if_provided(github, repo_root, thread_id, comment)
+    )
+
+    # Attempt to resolve the thread
+    try:
+        resolved = github.resolve_review_thread(repo_root, thread_id)
+    except RuntimeError as e:
+        result = ResolveThreadError(
+            success=False,
+            error_type="github-api-failed",
+            message=str(e),
+        )
+        click.echo(json.dumps(asdict(result), indent=2))
+        raise SystemExit(0) from None
+
+    if resolved:
+        result_success = ResolveThreadSuccess(
+            success=True,
+            thread_id=thread_id,
+            comment_added=comment_added,
+        )
+        click.echo(json.dumps(asdict(result_success), indent=2))
+    else:
+        result_error = ResolveThreadError(
+            success=False,
+            error_type="resolution-failed",
+            message=f"Failed to resolve thread {thread_id}",
+        )
+        click.echo(json.dumps(asdict(result_error), indent=2))
+
+    raise SystemExit(0)

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

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Session ID Injector Hook
+
+This command is invoked via erk exec session-id-injector-hook.
+"""
+
+import click
+
+from erk.hooks.decorators import HookContext, hook_command
+from erk_shared.gateway.erk_installation.real import RealErkInstallation
+
+
+def _is_github_planning_enabled() -> bool:
+    """Check if github_planning is enabled in ~/.erk/config.toml.
+
+    Returns True (enabled) if config doesn't exist or flag is missing.
+    """
+    # Use RealErkInstallation directly since hooks run outside normal CLI context
+    installation = RealErkInstallation()
+    if not installation.config_exists():
+        return True  # Default enabled
+
+    config = installation.load_config()
+    return config.github_planning
+
+
+@hook_command(name="session-id-injector-hook")
+def session_id_injector_hook(ctx: click.Context, *, hook_ctx: HookContext) -> None:
+    """Inject session ID into conversation context when relevant."""
+    # Scope check: only run in erk-managed projects
+    if not hook_ctx.is_erk_project:
+        return
+
+    # Early exit if github_planning is disabled - output nothing
+    if not _is_github_planning_enabled():
+        return
+
+    # Output session ID if available
+    if hook_ctx.session_id is not None:
+        # Write to file for CLI tools to read (worktree-scoped persistence)
+        session_file = hook_ctx.repo_root / ".erk" / "scratch" / "current-session-id"
+        session_file.parent.mkdir(parents=True, exist_ok=True)
+        session_file.write_text(hook_ctx.session_id, encoding="utf-8")
+
+        # Still output reminder for LLM context
+        click.echo(f"📌 session: {hook_ctx.session_id}")
+    # If no session ID available, output nothing (hook doesn't fire unnecessarily)
+
+
+if __name__ == "__main__":
+    session_id_injector_hook()