fix(letta): harden official Python hook integration

elydora/plugins/letta_config.py

@@ -0,0 +1,195 @@
+"""Strict Letta Code settings parsing and source-preserving edits."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+from ._jsonc import JsoncEditor
+from ._managed_files import FileSnapshot
+from ._strict_json import parse_json_object
+from .letta_contract import (
+    MANAGED_EVENTS,
+    JsonObject,
+    LettaHooks,
+    managed_letta_removals,
+    read_letta_hooks,
+)
+
+
+@dataclass(frozen=True)
+class LettaDocument:
+    kind: str
+    file_path: str
+    exists: bool
+    raw: str
+    snapshot: Optional[FileSnapshot]
+    root: JsonObject
+    hooks: LettaHooks
+    has_hooks_container: bool
+
+
+@dataclass(frozen=True)
+class RenderedLettaDocument:
+    document: LettaDocument
+    changed: bool
+    next_source: Optional[str]
+
+
+def letta_source_label(kind: str) -> str:
+    labels = {
+        "global": "Letta Code global settings",
+        "project": "Letta Code project settings",
+        "project-local": "Letta Code project-local settings",
+    }
+    try:
+        return labels[kind]
+    except KeyError as error:
+        raise ValueError(f"Unsupported Letta Code document kind: {kind}") from error
+
+
+def letta_document_label(document: LettaDocument) -> str:
+    return letta_source_label(document.kind)
+
+
+def parse_letta_document(
+    *,
+    kind: str,
+    exists: bool,
+    file_path: str,
+    raw: str,
+    snapshot: Optional[FileSnapshot] = None,
+) -> LettaDocument:
+    label = f"{letta_source_label(kind)} at {file_path}"
+    root = parse_json_object(raw, label)
+    return LettaDocument(
+        kind,
+        file_path,
+        exists,
+        raw,
+        snapshot,
+        root,
+        read_letta_hooks(root["hooks"]) if "hooks" in root else {},
+        "hooks" in root,
+    )
+
+
+def create_letta_document(kind: str, file_path: str) -> LettaDocument:
+    return parse_letta_document(
+        kind=kind,
+        exists=False,
+        file_path=file_path,
+        raw="{}\n",
+    )
+
+
+def _current_document(
+    document: LettaDocument, editor: JsoncEditor
+) -> LettaDocument:
+    return parse_letta_document(
+        kind=document.kind,
+        exists=document.exists,
+        file_path=document.file_path,
+        raw=editor.raw,
+        snapshot=document.snapshot,
+    )
+
+
+def _event_groups(hooks: LettaHooks, event: str) -> list[JsonObject]:
+    value = hooks.get(event)
+    return value if isinstance(value, list) else []
+
+
+def _remove_managed(
+    editor: JsoncEditor,
+    document: LettaDocument,
+    agent_id: Optional[str],
+) -> None:
+    removals = managed_letta_removals(document.hooks, agent_id)
+    for event in MANAGED_EVENTS:
+        event_removals = sorted(
+            (item for item in removals if item.event == event),
+            key=lambda item: item.group_index,
+            reverse=True,
+        )
+        for removal in event_removals:
+            group_path = ("hooks", event, removal.group_index)
+            if removal.remove_group:
+                editor.delete(group_path)
+                continue
+            for handler_index in sorted(removal.handler_indexes, reverse=True):
+                editor.delete((*group_path, "hooks", handler_index))
+        if event_removals:
+            current = _current_document(document, editor)
+            if event in current.hooks and not _event_groups(current.hooks, event):
+                editor.delete(("hooks", event))
+    current = _current_document(document, editor)
+    if current.has_hooks_container and not current.hooks:
+        editor.delete(("hooks",))
+
+
+def _append_group(
+    editor: JsoncEditor,
+    document: LettaDocument,
+    event: str,
+    group: JsonObject,
+) -> None:
+    current = _current_document(document, editor)
+    groups = _event_groups(current.hooks, event)
+    if not current.has_hooks_container:
+        editor.add_property((), "hooks", {event: [group]})
+    elif groups:
+        editor.append(("hooks", event), group)
+    elif event in current.hooks:
+        editor.append(("hooks", event), group)
+    else:
+        editor.add_property(("hooks",), event, [group])
+
+
+def _already_installed(
+    document: LettaDocument, additions: Dict[str, JsonObject]
+) -> bool:
+    if set(additions) != set(MANAGED_EVENTS):
+        return False
+    removals = managed_letta_removals(document.hooks)
+    for event in MANAGED_EVENTS:
+        expected = additions[event]
+        event_removals = [item for item in removals if item.event == event]
+        exact_groups = [
+            group for group in _event_groups(document.hooks, event)
+            if group == expected
+        ]
+        if (
+            len(event_removals) != 1
+            or not event_removals[0].remove_group
+            or len(exact_groups) != 1
+        ):
+            return False
+    return True
+
+
+def render_letta_document(
+    document: LettaDocument,
+    agent_id: Optional[str],
+    additions: Dict[str, JsonObject],
+) -> RenderedLettaDocument:
+    if agent_id is None and _already_installed(document, additions):
+        return RenderedLettaDocument(document, False, document.raw)
+    editor = JsoncEditor(
+        document.raw,
+        f"{letta_document_label(document)} at {document.file_path}",
+        allow_trailing_commas=False,
+    )
+    _remove_managed(editor, document, agent_id)
+    for event in MANAGED_EVENTS:
+        group = additions.get(event)
+        if group is not None:
+            _append_group(editor, document, event, group)
+    current = _current_document(document, editor)
+    if not additions and not current.root:
+        return RenderedLettaDocument(document, True, None)
+    return RenderedLettaDocument(
+        document,
+        editor.raw != document.raw,
+        editor.raw,
+    )