@scemoon/cdh 1.0.0

package/tui/shell.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+
+from contextlib import suppress
+import os
+import asyncio
+import codecs
+import fcntl
+import platform
+import pty
+import struct
+import termios
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from textual import log
+from textual.message import Message
+
+from tui.shell_read import shell_read
+
+from tui.widgets.terminal import Terminal
+
+if TYPE_CHECKING:
+    from tui.widgets.conversation import Conversation
+
+IS_MACOS = platform.system() == "Darwin"
+
+
+def resize_pty(fd, cols, rows):
+    """Resize the pseudo-terminal"""
+    # Pack the dimensions into the format expected by TIOCSWINSZ
+    try:
+        size = struct.pack("HHHH", rows, cols, 0, 0)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, size)
+    except OSError:
+        # Possibly file descriptor closed
+        pass
+
+
+@dataclass
+class CurrentWorkingDirectoryChanged(Message):
+    """Current working directory has changed in shell."""
+
+    path: str
+
+
+@dataclass
+class ShellFinished(Message):
+    """The shell finished."""
+
+
+class Shell:
+    """Responsible for shell interactions in Conversation."""
+
+    def __init__(
+        self,
+        conversation: Conversation,
+        working_directory: str,
+        shell="",
+        start="",
+        hide_start: bool = True,
+    ) -> None:
+        self.conversation = conversation
+        self.working_directory = working_directory
+
+        self.terminal: Terminal | None = None
+        self.new_log: bool = False
+        self.shell = shell or os.environ.get("SHELL", "sh")
+        self.shell_start = start
+        self.hide_start = hide_start
+        self.master: int | None = None
+        self._task: asyncio.Task | None = None
+        self._process: asyncio.subprocess.Process | None = None
+
+        self._finished: bool = False
+        self._ready_event: asyncio.Event = asyncio.Event()
+
+        self._hide_echo: set[bytes] = set()
+        """A set of byte strings to remove from output."""
+
+        self._hide_output = hide_start
+        """Hide all output."""
+
+        self._pid: int | None = None
+        """Shell process id"""
+
+    @property
+    def is_finished(self) -> bool:
+        return self._finished
+
+    def _is_busy(self) -> bool:
+        """Check if the shell is busy.
+
+        Called from a thread by `is_busy`.
+
+        Returns:
+            `True` if a command is running, or `False` if the shell is waiting for input.
+
+        """
+        if self._pid is None:
+            return False
+        import psutil
+
+        try:
+            shell_process = psutil.Process(self._pid)
+            children = shell_process.children(recursive=True)
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+        else:
+            return bool(children)
+
+    async def is_busy(self) -> bool:
+        """Is there a process running in the shell?
+
+        Returns:
+            `True` if a command is running, or `False` if the shell is waiting for input.
+        """
+        return await asyncio.to_thread(self._is_busy)
+
+    async def wait_for_ready(self) -> None:
+        await self._ready_event.wait()
+
+    async def send(self, command: str, width: int, height: int) -> None:
+        await self._ready_event.wait()
+        if self.master is None:
+            print("TTY FD not set")
+            return
+
+        if self.terminal is not None:
+            self.terminal.finalize()
+            self.terminal = None
+
+        try:
+            await asyncio.to_thread(resize_pty, self.master, width, max(height, 1))
+        except OSError:
+            pass
+
+        get_pwd_command = f"{command};" + r'printf "\e]2025;$(pwd);\e\\"' + "\n"
+        await self.write(get_pwd_command, hide_echo=True)
+
+    async def send_input(self, text: str, paste: bool = False) -> None:
+        await self._ready_event.wait()
+        if self.master is None:
+            return
+        if paste and self.terminal is not None and self.terminal.state.bracketed_paste:
+            text = f"\x1b[200~{text}\x1b[201~"
+        await self.write(f"{text}\n", hide_echo=True)
+
+    def start(self) -> None:
+        assert self._task is None
+        self._task = asyncio.create_task(self.run(), name=repr(self))
+        log("shell starting")
+
+    async def interrupt(self) -> None:
+        """Interrupt the running command."""
+        await self.write(b"\x03")
+
+    def update_size(self, width: int, height: int) -> None:
+        """Update the size of the shell pty.
+
+        Args:
+            width: Desired width.
+            height: Desired height.
+        """
+        if self.master is None:
+            return
+        with suppress(OSError):
+            resize_pty(self.master, width, max(height, 1))
+
+    async def write(
+        self, text: str | bytes, hide_echo: bool = False, hide_output: bool = False
+    ) -> int:
+        if self.master is None:
+            return 0
+        text_bytes = text.encode("utf-8", "ignore") if isinstance(text, str) else text
+
+        if hide_echo:
+            for line in text_bytes.split(b"\n"):
+                if line:
+                    self._hide_echo.add(line)
+        try:
+            result = await asyncio.to_thread(os.write, self.master, text_bytes)
+        except OSError:
+            return 0
+        self._hide_output = hide_output
+        return result
+
+    async def run(self) -> None:
+        current_directory = self.working_directory
+
+        master, slave = pty.openpty()
+        self.master = master
+
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+        fcntl.fcntl(master, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+        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"
+
+        shell = self.shell
+
+        def setup_pty():
+            os.setsid()
+            fcntl.ioctl(slave, termios.TIOCSCTTY, 0)
+
+        try:
+            _process = await asyncio.create_subprocess_shell(
+                shell,
+                stdin=slave,
+                stdout=slave,
+                stderr=slave,
+                env=env,
+                cwd=current_directory,
+                preexec_fn=setup_pty,
+            )
+        except Exception as error:
+            self.conversation.notify(
+                f"Unable to start shell: {error}\n\nCheck your settings.",
+                title="Shell",
+                severity="error",
+            )
+            return
+        self._pid = _process.pid
+
+        os.close(slave)
+        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)
+        )
+
+        self._ready_event.set()
+
+        if shell_start := self.shell_start.strip():
+            shell_start = self.shell_start.strip()
+            if not shell_start.endswith("\n"):
+                shell_start += "\n"
+            await self.write(shell_start, hide_echo=False, hide_output=self.hide_start)
+
+        unicode_decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+
+        while True:
+            data = await shell_read(reader, BUFFER_SIZE)
+
+            for string_bytes in list(self._hide_echo):
+                remove_bytes = string_bytes
+                if remove_bytes in data:
+                    remove_start = data.index(remove_bytes)
+                    try:
+                        next_line = data.index(b"\n", remove_start + len(remove_bytes))
+                    except ValueError:
+                        data = data.replace(remove_bytes, b"\x1b[2K")
+                    else:
+                        data = data[:remove_start] + b"\x1b[2K" + data[next_line + 1 :]
+
+                    self._hide_echo.discard(string_bytes)
+
+            if line := unicode_decoder.decode(data, final=not data):
+                if self.terminal is None or self.terminal.is_finalized:
+                    previous_state = (
+                        None if self.terminal is None else self.terminal.state
+                    )
+                    self.terminal = await self.conversation.new_terminal()
+                    # if previous_state is not None:
+                    #     self.terminal.set_state(previous_state)
+                    self.terminal.set_write_to_stdin(self.write)
+
+                terminal_updated = await self.terminal.write(
+                    line, hide_output=self._hide_output
+                )
+                if terminal_updated and not self.terminal.display:
+                    if (
+                        self.terminal.alternate_screen
+                        or not self.terminal.state.scrollback_buffer.is_blank
+                    ):
+                        self.terminal.display = True
+                new_directory = self.terminal.current_directory
+                if new_directory and new_directory != current_directory:
+                    current_directory = new_directory
+                    self.conversation.post_message(
+                        CurrentWorkingDirectoryChanged(current_directory)
+                    )
+            if (
+                self.terminal is not None
+                and self.terminal.is_finalized
+                and self.terminal.state.scrollback_buffer.is_blank
+            ):
+                self.terminal.finalize()
+                self.terminal = None
+
+            if not data:
+                break
+
+        self.master = None
+        self._finished = True
+        self.conversation.post_message(ShellFinished())

