erk 0.4.5__py3-none-any.whl

erk/tui/jsonl_viewer/app.py

@@ -0,0 +1,61 @@
+"""Main Textual application for JSONL viewer."""
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Header
+
+from erk.tui.jsonl_viewer.models import parse_jsonl_file
+from erk.tui.jsonl_viewer.widgets import CustomListView, JsonlEntryItem
+
+
+class JsonlViewerApp(App):
+    """Interactive TUI for viewing JSONL files."""
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("escape", "quit", "Quit"),
+        Binding("j", "cursor_down", "Down", show=False),
+        Binding("k", "cursor_up", "Up", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    JsonlViewerApp {
+        background: $surface;
+    }
+
+    ListView {
+        height: 1fr;
+    }
+
+    ListView > ListItem.--highlight {
+        background: $primary-darken-2;
+    }
+    """
+
+    def __init__(self, jsonl_path: Path) -> None:
+        """Initialize with path to JSONL file.
+
+        Args:
+            jsonl_path: Path to the JSONL file to view
+        """
+        super().__init__()
+        self._jsonl_path = jsonl_path
+        self._entries = parse_jsonl_file(jsonl_path)
+
+    def compose(self) -> ComposeResult:
+        """Create application layout."""
+        yield Header(show_clock=False)
+        yield CustomListView(*[JsonlEntryItem(entry) for entry in self._entries])
+        yield Footer()
+
+    def action_cursor_down(self) -> None:
+        """Move cursor down (vim j key)."""
+        list_view = self.query_one(CustomListView)
+        list_view.action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        """Move cursor up (vim k key)."""
+        list_view = self.query_one(CustomListView)
+        list_view.action_cursor_up()

erk/tui/jsonl_viewer/models.py

@@ -0,0 +1,208 @@
+"""Data models for JSONL viewer."""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class JsonlEntry:
+    """Represents a single entry from a JSONL file."""
+
+    line_number: int
+    entry_type: str
+    role: str | None
+    tool_name: str | None
+    raw_json: str
+    parsed: dict
+
+
+def extract_tool_name(entry: dict) -> str | None:
+    """Extract tool name from tool_use content blocks.
+
+    Args:
+        entry: Parsed JSON entry
+
+    Returns:
+        Tool name if found, None otherwise
+    """
+    message = entry.get("message")
+    if not isinstance(message, dict):
+        return None
+
+    content = message.get("content")
+    if not isinstance(content, list):
+        return None
+
+    # Find first tool_use block
+    for block in content:
+        if isinstance(block, dict) and block.get("type") == "tool_use":
+            name = block.get("name")
+            if isinstance(name, str):
+                return name
+
+    return None
+
+
+def format_summary(entry: JsonlEntry) -> str:
+    """Format entry summary for display.
+
+    Format: [line#] type | tool_name?
+
+    Args:
+        entry: JSONL entry to format
+
+    Returns:
+        Formatted summary string
+    """
+    line_str = f"[{entry.line_number:>4}]"
+
+    parts = [line_str, entry.entry_type]
+    if entry.tool_name:
+        parts.append(entry.tool_name)
+
+    return " | ".join(parts)
+
+
+def _interpret_escape_sequences(text: str) -> str:
+    """Convert literal escape sequences to actual characters.
+
+    Converts \\n, \\t, \\r to their actual character equivalents.
+
+    Args:
+        text: Text with literal escape sequences
+
+    Returns:
+        Text with actual newlines, tabs, carriage returns
+    """
+    return text.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r")
+
+
+def _format_as_yaml_like(value: object, indent: int = 0) -> str:
+    """Format a value in YAML-like style for readability.
+
+    Args:
+        value: Value to format (dict, list, str, int, float, bool, None)
+        indent: Current indentation level
+
+    Returns:
+        Formatted string representation
+    """
+    prefix = "  " * indent
+
+    if value is None:
+        return "null"
+
+    if isinstance(value, bool):
+        return "true" if value else "false"
+
+    if isinstance(value, (int, float)):
+        return str(value)
+
+    if isinstance(value, str):
+        # Interpret escape sequences - no additional formatting for strings
+        return _interpret_escape_sequences(value)
+
+    if isinstance(value, list):
+        if not value:
+            return "[]"
+        lines = []
+        for item in value:
+            formatted_item = _format_as_yaml_like(item, indent + 1)
+            if "\n" in formatted_item:
+                # Multi-line item
+                first_line, *rest = formatted_item.split("\n")
+                lines.append(f"{prefix}- {first_line}")
+                lines.extend(rest)
+            else:
+                lines.append(f"{prefix}- {formatted_item}")
+        return "\n".join(lines)
+
+    if isinstance(value, dict):
+        if not value:
+            return "{}"
+        lines = []
+        for k, v in value.items():
+            formatted_v = _format_as_yaml_like(v, indent + 1)
+            if "\n" in formatted_v:
+                # Multi-line value
+                first_line, *rest = formatted_v.split("\n")
+                lines.append(f"{prefix}{k}: {first_line}")
+                lines.extend(rest)
+            else:
+                lines.append(f"{prefix}{k}: {formatted_v}")
+        return "\n".join(lines)
+
+    # Fallback for unknown types
+    return str(value)
+
+
+def format_entry_detail(entry: JsonlEntry, formatted: bool = True) -> str:
+    """Format entry detail for display.
+
+    Args:
+        entry: JSONL entry to format
+        formatted: If True, use YAML-like formatting. If False, use raw JSON.
+
+    Returns:
+        Formatted string representation
+    """
+    if not formatted:
+        return entry.raw_json
+
+    return _format_as_yaml_like(entry.parsed)
+
+
+def parse_jsonl_file(path: Path) -> list[JsonlEntry]:
+    """Parse JSONL file into list of entries.
+
+    Skips empty lines and malformed JSON.
+
+    Args:
+        path: Path to JSONL file
+
+    Returns:
+        List of parsed entries
+    """
+    entries: list[JsonlEntry] = []
+    content = path.read_text(encoding="utf-8")
+
+    for line_number, line in enumerate(content.splitlines(), start=1):
+        stripped = line.strip()
+        if not stripped:
+            continue
+
+        try:
+            parsed = json.loads(stripped)
+        except json.JSONDecodeError:
+            continue
+
+        if not isinstance(parsed, dict):
+            continue
+
+        entry_type = parsed.get("type", "unknown")
+        if not isinstance(entry_type, str):
+            entry_type = "unknown"
+
+        # Extract role from message if present
+        role: str | None = None
+        message = parsed.get("message")
+        if isinstance(message, dict):
+            msg_role = message.get("role")
+            if isinstance(msg_role, str):
+                role = msg_role
+
+        tool_name = extract_tool_name(parsed)
+
+        entries.append(
+            JsonlEntry(
+                line_number=line_number,
+                entry_type=entry_type,
+                role=role,
+                tool_name=tool_name,
+                raw_json=stripped,
+                parsed=parsed,
+            )
+        )
+
+    return entries

erk/tui/jsonl_viewer/widgets.py

@@ -0,0 +1,204 @@
+"""Widgets for JSONL viewer."""
+
+import json
+
+from rich.markup import escape as escape_markup
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widgets import Label, ListItem, ListView, Static
+
+from erk.tui.jsonl_viewer.models import JsonlEntry, format_entry_detail, format_summary
+
+
+class JsonlEntryItem(ListItem):
+    """Expandable JSONL entry with summary and JSON detail."""
+
+    DEFAULT_CSS = """
+    JsonlEntryItem {
+        height: auto;
+        padding: 0 1;
+    }
+
+    JsonlEntryItem .entry-summary {
+        height: 1;
+    }
+
+    JsonlEntryItem .entry-summary-user {
+        color: #58a6ff;
+    }
+
+    JsonlEntryItem .entry-summary-assistant {
+        color: #7ee787;
+    }
+
+    JsonlEntryItem .entry-summary-tool-result {
+        color: #ffa657;
+    }
+
+    JsonlEntryItem .entry-summary-other {
+        color: $text-muted;
+    }
+
+    JsonlEntryItem .json-detail {
+        display: none;
+        padding: 1;
+        background: $surface-darken-1;
+        overflow-x: auto;
+    }
+
+    JsonlEntryItem.expanded .json-detail {
+        display: block;
+    }
+
+    JsonlEntryItem.selected {
+        background: $accent;
+    }
+
+    JsonlEntryItem.selected .entry-summary {
+        color: $text;
+    }
+    """
+
+    def __init__(self, entry: JsonlEntry) -> None:
+        """Initialize with JSONL entry.
+
+        Args:
+            entry: The JSONL entry to display
+        """
+        super().__init__()
+        self._entry = entry
+        self._expanded = False
+
+    def compose(self) -> ComposeResult:
+        """Create widget content."""
+        summary = format_summary(self._entry)
+
+        # Determine style class based on entry type
+        entry_type = self._entry.entry_type
+        if entry_type == "user":
+            style_class = "entry-summary entry-summary-user"
+        elif entry_type == "assistant":
+            style_class = "entry-summary entry-summary-assistant"
+        elif entry_type == "tool_result":
+            style_class = "entry-summary entry-summary-tool-result"
+        else:
+            style_class = "entry-summary entry-summary-other"
+
+        yield Label(escape_markup(summary), classes=style_class)
+
+        # Pretty-printed JSON detail (hidden by default)
+        # Use markup=False to avoid Rich interpreting brackets as markup tags
+        pretty_json = json.dumps(self._entry.parsed, indent=2)
+        with Vertical(classes="json-detail"):
+            yield Static(pretty_json, markup=False)
+
+    def toggle_expand(self) -> None:
+        """Toggle expand/collapse state."""
+        self._expanded = not self._expanded
+        if self._expanded:
+            self.add_class("expanded")
+        else:
+            self.remove_class("expanded")
+        # Ensure the widget is updated
+        self.refresh()
+
+    def set_expanded(self, expanded: bool) -> None:
+        """Set expand state explicitly.
+
+        Args:
+            expanded: Whether to expand (True) or collapse (False)
+        """
+        self._expanded = expanded
+        if expanded:
+            self.add_class("expanded")
+        else:
+            self.remove_class("expanded")
+        self.refresh()
+
+    def is_expanded(self) -> bool:
+        """Return current expanded state."""
+        return self._expanded
+
+    def update_format(self, formatted: bool) -> None:
+        """Update the JSON detail display format.
+
+        Args:
+            formatted: If True, use YAML-like format. If False, use raw JSON.
+        """
+        detail_container = self.query_one(".json-detail", Vertical)
+        static = detail_container.query_one(Static)
+        content = format_entry_detail(self._entry, formatted=formatted)
+        # No escape_markup needed - Static widget has markup=False
+        static.update(content)
+
+
+class CustomListView(ListView):
+    """Custom ListView with expand/collapse keybinding."""
+
+    BINDINGS = [
+        Binding("enter", "toggle_expand", "Expand/Collapse"),
+        Binding("f", "toggle_format", "Format"),
+    ]
+
+    def __init__(self, *children: ListItem) -> None:
+        """Initialize with format and expand mode state.
+
+        Args:
+            children: List items to include in the view
+        """
+        super().__init__(*children)
+        self._formatted_mode = True
+        self._expand_mode = False
+        self._expanded_item: JsonlEntryItem | None = None
+
+    def action_toggle_expand(self) -> None:
+        """Toggle expand/collapse for selected entry."""
+        highlighted = self.highlighted_child
+        if isinstance(highlighted, JsonlEntryItem):
+            highlighted.toggle_expand()
+            # Track expand mode
+            self._expand_mode = highlighted.is_expanded()
+            self._expanded_item = highlighted if self._expand_mode else None
+
+    def action_toggle_format(self) -> None:
+        """Toggle format mode between formatted and raw JSON."""
+        self._formatted_mode = not self._formatted_mode
+        # Update all items with new format
+        for child in self.children:
+            if isinstance(child, JsonlEntryItem):
+                child.update_format(self._formatted_mode)
+
+    def watch_index(self, old_index: int | None, new_index: int | None) -> None:
+        """Handle index changes for sticky expand mode and selection styling.
+
+        Args:
+            old_index: Previous highlighted index (None if no previous selection)
+            new_index: New highlighted index (None if no selection)
+        """
+        # Update selection styling
+        if old_index is not None and old_index >= 0 and old_index < len(self.children):
+            old_child = self.children[old_index]
+            if isinstance(old_child, JsonlEntryItem):
+                old_child.remove_class("selected")
+
+        if new_index is not None and new_index >= 0 and new_index < len(self.children):
+            new_child = self.children[new_index]
+            if isinstance(new_child, JsonlEntryItem):
+                new_child.add_class("selected")
+
+                # Sticky expand mode: maintain expand state when navigating
+                if self._expand_mode and self._expanded_item is not None:
+                    # Collapse previous expanded item
+                    self._expanded_item.set_expanded(False)
+                    # Expand new item
+                    new_child.set_expanded(True)
+                    self._expanded_item = new_child
+
+    def _on_list_item__child_clicked(self, event: ListItem._ChildClicked) -> None:
+        """Disable mouse clicks for item selection.
+
+        We want keyboard-only navigation for this viewer.
+        """
+        event.prevent_default()
+        event.stop()

erk/tui/sorting/__init__.py

@@ -0,0 +1,6 @@
+"""Sorting module for TUI dashboard."""
+
+from erk.tui.sorting.logic import sort_plans
+from erk.tui.sorting.types import BranchActivity, SortKey, SortState
+
+__all__ = ["BranchActivity", "SortKey", "SortState", "sort_plans"]

erk/tui/sorting/logic.py

@@ -0,0 +1,55 @@
+"""Pure sorting logic for TUI dashboard."""
+
+from datetime import datetime
+
+from erk.tui.data.types import PlanRowData
+from erk.tui.sorting.types import BranchActivity, SortKey
+
+
+def sort_plans(
+    plans: list[PlanRowData],
+    sort_key: SortKey,
+    activity_by_issue: dict[int, BranchActivity] | None = None,
+) -> list[PlanRowData]:
+    """Sort plans by the given key.
+
+    Args:
+        plans: List of plans to sort
+        sort_key: Which field to sort by
+        activity_by_issue: Mapping of issue number to branch activity data.
+            Required when sort_key is BRANCH_ACTIVITY.
+
+    Returns:
+        Sorted list of plans. Original list is not modified.
+    """
+    if sort_key == SortKey.ISSUE_NUMBER:
+        # Sort by issue number descending (newest first)
+        return sorted(plans, key=lambda p: p.issue_number, reverse=True)
+
+    if sort_key == SortKey.BRANCH_ACTIVITY:
+        # Sort by most recent commit on branch
+        # Plans with recent activity first, no activity at end
+        activity_map = activity_by_issue or {}
+
+        def get_activity_key(plan: PlanRowData) -> tuple[bool, datetime]:
+            """Return sort key tuple: (has_activity, timestamp).
+
+            Returns tuple where:
+            - has_activity: True if there's branch activity (so it sorts first)
+            - timestamp: The activity timestamp (or min datetime for no activity)
+            """
+            activity = activity_map.get(plan.issue_number)
+            if activity is None or activity.last_commit_at is None:
+                # No activity - sort to end with very old date
+                return (False, datetime.min)
+            return (True, activity.last_commit_at)
+
+        # Sort: has_activity=True first, then by timestamp descending (newest first)
+        return sorted(
+            plans,
+            key=get_activity_key,
+            reverse=True,
+        )
+
+    # Default fallback: return as-is
+    return list(plans)

erk/tui/sorting/types.py

@@ -0,0 +1,68 @@
+"""Sort state types for TUI dashboard."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum, auto
+
+
+class SortKey(Enum):
+    """Available sort keys for plan list."""
+
+    ISSUE_NUMBER = auto()  # Default: sort by issue number (descending)
+    BRANCH_ACTIVITY = auto()  # Sort by most recent commit on branch
+
+
+@dataclass(frozen=True)
+class BranchActivity:
+    """Branch activity data for a plan.
+
+    Represents the most recent commit on the branch (not in trunk),
+    indicating how recently the branch was worked on.
+
+    Attributes:
+        last_commit_at: Timestamp of most recent commit on branch, None if no commits
+        last_commit_author: Author of most recent commit, None if no commits
+    """
+
+    last_commit_at: datetime | None
+    last_commit_author: str | None
+
+    @staticmethod
+    def empty() -> BranchActivity:
+        """Create empty activity (no commits on branch)."""
+        return BranchActivity(last_commit_at=None, last_commit_author=None)
+
+
+@dataclass(frozen=True)
+class SortState:
+    """State for sort mode.
+
+    Attributes:
+        key: Current sort key
+    """
+
+    key: SortKey
+
+    @staticmethod
+    def initial() -> SortState:
+        """Create initial state with default sort (by issue number)."""
+        return SortState(key=SortKey.ISSUE_NUMBER)
+
+    def toggle(self) -> SortState:
+        """Toggle between sort keys.
+
+        Returns:
+            New state with next sort key
+        """
+        if self.key == SortKey.ISSUE_NUMBER:
+            return SortState(key=SortKey.BRANCH_ACTIVITY)
+        return SortState(key=SortKey.ISSUE_NUMBER)
+
+    @property
+    def display_label(self) -> str:
+        """Get display label for current sort mode."""
+        if self.key == SortKey.ISSUE_NUMBER:
+            return "by issue#"
+        return "by recent activity"

erk/tui/styles/dash.tcss

@@ -0,0 +1,95 @@
+/* Styles for erk dash interactive TUI */
+
+Screen {
+    background: $surface;
+}
+
+/* Plan table styling */
+PlanDataTable {
+    height: 1fr;
+    margin: 1 2;
+}
+
+PlanDataTable > .datatable--header {
+    background: $primary;
+    color: $text;
+    text-style: bold;
+}
+
+PlanDataTable > .datatable--cursor {
+    background: $accent;
+    color: $text;
+}
+
+PlanDataTable > .datatable--hover {
+    background: $surface-lighten-1;
+}
+
+/* Status bar styling */
+StatusBar {
+    dock: bottom;
+    height: 1;
+    background: $primary-background;
+    color: $text-muted;
+    padding: 0 1;
+}
+
+/* Help overlay styling */
+#help-container {
+    align: center middle;
+}
+
+#help-panel {
+    width: 60;
+    height: auto;
+    max-height: 80%;
+    background: $surface;
+    border: solid $primary;
+    padding: 1 2;
+}
+
+#help-title {
+    text-style: bold;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#help-content {
+    height: auto;
+}
+
+/* Loading indicator */
+#loading {
+    align: center middle;
+    height: 100%;
+    width: 100%;
+}
+
+#loading-message {
+    text-align: center;
+    color: $text-muted;
+}
+
+/* Header styling */
+#header {
+    dock: top;
+    height: 1;
+    background: $primary;
+    color: $text;
+    text-style: bold;
+    content-align: center middle;
+}
+
+/* Filter input styling - positioned above status bar */
+#filter-input {
+    dock: bottom;
+    height: 3;
+    display: none;
+    background: $primary;
+    border: solid $accent;
+    padding: 0 1;
+}
+
+#filter-input.visible {
+    display: block;
+}

erk/tui/widgets/__init__.py

@@ -0,0 +1 @@
+"""TUI widgets for erk dashboard."""