ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/cli/main.py

@@ -1,182 +1,415 @@
 """
-See:
- - https://github.com/simonw/llm
- - https://github.com/TheR1D/shell_gpt
- - https://github.com/paul-gauthier/aider
+TODO:
+ - bootstrap lol
 """
-import argparse
+import abc
 import functools
-import os.path
 import sys
 import typing as ta
 
 import anyio
 
-from omdev.home.secrets import load_secrets
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
-from omlish.diag import pycharm
+from omlish.argparse import all as ap
 from omlish.logs import all as logs
-from omlish.subprocesses.editor import edit_text_with_user_editor
-from omlish.subprocesses.sync import subprocesses
 
-from .. import minichain as mc
 from .inject import bind_main
+from .secrets import install_env_secrets
 from .sessions.base import Session
 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
 
 
-if ta.TYPE_CHECKING:
-    import PIL.Image as pimg  # noqa
-else:
-    pimg = lang.proxy_import('PIL.Image')
+##
+
+
+MAIN_EXTRA_ARGS: ta.Sequence[ap.Arg] = [
+    ap.arg('-v', '--verbose', action='store_true'),
+]
+
+
+def _process_main_extra_args(args: ap.Namespace) -> None:
+    if args.verbose:
+        logs.configure_standard_logging('DEBUG')
+    else:
+        logs.configure_standard_logging('INFO')
+
+    logs.silence_noisy_loggers()
 
 
 ##
 
 
-async def _a_main(args: ta.Any = None) -> None:
-    logs.configure_standard_logging('INFO')
+class Profile(lang.Abstract):
+    @abc.abstractmethod
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
+        raise NotImplementedError
 
-    #
 
-    parser = argparse.ArgumentParser()
-    parser.add_argument('prompt', nargs='*')
+##
 
-    parser.add_argument('-b', '--backend', default='openai')
 
-    parser.add_argument('-m', '--model-name')
+# class ChatAspect(lang.Abstract):
+#     def get_parser_args(self) -> ta.Sequence[ap.Arg]: ...
+#     def set_args(self, args: ap.Namespace) -> None: ...
+#     def configure(self, cfg: ChatConfig) -> ChatConfig: ...
 
-    parser.add_argument('-C', '--completion', action='store_true')
 
-    parser.add_argument('-n', '--new', action='store_true')
-    parser.add_argument('--ephemeral', action='store_true')
+class ChatProfile(Profile):
+    _args: ap.Namespace
 
-    parser.add_argument('-e', '--editor', action='store_true')
-    parser.add_argument('-i', '--interactive', action='store_true')
-    parser.add_argument('-c', '--code', action='store_true')
-    parser.add_argument('-s', '--stream', action='store_true')
-    parser.add_argument('-M', '--markdown', action='store_true')
+    #
 
-    parser.add_argument('-E', '--embed', action='store_true')
-    parser.add_argument('-j', '--image', action='store_true')
+    BACKEND_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-b', '--backend', group='backend'),
+    ]
+
+    def configure_backend(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            driver=dc.replace(
+                cfg.driver,
+                backend=dc.replace(
+                    cfg.driver.backend,
+                    backend=self._args.backend,
+                ),
+            ),
+        )
 
-    parser.add_argument('--enable-fs-tools', action='store_true')
-    parser.add_argument('--enable-todo-tools', action='store_true')
-    parser.add_argument('--enable-unsafe-tools-do-not-use-lol', action='store_true')
-    parser.add_argument('--enable-test-weather-tool', action='store_true')
-    parser.add_argument('--dangerous-no-tool-confirmation', action='store_true')
+    #
 
-    args = parser.parse_args(args)
+    INTERFACE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-i', '--interactive', action='store_true', group='interface'),
+        ap.arg('-T', '--textual', action='store_true', group='interface'),
+        ap.arg('-e', '--editor', action='store_true', group='interface'),
+    ]
+
+    def configure_interface(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.editor:
+            check.arg(not self._args.interactive)
+            check.arg(not self._args.message)
+            raise NotImplementedError
+
+        if self._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=self._args.interactive,
+                ),
+            )
+
+        return cfg
 
     #
 
