meltygui 0.1.0__py3-none-any.whl

meltygui/chat/__init__.py

@@ -0,0 +1,91 @@
+"""meltygui.chat — the code-assistant chat: the window, the data contract a
+backend implements, and the registry that plugs a backend into a provider.
+
+    import meltygui
+    from meltygui.chat import draw_chat_interface, persistent_metadata
+    import melty_agents                       # registers the Claude Code backend
+
+    persistent_metadata('~/.cache/my-app/chat_metadata.json')
+    meltygui.glfw_window(name='Chat', app_id='my-app')(draw_chat_interface)
+
+The window (`draw_chat_interface`, the studio's Chat playground) lists the
+account kinds that carry a `chat_label` in a provider dropdown, the accounts
+of that kind next to it, and draws the selected account's conversations:
+a project-grouped sidebar, the transcript, the composer, approval prompts.
+Conversations come from a **ChatProxy** — a dict of `Chat`s the UI edits
+directly (insert a dict to create, `del` to remove, set `title`, append a
+user message to `chat["messages"]`, set `running=False` to stop; `updated`
+is its last activity in epoch seconds, for the sidebar's age filter) and the
+backend mirrors to its provider from a worker thread. `chat_proxy.py` is
+the contract; `codex_proxy.py` in the same package is the reference
+implementation, and its docstrings say what each operation and event means.
+
+A backend registers a factory for an account kind name:
+
+    from meltygui.chat import ChatProxy, Chat, messages, register_chat_backend
+
+    @register_chat_backend('anthropic')     # the "Claude Code" provider
+    def claude_chats(account, metadata=None, wake=None):
+        return ClaudeCodeChats(account['id'], metadata, wake, account=account)
+
+Pictures (`images`): an ImageReference in a message — a base64 payload, a
+path or a data URL — is decoded once and drawn inline by the window, HDR
+sources (PQ PNGs, PQ ICC profiles) as RGB16F so an HDR desktop shows them.
+
+Message values (`messages`: UserMessage, AssistantMessage, ReasoningMessage,
+CommandExecution, FileChange, ... and `set_text`, `upsert`, `text_blocks`)
+are provider-neutral; the UI selects a view by type, so a backend only maps
+its events onto them.
+
+Light names (the contract, the registry, the message model) import
+eagerly; the window, the accounts store and the metadata mirror
+(`ChatMetadata`, `shared_metadata`, `persistent_metadata`) load lazily on
+first access, after meltygui's import thread, like the views in `meltygui` itself.
+"""
+from typing import TYPE_CHECKING
+
+from meltygui.chat import messages
+import meltygui.chat.images as images   # message pictures: image_key, ImageCache, fitted_size
+from meltygui.chat.backends import CHAT_BACKENDS
+from meltygui.chat.backends import chat_backend
+from meltygui.chat.backends import register_chat_backend
+from meltygui.chat.chat_proxy import Chat
+from meltygui.chat.chat_proxy import ChatProxy
+
+if TYPE_CHECKING:   # IDE and type checkers only; never executed
+    from meltygui.chat.metadata import ChatMetadata
+    from meltygui.chat.metadata import persistent_metadata
+    from meltygui.chat.metadata import shared_metadata
+    from meltygui.view.chat_view import draw_chat_interface
+    from meltygui.state.chat_state import ChatInterfaceState
+    from meltygui.accounts.internet_accounts import accounts
+    from meltygui.accounts.internet_accounts import KINDS
+    from meltygui.accounts.internet_accounts import AccountKind
+    from meltygui.accounts.internet_accounts import account_kind
+
+_LAZY = {
+    'ChatMetadata': ('meltygui.chat.metadata', 'ChatMetadata'),
+    'shared_metadata': ('meltygui.chat.metadata', 'shared_metadata'),
+    'persistent_metadata': ('meltygui.chat.metadata', 'persistent_metadata'),
+    'draw_chat_interface': ('meltygui.chat.chat_interface', 'draw_chat_interface'),
+    'ChatInterfaceState': ('meltygui.chat.chat_interface', 'ChatInterfaceState'),
+    'accounts': ('meltygui.accounts.internet_accounts', 'accounts'),
+    'KINDS': ('meltygui.accounts.internet_accounts', 'KINDS'),
+    'AccountKind': ('meltygui.accounts.internet_accounts', 'AccountKind'),
+    'account_kind': ('meltygui.accounts.internet_accounts', 'account_kind'),
+}
+
+
+def __getattr__(name):
+    spec = _LAZY.get(name)
+    if spec is None:
+        raise AttributeError(name)
+    import importlib
+    from meltygui.core.runtime.app import _wait_imports
+    _wait_imports()
+    value = getattr(importlib.import_module(spec[0]), spec[1])
+    globals()[name] = value
+    return value
+
+
+__all__ = ['messages', 'images', 'Chat', 'ChatProxy', 'CHAT_BACKENDS', 'chat_backend', 'register_chat_backend', *_LAZY]

