@trac3er/oh-my-god 2.0.0 → 2.0.2

package/runtime/memory_parsers/kimi_import.py

@@ -0,0 +1,91 @@
+"""Kimi Web paste-based memory import — parse and import memories from Kimi Web interface."""
+
+from __future__ import annotations
+
+import re
+from typing import Any  # pyright: ignore[reportExplicitAny]
+
+EXTRACTION_PROMPT = (
+    "What information do you remember about me? Please list all stored preferences, facts, and context "
+    "as bullet points starting with '- '."
+)
+
+
+def parse_kimi_paste(text: str) -> list[dict[str, Any]]:  # pyright: ignore[reportExplicitAny]
+    """Parse memories from Kimi Web paste text.
+
+    Supports bullet points (- item) and numbered lists (1. item).
+
+    Args:
+        text: Raw text pasted from Kimi Web interface.
+
+    Returns:
+        List of memory items with keys, content, source_cli, and tags.
+    """
+    if not text or not text.strip():
+        return []
+
+    items: list[str] = []
+    lines = text.split("\n")
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        # Try bullet point format: "- item"
+        if line.startswith("-"):
+            content = line[1:].strip()
+            if content:
+                items.append(content)
+            continue
+
+        # Try numbered format: "1. item", "2. item", etc.
+        match = re.match(r"^\d+\.\s+(.+)$", line)
+        if match:
+            content = match.group(1).strip()
+            if content:
+                items.append(content)
+            continue
+
+    # Convert to memory item dicts
+    result: list[dict[str, Any]] = []  # pyright: ignore[reportExplicitAny]
+    for i, content in enumerate(items):
+        result.append(
+            {
+                "key": f"kimi-memory-{i+1}",
+                "content": content,
+                "source_cli": "kimi-web",
+                "tags": ["kimi-web", "imported"],
+            }
+        )
+
+    return result
+
+
+def import_from_paste(text: str, store: Any) -> int:  # pyright: ignore[reportAny]
+    """Import memories from Kimi Web paste into the memory store.
+
+    Args:
+        text: Raw text pasted from Kimi Web interface.
+        store: MemoryStore instance to add items to.
+
+    Returns:
+        Number of items successfully imported.
+    """
+    items = parse_kimi_paste(text)
+    count = 0
+
+    for item in items:
+        store.add(  # pyright: ignore[reportAny]
+            key=item["key"],
+            content=item["content"],
+            source_cli=item["source_cli"],
+            tags=item["tags"],
+        )
+        count += 1
+
+    return count
+
+
+__all__ = ["EXTRACTION_PROMPT", "parse_kimi_paste", "import_from_paste"]

package/runtime/memory_store.py

