@trac3er/oh-my-god 2.2.2 → 2.2.4

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

@@ -1,107 +0,0 @@
-"""Claude.ai paste-based memory import."""
-
-import re
-from typing import TYPE_CHECKING, TypedDict
-
-if TYPE_CHECKING:
-    from runtime.memory_store import MemoryStore
-
-
-class MemoryItem(TypedDict):
-    """Memory item structure."""
-
-    key: str
-    content: str
-    source_cli: str
-    tags: list[str]
-
-
-EXTRACTION_PROMPT = (
-    "List every memory you have stored about me. "
-    "Format each memory as a bullet point starting with '- '. "
-    "Include all preferences, facts, and context you remember."
-)
-
-
-def parse_claude_paste(text: str) -> list[MemoryItem]:
-    """Parse Claude.ai paste-based memory list into structured items.
-
-    Handles multiple formats:
-    - Bullet points: "- item", "* item", "• item"
-    - Numbered lists: "1. item", "2. item"
-    - Plain paragraphs: one per line
-
-    Args:
-        text: Freeform text pasted from Claude.ai memory list
-
-    Returns:
-        List of memory item dicts with keys: key, content, source_cli, tags
-    """
-    if not text or not text.strip():
-        return []
-
-    lines = text.split("\n")
-    items: list[MemoryItem] = []
-    item_index = 1
-
-    for line in lines:
-        stripped = line.strip()
-
-        if not stripped:
-            continue
-
-        content = stripped
-
-        if content.startswith("- "):
-            content = content[2:].strip()
-        elif content.startswith("* "):
-            content = content[2:].strip()
-        elif content.startswith("• "):
-            content = content[2:].strip()
-        elif re.match(r"^\d+\.\s", content):
-            content = re.sub(r"^\d+\.\s+", "", content).strip()
-
-        if not content:
-            continue
-
-        item: MemoryItem = {
-            "key": f"claude-memory-{item_index}",
-            "content": content,
-            "source_cli": "claude-web",
-            "tags": ["claude-web", "imported"],
-        }
-        items.append(item)
-        item_index += 1
-
-    return items
-
-
-def import_from_paste(text: str, store: "MemoryStore") -> int:
-    """Import memories from Claude.ai paste into a MemoryStore.
-
-    Args:
-        text: Pasted memory list from Claude.ai
-        store: MemoryStore instance to add items to
-
-    Returns:
-        Count of items successfully added to store
-    """
-    items = parse_claude_paste(text)
-    count = 0
-
-    for item in items:
-        content = item.get("content", "")
-        if content:  # Skip empty content
-            key = item.get("key", "")
-            source_cli = item.get("source_cli", "claude-web")
-            tags = item.get("tags", [])
-            if isinstance(key, str) and isinstance(source_cli, str) and isinstance(tags, list):
-                store.add(
-                    key=key,
-                    content=content,
-                    source_cli=source_cli,
-                    tags=tags,
-                )
-                count += 1
-
-    return count

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

@@ -1,97 +0,0 @@
-"""Export memory items to markdown format."""
-
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-
-def export_to_markdown(items: list[dict[str, Any]]) -> str:
-    """Convert list of memory items to markdown string.
-
-    Args:
-        items: List of memory item dicts with keys: id, key, content, source_cli, tags, created_at, updated_at
-
-    Returns:
-        Markdown string with formatted memory items.
-    """
-    # Generate current timestamp in ISO format
-    now = datetime.now(timezone.utc).isoformat()
-
-    # Start with header
-    lines = [
-        "# OMG Shared Memory Export",
-        "",
-        f"Generated: {now}",
-        f"Total items: {len(items)}",
-        "",
-        "---",
-        "",
-    ]
-
-    # Add each item
-    for idx, item in enumerate(items, start=1):
-        key = item.get("key", "unknown")
-        content = item.get("content", "")
-        source_cli = item.get("source_cli", "unknown")
-        tags = item.get("tags", [])
-        created_at = item.get("created_at", "")
-        updated_at = item.get("updated_at", "")
-
-        # Format tags as comma-separated string
-        tags_str = ", ".join(tags) if tags else ""
-
-        lines.append(f"## Memory {idx}: {key}")
-        lines.append("")
-        lines.append(f"**Source**: {source_cli}")
-        lines.append(f"**Tags**: {tags_str}")
-        lines.append(f"**Created**: {created_at}")
-        lines.append(f"**Updated**: {updated_at}")
-        lines.append("")
-        lines.append(content)
-        lines.append("")
-        lines.append("---")
-        lines.append("")
-
-    return "\n".join(lines)
-
-
-def export_to_file(items: list[dict[str, Any]], output_path: str) -> None:
-    """Write export_to_markdown(items) to the given file path.
-
-    Creates parent directories if missing. Overwrites if file exists.
-
-    Args:
-        items: List of memory item dicts
-        output_path: Path where to write the markdown file
-    """
-    path = Path(output_path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    markdown = export_to_markdown(items)
-    _ = path.write_text(markdown)
-
-
-def export_from_store(store: Any, output_path: str | None = None) -> str:  # pyright: ignore[reportExplicitAny]
-    """Export all items from a MemoryStore to markdown.
-
-    Gets all items from store.export_all(). If output_path is given, writes to file.
-    Always returns the markdown string.
-
-    Args:
-        store: MemoryStore instance
-        output_path: Optional path to write markdown file to
-
-    Returns:
-        Markdown string representation of all items
-    """
-    items = store.export_all()
-    markdown = export_to_markdown(items)
-
-    if output_path is not None:
-        export_to_file(items, output_path)
-
-    return markdown
-
-
-__all__ = ["export_to_markdown", "export_to_file", "export_from_store"]

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

@@ -1,91 +0,0 @@
-"""Gemini Web paste-based memory import — parse and import memories from Gemini Web interface."""
-
-from __future__ import annotations
-
-import re
-from typing import Any  # pyright: ignore[reportExplicitAny]
-
-EXTRACTION_PROMPT = (
-    "What do you remember about me? List all preferences, facts, and context you have stored. "
-    "Format each as a bullet point starting with '- '."
-)
-
-
-def parse_gemini_paste(text: str) -> list[dict[str, Any]]:  # pyright: ignore[reportExplicitAny]
-    """Parse memories from Gemini Web paste text.
-
-    Supports bullet points (- item) and numbered lists (1. item).
-
-    Args:
-        text: Raw text pasted from Gemini 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]] = []
-    for i, content in enumerate(items):
-        result.append(
-            {
-                "key": f"gemini-memory-{i+1}",
-                "content": content,
-                "source_cli": "gemini-web",
-                "tags": ["gemini-web", "imported"],
-            }
-        )
-
-    return result
-
-
-def import_from_paste(text: str, store: Any) -> int:  # pyright: ignore[reportAny]
-    """Import memories from Gemini Web paste into the memory store.
-
-    Args:
-        text: Raw text pasted from Gemini Web interface.
-        store: MemoryStore instance to add items to.
-
-    Returns:
-        Number of items successfully imported.
-    """
-    items = parse_gemini_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_gemini_paste", "import_from_paste"]

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

@@ -1,91 +0,0 @@
-"""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"]