@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/widgets/question.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from textual.app import ComposeResult
+from textual import getters
+from textual import events, on
+from textual.binding import Binding
+from textual import containers
+from textual.content import Content
+from textual.reactive import var, reactive
+from textual.message import Message
+from textual.widget import Widget
+
+from textual import widgets
+
+from tui.answer import Answer
+
+type Options = list[Answer]
+
+
+@dataclass
+class Ask:
+    """Data for Question."""
+
+    question: str
+    options: Options
+    get_content: Callable[[], Widget] | None = None
+    callback: Callable[[Answer], Any] | None = None
+
+
+class NonSelectableLabel(widgets.Label):
+    ALLOW_SELECT = False
+
+
+class Option(containers.HorizontalGroup):
+    ALLOW_SELECT = False
+    DEFAULT_CSS = """
+    Option {
+
+        &:hover {
+            background: $boost;
+        }
+        color: $text-muted;
+        #caret {
+            visibility: hidden;
+            padding: 0 1;
+        }
+        #index {
+            padding-right: 1;
+        }
+        #label {
+            width: 1fr;
+        }
+        &.-active {            
+            color: $text-accent;
+            #caret {
+                visibility: visible;
+            }
+        }
+        &.-selected {
+            opacity: 0.5;
+        }
+        &.-active.-selected {
+            opacity: 1.0;
+            background: transparent;
+            color: $text-accent;            
+            #label {
+                text-style: underline;
+            }
+            #caret {
+                visibility: hidden;
+            }
+        }
+    }
+    """
+
+    @dataclass
+    class Selected(Message):
+        """The option was selected."""
+
+        index: int
+
+    selected: reactive[bool] = reactive(False, toggle_class="-selected")
+
+    def __init__(
+        self, index: int, content: Content, key: str | None, classes: str = ""
+    ) -> None:
+        super().__init__(classes=classes)
+        self.index = index
+        self.content = content
+        self.key = key
+
+    def compose(self) -> ComposeResult:
+        key = self.key
+        yield NonSelectableLabel("❯", id="caret")
+        if key:
+            yield NonSelectableLabel(Content.styled(f"{key}", "b"), id="index")
+        else:
+            yield NonSelectableLabel(Content(" "), id="index")
+
+        yield NonSelectableLabel(self.content, id="label")
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        self.post_message(self.Selected(self.index))
+
+
+class Question(containers.VerticalGroup, can_focus=True):
+    """A text question with a menu of responses."""
+
+    BINDING_GROUP_TITLE = "Question"
+    ALLOW_SELECT = False
+    CURSOR_GROUP = Binding.Group("Cursor", compact=True)
+    ALLOW_GROUP = Binding.Group("Allow once/always", compact=True)
+    REJECT_GROUP = Binding.Group("Reject once/always", compact=True)
+    BINDINGS = [
+        Binding(
+            "up",
+            "selection_up",
+            "Up",
+            group=CURSOR_GROUP,
+        ),
+        Binding(
+            "down",
+            "selection_down",
+            "Down",
+            group=CURSOR_GROUP,
+        ),
+        Binding(
+            "enter",
+            "select",
+            "Select",
+        ),
+        Binding(
+            "a",
+            "select_kind(('allow_once', 'allow'))",
+            "1×",
+            group=ALLOW_GROUP,
+        ),
+        Binding(
+            "A",
+            "select_kind('allow_always')",
+            "∞",
+            group=ALLOW_GROUP,
+        ),
+        Binding(
+            "r",
+            "select_kind(('reject_once', 'reject'))",
+            "1×",
+            group=REJECT_GROUP,
+        ),
+        Binding(
+            "R",
+            "select_kind('reject_always')",
+            "∞",
+            group=REJECT_GROUP,
+        ),
+    ]
+
+    DEFAULT_CSS = """
+    Question {
+        width: 1fr;
+        height: auto;
+        padding: 0 1; 
+        background: transparent;
+        #title {
+            margin-bottom: 1;
+            color: $text-primary;
+        }
+        #question-container {
+            margin-bottom: 1;
+        }        
+
+        
+
+        #option-container.-blink Option.-active #caret {
+            opacity: 0.2;
+        }
+
+        &:blur {
+            #index {
+                opacity: 0.3;
+            }
+            #caret {
+                opacity: 0.3;
+            }
+        }
+    }
+    """
+
+    title: var[str] = var("")
+    options: var[Options] = var(list)
+
+    selection: reactive[int] = reactive(0, init=False)
+    selected: var[bool] = var(False, toggle_class="-selected")
+    blink: var[bool] = var(False)
+
+    option_container = getters.query_one("#option-container", containers.VerticalGroup)
+
+    DEFAULT_KINDS = {
+        "allow_once": "a",
+        "allow_always": "A",
+        "reject_once": "r",
+        "reject_always": "R",
+    }
+
+    @dataclass
+    class Answer(Message):
+        """User selected a response."""
+
+        index: int
+        answer: Answer
+
+    def __init__(
+        self,
+        title: str = "Ask and you will receive",
+        get_content: Callable[[], Widget] | None = None,
+        options: Options | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ):
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+        self.set_reactive(Question.title, title)
+        self._get_content = get_content
+        self.set_reactive(Question.options, options or [])
+
+    def on_mount(self) -> None:
+        def toggle_blink() -> None:
+            if self.has_focus:
+                self.blink = not self.blink
+            else:
+                self.blink = False
+
+        self._blink_timer = self.set_interval(0.5, toggle_blink)
+
+    def _reset_blink(self) -> None:
+        self.blink = False
+        self._blink_timer.reset()
+
+    def update(self, ask: Ask) -> None:
+        self.title = ask.question
+        self._get_content = ask.get_content
+        self.options = ask.options
+        self.selection = 0
+        self.selected = False
+        self.refresh(recompose=True)
+
+    def compose(self) -> ComposeResult:
+
+        with containers.VerticalGroup(id="contents"):
+            if self.title:
+                yield widgets.Label(self.title, id="title", markup=False)
+            if self._get_content is not None:
+                yield self._get_content()
+
+        with containers.VerticalGroup(id="option-container"):
+            kinds: set[str] = set()
+            for index, answer in enumerate(self.options):
+                active = index == self.selection
+                key = (
+                    answer.kind
+                    if (answer.kind and answer.kind not in kinds
+                        and answer.kind not in self.DEFAULT_KINDS)
+                    else (
+                        self.DEFAULT_KINDS.get(answer.kind)
+                        if (answer.kind and answer.kind not in kinds)
+                        else None
+                    )
+                )
+                yield Option(
+                    index,
+                    Content(answer.text),
+                    key,
+                    classes="-active" if active else "",
+                ).data_bind(Question.selected)
+                if answer.kind is not None:
+                    kinds.add(answer.kind)
+
+    def watch_selection(self, old_selection: int, new_selection: int) -> None:
+        self.query("#option-container > .-active").remove_class("-active")
+        if new_selection >= 0:
+            self.query_one("#option-container").children[new_selection].add_class(
+                "-active"
+            )
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if self.selected and action in ("selection_up", "selection_down"):
+            return False
+        if action == "select_kind":
+            kinds = {answer.kind for answer in self.options if answer.kind is not None}
+            check_kinds = set()
+            for parameter in parameters:
+                if isinstance(parameter, str):
+                    check_kinds.add(parameter)
+                elif isinstance(parameter, tuple):
+                    check_kinds.update(parameter)
+
+            return any(kind in kinds for kind in check_kinds)
+
+        return True
+
+    def watch_blink(self, blink: bool) -> None:
+        self.option_container.set_class(blink, "-blink")
+
+    def action_selection_up(self) -> None:
+        self._reset_blink()
+        self.selection = max(0, self.selection - 1)
+
+    def action_selection_down(self) -> None:
+        self._reset_blink()
+        self.selection = min(len(self.options) - 1, self.selection + 1)
+
+    def action_select(self) -> None:
+        self._reset_blink()
+        self.post_message(
+            self.Answer(
+                index=self.selection,
+                answer=self.options[self.selection],
+            )
+        )
+        self.selected = True
+
+    def action_select_kind(self, kind: str | tuple[str]) -> None:
+        kinds = kind if isinstance(kind, tuple) else (kind,)
+        for kind in kinds:
+            for index, answer in enumerate(self.options):
+                if answer.kind == kind:
+                    self.selection = index
+                    self.action_select()
+                    break
+
+    @on(Option.Selected)
+    def on_option_selected(self, event: Option.Selected) -> None:
+        event.stop()
+        self._reset_blink()
+        if not self.selected:
+            self.selection = event.index
+
+
+if __name__ == "__main__":
+    from textual.app import App
+    from textual.widgets import Footer
+
+    OPTIONS = [
+        Answer("Yes, allow once", "proceed_always", kind="allow_once"),
+        Answer("Yes, allow always", "allow_always", kind="allow_always"),
+        Answer("Modify with external editor", "modify", kind="allow_once"),
+        Answer("No, suggest changes (esc)", "reject"),
+    ]
+
+    class QuestionApp(App):
+        def compose(self) -> ComposeResult:
+            yield Question("Apply this change?", OPTIONS)
+            yield Footer()
+
+    QuestionApp().run()

