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

claudechic/widgets/{chat.py → content/message.py}

@@ -4,76 +4,17 @@ import re
 import time
 from pathlib import Path
 
-import pyperclip
-
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
 from textual.message import Message
 from textual.widgets import Markdown, TextArea, Static
 
-from claudechic.cursor import PointerMixin, set_pointer
+from claudechic.widgets.base.cursor import PointerMixin, set_pointer
 from claudechic.errors import log_exception
-from claudechic.profiling import profile
-from claudechic.widgets.button import Button
-
-
-class CopyButton(Button):
-    """Copy button with hand cursor on hover."""
-
-    pass
-
-
-class Spinner(Static):
-    """Animated spinner - all instances share a single timer for efficiency."""
-
-    FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
-    DEFAULT_CSS = """
-    Spinner {
-        width: 1;
-        height: 1;
-        color: $text-muted;
-    }
-    """
-
-    # Class-level shared state
-    _instances: set["Spinner"] = set()
-    _frame: int = 0
-    _timer = None
-
-    def __init__(self, text: str = "") -> None:
-        self._text = f" {text}" if text else ""
-        super().__init__()
-
-    def render(self) -> str:
-        """Return current frame from shared counter."""
-        return f"{self.FRAMES[Spinner._frame]}{self._text}"
-
-    def on_mount(self) -> None:
-        Spinner._instances.add(self)
-        # Start shared timer if this is the first spinner
-        # Use app.set_interval so timer survives widget unmount
-        if Spinner._timer is None:
-            Spinner._timer = self.app.set_interval(1 / 10, Spinner._tick_all)  # 10 FPS
-
-    def on_unmount(self) -> None:
-        Spinner._instances.discard(self)
-        # Stop timer if no spinners left
-        if not Spinner._instances and Spinner._timer is not None:
-            Spinner._timer.stop()
-            Spinner._timer = None
-
-    @staticmethod
-    @profile
-    def _tick_all() -> None:
-        """Advance frame and refresh all spinners.
-
-        Note: We don't check visibility - refresh() on hidden widgets is cheap,
-        and the DOM-walking visibility check was more expensive than the savings.
-        """
-        Spinner._frame = (Spinner._frame + 1) % len(Spinner.FRAMES)
-        for spinner in list(Spinner._instances):
-            spinner.refresh()
+from claudechic.widgets.primitives.button import Button
+from claudechic.widgets.primitives.spinner import Spinner
+from claudechic.widgets.base.copyable import CopyButton, CopyableMixin
 
 
 class ThinkingIndicator(Spinner):
@@ -128,7 +69,7 @@ class SystemInfo(Static):
         yield Markdown(self._message, id="content")
 
 
-class ChatMessage(Static, PointerMixin):
+class ChatMessage(Static, PointerMixin, CopyableMixin):
     """A single chat message with copy button.
 
     Uses Textual's MarkdownStream for efficient incremental rendering.
@@ -152,15 +93,15 @@ class ChatMessage(Static, PointerMixin):
         self._pending_text = ""  # Accumulated text waiting to be flushed
         self._flush_timer = None  # Timer for debounced flush
 
+    def _is_streaming(self) -> bool:
+        """Check if we're actively streaming content."""
+        return bool(self._pending_text) or self._flush_timer is not None
+
     def on_enter(self) -> None:
         set_pointer(self.pointer_style)
-        if not self.has_class("hovered"):
-            self.add_class("hovered")
 
     def on_leave(self) -> None:
         set_pointer("default")
-        if self.has_class("hovered"):
-            self.remove_class("hovered")
 
     def compose(self) -> ComposeResult:
         yield CopyButton("⧉", id="copy-btn", classes="copy-btn")
@@ -228,17 +169,15 @@ class ChatMessage(Static, PointerMixin):
             self.call_later(self._stream.stop)
             self._stream = None
 
-    def get_raw_content(self) -> str:
+    def get_copyable_content(self) -> str:
         """Get raw content for copying."""
         return self._content
 
+    # Alias for backwards compatibility
+    get_raw_content = get_copyable_content
+
     def on_button_pressed(self, event: Button.Pressed) -> None:
-        if event.button.id == "copy-btn":
-            try:
-                pyperclip.copy(self.get_raw_content())
-                self.app.notify("Copied to clipboard")
-            except Exception as e:
-                self.app.notify(f"Copy failed: {e}", severity="error")
+        self.handle_copy_button(event)
 
 
 class ChatAttachment(Button):
