@scemoon/cdh 1.0.6 → 1.0.7

package/tui/widgets/question.py

@@ -1,360 +0,0 @@
-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'))",
-            "Allow once",
-            group=ALLOW_GROUP,
-        ),
-        Binding(
-            "A",
-            "select_kind('allow_always')",
-            "Allow always",
-            group=ALLOW_GROUP,
-        ),
-        Binding(
-            "r",
-            "select_kind(('reject_once', 'reject'))",
-            "Reject once",
-            group=REJECT_GROUP,
-        ),
-        Binding(
-            "R",
-            "select_kind('reject_always')",
-            "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

@@ -1,230 +0,0 @@
-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 page"),
-        Binding("[", "prev_page", "Prev page"),
-    ]
-    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

@@ -1,115 +0,0 @@
-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()