ommlds 0.0.0.dev475__py3-none-any.whl → 0.0.0.dev476__py3-none-any.whl

ommlds/cli/main.py

@@ -1,176 +1,331 @@
 """
-See:
- - https://github.com/simonw/llm
- - https://github.com/TheR1D/shell_gpt
- - https://github.com/paul-gauthier/aider
+TODO:
+ - bootstrap lol
 """
+import abc
 import functools
-import os.path
 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.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_secrets
 from .sessions.base import Session
 from .sessions.chat.configs import ChatConfig
 from .sessions.completion.configs import CompletionConfig
 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'),
+]
 
 
-async def _a_main(args: ta.Any = None) -> None:
-    parser = ap.ArgumentParser()
-    parser.add_argument('prompt', nargs='*')
+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()
 
-    parser.add_argument('-b', '--backend', default='openai')
 
-    parser.add_argument('-m', '--model-name')
+##
 
-    parser.add_argument('-C', '--completion', action='store_true')
 
-    parser.add_argument('-n', '--new', action='store_true')
-    parser.add_argument('--ephemeral', action='store_true')
+class Profile(lang.Abstract):
+    @abc.abstractmethod
+    def run(self, argv: ta.Sequence[str]) -> ta.Awaitable[None]:
+        raise NotImplementedError
 
-    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')
+##
 
-    parser.add_argument('-v', '--verbose', action='store_true')
 
-    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')
+# 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: ...
 
-    args = parser.parse_args(args)
+
+class ChatProfile(Profile):
+    _args: ap.Namespace
 
     #
 
-    if args.verbose:
-        logs.configure_standard_logging('DEBUG')
-    else:
-        logs.configure_standard_logging('INFO')
-        logs.silence_noisy_loggers()
+    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,
+            backend=dc.replace(
+                cfg.backend,
+                backend=self._args.backend,
+            ),
+        )
 
     #
 
-    content: mc.Content | None
+    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('message', nargs='*', group='input'),
+        ap.arg('-i', '--interactive', action='store_true', group='input'),
+        ap.arg('-e', '--editor', action='store_true', group='input'),
+    ]
+
+    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.editor:
+            check.arg(not self._args.interactive)
+            check.arg(not self._args.message)
+            raise NotImplementedError
+
+        elif self._args.interactive:
+            check.arg(not self._args.message)
+            return dc.replace(
+                cfg,
+                user=dc.replace(
+                    cfg.user,
+                    interactive=True,
+                ),
+            )
+
+        elif self._args.message:
+            # TODO: '-' -> stdin
+            return dc.replace(
+                cfg,
+                user=dc.replace(
+                    cfg.user,
+                    initial_user_content=' '.join(self._args.message),
+                ),
+            )
 
-    if args.image:
-        content = mc.ImageContent(pimg.open(check.non_empty_str(check.single(args.prompt))))
+        else:
+            raise ValueError('Must specify input')
 
-    elif args.editor:
-        check.arg(not args.prompt)
-        if (ec := edit_text_with_user_editor('', subprocesses)) is None:
-            return
-        content = ec
+    #
 
-    elif args.interactive:
-        if args.prompt:
-            raise ValueError('Must not provide prompt')
-        content = None
+    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,
+            state=dc.replace(
+                cfg.state,
+                state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+            ),
+        )
 
-    elif args.code:
-        if args.prompt:
-            content = ' '.join(args.prompt)
-        else:
-            content = None
+    #
 
-    elif not args.prompt:
-        raise ValueError('Must provide prompt')
+    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,
+            ai=dc.replace(
+                cfg.ai,
+                stream=bool(self._args.stream),
+            ),
+            rendering=dc.replace(
+                cfg.rendering,
+                markdown=bool(self._args.markdown),
+            ),
+        )
 
     #
 
-    # 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()
+    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:
+        return dc.replace(
+            cfg,
+            ai=dc.replace(
+                cfg.ai,
+                enable_tools=(
+                    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
+                ),
+            ),
+            tools=dc.replace(
+                cfg.tools,
+                enabled_tools={  # noqa
+                    *(cfg.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 []),
+                },
+            ),
+        )
 
     #
 
-    session_cfg: ta.Any
+    CODE_CONFIG: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-c', '--code', action='store_true', group='code'),
+    ]
 
-    if args.embed:
-        session_cfg = EmbeddingConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
-        )
+    def configure_code(self, cfg: ChatConfig) -> ChatConfig:
+        if not self._args.code:
+            return cfg
 
