erk 0.4.5__py3-none-any.whl

erk/status/collectors/git.py

@@ -0,0 +1,76 @@
+"""Git status collector."""
+
+from pathlib import Path
+
+from erk.core.context import ErkContext
+from erk.status.collectors.base import StatusCollector
+from erk.status.models.status_data import CommitInfo, GitStatus
+
+
+class GitStatusCollector(StatusCollector):
+    """Collects git repository status information."""
+
+    @property
+    def name(self) -> str:
+        """Name identifier for this collector."""
+        return "git"
+
+    def is_available(self, ctx: ErkContext, worktree_path: Path) -> bool:
+        """Check if git operations are available.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+
+        Returns:
+            True if worktree exists and has git
+        """
+        if not worktree_path.exists():
+            return False
+
+        return True
+
+    def collect(self, ctx: ErkContext, worktree_path: Path, repo_root: Path) -> GitStatus | None:
+        """Collect git status information.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+            repo_root: Repository root path
+
+        Returns:
+            GitStatus with repository information or None if collection fails
+        """
+        branch = ctx.git.get_current_branch(worktree_path)
+        if branch is None:
+            return None
+
+        # Get git status
+        staged, modified, untracked = ctx.git.get_file_status(worktree_path)
+        clean = len(staged) == 0 and len(modified) == 0 and len(untracked) == 0
+
+        # Get ahead/behind counts
+        ahead, behind = ctx.git.get_ahead_behind(worktree_path, branch)
+
+        # Get recent commits
+        commit_dicts = ctx.git.get_recent_commits(worktree_path, limit=5)
+        recent_commits = [
+            CommitInfo(
+                sha=c["sha"],
+                message=c["message"],
+                author=c["author"],
+                date=c["date"],
+            )
+            for c in commit_dicts
+        ]
+
+        return GitStatus(
+            branch=branch,
+            clean=clean,
+            ahead=ahead,
+            behind=behind,
+            staged_files=staged,
+            modified_files=modified,
+            untracked_files=untracked,
+            recent_commits=recent_commits,
+        )

erk/status/collectors/github.py

@@ -0,0 +1,81 @@
+"""GitHub PR collector."""
+
+from pathlib import Path
+
+from erk.core.context import ErkContext
+from erk.status.collectors.base import StatusCollector
+from erk.status.models.status_data import PullRequestStatus
+
+
+class GitHubPRCollector(StatusCollector):
+    """Collects GitHub pull request information."""
+
+    @property
+    def name(self) -> str:
+        """Name identifier for this collector."""
+        return "pr"
+
+    def is_available(self, ctx: ErkContext, worktree_path: Path) -> bool:
+        """Check if PR information should be fetched.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+
+        Returns:
+            True if PR info is enabled in config
+        """
+        if not (ctx.global_config and ctx.global_config.show_pr_info):
+            return False
+
+        if not worktree_path.exists():
+            return False
+
+        return True
+
+    def collect(
+        self, ctx: ErkContext, worktree_path: Path, repo_root: Path
+    ) -> PullRequestStatus | None:
+        """Collect GitHub PR information.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+            repo_root: Repository root path
+
+        Returns:
+            PullRequestStatus with PR information or None if collection fails
+        """
+        branch = ctx.git.get_current_branch(worktree_path)
+        if branch is None:
+            return None
+
+        # Always use Graphite (fast, no pagination issues)
+        prs = ctx.graphite.get_prs_from_graphite(ctx.git, repo_root)
+
+        # Fail fast if Graphite cache unavailable - no fallback to GitHub
+        if not prs:
+            return None
+
+        # Find PR for current branch
+        pr = prs.get(branch)
+        if pr is None:
+            return None
+
+        # Determine if ready to merge
+        ready_to_merge = (
+            pr.state == "OPEN"
+            and not pr.is_draft
+            and (pr.checks_passing is True or pr.checks_passing is None)
+        )
+
+        return PullRequestStatus(
+            number=pr.number,
+            title=None,  # Title not available in PullRequestInfo
+            state=pr.state,
+            is_draft=pr.is_draft,
+            url=pr.url,
+            checks_passing=pr.checks_passing,
+            reviews=None,  # Reviews not available in PullRequestInfo
+            ready_to_merge=ready_to_merge,
+        )

erk/status/collectors/graphite.py

