erk 0.4.5__py3-none-any.whl

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

@@ -0,0 +1,103 @@
+"""Extract plan from Claude session and create GitHub issue.
+
+Usage:
+    erk exec create-issue-from-session [--session-id SESSION_ID]
+
+This command combines plan extraction from Claude session files with GitHub
+issue creation. It extracts the latest ExitPlanMode plan, ensures the erk-plan
+label exists, and creates a GitHub issue with the plan content.
+
+SCHEMA VERSION 2: This command uses the new two-step creation flow:
+1. Create issue with metadata-only body (using format_plan_header_body())
+2. Add first comment with plan content (using format_plan_content_comment())
+
+Output:
+    JSON result on stdout: {"success": true, "issue_number": N, "issue_url": "..."}
+    Error messages on stderr with exit code 1 on failure
+
+Exit Codes:
+    0: Success - issue created
+    1: Error - no plan found, gh CLI not available, or other error
+"""
+
+import json
+
+import click
+
+from erk_shared.context.helpers import (
+    require_claude_installation,
+    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
+
+
+@click.command(name="create-issue-from-session")
+@click.option(
+    "--session-id",
+    help="Session ID to search within (optional, searches all sessions if not provided)",
+)
+@click.pass_context
+def create_issue_from_session(ctx: click.Context, session_id: str | None) -> None:
+    """Extract plan from Claude session and create GitHub issue.
+
+    Combines plan extraction with GitHub issue creation in a single operation.
+
+    Schema Version 2 format:
+    - Issue body: metadata-only (schema_version, created_at, created_by, worktree_name)
+    - First comment: plan content wrapped in markers
+    """
+    # Get dependencies from context
+    github = require_github_issues(ctx)
+    repo_root = require_repo_root(ctx)
+    cwd = require_cwd(ctx)
+    claude_installation = require_claude_installation(ctx)
+
+    # Extract latest plan from session
+    plan_text = claude_installation.get_latest_plan(cwd, session_id=session_id)
+
+    if not plan_text:
+        result = {"success": False, "error": "No plan found in Claude session files"}
+        click.echo(json.dumps(result))
+        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=plan_text,
+        title=None,
+        plan_type=None,
+        extra_labels=None,
+        title_suffix=None,
+        source_plan_issues=None,
+        extraction_session_ids=None,
+        source_repo=None,
+        objective_issue=None,
+    )
+
+    if not result.success:
+        if result.issue_number is not None:
+            # Partial success - issue created but comment failed
+            output = {
+                "success": False,
+                "error": result.error,
+                "issue_number": result.issue_number,
+                "issue_url": result.issue_url,
+            }
+        else:
+            output = {"success": False, "error": result.error}
+        click.echo(json.dumps(output))
+        raise SystemExit(1)
+
+    # Return success result
+    output = {
+        "success": True,
+        "issue_number": result.issue_number,
+        "issue_url": result.issue_url,
+        "title": result.title,
+    }
+    click.echo(json.dumps(output))

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

