@scemoon/cdh 1.0.0

package/tui/widgets/agent_thought.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.reactive import reactive
+from textual.widgets import Markdown, Static
+from textual.widgets.markdown import MarkdownStream
+
+from tui.protocol import ExpandProtocol
+
+
+class AgentThought(Vertical, can_focus=True):
+    """The agent's 'thoughts' with collapsible header.
+
+    During streaming: header shows "⏳ thinking:", content visible (expanded).
+    After completion: header shows "+ Thought" (collapsed).
+    Ctrl+X or click on header toggles expand/collapse.
+
+    Content is rendered as Markdown (bold, italic, code, lists, etc.).
+    """
+
+    HELP = """
+## Agent thoughts
+
+- **ctrl+x** Toggle expand/collapse
+- **click on header** Toggle expand/collapse
+- **cursor keys** Scroll text
+"""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+x", "toggle", "Toggle", show=False, priority=True),
+        Binding("up", "scroll_up", "Scroll Up", show=False),
+        Binding("down", "scroll_down", "Scroll Down", show=False),
+        Binding("left", "scroll_left", "Scroll Left", show=False),
+        Binding("right", "scroll_right", "Scroll Right", show=False),
+        Binding("home", "scroll_home", "Scroll Home", show=False),
+        Binding("end", "scroll_end", "Scroll End", show=False),
+        Binding("pageup", "page_up", "Page Up", show=False),
+        Binding("pagedown", "page_down", "Page Down", show=False),
+        Binding("ctrl+pageup", "page_left", "Page Left", show=False),
+        Binding("ctrl+pagedown", "page_right", "Page Right", show=False),
+    ]
+
+    ALLOW_MAXIMIZE = True
+
+    DEFAULT_CSS = """
+    AgentThought {
+        height: auto;
+        width: 1fr;
+    }
+    """
+
+    loading: reactive[bool] = reactive(False)
+
+    def watch_loading(self, loading: bool) -> None:
+        self.set_class(loading, "-loading")
+
+    def __init__(self, initial_content: str = "", *, replay: bool = False):
+        super().__init__()
+        self._initial_content = initial_content
+        self._stream: MarkdownStream | None = None
+        self._completed = False
+        self._collapsed = False
+        self._replay = replay
+
+    def compose(self) -> ComposeResult:
+        yield Static("⏳ thinking:", id="thought-header")
+        yield Markdown(self._initial_content, id="thought-content")
+
+    def on_mount(self) -> None:
+        # Force proper sizing — Vertical defaults to height: 1fr which
+        # collapses to 0 inside a VerticalScroll parent.
+        self.styles.height = "auto"
+        self.styles.min_height = 3
+        self._completed = self._replay
+        self._collapsed = self._replay
+        self._update_header()
+        content = self.query_one("#thought-content", Markdown)
+        content.display = not self._collapsed
+        content.styles.height = "auto"
+
+    async def append_fragment(self, fragment: str) -> None:
+        content = self.query_one("#thought-content", Markdown)
+        if self._stream is None:
+            self._stream = Markdown.get_stream(content)
+        await self._stream.write(fragment)
+        content.scroll_end()
+
+    def mark_completed(self) -> None:
+        if self._completed:
+            return
+        self._completed = True
+        self._collapsed = True
+        self._update_header()
+        self.query_one("#thought-content", Markdown).display = False
+
+    def action_toggle(self) -> None:
+        self._collapsed = not self._collapsed
+        self._update_header()
+        self.query_one("#thought-content", Markdown).display = not self._collapsed
+
+    def on_click(self, event) -> None:
+        """Toggle when the header is clicked (only after completion)."""
+        if not self._completed:
+            return
+        if getattr(event.widget, "id", None) == "thought-header":
+            self.action_toggle()
+            event.stop()
+
+    def _update_header(self) -> None:
+        header = self.query_one("#thought-header", Static)
+        if not self._completed:
+            header.update("⏳ thinking:")
+        elif self._collapsed:
+            header.update("+ Thought")
+        else:
+            header.update("- Thought")
+
+    # ── ExpandProtocol ──
+
+    def can_expand(self) -> bool:
+        return True
+
+    def expand_block(self) -> None:
+        if self._collapsed:
+            self.action_toggle()
+
+    def collapse_block(self) -> None:
+        if not self._collapsed:
+            self.action_toggle()
+
+    def is_block_expanded(self) -> bool:
+        return not self._collapsed
+
+    # ── Forward scroll actions to inner Markdown ──
+
+    def action_scroll_up(self) -> None:
+        self.query_one(Markdown).scroll_up()
+
+    def action_scroll_down(self) -> None:
+        self.query_one(Markdown).scroll_down()
+
+    def action_scroll_left(self) -> None:
+        self.query_one(Markdown).scroll_left()
+
+    def action_scroll_right(self) -> None:
+        self.query_one(Markdown).scroll_right()
+
+    def action_scroll_home(self) -> None:
+        self.query_one(Markdown).scroll_home()
+
+    def action_scroll_end(self) -> None:
+        self.query_one(Markdown).scroll_end()
+
+    def action_page_up(self) -> None:
+        self.query_one(Markdown).scroll_page_up()
+
+    def action_page_down(self) -> None:
+        self.query_one(Markdown).scroll_page_down()
+
+    def action_page_left(self) -> None:
+        self.query_one(Markdown).scroll_page_left()
+
+    def action_page_right(self) -> None:
+        self.query_one(Markdown).scroll_page_right()

