ommlds 0.0.0.dev514__py3-none-any.whl → 0.0.0.dev516__py3-none-any.whl

ommlds/cli/profiles.py

@@ -0,0 +1,449 @@
+import abc
+import sys
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.argparse import all as ap
+
+from .sessions.chat.configs import ChatConfig
+from .sessions.chat.interfaces.bare.configs import BareInterfaceConfig
+from .sessions.chat.interfaces.configs import InterfaceConfig
+from .sessions.chat.interfaces.textual.configs import TextualInterfaceConfig
+from .sessions.completion.configs import CompletionConfig
+from .sessions.configs import SessionConfig
+from .sessions.embedding.configs import EmbeddingConfig
+
+
+SessionConfigT = ta.TypeVar('SessionConfigT', bound=SessionConfig)
+SessionConfigU = ta.TypeVar('SessionConfigU', bound=SessionConfig)
+
+
+##
+
+
+class Profile(lang.Abstract, ta.Generic[SessionConfigT]):
+    @abc.abstractmethod
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfigT:
+        raise NotImplementedError
+
+
+##
+
+
+class ProfileAspect(lang.Abstract, ta.Generic[SessionConfigT]):
+    @property
+    def name(self) -> str:
+        return lang.camel_to_snake(type(self).__name__).lower()
+
+    @property
+    def default_parser_arg_group(self) -> str | None:
+        return self.name
+
+    @property
+    def parser_args(self) -> ta.Sequence[ap.Arg]:
+        return []
+
+    @ta.final
+    @dc.dataclass(frozen=True)
+    class ConfigureContext(ta.Generic[SessionConfigU]):
+        profile: 'Profile[SessionConfigU]'
+        args: ap.Namespace
+
+    @abc.abstractmethod
+    def configure(self, ctx: ConfigureContext[SessionConfigT], cfg: SessionConfigT) -> SessionConfigT:
+        raise NotImplementedError
+
+
+class AspectProfile(Profile[SessionConfigT], lang.Abstract):
+    @abc.abstractmethod
+    def _build_aspects(self) -> ta.Sequence[ProfileAspect[SessionConfigT]]:
+        return []
+
+    __aspects: ta.Sequence[ProfileAspect[SessionConfigT]]
+
+    @ta.final
+    @property
+    def aspects(self) -> ta.Sequence[ProfileAspect[SessionConfigT]]:
+        try:
+            return self.__aspects
+        except AttributeError:
+            pass
+        self.__aspects = aspects = tuple(self._build_aspects())
+        return aspects
+
+    #
+
+    @abc.abstractmethod
+    def initial_config(self) -> SessionConfigT:
+        raise NotImplementedError
+
+    #
+
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfigT:
+        parser = ap.ArgumentParser()
+
+        pa_grps: dict[str, ta.Any] = {}
+        for a in self.aspects:
+            for pa in a.parser_args:
+                if (pa_gn := lang.opt_coalesce(pa.group, a.default_parser_arg_group)) is not None:
+                    check.non_empty_str(pa_gn)
+                    try:
+                        pa_grp = pa_grps[pa_gn]
+                    except KeyError:
+                        pa_grps[pa_gn] = pa_grp = parser.add_argument_group(pa_gn)
+                    pa_grp.add_argument(*pa.args, **pa.kwargs)
+                else:
+                    parser.add_argument(*pa.args, **pa.kwargs)
+
+        args = parser.parse_args(argv)
+
+        cfg_ctx = ProfileAspect.ConfigureContext(
+            self,
+            args,
+        )
+        cfg = self.initial_config()
+        for a in self.aspects:
+            cfg = a.configure(cfg_ctx, cfg)
+
+        return cfg
+
+
+##
+
+
+class ChatProfile(AspectProfile[ChatConfig]):
+    class Backend(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('-b', '--backend'),
+        ]
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            return dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    backend=dc.replace(
+                        cfg.driver.backend,
+                        backend=ctx.args.backend,
+                    ),
+                ),
+            )
+
+    #
+
+    class Interface(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('-i', '--interactive', action='store_true'),
+            ap.arg('-T', '--textual', action='store_true'),
+            ap.arg('-e', '--editor', action='store_true'),
+        ]
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            if ctx.args.editor:
+                check.arg(not ctx.args.interactive)
+                check.arg(not ctx.args.message)
+                raise NotImplementedError
+
+            if ctx.args.textual:
+                check.isinstance(cfg.interface, BareInterfaceConfig)
+                cfg = dc.replace(
+                    cfg,
+                    interface=TextualInterfaceConfig(**{
+                        f.name: getattr(cfg.interface, f.name)
+                        for f in dc.fields(InterfaceConfig)
+                    }),
+                )
+
+            else:
+                cfg = dc.replace(
+                    cfg,
+                    driver=dc.replace(
+                        cfg.driver,
+                        ai=dc.replace(
+                            cfg.driver.ai,
+                            verbose=True,
+                        ),
+                    ),
+                    interface=dc.replace(
+                        check.isinstance(cfg.interface, BareInterfaceConfig),
+                        interactive=ctx.args.interactive,
+                    ),
+                )
+
+            return cfg
+
+    #
+
+    class Input(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('message', nargs='*'),
+        ]
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            if ctx.args.interactive or ctx.args.textual:
+                check.arg(not ctx.args.message)
+
+            elif ctx.args.message:
+                ps: list[str] = []
+
+                for a in ctx.args.message:
+                    if a == '-':
+                        ps.append(sys.stdin.read())
+
+                    elif a.startswith('@'):
+                        with open(a[1:]) as f:
+                            ps.append(f.read())
+
+                    else:
+                        ps.append(a)
+
+                c = ' '.join(ps)
+
+                cfg = dc.replace(
+                    cfg,
+                    driver=dc.replace(
+                        cfg.driver,
+                        user=dc.replace(
+                            cfg.driver.user,
+                            initial_user_content=c,
+                        ),
+                    ),
+                )
+
+            else:
+                raise ValueError('Must specify input')
+
+            return cfg
+
+    #
+
+    class State(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('-n', '--new', action='store_true'),
+            ap.arg('--ephemeral', action='store_true'),
+        ]
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            return dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    state=dc.replace(
+                        cfg.driver.state,
+                        state='ephemeral' if ctx.args.ephemeral else 'new' if ctx.args.new else 'continue',
+                    ),
+                ),
+            )
+
+    #
+
+    class Output(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('-s', '--stream', action='store_true'),
+            ap.arg('-M', '--markdown', action='store_true'),
+        ]
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            return dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    ai=dc.replace(
+                        cfg.driver.ai,
+                        stream=bool(ctx.args.stream),
+                    ),
+                ),
+                rendering=dc.replace(
+                    cfg.rendering,
+                    markdown=bool(ctx.args.markdown),
+                ),
+            )
+
+    #
+
+    class Tools(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('--enable-fs-tools', action='store_true'),
+            ap.arg('--enable-todo-tools', action='store_true'),
+            # ap.arg('--enable-unsafe-tools-do-not-use-lol', action='store_true'),
+            ap.arg('--enable-test-weather-tool', action='store_true'),
+        ]
+
+        def configure_with_tools(
+                self,
+                ctx: ProfileAspect.ConfigureContext[ChatConfig],
+                cfg: ChatConfig,
+                enabled_tools: ta.Iterable[str],
+        ) -> ChatConfig:
+            check.not_isinstance(enabled_tools, str)
+
+            return dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    ai=dc.replace(
+                        cfg.driver.ai,
+                        enable_tools=True,
+                    ),
+                    tools=dc.replace(
+                        cfg.driver.tools,
+                        enabled_tools={  # noqa
+                            *(cfg.driver.tools.enabled_tools or []),
+                            *enabled_tools,
+                        },
+                    ),
+                ),
+                interface=dc.replace(
+                    cfg.interface,
+                    enable_tools=True,
+                ),
+            )
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            if not (
+                    ctx.args.enable_fs_tools or
+                    ctx.args.enable_todo_tools or
+                    # ctx.args.enable_unsafe_tools_do_not_use_lol or
+                    ctx.args.enable_test_weather_tool
+            ):
+                return cfg
+
+            return self.configure_with_tools(ctx, cfg, {
+                *(['fs'] if ctx.args.enable_fs_tools else []),
+                *(['todo'] if ctx.args.enable_todo_tools else []),
+                *(['weather'] if ctx.args.enable_test_weather_tool else []),
+            })
+
+    #
+
+    class Code(ProfileAspect[ChatConfig]):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+            ap.arg('-c', '--code', action='store_true'),
+        ]
+
+        def configure_for_code(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            cfg = dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    ai=dc.replace(
+                        cfg.driver.ai,
+                        enable_tools=True,
+                    ),
+                ),
+            )
+
+            if ctx.args.new or ctx.args.ephemeral:
+                from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
+                system_content = CODE_AGENT_SYSTEM_PROMPT
+
+                cfg = dc.replace(
+                    cfg,
+                    driver=dc.replace(
+                        cfg.driver,
+                        user=dc.replace(
+                            cfg.driver.user,
+                            initial_system_content=system_content,
+                        ),
+                    ),
+                )
+
+            return cfg
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            if not ctx.args.code:
+                return cfg
+
+            return self.configure_for_code(ctx, cfg)
+
+    #
+
+    def _build_aspects(self) -> ta.Sequence[ProfileAspect[ChatConfig]]:
+        return [
+            *super()._build_aspects(),
+            self.Backend(),
+            self.Interface(),
+            self.Input(),
+            self.State(),
+            self.Output(),
+            self.Tools(),
+            self.Code(),
+        ]
+
+    def initial_config(self) -> ChatConfig:
+        return ChatConfig()
+
+
+#
+
+
+class CodeProfile(ChatProfile):
+    class Tools(ChatProfile.Tools):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = []
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            return self.configure_with_tools(ctx, cfg, {
+                'fs',
+                'todo',
+            })
+
+    class Code(ChatProfile.Code):
+        parser_args: ta.ClassVar[ta.Sequence[ap.Arg]] = []
+
+        def configure(self, ctx: ProfileAspect.ConfigureContext[ChatConfig], cfg: ChatConfig) -> ChatConfig:
+            return self.configure_for_code(ctx, cfg)
+
+
+##
+
+
+class CompletionProfile(Profile):
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
+        parser = ap.ArgumentParser()
+        parser.add_argument('prompt', nargs='*')
+        parser.add_argument('-b', '--backend', default='openai')
+        args = parser.parse_args(argv)
+
+        content = ' '.join(args.prompt)
+
+        cfg = CompletionConfig(
+            content=check.non_empty_str(content),
+            backend=args.backend,
+        )
+
+        return cfg
+
+
+##
+
+
+class EmbedProfile(Profile):
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
+        parser = ap.ArgumentParser()
+        parser.add_argument('prompt', nargs='*')
+        parser.add_argument('-b', '--backend', default='openai')
+        args = parser.parse_args(argv)
+
+        content = ' '.join(args.prompt)
+
+        cfg = EmbeddingConfig(
+            content=check.non_empty_str(content),
+            backend=args.backend,
+        )
+
+        return cfg
+
+
+##
+
+
+PROFILE_TYPES: ta.Mapping[str, type[Profile]] = {
+    'chat': ChatProfile,
+    'code': CodeProfile,
+
+    'complete': CompletionProfile,
+
+    'embed': EmbedProfile,
+}

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