package/tui/shell_read.py

@@ -0,0 +1,42 @@
+import asyncio
+from contextlib import suppress
+from time import monotonic
+
+
+async def shell_read(
+    reader: asyncio.StreamReader,
+    buffer_size: int,
+    *,
+    buffer_period: float | None = 1 / 100,
+    max_buffer_duration: float = 1 / 60,
+) -> bytes:
+    """Read data from a stream reader, with buffer logic to reduce the number of chunks.
+
+    Args:
+        reader: A reader instance.
+        buffer_size: Maximum buffer size.
+        buffer_period: Time in seconds where reads are batched, or `None` for no batching.
+        max_buffer_duration: Maximum time in seconds to buffer.
+
+    Returns:
+        Bytes read. May be empty on the last read.
+    """
+    try:
+        data = await reader.read(buffer_size)
+    except OSError:
+        data = b""
+    if data and buffer_period is not None:
+        buffer_time = monotonic() + max_buffer_duration
+        with suppress(asyncio.TimeoutError):
+            while len(data) < buffer_size and (time := monotonic()) < buffer_time:
+                async with asyncio.timeout(min(buffer_time - time, buffer_period)):
+                    try:
+                        if chunk := await reader.read(buffer_size - len(data)):
+                            data += chunk
+                        else:
+                            break
+                    except OSError as error:
+                        print(repr(error))
+
+                        break
+    return data