@@ -339,7 +278,6 @@ class ChatInput(TextArea, PointerMixin):
         Binding("ctrl+j", "newline", "Newline", priority=True, show=False),
         Binding("up", "history_prev", "Previous", priority=True, show=False),
         Binding("down", "history_next", "Next", priority=True, show=False),
-        Binding("ctrl+a", "select_all", "Select all", priority=True, show=False),
         Binding(
             "alt+backspace",
             "delete_word_left",
@@ -347,6 +285,17 @@ class ChatInput(TextArea, PointerMixin):
             priority=True,
             show=False,
         ),
+        # Readline/emacs bindings (override Textual defaults where needed)
+        Binding("ctrl+f", "cursor_right", "Forward char", priority=True, show=False),
+        Binding("ctrl+b", "cursor_left", "Backward char", priority=True, show=False),
+        Binding("ctrl+p", "cursor_up", "Previous line", priority=True, show=False),
+        Binding("ctrl+n", "cursor_down", "Next line", priority=True, show=False),
+        Binding(
+            "alt+f", "cursor_word_right", "Forward word", priority=True, show=False
+        ),
+        Binding(
+            "alt+b", "cursor_word_left", "Backward word", priority=True, show=False
+        ),
     ]
 
     class Submitted(Message):

claudechic/widgets/{tools.py → content/tools.py}

@@ -5,16 +5,14 @@ import logging
 import re
 from pathlib import Path
 
-import pyperclip
 from rich.text import Text
 
 from textual.app import ComposeResult
 from textual.message import Message
 from textual.widgets import Markdown, Static
 
-from claudechic.widgets.button import Button
-
-from claudechic.widgets.collapsible import QuietCollapsible
+from claudechic.widgets.primitives.button import Button
+from claudechic.widgets.primitives.collapsible import QuietCollapsible
 
 from claude_agent_sdk import ToolUseBlock, ToolResultBlock
 
@@ -26,9 +24,10 @@ from claudechic.formatting import (
     get_lang_from_path,
     make_relative,
 )
-from claudechic.widgets.diff import DiffWidget
-from claudechic.widgets.chat import ChatMessage, Spinner, CopyButton
-from claudechic.cursor import HoverableMixin
+from claudechic.widgets.content.diff import DiffWidget
+from claudechic.widgets.content.message import ChatMessage
+from claudechic.widgets.primitives.spinner import Spinner
+from claudechic.widgets.base.copyable import CopyButton, CopyableMixin
 
 log = logging.getLogger(__name__)
 
@@ -79,7 +78,7 @@ class EditPlanRequested(Message):
         self.plan_path = plan_path
 
 
-class ToolUseWidget(Static, HoverableMixin):
+class ToolUseWidget(Static, CopyableMixin):
     """A collapsible widget showing a tool use."""
 
     can_focus = False
@@ -170,14 +169,9 @@ class ToolUseWidget(Static, HoverableMixin):
         return "\n\n".join(parts)
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
-        if "copy-btn" in event.button.classes:
-            event.stop()
-            try:
-                pyperclip.copy(self.get_copyable_content())
-                self.app.notify("Copied tool output")
-            except Exception as e:
-                self.app.notify(f"Copy failed: {e}", severity="error")
-        elif "edit-plan-btn" in event.button.classes:
+        if self.handle_copy_button(event):
+            return
+        if "edit-plan-btn" in event.button.classes:
             event.stop()
             if hasattr(self, "_plan_path"):
                 self.post_message(EditPlanRequested(self._plan_path))
@@ -374,7 +368,7 @@ class TaskWidget(Static):
             pass  # Widget may not be mounted
 
 
-class ShellOutputWidget(Static, HoverableMixin):
+class ShellOutputWidget(Static, CopyableMixin):
     """Collapsible widget showing inline shell command output."""
 
     can_focus = False
@@ -413,13 +407,7 @@ class ShellOutputWidget(Static, HoverableMixin):
         return "\n".join(parts)
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
-        if "copy-btn" in event.button.classes:
-            event.stop()
-            try:
-                pyperclip.copy(self.get_copyable_content())
-                self.app.notify("Copied shell output")
-            except Exception as e:
-                self.app.notify(f"Copy failed: {e}", severity="error")
+        self.handle_copy_button(event)
 
 
 class AgentListWidget(Static):

claudechic/widgets/input/__init__.py

@@ -0,0 +1,9 @@
+"""Input widgets - text areas, autocomplete, search."""
+
+from claudechic.widgets.input.autocomplete import TextAreaAutoComplete
+from claudechic.widgets.input.history_search import HistorySearch
+
+__all__ = [
+    "TextAreaAutoComplete",
+    "HistorySearch",
+]

claudechic/widgets/layout/__init__.py

