moolmesh 1.4.0__py3-none-any.whl

hub/__init__.py

@@ -0,0 +1,4 @@
+"""MoolMesh — the context mesh for AI coding agents."""
+
+__version__ = "1.4.0"
+USER_AGENT = f"moolmesh/{__version__}"

hub/__main__.py

@@ -0,0 +1,7 @@
+"""Allow `python -m hub` as a fallback entry point."""
+
+from hub.cli import main
+
+
+if __name__ == "__main__":
+    main()

hub/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseAdapter
+
+__all__ = ["BaseAdapter"]

hub/adapters/base.py

@@ -0,0 +1,27 @@
+"""Abstract base adapter for converting provider entries to unified models."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from hub.models.base import UnifiedEvent, UnifiedMessage
+
+
+class BaseAdapter(ABC):
+
+    @abstractmethod
+    def to_unified(self, entry: Any, project: str) -> UnifiedMessage | None:
+        """Convert a provider-specific entry to UnifiedMessage.
+
+        Returns None if the entry should be skipped.
+        """
+        ...
+
+    @abstractmethod
+    def to_event(self, entry: Any, project: str) -> UnifiedEvent | None:
+        """Convert a provider-specific entry to a lightweight UnifiedEvent for SSE.
+
+        Returns None if the entry should be skipped.
+        """
+        ...

hub/adapters/claude_adapter.py

@@ -0,0 +1,238 @@
+"""Adapter converting Claude entries to unified models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from hub.adapters.base import BaseAdapter
+from hub.models.base import (
+    MessageRole,
+    Provider,
+    TokenUsage,
+    ToolCall,
+    UnifiedEvent,
+    UnifiedMessage,
+)
+from hub.models.claude import ClaudeContentBlock, ClaudeEntry, ClaudeUsage
+
+# Types we skip during adaptation
+_SKIP_TYPES = frozenset({"file-history-snapshot"})
+
+
+class ClaudeAdapter(BaseAdapter):
+
+    def to_unified(self, entry: ClaudeEntry, project: str) -> UnifiedMessage | None:
+        if entry.type in _SKIP_TYPES:
+            return None
+
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        tool_calls = self._extract_tool_calls(entry.content_blocks)
+        tokens = self._map_usage(entry.usage)
+        timestamp = self._parse_timestamp(entry.timestamp)
+
+        return UnifiedMessage(
+            id=entry.uuid,
+            provider=Provider.CLAUDE,
+            session_id=entry.session_id,
+            project=project,
+            role=role,
+            text=entry.content_text,
+            tool_calls=tool_calls,
+            timestamp=timestamp,
+            model=entry.model,
+            tokens=tokens,
+            parent_id=entry.parent_uuid,
+            is_sidechain=entry.is_sidechain,
+            cwd=entry.cwd,
+            raw=entry.raw,
+        )
+
+    def to_event(self, entry: ClaudeEntry, project: str) -> UnifiedEvent | None:
+        if entry.type in _SKIP_TYPES:
+            return None
+
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        summary = self._summarize(entry)
+        tokens = None
+        if entry.usage:
+            tokens = {
+                "input": entry.usage.input_tokens,
+                "output": entry.usage.output_tokens,
+            }
+
+        tool_name = None
+        file_path = None
+        for block in entry.content_blocks:
+            if block.type == "tool_use" and block.tool_name:
+                tool_name = block.tool_name
+                if block.tool_input:
+                    file_path = (
+                        block.tool_input.get("file_path")
+                        or block.tool_input.get("path")
+                        or block.tool_input.get("command", "")[:80]
+                    )
+                break
+
+        return UnifiedEvent(
+            provider=Provider.CLAUDE,
+            project=project,
+            event_type=role.value,
+            timestamp=entry.timestamp,
+            summary=summary,
+            session_id=entry.session_id,
+            tokens=tokens,
+            tool_name=tool_name,
+            file_path=str(file_path) if file_path else None,
+            model=entry.model,
+            cwd=entry.cwd or None,
+        )
+
+    def _map_role(self, entry: ClaudeEntry) -> MessageRole | None:
+        match entry.type:
+            case "user":
+                return MessageRole.USER
+            case "assistant":
+                # Check if this is primarily a tool_use or tool_result message
+                has_tool_use = any(
+                    b.type == "tool_use" for b in entry.content_blocks
+                )
+                has_tool_result = any(
+                    b.type == "tool_result" for b in entry.content_blocks
+                )
+                has_thinking = any(
+                    b.type == "thinking" for b in entry.content_blocks
+                )
+                has_text = bool(entry.content_text.strip())
+
+                if has_tool_result and not has_text:
+                    return MessageRole.TOOL_RESULT
+                if has_tool_use and not has_text:
+                    return MessageRole.TOOL_USE
+                if has_thinking and not has_text and not has_tool_use:
+                    return MessageRole.THINKING
+                return MessageRole.ASSISTANT
+            case "system":
+                return MessageRole.SYSTEM
+            case "summary":
+                return MessageRole.SUMMARY
+            case _:
+                return None
+
+    def _extract_tool_calls(
+        self, blocks: list[ClaudeContentBlock]
+    ) -> list[ToolCall]:
+        calls: list[ToolCall] = []
+        for block in blocks:
+            if block.type != "tool_use" or not block.tool_name:
+                continue
+            input_data = block.tool_input or {}
+            fp = input_data.get("file_path") or input_data.get("path")
+            op_type = self._infer_operation_type(block.tool_name, input_data)
+            calls.append(
+                ToolCall(
+                    name=block.tool_name,
+                    input_data=input_data,
+                    tool_id=block.tool_id,
+                    file_path=fp,
+                    operation_type=op_type,
+                )
+            )
+        return calls
+
+    def _map_usage(self, usage: ClaudeUsage | None) -> TokenUsage | None:
+        if usage is None:
+            return None
+        return TokenUsage(
+            input_tokens=usage.input_tokens,
+            output_tokens=usage.output_tokens,
+            cache_creation=usage.cache_creation_input_tokens,
+            cache_read=usage.cache_read_input_tokens,
+        )
+
+    def _summarize(self, entry: ClaudeEntry) -> str:
+        """Produce a human-readable one-liner for the event feed."""
+        match entry.type:
+            case "user":
+                text = entry.content_text.strip().replace("\n", " ")
+                return text[:120] if text else "[empty user message]"
+            case "assistant":
+                # Prioritize tool_use summaries
+                for block in entry.content_blocks:
+                    if block.type == "tool_use" and block.tool_name:
+                        brief = self._brief_tool_args(
+                            block.tool_name, block.tool_input
+                        )
+                        return f"{block.tool_name}: {brief}"
+                    if block.type == "thinking" and block.thinking:
+                        return f"[thinking] {block.thinking[:100]}"
+                text = entry.content_text.strip().replace("\n", " ")
+                return text[:120] if text else "[assistant response]"
+            case "system":
+                sub = f" ({entry.subtype})" if entry.subtype else ""
+                return f"[system{sub}]"
+            case "summary":
+                return "[context summary]"
+            case _:
+                return f"[{entry.type}]"
+
+    @staticmethod
+    def _brief_tool_args(tool_name: str, input_data: dict | None) -> str:
+        if not input_data:
+            return ""
+        match tool_name:
+            case "Bash":
+                cmd = input_data.get("command", "")
+                return cmd[:80]
+            case "Read":
+                return input_data.get("file_path", "")[:80]
+            case "Write" | "Edit" | "MultiEdit":
+                return input_data.get("file_path", "")[:80]
+            case "Glob":
+                return input_data.get("pattern", "")[:80]
+            case "Grep":
+                return input_data.get("pattern", "")[:80]
+            case "Agent":
+                return input_data.get("description", "")[:80]
+            case "WebSearch" | "WebFetch":
+                return input_data.get("query", input_data.get("url", ""))[:80]
+            case _:
+                # Generic: show first key=value
+                for k, v in input_data.items():
+                    return f"{k}={str(v)[:60]}"
+                return ""
+
+    @staticmethod
+    def _infer_operation_type(tool_name: str, input_data: dict) -> str | None:
+        match tool_name:
+            case "Read" | "Glob" | "Grep":
+                return "read"
+            case "Write":
+                return "create"
+            case "Edit" | "MultiEdit":
+                return "modify"
+            case "Bash":
+                cmd = input_data.get("command", "")
+                if any(k in cmd for k in ("rm ", "rm\t", "rmdir")):
+                    return "delete"
+                if any(k in cmd for k in ("mkdir", "touch", "cp ", "mv ")):
+                    return "create"
+                return "exec"
+            case "Agent":
+                return "exec"
+            case _:
+                return None
+
+    @staticmethod
+    def _parse_timestamp(ts: str) -> datetime | None:
+        if not ts:
+            return None
+        try:
+            return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return None

