ommlds 0.0.0.dev490__py3-none-any.whl → 0.0.0.dev492__py3-none-any.whl

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

@@ -1,135 +1,91 @@
 import asyncio
-import dataclasses as dc
-import io
 import typing as ta
 
 from omdev.tui import textual as tx
 from omlish import check
 from omlish import lang
+from omlish.logs import all as logs
 
 from ...... import minichain as mc
-from ...agents.agent import ChatAgent
-from ...agents.events.types import AiMessagesChatEvent
+from ...drivers.driver import ChatDriver
+from ...drivers.events.types import AiDeltaChatEvent
+from ...drivers.events.types import AiMessagesChatEvent
+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 StaticAiMessage
+from .widgets.messages import StreamAiMessage
+from .widgets.messages import ToolConfirmationMessage
+from .widgets.messages import UserMessage
+from .widgets.messages import WelcomeMessage
 
 
-##
-
-
-ChatAgentEventQueue = ta.NewType('ChatAgentEventQueue', asyncio.Queue)
+log, alog = logs.get_module_loggers(globals())
 
 
 ##
 
 
-class WelcomeMessage(tx.Static):
-    def __init__(self, content: str) -> None:
-        super().__init__(content)
-
-        self.add_class('welcome-message')
-
-
-class UserMessage(tx.Static):
-    def __init__(self, content: str) -> None:
-        super().__init__(content)
-
-        self.add_class('user-message')
-
-
-class AiMessage(tx.Static):
-    def __init__(self, content: str) -> None:
-        super().__init__(content)
-
-        self.add_class('ai-message')
+ChatDriverEventQueue = ta.NewType('ChatDriverEventQueue', asyncio.Queue)
 
 
 ##
 
 