meltygui/chat/activity.py

@@ -0,0 +1,75 @@
+"""Incremental user-message timestamps from provider session logs (worker only)."""
+import json
+from pathlib import Path
+from meltygui.chat.chat_proxy import epoch_seconds
+
+
+class UserMessageTimes:
+    def __init__(self, provider):
+        self.provider = provider
+        self.files = {}
+
+    def timestamp(self, line):
+        try:
+            row = json.loads(line)
+        except (ValueError, UnicodeError):
+            return 0.0
+        if self.provider == 'codex':
+            payload = row.get('payload') or {}
+            user = ((row.get('type') == 'event_msg' and payload.get('type') == 'user_message')
+                    or (row.get('type') == 'response_item' and payload.get('type') == 'message'
+                        and payload.get('role') == 'user'))
+        else:
+            message = row.get('message') or {}
+            content = message.get('content', [])
+            user = (row.get('type') == 'user' and not row.get('isSidechain')
+                    and not row.get('parentToolUseId') and not row.get('isMeta')
+                    and (isinstance(content, str) or any(
+                        block.get('type') in ('text', 'image') for block in content if isinstance(block, dict))))
+        return epoch_seconds(row.get('timestamp')) if user else 0.0
+
+    def read(self, path):
+        if not path:
+            return 0.0
+        path = Path(path)
+        previous = self.files.get(path)
+        try:
+            stat = path.stat()
+            signature = (stat.st_ino, stat.st_size, stat.st_mtime_ns, 2)
+            if previous and previous[0] == signature:
+                return previous[2]
+            with path.open('rb') as handle:
+                if (previous and previous[0][-1] == 2 and len(previous[0]) == 4
+                        and previous[0][0] == stat.st_ino and stat.st_size > previous[0][1]):
+                    offset, latest = previous[1:]
+                    handle.seek(offset)
+                    while line := handle.readline():
+                        if not line.endswith(b'\n'):
+                            break
+                        latest = max(latest, self.timestamp(line))
+                        offset = handle.tell()
+                else:
+                    # Initial scan starts at the end; long histories normally
+                    # need only the final turn. Leave partial rows for next poll.
+                    offset, latest, position, tail = stat.st_size, 0.0, stat.st_size, b''
+                    first = True
+                    while position and not latest:
+                        count = min(position, 65536)
+                        position -= count
+                        handle.seek(position)
+                        parts = (handle.read(count) + tail).split(b'\n')
+                        tail = parts.pop(0) if position else b''
+                        if first and not parts:
+                            continue
+                        if first:
+                            partial = parts.pop()
+                            offset -= len(partial)
+                            first = False
+                        for line in reversed(parts):
+                            latest = self.timestamp(line)
+                            if latest:
+                                break
+            self.files[path] = (signature, offset, latest)
+            return latest
+        except OSError:
+            return previous[2] if previous else 0.0

meltygui/chat/backends.py

@@ -0,0 +1,36 @@
+"""The chat backend registry: account kind name -> ChatProxy factory.
+
+A backend is a ChatProxy subclass living anywhere (the studio's Codex one,
+an external package such as melty_agents). Registering it against an
+account kind gives that kind's accounts a conversation list in the Chat
+window; nothing else in the UI knows which package supplied it.
+
+    from meltygui.chat import register_chat_backend
+
+    def claude_chats(account, metadata=None, wake=None):
+        return ClaudeCodeChats(account["id"], metadata, wake, account=account)
+
+    register_chat_backend("anthropic", claude_chats)
+
+The factory receives the account dict (its ``id`` and fields), the shared
+ChatMetadata (or None for the default) and the wake callback; it returns a
+ChatProxy, or None to leave the kind blank for now (signing in, busy).
+This module imports nothing heavy so backends can register at import time.
+"""
+
+CHAT_BACKENDS = {}
+
+
+def register_chat_backend(kind_name, factory=None):
+    """Register ``factory(account, metadata=None, wake=None) -> ChatProxy | None``
+    for the account kind named ``kind_name`` ("anthropic", "codex", ...).
+    Re-registering replaces the previous factory. Usable as a decorator:
+    ``@register_chat_backend("anthropic")`` over the factory."""
+    if factory is None:
+        return lambda fn: register_chat_backend(kind_name, fn)
+    CHAT_BACKENDS[kind_name] = factory
+    return factory
+
+
+def chat_backend(kind_name):
+    return CHAT_BACKENDS.get(kind_name)