@scemoon/cdh 1.0.6 → 1.0.8

package/tui/widgets/agent_thought.py

@@ -1,167 +0,0 @@
-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
-
-
-
-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

@@ -1,264 +0,0 @@
-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)
-        self.post_message(AskUserSubmitted(value, self._tool_id))

package/tui/widgets/command_pane.py

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