-    elif args.completion:
-        session_cfg = CompletionConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
+        cfg = dc.replace(
+            cfg,
+            ai=dc.replace(
+                cfg.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,
+                user=dc.replace(
+                    cfg.user,
+                    initial_system_content=system_content,
+                ),
+            )
+
+        return cfg
+
+    #
+
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        parser = ap.ArgumentParser()
+
+        for grp_name, grp_args in [
+            ('backend', self.BACKEND_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_input(cfg)
+        cfg = self.configure_state(cfg)
+        cfg = self.configure_output(cfg)
+        cfg = self.configure_tools(cfg)
+        cfg = self.configure_code(cfg)
+
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+class CompletionProfile(Profile):
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        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(
+            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={  # noqa
-                *(['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),
         )
 
-    #
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+class EmbedProfile(Profile):
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        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(
+            check.non_empty_str(content),
+            backend=args.backend,
+        )
+
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+PROFILE_TYPES: ta.Mapping[str, type[Profile]] = {
+    'chat': ChatProfile,
+    'complete': CompletionProfile,
+    'embed': EmbedProfile,
+}
+
+
+##
+
+
+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_secrets()
 
-    with inj.create_managed_injector(bind_main(
-            session_cfg=session_cfg,
-            enable_backend_strings=isinstance(session_cfg, ChatConfig),
-    )) as injector:
-        await injector[Session].run()
+    profile_cls = PROFILE_TYPES[args.profile]
+    profile = profile_cls()
+    await profile.run([*unk_args, *args.args])
 
 
 def _main(args: ta.Any = None) -> None:
@@ -179,7 +334,6 @@ def _main(args: ta.Any = None) -> None:
             _a_main,
             args,
         ),
-        # backend='trio',
     )  # 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

@@ -3,7 +3,7 @@ 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,21 @@
+import os
+
+from omdev.home.secrets import load_secrets
+
+
+##
+
+
+def install_secrets() -> None:
+    # FIXME: lol garbage
+    for key in [
+        'ANTHROPIC_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,7 +1,7 @@
 import abc
-import dataclasses as dc
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish.configs import all as cfgs
 

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

@@ -0,0 +1,11 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AiConfig:
+    stream: bool = False
+    silent: bool = False
+    enable_tools: bool = False

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

@@ -2,6 +2,7 @@ from omlish import inject as inj
 from omlish import lang
 
 from ...... import minichain as mc
+from .configs import AiConfig
 from .injection import chat_options_providers
 
 
@@ -15,12 +16,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_ai(
-        *,
-        stream: bool = False,
-        silent: bool = False,
-        enable_tools: bool = False,
-) -> inj.Elements:
+def bind_ai(cfg: AiConfig = AiConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -38,12 +34,12 @@ def bind_ai(
 
     ai_stack = inj.wrapper_binder_helper(_types.AiChatGenerator)
 
-    if stream:
+    if cfg.stream:
         stream_ai_stack = inj.wrapper_binder_helper(_types.StreamAiChatGenerator)
 
         els.append(stream_ai_stack.push_bind(to_ctor=_services.ChatChoicesStreamServiceStreamAiChatGenerator, singleton=True))  # noqa
 
-        if not silent:
+        if not cfg.silent:
             els.append(stream_ai_stack.push_bind(to_ctor=_rendering.RenderingStreamAiChatGenerator, singleton=True))
 
         els.extend([
@@ -54,17 +50,17 @@ def bind_ai(
     else:
         els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
 
-        if not silent:
+        if not cfg.silent:
             els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
 
-    if enable_tools:
+    if cfg.enable_tools:
         els.append(ai_stack.push_bind(to_ctor=_tools.ToolExecutingAiChatGenerator, singleton=True))
 
     els.append(inj.bind(_types.AiChatGenerator, to_key=ai_stack.top))
 
     #
 
-    if enable_tools:
+    if cfg.enable_tools:
         def _provide_tools_chat_choices_options_provider(tc: mc.ToolCatalog) -> _services.ChatChoicesServiceOptionsProvider:  # noqa
             return _services.ChatChoicesServiceOptionsProvider(lambda: [
                 mc.Tool(tce.spec)

ommlds/cli/sessions/chat/chat/ai/rendering.py

@@ -1,10 +1,10 @@
 import typing as ta
 
 from ...... import minichain as mc
-from ...content.messages import MessageContentExtractor
-from ...content.messages import MessageContentExtractorImpl
-from ...rendering.types import ContentRendering
-from ...rendering.types import StreamContentRendering
+from .....content.messages import MessageContentExtractor
+from .....content.messages import MessageContentExtractorImpl
+from .....rendering.types import ContentRendering
+from .....rendering.types import StreamContentRendering
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 

ommlds/cli/sessions/chat/chat/ai/services.py

@@ -4,8 +4,8 @@ from omlish import check
 from omlish import lang
 
 from ...... import minichain as mc
-from ...backends.types import ChatChoicesServiceBackendProvider
-from ...backends.types import ChatChoicesStreamServiceBackendProvider
+from .....backends.types import ChatChoicesServiceBackendProvider
+from .....backends.types import ChatChoicesStreamServiceBackendProvider
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 

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

@@ -0,0 +1,11 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class StateConfig:
+    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'