hub/adapters/codex_adapter.py

@@ -0,0 +1,227 @@
+"""Adapter converting Codex entries to unified models."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+
+from hub.adapters.base import BaseAdapter
+from hub.models.base import (
+    MessageRole,
+    Provider,
+    TokenUsage,
+    ToolCall,
+    UnifiedEvent,
+    UnifiedMessage,
+)
+from hub.models.codex import CodexEntry
+
+
+class CodexAdapter(BaseAdapter):
+
+    def to_unified(self, entry: CodexEntry, project: str) -> UnifiedMessage | None:
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        tool_calls = self._extract_tool_calls(entry)
+        timestamp = self._parse_timestamp(entry.timestamp)
+        text = self._extract_text(entry)
+
+        tokens = self._extract_tokens(entry)
+
+        return UnifiedMessage(
+            id=entry.session_id or entry.timestamp,
+            provider=Provider.CODEX,
+            session_id=entry.session_id,
+            project=project,
+            role=role,
+            text=text,
+            tool_calls=tool_calls,
+            timestamp=timestamp,
+            model=entry.model_provider or None,
+            tokens=tokens,
+            cwd=entry.cwd or None,
+            raw=entry.raw,
+        )
+
+    def to_event(self, entry: CodexEntry, project: str) -> UnifiedEvent | None:
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        summary = self._summarize(entry)
+        tool_name = None
+        file_path = None
+
+        if entry.function_call:
+            tool_name = entry.function_call.name
+            # Try to extract command from arguments
+            try:
+                args = json.loads(entry.function_call.arguments)
+                file_path = (
+                    args.get("command", "")[:80]
+                    or args.get("file_path", "")[:80]
+                )
+            except (json.JSONDecodeError, TypeError):
+                file_path = entry.function_call.arguments[:80]
+
+        tokens_dict = None
+        if entry.event_type == "token_count" and entry.token_total > 0:
+            tokens_dict = {
+                "input": entry.token_input,
+                "output": entry.token_output,
+                "cached_input": entry.token_cached_input,
+                "reasoning": entry.token_reasoning,
+            }
+
+        return UnifiedEvent(
+            provider=Provider.CODEX,
+            project=project,
+            event_type=role.value,
+            timestamp=entry.timestamp,
+            summary=summary,
+            session_id=entry.session_id or None,
+            tokens=tokens_dict,
+            tool_name=tool_name,
+            file_path=file_path if file_path else None,
+            cwd=entry.cwd or None,
+        )
+
+    def _map_role(self, entry: CodexEntry) -> MessageRole | None:
+        match entry.event_type:
+            case "session_meta":
+                return MessageRole.SYSTEM
+            case "event_msg":
+                # Some event_msg entries contain system prompts, not user input
+                text = entry.event_msg_text
+                if text and self._is_system_prompt(text):
+                    return MessageRole.SYSTEM
+                return MessageRole.USER
+            case "token_count":
+                return MessageRole.SUMMARY
+            case "response_item":
+                match entry.payload_type:
+                    case "message":
+                        # "developer" role = system instructions for the model
+                        if entry.role == "developer":
+                            return MessageRole.SYSTEM
+                        if entry.role == "user":
+                            # Check if user message is actually a system prompt
+                            if entry.text and self._is_system_prompt(entry.text):
+                                return MessageRole.SYSTEM
+                            return MessageRole.USER
+                        return MessageRole.ASSISTANT
+                    case "function_call":
+                        return MessageRole.TOOL_USE
+                    case "function_call_output":
+                        return MessageRole.TOOL_RESULT
+                    case "reasoning":
+                        return MessageRole.THINKING
+                    case _:
+                        return None
+            case _:
+                return None
+
+    @staticmethod
+    def _is_system_prompt(text: str) -> bool:
+        """Detect system/developer prompts that are not real user input.
+
+        These patterns appear in Codex sessions as event_msg or response_item
+        with role 'user' but are actually system-injected instructions.
+        """
+        stripped = text.strip()
+        # XML-style system blocks
+        if stripped.startswith("<") and any(
+            stripped.startswith(f"<{tag}")
+            for tag in ("permissions", "skills_instructions", "environment_context",
+                        "system", "instructions", "tool_instructions")
+        ):
+            return True
+        # Very long messages (>2000 chars) starting with common system patterns
+        if len(stripped) > 2000 and any(
+            stripped.startswith(prefix)
+            for prefix in ("You are ", "You have ", "The following ", "## ")
+        ):
+            return True
+        return False
+
+    @staticmethod
+    def _extract_tokens(entry: CodexEntry) -> TokenUsage | None:
+        if entry.event_type != "token_count" or entry.token_total == 0:
+            return None
+        return TokenUsage(
+            input_tokens=entry.token_input,
+            output_tokens=entry.token_output + entry.token_reasoning,
+            cache_creation=0,
+            cache_read=entry.token_cached_input,
+        )
+
+    def _extract_text(self, entry: CodexEntry) -> str:
+        if entry.event_msg_text:
+            return entry.event_msg_text
+        if entry.text:
+            return entry.text
+        if entry.reasoning_text:
+            return entry.reasoning_text
+        if entry.function_call:
+            return f"{entry.function_call.name}({entry.function_call.arguments[:200]})"
+        if entry.function_output:
+            return entry.function_output.output[:500]
+        return ""
+
+    def _extract_tool_calls(self, entry: CodexEntry) -> list[ToolCall]:
+        if not entry.function_call:
+            return []
+        try:
+            args = json.loads(entry.function_call.arguments)
+        except (json.JSONDecodeError, TypeError):
+            args = {"raw": entry.function_call.arguments}
+        return [
+            ToolCall(
+                name=entry.function_call.name,
+                input_data=args,
+                tool_id=entry.function_call.call_id,
+                operation_type="exec",
+            )
+        ]
+
+    def _summarize(self, entry: CodexEntry) -> str:
+        match entry.event_type:
+            case "session_meta":
+                return f"[session start] cwd={entry.cwd} v{entry.cli_version}"
+            case "token_count":
+                return f"[tokens] in={entry.token_input:,} out={entry.token_output:,} cached={entry.token_cached_input:,} reasoning={entry.token_reasoning:,}"
+            case "event_msg":
+                text = entry.event_msg_text.strip().replace("\n", " ")
+                return text[:120] if text else "[user input]"
+            case "response_item":
+                match entry.payload_type:
+                    case "message":
+                        text = entry.text.strip().replace("\n", " ")
+                        return text[:120] if text else "[message]"
+                    case "function_call":
+                        if entry.function_call:
+                            name = entry.function_call.name
+                            args_brief = entry.function_call.arguments[:80]
+                            return f"{name}: {args_brief}"
+                        return "[function call]"
+                    case "function_call_output":
+                        if entry.function_output:
+                            return f"[output] {entry.function_output.output[:100]}"
+                        return "[function output]"
+                    case "reasoning":
+                        return f"[reasoning] {entry.reasoning_text[:100]}"
+                    case _:
+                        return f"[{entry.payload_type}]"
+            case _:
+                return f"[{entry.event_type}]"
+
+    @staticmethod
+    def _parse_timestamp(ts: str) -> datetime | None:
+        if not ts:
+            return None
+        try:
+            return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return None

hub/adapters/opencode_adapter.py

@@ -0,0 +1,143 @@
+"""Adapter converting OpenCode entries to unified models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from hub.adapters.base import BaseAdapter
+from hub.models.base import (
+    MessageRole, Provider, TokenUsage, ToolCall, UnifiedEvent, UnifiedMessage,
+)
+from hub.models.opencode import OpenCodeEntry
+
+
+class OpenCodeAdapter(BaseAdapter):
+
+    def to_unified(self, entry: OpenCodeEntry, project: str) -> UnifiedMessage | None:
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        tool_calls = self._extract_tool_calls(entry)
+        timestamp = self._parse_timestamp(entry.timestamp)
+        tokens = self._extract_tokens(entry)
+
+        return UnifiedMessage(
+            id=entry.message_id or entry.session_id,
+            provider=Provider.OPENCODE,
+            session_id=entry.session_id,
+            project=project,
+            role=role,
+            text=entry.text,
+            tool_calls=tool_calls,
+            timestamp=timestamp,
+            model=entry.model_id or None,
+            tokens=tokens,
+            cwd=entry.cwd or None,
+            raw=entry.raw,
+        )
+
+    def to_event(self, entry: OpenCodeEntry, project: str) -> UnifiedEvent | None:
+        role = self._map_role(entry)
+        if role is None:
+            return None
+
+        tool_name = None
+        file_path = None
+        if entry.tool_call:
+            tool_name = entry.tool_call.name
+            file_path = (entry.tool_call.input_data.get("path", "")
+                         or entry.tool_call.input_data.get("command", ""))[:80]
+
+        text = entry.text.strip().replace("\n", " ")
+        summary = text[:120] if text else f"[{entry.part_type}]"
+
+        parsed_ts = self._parse_timestamp(entry.timestamp)
+        ts_str = parsed_ts.isoformat() if parsed_ts else str(entry.timestamp)
+
+        return UnifiedEvent(
+            provider=Provider.OPENCODE,
+            project=project,
+            event_type=role.value,
+            timestamp=ts_str,
+            summary=summary,
+            session_id=entry.session_id or None,
+            tool_name=tool_name,
+            file_path=file_path if file_path else None,
+            cwd=entry.cwd or None,
+        )
+
+    def _map_role(self, entry: OpenCodeEntry) -> MessageRole | None:
+        match entry.part_type:
+            case "text":
+                if entry.role == "user":
+                    return MessageRole.USER
+                return MessageRole.ASSISTANT
+            case "reasoning":
+                return MessageRole.THINKING
+            case "tool" | "file" | "patch":
+                return MessageRole.TOOL_USE
+            case "step-finish":
+                return MessageRole.SUMMARY
+            case "compaction":
+                return MessageRole.SUMMARY
+            case _:
+                return None
+
+    @staticmethod
+    def _extract_tokens(entry: OpenCodeEntry) -> TokenUsage | None:
+        if entry.part_type != "step-finish":
+            return None
+        total = entry.token_input + entry.token_output + entry.token_reasoning
+        if total == 0:
+            return None
+        return TokenUsage(
+            input_tokens=entry.token_input,
+            output_tokens=entry.token_output + entry.token_reasoning,
+            cache_creation=entry.token_cache_write,
+            cache_read=entry.token_cache_read,
+        )
+
+    def _extract_tool_calls(self, entry: OpenCodeEntry) -> list[ToolCall]:
+        if not entry.tool_call:
+            return []
+        return [
+            ToolCall(
+                name=entry.tool_call.name,
+                input_data=entry.tool_call.input_data,
+                tool_id=entry.tool_call.tool_id,
+                output_data=entry.tool_call.output_data or None,
+                file_path=entry.files_affected[0] if entry.files_affected else None,
+                operation_type=self._classify_operation(entry.tool_call.name),
+            )
+        ]
+
+    @staticmethod
+    def _classify_operation(tool_name: str) -> str:
+        match tool_name:
+            case "read" | "file_read":
+                return "read"
+            case "write" | "file_edit" | "edit":
+                return "write"
+            case "bash":
+                return "exec"
+            case "glob" | "list" | "grep":
+                return "search"
+            case _:
+                return "other"
+
+    @staticmethod
+    def _parse_timestamp(ts: str | int | float) -> datetime | None:
+        if not ts:
+            return None
+        if isinstance(ts, (int, float)):
+            try:
+                if ts > 1e12:
+                    ts = ts / 1000
+                return datetime.fromtimestamp(ts, tz=datetime.now().astimezone().tzinfo)
+            except (ValueError, TypeError, OSError):
+                return None
+        try:
+            return datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return None