erk 0.4.5__py3-none-any.whl

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

@@ -0,0 +1,49 @@
+"""Extract the latest plan from Claude session files.
+
+Usage:
+    erk exec extract-latest-plan [--session-id SESSION_ID]
+
+This command searches Claude session files for the most recent ExitPlanMode
+tool use and extracts the plan text. It can search either the current session
+(if --session-id is provided) or all sessions for the project.
+
+Output:
+    Plan text on stdout
+    Error message on stderr with exit code 1 on failure
+
+Exit Codes:
+    0: Success - plan found and output
+    1: Error - no plan found or other error
+"""
+
+import click
+
+from erk_shared.context.helpers import require_claude_installation, require_cwd
+
+
+@click.command(name="extract-latest-plan")
+@click.option(
+    "--session-id",
+    help="Session ID to search within (optional, searches all sessions if not provided)",
+)
+@click.pass_context
+def extract_latest_plan(ctx: click.Context, session_id: str | None) -> None:
+    """Extract the latest plan from Claude session files.
+
+    Searches for the most recent ExitPlanMode tool use and extracts the plan text.
+    """
+    # Get dependencies from context
+    cwd = require_cwd(ctx)
+    claude_installation = require_claude_installation(ctx)
+
+    # Extract latest plan
+    plan_text = claude_installation.get_latest_plan(cwd, session_id=session_id)
+
+    if not plan_text:
+        click.echo(
+            click.style("Error: ", fg="red") + "No plan found in Claude session files", err=True
+        )
+        raise SystemExit(1)
+
+    # Output plan text to stdout
+    click.echo(plan_text)

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