-    content: mc.Content | None
+    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('message', nargs='*', group='input'),
+    ]
 
-    if args.image:
-        content = mc.ImageContent(pimg.open(check.non_empty_str(check.single(args.prompt))))
+    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.interactive or self._args.textual:
+            check.arg(not self._args.message)
 
-    elif args.editor:
-        check.arg(not args.prompt)
-        if (ec := edit_text_with_user_editor('', subprocesses)) is None:
-            return
-        content = ec
+        elif self._args.message:
+            ps: list[str] = []
 
-    elif args.interactive:
-        if args.prompt:
-            raise ValueError('Must not provide prompt')
-        content = None
+            for a in self._args.message:
+                if a == '-':
+                    ps.append(sys.stdin.read())
 
-    elif args.code:
-        if args.prompt:
-            content = ' '.join(args.prompt)
-        else:
-            content = None
+                elif a.startswith('@'):
+                    with open(a[1:]) as f:
+                        ps.append(f.read())
 
-    elif not args.prompt:
-        raise ValueError('Must provide prompt')
+                else:
+                    ps.append(a)
 
-    else:
-        prompt = ' '.join(args.prompt)
+            c = ' '.join(ps)
+
+            cfg = dc.replace(
+                cfg,
+                driver=dc.replace(
+                    cfg.driver,
+                    user=dc.replace(
+                        cfg.driver.user,
+                        initial_user_content=c,
+                    ),
+                ),
+            )
 
-        # FIXME: ptk / maysync
-        if not sys.stdin.isatty() and not pycharm.is_pycharm_hosted():
-            stdin_data = sys.stdin.read()
-            prompt = '\n'.join([prompt, stdin_data])
+        else:
+            raise ValueError('Must specify input')
 
-        content = prompt
+        return cfg
 
     #
 
-    # FIXME: lol garbage
-    for key in [
-        'OPENAI_API_KEY',
-        'HUGGINGFACE_TOKEN',
-        'TAVILY_API_KEY',
-        'ANTHROPIC_API_KEY',
-        'MISTRAL_API_KEY',
-        'GEMINI_API_KEY',
-    ]:
-        if (sec := load_secrets().try_get(key.lower())) is not None:
-            os.environ[key] = sec.reveal()
+    STATE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-n', '--new', action='store_true', group='state'),
+        ap.arg('--ephemeral', action='store_true', group='state'),
+    ]
+
+    def configure_state(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            driver=dc.replace(
+                cfg.driver,
+                state=dc.replace(
+                    cfg.driver.state,
+                    state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+                ),
+            ),
+        )
 
     #
 
-    session_cfg: ta.Any
+    OUTPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-s', '--stream', action='store_true', group='output'),
+        ap.arg('-M', '--markdown', action='store_true', group='output'),
+    ]
+
+    def configure_output(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            driver=dc.replace(
+                cfg.driver,
+                ai=dc.replace(
+                    cfg.driver.ai,
+                    stream=bool(self._args.stream),
+                ),
+            ),
+            rendering=dc.replace(
+                cfg.rendering,
+                markdown=bool(self._args.markdown),
+            ),
+        )
 
-    if args.embed:
-        session_cfg = EmbeddingConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
+    #
+
+    TOOLS_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('--enable-fs-tools', action='store_true', group='tools'),
+        ap.arg('--enable-todo-tools', action='store_true', group='tools'),
+        # ap.arg('--enable-unsafe-tools-do-not-use-lol', action='store_true', group='tools'),
+        ap.arg('--enable-test-weather-tool', action='store_true', group='tools'),
+    ]
+
+    def configure_tools(self, cfg: ChatConfig) -> ChatConfig:
+        if not (
+                self._args.enable_fs_tools or
+                self._args.enable_todo_tools or
+                # self._args.enable_unsafe_tools_do_not_use_lol or
+                self._args.enable_test_weather_tool or
+                self._args.code
+        ):
+            return cfg
+
+        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 []),
+                        *(['fs'] if self._args.enable_fs_tools else []),
+                        *(['todo'] if self._args.enable_todo_tools else []),
+                        *(['weather'] if self._args.enable_test_weather_tool else []),
+                    },
+                ),
+            ),
+            interface=dc.replace(
+                cfg.interface,
+                enable_tools=True,
+            ),
         )
 
