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

ommlds/specs/mcp/protocol.py

@@ -0,0 +1,369 @@
+"""
+https://modelcontextprotocol.io/specification/2025-06-18
+https://modelcontextprotocol.io/specification/2025-06-18/schema
+
+TODO:
+ - https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/cancellation
+ - https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/progress
+ - https://modelcontextprotocol.io/specification/2025-06-18/client/sampling
+ - https://modelcontextprotocol.io/specification/2025-06-18/client/elicitation
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/prompts
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/resources
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/logging
+"""
+import abc
+import typing as ta
+
+from omlish import collections as col
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+
+
+ClientRequestT = ta.TypeVar('ClientRequestT', bound='ClientRequest')
+ClientResultT = ta.TypeVar('ClientResultT', bound='ClientResult')
+
+ServerRequestT = ta.TypeVar('ServerRequestT', bound='ServerRequest')
+ServerResultT = ta.TypeVar('ServerResultT', bound='ServerResult')
+
+CursorClientRequestT = ta.TypeVar('CursorClientRequestT', bound='CursorClientRequest')
+CursorClientResultT = ta.TypeVar('CursorClientResultT', bound='CursorClientResult')
+
+
+msh.register_global_module_import('._marshal', __package__)
+
+
+##
+
+
+def _set_class_marshal_options(cls):
+    msh.update_object_options(
+        cls,
+        field_naming=msh.Naming.LOW_CAMEL,
+        field_defaults=msh.FieldOptions(
+            omit_if=lang.is_none,
+        ),
+    )
+    return cls
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Message(lang.Sealed, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def json_rpc_method_name(self) -> str:
+        raise NotImplementedError
+
+
+#
+
+
+class ClientRequest(Message, lang.Abstract, ta.Generic[ClientResultT]):
+    pass
+
+
+class ClientResult(Message, lang.Abstract, ta.Generic[ClientRequestT]):
+    pass
+
+
+#
+
+
+class ServerRequest(Message, lang.Abstract, ta.Generic[ServerResultT]):
+    pass
+
+
+class ServerResult(Message, lang.Abstract, ta.Generic[ServerRequestT]):
+    pass
+
+
+#
+
+
+class Notification(Message, lang.Abstract):
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class WithMeta(lang.Sealed, lang.Abstract):
+    meta_: ta.Mapping[str, ta.Any] | None = dc.field(default=None) | msh.with_field_options(name='_meta')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Implementation(lang.Final):
+    name: str
+    version: str
+
+
+DEFAULT_PROTOCOL_VERSION = '2025-06-18'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ClientCapabilities(lang.Final):
+    elicitation: ta.Any | None = None
+
+    experimental: ta.Mapping[str, ta.Any] | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Roots:
+        list_changed: bool | None = None
+
+    roots: Roots | None = None
+
+    sampling: ta.Any | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializeRequest(ClientRequest['InitializeResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialize'
+
+    client_info: Implementation
+    protocol_version: str = DEFAULT_PROTOCOL_VERSION
+    capabilities: ClientCapabilities = ClientCapabilities()
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ServerCapabilities:
+    completions: ta.Any | None = None
+
+    experimental: ta.Mapping[str, ta.Any] | None = None
+
+    logging: ta.Any | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Prompts:
+        list_changed: bool | None = None
+
+    prompts: Prompts | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Resources:
+        list_changed: bool | None = None
+        subscribe: bool | None = None
+
+    resources: Resources | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Tools:
+        list_changed: bool | None = None
+
+    tools: Tools | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializeResult(ClientResult[InitializeRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialize'
+
+    server_info: Implementation
+    protocol_version: str
+    capabilities: ServerCapabilities
+    instructions: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializedNotification(Notification):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialized'
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CursorClientRequest(ClientRequest[CursorClientResultT], lang.Abstract):
+    cursor: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CursorClientResult(ClientResult[CursorClientRequestT], lang.Abstract):
+    next_cursor: str | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ToolAnnotations(lang.Final):
+    destructive_hint: bool | None = None
+    idempotent_hint: bool | None = None
+    open_world_hint: bool | None = None
+    read_only_hint: bool | None = None
+    title: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Tool(WithMeta, lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    annotations: ToolAnnotations | None = None
+
+    input_schema: ta.Any
+    output_schema: ta.Any | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListToolsRequest(CursorClientRequest['ListToolsResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/list'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListToolsResult(CursorClientResult[ListToolsRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/list'
+
+    tools: ta.Sequence[Tool]
+
+
+##
+
+
+class ContentBlock(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class TextContentBlock(ContentBlock, lang.Final):
+    text: str
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class CallToolRequest(ClientRequest['CallToolResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/call'
+
+    name: str
+    arguments: ta.Mapping[str, ta.Any] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class CallToolResult(ClientResult[CallToolRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/call'
+
+    content: ta.Sequence[ContentBlock]
+    is_error: bool | None = None
+    structured_content: ta.Mapping[str, ta.Any] | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingClientRequest(ClientRequest['PingClientResult'], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingClientResult(ClientResult[PingClientRequest]):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingServerRequest(ServerRequest['PingServerResult'], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingServerResult(ServerResult[PingServerRequest]):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PromptArgument(lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    required: bool | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Prompt(WithMeta, lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    arguments: ta.Sequence[PromptArgument] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListPromptsRequest(CursorClientRequest['ListPromptsResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'prompts/list'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListPromptsResult(CursorClientResult[ListPromptsRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'prompts/list'
+
+    prompts: ta.Sequence[Prompt]
+
+
+##
+
+
+LoggingLevel: ta.TypeAlias = ta.Literal[
+    'debug',
+    'info',
+    'notice',
+    'warning',
+    'error',
+    'critical',
+    'alert',
+    'emergency',
+]
+
+
+##
+
+
+MESSAGE_TYPES_BY_JSON_RPC_METHOD_NAME: ta.Mapping[type[Message], ta.Mapping[str, type[Message]]] = {
+    bty: col.make_map_by(lambda mty: mty.json_rpc_method_name, lang.deep_subclasses(bty, concrete_only=True))  # type: ignore  # noqa
+    for bty in [
+        ClientRequest,
+        ClientResult,
+        ServerRequest,
+        ServerResult,
+        Notification,
+    ]
+}

ommlds/tools/git.py

@@ -3,30 +3,25 @@ TODO:
  - move omit magic to omdev lol
 """
 import abc
-import concurrent.futures as cf
 import dataclasses as dc
-import os.path
 import re
 import typing as ta
 import urllib.request
 
 from omdev.git.magic import GIT_DIFF_OMIT_MAGIC_COMMENT
-from omdev.home.secrets import load_secrets
+from omdev.py.srcheaders import get_py_header_lines
 from omdev.tools.git.messages import GitMessageGenerator
 from omlish import check
 from omlish import lang
 from omlish.configs.classes import Configurable
+from omlish.http import all as http
 from omlish.subprocesses.sync import subprocesses
 
 from .. import minichain as mc
-from ..minichain.backends.impls.openai.chat import OpenaiChatChoicesService
+from ..cli.secrets import install_env_secrets
 from ..server.client import McServerClient
 
 
-with lang.auto_proxy_import(globals()):
-    from ..minichain.backends.impls.mlx import chat as mc_mlx_chat
-
-
 GitAiBackendConfigT = ta.TypeVar('GitAiBackendConfigT', bound='GitAiBackend.Config')
 
 
@@ -34,7 +29,7 @@ GitAiBackendConfigT = ta.TypeVar('GitAiBackendConfigT', bound='GitAiBackend.Conf
 
 
 class GitAiBackend(Configurable[GitAiBackendConfigT], lang.Abstract):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(Configurable.Config):
         max_tokens: int | None = 128
 
@@ -62,21 +57,36 @@ def _get_single_ai_message_str(resp: mc.ChatChoicesResponse) -> str:
 #
 
 
-class OpenaiGitAiBackend(GitAiBackend['OpenaiGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+class StandardGitAiBackend(GitAiBackend['StandardGitAiBackend.Config']):
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
-        pass
+        backend: str | None = None
 
-    def __init__(self, config: Config = Config()) -> None:
+    DEFAULT_BACKEND_NAME: str = 'openai'
+
+    def __init__(
+            self,
+            config: Config = Config(),
+            *,
+            backend_catalog: ta.Optional['mc.BackendCatalog'] = None,
+    ) -> None:
         super().__init__(config)
 
+        if backend_catalog is None:
+            backend_catalog = mc.BackendStringBackendCatalog()
+        self._backend_catalog = backend_catalog
+
     def run_prompt(self, prompt: str) -> str:
-        # FIXME:
-        for key in ['OPENAI_API_KEY']:
-            if (sec := load_secrets().try_get(key.lower())) is not None:
-                os.environ[key] = sec.reveal()
+        install_env_secrets()  # FIXME
+
+        be = self._backend_catalog.get_backend(
+            mc.ChatChoicesService,  # type: ignore[type-abstract]
+            self._config.backend or self.DEFAULT_BACKEND_NAME,
+        )
 
-        llm = OpenaiChatChoicesService()
+        llm = be.factory(
+            http_client=http.SyncAsyncHttpClient(http.client()),  # FIXME
+        )
 
         resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
             [mc.UserMessage(prompt)],
@@ -94,51 +104,51 @@ def _strip_markdown_code_block(text: str) -> str:
     return match.group(1)
 
 
-class MlxGitAiBackend(GitAiBackend['MlxGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(GitAiBackend.Config):
-        model: str = 'mlx-community/Qwen2.5-Coder-32B-Instruct-8bit'
-
-        run_in_subprocess: bool = True
-        subprocess_timeout: float | None = 60.
-
-    def __init__(self, config: Config = Config()) -> None:
-        super().__init__(config)
-
-    def _run_prompt(self, prompt: str) -> str:
-        with mc_mlx_chat.MlxChatChoicesService(mc.ModelRepo.parse(self._config.model)) as llm:
-            resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
-                [mc.UserMessage(prompt)],
-                # FIXME: *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
-            )))
-            text = _get_single_ai_message_str(resp)
-
-            text = _strip_markdown_code_block(text)
-
-            return text
-
-    def run_prompt(self, prompt: str) -> str:
-        if self._config.run_in_subprocess:
-            # tokenizers installs a pthread_atfork callback at *import* time:
-            #   https://github.com/huggingface/tokenizers/blob/4f1a810aa258d287e6936315e63fbf58bde2a980/bindings/python/src/lib.rs#L57
-            # then complains about `TOKENIZERS_PARALLELISM` at the next fork (which presumably will happen immediately
-            # after this to `git commit`, despite it being conceptually just a fork/exe).
-            # TODO: a generic subprocessing minichain service wrapper?
-            with cf.ProcessPoolExecutor() as exe:
-                return exe.submit(
-                    self._run_prompt,
-                    prompt,
-                ).result(timeout=self._config.subprocess_timeout)
-
-        else:
-            return self._run_prompt(prompt)
+# class MlxGitAiBackend(GitAiBackend['MlxGitAiBackend.Config']):
+#     @dc.dataclass(frozen=True, kw_only=True)
+#     class Config(GitAiBackend.Config):
+#         model: str = 'mlx-community/Qwen2.5-Coder-32B-Instruct-8bit'
+#
+#         run_in_subprocess: bool = True
+#         subprocess_timeout: float | None = 60.
+#
+#     def __init__(self, config: Config = Config()) -> None:
+#         super().__init__(config)
+#
+#     def _run_prompt(self, prompt: str) -> str:
+#         with mc_mlx_chat.MlxChatChoicesService(mc.ModelRepo.parse(self._config.model)) as llm:
+#             resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
+#                 [mc.UserMessage(prompt)],
+#                 # FIXME: *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
+#             )))
+#             text = _get_single_ai_message_str(resp)
+#
+#             text = _strip_markdown_code_block(text)
+#
+#             return text
+#
+#     def run_prompt(self, prompt: str) -> str:
+#         if self._config.run_in_subprocess:
+#             # tokenizers installs a pthread_atfork callback at *import* time:
+#             #   https://github.com/huggingface/tokenizers/blob/4f1a810aa258d287e6936315e63fbf58bde2a980/bindings/python/src/lib.rs#L57  # noqa
+#             # then complains about `TOKENIZERS_PARALLELISM` at the next fork (which presumably will happen immediately
+#             # after this to `git commit`, despite it being conceptually just a fork/exe).
+#             # TODO: a generic subprocessing minichain service wrapper?
+#             with cf.ProcessPoolExecutor() as exe:
+#                 return exe.submit(
+#                     self._run_prompt,
+#                     prompt,
+#                 ).result(timeout=self._config.subprocess_timeout)
+#
+#         else:
+#             return self._run_prompt(prompt)
 
 
 #
 
 
 class LocalhostHttpPostGitAiBackend(GitAiBackend['LocalhostHttpPostGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
         port: int = 5067
         path: str = ''
@@ -162,7 +172,7 @@ class LocalhostHttpPostGitAiBackend(GitAiBackend['LocalhostHttpPostGitAiBackend.
 
 
 class McServerGitAiBackend(GitAiBackend['McServerGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
         pass
 
@@ -188,18 +198,23 @@ class AiGitMessageGenerator(GitMessageGenerator):
     def __init__(
             self,
             *,
-            backend: GitAiBackend | None = None,
+            backend: GitAiBackend | str | None = None,
     ) -> None:
         super().__init__()
 
         if backend is None:
             backend = self.DEFAULT_BACKEND
-        self._backend = backend
+        elif isinstance(backend, str):
+            backend = StandardGitAiBackend(
+                config=StandardGitAiBackend.Config(
+                    backend=backend,
+                ),
+            )
+        self._backend = check.isinstance(backend, GitAiBackend)
 
     DEFAULT_BACKEND: ta.ClassVar[GitAiBackend] = (
-        OpenaiGitAiBackend()
+        StandardGitAiBackend()
         # LocalhostHttpPostGitAiBackend()
-        # MlxGitAiBackend()
         # McServerGitAiBackend()
     )
 
@@ -213,9 +228,14 @@ class AiGitMessageGenerator(GitMessageGenerator):
         except FileNotFoundError:
             return False
 
+        hls = get_py_header_lines(f_src)
+
         return any(
-            l.startswith(GIT_DIFF_OMIT_MAGIC_COMMENT)
-            for l in f_src.splitlines()
+            hl.src.strip() in (
+                '# @omlish-generated',
+                GIT_DIFF_OMIT_MAGIC_COMMENT,
+            )
+            for hl in hls
         )
 
     # TODO: configurable

ommlds/tools/ocr.py

@@ -18,7 +18,7 @@ with lang.auto_proxy_import(globals()):
     import rapidocr_onnxruntime as rapidocr
     from PIL import Image
 
-    from omdev.clipboard import darwin_cf as darwin_clipboard
+    from omdev.clipboard.capi import darwin_cf as darwin_clipboard
 
 
 ##

ommlds/wiki/analyze.py

@@ -213,7 +213,7 @@ class FileAnalyzer:
         self.verbose and print()
         return True
 
-    @logs.error_logging(log)
+    @logs.exception_logging(log)
     def run(self, file_name: str) -> None:
         log.info(f'{self._ctx.deathpact=} {file_name}')  # noqa
 
@@ -268,7 +268,7 @@ class FileAnalyzer:
             self._flush_rows()
 
 
-@logs.error_logging(log)
+@logs.exception_logging(log)
 def analyze_file(
         file_name: str,
         db_url: str,

ommlds/wiki/models.py

@@ -51,7 +51,7 @@ class Redirect:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata([
+@msh.update_fields_options([
     'username',
     'id',
     'ip',
@@ -78,7 +78,7 @@ class RevisionText:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata([
+@msh.update_fields_options([
     'parentid',
     'timestamp',
     'contributors',
@@ -108,7 +108,7 @@ class Revision:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata([
+@msh.update_fields_options([
     'timestamp',
     'contributor',
     'comment',
@@ -129,7 +129,7 @@ class Upload:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata([
+@msh.update_fields_options([
     'redirect',
     'restrictions',
     'revisions',