ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev503__py3-none-any.whl

ommlds/cli/sessions/chat/interfaces/textual/app.py

@@ -0,0 +1,310 @@
+import asyncio
+import os
+import typing as ta
+import weakref
+
+from omdev.tui import textual as tx
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.logs import all as logs
+
+from ...... import minichain as mc
+from .....backends.types import BackendName
+from ...drivers.events.types import AiDeltaChatEvent
+from ...drivers.events.types import AiMessagesChatEvent
+from ...drivers.types import ChatDriver
+from ...facades.facade import ChatFacade
+from .styles import read_app_css
+from .widgets.input import InputOuter
+from .widgets.input import InputTextArea
+from .widgets.messages import AiMessage
+from .widgets.messages import MessagesContainer
+from .widgets.messages import StaticAiMessage
+from .widgets.messages import StreamAiMessage
+from .widgets.messages import ToolConfirmationMessage
+from .widgets.messages import UiMessage
+from .widgets.messages import UserMessage
+from .widgets.messages import WelcomeMessage
+
+
+log, alog = logs.get_module_loggers(globals())
+
+
+##
+
+
+ChatEventQueue = ta.NewType('ChatEventQueue', asyncio.Queue)
+
+
+##
+
+
+class ChatAppGetter(lang.AsyncCachedFunc0['ChatApp']):
+    pass
+
+
+class ChatApp(tx.App):
+    ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
+
+    def __init__(
+            self,
+            *,
+            chat_facade: ChatFacade,
+            chat_driver: ChatDriver,
+            chat_event_queue: ChatEventQueue,
+            backend_name: BackendName | None = None,
+            devtools_setup: tx.DevtoolsSetup | None = None,
+    ) -> None:
+        super().__init__()
+
+        if devtools_setup is not None:
+            devtools_setup(self)
+
+        self._chat_facade = chat_facade
+        self._chat_driver = chat_driver
+        self._chat_event_queue = chat_event_queue
+        self._backend_name = backend_name
+
+        self._chat_action_queue: asyncio.Queue[ta.Any] = asyncio.Queue()
+
+        self._input_focused_key_events: weakref.WeakSet[tx.Key] = weakref.WeakSet()
+
+    def get_driver_class(self) -> type[tx.Driver]:
+        return tx.get_pending_writes_driver_class(super().get_driver_class())
+
+    CSS: ta.ClassVar[str] = read_app_css()
+
+    #
+
+    def compose(self) -> tx.ComposeResult:
+        yield MessagesContainer(id='messages-container')
+
+        yield InputOuter(id='input-outer')
+
+    #
+
+    def _get_input_text_area(self) -> InputTextArea:
+        return self.query_one('#input', InputTextArea)
+
+    def _get_messages_container(self) -> tx.VerticalScroll:
+        return self.query_one('#messages-container', MessagesContainer)
+
+    #
+
+    def _is_messages_at_bottom(self, threshold: int = 3) -> bool:
+        return (ms := self._get_messages_container()).scroll_y >= (ms.max_scroll_y - threshold)
+
+    def _scroll_messages_to_bottom(self) -> None:
+        self._get_messages_container().scroll_end(animate=False)
+
+    def _anchor_messages(self) -> None:
+        if (ms := self._get_messages_container()).max_scroll_y:
+            ms.anchor()
+
+    #
+
+    _pending_mount_messages: list[tx.Widget] | None = None
+
+    async def _enqueue_mount_messages(self, *messages: tx.Widget) -> None:
+        if (lst := self._pending_mount_messages) is None:
+            lst = self._pending_mount_messages = []
+
+        lst.extend(messages)
+
+    _stream_ai_message: StreamAiMessage | None = None
+
+    async def _finalize_stream_ai_message(self) -> None:
+        if self._stream_ai_message is None:
+            return
+
+        await self._stream_ai_message.stop_stream()
+        self._stream_ai_message = None
+
+    async def _append_stream_ai_message_content(self, content: str) -> None:
+        if (sam := self._stream_ai_message) is not None:
+            was_at_bottom = self._is_messages_at_bottom()
+
+            await sam.append_content(content)
+
+            self.call_after_refresh(self._scroll_messages_to_bottom)
+
+            if was_at_bottom:
+                self.call_after_refresh(self._anchor_messages)
+
+        else:
+            await self._mount_messages(StreamAiMessage(content))
+
+    async def _mount_messages(self, *messages: tx.Widget) -> None:
+        was_at_bottom = self._is_messages_at_bottom()
+
+        msg_ctr = self._get_messages_container()
+
+        for msg in [*(self._pending_mount_messages or []), *messages]:
+            if isinstance(msg, (AiMessage, ToolConfirmationMessage)):
+                await self._finalize_stream_ai_message()
+
+            await msg_ctr.mount(msg)
+
+            if isinstance(msg, StreamAiMessage):
+                self._stream_ai_message = check.replacing_none(self._stream_ai_message, msg)
+                await msg.write_initial_content()
+
+        self._pending_mount_messages = None
+
+        self.call_after_refresh(self._scroll_messages_to_bottom)
+
+        if was_at_bottom:
+            self.call_after_refresh(self._anchor_messages)
+
+    #
+
+    _chat_event_task: asyncio.Task[None] | None = None
+
+    @logs.async_exception_logging(alog)
+    async def _chat_event_task_main(self) -> None:
+        while True:
+            ev = await self._chat_event_queue.get()
+            if ev is None:
+                break
+
+            await alog.debug(lambda: f'Got chat event: {ev!r}')
+
+            if isinstance(ev, AiMessagesChatEvent):
+                wx: list[tx.Widget] = []
+
+                for ai_msg in ev.chat:
+                    if isinstance(ai_msg, mc.AiMessage):
+                        wx.append(
+                            StaticAiMessage(
+                                check.isinstance(ai_msg.c, str),
+                                markdown=True,
+                            ),
+                        )
+
+                if wx:
+                    await self._enqueue_mount_messages(*wx)
+                    self.call_later(self._mount_messages)
+
+            elif isinstance(ev, AiDeltaChatEvent):
+                if isinstance(ev.delta, mc.ContentAiDelta):
+                    cc = check.isinstance(ev.delta.c, str)
+                    self.call_later(self._append_stream_ai_message_content, cc)
+
+                elif isinstance(ev.delta, mc.ToolUseAiDelta):
+                    pass
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class UserInput:
+        text: str
+
+    _chat_action_task: asyncio.Task[None] | None = None
+
+    @logs.async_exception_logging(alog)
+    async def _chat_action_task_main(self) -> None:
+        while True:
+            ac = await self._chat_action_queue.get()
+            if ac is None:
+                break
+
+            await alog.debug(lambda: f'Got chat action: {ac!r}')
+
+            if isinstance(ac, ChatApp.UserInput):
+                try:
+                    await self._chat_facade.handle_user_input(ac.text)
+                except Exception as e:  # noqa
+                    raise
+
+            else:
+                raise TypeError(ac)  # noqa
+
+    #
+
+    async def on_mount(self) -> None:
+        check.state(self._chat_event_task is None)
+        self._chat_event_task = asyncio.create_task(self._chat_event_task_main())
+
+        await self._chat_driver.start()
+
+        check.state(self._chat_action_task is None)
+        self._chat_action_task = asyncio.create_task(self._chat_action_task_main())
+
+        self._get_input_text_area().focus()
+
+        await self._mount_messages(
+            WelcomeMessage('\n'.join([
+                f'Backend: {self._backend_name or "?"}',
+                f'Dir: {os.getcwd()}',
+            ])),
+        )
+
+    async def on_unmount(self) -> None:
+        if (cdt := self._chat_event_task) is not None:
+            await self._chat_event_queue.put(None)
+            await cdt
+
+        await self._chat_driver.stop()
+
+        if (cet := self._chat_event_task) is not None:
+            await self._chat_event_queue.put(None)
+            await cet
+
+    @tx.on(InputTextArea.Submitted)
+    async def on_input_text_area_submitted(self, event: InputTextArea.Submitted) -> None:
+        self._get_input_text_area().clear()
+
+        await self._finalize_stream_ai_message()
+
+        await self._mount_messages(
+            UserMessage(
+                event.text,
+            ),
+        )
+
+        await self._chat_action_queue.put(ChatApp.UserInput(event.text))
+
+    @tx.on(tx.Key)
+    async def on_key(self, event: tx.Key) -> None:
+        if event in self._input_focused_key_events:
+            return
+
+        chat_input = self._get_input_text_area()
+
+        if not chat_input.has_focus:
+            self._input_focused_key_events.add(event)
+
+            chat_input.focus()
+
+            self.screen.post_message(tx.Key(event.key, event.character))
+
+    #
+
+    async def confirm_tool_use(
+            self,
+            outer_message: str,
+            inner_message: str,
+    ) -> bool:
+        fut: asyncio.Future[bool] = asyncio.get_running_loop().create_future()
+
+        tcm = ToolConfirmationMessage(
+            outer_message,
+            inner_message,
+            fut,
+        )
+
+        async def inner() -> None:
+            await self._mount_messages(tcm)
+
+        self.call_later(inner)
+
+        ret = await fut
+
+        return ret
+
+    async def display_ui_message(
+            self,
+            content: str,
+    ) -> None:
+        await self._mount_messages(UiMessage(content))