@@ -0,0 +1,51 @@
+"""Layout widgets - chat view, sidebar, footer."""
+
+from claudechic.widgets.layout.chat_view import ChatView
+from claudechic.widgets.layout.sidebar import (
+    AgentItem,
+    AgentSection,
+    WorktreeItem,
+    PlanItem,
+    PlanSection,
+    SidebarSection,
+    SidebarItem,
+    HamburgerButton,
+    SessionItem,
+)
+from claudechic.widgets.layout.footer import (
+    AutoEditLabel,
+    ModelLabel,
+    StatusFooter,
+)
+from claudechic.widgets.layout.indicators import (
+    IndicatorWidget,
+    CPUBar,
+    ContextBar,
+    ProcessIndicator,
+)
+from claudechic.widgets.layout.processes import (
+    ProcessPanel,
+    ProcessItem,
+)
+
+__all__ = [
+    "ChatView",
+    "AgentItem",
+    "AgentSection",
+    "WorktreeItem",
+    "PlanItem",
+    "PlanSection",
+    "SidebarSection",
+    "SidebarItem",
+    "HamburgerButton",
+    "SessionItem",
+    "AutoEditLabel",
+    "ModelLabel",
+    "StatusFooter",
+    "IndicatorWidget",
+    "CPUBar",
+    "ContextBar",
+    "ProcessIndicator",
+    "ProcessPanel",
+    "ProcessItem",
+]

claudechic/widgets/{chat_view.py → layout/chat_view.py}

@@ -4,22 +4,25 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from textual.widget import Widget
+
 from claudechic.agent import (
     Agent,
     ImageAttachment,
     UserContent,
     AssistantContent,
     ToolUse,
+    TextBlock,
 )
 from claudechic.enums import ToolName
-from claudechic.widgets.chat import (
+from claudechic.widgets.content.message import (
     ChatMessage,
     ChatAttachment,
     ThinkingIndicator,
     SystemInfo,
 )
-from claudechic.widgets.scroll import AutoHideScroll
-from claudechic.widgets.tools import ToolUseWidget, TaskWidget, AgentToolWidget
+from claudechic.widgets.primitives.scroll import AutoHideScroll
+from claudechic.widgets.content.tools import ToolUseWidget, TaskWidget, AgentToolWidget
 
 if TYPE_CHECKING:
     from claude_agent_sdk import ToolUseBlock, ToolResultBlock
@@ -75,30 +78,103 @@ class ChatView(AutoHideScroll):
         self._render_full()
 
     def _render_full(self) -> None:
-        """Fully re-render the chat view from agent.messages."""
+        """Fully re-render the chat view from agent.messages.
+
+        Uses mount_all() to batch all widget mounts into a single CSS recalculation,
+        which is much faster than mounting widgets one at a time.
+        """
         self.clear()
         if not self._agent:
             return
 
+        # Count total tool uses to determine which to collapse
+        # (collapse all except last RECENT_TOOLS_EXPANDED)
+        total_tools = sum(
+            sum(1 for b in item.content.blocks if isinstance(b, ToolUse))
+            for item in self._agent.messages
+            if item.role == "assistant" and isinstance(item.content, AssistantContent)
+        )
+        collapse_threshold = total_tools - RECENT_TOOLS_EXPANDED
+        tool_index = 0
+
+        # Build all widgets first, then mount in one batch
+        widgets: list[Widget] = []
         for item in self._agent.messages:
             if item.role == "user" and isinstance(item.content, UserContent):
-                self._mount_user_message(item.content.text, item.content.images)
+                widgets.extend(
+                    self._create_user_widgets(item.content.text, item.content.images)
+                )
             elif item.role == "assistant" and isinstance(
                 item.content, AssistantContent
             ):
-                self._render_assistant_history(item.content)
+                new_widgets, tool_index = self._create_assistant_widgets(
+                    item.content, tool_index, collapse_threshold
+                )
+                widgets.extend(new_widgets)
 
+        # Single mount_all triggers one CSS recalculation instead of N
+        self.mount_all(widgets)
         self.scroll_end(animate=False)
 
-    def _render_assistant_history(self, content: AssistantContent) -> None:
-        """Render an assistant message from history."""
-        if content.text:
-            msg = ChatMessage(content.text)
-            msg.add_class("assistant-message")
-            self.mount(msg)
+    def _create_user_widgets(
+        self, text: str, images: list[ImageAttachment], is_agent: bool = False
+    ) -> list[Widget]:
+        """Create widgets for a user message (without mounting)."""
+        widgets: list[Widget] = []
+        msg = ChatMessage(text, is_agent=is_agent)
+        msg.add_class("agent-message" if is_agent else "user-message")
+        widgets.append(msg)
+
+        for i, img in enumerate(images):
+            if img.filename.lower().startswith("screenshot"):
+                display_name = f"Screenshot #{i + 1}"
+            else:
+                display_name = img.filename
+            widgets.append(ChatAttachment(img.filename, display_name))
+
+        return widgets
+
+    def _create_assistant_widgets(
+        self, content: AssistantContent, tool_index: int, collapse_threshold: int
+    ) -> tuple[list[Widget], int]:
+        """Create widgets for an assistant message (without mounting).
+
+        Iterates over blocks in order to preserve text/tool interleaving.
+        Returns (widgets, updated_tool_index).
+        """
+        widgets: list[Widget] = []
+        for block in content.blocks:
+            if isinstance(block, TextBlock):
+                msg = ChatMessage(block.text)
+                msg.add_class("assistant-message")
+                widgets.append(msg)
+            elif isinstance(block, ToolUse):
+                collapse = tool_index < collapse_threshold
+                widgets.append(
+                    self._create_tool_widget(block, completed=True, collapsed=collapse)
+                )
+                tool_index += 1
+
+        return widgets, tool_index
+
+    def _create_tool_widget(
+        self, tool: ToolUse, completed: bool = False, collapsed: bool = False
+    ) -> Widget:
+        """Create a tool widget (without mounting)."""
+        from claude_agent_sdk import ToolUseBlock
+
+        block = ToolUseBlock(id=tool.id, name=tool.name, input=tool.input)
+        should_collapse = collapsed or tool.name in COLLAPSE_BY_DEFAULT
+        cwd = self._agent.cwd if self._agent else None
 
-        for tool in content.tool_uses:
-            self._mount_tool_widget(tool, completed=True)
+        if tool.name == ToolName.TASK:
+            return TaskWidget(block, collapsed=should_collapse, cwd=cwd)
+        elif tool.name.startswith("mcp__chic__"):
+            return AgentToolWidget(block, cwd=cwd)
+        else:
+            return ToolUseWidget(
+                block, collapsed=should_collapse, completed=completed, cwd=cwd
+            )
 
     # -----------------------------------------------------------------------
     # Streaming API - called by ChatApp during live response
@@ -233,35 +309,8 @@ class ChatView(AutoHideScroll):
         self, text: str, images: list[ImageAttachment], is_agent: bool = False
     ) -> None:
         """Mount a user message widget with optional image attachments."""