@@ -16,6 +16,7 @@ from omlish.logs import all as logs
 
 from ...... import minichain as mc
 from .....backends.types import BackendName
+from ....types import SessionProfileName
 from ...drivers.events.types import AiDeltaChatEvent
 from ...drivers.events.types import AiMessagesChatEvent
 from ...drivers.types import ChatDriver
@@ -100,6 +101,7 @@ class ChatApp(
             backend_name: BackendName | None = None,
             devtools_setup: tx.DevtoolsSetup | None = None,
             input_history_manager: InputHistoryManager,
+            session_profile_name: SessionProfileName | None = None,
     ) -> None:
         super().__init__()
 
@@ -111,6 +113,7 @@ class ChatApp(
         self._chat_event_queue = chat_event_queue
         self._backend_name = backend_name
         self._input_history_manager = input_history_manager
+        self._session_profile_name = session_profile_name
 
         self._chat_action_queue: asyncio.Queue[ta.Any] = asyncio.Queue()
 
@@ -328,6 +331,7 @@ class ChatApp(
 
         await self._mount_messages(
             WelcomeMessage('\n'.join([
+                *([f'Profile: {self._session_profile_name}'] if self._session_profile_name is not None else []),
                 f'Backend: {self._backend_name or "?"}',
                 f'Dir: {os.getcwd()}',
             ])),
@@ -335,7 +339,7 @@ class ChatApp(
 
     async def on_unmount(self) -> None:
         if (cat := self._chat_action_queue_task) is not None:
-            await self._chat_event_queue.put(None)
+            await self._chat_action_queue.put(None)
             await cat
 
         await self._chat_driver.stop()
@@ -359,7 +363,7 @@ class ChatApp(
             ),
         )
 
-        self._input_history_manager.add(event.text)
+        await self._input_history_manager.add(event.text)
 
         await self._chat_action_queue.put(ChatApp.UserInput(event.text))
 
@@ -371,12 +375,14 @@ class ChatApp(
 
     @tx.on(InputTextArea.HistoryPrevious)
     async def on_input_text_area_history_previous(self, event: InputTextArea.HistoryPrevious) -> None:
+        await self._input_history_manager.load_if_necessary()
         if (entry := self._input_history_manager.get_previous(event.text)) is not None:
             self._get_input_text_area().text = entry
             self._move_input_cursor_to_end()
 
     @tx.on(InputTextArea.HistoryNext)
     async def on_input_text_area_history_next(self, event: InputTextArea.HistoryNext) -> None:
+        await self._input_history_manager.load_if_necessary()
         if (entry := self._input_history_manager.get_next(event.text)) is not None:
             ita = self._get_input_text_area()
             ita.text = entry

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

@@ -1,9 +1,9 @@
 import abc
-import json
 import os
 import typing as ta
 
 from omlish import lang
+from omlish.formats import json
 
 
 ##
@@ -11,11 +11,11 @@ from omlish import lang
 
 class InputHistoryStorage(lang.Abstract):
     @abc.abstractmethod
-    def load(self) -> list[str]:
+    def load(self) -> ta.Awaitable[list[str]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def save(self, entries: ta.Sequence[str]) -> None:
+    def save(self, entries: ta.Sequence[str]) -> ta.Awaitable[None]:
         raise NotImplementedError
 
 
@@ -25,10 +25,10 @@ class InMemoryInputHistoryStorage(InputHistoryStorage):
 
         self._entries: list[str] = []
 
-    def load(self) -> list[str]:
+    async def load(self) -> list[str]:
         return list(self._entries)
 
-    def save(self, entries: ta.Sequence[str]) -> None:
+    async def save(self, entries: ta.Sequence[str]) -> None:
         self._entries = list(entries)
 
 
@@ -38,26 +38,31 @@ class FileInputHistoryStorage(InputHistoryStorage):
 
         self._path = path
 
-    def load(self) -> list[str]:
+    async def load(self) -> list[str]:
         if not os.path.exists(self._path):
             return []
 
         try:
-            with open(self._path) as f:
-                data = json.load(f)
-                if isinstance(data, list) and all(isinstance(e, str) for e in data):
-                    return data
-                return []
-        except (json.JSONDecodeError, OSError):
+            with open(self._path) as f:  # noqa
+                content = f.read()
+        except OSError:
             return []
 
-    def save(self, entries: ta.Sequence[str]) -> None:
+        data = json.loads(content)
+
+        if isinstance(data, list) and all(isinstance(e, str) for e in data):
+            return data
+        return []
+
+    async def save(self, entries: ta.Sequence[str]) -> None:
+        content = json.dumps_pretty(list(entries))
+        dir_path = os.path.dirname(self._path)
+
         try:
-            dir_path = os.path.dirname(self._path)
             if dir_path:
                 os.makedirs(dir_path, exist_ok=True)
-            with open(self._path, 'w') as f:
-                json.dump(list(entries), f, indent=2)
+            with open(self._path, 'w') as f:  # noqa
+                f.write(content)
         except OSError:
             pass
 
@@ -88,16 +93,34 @@ class InputHistoryManager:
         self._storage = storage
         self._max_entries = max_entries
 
-        self._entries: list[str] = self._storage.load()
-        self._position: int = len(self._entries)
-        self._current_draft: str = ''
+    #
+
+    _entries: list[str]
+    _position: int = 0
+
+    async def load_if_necessary(self) -> None:
+        try:
+            self._entries  # noqa
+        except AttributeError:
+            pass
+        else:
+            return
+
+        self._entries = await self._storage.load()
+        self._position = len(self._entries)
 
-    def add(self, text: str) -> None:
+    #
+
+    _current_draft: str = ''
+
+    async def add(self, text: str) -> None:
         """Add a new history entry and reset position."""
 
         if not text.strip():
             return
 
+        await self.load_if_necessary()
+
         # Don't add duplicate consecutive entries
         if self._entries and self._entries[-1] == text:
             self.reset_position()
@@ -109,7 +132,7 @@ class InputHistoryManager:
         if len(self._entries) > self._max_entries:
             self._entries = self._entries[-self._max_entries:]
 
-        self._storage.save(self._entries)
+        await self._storage.save(self._entries)
         self.reset_position()
 
     def get_previous(self, text: str | None = None) -> str | None:
@@ -123,20 +146,24 @@ class InputHistoryManager:
             The previous history entry, or None if at the beginning
         """
 
-        if not self._entries:
+        try:
+            entries = self._entries
+        except AttributeError:
+            return None
+        if entries:
             return None
 
         # Save current draft if we're at the end
-        if self._position == len(self._entries) and text is not None:
+        if self._position == len(entries) and text is not None:
             self._current_draft = text
 
         # Move to previous entry
         if self._position > 0:
             self._position -= 1
-            return self._entries[self._position]
+            return entries[self._position]
 
         # Already at oldest entry
-        return self._entries[0] if self._entries else None
+        return entries[0] if entries else None
 
     def get_next(self, text: str | None = None) -> str | None:
         """
@@ -149,20 +176,24 @@ class InputHistoryManager:
             The next history entry, the saved draft if moving past the end, or None
         """
 
-        if not self._entries:
+        try:
+            entries = self._entries
+        except AttributeError:
+            return None
+        if entries:
             return None
 
         # Move to next entry
-        if self._position < len(self._entries):
+        if self._position < len(entries):
             self._position += 1
 
             # If we moved past the end, return the draft
-            if self._position == len(self._entries):
+            if self._position == len(entries):
                 draft = self._current_draft
                 self._current_draft = ''
                 return draft
 
-            return self._entries[self._position]
+            return entries[self._position]
 
         # Already at newest position
         return None
@@ -170,5 +201,11 @@ class InputHistoryManager:
     def reset_position(self) -> None:
         """Reset history position to the end (no history item selected)."""
 
-        self._position = len(self._entries)
+        try:
+            entries = self._entries
+        except AttributeError:
+            self._position = 0
+        else:
+            self._position = len(entries)
+
         self._current_draft = ''