@@ -0,0 +1,80 @@
+"""Worktree stack collector."""
+
+from pathlib import Path
+
+from erk.core.context import ErkContext
+from erk.status.collectors.base import StatusCollector
+from erk.status.models.status_data import StackPosition
+
+
+class GraphiteStackCollector(StatusCollector):
+    """Collects worktree stack position information."""
+
+    @property
+    def name(self) -> str:
+        """Name identifier for this collector."""
+        return "stack"
+
+    def is_available(self, ctx: ErkContext, worktree_path: Path) -> bool:
+        """Check if Graphite is enabled and available.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+
+        Returns:
+            True if Graphite is enabled
+        """
+        if not (ctx.global_config and ctx.global_config.use_graphite):
+            return False
+
+        if not worktree_path.exists():
+            return False
+
+        return True
+
+    def collect(
+        self, ctx: ErkContext, worktree_path: Path, repo_root: Path
+    ) -> StackPosition | None:
+        """Collect worktree stack information.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+            repo_root: Repository root path
+
+        Returns:
+            StackPosition with stack information or None if collection fails
+        """
+        branch = ctx.git.get_current_branch(worktree_path)
+        if branch is None:
+            return None
+
+        # Get the stack for current branch
+        stack = ctx.graphite.get_branch_stack(ctx.git, repo_root, branch)
+        if stack is None:
+            return None
+
+        # Find current branch position in stack
+        if branch not in stack:
+            return None
+
+        current_idx = stack.index(branch)
+
+        # Determine parent and children
+        parent_branch = stack[current_idx - 1] if current_idx > 0 else None
+
+        children_branches = []
+        if current_idx < len(stack) - 1:
+            children_branches.append(stack[current_idx + 1])
+
+        # Check if this is trunk
+        is_trunk = current_idx == 0
+
+        return StackPosition(
+            stack=stack,
+            current_branch=branch,
+            parent_branch=parent_branch,
+            children_branches=children_branches,
+            is_trunk=is_trunk,
+        )

erk/status/collectors/impl.py

@@ -0,0 +1,145 @@
+"""Implementation folder collector."""
+
+import logging
+from pathlib import Path
+
+import frontmatter
+
+from erk.core.context import ErkContext
+from erk.status.collectors.base import StatusCollector
+from erk.status.models.status_data import PlanStatus
+from erk_shared.impl_folder import (
+    get_impl_path,
+    read_issue_reference,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def detect_enriched_plan(repo_root: Path) -> tuple[Path | None, str | None]:
+    """Detect enriched plan file at repository root.
+
+    Scans for *-plan.md files and checks for erk_plan marker.
+
+    Args:
+        repo_root: Repository root path
+
+    Returns:
+        Tuple of (path, filename) or (None, None) if not found
+    """
+    if not repo_root.exists():
+        return None, None
+
+    # Find all *-plan.md files
+    plan_files = list(repo_root.glob("*-plan.md"))
+
+    if not plan_files:
+        return None, None
+
+    # Sort by modification time (most recent first)
+    plan_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+    # Check each file for enrichment marker
+    for plan_file in plan_files:
+        # Use frontmatter library to parse YAML frontmatter
+        post = frontmatter.load(str(plan_file))
+
+        # Check for enrichment marker (handles missing frontmatter gracefully)
+        if post.get("erk_plan") is True:
+            return plan_file, plan_file.name
+
+    return None, None
+
+
+class PlanFileCollector(StatusCollector):
+    """Collects information about .impl/ folder."""
+
+    @property
+    def name(self) -> str:
+        """Name identifier for this collector."""
+        return "plan"
+
+    def is_available(self, ctx: ErkContext, worktree_path: Path) -> bool:
+        """Check if .impl/plan.md exists.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+
+        Returns:
+            True if .impl/plan.md exists
+        """
+        impl_path = get_impl_path(worktree_path, git_ops=ctx.git)
+        return impl_path is not None
+
+    def collect(self, ctx: ErkContext, worktree_path: Path, repo_root: Path) -> PlanStatus | None:
+        """Collect implementation folder information.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+            repo_root: Repository root path
+
+        Returns:
+            PlanStatus with folder information or None if collection fails
+        """
+        impl_path = get_impl_path(worktree_path, git_ops=ctx.git)
+
+        # Detect enriched plan at repo root
+        enriched_plan_path, enriched_plan_filename = detect_enriched_plan(repo_root)
+
+        if impl_path is None:
+            return PlanStatus(
+                exists=False,
+                path=None,
+                summary=None,
+                line_count=0,
+                first_lines=[],
+                format="none",
+                enriched_plan_path=enriched_plan_path,
+                enriched_plan_filename=enriched_plan_filename,
+            )
+
+        # Read plan.md
+        content = impl_path.read_text(encoding="utf-8")
+        lines = content.splitlines()
+        line_count = len(lines)
+
+        # Get first 5 lines
+        first_lines = lines[:5] if len(lines) >= 5 else lines
+
+        # Extract summary from first few non-empty lines
+        summary_lines = []
+        for line in lines[:10]:  # Look at first 10 lines
+            stripped = line.strip()
+            if stripped and not stripped.startswith("#"):
+                summary_lines.append(stripped)
+                if len(summary_lines) >= 2:
+                    break
+
+        summary = " ".join(summary_lines) if summary_lines else None
+
+        # Truncate summary if too long
+        if summary and len(summary) > 100:
+            summary = summary[:97] + "..."
+
+        # Return folder path, not plan.md file path
+        impl_folder = worktree_path / ".impl"
+
+        # Read issue reference if present
+        issue_ref = read_issue_reference(impl_folder)
+        issue_number = issue_ref.issue_number if issue_ref else None
+        issue_url = issue_ref.issue_url if issue_ref else None
+
+        return PlanStatus(
+            exists=True,
+            path=impl_folder,
+            summary=summary,
+            line_count=line_count,
+            first_lines=first_lines,
+            format="folder",
+            enriched_plan_path=enriched_plan_path,
+            enriched_plan_filename=enriched_plan_filename,
+            issue_number=issue_number,
+            issue_url=issue_url,
+        )

erk/status/models/__init__.py

@@ -0,0 +1,4 @@
+"""Data models for status command.
+
+Import from status_data submodule.
+"""