erk 0.4.5__py3-none-any.whl

erk/cli/commands/pr/fix_conflicts_cmd.py

@@ -0,0 +1,82 @@
+"""Fix merge conflicts with AI-powered resolution.
+
+Uses Claude to resolve merge conflicts on the current branch without
+any Graphite stack manipulation. Invokes the /erk:fix-conflicts
+Claude slash command.
+"""
+
+import click
+
+from erk.cli.output import stream_fix_conflicts
+from erk.core.context import ErkContext
+
+
+@click.command("fix-conflicts")
+@click.option(
+    "-f",
+    "--dangerous",
+    is_flag=True,
+    help="Acknowledge that this command invokes Claude with --dangerously-skip-permissions.",
+)
+@click.pass_obj
+def pr_fix_conflicts(ctx: ErkContext, *, dangerous: bool) -> None:
+    """Fix merge conflicts with AI-powered resolution.
+
+    Resolves merge conflicts on the current branch using Claude.
+    Does not require or interact with Graphite stacks.
+
+    Examples:
+
+    \b
+      # Fix conflicts with Claude
+      erk pr fix-conflicts --dangerous
+
+    To disable the --dangerous flag requirement:
+
+    \b
+      erk config set fix_conflicts_require_dangerous_flag false
+    """
+    # Runtime validation: require --dangerous unless config disables requirement
+    if not dangerous:
+        require_flag = (
+            ctx.global_config is None or ctx.global_config.fix_conflicts_require_dangerous_flag
+        )
+        if require_flag:
+            raise click.UsageError(
+                "Missing option '--dangerous'.\n"
+                "To disable: erk config set fix_conflicts_require_dangerous_flag false"
+            )
+
+    cwd = ctx.cwd
+
+    # Check for conflicts
+    conflicted_files = ctx.git.get_conflicted_files(cwd)
+    if not conflicted_files:
+        click.echo("No merge conflicts detected.")
+        return
+
+    # Check Claude availability
+    executor = ctx.claude_executor
+    if not executor.is_claude_available():
+        raise click.ClickException(
+            "Claude CLI is required for conflict resolution.\n\n"
+            "Install from: https://claude.com/download"
+        )
+
+    # Show conflict info
+    click.echo(
+        click.style(
+            f"Found {len(conflicted_files)} conflicted file(s). Invoking Claude...",
+            fg="yellow",
+        )
+    )
+
+    # Execute conflict resolution
+    result = stream_fix_conflicts(executor, cwd)
+
+    if result.requires_interactive:
+        raise click.ClickException("Semantic conflict requires interactive resolution")
+    if not result.success:
+        raise click.ClickException(result.error_message or "Conflict resolution failed")
+
+    click.echo(click.style("\n✅ Conflicts resolved!", fg="green", bold=True))

erk/cli/commands/pr/parse_pr_reference.py

@@ -0,0 +1,10 @@
+"""Parse PR reference from user input.
+
+This module re-exports parse_pr_identifier from the centralized CLI parsing module.
+Kept for backwards compatibility with existing imports.
+"""
+
+from erk.cli.github_parsing import parse_pr_identifier
+
+# Re-export with explicit assignment per PEP 484 to indicate intentional re-export
+parse_pr_reference = parse_pr_identifier

erk/cli/commands/pr/submit_cmd.py