-class InputTextArea(tx.TextArea):
-    @dc.dataclass()
-    class Submitted(tx.Message):
-        text: str
-
-    def __init__(self, **kwargs: ta.Any) -> None:
-        super().__init__(**kwargs)
-
-    async def _on_key(self, event: tx.Key) -> None:
-        if event.key == 'enter':
-            event.prevent_default()
-            event.stop()
-
-            if text := self.text.strip():
-                self.post_message(self.Submitted(text))
-
-        else:
-            await super()._on_key(event)
-
-
-##
-
-
-@lang.cached_function
-def _read_app_css() -> str:
-    tcss_rsrcs = [
-        rsrc
-        for rsrc in lang.get_relative_resources('.styles', 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()
-
-
-#
+class ChatAppGetter(lang.CachedFunc0['ChatApp']):
+    pass
 
 
 class ChatApp(tx.App):
+    ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
+
     def __init__(
             self,
             *,
-            agent: ChatAgent,
-            event_queue: ChatAgentEventQueue,
+            chat_driver: ChatDriver,
+            chat_driver_event_queue: ChatDriverEventQueue,
     ) -> None:
         super().__init__()
 
-        self._agent = agent
-        self._event_queue = event_queue
+        tx.setup_app_devtools(self, port=41932)
 
-    CSS: ta.ClassVar[str] = _read_app_css()
+        self._chat_driver = chat_driver
+        self._chat_driver_event_queue = chat_driver_event_queue
 
-    ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
+        self._chat_driver_action_queue: asyncio.Queue[ta.Any] = asyncio.Queue()
+
+    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:
-        with tx.VerticalScroll(id='messages-scroll'):
-            yield tx.Static(id='messages-container')
+        yield tx.VerticalScroll(id='messages-container')
 
-        with tx.Static(id='input-outer'):
-            with tx.Vertical(id='input-vertical'):
-                with tx.Vertical(id='input-vertical2'):
-                    with tx.Horizontal(id='input-horizontal'):
-                        yield tx.Static('>', id='input-glyph')
-                        yield InputTextArea(placeholder='...', id='input')
+        yield InputOuter(id='input-outer')
 
     #
 
     def _get_input_text_area(self) -> InputTextArea:
         return self.query_one('#input', InputTextArea)
 
-    def _get_messages_container(self) -> tx.Static:
-        return self.query_one('#messages-container', tx.Static)
+    def _get_messages_container(self) -> tx.VerticalScroll:
+        return self.query_one('#messages-container', tx.VerticalScroll)
+
+    #
+
+    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()
 
     #
 
@@ -141,34 +97,73 @@ class ChatApp(tx.App):
 
         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(lambda: msg_ctr.scroll_end(animate=False))
+        self.call_after_refresh(self._scroll_messages_to_bottom)
+
+        if was_at_bottom:
+            self.call_after_refresh(self._anchor_messages)
 
     #
 
-    _event_queue_task: asyncio.Task[None] | None = None
+    _chat_driver_event_task: asyncio.Task[None] | None = None
 
-    async def _event_queue_task_main(self) -> None:
+    @logs.async_exception_logging(alog)
+    async def _chat_driver_event_task_main(self) -> None:
         while True:
-            ev = await self._event_queue.get()
+            ev = await self._chat_driver_event_queue.get()
             if ev is None:
                 break
 
+            await alog.debug(lambda: f'Got chat driver 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(
-                            AiMessage(
+                            StaticAiMessage(
                                 check.isinstance(ai_msg.c, str),
+                                markdown=True,
                             ),
                         )
 
@@ -176,13 +171,46 @@ class ChatApp(tx.App):
                     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
+
+    #
+
+    _chat_driver_action_task: asyncio.Task[None] | None = None
+
+    @logs.async_exception_logging(alog)
+    async def _chat_driver_action_task_main(self) -> None:
+        while True:
+            ac = await self._chat_driver_action_queue.get()
+            if ac is None:
+                break
+
+            await alog.debug(lambda: f'Got chat driver action: {ac!r}')
+
+            if isinstance(ac, mc.UserMessage):
+                try:
+                    await self._chat_driver.send_user_messages([ac])
+                except Exception as e:  # noqa
+                    raise
+
+            else:
+                raise TypeError(ac)  # noqa
+
     #
 
     async def on_mount(self) -> None:
-        check.state(self._event_queue_task is None)
-        self._event_queue_task = asyncio.create_task(self._event_queue_task_main())
+        check.state(self._chat_driver_event_task is None)
+        self._chat_driver_event_task = asyncio.create_task(self._chat_driver_event_task_main())
 
-        await self._agent.start()
+        await self._chat_driver.start()
+
+        check.state(self._chat_driver_action_task is None)
+        self._chat_driver_action_task = asyncio.create_task(self._chat_driver_action_task_main())
 
         self._get_input_text_area().focus()
 
@@ -193,19 +221,42 @@ class ChatApp(tx.App):
         )
 
     async def on_unmount(self) -> None:
-        await self._agent.stop()
+        if (cdt := self._chat_driver_event_task) is not None:
+            await self._chat_driver_event_queue.put(None)
+            await cdt
+
+        await self._chat_driver.stop()
 
-        if (eqt := self._event_queue_task) is not None:
-            await self._event_queue.put(None)
-            await eqt
+        if (cet := self._chat_driver_event_task) is not None:
+            await self._chat_driver_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._agent.send_user_messages([mc.UserMessage(event.text)])
+        await self._chat_driver_action_queue.put(mc.UserMessage(event.text))
+
+    #
+
+    async def confirm_tool_use(self, message: str) -> bool:
+        fut: asyncio.Future[bool] = asyncio.get_running_loop().create_future()
+
+        tcm = ToolConfirmationMessage(message, fut)
+
+        async def inner() -> None:
+            await self._mount_messages(tcm)
+
+        self.call_later(inner)
+
+        ret = await fut
+
+        return ret

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

@@ -5,39 +5,64 @@ FIXME:
 import asyncio
 
 from omlish import inject as inj
+from omlish import lang
 
-from ...agents.events.injection import event_callbacks
+from ...drivers.events.injection import event_callbacks
 from ..base import ChatInterface
-from .app import ChatAgentEventQueue
-from .app import ChatApp
-from .interface import TextualChatInterface
+from ..configs import InterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from ...drivers.tools import confirmation as _tools_confirmation
+    from . import app as _app
+    from . import interface as _interface
+    from . import tools as _tools
 
 
 ##
 
 
-def bind_textual() -> inj.Elements:
+def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
     els: list[inj.Elemental] = [
-        inj.bind(ChatInterface, to_ctor=TextualChatInterface, singleton=True),
+        inj.bind(ChatInterface, to_ctor=_interface.TextualChatInterface, singleton=True),
     ]
 
     #
 
     els.extend([
-        inj.bind(ChatApp, singleton=True),
+        inj.bind(_app.ChatApp, singleton=True),
+
+        inj.bind_late(_app.ChatApp, _app.ChatAppGetter),
     ])
 
     #
 
     els.extend([
-        inj.bind(ChatAgentEventQueue, to_const=asyncio.Queue()),
+        inj.bind(_app.ChatDriverEventQueue, to_const=asyncio.Queue()),
 
         event_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
             lambda eq: lambda ev: eq.put(ev),
-            eq=ChatAgentEventQueue,
+            eq=_app.ChatDriverEventQueue,
         )),
     ])
 
     #
 