-    elif args.completion:
-        session_cfg = CompletionConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
+    #
+
+    CODE_CONFIG: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-c', '--code', action='store_true', group='code'),
+    ]
+
+    def configure_code(self, cfg: ChatConfig) -> ChatConfig:
+        if not self._args.code:
+            return cfg
+
+        cfg = dc.replace(
+            cfg,
+            driver=dc.replace(
+                cfg.driver,
+                ai=dc.replace(
+                    cfg.driver.ai,
+                    enable_tools=True,
+                ),
+            ),
         )
 
-    else:
-        system_content: mc.Content | None = None
-        if (args.new or args.ephemeral) and args.code:
+        if self._args.new or self._args.ephemeral:
             from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
             system_content = CODE_AGENT_SYSTEM_PROMPT
 
-        session_cfg = ChatConfig(
+            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, argv: ta.Sequence[str]) -> SessionConfig:
+        parser = ap.ArgumentParser()
+
+        for grp_name, grp_args in [
+            ('backend', self.BACKEND_ARGS),
+            ('interface', self.INTERFACE_ARGS),
+            ('input', self.INPUT_ARGS),
+            ('state', self.STATE_ARGS),
+            ('output', self.OUTPUT_ARGS),
+            ('tools', self.TOOLS_ARGS),
+            ('code', self.CODE_CONFIG),
+        ]:
+            grp = parser.add_argument_group(grp_name)
+            for a in grp_args:
+                grp.add_argument(*a.args, **a.kwargs)
+
+        self._args = parser.parse_args(argv)
+
+        cfg = ChatConfig()
+        cfg = self.configure_backend(cfg)
+        cfg = self.configure_interface(cfg)
+        cfg = self.configure_input(cfg)
+        cfg = self.configure_state(cfg)
+        cfg = self.configure_output(cfg)
+        cfg = self.configure_tools(cfg)
+        cfg = self.configure_code(cfg)
+
+        return 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,
-            model_name=args.model_name,
-            state='ephemeral' if args.ephemeral else 'new' if args.new else 'continue',
-            initial_system_content=system_content,
-            initial_user_content=content,  # noqa
-            interactive=bool(args.interactive),
-            markdown=bool(args.markdown),
-            stream=bool(args.stream),
-            enable_tools=(
-                args.enable_fs_tools or
-                args.enable_todo_tools or
-                args.enable_unsafe_tools_do_not_use_lol or
-                args.enable_test_weather_tool or
-                args.code
-            ),
-            enabled_tools={
-                *(['fs'] if args.enable_fs_tools else []),
-                *(['todo'] if args.enable_todo_tools else []),
-                *(['weather'] if args.enable_test_weather_tool else []),
-                # FIXME: enable_unsafe_tools_do_not_use_lol
-            },
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
         )
 
-    #
+        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,
+    'complete': CompletionProfile,
+    'embed': EmbedProfile,
+}
+
+
+##
 