@@ -0,0 +1,360 @@
+"""Submit current branch as a pull request.
+
+Unified PR submission with two-layer architecture:
+1. Core layer: git push + gh pr create (works without Graphite)
+2. Graphite layer: Optional enhancement via gt submit
+
+The workflow:
+1. Core submit: git push + gh pr create
+2. Get diff for AI: GitHub API
+3. Generate: AI-generated commit message via Claude CLI
+4. Graphite enhance: Optional gt submit for stack metadata
+5. Finalize: Update PR with AI-generated title/body
+"""
+
+import os
+import uuid
+from pathlib import Path
+
+import click
+
+from erk.core.commit_message_generator import (
+    CommitMessageGenerator,
+    CommitMessageRequest,
+    CommitMessageResult,
+)
+from erk.core.context import ErkContext
+from erk_shared.gateway.gt.events import CompletionEvent, ProgressEvent
+from erk_shared.gateway.gt.operations.finalize import execute_finalize
+from erk_shared.gateway.gt.types import FinalizeResult, PostAnalysisError
+from erk_shared.gateway.pr.diff_extraction import execute_diff_extraction
+from erk_shared.gateway.pr.graphite_enhance import execute_graphite_enhance
+from erk_shared.gateway.pr.submit import execute_core_submit
+from erk_shared.gateway.pr.types import (
+    CoreSubmitError,
+    CoreSubmitResult,
+    GraphiteEnhanceError,
+    GraphiteEnhanceResult,
+    GraphiteSkipped,
+)
+
+
+def _render_progress(event: ProgressEvent) -> None:
+    """Render a progress event to the CLI."""
+    message = f"   {event.message}"
+    if event.style == "info":
+        click.echo(click.style(message, dim=True))
+    elif event.style == "success":
+        click.echo(click.style(message, fg="green"))
+    elif event.style == "warning":
+        click.echo(click.style(message, fg="yellow"))
+    elif event.style == "error":
+        click.echo(click.style(message, fg="red"))
+    else:
+        click.echo(message)
+
+
+@click.command("submit")
+@click.option("--debug", is_flag=True, help="Show diagnostic output")
+@click.option(
+    "--no-graphite",
+    is_flag=True,
+    help="Skip Graphite enhancement (use git + gh only)",
+)
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    help="Force push (use when branch has diverged from remote)",
+)
+@click.pass_obj
+def pr_submit(ctx: ErkContext, debug: bool, no_graphite: bool, force: bool) -> None:
+    """Submit PR with AI-generated commit message.
+
+    Uses a two-layer architecture:
+    - Core layer (always): git push + gh pr create
+    - Graphite layer (optional): gt submit for stack metadata
+
+    The core layer works without Graphite installed. When Graphite is
+    available and the branch is tracked, it will enhance the PR with
+    stack metadata unless --no-graphite is specified.
+
+    Examples:
+
+    \b
+      # Submit PR (with Graphite if available)
+      erk pr submit
+
+      # Submit PR without Graphite enhancement
+      erk pr submit --no-graphite
+
+      # Force push when branch has diverged
+      erk pr submit -f
+    """
+    _execute_pr_submit(ctx, debug=debug, use_graphite=not no_graphite, force=force)
+
+
+def _execute_pr_submit(ctx: ErkContext, debug: bool, use_graphite: bool, force: bool) -> None:
+    """Execute PR submission with positively-named parameters."""
+    # Verify Claude is available (needed for commit message generation)
+    if not ctx.claude_executor.is_claude_available():
+        raise click.ClickException(
+            "Claude CLI not found\n\nInstall from: https://claude.com/download"
+        )
+
+    click.echo(click.style("🚀 Submitting PR...", bold=True))
+    click.echo("")
+
+    cwd = Path.cwd()
+    session_id = os.environ.get("SESSION_ID", str(uuid.uuid4()))
+
+    # Phase 1: Core submit (git push + gh pr create)
+    click.echo(click.style("Phase 1: Creating PR", bold=True))
+    core_result = _run_core_submit(ctx, cwd, debug, force)
+
+    if isinstance(core_result, CoreSubmitError):
+        raise click.ClickException(core_result.message)
+
+    click.echo(click.style(f"   PR #{core_result.pr_number} created", fg="green"))
+    click.echo("")
+
+    # Phase 2: Get diff for AI
+    click.echo(click.style("Phase 2: Getting diff", bold=True))
+    diff_file = _run_diff_extraction(ctx, cwd, core_result.pr_number, session_id, debug)
+
+    if diff_file is None:
+        raise click.ClickException("Failed to extract diff for AI analysis")
+
+    click.echo("")
+
+    # Get branch info for AI context
+    repo_root = ctx.git.get_repository_root(cwd)
+    current_branch = ctx.git.get_current_branch(cwd) or core_result.branch_name
+    trunk_branch = ctx.git.detect_trunk_branch(repo_root)
+
+    # Get parent branch (Graphite-aware, falls back to trunk)
+    parent_branch = (
+        ctx.graphite.get_parent_branch(ctx.git, Path(repo_root), current_branch) or trunk_branch
+    )
+
+    # Get commit messages for AI context (only from current branch)
+    commit_messages = ctx.git.get_commit_messages_since(cwd, parent_branch)
+
+    # Phase 3: Generate commit message
+    click.echo(click.style("Phase 3: Generating PR description", bold=True))
+    msg_gen = CommitMessageGenerator(ctx.claude_executor)
+    msg_result = _run_commit_message_generation(
+        msg_gen,
+        diff_file=diff_file,
+        repo_root=Path(repo_root),
+        current_branch=current_branch,
+        parent_branch=parent_branch,
+        commit_messages=commit_messages,
+        debug=debug,
+    )
+
+    if not msg_result.success:
+        raise click.ClickException(f"Failed to generate message: {msg_result.error_message}")
+
+    click.echo("")
+
+    # Phase 4: Graphite enhancement (optional)
+    graphite_url: str | None = None
+    if use_graphite:
+        click.echo(click.style("Phase 4: Graphite enhancement", bold=True))
+        graphite_result = _run_graphite_enhance(ctx, cwd, core_result.pr_number, debug, force)
+
+        if isinstance(graphite_result, GraphiteEnhanceResult):
+            graphite_url = graphite_result.graphite_url
+            click.echo("")
+        elif isinstance(graphite_result, GraphiteSkipped):
+            if debug:
+                click.echo(click.style(f"   {graphite_result.message}", dim=True))
+            click.echo("")
+        elif isinstance(graphite_result, GraphiteEnhanceError):
+            # Graphite errors are warnings, not fatal
+            click.echo(click.style(f"   Warning: {graphite_result.message}", fg="yellow"))
+            click.echo("")
+
+    # Phase 5: Finalize (update PR metadata)
+    click.echo(click.style("Phase 5: Updating PR metadata", bold=True))
+    finalize_result = _run_finalize(
+        ctx,
+        cwd,
+        pr_number=core_result.pr_number,
+        title=msg_result.title or "Update",
+        body=msg_result.body or "",
+        diff_file=str(diff_file),
+        debug=debug,
+    )
+
+    if isinstance(finalize_result, PostAnalysisError):
+        raise click.ClickException(finalize_result.message)
+
+    click.echo(click.style("   PR metadata updated", fg="green"))
+    click.echo("")
+
+    # Success output with clickable URL
+    styled_url = click.style(finalize_result.pr_url, fg="cyan", underline=True)
+    clickable_url = f"\033]8;;{finalize_result.pr_url}\033\\{styled_url}\033]8;;\033\\"
+    click.echo(f"✅ {clickable_url}")
+
+    # Show Graphite URL if available
+    if graphite_url:
+        styled_graphite = click.style(graphite_url, fg="cyan", underline=True)
+        clickable_graphite = f"\033]8;;{graphite_url}\033\\{styled_graphite}\033]8;;\033\\"
+        click.echo(f"📊 {clickable_graphite}")
+
+
+def _run_core_submit(
+    ctx: ErkContext,
+    cwd: Path,
+    debug: bool,
+    force: bool,
+) -> CoreSubmitResult | CoreSubmitError:
+    """Run core submit phase (git push + gh pr create)."""
+    result: CoreSubmitResult | CoreSubmitError | None = None
+    plans_repo = ctx.local_config.plans_repo if ctx.local_config else None
+
+    for event in execute_core_submit(
+        ctx, cwd, pr_title="WIP", pr_body="", force=force, plans_repo=plans_repo
+    ):
+        if isinstance(event, ProgressEvent):
+            if debug:
+                _render_progress(event)
+        elif isinstance(event, CompletionEvent):
+            result = event.result
+
+    if result is None:
+        return CoreSubmitError(
+            success=False,
+            error_type="submit-failed",
+            message="Core submit did not complete",
+            details={},
+        )
+
+    return result
+
+
+def _run_diff_extraction(
+    ctx: ErkContext,
+    cwd: Path,
+    pr_number: int,
+    session_id: str,
+    debug: bool,
+) -> Path | None:
+    """Run diff extraction phase."""
+    result: Path | None = None
+
+    for event in execute_diff_extraction(ctx, cwd, pr_number, session_id):
+        if isinstance(event, ProgressEvent):
+            if debug:
+                _render_progress(event)
+        elif isinstance(event, CompletionEvent):
+            result = event.result
+
+    return result
+
+
+def _run_graphite_enhance(
+    ctx: ErkContext,
+    cwd: Path,
+    pr_number: int,
+    debug: bool,
+    force: bool,
+) -> GraphiteEnhanceResult | GraphiteEnhanceError | GraphiteSkipped:
+    """Run Graphite enhancement phase."""
+    result: GraphiteEnhanceResult | GraphiteEnhanceError | GraphiteSkipped | None = None
+
+    for event in execute_graphite_enhance(ctx, cwd, pr_number, force=force):
+        if isinstance(event, ProgressEvent):
+            if debug:
+                _render_progress(event)
+        elif isinstance(event, CompletionEvent):
+            result = event.result
+
+    if result is None:
+        return GraphiteSkipped(
+            success=True,
+            reason="incomplete",
+            message="Graphite enhancement did not complete",
+        )
+
+    return result
+
+
+def _run_finalize(
+    ctx: ErkContext,
+    cwd: Path,
+    pr_number: int,
+    title: str,
+    body: str,
+    diff_file: str,
+    debug: bool,
+) -> FinalizeResult | PostAnalysisError:
+    """Run finalize phase and return result."""
+    result: FinalizeResult | PostAnalysisError | None = None
+
+    plans_repo = ctx.local_config.plans_repo if ctx.local_config else None
+    for event in execute_finalize(
+        ctx,
+        cwd,
+        pr_number=pr_number,
+        pr_title=title,
+        pr_body=body,
+        pr_body_file=None,
+        diff_file=diff_file,
+        plans_repo=plans_repo,
+    ):
+        if isinstance(event, ProgressEvent):
+            if debug:
+                _render_progress(event)
+        elif isinstance(event, CompletionEvent):
+            result = event.result
+
+    if result is None:
+        return PostAnalysisError(
+            success=False,
+            error_type="submit-failed",
+            message="Finalize did not complete",
+            details={},
+        )
+
+    return result
+
+
+def _run_commit_message_generation(
+    generator: CommitMessageGenerator,
+    diff_file: Path,
+    repo_root: Path,
+    current_branch: str,
+    parent_branch: str,
+    commit_messages: list[str] | None,
+    debug: bool,
+) -> CommitMessageResult:
+    """Run commit message generation and return result."""
+    result: CommitMessageResult | None = None
+
+    for event in generator.generate(
+        CommitMessageRequest(
+            diff_file=diff_file,
+            repo_root=repo_root,
+            current_branch=current_branch,
+            parent_branch=parent_branch,
+            commit_messages=commit_messages,
+        )
+    ):
+        if isinstance(event, ProgressEvent):
+            _render_progress(event)
+        elif isinstance(event, CompletionEvent):
+            result = event.result
+
+    if result is None:
+        return CommitMessageResult(
+            success=False,
+            title=None,
+            body=None,
+            error_message="Commit message generation did not complete",
+        )
+
+    return result

