erk 0.4.5__py3-none-any.whl

erk/status/models/status_data.py

@@ -0,0 +1,404 @@
+"""Data models for status information."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class WorktreeDisplayInfo:
+    """Worktree information for display/presentation purposes.
+
+    This represents worktree data for status rendering and display.
+    For infrastructure-layer worktree data, see erk.core.gitops.WorktreeInfo.
+    """
+
+    name: str
+    path: Path
+    branch: str | None
+    is_root: bool
+
+    @staticmethod
+    def root(path: Path, branch: str = "main", name: str = "root") -> WorktreeDisplayInfo:
+        """Create root worktree for test display.
+
+        Args:
+            path: Path to the root worktree
+            branch: Branch name (default: "main")
+            name: Display name (default: "root")
+
+        Returns:
+            WorktreeDisplayInfo with is_root=True
+
+        Example:
+            Before (4 lines):
+                worktree = WorktreeDisplayInfo(
+                    name="root", path=repo_root, branch="main", is_root=True
+                )
+
+            After (1 line):
+                worktree = WorktreeDisplayInfo.root(repo_root)
+        """
+        return WorktreeDisplayInfo(path=path, branch=branch, is_root=True, name=name)
+
+    @staticmethod
+    def feature(path: Path, branch: str, name: str | None = None) -> WorktreeDisplayInfo:
+        """Create feature worktree for test display.
+
+        Args:
+            path: Path to the feature worktree
+            branch: Branch name
+            name: Display name (default: uses path.name)
+
+        Returns:
+            WorktreeDisplayInfo with is_root=False
+
+        Example:
+            Before (4 lines):
+                worktree = WorktreeDisplayInfo(
+                    name="my-feature", path=feature_wt, branch="feature", is_root=False
+                )
+
+            After (1 line):
+                worktree = WorktreeDisplayInfo.feature(feature_wt, "feature")
+        """
+        display_name = name if name else path.name
+        return WorktreeDisplayInfo(path=path, branch=branch, is_root=False, name=display_name)
+
+
+@dataclass(frozen=True)
+class CommitInfo:
+    """Information about a git commit."""
+
+    sha: str
+    message: str
+    author: str
+    date: str
+
+    @staticmethod
+    def test_commit(
+        sha: str = "abc1234",
+        message: str = "Test commit",
+        author: str = "Test User",
+        date: str = "1 hour ago",
+    ) -> CommitInfo:
+        """Create a commit for tests with sensible defaults.
+
+        Args:
+            sha: Commit SHA (default: "abc1234")
+            message: Commit message (default: "Test commit")
+            author: Commit author (default: "Test User")
+            date: Commit date (default: "1 hour ago")
+
+        Returns:
+            CommitInfo with all fields populated
+
+        Example:
+            Before (5 lines):
+                recent_commits = [
+                    CommitInfo(sha="abc1234", message="Initial commit",
+                               author="Test User", date="1 hour ago"),
+                ]
+
+            After (1 line):
+                recent_commits = [CommitInfo.test_commit()]
+        """
+        return CommitInfo(sha=sha, message=message, author=author, date=date)
+
+
+@dataclass(frozen=True)
+class GitStatus:
+    """Git repository status information."""
+
+    branch: str | None
+    clean: bool
+    ahead: int
+    behind: int
+    staged_files: list[str]
+    modified_files: list[str]
+    untracked_files: list[str]
+    recent_commits: list[CommitInfo]
+
+    @staticmethod
+    def clean_status(branch: str, ahead: int = 0, behind: int = 0) -> GitStatus:
+        """Create clean status (no changes) for tests.
+
+        Args:
+            branch: Branch name
+            ahead: Commits ahead of remote (default: 0)
+            behind: Commits behind remote (default: 0)
+
+        Returns:
+            GitStatus with clean=True and empty file lists
+
+        Example:
+            Before (8 lines):
+                status = GitStatus(
+                    branch="test",
+                    clean=True,
+                    ahead=0,
+                    behind=0,
+                    staged_files=[],
+                    modified_files=[],
+                    untracked_files=[],
+                    recent_commits=[],
+                )
+
+            After (1 line):
+                status = GitStatus.clean_status("test")
+        """
+        return GitStatus(
+            branch=branch,
+            clean=True,
+            ahead=ahead,
+            behind=behind,
+            staged_files=[],
+            modified_files=[],
+            untracked_files=[],
+            recent_commits=[],
+        )
+
+    @staticmethod
+    def dirty_status(
+        branch: str,
+        *,
+        modified: list[str] | None = None,
+        staged: list[str] | None = None,
+        untracked: list[str] | None = None,
+        ahead: int = 0,
+        behind: int = 0,
+    ) -> GitStatus:
+        """Create dirty status (with changes) for tests.
+
+        Args:
+            branch: Branch name
+            modified: Modified files (default: [])
+            staged: Staged files (default: [])
+            untracked: Untracked files (default: [])
+            ahead: Commits ahead of remote (default: 0)
+            behind: Commits behind remote (default: 0)
+
+        Returns:
+            GitStatus with clean=False and specified file lists
+
+        Example:
+            Before (9 lines):
+                status = GitStatus(
+                    branch="feature",
+                    clean=False,
+                    ahead=0,
+                    behind=0,
+                    staged_files=[],
+                    modified_files=["file.py"],
+                    untracked_files=[],
+                    recent_commits=[],
+                )
+
+            After (1 line):
+                status = GitStatus.dirty_status("feature", modified=["file.py"])
+        """
+        return GitStatus(
+            branch=branch,
+            clean=False,
+            ahead=ahead,
+            behind=behind,
+            staged_files=staged or [],
+            modified_files=modified or [],
+            untracked_files=untracked or [],
+            recent_commits=[],
+        )
+
+    @staticmethod
+    def with_commits(branch: str, commits: list[CommitInfo], clean: bool = True) -> GitStatus:
+        """Create status with commit history for tests.
+
+        Args:
+            branch: Branch name
+            commits: List of recent commits
+            clean: Whether working tree is clean (default: True)
+
+        Returns:
+            GitStatus with commits populated
+
+        Example:
+            Before (9 lines):
+                status = GitStatus(
+                    branch="main",
+                    clean=True,
+                    ahead=0,
+                    behind=0,
+                    staged_files=[],
+                    modified_files=[],
+                    untracked_files=[],
+                    recent_commits=[commit1, commit2],
+                )
+
+            After (1 line):
+                status = GitStatus.with_commits("main", [commit1, commit2])
+        """
+        return GitStatus(
+            branch=branch,
+            clean=clean,
+            ahead=0,
+            behind=0,
+            staged_files=[],
+            modified_files=[],
+            untracked_files=[],
+            recent_commits=commits,
+        )
+
+
+@dataclass(frozen=True)
+class StackPosition:
+    """Worktree stack position information."""
+
+    stack: list[str]
+    current_branch: str
+    parent_branch: str | None
+    children_branches: list[str]
+    is_trunk: bool
+
+
+@dataclass(frozen=True)
+class PullRequestStatus:
+    """Pull request status information."""
+
+    number: int
+    title: str | None  # May not be available from all data sources
+    state: str
+    is_draft: bool
+    url: str
+    checks_passing: bool | None
+    reviews: list[str] | None  # May not be available from all data sources
+    ready_to_merge: bool
+
+
+@dataclass(frozen=True)
+class EnvironmentStatus:
+    """Environment variables status."""
+
+    variables: dict[str, str]
+
+
+@dataclass(frozen=True)
+class DependencyStatus:
+    """Dependency status for various language ecosystems."""
+
+    language: str
+    up_to_date: bool
+    outdated_count: int
+    details: str | None
+
+
+@dataclass(frozen=True)
+class PlanStatus:
+    """Status of .impl/ folder and enriched plans."""
+
+    exists: bool
+    path: Path | None
+    summary: str | None
+    line_count: int
+    first_lines: list[str]
+    format: str  # "folder" or "none"
+    enriched_plan_path: Path | None = None  # Path to enriched plan file
+    enriched_plan_filename: str | None = None  # Filename of enriched plan
+    issue_number: int | None = None  # GitHub issue number if linked
+    issue_url: str | None = None  # GitHub issue URL if linked
+
+
+@dataclass(frozen=True)
+class StatusData:
+    """Container for all status information."""
+
+    worktree_info: WorktreeDisplayInfo
+    git_status: GitStatus | None
+    stack_position: StackPosition | None
+    pr_status: PullRequestStatus | None
+    environment: EnvironmentStatus | None
+    dependencies: DependencyStatus | None
+    plan: PlanStatus | None
+    related_worktrees: list[WorktreeDisplayInfo]
+
+    @staticmethod
+    def minimal(worktree_info: WorktreeDisplayInfo) -> StatusData:
+        """Create minimal status data (all optional fields None) for tests.
+
+        Args:
+            worktree_info: Worktree display information
+
+        Returns:
+            StatusData with only worktree_info set, all other fields None/empty
+
+        Example:
+            Before (9 lines):
+                status_data = StatusData(
+                    worktree_info=WorktreeDisplayInfo(
+                        name="my-feature", path=wt_path, branch="feature", is_root=False
+                    ),
+                    git_status=None,
+                    stack_position=None,
+                    pr_status=None,
+                    environment=None,
+                    dependencies=None,
+                    plan=None,
+                    related_worktrees=[],
+                )
+
+            After (2 lines):
+                worktree_info = WorktreeDisplayInfo.feature(wt_path, "feature")
+                status_data = StatusData.minimal(worktree_info)
+        """
+        return StatusData(
+            worktree_info=worktree_info,
+            git_status=None,
+            stack_position=None,
+            pr_status=None,
+            environment=None,
+            dependencies=None,
+            plan=None,
+            related_worktrees=[],
+        )
+
+    @staticmethod
+    def with_git_status(worktree_info: WorktreeDisplayInfo, git_status: GitStatus) -> StatusData:
+        """Create status data with git status populated.
+
+        Args:
+            worktree_info: Worktree display information
+            git_status: Git status information
+
+        Returns:
+            StatusData with worktree_info and git_status set, other fields None/empty
+
+        Example:
+            Before (11 lines):
+                status_data = StatusData(
+                    worktree_info=WorktreeDisplayInfo(
+                        name="root", path=repo_root, branch="main", is_root=True
+                    ),
+                    git_status=GitStatus.clean_status("main"),
+                    stack_position=None,
+                    pr_status=None,
+                    environment=None,
+                    dependencies=None,
+                    plan=None,
+                    related_worktrees=[],
+                )
+
+            After (2 lines):
+                worktree_info = WorktreeDisplayInfo.root(repo_root)
+                status_data = StatusData.with_git_status(
+                    worktree_info, GitStatus.clean_status("main")
+                )
+        """
+        return StatusData(
+            worktree_info=worktree_info,
+            git_status=git_status,
+            stack_position=None,
+            pr_status=None,
+            environment=None,
+            dependencies=None,
+            plan=None,
+            related_worktrees=[],
+        )

erk/status/orchestrator.py

@@ -0,0 +1,169 @@
+"""Orchestrator for collecting and assembling status information."""
+
+import logging
+from collections.abc import Callable
+from pathlib import Path
+
+from erk.core.context import ErkContext
+from erk.status.collectors.base import StatusCollector
+from erk.status.models.status_data import StatusData, WorktreeDisplayInfo
+from erk_shared.gateway.parallel.abc import ParallelTaskRunner
+
+logger = logging.getLogger(__name__)
+
+
+class StatusOrchestrator:
+    """Coordinates all status collectors and assembles final data.
+
+    The orchestrator runs collectors in parallel with timeouts to ensure
+    responsive output even if some collectors are slow or fail.
+    """
+
+    def __init__(
+        self,
+        collectors: list[StatusCollector],
+        *,
+        timeout_seconds: float = 2.0,
+        runner: ParallelTaskRunner,
+    ) -> None:
+        """Create a status orchestrator.
+
+        Args:
+            collectors: List of status collectors to run
+            timeout_seconds: Maximum time to wait for each collector (default: 2.0)
+            runner: Parallel task runner for executing collectors
+        """
+        self.collectors = collectors
+        self.timeout_seconds = timeout_seconds
+        self.runner = runner
+
+    def collect_status(self, ctx: ErkContext, worktree_path: Path, repo_root: Path) -> StatusData:
+        """Collect all status information in parallel.
+
+        Each collector runs in its own thread with a timeout. Failed or slow
+        collectors will return None for their section.
+
+        Args:
+            ctx: Erk context with operations
+            worktree_path: Path to the worktree
+            repo_root: Path to repository root
+
+        Returns:
+            StatusData with all collected information
+        """
+        # Determine worktree info
+        worktree_info = self._get_worktree_info(ctx, worktree_path, repo_root)
+
+        # Build tasks for available collectors
+        tasks: dict[str, Callable[[], object]] = {}
+        for collector in self.collectors:
+            if collector.is_available(ctx, worktree_path):
+                # Create closure that captures current values
+                def make_task(c=collector):
+                    return lambda: c.collect(ctx, worktree_path, repo_root)
+
+                tasks[collector.name] = make_task()
+
+        # Run collectors in parallel via runner
+        results = self.runner.run_parallel(tasks, self.timeout_seconds)
+
+        # Get related worktrees
+        related_worktrees = self._get_related_worktrees(ctx, repo_root, worktree_path)
+
+        # Assemble StatusData - cast results to expected types
+        # Results are either the correct type or None (from collector failures)
+        from erk.status.models.status_data import (
+            DependencyStatus,
+            EnvironmentStatus,
+            GitStatus,
+            PlanStatus,
+            PullRequestStatus,
+            StackPosition,
+        )
+
+        git_result = results.get("git")
+        stack_result = results.get("stack")
+        pr_result = results.get("pr")
+        env_result = results.get("environment")
+        deps_result = results.get("dependencies")
+        plan_result = results.get("plan")
+
+        return StatusData(
+            worktree_info=worktree_info,
+            git_status=git_result if isinstance(git_result, GitStatus) else None,
+            stack_position=stack_result if isinstance(stack_result, StackPosition) else None,
+            pr_status=pr_result if isinstance(pr_result, PullRequestStatus) else None,
+            environment=env_result if isinstance(env_result, EnvironmentStatus) else None,
+            dependencies=deps_result if isinstance(deps_result, DependencyStatus) else None,
+            plan=plan_result if isinstance(plan_result, PlanStatus) else None,
+            related_worktrees=related_worktrees,
+        )
+
+    def _get_worktree_info(
+        self, ctx: ErkContext, worktree_path: Path, repo_root: Path
+    ) -> WorktreeDisplayInfo:
+        """Get basic worktree information.
+
+        Args:
+            ctx: Erk context
+            worktree_path: Path to worktree
+            repo_root: Path to repository root
+
+        Returns:
+            WorktreeDisplayInfo with basic information
+        """
+        # Check paths exist before resolution to avoid OSError
+        is_root = False
+        if worktree_path.exists() and repo_root.exists():
+            is_root = worktree_path.resolve() == repo_root.resolve()
+
+        name = "root" if is_root else worktree_path.name
+        branch = ctx.git.get_current_branch(worktree_path)
+
+        return WorktreeDisplayInfo(name=name, path=worktree_path, branch=branch, is_root=is_root)
+
+    def _get_related_worktrees(
+        self, ctx: ErkContext, repo_root: Path, current_path: Path
+    ) -> list[WorktreeDisplayInfo]:
+        """Get list of other worktrees in the repository.
+
+        Args:
+            ctx: Erk context
+            repo_root: Path to repository root
+            current_path: Path to current worktree (excluded from results)
+
+        Returns:
+            List of WorktreeDisplayInfo for other worktrees
+        """
+        worktrees = ctx.git.list_worktrees(repo_root)
+
+        # Check paths exist before resolution to avoid OSError
+        if not current_path.exists():
+            return []
+
+        current_resolved = current_path.resolve()
+
+        related = []
+        for wt in worktrees:
+            # Skip if worktree path doesn't exist
+            if not wt.path.exists():
+                continue
+
+            wt_resolved = wt.path.resolve()
+
+            # Skip current worktree
+            if wt_resolved == current_resolved:
+                continue
+
+            # Determine if this is the root worktree
+            is_root = False
+            if repo_root.exists():
+                is_root = wt_resolved == repo_root.resolve()
+
+            name = "root" if is_root else wt.path.name
+
+            related.append(
+                WorktreeDisplayInfo(name=name, path=wt.path, branch=wt.branch, is_root=is_root)
+            )
+
+        return related

erk/status/renderers/__init__.py

@@ -0,0 +1,5 @@
+"""Status renderers.
+
+Import from submodules:
+- simple: SimpleRenderer
+"""