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

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
@@ -40,7 +42,7 @@ class InteractiveBareChatInterface(ChatInterface):
             print('<')
             print()
 
-            await self._driver.send_user_messages([mc.UserMessage(s)])
+            await self._facade.handle_user_input(s)
 
             print()
 

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:
+    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,15 +1,19 @@
 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
@@ -27,13 +31,13 @@ log, alog = logs.get_module_loggers(globals())
 ##
 
 
-ChatDriverEventQueue = ta.NewType('ChatDriverEventQueue', asyncio.Queue)
+ChatEventQueue = ta.NewType('ChatEventQueue', asyncio.Queue)
 
 
 ##
 
 
-class ChatAppGetter(lang.CachedFunc0['ChatApp']):
+class ChatAppGetter(lang.CachedFunc0[ta.Awaitable['ChatApp']]):
     pass
 
 
@@ -43,17 +47,23 @@ class ChatApp(tx.App):
     def __init__(
             self,
             *,
+            chat_facade: ChatFacade,
             chat_driver: ChatDriver,
-            chat_driver_event_queue: ChatDriverEventQueue,
+            chat_event_queue: ChatEventQueue,
+            backend_name: BackendName | None = None,
+            devtools_setup: tx.DevtoolsSetup | None = None,
     ) -> None:
         super().__init__()
 
-        tx.setup_app_devtools(self, port=41932)
+        if devtools_setup is not None:
+            devtools_setup(self)
 
+        self._chat_facade = chat_facade
         self._chat_driver = chat_driver
-        self._chat_driver_event_queue = chat_driver_event_queue
+        self._chat_event_queue = chat_event_queue
+        self._backend_name = backend_name
 
-        self._chat_driver_action_queue: asyncio.Queue[ta.Any] = asyncio.Queue()
+        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())
@@ -144,16 +154,16 @@ class ChatApp(tx.App):
 
     #
 
-    _chat_driver_event_task: asyncio.Task[None] | None = None
+    _chat_event_task: asyncio.Task[None] | None = None
 
     @logs.async_exception_logging(alog)
-    async def _chat_driver_event_task_main(self) -> None:
+    async def _chat_event_task_main(self) -> None:
         while True:
-            ev = await self._chat_driver_event_queue.get()
+            ev = await self._chat_event_queue.get()
             if ev is None:
                 break
 
-            await alog.debug(lambda: f'Got chat driver event: {ev!r}')
+            await alog.debug(lambda: f'Got chat event: {ev!r}')
 
             if isinstance(ev, AiMessagesChatEvent):
                 wx: list[tx.Widget] = []
@@ -181,20 +191,24 @@ class ChatApp(tx.App):
 
     #
 
-    _chat_driver_action_task: asyncio.Task[None] | None = None
+    @dc.dataclass(frozen=True)
+    class UserInput:
+        text: str
+
+    _chat_action_task: asyncio.Task[None] | None = None
 
     @logs.async_exception_logging(alog)
-    async def _chat_driver_action_task_main(self) -> None:
+    async def _chat_action_task_main(self) -> None:
         while True:
-            ac = await self._chat_driver_action_queue.get()
+            ac = await self._chat_action_queue.get()
             if ac is None:
                 break
 
-            await alog.debug(lambda: f'Got chat driver action: {ac!r}')
+            await alog.debug(lambda: f'Got chat action: {ac!r}')
 
-            if isinstance(ac, mc.UserMessage):
+            if isinstance(ac, ChatApp.UserInput):
                 try:
-                    await self._chat_driver.send_user_messages([ac])
+                    await self._chat_facade.handle_user_input(ac.text)
                 except Exception as e:  # noqa
                     raise
 
@@ -204,31 +218,32 @@ class ChatApp(tx.App):
     #
 
     async def on_mount(self) -> None:
-        check.state(self._chat_driver_event_task is None)
-        self._chat_driver_event_task = asyncio.create_task(self._chat_driver_event_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_driver_action_task is None)
-        self._chat_driver_action_task = asyncio.create_task(self._chat_driver_action_task_main())
+        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_driver_event_task) is not None:
-            await self._chat_driver_event_queue.put(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_driver_event_task) is not None:
-            await self._chat_driver_event_queue.put(None)
+        if (cet := self._chat_event_task) is not None:
+            await self._chat_event_queue.put(None)
             await cet
 
     @tx.on(InputTextArea.Submitted)
@@ -243,14 +258,22 @@ class ChatApp(tx.App):
             ),
         )
 
-        await self._chat_driver_action_queue.put(mc.UserMessage(event.text))
+        await self._chat_action_queue.put(ChatApp.UserInput(event.text))
 
     #
 
-    async def confirm_tool_use(self, message: str) -> bool:
+    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(message, fut)
+        tcm = ToolConfirmationMessage(
+            outer_message,
+            inner_message,
+            fut,
+        )
 
         async def inner() -> None:
             await self._mount_messages(tcm)

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,16 +3,19 @@ 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 .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
@@ -22,7 +25,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-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=_interface.TextualChatInterface, singleton=True),
     ]
@@ -31,18 +34,17 @@ def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
 
     els.extend([
         inj.bind(_app.ChatApp, singleton=True),
-
-        inj.bind_late(_app.ChatApp, _app.ChatAppGetter),
+        inj.bind_async_late(_app.ChatApp, _app.ChatAppGetter),
     ])
 
     #
 
     els.extend([
-        inj.bind(_app.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=_app.ChatDriverEventQueue,
+            eq=_app.ChatEventQueue,
         )),
     ])
 
@@ -65,4 +67,25 @@ def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
 
     #
 
+    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,
+        ),
+    ])
+
+    #
+
     return inj.as_elements(*els)

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

@@ -1,90 +1,9 @@
-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]
-
-
 ##
 
 
@@ -99,6 +18,7 @@ class TextualChatInterface(ChatInterface):
         self._app = app
 
     async def run(self) -> None:
-        _hack_loggers(self._app.devtools)
+        # FIXME: move lol
+        tx.set_root_logger_to_devtools(self._app.devtools)
 
         await self._app.run_async()

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

@@ -42,7 +42,6 @@
 }
 
 .welcome-message-content {
-    text-align: center;
 }
 
 
@@ -135,8 +134,6 @@
 .tool-confirmation-message-inner {
     width: 1fr;
     height: auto;
-
-    padding: 1;
 }
 
 .tool-confirmation-message-inner-open {
@@ -146,10 +143,16 @@
 .tool-confirmation-message-inner-closed {
 }
 
-.tool-confirmation-message-content {
+.tool-confirmation-message-outer-content {
+}
+
+.tool-confirmation-message-inner-content {
     background: $background;
+
+    margin: 1;
+    padding: 1;
 }
 
 .tool-confirmation-message-controls {
-    margin-top: 1;
+    margin: 1;
 }

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

@@ -31,7 +31,8 @@ class ChatAppToolExecutionConfirmation(ToolExecutionConfirmation):
             # spec=msh.marshal(tce.spec),
         )
 
-        msg = f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}'  # noqa
-
-        if not await self._app().confirm_tool_use(msg):
+        if not await (await self._app()).confirm_tool_use(
+                'Execute requested tool?',
+                json.dumps_pretty(tr_dct),
+        ):
             raise ToolExecutionRequestDeniedError

ommlds/cli/sessions/chat/interfaces/textual/widgets/messages.py

@@ -139,19 +139,26 @@ class ToolConfirmationControls(tx.Static):
 
 
 class ToolConfirmationMessage(Message):
-    def __init__(self, content: str, fut: asyncio.Future[bool]) -> None:
+    def __init__(
+            self,
+            outer_content: str,
+            inner_content: str,
+            fut: asyncio.Future[bool],
+    ) -> None:
         super().__init__()
 
         self.add_class('tool-confirmation-message')
 
