erk 0.4.5__py3-none-any.whl

erk/tui/commands/__init__.py

@@ -0,0 +1 @@
+"""Command palette module for erk dash TUI."""

erk/tui/commands/executor.py

@@ -0,0 +1,66 @@
+"""Abstract interface for executing palette commands."""
+
+from abc import ABC, abstractmethod
+
+
+class CommandExecutor(ABC):
+    """Abstract interface for executing palette commands.
+
+    This ABC defines the operations that commands can perform.
+    Real and fake implementations handle the actual execution.
+    """
+
+    @abstractmethod
+    def open_url(self, url: str) -> None:
+        """Open URL in browser.
+
+        Args:
+            url: The URL to open
+        """
+        ...
+
+    @abstractmethod
+    def copy_to_clipboard(self, text: str) -> None:
+        """Copy text to clipboard.
+
+        Args:
+            text: The text to copy
+        """
+        ...
+
+    @abstractmethod
+    def close_plan(self, issue_number: int, issue_url: str) -> list[int]:
+        """Close plan and linked PRs.
+
+        Args:
+            issue_number: The issue number to close
+            issue_url: The issue URL for PR linkage lookup
+
+        Returns:
+            List of PR numbers that were also closed
+        """
+        ...
+
+    @abstractmethod
+    def notify(self, message: str) -> None:
+        """Show notification to user.
+
+        Args:
+            message: The message to display
+        """
+        ...
+
+    @abstractmethod
+    def refresh_data(self) -> None:
+        """Trigger data refresh."""
+        ...
+
+    @abstractmethod
+    def submit_to_queue(self, issue_number: int, issue_url: str) -> None:
+        """Submit plan to queue for remote AI implementation.
+
+        Args:
+            issue_number: The issue number to submit
+            issue_url: The issue URL for repository context
+        """
+        ...

erk/tui/commands/provider.py

@@ -0,0 +1,165 @@
+"""Command provider for Textual command palette."""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING
+
+from textual.command import DiscoveryHit, Hit, Hits, Provider
+
+from erk.tui.commands.registry import get_available_commands
+from erk.tui.commands.types import CommandContext
+
+if TYPE_CHECKING:
+    from erk.tui.app import ErkDashApp, PlanDetailScreen
+
+
+class MainListCommandProvider(Provider):
+    """Command provider for main plan list view.
+
+    Provides commands for the currently selected plan row directly from main list.
+    """
+
+    @property
+    def _app(self) -> ErkDashApp:
+        """Get the ErkDashApp instance.
+
+        Returns:
+            The ErkDashApp instance
+
+        Raises:
+            AssertionError: If app is not ErkDashApp
+        """
+        from erk.tui.app import ErkDashApp
+
+        app = self.app
+        if not isinstance(app, ErkDashApp):
+            msg = f"MainListCommandProvider expected ErkDashApp, got {type(app)}"
+            raise AssertionError(msg)
+        return app
+
+    def _get_context(self) -> CommandContext | None:
+        """Build command context from selected row.
+
+        Returns:
+            CommandContext if a row is selected, None otherwise
+        """
+        row = self._app._get_selected_row()
+        if row is None:
+            return None
+        return CommandContext(row=row)
+
+    async def discover(self) -> Hits:
+        """Show available commands when palette opens.
+
+        Yields:
+            DiscoveryHit for each available command
+        """
+        ctx = self._get_context()
+        if ctx is None:
+            return
+
+        for cmd in get_available_commands(ctx):
+            shortcut = f" [{cmd.shortcut}]" if cmd.shortcut else ""
+            yield DiscoveryHit(
+                f"{cmd.name}{shortcut}",
+                partial(self._app.execute_palette_command, cmd.id),
+                help=cmd.description,
+            )
+
+    async def search(self, query: str) -> Hits:
+        """Fuzzy search commands.
+
+        Args:
+            query: The search query from user input
+
+        Yields:
+            Hit for each matching command, with fuzzy match score
+        """
+        ctx = self._get_context()
+        if ctx is None:
+            return
+
+        matcher = self.matcher(query)
+
+        for cmd in get_available_commands(ctx):
+            score = matcher.match(cmd.name)
+            if score > 0:
+                shortcut = f" [{cmd.shortcut}]" if cmd.shortcut else ""
+                yield Hit(
+                    score,
+                    matcher.highlight(f"{cmd.name}{shortcut}"),
+                    partial(self._app.execute_palette_command, cmd.id),
+                    help=cmd.description,
+                )
+
+
+class PlanCommandProvider(Provider):
+    """Command provider for plan detail modal.
+
+    Provides commands specific to the selected plan via Textual's command palette.
+    """
+
+    @property
+    def _detail_screen(self) -> PlanDetailScreen:
+        """Get the PlanDetailScreen from current screen context.
+
+        Returns:
+            The PlanDetailScreen instance
+
+        Raises:
+            AssertionError: If not called from a PlanDetailScreen
+        """
+        from erk.tui.app import PlanDetailScreen
+
+        screen = self.screen
+        if not isinstance(screen, PlanDetailScreen):
+            msg = f"PlanCommandProvider expected PlanDetailScreen, got {type(screen)}"
+            raise AssertionError(msg)
+        return screen
+
+    def _get_context(self) -> CommandContext:
+        """Build command context from current screen state.
+
+        Returns:
+            CommandContext with the selected plan's row data
+        """
+        return CommandContext(row=self._detail_screen._row)
+
+    async def discover(self) -> Hits:
+        """Show available commands when palette opens.
+
+        Yields:
+            DiscoveryHit for each available command
+        """
+        ctx = self._get_context()
+        for cmd in get_available_commands(ctx):
+            shortcut = f" [{cmd.shortcut}]" if cmd.shortcut else ""
+            yield DiscoveryHit(
+                f"{cmd.name}{shortcut}",
+                partial(self._detail_screen.execute_command, cmd.id),
+                help=cmd.description,
+            )
+
+    async def search(self, query: str) -> Hits:
+        """Fuzzy search commands.
+
+        Args:
+            query: The search query from user input
+
+        Yields:
+            Hit for each matching command, with fuzzy match score
+        """
+        matcher = self.matcher(query)
+        ctx = self._get_context()
+
+        for cmd in get_available_commands(ctx):
+            score = matcher.match(cmd.name)
+            if score > 0:
+                shortcut = f" [{cmd.shortcut}]" if cmd.shortcut else ""
+                yield Hit(
+                    score,
+                    matcher.highlight(f"{cmd.name}{shortcut}"),
+                    partial(self._detail_screen.execute_command, cmd.id),
+                    help=cmd.description,
+                )

