erk 0.4.5__py3-none-any.whl

erk/core/health_checks_dogfooder/outdated_erk_skill.py

@@ -0,0 +1,43 @@
+"""Check for outdated erk skill that should be deleted.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have removed the outdated .claude/skills/erk/ directory.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def check_outdated_erk_skill(repo_root: Path) -> CheckResult:
+    """Check for outdated erk skill directory that should be deleted.
+
+    The erk skill at .claude/skills/erk/ is outdated and no longer maintained.
+    Users should delete this directory.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult indicating whether outdated skill was found
+    """
+    skill_dir = repo_root / ".claude" / "skills" / "erk"
+    if not skill_dir.exists():
+        return CheckResult(
+            name="outdated-erk-skill",
+            passed=True,
+            message="No outdated erk skill found",
+        )
+
+    # Found outdated skill - return failure with remediation
+    return CheckResult(
+        name="outdated-erk-skill",
+        passed=False,
+        message="Outdated erk skill found at .claude/skills/erk/",
+        details=(
+            "The erk skill is outdated and should be deleted.\n"
+            "\n"
+            "Remediation:\n"
+            "  rm -rf .claude/skills/erk/"
+        ),
+    )

erk/core/implementation_queue/__init__.py

@@ -0,0 +1 @@
+"""Implementation queue core functionality."""

erk/core/implementation_queue/github/__init__.py

@@ -0,0 +1,8 @@
+"""GitHub integration for implementation queue operations.
+
+Import from submodules:
+- abc: GitHubAdmin
+- real: RealGitHubAdmin
+- noop: NoopGitHubAdmin
+- printing: PrintingGitHubAdmin
+"""

erk/core/implementation_queue/github/abc.py

@@ -0,0 +1,7 @@
+"""Abstract base class for GitHub Actions admin operations.
+
+Re-exports from erk_shared for backwards compatibility.
+"""
+
+from erk_shared.github_admin.abc import AuthStatus as AuthStatus
+from erk_shared.github_admin.abc import GitHubAdmin as GitHubAdmin

erk/core/implementation_queue/github/noop.py

@@ -0,0 +1,38 @@
+"""No-op wrapper for GitHub Actions admin operations."""
+
+from typing import Any
+
+from erk_shared.github.types import GitHubRepoLocation
+from erk_shared.github_admin.abc import AuthStatus, GitHubAdmin
+
+
+class NoopGitHubAdmin(GitHubAdmin):
+    """No-op wrapper for GitHub Actions admin operations.
+
+    Read operations are delegated to the wrapped implementation.
+    Write operations return without executing (no-op behavior).
+
+    This wrapper prevents destructive GitHub admin operations from executing
+    in dry-run mode, while still allowing read operations for validation.
+    """
+
+    def __init__(self, wrapped: GitHubAdmin) -> None:
+        """Initialize no-op wrapper with a real implementation.
+
+        Args:
+            wrapped: The real GitHubAdmin implementation to wrap
+        """
+        self._wrapped = wrapped
+
+    def get_workflow_permissions(self, location: GitHubRepoLocation) -> dict[str, Any]:
+        """Delegate read operation to wrapped implementation."""
+        return self._wrapped.get_workflow_permissions(location)
+
+    def set_workflow_pr_permissions(self, location: GitHubRepoLocation, enabled: bool) -> None:
+        """No-op for setting workflow permissions in dry-run mode."""
+        # Do nothing - prevents actual permission changes
+        pass
+
+    def check_auth_status(self) -> AuthStatus:
+        """Delegate read operation to wrapped implementation."""
+        return self._wrapped.check_auth_status()

erk/core/implementation_queue/github/printing.py

@@ -0,0 +1,43 @@
+"""Printing wrapper for GitHub Actions admin operations."""
+
+from typing import Any
+
+from erk_shared.github.types import GitHubRepoLocation
+from erk_shared.github_admin.abc import AuthStatus, GitHubAdmin
+from erk_shared.printing.base import PrintingBase
+
+
+class PrintingGitHubAdmin(PrintingBase, GitHubAdmin):
+    """Wrapper that prints operations before delegating to inner implementation.
+
+    This wrapper prints styled output for operations, then delegates to the
+    wrapped implementation (which could be Real or Noop).
+
+    Usage:
+        # For production
+        printing_admin = PrintingGitHubAdmin(real_admin, script_mode=False, dry_run=False)
+
+        # For dry-run
+        noop_inner = NoopGitHubAdmin(real_admin)
+        printing_admin = PrintingGitHubAdmin(noop_inner, script_mode=False, dry_run=True)
+    """
+
+    # Inherits __init__, _emit, and _format_command from PrintingBase
+
+    def get_workflow_permissions(self, location: GitHubRepoLocation) -> dict[str, Any]:
+        """Get workflow permissions (read-only, no printing)."""
+        return self._wrapped.get_workflow_permissions(location)
+
+    def set_workflow_pr_permissions(self, location: GitHubRepoLocation, enabled: bool) -> None:
+        """Set workflow PR permissions with printed output."""
+        self._emit(
+            self._format_command(
+                f"gh api --method PUT .../actions/permissions/workflow "
+                f"(can_approve_pull_request_reviews={str(enabled).lower()})"
+            )
+        )
+        self._wrapped.set_workflow_pr_permissions(location, enabled)
+
+    def check_auth_status(self) -> AuthStatus:
+        """Check auth status (read-only, no printing)."""
+        return self._wrapped.check_auth_status()

erk/core/implementation_queue/github/real.py

@@ -0,0 +1,119 @@
+"""Production implementation of GitHub Actions admin operations."""
+
+import json
+import subprocess
+from typing import Any
+
+from erk_shared.github.types import GitHubRepoLocation
+from erk_shared.github_admin.abc import AuthStatus, GitHubAdmin
+from erk_shared.subprocess_utils import run_subprocess_with_context
+
+
+class RealGitHubAdmin(GitHubAdmin):
+    """Production implementation using gh CLI.
+
+    All GitHub Actions admin operations execute actual gh commands via subprocess.
+    """
+
+    def get_workflow_permissions(self, location: GitHubRepoLocation) -> dict[str, Any]:
+        """Get current workflow permissions using gh CLI.
+
+        Args:
+            location: GitHub repository location (local root + repo identity)
+
+        Returns:
+            Dict with keys:
+            - default_workflow_permissions: "read" or "write"
+            - can_approve_pull_request_reviews: bool
+
+        Raises:
+            RuntimeError: If gh CLI command fails
+        """
+        repo_id = location.repo_id
+        # GH-API-AUDIT: REST - GET actions/permissions/workflow
+        cmd = [
+            "gh",
+            "api",
+            "-H",
+            "Accept: application/vnd.github+json",
+            "-H",
+            "X-GitHub-Api-Version: 2022-11-28",
+            f"/repos/{repo_id.owner}/{repo_id.repo}/actions/permissions/workflow",
+        ]
+
+        result = run_subprocess_with_context(
+            cmd,
+            operation_context=f"get workflow permissions for {repo_id.owner}/{repo_id.repo}",
+            cwd=location.root,
+        )
+
+        return json.loads(result.stdout)
+
+    def set_workflow_pr_permissions(self, location: GitHubRepoLocation, enabled: bool) -> None:
+        """Enable/disable PR creation via workflow permissions API.
+
+        Args:
+            location: GitHub repository location (local root + repo identity)
+            enabled: True to enable PR creation, False to disable
+
+        Raises:
+            RuntimeError: If gh CLI command fails
+        """
+        # CRITICAL: Must set both fields together
+        # - default_workflow_permissions: Keep as "read" (workflows declare their own)
+        # - can_approve_pull_request_reviews: This enables PR creation
+        repo_id = location.repo_id
+        # GH-API-AUDIT: REST - PUT actions/permissions/workflow
+        cmd = [
+            "gh",
+            "api",
+            "--method",
+            "PUT",
+            "-H",
+            "Accept: application/vnd.github+json",
+            "-H",
+            "X-GitHub-Api-Version: 2022-11-28",
+            f"/repos/{repo_id.owner}/{repo_id.repo}/actions/permissions/workflow",
+            "-f",
+            "default_workflow_permissions=read",
+            "-F",
+            f"can_approve_pull_request_reviews={str(enabled).lower()}",
+        ]
+
+        run_subprocess_with_context(
+            cmd,
+            operation_context=f"set workflow PR permissions for {repo_id.owner}/{repo_id.repo}",
+            cwd=location.root,
+        )
+
+    def check_auth_status(self) -> AuthStatus:
+        """Check GitHub CLI authentication status using gh auth status."""
+        try:
+            # GH-API-AUDIT: REST - auth validation
+            result = subprocess.run(
+                ["gh", "auth", "status"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                # Parse output to find username
+                # Format: "✓ Logged in to github.com account username (keyring)"
+                output = result.stdout.strip() or result.stderr.strip()
+                username = None
+                for line in output.split("\n"):
+                    if "Logged in to" in line and "account" in line:
+                        # Extract username from "... account username (...)"
+                        parts = line.split("account")
+                        if len(parts) > 1:
+                            username_part = parts[1].strip()
+                            username = username_part.split()[0] if username_part else None
+                        break
+                return AuthStatus(authenticated=True, username=username, error=None)
+            else:
+                return AuthStatus(authenticated=False, username=None, error=None)
+        except subprocess.TimeoutExpired:
+            return AuthStatus(authenticated=False, username=None, error="Auth check timed out")
+        except OSError as e:
+            return AuthStatus(authenticated=False, username=None, error=str(e))

erk/core/init_utils.py

@@ -0,0 +1,227 @@
+"""Pure business logic for init command operations.
+
+This module contains testable functions for detecting project configuration,
+discovering presets, and rendering templates, without I/O side effects.
+"""
+
+import re
+import tomllib
+from pathlib import Path
+
+
+def is_repo_erk_ified(repo_root: Path) -> bool:
+    """Check if a repository has been initialized with erk.
+
+    A repository is considered erk-ified if it has a .erk/config.toml file.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        True if .erk/config.toml exists, False otherwise
+
+    Example:
+        >>> repo_root = Path("/path/to/repo")
+        >>> is_repo_erk_ified(repo_root)
+        False
+    """
+    config_path = repo_root / ".erk" / "config.toml"
+    return config_path.exists()
+
+
+def detect_root_project_name(repo_root: Path) -> str | None:
+    """Return the declared project name at the repo root, if any.
+
+    Checks root `pyproject.toml`'s `[project].name`. If absent, tries to heuristically
+    extract from `setup.py` by matching `name="..."` or `name='...'`.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        Project name if found, None otherwise
+
+    Example:
+        >>> repo_root = Path("/path/to/repo")
+        >>> # Assuming pyproject.toml exists with [project] name = "my-project"
+        >>> detect_root_project_name(repo_root)
+        'my-project'
+    """
+    root_pyproject = repo_root / "pyproject.toml"
+    if root_pyproject.exists():
+        data = tomllib.loads(root_pyproject.read_text(encoding="utf-8"))
+        project = data.get("project") or {}
+        name = project.get("name")
+        if isinstance(name, str) and name:
+            return name
+
+    setup_py = repo_root / "setup.py"
+    if setup_py.exists():
+        text = setup_py.read_text(encoding="utf-8")
+        m = re.search(r"name\s*=\s*['\"]([^'\"]+)['\"]", text)
+        if m:
+            return m.group(1)
+
+    return None
+
+
+def is_repo_named(repo_root: Path, expected_name: str) -> bool:
+    """Return True if the root project name matches `expected_name` (case-insensitive).
+
+    Args:
+        repo_root: Path to the repository root
+        expected_name: Expected project name to match
+
+    Returns:
+        True if project name matches (case-insensitive), False otherwise
+
+    Example:
+        >>> repo_root = Path("/path/to/repo")
+        >>> is_repo_named(repo_root, "dagster")
+        True
+    """
+    name = detect_root_project_name(repo_root)
+    return (name or "").lower() == expected_name.lower()
+
+
+def discover_presets(presets_dir: Path) -> list[str]:
+    """Discover available preset names by scanning the presets directory.
+
+    Args:
+        presets_dir: Path to the directory containing preset files
+
+    Returns:
+        Sorted list of preset names (without .toml extension)
+
+    Example:
+        >>> presets_dir = Path("/path/to/erk/presets")
+        >>> discover_presets(presets_dir)
+        ['dagster', 'generic', 'python']
+    """
+    if not presets_dir.exists():
+        return []
+
+    return sorted(p.stem for p in presets_dir.glob("*.toml") if p.is_file())
+
+
+def render_config_template(presets_dir: Path, preset: str | None) -> str:
+    """Return default config TOML content, optionally using a preset.
+
+    If preset is None, uses the "generic" preset by default.
+
+    Args:
+        presets_dir: Path to the directory containing preset files
+        preset: Name of the preset to use, or None for "generic"
+
+    Returns:
+        Content of the preset file as a string
+
+    Raises:
+        ValueError: If the specified preset file doesn't exist
+
+    Example:
+        >>> presets_dir = Path("/path/to/erk/presets")
+        >>> content = render_config_template(presets_dir, "dagster")
+        >>> "trunk_branch" in content
+        True
+    """
+    preset_name = preset if preset is not None else "generic"
+    preset_file = presets_dir / f"{preset_name}.toml"
+
+    if not preset_file.exists():
+        raise ValueError(f"Preset '{preset_name}' not found at {preset_file}")
+
+    return preset_file.read_text(encoding="utf-8")
+
+
+def get_shell_wrapper_content(shell_integration_dir: Path, shell: str) -> str:
+    """Load the shell wrapper function for the given shell type.
+
+    Args:
+        shell_integration_dir: Path to the directory containing shell integration files
+        shell: Shell type (e.g., "zsh", "bash", "fish")
+
+    Returns:
+        Content of the shell wrapper file as a string
+
+    Raises:
+        ValueError: If the shell wrapper file doesn't exist for the given shell
+
+    Example:
+        >>> shell_dir = Path("/path/to/erk/shell_integration")
+        >>> content = get_shell_wrapper_content(shell_dir, "zsh")
+        >>> "function erk" in content
+        True
+    """
+    if shell == "fish":
+        wrapper_file = shell_integration_dir / "fish_wrapper.fish"
+    else:
+        wrapper_file = shell_integration_dir / f"{shell}_wrapper.sh"
+
+    if not wrapper_file.exists():
+        raise ValueError(f"Shell wrapper not found for {shell}")
+
+    return wrapper_file.read_text(encoding="utf-8")
+
+
+# Marker string that identifies erk shell integration in RC files
+ERK_SHELL_INTEGRATION_MARKER = "# Erk shell integration"
+
+
+def has_shell_integration_in_rc(rc_path: Path) -> bool:
+    """Check if shell RC file contains erk shell integration.
+
+    Looks for the marker comment that erk adds when shell integration is configured.
+
+    Args:
+        rc_path: Path to the shell RC file (e.g., ~/.zshrc)
+
+    Returns:
+        True if the marker is found in the file, False otherwise
+        (also returns False if file doesn't exist)
+
+    Example:
+        >>> rc_path = Path.home() / ".zshrc"
+        >>> has_shell_integration_in_rc(rc_path)
+        False
+    """
+    if not rc_path.exists():
+        return False
+
+    content = rc_path.read_text(encoding="utf-8")
+    return ERK_SHELL_INTEGRATION_MARKER in content
+
+
+def add_gitignore_entry(content: str, entry: str) -> str:
+    """Add an entry to gitignore content if not already present.
+
+    This is a pure function that returns the potentially modified content.
+    User confirmation should be handled by the caller.
+
+    Args:
+        content: Current gitignore content
+        entry: Entry to add (e.g., ".env")
+
+    Returns:
+        Updated gitignore content (original if entry already present)
+
+    Example:
+        >>> content = "*.pyc\\n"
+        >>> new_content = add_gitignore_entry(content, ".env")
+        >>> ".env" in new_content
+        True
+        >>> # Calling again should be idempotent
+        >>> newer_content = add_gitignore_entry(new_content, ".env")
+        >>> newer_content == new_content
+        True
+    """
+    # Entry already present
+    if entry in content:
+        return content
+
+    # Ensure trailing newline before adding
+    if not content.endswith("\n"):
+        content += "\n"
+
+    content += f"{entry}\n"
+    return content