claudechic 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

claudechic/widgets/layout/processes.py

@@ -0,0 +1,68 @@
+"""Process panel widget for displaying background processes."""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Static
+
+from claudechic.processes import BackgroundProcess
+
+
+class ProcessItem(Static):
+    """Single process item with PID and command."""
+
+    can_focus = False
+
+    def __init__(self, process: BackgroundProcess) -> None:
+        super().__init__()
+        self.process = process
+
+    def render(self) -> Text:
+        # Show running indicator and truncated command
+        cmd = self.process.command
+        if len(cmd) > 20:
+            cmd = cmd[:19] + "…"
+        return Text.assemble(("● ", "yellow"), (cmd, ""))
+
+
+class ProcessPanel(Widget):
+    """Sidebar panel for background processes."""
+
+    DEFAULT_CSS = """
+    ProcessPanel {
+        width: 100%;
+        height: auto;
+        max-height: 30%;
+        border-top: solid $panel;
+        padding: 1;
+    }
+    ProcessPanel.hidden {
+        display: none;
+    }
+    ProcessPanel .process-title {
+        color: $text-muted;
+        text-style: bold;
+        padding: 0 0 1 0;
+    }
+    ProcessItem {
+        height: 1;
+    }
+    """
+
+    can_focus = False
+
+    def compose(self) -> ComposeResult:
+        yield Static("Processes", classes="process-title")
+
+    def update_processes(self, processes: list[BackgroundProcess]) -> None:
+        """Replace processes with new list."""
+        # Remove old items
+        for item in self.query(ProcessItem):
+            item.remove()
+
+        # Add new items
+        for proc in processes:
+            self.mount(ProcessItem(proc))
+
+        # Show/hide based on whether we have processes
+        self.set_class(len(processes) == 0, "hidden")

claudechic/widgets/{agents.py → layout/sidebar.py}

@@ -1,5 +1,6 @@
 """Agent sidebar widget for multi-agent management."""
 
+import time
 from pathlib import Path
 
 from textual.app import ComposeResult
@@ -7,19 +8,111 @@ from textual.events import Click
 from textual.message import Message
 from textual.reactive import reactive
 from textual.widget import Widget
-from textual.widgets import Static
+from textual.widgets import Static, Label, ListItem
 from rich.text import Text
 
 from claudechic.enums import AgentStatus
-from claudechic.cursor import ClickableMixin
-from claudechic.widgets.button import Button
+from claudechic.widgets.base.cursor import ClickableMixin, PointerMixin
+from claudechic.widgets.primitives.button import Button
+
+
+class SidebarItem(Widget, ClickableMixin):
+    """Base class for clickable sidebar items."""
+
+    DEFAULT_CSS = """
+    SidebarItem {
+        height: 3;
+        min-height: 3;
+        padding: 1 1 1 2;
+    }
+    SidebarItem.compact {
+        height: 1;
+        min-height: 1;
+        padding: 0 1 0 2;
+    }
+    SidebarItem:hover {
+        background: $surface-lighten-1;
+    }
+    """
+
+    max_name_length: int = 16
+
+    def truncate_name(self, name: str) -> str:
+        """Truncate name with ellipsis if too long."""
+        if len(name) > self.max_name_length:
+            return name[: self.max_name_length - 1] + "…"
+        return name
+
+
+class SidebarSection(Widget):
+    """Base component for sidebar sections with a title and items."""
+
+    DEFAULT_CSS = """
+    SidebarSection {
+        width: 100%;
+        height: auto;
+        padding: 0;
+    }
+    SidebarSection .section-title {
+        color: $text-muted;
+        text-style: bold;
+        padding: 1 1 1 1;
+    }
+    SidebarSection.hidden {
+        display: none;
+    }
+    """
+
+    def __init__(self, title: str, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._title, classes="section-title")
+
+
+def _format_time_ago(mtime: float) -> str:
+    """Format a timestamp as relative time (e.g., '2 hours ago')."""
+    delta = time.time() - mtime
+    if delta < 60:
+        return "just now"
+    elif delta < 3600:
+        mins = int(delta / 60)
+        return f"{mins} min{'s' if mins != 1 else ''} ago"
+    elif delta < 86400:
+        hours = int(delta / 3600)
+        return f"{hours} hour{'s' if hours != 1 else ''} ago"
+    elif delta < 604800:
+        days = int(delta / 86400)
+        return f"{days} day{'s' if days != 1 else ''} ago"
+    else:
+        weeks = int(delta / 604800)
+        return f"{weeks} week{'s' if weeks != 1 else ''} ago"
+
+
+class SessionItem(ListItem, PointerMixin):
+    """A session in the session picker sidebar."""
+
+    def __init__(
+        self, session_id: str, title: str, mtime: float, msg_count: int = 0
+    ) -> None:
+        super().__init__()
+        self.session_id = session_id
+        self.title = title
+        self.mtime = mtime
+        self.msg_count = msg_count
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.title, classes="session-preview")
+        time_ago = _format_time_ago(self.mtime)
+        yield Label(f"{time_ago} · {self.msg_count} msgs", classes="session-meta")
 
 
 class HamburgerButton(Button):
     """Floating hamburger button for narrow screens."""
 
