ommlds 0.0.0.dev491__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

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

@@ -0,0 +1,15 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..configs import InterfaceConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BareInterfaceConfig(InterfaceConfig):
+    interactive: bool = False
+
+    use_readline: bool | ta.Literal['auto'] = 'auto'

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

@@ -2,7 +2,7 @@ from omlish import inject as inj
 from omlish import lang
 
 from ..base import ChatInterface
-from ..configs import InterfaceConfig
+from .configs import BareInterfaceConfig
 
 
 with lang.auto_proxy_import(globals()):
@@ -17,7 +17,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_bare(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+def bind_bare(cfg: BareInterfaceConfig = BareInterfaceConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #

ommlds/cli/sessions/chat/interfaces/bare/interactive.py

@@ -1,10 +1,10 @@
 import typing as ta
 
-from ...... import minichain as mc
 from .....inputs.asyncs import AsyncStringInput
 from .....inputs.asyncs import SyncAsyncStringInput
 from .....inputs.sync import InputSyncStringInput
 from ...drivers.driver import ChatDriver
+from ...facades.facade import ChatFacade
 from ..base import ChatInterface
 
 
@@ -18,11 +18,13 @@ class InteractiveBareChatInterface(ChatInterface):
             self,
             *,
             driver: ChatDriver,
+            facade: ChatFacade,
             string_input: AsyncStringInput | None = None,
     ) -> None:
         super().__init__()
 
         self._driver = driver
+        self._facade = facade
         if string_input is None:
             string_input = self.DEFAULT_STRING_INPUT
         self._string_input = string_input
@@ -36,6 +38,12 @@ class InteractiveBareChatInterface(ChatInterface):
             except EOFError:
                 break
 
-            await self._driver.send_user_messages([mc.UserMessage(s)])
+            print()
+            print('<')
+            print()
+
+            await self._facade.handle_user_input(s)
+
+            print()
 
         await self._driver.stop()

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

@@ -1,23 +1,11 @@
-"""
-TODO:
- - obviously, subclasses of InterfaceConfig
-  - this is really just another instance of the whole `argparse -> config -> inject` flow
-"""
-import typing as ta
-
 from omlish import dataclasses as dc
+from omlish import lang
 
 
 ##
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class InterfaceConfig:
-    interactive: bool = False
-
-    use_textual: bool = False
-
-    use_readline: bool | ta.Literal['auto'] = 'auto'
-
+class InterfaceConfig(lang.Abstract):
     enable_tools: bool = False
     dangerous_no_tool_confirmation: bool = False

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

@@ -1,7 +1,9 @@
 from omlish import inject as inj
 from omlish import lang
 
+from .bare.configs import BareInterfaceConfig
 from .configs import InterfaceConfig
+from .textual.configs import TextualInterfaceConfig
 
 
 with lang.auto_proxy_import(globals()):
@@ -12,13 +14,16 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_interface(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+def bind_interface(cfg: InterfaceConfig = BareInterfaceConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
-    if cfg.use_textual:
-        els.append(_textual.bind_textual())
+    if isinstance(cfg, TextualInterfaceConfig):
+        els.append(_textual.bind_textual(cfg))
 
-    else:
+    elif isinstance(cfg, BareInterfaceConfig):
         els.append(_bare.bind_bare(cfg))
 
+    else:
+        raise TypeError(cfg)
+
     return inj.as_elements(*els)

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

@@ -1,45 +1,69 @@
 import asyncio
+import os
 import typing as ta
 
 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.driver import ChatDriver
 from ...drivers.events.types import AiDeltaChatEvent
 from ...drivers.events.types import AiMessagesChatEvent
+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 StaticAiMessage
 from .widgets.messages import StreamAiMessage
+from .widgets.messages import ToolConfirmationMessage
 from .widgets.messages import UserMessage
 from .widgets.messages import WelcomeMessage
 
 
+log, alog = logs.get_module_loggers(globals())
+
+
 ##
 
 
-ChatDriverEventQueue = ta.NewType('ChatDriverEventQueue', asyncio.Queue)
+ChatEventQueue = ta.NewType('ChatEventQueue', asyncio.Queue)
 
 
 ##
 
 
+class ChatAppGetter(lang.CachedFunc0[ta.Awaitable['ChatApp']]):
+    pass
+
+
 class ChatApp(tx.App):
     ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
 
     def __init__(
             self,
             *,
-            driver: ChatDriver,
-            event_queue: ChatDriverEventQueue,
+            chat_facade: ChatFacade,
+            chat_driver: ChatDriver,
+            chat_event_queue: ChatEventQueue,
+            backend_name: BackendName | None = None,
+            devtools_setup: tx.DevtoolsSetup | None = None,
     ) -> None:
         super().__init__()
 
-        self._chat_driver = driver
-        self._event_queue = event_queue
+        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()
 
     def get_driver_class(self) -> type[tx.Driver]:
         return tx.get_pending_writes_driver_class(super().get_driver_class())
@@ -49,8 +73,7 @@ class ChatApp(tx.App):
     #
 
     def compose(self) -> tx.ComposeResult:
-        with tx.VerticalScroll(id='messages-scroll'):
-            yield tx.Static(id='messages-container')
+        yield tx.VerticalScroll(id='messages-container')
 
         yield InputOuter(id='input-outer')
 
@@ -59,22 +82,19 @@ class ChatApp(tx.App):
     def _get_input_text_area(self) -> InputTextArea:
         return self.query_one('#input', InputTextArea)
 
-    def _get_messages_scroll(self) -> tx.VerticalScroll:
-        return self.query_one('#messages-scroll', tx.VerticalScroll)
-
-    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_scroll()).scroll_y >= (ms.max_scroll_y - threshold)
+        return (ms := self._get_messages_container()).scroll_y >= (ms.max_scroll_y - threshold)
 
     def _scroll_messages_to_bottom(self) -> None:
-        self._get_messages_scroll().scroll_end(animate=False)
+        self._get_messages_container().scroll_end(animate=False)
 
     def _anchor_messages(self) -> None:
-        if (ms := self._get_messages_scroll()).max_scroll_y:
+        if (ms := self._get_messages_container()).max_scroll_y:
             ms.anchor()
 
     #
@@ -102,7 +122,7 @@ class ChatApp(tx.App):
 
             await sam.append_content(content)
 
-            self.call_after_refresh(lambda: self._get_messages_container().scroll_end(animate=False))
+            self.call_after_refresh(self._scroll_messages_to_bottom)
 
             if was_at_bottom:
                 self.call_after_refresh(self._anchor_messages)
@@ -116,7 +136,7 @@ class ChatApp(tx.App):
         msg_ctr = self._get_messages_container()
 
         for msg in [*(self._pending_mount_messages or []), *messages]:
-            if isinstance(msg, AiMessage):
+            if isinstance(msg, (AiMessage, ToolConfirmationMessage)):
                 await self._finalize_stream_ai_message()
 
             await msg_ctr.mount(msg)
@@ -127,21 +147,24 @@ class ChatApp(tx.App):
 
         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_event_task: asyncio.Task[None] | None = None
 
-    async def _event_queue_task_main(self) -> None:
+    @logs.async_exception_logging(alog)
+    async def _chat_event_task_main(self) -> None:
         while True:
-            ev = await self._event_queue.get()
+            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] = []
 
@@ -159,50 +182,71 @@ class ChatApp(tx.App):
                     self.call_later(self._mount_messages)
 
             elif isinstance(ev, AiDeltaChatEvent):
-                cd = check.isinstance(ev.delta, mc.ContentAiDelta)
-                cc = check.isinstance(cd.c, str)
-                self.call_later(self. _append_stream_ai_message_content, cc)
+                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
 
     #
 
-    # def _schedule_after_refresh(self) -> None:
-    #     self.call_after_refresh(self._after_refresh)
+    @dc.dataclass(frozen=True)
+    class UserInput:
+        text: str
 
-    # def _after_refresh(self) -> None:
-    #     self.after_repaint()
-    #
-    #     self._schedule_after_refresh()
+    _chat_action_task: asyncio.Task[None] | None = None
 
-    # def after_repaint(self) -> None:
-    #     # from omdev.tui.textual.debug.dominfo import inspect_dom_node  # noqa
-    #
-    #     pass
+    @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:
-        # self._schedule_after_refresh()
-
-        check.state(self._event_queue_task is None)
-        self._event_queue_task = asyncio.create_task(self._event_queue_task_main())
+        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(
-                'Hello!',
-            ),
+            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 (eqt := self._event_queue_task) is not None:
-            await self._event_queue.put(None)
-            await eqt
+        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()
 
@@ -214,4 +258,28 @@ class ChatApp(tx.App):
             ),
         )
 