@@ -0,0 +1,150 @@
+"""Extract session XML content from a GitHub issue's comments.
+
+Usage:
+    erk exec extract-session-from-issue <issue-number> [--output <path>]
+    erk exec extract-session-from-issue <issue-number> --stdout
+
+This command:
+1. Fetches all comments from the specified GitHub issue
+2. Parses session-content metadata blocks from the comments
+3. Handles chunked content by combining in order
+4. Writes the combined XML to the output path (or stdout with --stdout)
+5. Returns metadata about the extracted session
+
+Output:
+    Default: JSON with success status, session_file path, session_ids, and chunk_count
+    With --stdout: Session XML to stdout, metadata JSON to stderr
+"""
+
+import json
+from pathlib import Path
+
+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.session import extract_session_content_from_comments
+from erk_shared.scratch.scratch import write_scratch_file
+
+
+@click.command(name="extract-session-from-issue")
+@click.argument("issue_number", type=int)
+@click.option(
+    "--output",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Output path for the session XML (default: auto-generated in .erk/scratch/)",
+)
+@click.option(
+    "--session-id",
+    type=str,
+    default=None,
+    help="Session ID for scratch directory (used if --output not provided)",
+)
+@click.option(
+    "--stdout",
+    "use_stdout",
+    is_flag=True,
+    default=False,
+    help="Output session XML to stdout instead of writing to a file",
+)
+@click.pass_context
+def extract_session_from_issue(
+    ctx: click.Context,
+    issue_number: int,
+    output: Path | None,
+    session_id: str | None,
+    use_stdout: bool,
+) -> None:
+    """Extract session XML from GitHub issue comments.
+
+    Reads all comments from the specified issue, finds session-content
+    metadata blocks, combines chunked content in order, and writes
+    the result to the output path.
+
+    ISSUE_NUMBER is the GitHub issue number to extract session data from.
+    """
+    # Get required context
+    github = require_github_issues(ctx)
+    repo_root = require_repo_root(ctx)
+
+    # Fetch issue comments
+    comments = github.get_issue_comments(repo_root, issue_number)
+
+    # Extract session content
+    session_xml, session_ids = extract_session_content_from_comments(comments)
+
+    if session_xml is None:
+        click.echo(
+            json.dumps(
+                {
+                    "success": False,
+                    "error": f"No session content found in issue #{issue_number}",
+                    "issue_number": issue_number,
+                }
+            )
+        )
+        raise SystemExit(1)
+
+    # Handle --stdout: output XML to stdout, metadata to stderr
+    if use_stdout:
+        click.echo(session_xml)
+        click.echo(
+            json.dumps(
+                {
+                    "success": True,
+                    "issue_number": issue_number,
+                    "session_ids": session_ids,
+                    "chunk_count": len(session_ids) if session_ids else 1,
+                }
+            ),
+            err=True,
+        )
+        return
+
+    # Determine output path
+    if output is not None:
+        # Use explicit output path
+        output_path = output
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(session_xml, encoding="utf-8")
+    elif session_id is not None:
+        # Use scratch directory with provided session ID
+        output_path = write_scratch_file(
+            session_xml,
+            session_id=session_id,
+            suffix=".xml",
+            prefix="session-from-issue-",
+            repo_root=repo_root,
+        )
+    else:
+        # Generate session ID from first extracted session ID, or use issue number
+        fallback_session_id = session_ids[0] if session_ids else f"issue-{issue_number}"
+        output_path = write_scratch_file(
+            session_xml,
+            session_id=fallback_session_id,
+            suffix=".xml",
+            prefix="session-from-issue-",
+            repo_root=repo_root,
+        )
+
+    # Calculate chunk count from the original comments
+    chunk_count = len([s for s in session_ids])  # Approximate based on unique session IDs
+    if chunk_count == 0:
+        chunk_count = 1  # At least one chunk if we got content
+
+    click.echo(
+        json.dumps(
+            {
+                "success": True,
+                "issue_number": issue_number,
+                "session_file": str(output_path),
+                "session_ids": session_ids,
+                "chunk_count": chunk_count,
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    extract_session_from_issue()

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

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Find Claude Code project directory for a given filesystem path.
+
+This command provides deterministic mapping between filesystem paths and
+Claude Code project directories in ~/.claude/projects/.
+
+Claude Code encodes filesystem paths using a simple rule:
+- Replace "/" with "-"
+- Replace "." with "-"
+
+Examples:
+    /Users/foo/bar → -Users-foo-bar
+    /Users/foo/.config/bar → -Users-foo--config-bar (double dash for dot)
+
+This command returns the project directory path and metadata about session logs.
+
+Usage:
+    # Find project directory for current directory
+    erk exec find-project-dir
+
+    # Find project directory for specific path
+    erk exec find-project-dir --path /some/path
+
+    # JSON output for scripting
+    erk exec find-project-dir --json
+
+Output:
+    JSON object with success status and project information
+
+Exit Codes:
+    0: Success (project directory found)
+    1: Error (project directory not found or other error)
+
+Examples:
+    $ erk exec find-project-dir
+    {
+      "success": true,
+      "project_dir": "/Users/foo/.claude/projects/-Users-foo-code-erk",
+      "cwd": "/Users/foo/code/erk",
+      "encoded_path": "-Users-foo-code-erk",
+      "session_logs": ["abc123.jsonl", "agent-17cfd3f4.jsonl"],
+      "latest_session_id": "abc123"
+    }
+
+    $ erk exec find-project-dir --path /nonexistent
+    {
+      "success": false,
+      "error": "Project directory not found",
+      "help": "No Claude Code project found for /nonexistent",
+      "context": {
+        "path": "/nonexistent",
+        "encoded_path": "-nonexistent"
+      }
+    }
+"""
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import click
+
+from erk_shared.context.helpers import require_claude_installation
+from erk_shared.extraction.claude_installation import ClaudeInstallation
+
+
+@dataclass(frozen=True)
+class ProjectInfo:
+    """Success result with project information."""
+
+    success: bool
+    project_dir: str
+    cwd: str
+    encoded_path: str
+    session_logs: list[str]
+    latest_session_id: str | None
+
+
+@dataclass(frozen=True)
+class ProjectError:
+    """Error result when project directory not found."""
+
+    success: bool
+    error: str
+    help: str
+    context: dict[str, str]
+
+
+def encode_path_to_project_folder(path: Path) -> str:
+    """Encode filesystem path to Claude Code project folder name.
+
+    Claude Code uses a simple encoding scheme:
+    - Replace "/" with "-"
+    - Replace "." with "-"
+
+    This creates deterministic folder names in ~/.claude/projects/.
+
+    Args:
+        path: Filesystem path to encode
+
+    Returns:
+        Encoded path suitable for project folder name
+
+    Examples:
+        >>> encode_path_to_project_folder(Path("/Users/foo/bar"))
+        '-Users-foo-bar'
+        >>> encode_path_to_project_folder(Path("/Users/foo/.config"))
+        '-Users-foo--config'
+    """
+    return str(path).replace("/", "-").replace(".", "-")
+
+
+def find_project_info(path: Path, installation: ClaudeInstallation) -> ProjectInfo | ProjectError:
+    """Find Claude Code project directory and metadata for given path.
+
+    Args:
+        path: Filesystem path to find project for
+        installation: ClaudeInstallation gateway for accessing projects directory
+
+    Returns:
+        ProjectInfo on success, ProjectError if not found
+    """
+    projects_dir = installation.get_projects_dir_path()
+    if not installation.projects_dir_exists():
+        return ProjectError(
+            success=False,
+            error="Claude Code projects directory not found",
+            help="~/.claude/projects/ does not exist. Is Claude Code installed?",
+            context={
+                "path": str(path),
+                "projects_dir": str(projects_dir),
+            },
+        )
+
+    # Encode path and find project directory
+    encoded_path = encode_path_to_project_folder(path)
+    project_dir = projects_dir / encoded_path
+
+    if not project_dir.exists():
+        return ProjectError(
+            success=False,
+            error="Project directory not found",
+            help=f"No Claude Code project found for {path}",
+            context={
+                "path": str(path),
+                "encoded_path": encoded_path,
+                "expected_dir": str(project_dir),
+            },
+        )
+
+    # Find all session logs (main sessions and agent logs)
+    session_logs = []
+    latest_session: tuple[str, float] | None = None
+
+    for log_file in project_dir.iterdir():
+        if log_file.is_file() and log_file.suffix == ".jsonl":
+            session_logs.append(log_file.name)
+
+            # Track latest main session (not agent logs)
+            if not log_file.name.startswith("agent-"):
+                mtime = log_file.stat().st_mtime
+                if latest_session is None or mtime > latest_session[1]:
+                    # Extract session ID (filename without .jsonl)
+                    session_id = log_file.stem
+                    latest_session = (session_id, mtime)
+
+    # Sort logs for consistent output
+    session_logs.sort()
+
+    return ProjectInfo(
+        success=True,
+        project_dir=str(project_dir),
+        cwd=str(path),
+        encoded_path=encoded_path,
+        session_logs=session_logs,
+        latest_session_id=latest_session[0] if latest_session else None,
+    )
+
+
+@click.command(name="find-project-dir")
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Path to find project for (defaults to current directory)",
+)
+@click.option(
+    "--json",
+    "json_output",
+    is_flag=True,
+    help="Output in JSON format",
+)
+@click.pass_context
+def find_project_dir(ctx: click.Context, path: Path | None, json_output: bool) -> None:
+    """Find Claude Code project directory for a filesystem path.
+
+    This command maps filesystem paths to Claude Code project directories
+    in ~/.claude/projects/ using deterministic encoding rules.
+    """
+    installation = require_claude_installation(ctx)
+
+    # Default to current directory if no path specified
+    if path is None:
+        path = Path(os.getcwd())
+
+    # Find project information
+    result = find_project_info(path, installation)
+
+    # Always output JSON (the --json flag is for future extensibility)
+    click.echo(json.dumps(asdict(result), indent=2))
+
+    # Exit with error code if not found
+    if isinstance(result, ProjectError):
+        raise SystemExit(1)

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

@@ -0,0 +1,112 @@
+"""Generate PR summary from PR diff.
+
+This exec command generates a PR summary by analyzing the PR diff
+using Claude. It uses the same prompt as commit message generation but
+does NOT include commit messages (which may contain misleading info
+about .worker-impl/ deletions).
+
+This is used by the GitHub Actions workflow when updating PR bodies
+after implementation.
+
+Usage:
+    erk exec generate-pr-summary --pr-number 123
+
+Output:
+    PR summary text (title on first line, body follows)
+
+Exit Codes:
+    0: Success
+    1: Error (missing pr-number, no diff, Claude failure)
+
+Examples:
+    $ erk exec generate-pr-summary --pr-number 1895
+    Fix authentication flow for OAuth providers
+
+    This PR fixes the OAuth authentication flow...
+    ...
+"""
+
+import click
+
+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
+
+
+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, unlike
+    CommitMessageGenerator. 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:"""
+
+
+@click.command(name="generate-pr-summary")
+@click.option("--pr-number", type=int, required=True, help="PR number to summarize")
+@click.pass_context
+def generate_pr_summary(ctx: click.Context, pr_number: int) -> None:
+    """Generate PR summary from PR diff using Claude.
+
+    Analyzes the PR diff (what GitHub shows) and generates a summary.
+    Does NOT use commit messages, which may contain misleading info
+    about files that net to zero in the final diff.
+
+    Args:
+        pr_number: The PR number to analyze
+    """
+    repo_root = require_repo_root(ctx)
+    github = require_github(ctx)
+    git = require_git(ctx)
+    executor = require_prompt_executor(ctx)
+
+    # Get PR diff
+    try:
+        pr_diff = github.get_pr_diff(repo_root, pr_number)
+    except RuntimeError as e:
+        click.echo(f"Error: Failed to get PR diff: {e}", err=True)
+        raise SystemExit(1) from e
+
+    if not pr_diff.strip():
+        click.echo("Error: PR diff is empty", err=True)
+        raise SystemExit(1)
+
+    # Truncate if needed
+    diff_content, was_truncated = truncate_diff(pr_diff)
+    if was_truncated:
+        click.echo("Warning: Diff truncated for size", err=True)
+
+    # Get branch context using injected Git
+    current_branch = git.get_current_branch(repo_root) or f"pr-{pr_number}"
+    parent_branch = git.detect_trunk_branch(repo_root)
+
+    # Build prompt and run Claude via injected executor
+    prompt = _build_prompt(diff_content, current_branch, parent_branch)
+    result = executor.execute_prompt(prompt, model="haiku", cwd=repo_root)
+
+    if not result.success:
+        click.echo(f"Error: Claude execution failed: {result.error}", err=True)
+        raise SystemExit(1) from None
+
+    # Output the summary (no trailing newline, let caller handle formatting)
+    click.echo(result.output, nl=False)

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

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Get closing text for PR body based on .impl/issue.json or branch name.
+
+This command determines the issue number from .impl/issue.json or the branch
+name (P{issue_number}-... pattern) and outputs the appropriate closing text.
+
+Usage:
+    erk exec get-closing-text
+
+Output:
+    Plain text "Closes #N" (same-repo) or "Closes owner/repo#N" (cross-repo)
+    Empty output if no issue reference found
+
+Exit Codes:
+    0: Success (whether issue reference exists or not)
+    1: Error (branch/issue.json mismatch)
+
+Examples:
+    $ erk exec get-closing-text
+    Closes #776
+
+    $ erk exec get-closing-text  # Cross-repo plans
+    Closes owner/plans-repo#776
+
+    $ erk exec get-closing-text  # No .impl/issue.json but branch is P123-feature
+    Closes #123
+
+    $ erk exec get-closing-text  # No .impl/ and branch is feature-branch
+    (no output)
+"""
+
+from pathlib import Path
+
+import click
+
+from erk.cli.config import load_config
+from erk_shared.context.helpers import get_current_branch, require_cwd
+from erk_shared.impl_folder import validate_issue_linkage
+
+
+def _find_repo_root(start: Path) -> Path | None:
+    """Find repository root by looking for .git directory."""
+    current = start
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return None
+
+
+@click.command(name="get-closing-text")
+@click.pass_context
+def get_closing_text(ctx: click.Context) -> None:
+    """Get closing text for PR body based on .impl/issue.json or branch name.
+
+    Validates that branch name and .impl/issue.json agree (if both present).
+    Falls back to branch name if no .impl/ folder exists.
+
+    Outputs nothing and exits successfully if no issue number is discoverable.
+    """
+    cwd = require_cwd(ctx)
+
+    # Get current branch name for validation and fallback
+    branch_name = get_current_branch(ctx)
+    if branch_name is None:
+        # Not on a branch (detached HEAD) - can't determine issue number
+        return
+
+    # Check .impl/ first, then .worker-impl/
+    impl_dir = cwd / ".impl"
+    if not impl_dir.exists():
+        impl_dir = cwd / ".worker-impl"
+
+    # Validate linkage and get issue number (branch fallback if no .impl/)
+    try:
+        issue_number = validate_issue_linkage(impl_dir, branch_name)
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        raise SystemExit(1) from None
+
+    if issue_number is None:
+        # No issue to close (neither branch nor .impl/ has one)
+        return
+
+    # Load config to check for cross-repo plans
+    repo_root = _find_repo_root(cwd)
+    plans_repo: str | None = None
+    if repo_root is not None:
+        config = load_config(repo_root)
+        plans_repo = config.plans_repo
+
+    # Format closing text
+    if plans_repo is None:
+        closing_text = f"Closes #{issue_number}"
+    else:
+        closing_text = f"Closes {plans_repo}#{issue_number}"
+
+    click.echo(closing_text)

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

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Get embedded prompt content from bundled prompts.
+
+This command reads prompt files bundled with the erk package and outputs
+their content. Useful for GitHub Actions workflows that need prompt content.
+
+Usage:
+    erk exec get-embedded-prompt <prompt-name>
+
+Output:
+    The prompt content (markdown)
+
+Exit Codes:
+    0: Success
+    1: Prompt not found
+
+Examples:
+    $ erk exec get-embedded-prompt dignified-python-review
+    # Dignified Python Review Prompt
+    ...
+
+    $ erk exec get-embedded-prompt dignified-python-review > /tmp/prompt.md
+"""
+
+import click
+
+from erk.artifacts.sync import get_bundled_github_dir
+
+# Available prompts that can be retrieved
+AVAILABLE_PROMPTS = frozenset(
+    {
+        "ci-autofix",
+        "dignified-python-review",
+    }
+)
+
+
+@click.command(name="get-embedded-prompt")
+@click.argument("prompt_name")
+def get_embedded_prompt(prompt_name: str) -> None:
+    """Get embedded prompt content from bundled prompts.
+
+    Reads the specified prompt from the erk package's bundled prompts
+    and outputs its content to stdout.
+
+    PROMPT_NAME is the name of the prompt (without .md extension).
+    """
+    if prompt_name not in AVAILABLE_PROMPTS:
+        available = ", ".join(sorted(AVAILABLE_PROMPTS))
+        click.echo(f"Unknown prompt: {prompt_name}", err=True)
+        click.echo(f"Available prompts: {available}", err=True)
+        raise SystemExit(1)
+
+    bundled_github_dir = get_bundled_github_dir()
+    prompt_path = bundled_github_dir / "prompts" / f"{prompt_name}.md"
+
+    if not prompt_path.exists():
+        click.echo(f"Prompt file not found: {prompt_path}", err=True)
+        raise SystemExit(1)
+
+    content = prompt_path.read_text(encoding="utf-8")
+    click.echo(content, nl=False)