-    with inj.create_managed_injector(bind_main(
+
+async def _run_session_cfg(session_cfg: SessionConfig) -> None:
+    async with inj.create_async_managed_injector(bind_main(
             session_cfg=session_cfg,
-            enable_backend_strings=isinstance(session_cfg, ChatConfig),
     )) as injector:
-        await injector[Session].run()
+        await (await injector[Session]).run()
+
+
+##
+
+
+MAIN_PROFILE_ARGS: ta.Sequence[ap.Arg] = [
+    ap.arg('-p', '--profile', default='chat'),
+    ap.arg('args', nargs=ap.REMAINDER),
+]
+
+
+async def _a_main(argv: ta.Any = None) -> None:
+    parser = ap.ArgumentParser()
+
+    for a in [*MAIN_PROFILE_ARGS, *MAIN_EXTRA_ARGS]:
+        parser.add_argument(*a.args, **a.kwargs)
+
+    args, unk_args = parser.parse_known_args(argv)
+
+    _process_main_extra_args(args)
+
+    install_env_secrets()
+
+    profile_cls = PROFILE_TYPES[args.profile]
+    profile = profile_cls()
+
+    session_cfg = profile.configure([*unk_args, *args.args])
+
+    await _run_session_cfg(session_cfg)
 
 
 def _main(args: ta.Any = None) -> None:
@@ -185,7 +418,6 @@ def _main(args: ta.Any = None) -> None:
             _a_main,
             args,
         ),
-        backend='asyncio',
     )  # noqa
 
 

ommlds/cli/rendering/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class RenderingConfig:
+    markdown: bool = False

ommlds/cli/{sessions/chat/rendering → rendering}/inject.py

@@ -1,6 +1,8 @@
 from omlish import inject as inj
 from omlish import lang
 
+from .configs import RenderingConfig
+
 
 with lang.auto_proxy_import(globals()):
     from . import markdown as _markdown
@@ -11,13 +13,10 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_rendering(
-        *,
-        markdown: bool = False,
-) -> inj.Elements:
+def bind_rendering(cfg: RenderingConfig = RenderingConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
-    if markdown:
+    if cfg.markdown:
         els.extend([
             inj.bind(_types.ContentRendering, to_ctor=_markdown.MarkdownContentRendering, singleton=True),
             inj.bind(_types.StreamContentRendering, to_ctor=_markdown.MarkdownStreamContentRendering, singleton=True),

ommlds/cli/{sessions/chat/rendering → rendering}/markdown.py

@@ -3,7 +3,7 @@ import typing as ta
 from omdev.tui import rich
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 from ..content.strings import ContentStringifier
 from ..content.strings import HasContentStringifier
 from .types import ContentRendering

ommlds/cli/{sessions/chat/rendering → rendering}/raw.py

@@ -2,7 +2,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 from ..content.strings import ContentStringifier
 from ..content.strings import HasContentStringifier
 from .types import ContentRendering

ommlds/cli/{sessions/chat/rendering → rendering}/types.py

@@ -1,9 +1,15 @@
+"""
+TODO:
+ - html?
+ - terminal?
+ - rich? textual.Content?
+"""
 import abc
 import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##

ommlds/cli/secrets.py

@@ -0,0 +1,22 @@
+import os
+
+from omdev.home.secrets import load_secrets
+
+
+##
+
+
+def install_env_secrets() -> None:
+    # FIXME: lol garbage
+    for key in [
+        'ANTHROPIC_API_KEY',
+        'CEREBRAS_API_KEY',
+        'GEMINI_API_KEY',
+        'GROQ_API_KEY',
+        'HUGGINGFACE_TOKEN',
+        'MISTRAL_API_KEY',
+        'OPENAI_API_KEY',
+        'TAVILY_API_KEY',
+    ]:
+        if (sec := load_secrets().try_get(key.lower())) is not None:
+            os.environ[key] = sec.reveal()

ommlds/cli/sessions/base.py

@@ -1,22 +1,13 @@
 import abc
-import dataclasses as dc
 import typing as ta
 
 from omlish import lang
-from omlish.configs import all as cfgs
-
-
-SessionConfigT = ta.TypeVar('SessionConfigT', bound='Session.Config')
 
 
 ##
 
 
-class Session(cfgs.Configurable[SessionConfigT], lang.Abstract):
-    @dc.dataclass(frozen=True)
-    class Config(cfgs.Configurable.Config):
-        pass
-
+class Session(lang.Abstract):
     @abc.abstractmethod
     def run(self) -> ta.Awaitable[None]:
         raise NotImplementedError