package/tui/widgets/session_grid_select.py

@@ -0,0 +1,230 @@
+from textual.app import ComposeResult
+from textual import getters
+from textual.binding import Binding
+
+from tui.app import A2TUIApp
+from tui.constants import SESSION_GRID_PAGE_SIZE
+from tui.widgets.grid_select import GridSelect
+from tui.widgets.session_summary import SessionSummary
+from tui.session_tracker import SessionTracker, SessionDetails
+
+
+PAGE_INDICATOR_ID = "session-grid-page-indicator"
+
+
+class SessionGridSelect(GridSelect):
+    FOCUS_ON_CLICK = True
+    CURSOR_GROUP = Binding.Group("Select")
+    BINDINGS = [
+        Binding("]", "next_page", "Next"),
+        Binding("[", "prev_page", "Prev"),
+    ]
+    app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
+
+    def __init__(
+        self,
+        session_tracker: SessionTracker,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        self.session_tracker = session_tracker
+        self._all_sessions: list[SessionDetails] = []
+        self._current_page: int = 0
+        super().__init__(
+            id=id,
+            classes=classes,
+            min_column_width=36,
+        )
+
+    @property
+    def page_size(self) -> int:
+        return SESSION_GRID_PAGE_SIZE
+
+    @property
+    def page_count(self) -> int:
+        total = len(self._all_sessions)
+        if total == 0:
+            return 0
+        return (total + self.page_size - 1) // self.page_size
+
+    @property
+    def current_page(self) -> int:
+        return self._current_page
+
+    def allow_focus(self) -> bool:
+        return True
+
+    def on_mount(self) -> None:
+        self.app.session_update_signal.subscribe(
+            self, self.handle_session_update_signal
+        )
+        if self._all_sessions:
+            self._render_page()
+        self.call_after_refresh(self._ensure_focus)
+
+    def _ensure_focus(self) -> None:
+        if (
+            self.is_mounted
+            and not self._closing
+            and self.focusable
+            and self.screen is not None
+            and self.screen.is_mounted
+        ):
+            self.focus()
+
+    def update_current(self, current_mode: str) -> None:
+        for index, child in enumerate(self.query_children(SessionSummary)):
+            if child.session_details is None:
+                continue
+            is_current = child.session_details.mode_name == current_mode
+            child.current = is_current
+            if is_current:
+                self.highlighted = index
+
+    async def handle_session_update_signal(
+        self, update: tuple[str, SessionDetails | None]
+    ) -> None:
+        mode_name, details = update
+        if details is None:
+            if session_summary := self.query_one_optional(
+                f"#{mode_name}", SessionSummary
+            ):
+                await session_summary.remove()
+            for i, existing in enumerate(self._all_sessions):
+                if existing.mode_name == mode_name:
+                    self._all_sessions.pop(i)
+                    break
+            self._clamp_page()
+            self._render_page()
+            return
+
+        if session_summary := self.query_one_optional(
+            f"#{mode_name}", SessionSummary
+        ):
+            session_summary.session_details = details
+            for existing in self._all_sessions:
+                if existing.mode_name == mode_name:
+                    existing.title = details.title
+                    existing.subtitle = details.subtitle
+                    existing.path = details.path
+                    existing.state = details.state
+                    break
+            return
+
+        for i, existing in enumerate(self._all_sessions):
+            if existing.mode_name == mode_name:
+                self._all_sessions[i] = details
+                self._render_page()
+                return
+
+        if details.session_pk is not None:
+            for i, existing in enumerate(self._all_sessions):
+                if existing.session_pk == details.session_pk:
+                    self._all_sessions[i] = details
+                    self._render_page()
+                    return
+
+        self._all_sessions.append(details)
+        self._render_page()
+
+    def compose(self) -> ComposeResult:
+        yield from ()
+
+    def set_sessions(self, sessions: list[SessionDetails]) -> None:
+        deduped: list[SessionDetails] = []
+        seen: set[int] = set()
+        for session in sessions:
+            if session.session_pk is not None:
+                if session.session_pk in seen:
+                    continue
+                seen.add(session.session_pk)
+            deduped.append(session)
+        self._all_sessions = deduped
+        self._current_page = 0
+        if self.is_mounted:
+            self._render_page()
+
+    def _current_page_items(self) -> list[SessionDetails]:
+        if not self._all_sessions:
+            return []
+        start = self._current_page * self.page_size
+        end = start + self.page_size
+        return self._all_sessions[start:end]
+
+    def _clamp_page(self) -> None:
+        if self._current_page >= self.page_count and self.page_count > 0:
+            self._current_page = self.page_count - 1
+
+    def _render_page(self) -> None:
+        if not self.is_mounted or self._closing or self._closed:
+            return
+        if self.screen is None or not self.screen.is_mounted:
+            return
+
+        current_items = self._current_page_items()
+        seen: dict[str, SessionDetails] = {}
+        for session in current_items:
+            seen[session.mode_name] = session
+        unique_items = list(seen.values())
+
+        for child in list(self.query_children(SessionSummary)):
+            if child.id not in seen:
+                try:
+                    child.remove()
+                except Exception:
+                    pass
+
+        existing_ids = {c.id for c in self.query_children(SessionSummary)}
+        for session in unique_items:
+            if session.mode_name not in existing_ids:
+                try:
+                    self.mount(SessionSummary(session, id=session.mode_name))
+                except Exception:
+                    pass
+
+        self._apply_current()
+        self._update_page_indicator()
+        self.highlighted = 0 if unique_items else None
+
+        if unique_items:
+            self.call_later(self._ensure_focus)
+
+    def _apply_current(self) -> None:
+        current_mode = self._current_screen_mode_name()
+        for index, child in enumerate(self.query_children(SessionSummary)):
+            if child.session_details is None:
+                continue
+            is_current = child.session_details.mode_name == current_mode
+            child.current = is_current
+            if is_current:
+                self.highlighted = index
+
+    def _current_screen_mode_name(self) -> str | None:
+        try:
+            screen = self.app.screen_stack[0]
+        except (IndexError, AttributeError):
+            return None
+        return getattr(screen, "id", None)
+
+    def _update_page_indicator(self) -> None:
+        try:
+            indicator = self.app.query_one(f"#{PAGE_INDICATOR_ID}")
+        except Exception:
+            return
+        total = len(self._all_sessions)
+        if total == 0:
+            indicator.update("")
+            return
+        indicator.update(
+            f"Page {self._current_page + 1} / {self.page_count} · 共 {total} 项"
+        )
+
+    def action_next_page(self) -> None:
+        if self._current_page + 1 < self.page_count:
+            self._current_page += 1
+            self._render_page()
+
+    def action_prev_page(self) -> None:
+        if self._current_page > 0:
+            self._current_page -= 1
+            self._render_page()

package/tui/widgets/session_summary.py

@@ -0,0 +1,115 @@
+from textual.app import ComposeResult
+from textual import getters
+from textual import containers
+from textual import widgets
+from textual.reactive import reactive
+from textual.timer import Timer
+
+
+from tui.widgets.condensed_path import CondensedPath
+from tui.widgets.throbber import ThrobberVisual
+from tui.session_tracker import SessionDetails
+
+
+class BusyIndicator(widgets.Static):
+    def render(self) -> ThrobberVisual:
+        return ThrobberVisual("▔")
+
+    def on_mount(self) -> None:
+        self.auto_refresh = 1 / 4
+
+
+class SessionSummary(containers.VerticalGroup):
+    session_details: reactive[SessionDetails | None] = reactive(
+        None, always_update=True, recompose=True
+    )
+
+    title = getters.query_one(".title", widgets.Label)
+    subtitle = getters.query_one(".subtitle", widgets.Label)
+    current = reactive(False, toggle_class="-current", init=False, recompose=True)
+    blink = reactive(False, toggle_class="-blink")
+
+    def __init__(
+        self,
+        session_details: SessionDetails | None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes=classes)
+        self.blink_timer: Timer | None = None
+        self.set_reactive(SessionSummary.session_details, session_details)
+
+    def on_mount(self) -> None:
+
+        def do_blink() -> None:
+            self.blink = not self.blink
+
+        self.blink_timer = self.set_interval(0.5, do_blink, pause=False)
+
+    def watch_current(self, current: bool) -> None:
+        if (session_details := self.session_details) is not None:
+            if current:
+                self.title.update(f"✱{session_details.title}")
+            else:
+                self.title.update(session_details.title)
+
+    def compose(self) -> ComposeResult:
+        if (session_details := self.session_details) is not None:
+            self.remove_class(
+                "-state-notready",
+                "-state-busy",
+                "-state-asking",
+                "-state-idle",
+                update=False,
+            )
+            self.add_class(f"-state-{session_details.state}")
+
+        yield BusyIndicator()
+        # yield widgets.Rule(line_style="heavy")
+        with containers.HorizontalGroup():
+            yield widgets.Label("❯", classes="icon")
+            with containers.VerticalGroup():
+                if session_details is not None:
+                    yield widgets.Label(
+                        (
+                            f"✱{session_details.title}"
+                            if self.current
+                            else session_details.title
+                        ),
+                        classes="title",
+                        markup=False,
+                    )
+                    yield widgets.Label(
+                        session_details.subtitle,
+                        classes="subtitle",
+                        markup=False,
+                    )
+                    with containers.HorizontalGroup():
+                        yield widgets.Label("📁 ")
+                        yield CondensedPath(session_details.path)
+
+
+if __name__ == "__main__":
+    from textual.app import App
+
+    session_details = SessionDetails(
+        0,
+        "mode",
+        title="Building BMI calculator",
+        subtitle="Claude Code",
+    )
+
+    class SessionApp(App):
+        CSS_PATH = "../tui.tcss"
+        CSS = """
+        Screen {
+            layout: horizontal;
+        }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield SessionSummary(session_details, classes="-state-busy")
+            yield SessionSummary(session_details, classes="-state-asking")
+            yield SessionSummary(session_details, classes="-state-idle")
+
+    SessionApp().run()