memuron 0.1.1__py3-none-any.whl

memuron/domain/encoders.py

@@ -0,0 +1,185 @@
+"""Product-specific encoders."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from artha_engine.embeddings import TextEmbedder
+from artha_engine.encoders.base import Encoder
+
+from memuron.domain.representations import (
+    MemoryArthaanu,
+    MemoryLinkArthaanu,
+    MemoryLinkValue,
+    MemoryPlacementArthaanu,
+    MemoryPlacementValue,
+    MemoryValue,
+)
+
+
+@dataclass(frozen=True)
+class MemoryEncoderInput:
+    content: str
+    scope: list[str] = field(default_factory=list)
+    node_type: str = "text"
+    payload: dict[str, Any] = field(default_factory=dict)
+    perception: str | None = None
+    encoding: str = "memory"
+    metadata: dict[str, Any] = field(default_factory=dict)
+    artha_id: str | None = None
+    name: str = "memory"
+    retrieval_count: int = 0
+
+
+@dataclass(frozen=True)
+class MemoryLinkEncoderInput:
+    source_id: str
+    target_id: str
+    description: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+    name: str = "memory_link"
+    artha_id: str | None = None
+
+
+@dataclass(frozen=True)
+class MemoryPlacementEncoderInput:
+    parent_id: str
+    child_id: str
+    name: str
+    scope: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    inherit_parent_scope: bool = True
+    artha_id: str | None = None
+
+
+class MemoryEncoder(Encoder[MemoryEncoderInput, MemoryArthaanu]):
+    name = "memory"
+    version = "0.1.0"
+    output_value_type = "memory"
+
+    def __init__(self, embedder: TextEmbedder | None = None) -> None:
+        self.embedder = embedder
+
+    def encode(self, source: MemoryEncoderInput) -> MemoryArthaanu:
+        embedding: list[float] = []
+        perception = source.perception or source.content
+        if self.embedder is not None and perception.strip():
+            embedding = self.embedder.embed_documents([perception])[0]
+        artha_id = source.artha_id or f"artha_{uuid4().hex}"
+        return MemoryArthaanu(
+            artha_id=artha_id,
+            name=source.name,
+            value=MemoryValue(
+                content=source.content,
+                node_type=source.node_type,  # type: ignore[arg-type]
+                payload=dict(source.payload),
+                perception=perception,
+                encoding=source.encoding,
+                metadata=dict(source.metadata),
+                scope=list(source.scope),
+                embedding=embedding,
+                retrieval_count=source.retrieval_count,
+            ),
+        )
+
+
+class MemoryLinkEncoder(Encoder[MemoryLinkEncoderInput, MemoryLinkArthaanu]):
+    name = "memory_link"
+    version = "0.1.0"
+    output_value_type = "memory_link"
+
+    def __init__(self, embedder: TextEmbedder | None = None) -> None:
+        self.embedder = embedder
+
+    def encode(self, source: MemoryLinkEncoderInput) -> MemoryLinkArthaanu:
+        embedding: list[float] = []
+        if self.embedder is not None and source.description.strip():
+            embedding = self.embedder.embed_documents([source.description])[0]
+        artha_id = source.artha_id or f"artha_{uuid4().hex}"
+        return MemoryLinkArthaanu(
+            artha_id=artha_id,
+            name=source.name,
+            value=MemoryLinkValue(
+                source_id=source.source_id,
+                target_id=source.target_id,
+                description=source.description,
+                metadata=dict(source.metadata),
+                embedding=embedding,
+            ),
+        )
+
+
+class MemoryPlacementEncoder(Encoder[MemoryPlacementEncoderInput, MemoryPlacementArthaanu]):
+    name = "memory_placement"
+    version = "0.1.0"
+    output_value_type = "memory_placement"
+
+    def encode(self, source: MemoryPlacementEncoderInput) -> MemoryPlacementArthaanu:
+        artha_id = source.artha_id or f"placement_{uuid4().hex}"
+        return MemoryPlacementArthaanu(
+            artha_id=artha_id,
+            name="memory_placement",
+            value=MemoryPlacementValue(
+                parent_id=source.parent_id,
+                child_id=source.child_id,
+                name=source.name,
+                scope=list(source.scope),
+                metadata=dict(source.metadata),
+                inherit_parent_scope=source.inherit_parent_scope,
+            ),
+        )
+
+
+def normalize_memory_encoder_input(raw_input: object) -> MemoryEncoderInput:
+    if isinstance(raw_input, MemoryEncoderInput):
+        return raw_input
+    if isinstance(raw_input, dict):
+        data: dict[str, Any] = raw_input
+        return MemoryEncoderInput(
+            content=str(data["content"]),
+            scope=[str(item) for item in data.get("scope") or []],
+            node_type=str(data.get("node_type") or data.get("type") or "text"),
+            payload=dict(data.get("payload") or {}),
+            perception=str(data["perception"]) if data.get("perception") is not None else None,
+            encoding=str(data.get("encoding") or "memory"),
+            metadata=dict(data.get("metadata") or {}),
+            artha_id=data.get("artha_id"),
+            name=str(data.get("name") or "memory"),
+            retrieval_count=int(data.get("retrieval_count") or 0),
+        )
+    raise ValueError("memory encoder requires MemoryEncoderInput or dict")
+
+
+def normalize_memory_link_encoder_input(raw_input: object) -> MemoryLinkEncoderInput:
+    if isinstance(raw_input, MemoryLinkEncoderInput):
+        return raw_input
+    if isinstance(raw_input, dict):
+        data: dict[str, Any] = raw_input
+        return MemoryLinkEncoderInput(
+            source_id=str(data["source_id"]),
+            target_id=str(data["target_id"]),
+            description=str(data["description"]),
+            metadata=dict(data.get("metadata") or {}),
+            name=str(data.get("name") or "memory_link"),
+            artha_id=data.get("artha_id"),
+        )
+    raise ValueError("memory_link encoder requires MemoryLinkEncoderInput or dict")
+
+
+def normalize_memory_placement_encoder_input(raw_input: object) -> MemoryPlacementEncoderInput:
+    if isinstance(raw_input, MemoryPlacementEncoderInput):
+        return raw_input
+    if isinstance(raw_input, dict):
+        data: dict[str, Any] = raw_input
+        return MemoryPlacementEncoderInput(
+            parent_id=str(data["parent_id"]),
+            child_id=str(data["child_id"]),
+            name=str(data["name"]),
+            scope=[str(item) for item in data.get("scope") or []],
+            metadata=dict(data.get("metadata") or {}),
+            inherit_parent_scope=bool(data.get("inherit_parent_scope", True)),
+            artha_id=data.get("artha_id"),
+        )
+    raise ValueError("memory_placement encoder requires MemoryPlacementEncoderInput or dict")

memuron/domain/lifecycles.py

@@ -0,0 +1,8 @@
+"""Product-specific lifecycle steps live here.
+
+Guardian write planning (create/update/link/consolidate) currently lives in
+recipes.py + guardian.py as an intentional v0 slice. When Memuron adds
+reinforcement, merge, supersession, archival, or reflection, those transitions
+should become registered lifecycles so transformations are explicit, replayable,
+and reusable outside a single recipe.
+"""

memuron/domain/limits.py

@@ -0,0 +1,6 @@
+"""Memory content limits."""
+
+MAX_MEMORY_CONTENT = 50_000
+MAX_ADD_MEMORY_CONTENT = MAX_MEMORY_CONTENT * 10
+MAX_SCOPE_ITEMS = 50
+MAX_SCOPE_TOKEN_LEN = 256

memuron/domain/representations.py

@@ -0,0 +1,56 @@
+"""Product-specific Arthaanu representation classes."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from artha_engine.representations import Arthaanu
+
+
+class MemoryValue(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    content: str
+    node_type: Literal["text", "image", "document", "collection"] = "text"
+    payload: dict[str, Any] = Field(default_factory=dict)
+    perception: str | None = None
+    encoding: str = "memory"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    scope: list[str] = Field(default_factory=list)
+    embedding: list[float] = Field(default_factory=list)
+    retrieval_count: int = 0
+
+
+class MemoryArthaanu(Arthaanu[MemoryValue]):
+    value_type: Literal["memory"] = "memory"
+
+
+class MemoryLinkValue(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    source_id: str
+    target_id: str
+    description: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    embedding: list[float] = Field(default_factory=list)
+
+
+class MemoryLinkArthaanu(Arthaanu[MemoryLinkValue]):
+    value_type: Literal["memory_link"] = "memory_link"
+
+
+class MemoryPlacementValue(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    parent_id: str
+    child_id: str
+    name: str
+    scope: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    inherit_parent_scope: bool = True
+
+
+class MemoryPlacementArthaanu(Arthaanu[MemoryPlacementValue]):
+    value_type: Literal["memory_placement"] = "memory_placement"