erk/cli/commands/pr/sync_cmd.py

@@ -0,0 +1,181 @@
+"""Synchronize current PR branch with Graphite.
+
+This command registers a checked-out PR branch with Graphite so it can be managed
+using gt commands (gt pr, gt land, etc.). Useful after checking out a PR from a
+remote source (like GitHub Actions).
+
+Flow:
+1. Validate preconditions (gh/gt auth, on branch, PR exists and is OPEN)
+2. Check if already tracked by Graphite (idempotent)
+3. Get PR base branch from GitHub
+4. Track with Graphite: gt track --branch <current> --parent <base>
+5. Squash commits: gt squash --no-edit --no-interactive
+6. Update local commit message with PR title/body from GitHub
+7. Restack: gt restack (manual conflict resolution if needed)
+8. Submit: gt submit --no-edit --no-interactive (force-push to link with Graphite)
+"""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.ensure import Ensure
+from erk.cli.graphite_command import GraphiteCommand
+from erk.core.context import ErkContext
+from erk.core.repo_discovery import NoRepoSentinel, RepoContext
+from erk_shared.gateway.gt.events import CompletionEvent
+from erk_shared.gateway.gt.operations import execute_squash
+from erk_shared.gateway.gt.types import RestackError, SquashError, SquashSuccess
+from erk_shared.github.types import PRNotFound
+from erk_shared.output.output import user_output
+
+
+def _squash_commits(ctx: ErkContext, repo_root: Path) -> None:
+    """Squash all commits on the current branch into one."""
+    user_output("Squashing commits...")
+    squash_result = None
+    for event in execute_squash(ctx, repo_root):
+        if isinstance(event, CompletionEvent):
+            squash_result = event.result
+    squash_result = Ensure.not_none(squash_result, "Squash operation produced no result")
+    if isinstance(squash_result, SquashError):
+        Ensure.invariant(False, squash_result.message)
+    assert isinstance(squash_result, SquashSuccess)  # Type narrowing after error check
+    user_output(click.style("✓", fg="green") + f" {squash_result.message}")
+
+
+def _update_commit_message_from_pr(ctx: ErkContext, repo_root: Path, pr_number: int) -> None:
+    """Update the commit message with PR title and body from GitHub."""
+    pr = ctx.github.get_pr(repo_root, pr_number)
+    if isinstance(pr, PRNotFound):
+        # PR was verified to exist earlier, so this shouldn't happen
+        return
+    if pr.title:
+        commit_message = pr.title
+        if pr.body:
+            commit_message = f"{pr.title}\n\n{pr.body}"
+        user_output("Updating commit message from PR...")
+        ctx.git.amend_commit(repo_root, commit_message)
+        user_output(click.style("✓", fg="green") + " Commit message updated")
+
+
+@click.command("sync", cls=GraphiteCommand)
+@click.option(
+    "--dangerous",
+    is_flag=True,
+    required=True,
+    help="Acknowledge that this command invokes Claude with --dangerously-skip-permissions.",
+)
+@click.pass_obj
+def pr_sync(ctx: ErkContext, *, dangerous: bool) -> None:
+    """Synchronize current PR branch with Graphite.
+
+    Registers the current PR branch with Graphite for stack management.
+    After syncing, you can use standard gt commands (gt pr, gt land, etc.).
+
+    This is typically used after 'erk pr checkout' to enable Graphite workflows
+    on a PR that was created elsewhere (like from a GitHub Actions run).
+
+    Examples:
+
+        # Checkout and sync a PR
+        erk pr checkout 1973
+        erk pr sync --dangerous
+
+        # Now you can use Graphite commands
+        gt pr
+        gt land
+
+    Requirements:
+    - On a branch (not detached HEAD)
+    - PR exists and is OPEN
+    - PR is not from a fork (cross-repo PRs cannot be tracked)
+    """
+    # dangerous flag is required to indicate acknowledgment
+    _ = dangerous
+    # Step 1: Validate preconditions
+    Ensure.gh_authenticated(ctx)
+    Ensure.gt_authenticated(ctx)
+    Ensure.invariant(
+        not isinstance(ctx.repo, NoRepoSentinel),
+        "Not in a git repository",
+    )
+    assert not isinstance(ctx.repo, NoRepoSentinel)  # Type narrowing for ty
+    repo: RepoContext = ctx.repo
+
+    # Check we're on a branch (not detached HEAD)
+    current_branch = Ensure.not_none(
+        ctx.git.get_current_branch(ctx.cwd),
+        "Not on a branch - checkout a branch before syncing",
+    )
+
+    # Step 2: Check if PR exists and get status
+    pr = ctx.github.get_pr_for_branch(repo.root, current_branch)
+    Ensure.invariant(
+        not isinstance(pr, PRNotFound),
+        f"No pull request found for branch '{current_branch}'",
+    )
+    # Type narrowing after invariant check
+    assert not isinstance(pr, PRNotFound)
+    Ensure.invariant(
+        pr.state == "OPEN",
+        f"Cannot sync {pr.state} PR - only OPEN PRs can be synchronized",
+    )
+
+    pr_number = pr.number
+
+    # Check if PR is from a fork (cross-repo)
+    Ensure.invariant(
+        not pr.is_cross_repository,
+        "Cannot sync fork PRs - Graphite cannot track branches from forks",
+    )
+
+    # Step 3: Check if already tracked by Graphite (idempotent)
+    parent_branch = ctx.graphite.get_parent_branch(ctx.git, repo.root, current_branch)
+    if parent_branch is not None:
+        user_output(
+            click.style("✓", fg="green")
+            + f" Branch '{current_branch}' already tracked by Graphite (parent: {parent_branch})"
+        )
+        return
+
+    # Step 4: Get PR base branch from GitHub (use same PRDetails object)
+    base_branch = pr.base_ref_name
+    user_output(f"Base branch: {base_branch}")
+
+    # Step 5: Track with Graphite
+    user_output(f"Tracking branch '{current_branch}' with parent '{base_branch}'...")
+    ctx.graphite.track_branch(ctx.cwd, current_branch, base_branch)
+    user_output(click.style("✓", fg="green") + " Branch tracked with Graphite")
+
+    # Step 6: Squash commits (idempotent)
+    _squash_commits(ctx, repo.root)
+
+    # Step 6b: Update commit message with PR title/body
+    _update_commit_message_from_pr(ctx, repo.root, pr_number)
+
+    # Step 7: Restack with Graphite (manual conflict resolution if needed)
+    user_output("Restacking branch...")
+    restack_result = ctx.graphite.restack_idempotent(repo.root, no_interactive=True, quiet=False)
+    if isinstance(restack_result, RestackError):
+        if restack_result.error_type == "restack-conflict":
+            user_output(click.style("\nRestack paused due to merge conflicts.", fg="yellow"))
+            user_output("To resolve conflicts, run:")
+            user_output(click.style("  erk pr fix-conflicts --dangerous", fg="cyan"))
+            user_output("\nOr manually:")
+            user_output("  1. Resolve conflicts in the listed files")
+            user_output("  2. Run: gt add -A")
+            user_output("  3. Run: gt continue")
+            raise SystemExit(1)
+        # Non-conflict error
+        raise click.ClickException(restack_result.message)
+    user_output(click.style("✓", fg="green") + " Branch restacked")
+
+    # Step 8: Submit to link with Graphite
+    # Force push is required because squashing rewrites history, causing divergence from remote
+    user_output("Submitting to link with Graphite...")
+    ctx.graphite.submit_stack(repo.root, quiet=True, force=True)
+    user_output(click.style("✓", fg="green") + f" PR #{pr_number} synchronized with Graphite")
+
+    user_output(f"\nBranch '{current_branch}' is now tracked by Graphite.")
+    user_output("You can now use: gt pr, gt land, etc.")