@@ -0,0 +1,215 @@
+"""MemoryStore — CRUD + JSON persistence for shared memory across CLI providers."""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class MemoryStoreFullError(Exception):
+    """Raised when adding to a store that has reached the 10,000 item limit."""
+
+
+_MAX_ITEMS = 10_000
+
+# Type alias for memory items — JSON-like dicts.
+_Item = dict[str, Any]  # pyright: ignore[reportExplicitAny]
+
+
+class MemoryStore:
+    """Thread-unsafe, file-backed key/content store with JSON persistence.
+
+    Each item follows the schema::
+
+        {
+            "id":         str,       # UUID4
+            "key":        str,       # user-defined key
+            "content":    str,       # the memory text
+            "source_cli": str,       # originating CLI name
+            "tags":       list[str], # optional tags
+            "created_at": str,       # ISO 8601 UTC
+            "updated_at": str,       # ISO 8601 UTC
+        }
+
+    Persistence uses atomic writes (tmp file + ``os.replace``).
+    """
+
+    def __init__(self, store_path: str | None = None) -> None:
+        if store_path is None:
+            store_path = str(Path.home() / ".omg" / "shared-memory" / "store.json")
+        self.store_path: str = store_path
+        self._items: list[_Item] = self._load()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def add(
+        self,
+        key: str,
+        content: str,
+        source_cli: str,
+        tags: list[str] | None = None,
+    ) -> _Item:
+        """Create a new memory item and persist to disk.
+
+        Raises ``MemoryStoreFullError`` when the store already holds
+        ``_MAX_ITEMS`` entries.
+        """
+        if self.count() >= _MAX_ITEMS:
+            raise MemoryStoreFullError(
+                f"Memory store is full ({_MAX_ITEMS} items). "
+                "Delete items before adding new ones."
+            )
+
+        now = _utc_now_iso()
+        item: _Item = {
+            "id": str(uuid.uuid4()),
+            "key": key,
+            "content": content,
+            "source_cli": source_cli,
+            "tags": tags if tags is not None else [],
+            "created_at": now,
+            "updated_at": now,
+        }
+        self._items.append(item)
+        self._save()
+        return item
+
+    def get(self, item_id: str) -> _Item | None:
+        """Return the item with *item_id*, or ``None`` if not found."""
+        for item in self._items:
+            if item["id"] == item_id:
+                return item
+        return None
+
+    def update(
+        self,
+        item_id: str,
+        content: str | None = None,
+        tags: list[str] | None = None,
+    ) -> _Item | None:
+        """Update *content* and/or *tags* for an existing item.
+
+        Returns the updated item, or ``None`` if *item_id* is not found.
+        """
+        item = self.get(item_id)
+        if item is None:
+            return None
+
+        if content is not None:
+            item["content"] = content
+        if tags is not None:
+            item["tags"] = tags
+        item["updated_at"] = _utc_now_iso()
+        self._save()
+        return item
+
+    def delete(self, item_id: str) -> bool:
+        """Remove the item with *item_id*.
+
+        Returns ``True`` if deleted, ``False`` if not found.
+        """
+        for idx, item in enumerate(self._items):
+            if item["id"] == item_id:
+                del self._items[idx]
+                self._save()
+                return True
+        return False
+
+    def search(
+        self,
+        query: str,
+        source_cli: str | None = None,
+    ) -> list[_Item]:
+        """Keyword search across key, content, and tags (case-insensitive).
+
+        Optionally filtered by *source_cli*.
+        """
+        q = query.lower()
+        results: list[_Item] = []
+        for item in self._items:
+            if source_cli is not None and item["source_cli"] != source_cli:
+                continue
+            key_str = str(item.get("key", "")).lower()
+            content_str = str(item.get("content", "")).lower()
+            tags_raw = item.get("tags", [])
+            tags_str = " ".join(str(t).lower() for t in tags_raw) if isinstance(tags_raw, list) else ""
+            if q in key_str or q in content_str or q in tags_str:
+                results.append(item)
+        return results
+
+    def list_all(self, source_cli: str | None = None) -> list[_Item]:
+        """Return all items, optionally filtered by *source_cli*."""
+        if source_cli is None:
+            return list(self._items)
+        return [i for i in self._items if i["source_cli"] == source_cli]
+
+    def export_all(self) -> list[_Item]:
+        """Return a copy of all items as a list."""
+        return list(self._items)
+
+    def import_items(self, items: list[_Item]) -> int:
+        """Bulk import items, skipping any whose ``id`` already exists.
+
+        Returns the number of items actually added.
+        """
+        existing_ids = {str(i["id"]) for i in self._items}
+        added = 0
+        for item in items:
+            item_id = str(item.get("id", ""))
+            if item_id and item_id not in existing_ids:
+                self._items.append(item)
+                existing_ids.add(item_id)
+                added += 1
+        if added:
+            self._save()
+        return added
+
+    def count(self) -> int:
+        """Return the total number of stored items."""
+        return len(self._items)
+
+    def clear(self) -> int:
+        """Delete all items and return the count of deleted items."""
+        n = len(self._items)
+        self._items.clear()
+        self._save()
+        return n
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load(self) -> list[_Item]:
+        """Load items from the JSON file.  Returns empty list if missing."""
+        path = Path(self.store_path)
+        if not path.exists():
+            return []
+        try:
+            raw = json.loads(path.read_text())
+            if isinstance(raw, list):
+                return raw  # type: ignore[return-value]
+            return []
+        except (json.JSONDecodeError, ValueError):
+            return []
+
+    def _save(self) -> None:
+        """Persist items to disk with atomic write (tmp + os.replace)."""
+        path = Path(self.store_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = path.with_name(f"{path.name}.tmp")
+        _ = tmp_path.write_text(json.dumps(self._items, indent=2) + "\n")
+        _ = os.replace(tmp_path, path)
+
+
+def _utc_now_iso() -> str:
+    """Return current UTC time as ISO 8601 string."""
+    return datetime.now(timezone.utc).isoformat()
+
+
+__all__ = ["MemoryStore", "MemoryStoreFullError"]

package/runtime/omc_compat.py

@@ -0,0 +1,7 @@
+"""Backward-compatible aliases for legacy compatibility routing.
+
+Primary implementation lives in `runtime.compat`.
+"""
+from __future__ import annotations
+
+from .compat import *  # noqa: F401,F403

package/runtime/providers/codex_provider.py

@@ -0,0 +1,112 @@
+"""Codex CLI provider — implements CLIProvider for the ``codex`` binary."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import uuid
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+
+
+class CodexProvider(CLIProvider):
+    """CLIProvider implementation for the Codex CLI (``codex``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "codex"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``codex`` binary is available on PATH."""
+        return shutil.which("codex") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check Codex authentication status via ``codex auth status``."""
+        try:
+            result = self.run_tool(["codex", "auth", "status"], timeout=30)
+            if result.returncode == 0:
+                return True, result.stdout.strip()
+            return False, result.stderr.strip() or result.stdout.strip()
+        except Exception as exc:
+            return None, f"codex auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``codex exec --json`` via subprocess."""
+        try:
+            result = self.run_tool(
+                ["codex", "exec", "--json", prompt],
+                timeout=timeout,
+            )
+            return {
+                "model": "codex-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "codex-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "codex-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``codex exec --json`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("codex", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name)
+            output = mgr.send_command(session, f"codex exec --json {shlex.quote(prompt)}", timeout=timeout)
+            mgr.kill_session(session)
+            return {"model": "codex-cli", "output": output, "exit_code": 0}
+        except Exception as exc:
+            _logger.warning("tmux codex invocation failed, falling back to subprocess: %s", exc)
+            return self.invoke(prompt, project_dir, timeout=timeout)
+
+    # -- command helpers ----------------------------------------------------
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return the non-interactive command for codex."""
+        return ["codex", "exec", "--json", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the Codex configuration file path."""
+        return os.path.expanduser("~/.codex/config.toml")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.codex/config.toml``."""
+        config_path = self.get_config_path()
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+
+        entry = (
+            f'[mcp_servers."{server_name}"]\n'
+            f'url = "{server_url}"\n'
+        )
+
+        # Append or create
+        mode = "a" if os.path.exists(config_path) else "w"
+        with open(config_path, mode) as fh:
+            fh.write(entry)
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(CodexProvider())

package/runtime/providers/gemini_provider.py

@@ -0,0 +1,128 @@
+"""Gemini CLI provider — implements CLIProvider for the ``gemini`` binary."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import uuid
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+
+
+class GeminiProvider(CLIProvider):
+    """CLIProvider implementation for the Gemini CLI (``gemini``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "gemini"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``gemini`` binary is available on PATH."""
+        return shutil.which("gemini") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check Gemini authentication status via ``gemini auth status``."""
+        try:
+            result = self.run_tool(["gemini", "auth", "status"], timeout=30)
+            if result.returncode == 0:
+                return True, result.stdout.strip()
+            return False, result.stderr.strip() or result.stdout.strip()
+        except Exception as exc:
+            return None, f"gemini auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``gemini -p`` via subprocess.
+
+        Gemini CLI has no ``--json`` flag — output is plain text stdout.
+        """
+        try:
+            result = self.run_tool(
+                ["gemini", "-p", prompt],
+                timeout=timeout,
+            )
+            return {
+                "model": "gemini-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "gemini-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "gemini-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``gemini -p`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("gemini", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name)
+            output = mgr.send_command(session, f"gemini -p {shlex.quote(prompt)}", timeout=timeout)
+            mgr.kill_session(session)
+            return {"model": "gemini-cli", "output": output, "exit_code": 0}
+        except Exception as exc:
+            _logger.warning("tmux gemini invocation failed, falling back to subprocess: %s", exc)
+            return self.invoke(prompt, project_dir, timeout=timeout)
+
+    # -- command helpers ----------------------------------------------------
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return the non-interactive command for gemini."""
+        return ["gemini", "-p", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the Gemini configuration file path."""
+        return os.path.expanduser("~/.gemini/settings.json")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.gemini/settings.json``.
+
+        Uses JSON format with ``mcpServers`` key and ``httpUrl`` field,
+        merging into any existing configuration.
+        """
+        config_path = self.get_config_path()
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+
+        # Load existing config or start fresh
+        existing: dict[str, Any] = {}  # pyright: ignore[reportExplicitAny]
+        if os.path.exists(config_path):
+            with open(config_path) as fh:
+                try:
+                    existing = json.load(fh)
+                except (json.JSONDecodeError, ValueError):
+                    existing = {}
+
+        # Ensure mcpServers dict exists
+        if "mcpServers" not in existing:
+            existing["mcpServers"] = {}
+
+        existing["mcpServers"][server_name] = {"httpUrl": server_url}
+
+        with open(config_path, "w") as fh:
+            json.dump(existing, fh, indent=2)
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(GeminiProvider())