-    class Clicked(Message):
-        """Posted when hamburger is clicked."""
+    class SidebarToggled(Message):
+        """Posted when hamburger is pressed to toggle sidebar."""
 
         pass
 
@@ -56,43 +149,64 @@ class HamburgerButton(Button):
         return "Agents"
 
     def on_click(self, event) -> None:
-        self.post_message(self.Clicked())
+        self.post_message(self.SidebarToggled())
 
 
-class PlanButton(Button):
-    """Button to open the current session's plan file."""
+class PlanItem(SidebarItem):
+    """Clickable plan item that opens the plan file."""
 
-    class Clicked(Message):
-        """Posted when plan button is clicked."""
+    class PlanRequested(Message):
+        """Posted when plan item is clicked."""
 
         def __init__(self, plan_path: Path) -> None:
             self.plan_path = plan_path
             super().__init__()
 
-    DEFAULT_CSS = """
-    PlanButton {
-        height: 3;
-        min-height: 3;
-        padding: 1 1 1 2;
-        dock: bottom;
-    }
-    PlanButton:hover {
-        background: $surface-lighten-1;
-    }
-    """
+    max_name_length: int = 18
 
     def __init__(self, plan_path: Path) -> None:
         super().__init__()
         self.plan_path = plan_path
 
     def render(self) -> Text:
-        return Text.assemble(("📋", ""), " ", ("Plan", "dim"))
+        name = self.truncate_name(self.plan_path.name)
+        return Text.assemble(("📋", ""), " ", (name, ""))
 
     def on_click(self, event) -> None:
-        self.post_message(self.Clicked(self.plan_path))
+        self.post_message(self.PlanRequested(self.plan_path))
+
+
+class PlanSection(SidebarSection):
+    """Sidebar section for plan files."""
+
+    DEFAULT_CSS = """
+    PlanSection {
+        border-top: solid $panel;
+    }
+    """
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__("Plan", *args, **kwargs)
+        self._plan_item: PlanItem | None = None
 
-class WorktreeItem(Widget, ClickableMixin):
+    def set_plan(self, plan_path: Path | None) -> None:
+        """Show or hide the plan."""
+        if plan_path:
+            if self._plan_item is None:
+                self._plan_item = PlanItem(plan_path)
+                self.mount(self._plan_item)
+            else:
+                self._plan_item.plan_path = plan_path
+                self._plan_item.refresh()
+            self.remove_class("hidden")
+        else:
+            if self._plan_item is not None:
+                self._plan_item.remove()
+                self._plan_item = None
+            self.add_class("hidden")
+
+
+class WorktreeItem(SidebarItem):
     """A ghost worktree in the sidebar (not yet an agent)."""
 
     class Selected(Message):
@@ -103,33 +217,20 @@ class WorktreeItem(Widget, ClickableMixin):
             self.path = path
             super().__init__()
 
-    DEFAULT_CSS = """
-    WorktreeItem {
-        height: 3;
-        min-height: 3;
-        padding: 1 1 1 2;
-    }
-    WorktreeItem:hover {
-        background: $surface-lighten-1;
-    }
-    """
-
     def __init__(self, branch: str, path: Path) -> None:
         super().__init__()
         self.branch = branch
         self.path = path
 
     def render(self) -> Text:
-        name = self.branch
-        if len(name) > 16:
-            name = name[:15] + "…"
+        name = self.truncate_name(self.branch)
         return Text.assemble(("◌", ""), " ", (name, "dim"))
 
     def on_click(self, event) -> None:
         self.post_message(self.Selected(self.branch, self.path))
 
 
-class AgentItem(Widget, ClickableMixin):
+class AgentItem(SidebarItem):
     """A single agent in the sidebar."""
 
     class Selected(Message):
@@ -148,18 +249,16 @@ class AgentItem(Widget, ClickableMixin):
 
     DEFAULT_CSS = """
     AgentItem {
-        height: 3;
-        padding: 1 1 1 2;
         layout: horizontal;
     }
-    AgentItem:hover {
-        background: $surface-lighten-1;
-    }
     AgentItem.active {
         padding: 1 1 1 1;
         border-left: wide $primary;
         background: $surface;
     }
+    AgentItem.active.compact {
+        padding: 0 1 0 1;
+    }
     AgentItem .agent-label {
         width: 1fr;
         height: 1;
@@ -181,6 +280,8 @@ class AgentItem(Widget, ClickableMixin):
     }
     """
 