erk/cli/commands/prepare_cwd_recovery.py

@@ -0,0 +1,60 @@
+"""Hidden command that pre-generates recovery scripts for passthrough flows."""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.core import discover_repo_context
+from erk.cli.shell_utils import render_navigation_script
+from erk.core.context import ErkContext
+from erk_shared.output.output import user_output
+
+
+def generate_recovery_script(ctx: ErkContext) -> Path | None:
+    """Create a recovery script that returns to the repo root if cwd vanishes.
+
+    This helper intentionally guards against runtime cwd races:
+    - ctx.cwd is a snapshot from CLI entry; it may no longer exist by the time this runs.
+    - discover_repo_context() performs the authoritative repo lookup; probing earlier provides
+      no additional safety and merely repeats the work.
+    - Returning None signals that graceful degradation is preferred to exploding at the boundary.
+    """
+    current_dir = ctx.cwd
+
+    if not current_dir.exists():
+        return None
+
+    try:
+        repo = discover_repo_context(ctx, current_dir)
+    except (FileNotFoundError, ValueError):
+        return None
+
+    script_content = render_navigation_script(
+        repo.root,
+        repo.root,
+        comment="erk passthrough recovery script",
+        success_message="",
+    )
+
+    result = ctx.script_writer.write_activation_script(
+        script_content,
+        command_name="prepare",
+        comment="pre-generated by __prepare_cwd_recovery",
+    )
+
+    return result.path
+
+
+@click.command(
+    "__prepare_cwd_recovery",
+    hidden=True,
+    add_help_option=False,
+)
+@click.pass_obj
+def prepare_cwd_recovery_cmd(ctx: ErkContext) -> None:
+    """Emit a recovery script if we are inside a managed repository."""
+    script_path = generate_recovery_script(ctx)
+    if script_path is None:
+        return
+
+    user_output(str(script_path), nl=False)