package/tui/slash_command.py

@@ -0,0 +1,34 @@
+import rich.repr
+
+from textual.content import Content
+
+
+@rich.repr.auto
+class SlashCommand:
+    """A record of a slash command."""
+
+    def __init__(self, command: str, help: str, hint: str | None = None) -> None:
+        """
+
+        Args:
+            command: The command name.
+            help: Description of command.
+            hint: Hint text (displayed as suggestion)
+        """
+        self.command = command
+        self.help = help
+        self.hint: str | None = hint
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        yield self.command
+        yield "help", self.help
+        yield "hint", self.hint, None
+
+    def __str__(self) -> str:
+        return self.command
+
+    @property
+    def content(self) -> Content:
+        return Content.assemble(
+            (self.command, "$text-success"), "\t", (self.help, "dim")
+        )

package/tui/tui.tcss

@@ -0,0 +1,246 @@
+.block {
+    margin: 1 1 1 0;  
+}
+
+
+Markdown {
+    layout: stream;    
+}
+
+LoadingIndicator {
+    background: transparent;
+}
+
+Throbber {
+    width: 100%;
+    height: 1;    
+    layer: base;    
+    visibility: hidden;
+    &.-busy {
+        visibility: visible;
+    }    
+} 
+
+.-hidden {
+    display: none;
+}
+
+App.-hide-footer {
+    #info-container {
+        margin: 0 !important;        
+    }
+    Footer {
+        display: none;        
+    }
+}
+
+App.-hide-footer.-compact-input {
+    #prompt-container {
+        margin: 0 0;
+    }
+}
+
+
+App.-hide-thoughts AgentThought {
+    display: none;
+}
+
+App.-hide-sidebar SideBar {    
+    layer: sidebar;    
+    offset-x: -100%;
+    &:focus-within {
+        offset-x: 0;                    
+    }
+}
+
+App.-hide-status-line StatusLine {
+    display: none;        
+}
+
+App.-hide-agent-title AgentInfo {
+    display: none;
+}
+
+App.-hide-info-bar #info-container {
+    height: 1;    
+    display: none;
+}
+
+App.-compact-input {    
+    Prompt {           
+        &.-mode-ask #prompt-container {
+            border: tall transparent !important;
+            &:focus-within {
+                border: tall $primary !important;
+            }   
+        }
+        #prompt-container {
+            border: none;
+            &:focus-within {
+                border: none;
+            }   
+            margin: 0 0 0 0;            
+        }        
+        #info-container {
+            margin: 0 0;        
+        }
+    }
+}
+
+App.-show-sessions-bar {
+    SessionsTabs {
+        display: block;
+    }
+    Throbber {
+        offset-y: 1;
+    }
+}
+
+Checkbox {
+    # TODO: Bug in Textual?
+    text-overflow: clip;    
+}
+
+
+Footer {    
+    background: transparent;
+    .footer-key--key {
+        color: $text;
+        background: transparent;
+        # text-style: not bold;
+        padding: 0 1;        
+    }
+
+    .footer-key--description {
+        padding: 0 1 0 0;
+        color: $text-muted;
+        background: $footer-description-background;
+    }
+
+    &:hover {
+        color: transparent;
+        background: transparent;
+    }
+
+    &.-disabled {
+        text-style: dim;
+    }
+
+    &.-compact {
+        .footer-key--key {
+            padding: 0;
+        }
+        .footer-key--description {
+            padding: 0 0 0 1;
+        }
+    }
+    FooterLabel {
+        color: $text-muted;
+        background: $footer-description-background;
+    }
+
+    FooterKey.-disabled {
+        .footer-key--key {
+            text-opacity: 0.6;       
+        }
+    }
+}
+
+HelpPanel {    
+    
+    border-left: solid white 7%;
+    padding-right: 0;
+    # color: $text-secondary;
+    
+    #widget-help {
+        # color: $text-secondary;
+        border: round $secondary;
+        background: transparent;
+        margin-top: 0;
+        padding: 0 0;        
+        MarkdownBlock {
+            padding: 0 1;
+        }
+        MarkdownH2 {
+            margin: 0 0 1 0;
+        }
+        MarkdownBlock:last-child {
+            margin: 0 0 0 0;
+        }
+    }
+
+    KeyPanel {
+        # color: $text-secondary;
+        scrollbar-gutter: stable;        
+        &> BindingsTable > .bindings-table--description {            
+            # color: $text-secondary;
+            text-opacity:90%;
+        }
+        .bindings-table--key {
+            # color: $text-secondary;  
+            color: $text;
+        }
+        &> BindingsTable > .bindings-table--header {        
+            color: $primary;
+            text-style: underline;
+        }
+    }
+}
+
+
+
+Toast {    
+    margin: 0 0;
+    padding: 0 1;
+    background: $background;
+    color: $text-muted;
+    .toast--title {        
+        color: $text;            
+    }    
+    &.-information {
+        border: round $primary;                          
+    }
+    &.-warning {
+        border: round $warning;                        
+    }
+    &.-error {
+        border: round $error;                  
+    }    
+}
+
+
+Loading {
+    color: $text-primary;        
+}
+
+SessionsTabs {
+    layout: grid;
+    grid-columns: auto auto;
+    grid-size: 1 ;
+    overflow: scroll scroll;
+    scrollbar-size: 0 0;
+    width: 1fr;
+    display: none;
+        
+    height: 2;
+    box-sizing: content-box;
+    Underline {
+        width: 1fr;
+        height: 1;
+        & > .underline--bar {
+            color: $block-cursor-background;
+            background: $foreground 10%;
+        }        
+    }
+    #title-container {
+        width: auto;
+        Label {
+            text-style: dim;
+            pointer: pointer;
+            padding: 0 1;            
+            &.-current {
+                text-style: not dim;                
+            }
+        }
+    }
+}

package/tui/twitter.py

@@ -0,0 +1,38 @@
+import webbrowser
+from urllib.parse import urlencode
+
+
+def open_tweet_intent(
+    text: str,
+    *,
+    url: str | None = None,
+    hashtags: list[str] | None = None,
+    via: str | None = None,
+    in_reply_to: str | None = None,
+) -> str:
+    """Open a pre-filled Twitter/X tweet intent in the default browser.
+
+    Args:
+        text: The pre-filled tweet text.
+        url: An optional URL to append to the tweet.
+        hashtags: An optional list of hashtags to include (without '#').
+        via: An optional username to attribute the tweet to.
+        in_reply_to: An optional tweet ID to reply to.
+
+    Returns:
+        The full tweet intent URL that was opened.
+    """
+    params: dict[str, str] = {"text": text}
+
+    if url is not None:
+        params["url"] = url
+    if hashtags:
+        params["hashtags"] = ",".join(hashtags)
+    if via is not None:
+        params["via"] = via.lstrip("@")
+    if in_reply_to is not None:
+        params["in_reply_to"] = in_reply_to
+
+    tweet_url = f"https://twitter.com/intent/tweet?{urlencode(params)}"
+    webbrowser.open(tweet_url)
+    return tweet_url