@trac3er/oh-my-god 2.2.2 → 2.2.4

package/build/lib/runtime/mcp_lifecycle.py

@@ -1,175 +0,0 @@
-"""MCP server lifecycle manager — start/stop/health/ensure."""
-from __future__ import annotations
-
-import os
-import signal
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Any
-
-
-def get_pid_file_path() -> str:
-    """Return path to the PID file for the memory server."""
-    return str(Path.home() / ".omg" / "shared-memory" / "server.pid")
-
-
-def get_server_url() -> str:
-    """Return the MCP server URL using host/port from mcp_memory_server."""
-    from runtime.mcp_memory_server import get_host, get_port
-
-    return f"http://{get_host()}:{get_port()}/mcp"
-
-
-def _read_pid() -> int | None:
-    """Read PID from PID file. Returns None if missing or invalid."""
-    try:
-        return int(Path(get_pid_file_path()).read_text().strip())
-    except (FileNotFoundError, ValueError):
-        return None
-
-
-def is_server_running() -> bool:
-    """Check if the memory server process is alive."""
-    pid = _read_pid()
-    if pid is None:
-        return False
-    try:
-        os.kill(pid, 0)
-        return True
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True  # Process exists but we can't signal it
-
-
-def _wait_for_health(url: str, timeout: float = 5.0) -> bool:
-    """Wait for server health endpoint to respond."""
-    import urllib.request
-
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        try:
-            with urllib.request.urlopen(url, timeout=1) as resp:
-                if resp.status == 200:
-                    return True
-        except Exception:
-            time.sleep(0.1)
-    return False
-
-
-def _wait_for_exit(pid: int, timeout: float = 5.0) -> bool:
-    """Wait for a process to exit."""
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        try:
-            os.kill(pid, 0)
-            time.sleep(0.1)
-        except (ProcessLookupError, PermissionError):
-            return True
-    return False
-
-
-def start_memory_server() -> dict[str, Any]:
-    """Start the MCP memory server as a background process."""
-    if is_server_running():
-        return {"status": "already_running", "url": get_server_url()}
-
-    pid_path = Path(get_pid_file_path())
-    pid_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        server_script = str(Path(__file__).parent / "mcp_memory_server.py")
-        proc = subprocess.Popen(
-            [sys.executable, server_script],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-        health_url = get_server_url().replace("/mcp", "/health")
-        if _wait_for_health(health_url):
-            pid_path.write_text(str(proc.pid))
-            return {"status": "started", "pid": proc.pid, "url": get_server_url()}
-        try:
-            proc.terminate()
-            proc.wait(timeout=2)
-        except Exception:
-            try:
-                proc.kill()
-            except Exception:
-                pass
-        if pid_path.exists():
-            pid_path.unlink()
-        return {
-            "status": "error",
-            "message": "Server did not respond within timeout",
-        }
-    except Exception as exc:
-        return {"status": "error", "message": str(exc)}
-
-
-def stop_memory_server() -> dict[str, Any]:
-    """Stop the MCP memory server."""
-    if not is_server_running():
-        return {"status": "not_running"}
-
-    pid = _read_pid()
-    if pid is None:
-        return {"status": "not_running"}
-
-    try:
-        os.kill(pid, signal.SIGTERM)
-        _wait_for_exit(pid)
-
-        pid_path = Path(get_pid_file_path())
-        if pid_path.exists():
-            pid_path.unlink()
-
-        return {"status": "stopped", "pid": pid}
-    except ProcessLookupError:
-        pid_path = Path(get_pid_file_path())
-        if pid_path.exists():
-            pid_path.unlink()
-        return {"status": "stopped", "pid": pid}
-    except Exception as exc:
-        return {"status": "error", "message": str(exc)}
-
-
-def check_memory_server() -> dict[str, Any]:
-    """Check the memory server status."""
-    running = is_server_running()
-    if not running:
-        return {"running": False, "url": None, "pid": None}
-
-    return {
-        "running": True,
-        "url": get_server_url(),
-        "pid": _read_pid(),
-    }
-
-
-_HTTP_MEMORY_RESTRICTED_PRESETS = frozenset({"safe", "balanced"})
-
-
-def _get_current_preset() -> str:
-    return os.environ.get("OMG_PRESET", "safe")
-
-
-def ensure_memory_server() -> dict[str, Any]:
-    """Ensure the memory server is running (idempotent).
-
-    Skips startup when the active preset is ``safe`` or ``balanced`` —
-    HTTP memory is an opt-in surface starting at the ``interop`` tier.
-    """
-    preset = _get_current_preset()
-    if preset in _HTTP_MEMORY_RESTRICTED_PRESETS:
-        return {"status": "skipped", "reason": f"HTTP memory disabled for preset '{preset}'"}
-    if is_server_running():
-        return {"status": "already_running", "url": get_server_url()}
-    return start_memory_server()
-
-
-# Feature flag: auto-start on import (respects preset restrictions)
-if os.environ.get("OMG_MEMORY_AUTOSTART") == "1":
-    ensure_memory_server()

package/build/lib/runtime/mcp_memory_server.py

@@ -1,220 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import hashlib
-from pathlib import Path
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from datetime import datetime, timezone
-from typing import Any
-
-_MCP_IMPORT_ERROR: ModuleNotFoundError | None = None
-
-try:
-    from fastmcp import FastMCP as FastMCPImpl
-    from starlette.requests import Request as RequestImpl
-    from starlette.responses import JSONResponse as JSONResponseImpl
-except ModuleNotFoundError as exc:
-    _MCP_IMPORT_ERROR = exc
-    RequestImpl = Any
-
-    class JSONResponseFallback(dict):
-        def __init__(self, content: dict[str, Any]):
-            super().__init__(content)
-
-    def _passthrough_decorator(*_args: Any, **_kwargs: Any):
-        def decorator(func: Any) -> Any:
-            return func
-
-        return decorator
-
-    class FastMCPFallback:  # type: ignore[override]
-        def __init__(self, *_args: Any, **_kwargs: Any) -> None:
-            self._import_error = _MCP_IMPORT_ERROR
-
-        custom_route = staticmethod(_passthrough_decorator)
-        tool = staticmethod(_passthrough_decorator)
-        resource = staticmethod(_passthrough_decorator)
-
-        def run(self, *_args: Any, **_kwargs: Any) -> None:
-            raise RuntimeError("fastmcp and starlette are required to run the OMG memory server") from self._import_error
-
-    FastMCPFallback.__module__ = "fastmcp"
-    FastMCPImpl = FastMCPFallback
-    JSONResponseImpl = JSONResponseFallback
-
-from runtime.memory_store import MemoryStore, MemoryStoreFullError
-
-_store = MemoryStore(store_path=str(Path.home() / ".omg" / "shared-memory" / "store.json"))
-
-
-class _HybridExportBundle(list[dict[str, Any]]):
-    def __init__(self, items: list[dict[str, Any]], bundle: dict[str, Any]) -> None:
-        super().__init__(items)
-        self._bundle = bundle
-
-    def __getitem__(self, key: Any) -> Any:
-        if isinstance(key, str):
-            return self._bundle[key]
-        return super().__getitem__(key)
-
-    def get(self, key: str, default: Any = None) -> Any:
-        return self._bundle.get(key, default)
-
-    def __contains__(self, item: object) -> bool:
-        if isinstance(item, str):
-            return item in self._bundle
-        return super().__contains__(item)
-
-
-def _load_state() -> None:
-    return None
-
-
-def _save_state() -> None:
-    return None
-
-
-@asynccontextmanager
-async def lifespan(_: object) -> AsyncIterator[None]:
-    _load_state()
-    try:
-        yield
-    finally:
-        _save_state()
-
-
-mcp = FastMCPImpl("OMG Memory Server", lifespan=lifespan)
-
-
-@mcp.custom_route("/health", methods=["GET"])
-async def health(_: Any) -> Any:
-    return JSONResponseImpl({"status": "ok", "version": "2.0.8"})
-
-
-@mcp.tool()
-def memory_store(
-    key: str,
-    content: str,
-    source_cli: str,
-    tags: list[str] | None = None,
-    namespace: str = "default",
-    retention_days: int | None = None,
-) -> dict[str, Any]:
-    try:
-        return _store.add(
-            key=key,
-            content=content,
-            source_cli=source_cli,
-            tags=tags,
-            namespace=namespace,
-            retention_days=retention_days,
-        )
-    except MemoryStoreFullError as exc:
-        return {"error": str(exc)}
-    except ValueError as exc:
-        return {"error": str(exc)}
-
-
-@mcp.tool()
-def memory_search(
-    query: str,
-    source_cli: str | None = None,
-    namespace: str | None = None,
-) -> list[dict[str, Any]]:
-    return _store.search(query=query, source_cli=source_cli, namespace=namespace)
-
-
-@mcp.tool()
-def memory_list(
-    source_cli: str | None = None,
-    namespace: str | None = None,
-) -> list[dict[str, Any]]:
-    return _store.list_all(source_cli=source_cli, namespace=namespace)
-
-
-@mcp.tool()
-def memory_delete(item_id: str) -> dict[str, Any]:
-    deleted = _store.delete(item_id)
-    return {"deleted": deleted, "id": item_id}
-
-
-@mcp.tool()
-def memory_import(items: list[dict[str, Any]]) -> dict[str, int]:
-    count = _store.import_items(items, quarantined=False)
-    return {"imported": count}
-
-
-@mcp.tool()
-def memory_import_bundle(bundle: dict[str, Any]) -> dict[str, Any]:
-    if str(bundle.get("format", "")) != "omg.memory.export.v1":
-        return {"imported": 0, "error": "bundle format is invalid"}
-    payload = str(bundle.get("encrypted_payload", ""))
-    integrity = bundle.get("integrity", {})
-    expected_sha = ""
-    if isinstance(integrity, dict):
-        expected_sha = str(integrity.get("sha256", ""))
-    if not payload or hashlib.sha256(payload.encode("utf-8")).hexdigest() != expected_sha:
-        return {"imported": 0, "error": "bundle integrity check failed"}
-    if not payload.startswith("enc:v1:"):
-        return {"imported": 0, "error": "bundle payload must be encrypted"}
-    decoded = _store._decrypt_text(payload, purpose="export-bundle")  # noqa: SLF001
-    if not decoded:
-        return {"imported": 0, "error": "bundle decryption failed"}
-    try:
-        raw_items = json.loads(decoded)
-    except (TypeError, ValueError, json.JSONDecodeError):
-        return {"imported": 0, "error": "bundle payload is not valid JSON"}
-    if not isinstance(raw_items, list):
-        return {"imported": 0, "error": "bundle payload must be a list"}
-    count = _store.import_items(raw_items, quarantined=True)
-    return {"imported": count, "quarantined": count}
-
-
-@mcp.tool()
-def memory_export(namespace: str | None = None) -> list[dict[str, Any]] | dict[str, Any]:
-    items = _store.list_all(namespace=namespace)
-    serialized = json.dumps(items, separators=(",", ":"), ensure_ascii=True)
-    encrypted_payload = _store._encrypt_text(serialized, purpose="export-bundle")  # noqa: SLF001
-    bundle = {
-        "format": "omg.memory.export.v1",
-        "encrypted_payload": encrypted_payload,
-        "integrity": {
-            "sha256": hashlib.sha256(encrypted_payload.encode("utf-8")).hexdigest(),
-            "algorithm": "sha256",
-        },
-        "metadata": {
-            "count": len(items),
-            "exported_at": datetime.now(timezone.utc).isoformat(),
-            "namespace": namespace,
-        },
-    }
-    return _HybridExportBundle(items, bundle)
-
-
-@mcp.tool()
-def memory_promote(item_id: str) -> dict[str, Any]:
-    promoted = _store.promote_item(item_id)
-    return {"promoted": promoted, "id": item_id}
-
-
-@mcp.resource("memory://all")
-def memory_all_resource() -> str:
-    return json.dumps(_store.list_all())
-
-
-def get_host() -> str:
-    return os.environ.get("OMG_MEMORY_HOST", "127.0.0.1")
-
-
-def get_port() -> int:
-    return int(os.environ.get("OMG_MEMORY_PORT", "8765"))
-
-
-def run_server() -> None:
-    mcp.run(transport="http", host=get_host(), port=get_port())
-
-
-if __name__ == "__main__":
-    run_server()

package/build/lib/runtime/memory_parsers/chatgpt_parser.py

@@ -1,257 +0,0 @@
-"""ChatGPT conversations.json parser for OMG shared memory import.
-
-Parses the ChatGPT data export format (``conversations.json``) and converts
-conversations into OMG memory items compatible with :class:`MemoryStore`.
-
-Functions:
-    extract_linear_conversation — traverse mapping tree to ordered message list
-    parse_conversations_file   — read + parse the export JSON file
-    conversations_to_memory_items — convert parsed conversations to memory items
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import uuid
-import warnings
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# Maximum traversal depth to guard against circular parent references.
-_MAX_DEPTH = 10_000
-
-# Maximum content length per memory item (chars).
-_MAX_CONTENT_LENGTH = 5_000
-
-
-# ---------------------------------------------------------------------------
-# extract_linear_conversation
-# ---------------------------------------------------------------------------
-
-
-def extract_linear_conversation(
-    mapping: dict[str, Any],
-    current_node: str,
-) -> list[dict[str, Any]]:
-    """Walk *current_node* back to root via ``parent`` pointers.
-
-    Returns a chronologically ordered list (root -> leaf) of message dicts::
-
-        {"role": str, "content": str, "timestamp": float | None}
-
-    * Skips nodes whose ``message`` is ``None`` or has empty text.
-    * Skips ``system`` role messages.
-    * Guards against circular references with a depth limit of 10 000.
-    """
-    if current_node not in mapping:
-        return []
-
-    # Collect nodes from current_node back to root.
-    chain: list[dict[str, Any]] = []
-    visited: set[str] = set()
-    node_id: str | None = current_node
-
-    depth = 0
-    while node_id is not None and depth < _MAX_DEPTH:
-        if node_id in visited:
-            break
-        visited.add(node_id)
-
-        node = mapping.get(node_id)
-        if node is None:
-            break
-
-        chain.append(node)
-        node_id = node.get("parent")
-        depth += 1
-
-    # Reverse so root comes first (chronological order).
-    chain.reverse()
-
-    messages: list[dict[str, Any]] = []
-    for node in chain:
-        msg = node.get("message")
-        if msg is None:
-            continue
-
-        author = msg.get("author") or {}
-        role = author.get("role", "")
-
-        # Skip system messages.
-        if role == "system":
-            continue
-
-        content_obj = msg.get("content") or {}
-        parts = content_obj.get("parts") or []
-        text = "".join(str(p) for p in parts).strip()
-
-        # Skip empty content.
-        if not text:
-            continue
-
-        timestamp = msg.get("create_time")
-
-        messages.append(
-            {
-                "role": role,
-                "content": text,
-                "timestamp": timestamp,
-            }
-        )
-
-    return messages
-
-
-# ---------------------------------------------------------------------------
-# parse_conversations_file
-# ---------------------------------------------------------------------------
-
-
-def parse_conversations_file(file_path: str) -> list[dict[str, Any]]:
-    """Read and parse a ChatGPT ``conversations.json`` export file.
-
-    For each conversation object, calls :func:`extract_linear_conversation`
-    to obtain an ordered message list.
-
-    Returns a list of conversation dicts::
-
-        {
-            "id": str,
-            "title": str,
-            "messages": list[dict],
-            "create_time": float | None,
-            "source": "chatgpt",
-        }
-
-    Gracefully handles:
-    * File not found -> empty list
-    * Invalid JSON -> empty list
-    * Malformed individual conversations -> logged warning, skipped
-    """
-    path = Path(file_path)
-    if not path.exists():
-        logger.warning("Conversations file not found: %s", file_path)
-        return []
-
-    try:
-        raw_text = path.read_text(encoding="utf-8")
-    except OSError as exc:
-        logger.warning("Failed to read conversations file: %s", exc)
-        return []
-
-    # Warn about potentially large files.
-    file_size = path.stat().st_size
-    if file_size > 50 * 1024 * 1024:  # 50 MB
-        warnings.warn(
-            f"Large conversations file ({file_size / 1024 / 1024:.1f} MB). "
-            "Consider using streaming JSON parser (ijson) for better memory usage.",
-            ResourceWarning,
-            stacklevel=2,
-        )
-
-    try:
-        data = json.loads(raw_text)
-    except json.JSONDecodeError as exc:
-        logger.warning("Invalid JSON in conversations file: %s", exc)
-        return []
-
-    if not isinstance(data, list):
-        logger.warning("Expected JSON array, got %s", type(data).__name__)
-        return []
-
-    results: list[dict[str, Any]] = []
-
-    for conv in data:
-        try:
-            conv_id = conv["id"]
-            title = conv.get("title", "Untitled")
-            mapping = conv["mapping"]
-            current_node = conv["current_node"]
-            create_time = conv.get("create_time")
-
-            messages = extract_linear_conversation(mapping, current_node)
-
-            results.append(
-                {
-                    "id": conv_id,
-                    "title": title,
-                    "messages": messages,
-                    "create_time": create_time,
-                    "source": "chatgpt",
-                }
-            )
-        except (KeyError, TypeError) as exc:
-            conv_id_str = conv.get("id", "<unknown>") if isinstance(conv, dict) else "<invalid>"
-            logger.warning(
-                "Skipping malformed conversation %s: %s", conv_id_str, exc
-            )
-
-    return results
-
-
-# ---------------------------------------------------------------------------
-# conversations_to_memory_items
-# ---------------------------------------------------------------------------
-
-
-def conversations_to_memory_items(
-    conversations: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
-    """Convert parsed conversations to OMG memory item format.
-
-    Each conversation becomes ONE memory item with::
-
-        {
-            "key": "chatgpt-{id[:8]}",
-            "content": "# {title}\\n\\n**role**: content\\n\\n...",
-            "source_cli": "chatgpt",
-            "tags": ["chatgpt", "imported"],
-        }
-
-    * Conversations with no messages are skipped.
-    * Content is truncated to 5 000 chars max.
-    """
-    items: list[dict[str, Any]] = []
-
-    for conv in conversations:
-        messages = conv.get("messages", [])
-        if not messages:
-            continue
-
-        conv_id = conv.get("id", "unknown")
-        title = conv.get("title", "Untitled")
-
-        # Build content string.
-        parts = [f"# {title}", ""]
-        for msg in messages:
-            role = msg.get("role", "unknown")
-            content = msg.get("content", "")
-            parts.append(f"**{role}**: {content}")
-
-        full_content = "\n\n".join(parts)
-
-        # Truncate to max length.
-        if len(full_content) > _MAX_CONTENT_LENGTH:
-            full_content = full_content[:_MAX_CONTENT_LENGTH]
-
-        items.append(
-            {
-                "id": str(uuid.uuid4()),
-                "key": f"chatgpt-{conv_id[:8]}",
-                "content": full_content,
-                "source_cli": "chatgpt",
-                "tags": ["chatgpt", "imported"],
-            }
-        )
-
-    return items
-
-
-__all__ = [
-    "extract_linear_conversation",
-    "parse_conversations_file",
-    "conversations_to_memory_items",
-]