@@ -0,0 +1,103 @@
+"""Create GitHub issue from plan content (via stdin) with erk-plan label.
+
+This exec command handles the complete workflow for creating a plan:
+1. Read plan from stdin
+2. Extract title from plan
+3. Ensure erk-plan label exists
+4. Create GitHub issue with plan body and label
+5. Return structured JSON result
+
+This replaces the complex shell orchestration in the slash command with a single,
+well-tested Python command that uses the ABC interface for GitHub operations.
+"""
+
+import json
+import sys
+
+import click
+
+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.metadata.core import format_plan_issue_body
+from erk_shared.plan_utils import extract_title_from_plan
+
+
+@click.command(name="create-plan-from-context")
+@click.pass_context
+def create_plan_from_context(ctx: click.Context) -> None:
+    """Create GitHub issue from plan content with erk-plan label.
+
+    Reads plan content from stdin, extracts title, ensures erk-plan label exists,
+    creates issue with collapsible plan body and execution commands, and returns JSON result.
+
+    Workflow:
+    1. Create issue with plan body wrapped in collapsible metadata block
+    2. Update issue body to include execution commands (using returned issue number)
+
+    Usage:
+        echo "$plan" | erk exec create-plan-from-context
+
+    Exit Codes:
+        0: Success
+        1: Error (empty plan, gh failure, etc.)
+
+    Output:
+        JSON object: {"success": true, "issue_number": 123, "issue_url": "..."}
+    """
+    # Get GitHub Issues from context (LBYL check in helper)
+    github = require_github_issues(ctx)
+    repo_root = require_repo_root(ctx)
+
+    # Read plan from stdin
+    plan = sys.stdin.read()
+
+    # Validate plan not empty
+    if not plan or not plan.strip():
+        click.echo("Error: Empty plan content received", err=True)
+        raise SystemExit(1)
+
+    # Extract title (pure function call)
+    title = extract_title_from_plan(plan)
+
+    # Initial body: just the plan content (without commands, since we don't have issue number yet)
+    # We'll update it after creation with the full formatted body including commands
+    initial_body = plan.strip()
+
+    # Ensure label exists (ABC interface)
+    try:
+        github.ensure_label_exists(
+            repo_root=repo_root,
+            label="erk-plan",
+            description="Implementation plan for manual execution",
+            color="0E8A16",
+        )
+    except RuntimeError as e:
+        click.echo(f"Error: Failed to ensure label exists: {e}", err=True)
+        raise SystemExit(1) from e
+
+    # Create issue (ABC interface with EAFP pattern)
+    # Add [erk-plan] suffix to title for visibility
+    issue_title = f"{title} [erk-plan]"
+    try:
+        result = github.create_issue(repo_root, issue_title, initial_body, ["erk-plan"])
+    except RuntimeError as e:
+        click.echo(f"Error: Failed to create GitHub issue: {e}", err=True)
+        raise SystemExit(1) from e
+
+    # Now that we have the issue number, format the complete body with commands
+    formatted_body = format_plan_issue_body(plan.strip(), result.number)
+
+    # Update the issue body with the formatted version
+    try:
+        github.update_issue_body(repo_root, result.number, formatted_body)
+    except RuntimeError as e:
+        click.echo(f"Error: Failed to update issue body: {e}", err=True)
+        raise SystemExit(1) from e
+
+    # Output structured JSON
+    output = {
+        "success": True,
+        "issue_number": result.number,
+        "issue_url": result.url,
+    }
+    click.echo(json.dumps(output))

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

