@trac3er/oh-my-god 2.0.0-beta.2 → 2.1.0-alpha

package/claude_experimental/memory/episodic.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from importlib import import_module
+import json
+from typing import cast
+
+from claude_experimental.memory.store import MemoryStore
+
+_EVENT_TYPES = {"success", "failure", "decision", "discovery"}
+
+
+class EpisodicMemory:
+    def __init__(self, store: MemoryStore | None = None):
+        self.store: MemoryStore = store or MemoryStore()
+
+    def record(
+        self,
+        event_type: str,
+        context: object,
+        outcome: object,
+        session_id: str | None = None,
+        metadata: dict[str, object] | None = None,
+    ) -> int:
+        _require_memory_enabled()
+
+        normalized_event_type = event_type.strip().lower()
+        if normalized_event_type not in _EVENT_TYPES:
+            allowed = ", ".join(sorted(_EVENT_TYPES))
+            raise ValueError(f"Invalid event_type '{event_type}'. Allowed values: {allowed}")
+
+        importance = self._importance_for(normalized_event_type, outcome, metadata)
+        payload = {
+            "event_type": normalized_event_type,
+            "session_id": session_id,
+            "context": context,
+            "outcome": outcome,
+        }
+        content = self._to_text(payload)
+
+        store_metadata: dict[str, object] = {
+            "event_type": normalized_event_type,
+            "session_id": session_id,
+            "context": context,
+            "outcome": outcome,
+        }
+        if metadata:
+            store_metadata.update(metadata)
+
+        return self.store.save(
+            content=content,
+            memory_type="episodic",
+            importance=importance,
+            metadata=store_metadata,
+        )
+
+    def recall(
+        self,
+        query: str,
+        limit: int = 5,
+        temperature: float = 0.3,
+        event_type_filter: str | None = None,
+    ) -> list[dict[str, object]]:
+        _require_memory_enabled()
+
+        clamped_temperature = max(0.0, min(1.0, temperature))
+        min_score = 1.0 - clamped_temperature
+        normalized_filter = event_type_filter.strip().lower() if event_type_filter else None
+        if normalized_filter and normalized_filter not in _EVENT_TYPES:
+            allowed = ", ".join(sorted(_EVENT_TYPES))
+            raise ValueError(
+                f"Invalid event_type_filter '{event_type_filter}'. Allowed values: {allowed}"
+            )
+
+        base_results = self.store.search(
+            query=query,
+            limit=max(limit, 1),
+            memory_type="episodic",
+        )
+
+        filtered: list[dict[str, object]] = []
+        total = len(base_results)
+        for index, item in enumerate(base_results):
+            memory = dict(item)
+            metadata_raw = memory.get("metadata")
+            if isinstance(metadata_raw, str):
+                parsed_json: object
+                try:
+                    parsed_json = cast(object, json.loads(metadata_raw))
+                except json.JSONDecodeError:
+                    parsed_json = cast(object, {})
+                metadata = _coerce_object_dict(parsed_json)
+            else:
+                metadata = _coerce_object_dict(metadata_raw)
+
+            event_type = str(metadata.get("event_type", "")).strip().lower()
+            if normalized_filter and event_type != normalized_filter:
+                continue
+
+            relevance = self._relevance(memory, index, total)
+            memory["score"] = relevance
+            if relevance >= min_score:
+                filtered.append(memory)
+                if len(filtered) >= limit:
+                    break
+
+        return filtered
+
+    @staticmethod
+    def _importance_for(
+        event_type: str,
+        outcome: object,
+        metadata: dict[str, object] | None,
+    ) -> float:
+        if event_type == "success":
+            return 0.7
+        if event_type == "failure" and EpisodicMemory._has_lessons(outcome, metadata):
+            return 0.8
+        return 0.3
+
+    @staticmethod
+    def _has_lessons(outcome: object, metadata: dict[str, object] | None) -> bool:
+        if metadata:
+            if _contains_lesson_signal(metadata.get("lessons")):
+                return True
+
+        outcome_dict = _coerce_object_dict(outcome)
+        if _contains_lesson_signal(outcome_dict.get("lessons")):
+            return True
+
+        outcome_text = EpisodicMemory._to_text(outcome).lower()
+        return "lesson" in outcome_text or "learned" in outcome_text
+
+    @staticmethod
+    def _to_text(value: object) -> str:
+        if isinstance(value, str):
+            return value
+        return json.dumps(value, sort_keys=True, default=str)
+
+    @staticmethod
+    def _relevance(memory: dict[str, object], index: int, total: int) -> float:
+        if total <= 1:
+            rank_relevance = 1.0
+        else:
+            rank_relevance = max(0.0, min(1.0, 1.0 - (index / (total - 1))))
+
+        score = memory.get("score")
+        if isinstance(score, (int, float)):
+            return max(0.0, min(1.0, float(score)))
+
+        return rank_relevance
+
+
+def _require_memory_enabled() -> None:
+    memory_module = import_module("claude_experimental.memory")
+    require_enabled = getattr(memory_module, "_require_enabled", None)
+    if callable(require_enabled):
+        _ = require_enabled()
+        return
+    raise RuntimeError("claude_experimental.memory._require_enabled is unavailable")
+
+
+def _coerce_object_dict(value: object) -> dict[str, object]:
+    if not isinstance(value, dict):
+        return {}
+    value_dict = cast(dict[object, object], value)
+    return {str(key): item for key, item in value_dict.items()}
+
+
+def _contains_lesson_signal(value: object) -> bool:
+    if isinstance(value, str):
+        return bool(value.strip())
+    if isinstance(value, list):
+        for item in cast(list[object], value):
+            if _contains_lesson_signal(item):
+                return True
+        return False
+    if isinstance(value, tuple):
+        for item in cast(tuple[object, ...], value):
+            if _contains_lesson_signal(item):
+                return True
+        return False
+    if isinstance(value, set):
+        for item in cast(set[object], value):
+            if _contains_lesson_signal(item):
+                return True
+        return False
+    if isinstance(value, dict):
+        value_dict = cast(dict[object, object], value)
+        return _contains_lesson_signal(list(value_dict.values()))
+    return False