package/tui/widgets/ask_user.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import json
+
+from textual.app import ComposeResult
+from textual import on
+from textual.containers import Horizontal, VerticalGroup
+from textual.message import Message
+from textual.widgets import Button, Checkbox, Input, Static
+
+
+class AskUserSubmitted(Message):
+    def __init__(self, value: str, tool_id: str) -> None:
+        super().__init__()
+        self.value = value
+        self.tool_id = tool_id
+
+
+class AskUserWidget(VerticalGroup):
+    DEFAULT_CLASSES = "block"
+    DEFAULT_CSS = """
+    AskUserWidget {
+        height: auto;
+        padding: 1 2;
+        margin: 1 0;
+        border: round $primary;
+        background: $boost;
+    }
+    AskUserWidget #ask-question {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    AskUserWidget #ask-options {
+        height: auto;
+        margin-bottom: 1;
+    }
+    AskUserWidget #ask-input-row {
+        height: auto;
+    }
+    AskUserWidget #ask-input {
+        margin-right: 1;
+    }
+    AskUserWidget #ask-answer-done {
+        margin: 0 1;
+    }
+    AskUserWidget .ask-q-section {
+        height: auto;
+        margin-bottom: 1;
+        padding: 0 0 0 1;
+        border-left: solid $primary 30%;
+    }
+    AskUserWidget .ask-q-header {
+        text-style: bold;
+    }
+    AskUserWidget .ask-q-text {
+        margin-bottom: 1;
+    }
+    AskUserWidget .ask-q-options {
+        height: auto;
+        margin-bottom: 0;
+    }
+    AskUserWidget .ask-submit-row {
+        height: auto;
+        margin-top: 1;
+    }
+    AskUserWidget .ask-opt-btn {
+        margin-right: 1;
+    }
+    AskUserWidget .ask-q-input {
+        margin: 0 0 1 0;
+    }
+    """
+
+    def __init__(
+        self, tool_id: str, question: str = "",
+        options: list[dict] | None = None,
+        questions: list[dict] | None = None,
+    ) -> None:
+        super().__init__()
+        self._tool_id = tool_id
+        self._question = question
+        self._options = options or []
+        self._questions = questions or []
+        self._is_multi = bool(self._questions)
+        self._answer = ""
+        self._done = False
+        self._option_buttons: dict[str, str] = {}
+        # multi-q state: btn_id → (question_index, value)
+        self._q_btn_map: dict[str, tuple[int, str]] = {}
+        # multi-q state: qid → set of selected option values (for "multiple" type)
+        self._multi_selections: dict[str, set[str]] = {}
+        # multi-q state: qid → single selected value (for "single"/"confirm" type)
+        self._q_selections: dict[str, str] = {}
+
+    def compose(self) -> ComposeResult:
+        if self._done:
+            suffix = "multi" if self._is_multi else self._answer
+            yield Static(f"✅ AskUser — {suffix}", id="ask-answer-done")
+            return
+        if self._is_multi:
+            yield from self._compose_multi()
+        else:
+            yield from self._compose_single()
+
+    def _compose_single(self) -> ComposeResult:
+        yield Static(f"❓ {self._question}", id="ask-question")
+        if self._options:
+            with Horizontal(id="ask-options"):
+                for i, opt in enumerate(self._options):
+                    label = opt.get("label", "")
+                    value = opt.get("value", "")
+                    key = opt.get("key")
+                    if key:
+                        display = f"[{key.upper()}] {label}"
+                    else:
+                        display = label
+                    btn_id = f"_ask_opt_{i}"
+                    self._option_buttons[btn_id] = value
+                    yield Button(display, id=btn_id)
+        with Horizontal(id="ask-input-row"):
+            yield Input(placeholder="Type your answer\u2026", id="ask-input")
+            yield Button("Send", variant="primary", id="ask-send")
+            yield Button("Cancel", id="ask-cancel")
+
+    def _compose_multi(self) -> ComposeResult:
+        for qi, q in enumerate(self._questions):
+            qheader = q.get("header", "") or f"Question {qi + 1}"
+            qtext = q.get("question", "")
+            qtype = q.get("type", "single")
+            qopts = q.get("options", [])
+            qid = f"_ask_q_{qi}"
+
+            with VerticalGroup(classes="ask-q-section"):
+                yield Static(qheader, classes="ask-q-header")
+                yield Static(qtext, classes="ask-q-text")
+
+                if qtype == "multiple" and qopts:
+                    with VerticalGroup(classes="ask-q-options"):
+                        for oi, opt in enumerate(qopts):
+                            opt_id = f"{qid}_chk_{oi}"
+                            label = opt.get("label", "")
+                            yield Checkbox(f" {label}", id=opt_id)
+                            self._multi_selections.setdefault(qid, set())
+                else:
+                    # single, confirm, or multiple without options → buttons + custom input
+                    with VerticalGroup(classes="ask-q-options"):
+                        if qtype == "confirm":
+                            yield Horizontal(
+                                Button("Yes", id=f"{qid}_yes", variant="primary", classes="ask-opt-btn"),
+                                Button("No", id=f"{qid}_no", classes="ask-opt-btn"),
+                            )
+                            self._q_btn_map[f"{qid}_yes"] = (qi, "yes")
+                            self._q_btn_map[f"{qid}_no"] = (qi, "no")
+                        elif qopts:
+                            with Horizontal():
+                                for oi, opt in enumerate(qopts):
+                                    label = opt.get("label", "")
+                                    value = opt.get("value", "")
+                                    btn_id = f"{qid}_opt_{oi}"
+                                    self._option_buttons[btn_id] = value
+                                    self._q_btn_map[btn_id] = (qi, value)
+                                    yield Button(label, id=btn_id, classes="ask-opt-btn")
+                        yield Input(placeholder="Custom answer\u2026", id=f"{qid}_input", classes="ask-q-input")
+
+        with Horizontal(classes="ask-submit-row"):
+            yield Button("Submit All", variant="primary", id="ask-submit-all")
+            yield Button("Cancel", id="ask-cancel")
+
+    def on_mount(self) -> None:
+        if not self._is_multi:
+            try:
+                self.query_one("#ask-input", Input).focus()
+            except Exception:
+                pass
+
+    # ── Single question handlers (backward compat) ──
+
+    @on(Button.Pressed, "#ask-cancel")
+    def handle_cancel(self) -> None:
+        self.post_message(AskUserSubmitted("__cancel__", self._tool_id))
+
+    @on(Button.Pressed, "#ask-send")
+    def handle_send(self) -> None:
+        value = self.query_one("#ask-input", Input).value.strip()
+        if value:
+            self._finish(value)
+
+    @on(Input.Submitted, "#ask-input")
+    def handle_input_submitted(self) -> None:
+        value = self.query_one("#ask-input", Input).value.strip()
+        if value:
+            self._finish(value)
+
+    @on(Button.Pressed)
+    def handle_option(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+        if btn_id and btn_id in self._option_buttons and not self._is_multi:
+            self._finish(self._option_buttons[btn_id])
+
+    # ── Multi-question handlers ──
+
+    @on(Button.Pressed, "#ask-submit-all")
+    def handle_submit_all(self) -> None:
+        answers = {}
+        for qi, q in enumerate(self._questions):
+            qtype = q.get("type", "single")
+            qid = f"_ask_q_{qi}"
+            if qtype == "multiple":
+                selected = []
+                for chk in self.query(f"#{qid}_chk_"):
+                    if isinstance(chk, Checkbox) and chk.value:
+                        label = chk.label.plain if hasattr(chk, "label") else ""
+                        selected.append(label.strip())
+                answers[str(qi)] = selected if selected else ""
+            elif qtype == "confirm":
+                val = self._q_selections.get(qid, "")
+                if not val:
+                    try:
+                        inp = self.query_one(f"#{qid}_input", Input)
+                        val = inp.value.strip()
+                    except Exception:
+                        pass
+                answers[str(qi)] = val or ""
+            else:
+                val = self._q_selections.get(qid, "")
+                if not val:
+                    try:
+                        inp = self.query_one(f"#{qid}_input", Input)
+                        val = inp.value.strip()
+                    except Exception:
+                        pass
+                answers[str(qi)] = val or ""
+
+        # Check all questions have answers
+        unanswered = [str(i) for i, q in enumerate(self._questions) if not answers.get(str(i))]
+        if unanswered:
+            return
+        self._finish(json.dumps(answers))
+
+    @on(Button.Pressed, ".ask-opt-btn")
+    def handle_q_option(self, event: Button.Pressed) -> None:
+        entry = self._q_btn_map.get(event.button.id or "")
+        if entry:
+            q_idx, value = entry
+            qid = f"_ask_q_{q_idx}"
+            self._q_selections[qid] = value
+
+    @on(Input.Submitted)
+    def handle_q_input(self, event: Input.Submitted) -> None:
+        inp_id = event.input.id or ""
+        if inp_id.startswith("_ask_q_") and inp_id.endswith("_input"):
+            qi = inp_id.replace("_ask_q_", "").replace("_input", "")
+            qid = f"_ask_q_{qi}"
+            val = event.value.strip()
+            if val:
+                self._q_selections[qid] = val
+
+    # ── Finish ──
+
+    def _finish(self, value: str) -> None:
+        self._answer = value
+        self._done = True
+        self.refresh(recompose=True, layout=True)
+        self.post_message(AskUserSubmitted(value, self._tool_id))

package/tui/widgets/command_pane.py

@@ -0,0 +1,223 @@
+import asyncio
+import codecs
+from dataclasses import dataclass
+
+import os
+import fcntl
+import pty
+import struct
+import termios
+
+
+from textual import events
+from textual.message import Message
+
+from tui.shell_read import shell_read
+
+from tui.widgets.terminal import Terminal
+
+
+class CommandError(Exception):
+    """An error occurred running the command."""
+
+
+class CommandPane(Terminal):
+    DEFAULT_CSS = """
+    CommandPane {
+        scrollbar-size: 0 0;
+    }
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self._execute_task: asyncio.Task | None = None
+        self._return_code: int | None = None
+        self._master: int | None = None
+        super().__init__(name=name, id=id, classes=classes)
+
+    @property
+    def return_code(self) -> int | None:
+        return self._return_code
+
+    @dataclass
+    class CommandComplete(Message):
+        return_code: int
+
+    def execute(self, command: str, *, final: bool = True) -> asyncio.Task:
+        self._execute_task = asyncio.create_task(self._execute(command, final=final))
+        self.anchor()
+        return self._execute_task
+
+    def on_resize(self, event: events.Resize):
+        event.prevent_default()
+        if self._master is None:
+            return
+        self._size_changed()
+
+    def _size_changed(self):
+        if self._master is None:
+            return
+        width, height = self.scrollable_content_region.size
+        try:
+            size = struct.pack("HHHH", height, width, 0, 0)
+            fcntl.ioctl(self._master, termios.TIOCSWINSZ, size)
+        except OSError:
+            pass
+        self.update_size(width, height)
+
+    @property
+    def is_cooked(self) -> bool:
+        """Is the terminal in 'cooked' mode?"""
+        if self._master is None:
+            return True
+        attrs = termios.tcgetattr(self._master)
+        lflag = attrs[3]
+        return bool(lflag & termios.ICANON)
+
+    async def write_stdin(self, text: str | bytes, hide_echo: bool = False) -> int:
+        if self._master is None:
+            return 0
+        text_bytes = text.encode("utf-8", "ignore") if isinstance(text, str) else text
+        try:
+            return await asyncio.to_thread(os.write, self._master, text_bytes)
+        except OSError:
+            return 0
+
+    async def _execute(self, command: str, *, final: bool = True) -> None:
+        # width, height = self.scrollable_content_region.size
+
+        await self.wait_for_refresh()
+
+        master, slave = pty.openpty()
+        self._master = master
+
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+        fcntl.fcntl(master, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+        # # Get terminal attributes
+        # attrs = termios.tcgetattr(slave)
+
+        # # Apply the changes
+        # termios.tcsetattr(slave, termios.TCSANOW, attrs)
+
+        env = os.environ.copy()
+        env["FORCE_COLOR"] = "1"
+        env["TTY_COMPATIBLE"] = "1"
+        env["TERM"] = "xterm-256color"
+        env["COLORTERM"] = "truecolor"
+        env["TOAD"] = "1"
+        env["CLICOLOR"] = "1"
+
+        try:
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdin=slave,
+                stdout=slave,
+                stderr=slave,
+                env=env,
+                start_new_session=True,  # Linux / macOS only
+            )
+        except Exception as error:
+            raise CommandError(f"Failed to execute {command!r}; {error}")
+
+        os.close(slave)
+
+        self._size_changed()
+
+        self.set_write_to_stdin(self.write_stdin)
+
+        BUFFER_SIZE = 64 * 1024
+        reader = asyncio.StreamReader(BUFFER_SIZE)
+        protocol = asyncio.StreamReaderProtocol(reader)
+
+        loop = asyncio.get_event_loop()
+        transport, _ = await loop.connect_read_pipe(
+            lambda: protocol, os.fdopen(master, "rb", 0)
+        )
+
+        # Create write transport
+        writer_protocol = asyncio.BaseProtocol()
+        self.write_transport, _ = await loop.connect_write_pipe(
+            lambda: writer_protocol,
+            os.fdopen(os.dup(master), "wb", 0),
+        )
+        unicode_decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+        try:
+            while True:
+                data = await shell_read(reader, BUFFER_SIZE)
+                if line := unicode_decoder.decode(data, final=not data):
+                    try:
+                        await self.write(line)
+                    except Exception as error:
+                        print(repr(line))
+                        print(error)
+                        from traceback import print_exc
+
+                        print_exc()
+
+                if not data:
+                    break
+        finally:
+            transport.close()
+
+        await process.wait()
+        return_code = self._return_code = process.returncode
+        if final:
+            self.set_class(return_code == 0, "-success")
+            self.set_class(return_code != 0, "-fail")
+        self.post_message(self.CommandComplete(return_code or 0))
+        self.hide_cursor = True
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+    from textual.content import Content
+
+    COMMAND = os.environ["SHELL"]
+    # COMMAND = "python test_input.py"
+
+    # COMMAND = "htop"
+    # COMMAND = "python test_scroll_margins.py"
+
+    # COMMAND = "python cpr.py"
+
+    COMMAND = "python test_input.py"
+
+    class CommandApp(App):
+        CSS = """
+        Screen {
+            align: center middle;
+        }
+        CommandPane {
+            # background: blue 20%;
+            scrollbar-gutter: stable;
+            background: black 10%;
+            max-height: 40;
+            # border: green;
+            border: tab $text-primary;            
+            margin: 0 2;
+        }
+        # CommandPane {
+        #     width: 1fr;
+        #     height: 1fr;
+        #     # background: black 10%;
+        #     # color: white;
+        #     background: ansi_default;
+        #     # color: ansi_default;
+        # }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield CommandPane()
+
+        def on_mount(self) -> None:
+            command_pane = self.query_one(CommandPane)
+            command_pane.border_title = Content(COMMAND)
+            command_pane.execute(COMMAND)
+
+    app = CommandApp()
+    app.run()