-        msg = ChatMessage(text, is_agent=is_agent)
-        msg.add_class("agent-message" if is_agent else "user-message")
-        self.mount(msg)
-
-        for i, img in enumerate(images):
-            if img.filename.lower().startswith("screenshot"):
-                display_name = f"Screenshot #{i + 1}"
-            else:
-                display_name = img.filename
-            self.mount(ChatAttachment(img.filename, display_name))
-
-    def _mount_tool_widget(self, tool: ToolUse, completed: bool = False) -> None:
-        """Mount a tool widget (for history rendering)."""
-        from claude_agent_sdk import ToolUseBlock
-
-        block = ToolUseBlock(id=tool.id, name=tool.name, input=tool.input)
-        collapsed = tool.name in COLLAPSE_BY_DEFAULT
-        cwd = self._agent.cwd if self._agent else None
-
-        if tool.name == ToolName.TASK:
-            widget = TaskWidget(block, collapsed=collapsed, cwd=cwd)
-        elif tool.name.startswith("mcp__chic__"):
-            widget = AgentToolWidget(block, cwd=cwd)
-        else:
-            widget = ToolUseWidget(
-                block, collapsed=collapsed, completed=completed, cwd=cwd
-            )
-
-        self.mount(widget)
+        for widget in self._create_user_widgets(text, images, is_agent):
+            self.mount(widget)
 
     def _hide_thinking(self) -> None:
         """Remove thinking indicator if present."""

claudechic/widgets/{footer.py → layout/footer.py}

@@ -8,11 +8,12 @@ from textual.reactive import reactive
 from textual.containers import Horizontal
 from textual.widgets import Static
 
-from claudechic.widgets.button import Button
-from claudechic.widgets.indicators import CPUBar, ContextBar
+from claudechic.widgets.base.clickable import ClickableLabel
+from claudechic.widgets.layout.indicators import CPUBar, ContextBar, ProcessIndicator
+from claudechic.processes import BackgroundProcess
 
 
-class AutoEditLabel(Button):
+class AutoEditLabel(ClickableLabel):
     """Clickable auto-edit status label."""
 
     class Toggled(Message):