ommlds/cli/sessions/chat/interfaces/textual/configs.py

@@ -0,0 +1,11 @@
+from omlish import dataclasses as dc
+
+from ..configs import InterfaceConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TextualInterfaceConfig(InterfaceConfig):
+    pass

ommlds/cli/sessions/chat/interfaces/textual/facades.py

@@ -0,0 +1,19 @@
+from ...facades.ui import UiMessageDisplayer
+from .app import ChatAppGetter
+
+
+##
+
+
+class ChatAppUiMessageDisplayer(UiMessageDisplayer):
+    def __init__(
+            self,
+            *,
+            app: ChatAppGetter,
+    ) -> None:
+        super().__init__()
+
+        self._app = app
+
+    async def display_ui_message(self, content: str) -> None:
+        await (await self._app()).display_ui_message(content)

ommlds/cli/sessions/chat/interfaces/textual/inject.py

@@ -0,0 +1,97 @@
+"""
+FIXME:
+ - too lazy to lazy import guts like every other proper inject module lol >_<
+"""
+import asyncio
+import contextlib
+
+from omlish import inject as inj
+from omlish import lang
+
+from ...drivers.events.injection import event_callbacks
+from ..base import ChatInterface
+from .configs import TextualInterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from omdev.tui import textual as tx
+
+    from ...drivers.tools import confirmation as _tools_confirmation
+    from ...facades import ui as _facades_ui
+    from . import app as _app
+    from . import facades as _facades
+    from . import interface as _interface
+    from . import tools as _tools
+
+
+##
+
+
+def bind_textual(cfg: TextualInterfaceConfig = TextualInterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=_interface.TextualChatInterface, singleton=True),
+    ]
+
+    #
+
+    els.extend([
+        inj.bind(_app.ChatApp, singleton=True),
+        inj.bind_async_late(_app.ChatApp, _app.ChatAppGetter),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_app.ChatEventQueue, to_const=asyncio.Queue()),
+
+        event_callbacks().bind_item(to_fn=inj.target(eq=_app.ChatEventQueue)(lambda eq: lambda ev: eq.put(ev))),
+    ])
+
+    #
+
+    if cfg.enable_tools:
+        if cfg.dangerous_no_tool_confirmation:
+            els.append(inj.bind(
+                _tools_confirmation.ToolExecutionConfirmation,
+                to_ctor=_tools_confirmation.UnsafeAlwaysAllowToolExecutionConfirmation,
+                singleton=True,
+            ))
+
+        else:
+            els.append(inj.bind(
+                _tools_confirmation.ToolExecutionConfirmation,
+                to_ctor=_tools.ChatAppToolExecutionConfirmation,
+                singleton=True,
+            ))
+
+    #
+
+    els.extend([
+        inj.bind(tx.DevtoolsConfig(port=41932)),  # FIXME: lol
+
+        inj.bind(
+            tx.DevtoolsManager,
+            singleton=True,
+            to_async_fn=inj.make_async_managed_provider(
+                tx.DevtoolsManager,
+                contextlib.aclosing,
+            ),
+        ),
+
+        inj.bind(
+            tx.DevtoolsSetup,
+            to_async_fn=inj.target(mgr=tx.DevtoolsManager)(lambda mgr: mgr.get_setup()),
+            singleton=True,
+        ),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_facades.ChatAppUiMessageDisplayer, singleton=True),
+        inj.bind(_facades_ui.UiMessageDisplayer, to_key=_facades.ChatAppUiMessageDisplayer),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interfaces/textual/interface.py

@@ -0,0 +1,24 @@
+from omdev.tui import textual as tx
+
+from ..base import ChatInterface
+from .app import ChatApp
+
+
+##
+
+
+class TextualChatInterface(ChatInterface):
+    def __init__(
+            self,
+            *,
+            app: ChatApp,
+    ) -> None:
+        super().__init__()
+
+        self._app = app
+
+    async def run(self) -> None:
+        # FIXME: move lol
+        tx.set_root_logger_to_devtools(self._app.devtools)
+
+        await self._app.run_async()

ommlds/cli/sessions/chat/interfaces/textual/styles/__init__.py

@@ -0,0 +1,29 @@
+import io as _io
+
+from omlish import lang as _lang
+
+
+##
+
+
+@_lang.cached_function
+def read_app_css() -> str:
+    tcss_rsrcs = [
+        rsrc
+        for rsrc in _lang.get_relative_resources(globals=globals()).values()
+        if rsrc.name.endswith('.tcss')
+    ]
+
+    out = _io.StringIO()
+
+    for i, rsrc in enumerate(tcss_rsrcs):
+        if i:
+            out.write('\n\n')
+
+        out.write(f'/*** {rsrc.name} ***/\n')
+        out.write('\n')
+
+        out.write(rsrc.read_text().strip())
+        out.write('\n')
+
+    return out.getvalue()

ommlds/cli/sessions/chat/interfaces/textual/styles/input.tcss

@@ -0,0 +1,53 @@
+#input-outer {
+    width: 100%;
+    height: auto;
+
+    background: $background-darken-3;
+}
+
+#input-vertical {
+    width: 100%;
+    height: auto;
+
+    margin: 0 1 1 1;
+
+    padding: 0;
+}
+
+#input-vertical2 {
+    width: 100%;
+    height: auto;
+
+    border: round $foreground-muted;
+
+    padding: 0 1;
+}
+
+#input-horizontal {
+    width: 100%;
+    height: auto;
+}
+
+#input-glyph {
+    width: auto;
+
+    padding: 0 1 0 0;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+#input {
+    width: 1fr;
+    height: auto;
+    max-height: 16;
+
+    border: none;
+
+    padding: 0;
+
+    background: transparent;
+    color: $text;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/markdown.tcss