erk/tui/commands/real_executor.py

@@ -0,0 +1,63 @@
+"""Real implementation of CommandExecutor for production use."""
+
+from collections.abc import Callable
+from typing import Any
+
+from erk.tui.commands.executor import CommandExecutor
+
+
+class RealCommandExecutor(CommandExecutor):
+    """Production executor using injected dependencies.
+
+    Uses callables for each operation to decouple from concrete implementations.
+    """
+
+    def __init__(
+        self,
+        browser_launch: Callable[[str], Any],
+        clipboard_copy: Callable[[str], Any],
+        close_plan_fn: Callable[[int, str], list[int]],
+        notify_fn: Callable[[str], None],
+        refresh_fn: Callable[[], None],
+        submit_to_queue_fn: Callable[[int, str], None],
+    ) -> None:
+        """Initialize with dependency functions.
+
+        Args:
+            browser_launch: Function to launch URL in browser (return value ignored)
+            clipboard_copy: Function to copy text to clipboard (return value ignored)
+            close_plan_fn: Function to close plan and linked PRs
+            notify_fn: Function to show notification
+            refresh_fn: Function to trigger data refresh
+            submit_to_queue_fn: Function to submit plan to implementation queue
+        """
+        self._browser_launch = browser_launch
+        self._clipboard_copy = clipboard_copy
+        self._close_plan_fn = close_plan_fn
+        self._notify_fn = notify_fn
+        self._refresh_fn = refresh_fn
+        self._submit_to_queue_fn = submit_to_queue_fn
+
+    def open_url(self, url: str) -> None:
+        """Open URL in browser."""
+        self._browser_launch(url)
+
+    def copy_to_clipboard(self, text: str) -> None:
+        """Copy text to clipboard."""
+        self._clipboard_copy(text)
+
+    def close_plan(self, issue_number: int, issue_url: str) -> list[int]:
+        """Close plan and linked PRs."""
+        return self._close_plan_fn(issue_number, issue_url)
+
+    def notify(self, message: str) -> None:
+        """Show notification to user."""
+        self._notify_fn(message)
+
+    def refresh_data(self) -> None:
+        """Trigger data refresh."""
+        self._refresh_fn()
+
+    def submit_to_queue(self, issue_number: int, issue_url: str) -> None:
+        """Submit plan to implementation queue."""
+        self._submit_to_queue_fn(issue_number, issue_url)

erk/tui/commands/registry.py