-        await self._chat_driver.send_user_messages([mc.UserMessage(event.text)])
+        await self._chat_action_queue.put(ChatApp.UserInput(event.text))
+
+    #
+
+    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

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/inject.py

@@ -3,44 +3,48 @@ 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 InterfaceConfig
-from .app import ChatApp
-from .app import ChatDriverEventQueue
-from .interface import TextualChatInterface
+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 . import app as _app
+    from . import interface as _interface
+    from . import tools as _tools
 
 
 ##
 
 
-def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+def bind_textual(cfg: TextualInterfaceConfig = TextualInterfaceConfig()) -> 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_async_late(_app.ChatApp, _app.ChatAppGetter),
     ])
 
     #
 
     els.extend([
-        inj.bind(ChatDriverEventQueue, to_const=asyncio.Queue()),
+        inj.bind(_app.ChatEventQueue, to_const=asyncio.Queue()),
 
         event_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
             lambda eq: lambda ev: eq.put(ev),
-            eq=ChatDriverEventQueue,
+            eq=_app.ChatEventQueue,
         )),
     ])
 
@@ -55,12 +59,32 @@ def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
             ))
 
         else:
-            # els.append(inj.bind(
-            #     _tools_confirmation.ToolExecutionConfirmation,
-            #     to_ctor=_tools.InteractiveToolExecutionConfirmation,
-            #     singleton=True,
-            # ))
-            raise NotImplementedError
+            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.KwargsTarget.of(lambda mgr: mgr.get_setup(), mgr=tx.DevtoolsManager),
+            singleton=True,
+        ),
+    ])
 
     #
 

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

@@ -1,3 +1,5 @@
+from omdev.tui import textual as tx
+
 from ..base import ChatInterface
 from .app import ChatApp
 
@@ -16,4 +18,7 @@ class TextualChatInterface(ChatInterface):
         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/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;
 }