+    max_name_length: int = 14
+
     status: reactive[AgentStatus] = reactive(AgentStatus.IDLE)
 
     def __init__(
@@ -205,9 +306,7 @@ class AgentItem(Widget, ClickableMixin):
         else:
             indicator = "\u25cb"
             style = "dim"
-        name = self.display_name
-        if len(name) > 14:
-            name = name[:13] + "…"
+        name = self.truncate_name(self.display_name)
         return Text.assemble((indicator, style), " ", (name, ""))
 
     def watch_status(self, _status: str) -> None:
@@ -227,31 +326,22 @@ class AgentItem(Widget, ClickableMixin):
             self.post_message(self.Selected(self.agent_id))
 
 
-class AgentSidebar(Widget):
-    """Sidebar showing all agents with status indicators."""
-
-    DEFAULT_CSS = """
-    AgentSidebar {
-        width: 24;
-        height: 100%;
-        padding: 0;
-        overflow-y: auto;
-    }
-    AgentSidebar .sidebar-title {
-        color: $text-muted;
-        text-style: bold;
-        padding: 1 1 1 1;
-    }
-    """
+class AgentSection(SidebarSection):
+    """Sidebar section showing all agents with status indicators."""
 
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
+        super().__init__("Agents", *args, **kwargs)
         self._agents: dict[str, AgentItem] = {}
         self._worktrees: dict[str, WorktreeItem] = {}  # branch -> item
-        self._plan_button: PlanButton | None = None
 
-    def compose(self) -> ComposeResult:
-        yield Static("Agents", classes="sidebar-title")
+    def _update_compact_mode(self) -> None:
+        """Apply compact mode when there are many items."""
+        total = len(self._agents) + len(self._worktrees)
+        compact = total > 6
+        for item in self._agents.values():
+            item.set_class(compact, "compact")
+        for item in self._worktrees.values():
+            item.set_class(compact, "compact")
 
     def add_agent(
         self, agent_id: str, name: str, status: AgentStatus = AgentStatus.IDLE
@@ -264,15 +354,18 @@ class AgentSidebar(Widget):
             self._worktrees[name].remove()
             del self._worktrees[name]
         item = AgentItem(agent_id, name, status)
-        item.id = f"agent-{agent_id}"
+        # Sanitize for Textual ID (no slashes allowed)
+        item.id = f"agent-{agent_id.replace('/', '-')}"
         self._agents[agent_id] = item
         self.mount(item)
+        self._update_compact_mode()
 
     def remove_agent(self, agent_id: str) -> None:
         """Remove an agent from the sidebar."""
         if agent_id in self._agents:
             self._agents[agent_id].remove()
             del self._agents[agent_id]
+            self._update_compact_mode()
 
     def set_active(self, agent_id: str) -> None:
         """Mark an agent as active (selected)."""
@@ -299,23 +392,11 @@ class AgentSidebar(Widget):
         item.id = f"worktree-{branch}"
         self._worktrees[branch] = item
         self.mount(item)
+        self._update_compact_mode()
 
     def remove_worktree(self, branch: str) -> None:
         """Remove a ghost worktree from the sidebar."""
         if branch in self._worktrees:
             self._worktrees[branch].remove()
             del self._worktrees[branch]
-
-    def set_plan(self, plan_path: Path | None) -> None:
-        """Show or hide the plan button."""
-        if plan_path:
-            if self._plan_button is None:
-                self._plan_button = PlanButton(plan_path)
-                self._plan_button.id = "plan-button"
-                self.mount(self._plan_button)
-            else:
-                self._plan_button.plan_path = plan_path
-        else:
-            if self._plan_button is not None:
-                self._plan_button.remove()
-                self._plan_button = None
+            self._update_compact_mode()

claudechic/widgets/modals/__init__.py

@@ -0,0 +1,9 @@
+"""Modal screen widgets."""
+
+from claudechic.widgets.modals.profile import ProfileModal
+from claudechic.widgets.modals.process_modal import ProcessModal
+
+__all__ = [
+    "ProfileModal",
+    "ProcessModal",
+]

claudechic/widgets/modals/process_modal.py

@@ -0,0 +1,121 @@
+"""Process list modal."""
+
+from datetime import datetime
+
+from rich.table import Table
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button
+
+from claudechic.processes import BackgroundProcess
+
+
+def _format_duration(start_time: datetime) -> str:
+    """Format duration since start_time."""
+    delta = datetime.now() - start_time
+    secs = int(delta.total_seconds())
+    if secs < 60:
+        return f"{secs}s"
+    elif secs < 3600:
+        return f"{secs // 60}m {secs % 60}s"
+    else:
+        hours = secs // 3600
+        mins = (secs % 3600) // 60
+        return f"{hours}h {mins}m"
+
+
+def _get_process_table(processes: list[BackgroundProcess]) -> Table:
+    """Build a table of running processes."""
+    table = Table(
+        box=None,
+        padding=(0, 2),
+        collapse_padding=True,
+        show_header=True,
+    )
+    table.add_column("PID", justify="right", style="dim")
+    table.add_column("Command")
+    table.add_column("Duration", justify="right", style="dim")
+
+    for proc in processes:
+        cmd = proc.command
+        if len(cmd) > 50:
+            cmd = cmd[:47] + "..."
+        table.add_row(str(proc.pid), cmd, _format_duration(proc.start_time))
+
+    return table
+
+
+class ProcessModal(ModalScreen):
+    """Modal showing running background processes."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close"),
+    ]
+
+    DEFAULT_CSS = """
+    ProcessModal {
+        align: center middle;
+    }
+
+    ProcessModal #process-container {
+        width: auto;
+        min-width: 50;
+        max-width: 80%;
+        height: auto;
+        max-height: 60%;
+        background: $surface;
+        border: solid $panel;
+        padding: 1 2;
+    }
+
+    ProcessModal #process-header {
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    ProcessModal #process-title {
+        width: 1fr;
+    }
+
+    ProcessModal #process-content {
+        height: auto;
+    }
+
+    ProcessModal #process-footer {
+        height: 1;
+        margin-top: 1;
+        align: center middle;
+    }
+
+    ProcessModal #close-btn {
+        min-width: 10;
+    }
+    """
+
+    def __init__(self, processes: list[BackgroundProcess]) -> None:
+        super().__init__()
+        self._processes = processes
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="process-container"):
+            with Horizontal(id="process-header"):
+                yield Static(
+                    "[bold]Background Processes[/]", id="process-title", markup=True
+                )
+            if self._processes:
+                yield Static(_get_process_table(self._processes), id="process-content")
+            else:
+                yield Static(
+                    "[dim]No background processes running.[/]",
+                    id="process-content",
+                    markup=True,
+                )
+            with Horizontal(id="process-footer"):
+                yield Button("Close", id="close-btn")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "close-btn":
+            self.dismiss()

claudechic/widgets/{profile_modal.py → modals/profile.py}

@@ -1,6 +1,5 @@
 """Profile statistics modal."""
 
-import pyperclip
 from rich.table import Table
 
 from textual.app import ComposeResult
@@ -186,6 +185,8 @@ class ProfileModal(ModalScreen):
     def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id == "copy-btn":
             try:
+                import pyperclip
+
                 text = get_stats_text() + "\n" + _get_sampling_text()
                 pyperclip.copy(text)
                 self.notify("Copied to clipboard")

claudechic/widgets/primitives/__init__.py

@@ -0,0 +1,13 @@
+"""Primitive building-block widgets."""
+
+from claudechic.widgets.primitives.button import Button
+from claudechic.widgets.primitives.collapsible import QuietCollapsible
+from claudechic.widgets.primitives.scroll import AutoHideScroll
+from claudechic.widgets.primitives.spinner import Spinner
+
+__all__ = [
+    "Button",
+    "QuietCollapsible",
+    "AutoHideScroll",
+    "Spinner",
+]

claudechic/widgets/{button.py → primitives/button.py}

@@ -3,7 +3,7 @@
 from textual.message import Message
 from textual.widgets import Static
 
-from claudechic.cursor import ClickableMixin
+from claudechic.widgets.base.cursor import ClickableMixin
 
 
 class Button(Static, ClickableMixin):

claudechic/widgets/{collapsible.py → primitives/collapsible.py}

@@ -2,13 +2,17 @@
 
 from textual.widgets import Collapsible
 
+from claudechic.widgets.base.cursor import ClickableMixin
 
-class QuietCollapsible(Collapsible):
+
+class QuietCollapsible(Collapsible, ClickableMixin):
     """Collapsible that doesn't scroll itself into view on toggle.
 
     The default Textual Collapsible calls scroll_visible() whenever it's
     toggled, which causes scroll jumping in chat interfaces where we want
     to control scrolling ourselves (e.g., tail-following new content).
+
+    Also shows pointer cursor to indicate clickability.
     """
 
     def _watch_collapsed(self, collapsed: bool) -> None:

claudechic/widgets/{scroll.py → primitives/scroll.py}

@@ -13,6 +13,8 @@ class AutoHideScroll(VerticalScroll):
     only when user explicitly scrolls to bottom.
     """
 
+    can_focus = False
+
     DEFAULT_CSS = """
     AutoHideScroll {
         scrollbar-size-vertical: 1;