@@ -22,14 +23,14 @@ class AutoEditLabel(Button):
         self.post_message(self.Toggled())
 
 
-class ModelLabel(Button):
+class ModelLabel(ClickableLabel):
     """Clickable model label."""
 
-    class Clicked(Message):
-        """Emitted when model label is clicked."""
+    class ModelChangeRequested(Message):
+        """Emitted when user wants to change the model."""
 
     def on_click(self, event) -> None:
-        self.post_message(self.Clicked())
+        self.post_message(self.ModelChangeRequested())
 
 
 async def get_git_branch(cwd: str | None = None) -> str:
@@ -72,6 +73,7 @@ class StatusFooter(Static):
                 "Auto-edit: off", id="auto-edit-label", classes="footer-label"
             )
             yield Static("", id="footer-spacer")
+            yield ProcessIndicator(id="process-indicator", classes="hidden")
             yield ContextBar(id="context-bar")
             yield CPUBar(id="cpu-bar")
             yield Static("", id="branch-label", classes="footer-label")
@@ -100,3 +102,11 @@ class StatusFooter(Static):
             label.set_class(value, "active")
         except Exception:
             pass
+
+    def update_processes(self, processes: list[BackgroundProcess]) -> None:
+        """Update the process indicator."""
+        try:
+            indicator = self.query_one("#process-indicator", ProcessIndicator)
+            indicator.update_processes(processes)
+        except Exception:
+            pass

claudechic/widgets/{indicators.py → layout/indicators.py}

@@ -1,21 +1,32 @@
-"""Resource indicator widgets - context bar and CPU monitor."""
+"""Resource indicator widgets - context bar, CPU monitor, and process indicator."""
 
 import psutil
 
 from textual.app import RenderResult
 from textual.reactive import reactive
+from textual.widgets import Static
 from rich.text import Text
 
-from claudechic.widgets.button import Button
+from claudechic.widgets.base.cursor import ClickableMixin
 from claudechic.formatting import MAX_CONTEXT_TOKENS
 from claudechic.profiling import profile, timed
+from claudechic.processes import BackgroundProcess
 
 
-class CPUBar(Button):
+class IndicatorWidget(Static, ClickableMixin):
+    """Base class for clickable indicator widgets in the footer.
+
+    Inherits from Static (for render()) and ClickableMixin (for pointer cursor).
+    Override on_click() to handle click events.
+    """
+
+    can_focus = True
+
+
+class CPUBar(IndicatorWidget):
     """Display CPU usage. Click to show profiling stats."""
 
     cpu_pct = reactive(0.0)
-    can_focus = True
 
     def on_mount(self) -> None:
         self._process = psutil.Process()
@@ -46,17 +57,16 @@ class CPUBar(Button):
 
     def on_click(self, event) -> None:
         """Show profile modal on click."""
-        from claudechic.widgets.profile_modal import ProfileModal
+        from claudechic.widgets.modals.profile import ProfileModal
 
         self.app.push_screen(ProfileModal())
 
 
-class ContextBar(Button):
+class ContextBar(IndicatorWidget):
     """Display context usage as a progress bar. Click to run /context."""
 
     tokens = reactive(0)
     max_tokens = reactive(MAX_CONTEXT_TOKENS)
-    can_focus = True
 
     def render(self) -> RenderResult:
         pct = min(self.tokens / self.max_tokens, 1.0) if self.max_tokens else 0
@@ -89,3 +99,41 @@ class ContextBar(Button):
 
         if isinstance(self.app, ChatApp):
             self.app._handle_prompt("/context")
+
+
+class ProcessIndicator(IndicatorWidget):
+    """Display count of background processes. Click to show details."""
+
+    DEFAULT_CSS = """
+    ProcessIndicator {
+        width: auto;
+        padding: 0 1;
+    }
+    ProcessIndicator:hover {
+        background: $panel;
+    }
+    ProcessIndicator.hidden {
+        display: none;
+    }
+    """
+
+    count = reactive(0)
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._processes: list[BackgroundProcess] = []
+
+    def update_processes(self, processes: list[BackgroundProcess]) -> None:
+        """Update the process list and count."""
+        self._processes = processes
+        self.count = len(processes)
+        self.set_class(self.count == 0, "hidden")
+
+    def render(self) -> RenderResult:
+        return Text.assemble(("⚙ ", "yellow"), (f"{self.count}", ""))
+
+    def on_click(self, event) -> None:
+        """Show process modal on click."""
+        from claudechic.widgets.modals.process_modal import ProcessModal
+
+        self.app.push_screen(ProcessModal(self._processes))