+    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,
+            ))
+
+    #
+
     return inj.as_elements(*els)

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

@@ -1,7 +1,90 @@
+import inspect
+import logging
+import typing as ta
+
+from omdev.tui import textual as tx
+
 from ..base import ChatInterface
 from .app import ChatApp
 
 
+if ta.TYPE_CHECKING:
+    from textual_dev.client import DevtoolsClient
+
+
+##
+
+
+def _translate_log_level(level: int) -> tuple['tx.LogGroup', 'tx.LogVerbosity']:
+    if level >= logging.ERROR:
+        return (tx.LogGroup.ERROR, tx.LogVerbosity.HIGH)
+    elif level >= logging.WARNING:
+        return (tx.LogGroup.ERROR, tx.LogVerbosity.HIGH)
+    elif level >= logging.INFO:
+        return (tx.LogGroup.INFO, tx.LogVerbosity.NORMAL)
+    elif level >= logging.DEBUG:
+        return (tx.LogGroup.DEBUG, tx.LogVerbosity.NORMAL)
+    else:
+        return (tx.LogGroup.UNDEFINED, tx.LogVerbosity.NORMAL)
+
+
+class _HackLoggingHandler(logging.Handler):
+    """
+    TODO:
+     - reify caller from LogContextInfos
+     - queue worker, this blocks the asyncio thread lol
+     - move to omdev.tui.textual obviously
+    """
+
+    def __init__(self, devtools: ta.Optional['DevtoolsClient']) -> None:
+        super().__init__()
+
+        self._devtools = devtools
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if (devtools := self._devtools) is not None and devtools.is_connected:
+            from textual_dev.client import DevtoolsLog
+
+            msg = self.format(record)
+
+            caller = inspect.Traceback(
+                filename=record.filename,
+                lineno=record.lineno,
+                function=record.funcName,
+                code_context=None,
+                index=None,
+            )
+
+            group, verbosity = _translate_log_level(record.levelno)
+
+            devtools.log(
+                DevtoolsLog(
+                    msg,
+                    caller=caller,
+                ),
+                group=group,
+                verbosity=verbosity,
+            )
+
+
+def _hack_loggers(devtools: ta.Optional['DevtoolsClient']) -> None:
+    from omlish.logs.std.standard import _locking_logging_module_lock  # noqa
+    from omlish.logs.std.standard import StandardConfiguredLoggingHandler
+
+    with _locking_logging_module_lock():
+        std_handler = next((h for h in logging.root.handlers if isinstance(h, StandardConfiguredLoggingHandler)), None)
+
+        hack_handler = _HackLoggingHandler(devtools)
+
+        if std_handler is not None:
+            hack_handler.setFormatter(std_handler.formatter)
+
+            for std_filter in std_handler.filters:
+                hack_handler.addFilter(std_filter)
+
+        logging.root.handlers = [hack_handler]
+
+
 ##
 
 
@@ -16,4 +99,6 @@ class TextualChatInterface(ChatInterface):
         self._app = app
 
     async def run(self) -> None:
+        _hack_loggers(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

@@ -1,13 +1,15 @@
 #input-outer {
     width: 100%;
     height: auto;
+
+    background: $background-darken-3;
 }
 
 #input-vertical {
     width: 100%;
     height: auto;
 
-    margin: 0 2 1 2;
+    margin: 0 1 1 1;
 
     padding: 0;
 }

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;
+}