@@ -0,0 +1,121 @@
+"""Command registry for command palette.
+
+This module defines all available commands and their availability predicates.
+Commands are organized by category: Actions, Opens, Copies.
+"""
+
+from erk.tui.commands.types import CommandContext, CommandDefinition
+
+
+def get_all_commands() -> list[CommandDefinition]:
+    """Return all command definitions.
+
+    Commands are ordered by category:
+    1. Actions (mutative operations)
+    2. Opens (browser navigation)
+    3. Copies (clipboard operations)
+
+    Returns:
+        List of all available command definitions
+    """
+    return [
+        # === ACTIONS ===
+        CommandDefinition(
+            id="close_plan",
+            name="Action: Close Plan",
+            description="Close issue and linked PRs",
+            shortcut=None,
+            is_available=lambda _: True,
+        ),
+        CommandDefinition(
+            id="submit_to_queue",
+            name="Action: Submit to Queue",
+            description="Submit plan for remote AI implementation",
+            shortcut="s",
+            is_available=lambda ctx: ctx.row.issue_url is not None,
+        ),
+        # === OPENS ===
+        CommandDefinition(
+            id="open_browser",
+            name="Open: In Browser",
+            description="Open PR (or issue if no PR)",
+            shortcut="o",
+            is_available=lambda ctx: bool(ctx.row.pr_url or ctx.row.issue_url),
+        ),
+        CommandDefinition(
+            id="open_issue",
+            name="Open: Issue",
+            description="Open issue in browser",
+            shortcut="i",
+            is_available=lambda ctx: ctx.row.issue_url is not None,
+        ),
+        CommandDefinition(
+            id="open_pr",
+            name="Open: PR",
+            description="Open PR in browser",
+            shortcut="p",
+            is_available=lambda ctx: ctx.row.pr_url is not None,
+        ),
+        CommandDefinition(
+            id="open_run",
+            name="Open: Workflow Run",
+            description="Open GitHub Actions run",
+            shortcut="r",
+            is_available=lambda ctx: ctx.row.run_url is not None,
+        ),
+        # === COPIES ===
+        CommandDefinition(
+            id="copy_checkout",
+            name="Copy: erk co <worktree>",
+            description="Copy checkout command",
+            shortcut="c",
+            is_available=lambda ctx: ctx.row.exists_locally,
+        ),
+        CommandDefinition(
+            id="copy_pr_checkout",
+            name="Copy: erk pr co <number>",
+            description="Copy PR checkout command",
+            shortcut="e",
+            is_available=lambda ctx: ctx.row.pr_number is not None,
+        ),
+        CommandDefinition(
+            id="copy_implement",
+            name="Copy: erk implement",
+            description="Copy implement command",
+            shortcut="1",
+            is_available=lambda _: True,
+        ),
+        CommandDefinition(
+            id="copy_implement_dangerous",
+            name="Copy: erk implement --dangerous",
+            description="Copy dangerous implement command",
+            shortcut="2",
+            is_available=lambda _: True,
+        ),
+        CommandDefinition(
+            id="copy_implement_yolo",
+            name="Copy: erk implement --yolo",
+            description="Copy yolo implement command",
+            shortcut="3",
+            is_available=lambda _: True,
+        ),
+        CommandDefinition(
+            id="copy_submit",
+            name="Copy: erk plan submit",
+            description="Copy submit command",
+            shortcut="4",
+            is_available=lambda _: True,
+        ),
+    ]
+
+
+def get_available_commands(ctx: CommandContext) -> list[CommandDefinition]:
+    """Return commands available in current context.
+
+    Args:
+        ctx: Command context containing the plan row data
+
+    Returns:
+        List of commands that are available for the given context
+    """
+    return [cmd for cmd in get_all_commands() if cmd.is_available(ctx)]

erk/tui/commands/types.py

@@ -0,0 +1,36 @@
+"""Data types for command palette."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from erk.tui.data.types import PlanRowData
+
+
+@dataclass(frozen=True)
+class CommandContext:
+    """Context available to commands.
+
+    Attributes:
+        row: The plan row data for the selected plan
+    """
+
+    row: PlanRowData
+
+
+@dataclass(frozen=True)
+class CommandDefinition:
+    """Definition of a command in the command palette.
+
+    Attributes:
+        id: Unique identifier for the command (e.g., "close_plan")
+        name: Display name (e.g., "Close Plan")
+        description: Brief description of what the command does
+        shortcut: Optional keyboard shortcut for display (e.g., "c")
+        is_available: Predicate function to check if command is available
+    """
+
+    id: str
+    name: str
+    description: str
+    shortcut: str | None
+    is_available: Callable[[CommandContext], bool]

erk/tui/data/__init__.py

@@ -0,0 +1 @@
+"""Data providers and types for TUI components."""