@@ -0,0 +1,7 @@
+Markdown MarkdownFence {
+    max-width: 95%;
+
+    overflow-x: auto;
+
+    scrollbar-size-horizontal: 1;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/messages.tcss

@@ -0,0 +1,157 @@
+/* Container */
+
+#messages-container {
+    width: 100%;
+    height: 1fr;
+
+    scrollbar-gutter: stable;
+
+    background: $background-darken-3;
+
+    text-align: left;
+
+    scrollbar-size: 1 1;
+}
+
+
+/* Base */
+
+.message {
+    width: 1fr;
+    height: auto;
+
+    margin: 1 0 0 0;
+
+    padding-right: 1;
+
+    layout: stream;
+}
+
+.message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.message-outer {
+    width: 1fr;
+    height: auto;
+
+    align: left top;
+}
+
+.message-inner {
+    width: 1fr;
+    height: auto;
+}
+
+
+/* Welcome */
+
+.welcome-message {
+    margin: 0;
+
+    padding: 1 2 1 1;
+
+    border: round;
+}
+
+.welcome-message-outer {
+}
+
+.welcome-message-content {
+}
+
+
+/* User */
+
+.user-message {
+}
+
+.user-message-outer {
+}
+
+.user-message-glyph {
+}
+
+.user-message-inner {
+}
+
+
+/* Ai */
+
+.ai-message {
+}
+
+.ai-message-outer {
+}
+
+.ai-message-glyph {
+}
+
+.ai-message-inner {
+    padding: 0;
+
+    Markdown {
+        width: 100%;
+        height: auto;
+
+        margin: 0;
+        padding: 0;
+    }
+}
+
+
+/* Tool Confirmation */
+
+.tool-confirmation-message {
+}
+
+.tool-confirmation-message-outer {
+}
+
+.tool-confirmation-message-glyph {
+}
+
+.tool-confirmation-message-inner {
+}
+
+.tool-confirmation-message-inner-open {
+    background: $warning-lighten-3 15%;
+}
+
+.tool-confirmation-message-inner-closed {
+}
+
+.tool-confirmation-message-outer-content {
+}
+
+.tool-confirmation-message-inner-content {
+    background: $background;
+
+    margin: 1;
+    padding: 1;
+}
+
+.tool-confirmation-message-controls {
+    margin: 1;
+}
+
+
+/* Ui */
+
+.ui-message {
+}
+
+.ui-message-glyph {
+}
+
+.ui-message-outer {
+}
+
+.ui-message-inner {
+}