@@ -0,0 +1,93 @@
+"""Create .worker-impl/ folder from GitHub issue with plan content.
+
+This exec command fetches a plan from a GitHub issue and creates the .worker-impl/
+folder structure, providing a testable alternative to inline workflow scripts.
+
+Usage:
+    erk exec create-worker-impl-from-issue <issue-number>
+
+Output:
+    Structured JSON output with success status and folder details
+
+Exit Codes:
+    0: Success (.worker-impl/ folder created)
+    1: Error (issue not found, plan fetch failed, folder creation failed)
+
+Examples:
+    $ erk exec create-worker-impl-from-issue 1028
+    {"success": true, "worker_impl_path": "/path/to/.worker-impl", "issue_number": 1028}
+
+    $ erk exec create-worker-impl-from-issue 999
+    {"success": false, "error": "issue_not_found", "message": "..."}
+"""
+
+import json
+from pathlib import Path
+
+import click
+
+from erk_shared.gateway.time.real import RealTime
+from erk_shared.github.issues import RealGitHubIssues
+from erk_shared.plan_store.github import GitHubPlanStore
+from erk_shared.worker_impl_folder import create_worker_impl_folder
+
+
+@click.command(name="create-worker-impl-from-issue")
+@click.argument("issue_number", type=int)
+@click.option(
+    "--repo-root",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+    default=None,
+    help="Repository root directory (defaults to current directory)",
+)
+def create_worker_impl_from_issue(
+    issue_number: int,
+    repo_root: Path | None,
+) -> None:
+    """Create .worker-impl/ folder from GitHub issue with plan content.
+
+    Fetches plan content from GitHub issue and creates .worker-impl/ folder structure
+    with plan.md, issue.json, and metadata.
+
+    ISSUE_NUMBER: GitHub issue number containing the plan
+    """
+    # Default to current directory if not specified
+    if repo_root is None:
+        repo_root = Path.cwd()
+
+    # Direct instantiation of required dependencies (avoids erk import)
+    # This allows the command to work when run via erk kit exec without uv
+    time = RealTime()
+    github_issues = RealGitHubIssues(target_repo=None)
+    plan_store = GitHubPlanStore(github_issues, time)
+
+    # Fetch plan from GitHub (raises RuntimeError if not found)
+    try:
+        plan = plan_store.get_plan(repo_root, str(issue_number))
+    except RuntimeError as e:
+        error_output = {
+            "success": False,
+            "error": "plan_not_found",
+            "message": f"Could not fetch plan for issue #{issue_number}: {e}. "
+            f"Ensure issue has erk-plan label and plan content.",
+        }
+        click.echo(json.dumps(error_output), err=True)
+        raise SystemExit(1) from e
+
+    # Create .worker-impl/ folder with plan content
+    worker_impl_path = repo_root / ".worker-impl"
+    create_worker_impl_folder(
+        plan_content=plan.body,
+        issue_number=issue_number,
+        issue_url=plan.url,
+        repo_root=repo_root,
+    )
+
+    # Output structured success result
+    output = {
+        "success": True,
+        "worker_impl_path": str(worker_impl_path),
+        "issue_number": issue_number,
+        "issue_url": plan.url,
+    }
+    click.echo(json.dumps(output))

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

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Detect whether repo uses `main` or `master` as trunk branch.
+
+This command checks the remote (origin) for the existence of trunk branches,
+suitable for CI environments where local branches may not be available.
+
+This replaces bash-based detection in GitHub Actions workflows:
+```bash
+if git ls-remote --heads origin main | grep -q main; then
+  echo "trunk_branch=main"
+elif git ls-remote --heads origin master | grep -q master; then
+  echo "trunk_branch=master"
+else
+  exit 1
+fi
+```
+
+Usage:
+    erk exec detect-trunk-branch
+
+Output:
+    JSON object with success status and detected trunk branch
+
+Exit Codes:
+    0: Success (trunk branch detected)
+    1: Error (neither main nor master exists on remote)
+
+Examples:
+    $ erk exec detect-trunk-branch
+    {
+      "success": true,
+      "trunk_branch": "main"
+    }
+
+    $ erk exec detect-trunk-branch  # in repo with master only
+    {
+      "success": true,
+      "trunk_branch": "master"
+    }
+
+    $ erk exec detect-trunk-branch  # in repo without main/master
+    {
+      "success": false,
+      "error": "trunk_not_found",
+      "message": "Could not detect trunk branch (neither 'main' nor 'master' exists on origin)"
+    }
+"""
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Literal
+
+import click
+
+from erk_shared.context.helpers import require_git, require_repo_root
+from erk_shared.git.abc import Git
+
+
+@dataclass(frozen=True)
+class DetectedTrunk:
+    """Success result with detected trunk branch."""
+
+    success: bool
+    trunk_branch: str
+
+
+@dataclass(frozen=True)
+class DetectionError:
+    """Error result when trunk branch cannot be detected."""
+
+    success: bool
+    error: Literal["trunk-not-found", "git-error"]
+    message: str
+
+
+def _detect_trunk_branch_impl(git: Git, repo_root: Path) -> DetectedTrunk | DetectionError:
+    """Detect trunk branch by checking remote for main or master.
+
+    Checks origin remote for 'main' first, then 'master'. Returns error
+    if neither exists.
+
+    Args:
+        git: Git interface for operations
+        repo_root: Path to the git repository root
+
+    Returns:
+        DetectedTrunk on success, DetectionError if neither branch found
+    """
+    # Check main first (modern convention), then master (legacy convention)
+    for candidate in ["main", "master"]:
+        if git.branch_exists_on_remote(repo_root, "origin", candidate):
+            return DetectedTrunk(success=True, trunk_branch=candidate)
+
+    # Neither found
+    return DetectionError(
+        success=False,
+        error="trunk-not-found",
+        message="Could not detect trunk branch (neither 'main' nor 'master' exists on origin)",
+    )
+
+
+@click.command(name="detect-trunk-branch")
+@click.pass_context
+def detect_trunk_branch(ctx: click.Context) -> None:
+    """Detect whether repo uses main or master as trunk branch.
+
+    Queries the origin remote to check for trunk branch existence.
+    Checks for 'main' first, then 'master'. Exits with error if neither exists.
+    """
+    git = require_git(ctx)
+    repo_root = require_repo_root(ctx)
+
+    result = _detect_trunk_branch_impl(git, repo_root)
+
+    # Output JSON result
+    click.echo(json.dumps(asdict(result), indent=2))
+
+    # Exit with error code if detection failed
+    if isinstance(result, DetectionError):
+        raise SystemExit(1)