package/claude_experimental/memory/failure_learning.py

@@ -0,0 +1,183 @@
+"""FailureLearner — records agent failures and learns patterns to warn on similar future contexts."""
+from __future__ import annotations
+
+import json
+import os
+import re
+from importlib import import_module
+from typing import cast
+
+from claude_experimental.memory.episodic import EpisodicMemory
+from claude_experimental.memory.store import MemoryStore
+
+
+class FailureLearner:
+    """Records agent failures and learns patterns to warn on similar future contexts.
+
+    Uses episodic memory to store failure records and FTS5 search to find
+    similar past failures when new errors occur.  Warn-only: does not
+    prevent dispatch or automatic avoidance.
+    """
+
+    def __init__(self, db_path: str | None = None) -> None:
+        self.store: MemoryStore = MemoryStore(db_path=db_path) if db_path else MemoryStore()
+        self.episodic: EpisodicMemory = EpisodicMemory(self.store)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def record_failure(
+        self,
+        context: str,
+        error_type: str,
+        error_message: str,
+        stack_trace: str | None = None,
+    ) -> int:
+        """Record a failure for future pattern matching.
+
+        Returns the memory ID of the stored failure record.
+        """
+        _require_memory_enabled()
+
+        sanitized_trace: str | None = (
+            self._sanitize_trace(stack_trace) if stack_trace else None
+        )
+
+        content = f"FAILURE: {error_type} | Context: {context} | Error: {error_message}"
+
+        metadata: dict[str, object] = {
+            "error_type": error_type,
+            "context": context,
+            "error_message": error_message,
+            "sanitized_trace": sanitized_trace,
+            "event_type": "failure",
+        }
+
+        return self.store.save(
+            content=content,
+            memory_type="episodic",
+            importance=0.9,
+            metadata=metadata,
+        )
+
+    def suggest_fix(
+        self,
+        error_type: str,
+        context: str,
+        limit: int = 3,
+    ) -> list[dict[str, object]]:
+        """Find past failures matching this error type and context.
+
+        Returns list of dicts with context, error_type, error_message,
+        memory_id, and relevance score.
+        """
+        _require_memory_enabled()
+
+        # FTS5 uses implicit AND; use OR for broader failure matching
+        raw_terms = f"{error_type} {context}".split()
+        query = " OR ".join(raw_terms)
+        results = self.episodic.recall(
+            query=query,
+            limit=limit,
+            event_type_filter="failure",
+        )
+
+        suggestions: list[dict[str, object]] = []
+        for result in results:
+            meta = _parse_metadata(result)
+            suggestions.append({
+                "context": str(meta.get("context", "")),
+                "error_type": str(meta.get("error_type", "")),
+                "error_message": str(meta.get("error_message", "")),
+                "memory_id": result.get("id", 0),
+                "relevance": float(cast(float, result.get("score", 0.0))),
+            })
+
+        return suggestions
+
+    def get_failure_patterns(
+        self,
+        min_occurrences: int = 2,
+    ) -> list[dict[str, object]]:
+        """Find recurring failure patterns grouped by error type.
+
+        Returns error types that have occurred at least *min_occurrences* times.
+        """
+        _require_memory_enabled()
+
+        conn = self.store.connect()
+        try:
+            rows = conn.execute(
+                "SELECT metadata FROM memories WHERE memory_type = 'episodic'"
+            ).fetchall()
+
+            counts: dict[str, int] = {}
+            for row in rows:
+                meta = _safe_parse_json(row["metadata"])
+                if meta.get("event_type") != "failure":
+                    continue
+                error_type = str(meta.get("error_type", "unknown"))
+                counts[error_type] = counts.get(error_type, 0) + 1
+
+            return [
+                {"error_type": error_type, "count": count}
+                for error_type, count in sorted(counts.items())
+                if count >= min_occurrences
+            ]
+        finally:
+            conn.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _sanitize_trace(trace: str) -> str:
+        """Remove full file paths and line numbers from stack traces."""
+        sanitized = re.sub(
+            r'File "([^"]+)"',
+            lambda m: f'File "{os.path.basename(m.group(1))}"',
+            trace,
+        )
+        return re.sub(r", line \d+", "", sanitized)
+
+
+# ------------------------------------------------------------------
+# Module-level helpers
+# ------------------------------------------------------------------
+
+
+def _require_memory_enabled() -> None:
+    """Gate all public methods behind the experimental memory feature flag."""
+    memory_module = import_module("claude_experimental.memory")
+    require_enabled = getattr(memory_module, "_require_enabled", None)
+    if callable(require_enabled):
+        _ = require_enabled()
+        return
+    raise RuntimeError("claude_experimental.memory._require_enabled is unavailable")
+
+
+def _parse_metadata(result: dict[str, object]) -> dict[str, object]:
+    """Parse metadata from a recall result dict."""
+    return _safe_parse_json(result.get("metadata"))
+
+
+def _safe_parse_json(value: object) -> dict[str, object]:
+    """Safely parse a JSON string or coerce a dict; returns empty dict on failure."""
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, dict):
+                parsed_dict = cast(dict[object, object], parsed)
+                return {str(k): v for k, v in parsed_dict.items()}
+        except json.JSONDecodeError:
+            pass
+        return {}
+    if isinstance(value, dict):
+        raw_dict = cast(dict[object, object], value)
+        return {str(k): v for k, v in raw_dict.items()}
+    return {}
+
+
+__all__ = ["FailureLearner"]