-        self._content = content
+        self._outer_content = outer_content
+        self._inner_content = inner_content
         self._fut = fut
 
     def compose(self) -> tx.ComposeResult:
         with tx.Horizontal(classes='tool-confirmation-message-outer'):
             yield tx.Static('? ', classes='tool-confirmation-message-glyph')
             with tx.Vertical(classes='tool-confirmation-message-inner tool-confirmation-message-inner-open'):
-                yield tx.Static(self._content, classes='tool-confirmation-message-content')
+                yield tx.Static(self._outer_content, classes='tool-confirmation-message-outer-content')
+                yield tx.Static(self._inner_content, classes='tool-confirmation-message-inner-content')
                 yield ToolConfirmationControls(classes='tool-confirmation-message-controls')
 
     @tx.on(ToolConfirmationControls.Allowed)
@@ -160,5 +167,6 @@ class ToolConfirmationMessage(Message):
         await inner.query_one(ToolConfirmationControls).remove()
         inner.remove_class('tool-confirmation-message-inner-open')
         inner.add_class('tool-confirmation-message-inner-closed')
+        inner.query_one('.tool-confirmation-message-outer-content', tx.Static).update('Tool use confirmed.')
 
         self._fut.set_result(True)

ommlds/cli/sessions/chat/session.py

@@ -1,9 +1,6 @@
 import typing as ta
 
-from omlish import dataclasses as dc
-
 from ..base import Session
-from .configs import ChatConfig
 from .interfaces.base import ChatInterface
 
 
@@ -11,23 +8,13 @@ from .interfaces.base import ChatInterface
 
 
 @ta.final
-class ChatSession(Session['ChatSession.Config']):
-    """
-    An adapter to the lower level, dumber, non-chat-specific cli 'session' layer. Nothing else takes the kitchen-sink
-    'ChatConfig' object, it's only here for type dispatch in lower layers.
-    """
-
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config, ChatConfig):
-        pass
-
+class ChatSession(Session):
     def __init__(
             self,
-            config: Config,
             *,
             interface: ChatInterface,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
         self._interface = interface
 

ommlds/cli/sessions/completion/configs.py

@@ -1,6 +1,7 @@
 from omlish import dataclasses as dc
 
 from .... import minichain as mc
+from ..configs import SessionConfig
 
 
 ##
@@ -12,10 +13,8 @@ DEFAULT_BACKEND = 'openai'
 ##
 
 
-@dc.dataclass(frozen=True)
-class CompletionConfig:
+@dc.dataclass(frozen=True, kw_only=True)
+class CompletionConfig(SessionConfig):
     content: 'mc.Content'
 
-    _: dc.KW_ONLY
-
     backend: str | None = None

ommlds/cli/sessions/completion/inject.py

@@ -1,4 +1,3 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
@@ -23,7 +22,7 @@ def bind_completion(cfg: CompletionConfig) -> inj.Elements:
     #
 
     els.extend([
-        inj.bind(_session.CompletionSession.Config(**dc.asdict(cfg))),
+        inj.bind(cfg),
         inj.bind(Session, to_ctor=_session.CompletionSession, singleton=True),
     ])
 

ommlds/cli/sessions/completion/session.py

@@ -1,5 +1,4 @@
 from omlish import check
-from omlish import dataclasses as dc
 
 from .... import minichain as mc
 from ...backends.types import CompletionServiceBackendProvider
@@ -10,19 +9,16 @@ from .configs import CompletionConfig
 ##
 
 
-class CompletionSession(Session['CompletionSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config, CompletionConfig):
-        pass
-
+class CompletionSession(Session):
     def __init__(
             self,
-            config: Config,
+            config: CompletionConfig,
             *,
             service_provider: CompletionServiceBackendProvider,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
+        self._config = config
         self._service_provider = service_provider
 
     async def run(self) -> None:

ommlds/cli/sessions/configs.py

@@ -0,0 +1,10 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class SessionConfig(lang.Abstract):
+    pass