@simbimbo/memory-ocmemog 0.1.4

package/brain/runtime/memory/candidate.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import uuid
+import json
+from typing import Dict, Any
+
+from brain.runtime.instrumentation import emit_event
+from brain.runtime import state_store
+from brain.runtime.memory import provenance, store
+from brain.runtime.security import redaction
+
+
+LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
+
+
+def create_candidate(
+    source_event_id: int,
+    distilled_summary: str,
+    verification_points: list[str],
+    confidence_score: float,
+    metadata: Dict[str, Any] | None = None,
+) -> Dict[str, Any]:
+    summary, redacted = redaction.redact_text(distilled_summary)
+    verification_lines = []
+    for point in verification_points:
+        clean, _ = redaction.redact_text(str(point))
+        verification_lines.append(clean)
+
+    normalized_metadata = provenance.normalize_metadata(metadata, source="candidate")
+
+    conn = store.connect()
+    row = conn.execute(
+        "SELECT candidate_id FROM candidates WHERE source_event_id=? AND distilled_summary=?",
+        (source_event_id, summary),
+    ).fetchone()
+    if row:
+        conn.close()
+        emit_event(LOGFILE, "brain_memory_candidate_duplicate", status="ok", source_event_id=source_event_id)
+        return {"candidate_id": row[0], "duplicate": True}
+
+    candidate_id = str(uuid.uuid4())
+    verification_status = "verified" if verification_lines else "unverified"
+    conn.execute(
+        """
+        INSERT INTO candidates (
+            candidate_id, source_event_id, distilled_summary, verification_points,
+            confidence_score, status, verification_status, metadata_json, schema_version
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            candidate_id,
+            source_event_id,
+            summary,
+            "\n".join(verification_lines),
+            confidence_score,
+            "pending",
+            verification_status,
+            json.dumps(normalized_metadata, ensure_ascii=False),
+            store.SCHEMA_VERSION,
+        ),
+    )
+    conn.execute(
+        "INSERT INTO memory_events (event_type, source, details_json, schema_version) VALUES (?, ?, ?, ?)",
+        (
+            "candidate_created",
+            str(source_event_id),
+            json.dumps({"candidate_id": candidate_id, "redacted": redacted, "verification_status": verification_status}),
+            store.SCHEMA_VERSION,
+        ),
+    )
+    conn.commit()
+    conn.close()
+    emit_event(LOGFILE, "brain_memory_candidate_created", status="ok", source_event_id=source_event_id, redacted=redacted)
+    return {"candidate_id": candidate_id, "duplicate": False}
+
+
+def get_candidate(candidate_id: str) -> Dict[str, Any] | None:
+    conn = store.connect()
+    row = conn.execute(
+        """
+        SELECT candidate_id, source_event_id, distilled_summary, verification_points,
+               confidence_score, status, verification_status, metadata_json
+        FROM candidates
+        WHERE candidate_id=?
+        """,
+        (candidate_id,),
+    ).fetchone()
+    conn.close()
+    return dict(row) if row else None

package/brain/runtime/memory/context_builder.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, List
+
+from brain.runtime.instrumentation import emit_event
+from brain.runtime import state_store
+from brain.runtime.memory import retrieval
+
+
+def build_context(
+    prompt: str,
+    max_context_blocks: int = 5,
+    *,
+    memory_queries: Iterable[str] | None = None,
+    memory_priorities: Iterable[str] | None = None,
+    role_id: str | None = None,
+) -> Dict[str, List[str]]:
+    emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_context_build_start", status="ok")
+    queries = [query for query in (memory_queries or ()) if isinstance(query, str) and query.strip()]
+    categories = [category for category in (memory_priorities or ()) if isinstance(category, str) and category.strip()]
+    role_priorities: List[str] = []
+    if role_id:
+        try:
+            from brain.runtime.roles import role_registry
+            role = role_registry.get_role(role_id)
+            role_priorities = list(role.memory_priority) if role else []
+        except Exception:
+            role_priorities = []
+    combined_priorities = [*categories, *role_priorities]
+    if queries:
+        mem = retrieval.retrieve_for_queries(queries, categories=combined_priorities or None)
+    else:
+        mem = retrieval.retrieve(prompt, categories=combined_priorities or None)
+
+    ranked_blocks: List[Dict[str, str | float]] = []
+    for item in mem.get("knowledge", []):
+        ranked_blocks.append(
+            {
+                "content": item.get("content"),
+                "source": "knowledge",
+                "score": float(item.get("score") or item.get("confidence") or 0.0),
+            }
+        )
+    for item in mem.get("tasks", []):
+        ranked_blocks.append(
+            {
+                "content": item.get("content"),
+                "source": "tasks",
+                "score": float(item.get("score") or item.get("confidence") or 0.0),
+            }
+        )
+    if role_priorities:
+        for item in ranked_blocks:
+            if item.get("source") in role_priorities:
+                item["score"] = float(item.get("score", 0.0)) + 0.2
+        emit_event(
+            state_store.reports_dir() / "brain_memory.log.jsonl",
+            "brain_role_context_weighted",
+            status="ok",
+            role_id=role_id,
+            priorities=len(role_priorities),
+        )
+    ranked_blocks.sort(key=lambda item: item.get("score", 0.0), reverse=True)
+    if len(ranked_blocks) > max_context_blocks:
+        ranked_blocks = ranked_blocks[:max_context_blocks]
+        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_context_trim", status="ok")
+
+    context_blocks = [item["content"] for item in ranked_blocks if item.get("content")]
+    context_scores = [item.get("score", 0.0) for item in ranked_blocks]
+    synthesis = mem.get("synthesis", []) if isinstance(mem, dict) else []
+    for item in synthesis[:2]:
+        summary = item.get("summary") if isinstance(item, dict) else None
+        if summary:
+            context_blocks.append(str(summary))
+
+    context = {
+        "context_blocks": context_blocks,
+        "context_scores": context_scores,
+        "ranked_blocks": ranked_blocks,
+        "knowledge": mem.get("knowledge", []),
+        "tasks": mem.get("tasks", []),
+        "directives": [item["content"] if isinstance(item, dict) else item for item in mem.get("directives", [])],
+        "reflections": [item["content"] if isinstance(item, dict) else item for item in mem.get("reflections", [])],
+        "used_queries": queries,
+    }
+    emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_context_build_complete", status="ok")
+    return context