package/claude_experimental/memory/migrate.py

@@ -0,0 +1,169 @@
+"""Legacy Markdown Memory Migration Utility.
+
+Migrates existing .omg/state/memory/*.md files to SQLite MemoryStore.
+Preserves original files (copy, don't move) for safe rollback.
+Idempotent: running twice doesn't create duplicates (dedup via content hash).
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import cast
+
+from claude_experimental.memory.store import MemoryStore
+
+
+def migrate_markdown_memories(
+    project_dir: str,
+    target_store: MemoryStore | None = None,
+) -> dict[str, int]:
+    """Migrate markdown memories from .omg/state/memory/ to SQLite store.
+
+    Args:
+        project_dir: Root project directory containing .omg/state/memory/
+        target_store: MemoryStore instance (default: project-scoped store)
+
+    Returns:
+        Dict with keys:
+        - files_found: Number of .md files discovered
+        - memories_migrated: Number successfully inserted
+        - errors: Number of files that failed to process
+        - skipped_duplicates: Number skipped due to content hash collision
+    """
+    store = target_store or MemoryStore(scope="project")
+    memory_dir = os.path.join(project_dir, ".omg", "state", "memory")
+
+    result = {
+        "files_found": 0,
+        "memories_migrated": 0,
+        "errors": 0,
+        "skipped_duplicates": 0,
+    }
+
+    # Handle missing directory gracefully
+    if not os.path.isdir(memory_dir):
+        return result
+
+    # Collect all .md files
+    md_files = sorted(
+        [f for f in os.listdir(memory_dir) if f.endswith(".md")],
+        reverse=True,  # Process newest first
+    )
+    result["files_found"] = len(md_files)
+
+    for filename in md_files:
+        filepath = os.path.join(memory_dir, filename)
+
+        try:
+            # Read file content
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+
+            if not content.strip():
+                result["errors"] += 1
+                continue
+
+            # Extract date from filename (format: YYYY-MM-DD-*.md)
+            date_match = re.match(r"(\d{4}-\d{2}-\d{2})", filename)
+            if date_match:
+                date_str = date_match.group(1)
+                try:
+                    created_at = datetime.strptime(date_str, "%Y-%m-%d").timestamp()
+                except ValueError:
+                    created_at = datetime.now().timestamp()
+            else:
+                created_at = datetime.now().timestamp()
+
+            # Compute content hash for deduplication
+            content_hash = hashlib.sha256(content.encode()).hexdigest()
+
+            # Check if memory with same content hash already exists
+            existing = _find_memory_by_content_hash(store, content_hash)
+            if existing is not None:
+                result["skipped_duplicates"] += 1
+                continue
+
+            # Calculate importance: normalized to 500 chars
+            importance = min(len(content) / 500.0, 1.0)
+
+            # Build metadata
+            metadata: dict[str, object] = {
+                "content_hash": content_hash,
+                "source_file": filename,
+                "migrated_from": "markdown",
+            }
+
+            # Insert into store
+            memory_id = store.save(
+                content=content,
+                memory_type="semantic",
+                importance=importance,
+                scope="project",
+                metadata=metadata,
+            )
+
+            if memory_id > 0:
+                result["memories_migrated"] += 1
+            else:
+                result["errors"] += 1
+
+        except (OSError, IOError) as e:
+            result["errors"] += 1
+            continue
+
+    return result
+
+
+def _find_memory_by_content_hash(
+    store: MemoryStore, content_hash: str
+) -> dict[str, object] | None:
+    """Search for existing memory with matching content hash in metadata.
+
+    Args:
+        store: MemoryStore instance
+        content_hash: SHA256 hex digest to search for
+
+    Returns:
+        Memory dict if found, None otherwise
+    """
+    conn = store.connect()
+    try:
+        # Search metadata JSON for content_hash field
+        rows = cast(
+            list[tuple[object, ...]],
+            conn.execute(
+                """
+                SELECT id, content, memory_type, importance, scope, metadata,
+                       created_at, accessed_at, access_count, schema_version
+                FROM memories
+                WHERE scope = ? AND json_extract(metadata, '$.content_hash') = ?
+                LIMIT 1
+                """,
+                ("project", content_hash),
+            ).fetchall(),
+        )
+
+        if rows:
+            row = rows[0]
+            return {
+                "id": row[0],
+                "content": row[1],
+                "memory_type": row[2],
+                "importance": row[3],
+                "scope": row[4],
+                "metadata": json.loads(row[5]) if isinstance(row[5], str) else row[5],
+                "created_at": row[6],
+                "accessed_at": row[7],
+                "access_count": row[8],
+                "schema_version": row[9],
+            }
+        return None
+    except Exception:
+        # If query fails (e.g., json_extract not available), return None
+        return None
+    finally:
+        conn.close()