infinity-context 0.1.0__py3-none-any.whl

infinity_context_adapters/graphiti/scope_identity.py

@@ -0,0 +1,31 @@
+"""Stable Graphiti group identity mapping shared by write and evidence adapters."""
+
+from __future__ import annotations
+
+import re
+
+
+def graphiti_group_id(
+    space_id: str,
+    memory_scope_id: str,
+    *,
+    prefix: str = "memory",
+) -> str:
+    """Map canonical scope identity to Graphiti's persisted group identifier."""
+
+    return "__".join(
+        (
+            _safe_group_id_part(prefix),
+            _safe_group_id_part(space_id),
+            _safe_group_id_part(memory_scope_id),
+        )
+    )
+
+
+def _safe_group_id_part(value: str) -> str:
+    cleaned = re.sub(r"[^a-zA-Z0-9_-]+", "_", value.strip())
+    cleaned = cleaned.strip("_")
+    return cleaned or "default"
+
+
+__all__ = ("graphiti_group_id",)

infinity_context_adapters/local_blob.py

@@ -0,0 +1,101 @@
+"""Local filesystem blob storage adapter."""
+
+from __future__ import annotations
+
+import os
+from bisect import bisect_right
+from datetime import UTC, datetime
+from pathlib import Path
+
+from infinity_context_core.domain.errors import MemoryNotFoundError, MemoryValidationError
+from infinity_context_core.ports.assets import StoredBlob, StoredBlobObject, StoredBlobPage
+
+
+class LocalBlobStorage:
+    def __init__(self, *, root_dir: str | Path) -> None:
+        self._root = Path(root_dir).expanduser().resolve()
+
+    async def write_bytes(self, *, storage_key: str, content: bytes) -> StoredBlob:
+        path = self._path_for_key(storage_key)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = path.with_name(f".{path.name}.tmp")
+        tmp_path.write_bytes(content)
+        os.replace(tmp_path, path)
+        return StoredBlob(storage_key=storage_key, byte_size=len(content))
+
+    async def read_bytes(self, *, storage_key: str) -> bytes:
+        path = self._path_for_key(storage_key)
+        if not path.exists() or not path.is_file():
+            raise MemoryNotFoundError("Asset blob not found")
+        return path.read_bytes()
+
+    async def delete(self, *, storage_key: str) -> None:
+        path = self._path_for_key(storage_key)
+        if path.exists() and path.is_file():
+            path.unlink()
+
+    async def stat_object(self, *, storage_key: str) -> StoredBlobObject:
+        path = self._path_for_key(storage_key)
+        if not path.exists() or not path.is_file():
+            raise MemoryNotFoundError("Asset blob not found")
+        return self._object_for_path(path)
+
+    async def list_objects(
+        self,
+        *,
+        prefix: str = "",
+        limit: int = 500,
+        cursor: str | None = None,
+    ) -> StoredBlobPage:
+        normalized_prefix = self._normalize_list_prefix(prefix)
+        safe_limit = max(1, min(limit, 5_000))
+        root = self._root
+        if normalized_prefix:
+            root = self._path_for_key(normalized_prefix)
+            if root.is_file():
+                candidates = [root]
+            elif root.exists():
+                candidates = [path for path in root.rglob("*") if path.is_file()]
+            else:
+                candidates = []
+        else:
+            candidates = [path for path in self._root.rglob("*") if path.is_file()]
+
+        objects = sorted(
+            (self._object_for_path(path) for path in candidates),
+            key=lambda item: item.storage_key,
+        )
+        keys = [item.storage_key for item in objects]
+        start = bisect_right(keys, cursor) if cursor else 0
+        page_objects = tuple(objects[start : start + safe_limit])
+        next_cursor = (
+            page_objects[-1].storage_key
+            if start + safe_limit < len(objects) and page_objects
+            else None
+        )
+        return StoredBlobPage(objects=page_objects, next_cursor=next_cursor)
+
+    def _path_for_key(self, storage_key: str) -> Path:
+        normalized = storage_key.strip().replace("\\", "/")
+        if not normalized or normalized.startswith("/") or ".." in normalized.split("/"):
+            raise MemoryValidationError("Invalid storage key")
+        path = (self._root / normalized).resolve()
+        if self._root != path and self._root not in path.parents:
+            raise MemoryValidationError("Invalid storage key")
+        return path
+
+    def _object_for_path(self, path: Path) -> StoredBlobObject:
+        stat = path.stat()
+        storage_key = path.relative_to(self._root).as_posix()
+        return StoredBlobObject(
+            storage_key=storage_key,
+            byte_size=stat.st_size,
+            updated_at=datetime.fromtimestamp(stat.st_mtime, tz=UTC),
+        )
+
+    def _normalize_list_prefix(self, prefix: str) -> str:
+        normalized = prefix.strip().replace("\\", "/").strip("/")
+        if not normalized:
+            return ""
+        self._path_for_key(normalized)
+        return normalized

infinity_context_adapters/noop/__init__.py

@@ -0,0 +1,16 @@
+"""Noop runtime adapters."""
+
+from infinity_context_adapters.noop.adapters import (
+    NoopEmbeddingAdapter,
+    NoopGraphMemoryAdapter,
+    NoopVectorMemoryAdapter,
+)
+from infinity_context_adapters.noop.runtime import SystemClock, UuidIdGenerator
+
+__all__ = [
+    "NoopEmbeddingAdapter",
+    "NoopGraphMemoryAdapter",
+    "NoopVectorMemoryAdapter",
+    "SystemClock",
+    "UuidIdGenerator",
+]

infinity_context_adapters/noop/adapters.py

@@ -0,0 +1,156 @@
+"""Noop adapters used when optional engines are disabled."""
+
+from infinity_context_core.ports.adapters import (
+    AdapterCapabilities,
+    EmbeddingResult,
+    GraphSearchResult,
+    VectorSearchResult,
+    VectorWriteResult,
+)
+from infinity_context_core.ports.capabilities import (
+    CapabilityDescriptor,
+    CapabilityMode,
+    CapabilityRecallQuery,
+    CapabilityRecallResult,
+    CapabilityStatus,
+    EngineHealthSnapshot,
+    FactProjectionWrite,
+    MemoryCapability,
+    ProjectionForgetRequest,
+    ProjectionForgetResult,
+    ProjectionWriteResult,
+)
+
+
+class NoopVectorMemoryAdapter:
+    def __init__(self, name: str = "qdrant") -> None:
+        self._name = name
+
+    async def capabilities(self) -> AdapterCapabilities:
+        return AdapterCapabilities(
+            name=self._name,
+            enabled=False,
+            healthy=True,
+            supports_upsert=False,
+            supports_delete=False,
+            supports_search=False,
+            supports_filters=False,
+            degraded_reason="disabled",
+        )
+
+    async def search_chunks(self, *_args: object, **_kwargs: object) -> VectorSearchResult:
+        return VectorSearchResult.degraded("vector.disabled", retryable=False)
+
+    async def upsert_chunks(self, *_args: object, **_kwargs: object) -> VectorWriteResult:
+        return VectorWriteResult.degraded("vector.disabled", retryable=False)
+
+    async def delete_chunks(self, *_args: object, **_kwargs: object) -> VectorWriteResult:
+        return VectorWriteResult.degraded("vector.disabled", retryable=False)
+
+
+class NoopGraphMemoryAdapter:
+    def __init__(self, name: str = "graphiti") -> None:
+        self._name = name
+
+    async def capabilities(self) -> AdapterCapabilities:
+        return AdapterCapabilities(
+            name=self._name,
+            enabled=False,
+            healthy=True,
+            supports_upsert=False,
+            supports_delete=False,
+            supports_search=False,
+            supports_filters=False,
+            supports_temporal_queries=False,
+            degraded_reason="disabled",
+        )
+
+    async def capability_descriptors(self) -> tuple[CapabilityDescriptor, ...]:
+        return (
+            _disabled_capability(self._name, MemoryCapability.TEMPORAL_FACT_GRAPH),
+            _disabled_capability(self._name, MemoryCapability.FACT_PROJECTION),
+            _disabled_capability(
+                self._name,
+                MemoryCapability.PROJECTION_FORGET,
+                supports_delete=False,
+            ),
+        )
+
+    async def health(self) -> EngineHealthSnapshot:
+        return EngineHealthSnapshot(
+            adapter_name=self._name,
+            status=CapabilityStatus.DISABLED,
+            capabilities=await self.capability_descriptors(),
+        )
+
+    async def search(self, *_args: object, **_kwargs: object) -> GraphSearchResult:
+        return GraphSearchResult.degraded("graph.disabled", retryable=False)
+
+    async def upsert_fact(self, *_args: object, **_kwargs: object) -> VectorWriteResult:
+        return VectorWriteResult.degraded("graph.disabled", retryable=False)
+
+    async def upsert_fact_projection(
+        self,
+        _command: FactProjectionWrite,
+    ) -> ProjectionWriteResult:
+        return ProjectionWriteResult(
+            status=CapabilityStatus.DISABLED,
+            affected_ids=(),
+        )
+
+    async def delete_fact(self, *_args: object, **_kwargs: object) -> VectorWriteResult:
+        return VectorWriteResult.degraded("graph.disabled", retryable=False)
+
+    async def forget_projection(
+        self,
+        _command: ProjectionForgetRequest,
+    ) -> ProjectionForgetResult:
+        return ProjectionForgetResult(
+            status=CapabilityStatus.DISABLED,
+            forgotten_ids=(),
+        )
+
+    async def search_facts(self, _query: CapabilityRecallQuery) -> CapabilityRecallResult:
+        return CapabilityRecallResult(
+            status=CapabilityStatus.DISABLED,
+            items=(),
+        )
+
+
+class NoopEmbeddingAdapter:
+    def __init__(self, name: str = "embeddings") -> None:
+        self._name = name
+
+    async def capabilities(self) -> AdapterCapabilities:
+        return AdapterCapabilities(
+            name=self._name,
+            enabled=False,
+            healthy=True,
+            supports_upsert=False,
+            supports_delete=False,
+            supports_search=False,
+            supports_filters=False,
+            degraded_reason="disabled",
+        )
+
+    async def embed_texts(self, *_args: object, **_kwargs: object) -> EmbeddingResult:
+        return EmbeddingResult.degraded("embeddings.disabled", retryable=False)
+
+
+def _disabled_capability(
+    adapter_name: str,
+    capability: MemoryCapability,
+    *,
+    supports_delete: bool = False,
+) -> CapabilityDescriptor:
+    return CapabilityDescriptor(
+        capability=capability,
+        adapter_name=adapter_name,
+        mode=CapabilityMode.DISABLED,
+        status=CapabilityStatus.DISABLED,
+        enabled=False,
+        supports_scope_filter=False,
+        supports_source_refs=False,
+        supports_delete=supports_delete,
+        degraded_reason="disabled",
+    )

infinity_context_adapters/noop/runtime.py

@@ -0,0 +1,21 @@
+"""Small runtime adapters that satisfy core ports."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from hashlib import sha256
+from uuid import uuid4
+
+
+class SystemClock:
+    def now(self) -> datetime:
+        return datetime.now(tz=UTC)
+
+
+class UuidIdGenerator:
+    def new_id(self, prefix: str) -> str:
+        return f"{prefix}_{uuid4().hex}"
+
+    def projection_id(self, adapter: str, aggregate_type: str, aggregate_id: str) -> str:
+        raw = f"{adapter}:{aggregate_type}:{aggregate_id}"
+        return "proj_" + sha256(raw.encode("utf-8")).hexdigest()[:24]

infinity_context_adapters/postgres/__init__.py

@@ -0,0 +1,19 @@
+"""Postgres adapter package."""
+
+from infinity_context_adapters.postgres.projection_fence import PostgresProjectionFence
+from infinity_context_adapters.postgres.unit_of_work import (
+    PostgresUnitOfWork,
+    PostgresUnitOfWorkFactory,
+    build_async_engine,
+    build_session_factory,
+    create_schema,
+)
+
+__all__ = [
+    "PostgresProjectionFence",
+    "PostgresUnitOfWork",
+    "PostgresUnitOfWorkFactory",
+    "build_async_engine",
+    "build_session_factory",
+    "create_schema",
+]

infinity_context_adapters/postgres/asset_mappers.py

@@ -0,0 +1,348 @@
+"""Postgres row mappers for asset extraction lifecycle entities."""
+
+from __future__ import annotations
+
+from infinity_context_core.domain.assets import (
+    AssetStatus,
+    ContextLinkSuggestionStatus,
+    MemoryAsset,
+    MemoryAssetId,
+    MemoryContextLink,
+    MemoryContextLinkId,
+    MemoryContextLinkSuggestion,
+    MemoryContextLinkSuggestionId,
+)
+from infinity_context_core.domain.entities import (
+    LifecycleStatus,
+    MemoryScopeId,
+    SpaceId,
+    ThreadId,
+)
+from infinity_context_core.domain.extraction import (
+    AssetExtractionJob,
+    AssetExtractionJobId,
+    AssetExtractionStatus,
+    ExtractionArtifact,
+    ExtractionArtifactId,
+    ExtractionArtifactType,
+    ExtractionRetryDisposition,
+)
+
+from infinity_context_adapters.postgres.models import (
+    MemoryAssetExtractionArtifactRow,
+    MemoryAssetExtractionJobRow,
+    MemoryAssetRow,
+    MemoryContextLinkRow,
+    MemoryContextLinkSuggestionRow,
+)
+
+
+def asset_to_row(asset: MemoryAsset) -> MemoryAssetRow:
+    return MemoryAssetRow(
+        id=str(asset.id),
+        space_id=str(asset.space_id),
+        memory_scope_id=str(asset.memory_scope_id),
+        thread_id=str(asset.thread_id) if asset.thread_id else None,
+        filename=asset.filename,
+        content_type=asset.content_type,
+        byte_size=asset.byte_size,
+        sha256_hex=asset.sha256_hex,
+        storage_backend=asset.storage_backend,
+        storage_key=asset.storage_key,
+        status=asset.status.value,
+        classification=asset.classification,
+        metadata_json=dict(asset.metadata),
+        created_at=asset.created_at,
+        updated_at=asset.updated_at,
+    )
+
+
+def apply_asset_to_row(asset: MemoryAsset, row: MemoryAssetRow) -> None:
+    row.space_id = str(asset.space_id)
+    row.memory_scope_id = str(asset.memory_scope_id)
+    row.thread_id = str(asset.thread_id) if asset.thread_id else None
+    row.filename = asset.filename
+    row.content_type = asset.content_type
+    row.byte_size = asset.byte_size
+    row.sha256_hex = asset.sha256_hex
+    row.storage_backend = asset.storage_backend
+    row.storage_key = asset.storage_key
+    row.status = asset.status.value
+    row.classification = asset.classification
+    row.metadata_json = dict(asset.metadata)
+    row.created_at = asset.created_at
+    row.updated_at = asset.updated_at
+
+
+def asset_row_to_domain(row: MemoryAssetRow) -> MemoryAsset:
+    return MemoryAsset(
+        id=MemoryAssetId(row.id),
+        space_id=SpaceId(row.space_id),
+        memory_scope_id=MemoryScopeId(row.memory_scope_id),
+        thread_id=ThreadId(row.thread_id) if row.thread_id else None,
+        filename=row.filename,
+        content_type=row.content_type,
+        byte_size=row.byte_size,
+        sha256_hex=row.sha256_hex,
+        storage_backend=row.storage_backend,
+        storage_key=row.storage_key,
+        status=AssetStatus(row.status),
+        classification=row.classification,
+        metadata=dict(row.metadata_json or {}),
+        created_at=row.created_at,
+        updated_at=row.updated_at,
+    )
+
+
+def asset_extraction_job_to_row(job: AssetExtractionJob) -> MemoryAssetExtractionJobRow:
+    return MemoryAssetExtractionJobRow(
+        id=str(job.id),
+        asset_id=str(job.asset_id),
+        space_id=str(job.space_id),
+        memory_scope_id=str(job.memory_scope_id),
+        thread_id=str(job.thread_id) if job.thread_id else None,
+        parser_profile=job.parser_profile,
+        parser_config_hash=job.parser_config_hash,
+        source_sha256_hex=job.source_sha256_hex,
+        parser_name=job.parser_name,
+        parser_version=job.parser_version,
+        model_version=job.model_version,
+        status=job.status.value,
+        attempt_count=job.attempt_count,
+        safe_error_code=job.safe_error_code,
+        safe_error_message=job.safe_error_message,
+        result_document_ids_json=list(job.result_document_ids),
+        metadata_json=dict(job.metadata),
+        created_at=job.created_at,
+        updated_at=job.updated_at,
+        started_at=job.started_at,
+        finished_at=job.finished_at,
+        lease_owner=job.lease_owner,
+        lease_expires_at=job.lease_expires_at,
+        heartbeat_at=job.heartbeat_at,
+        retry_after_at=job.retry_after_at,
+        cancellation_requested_at=job.cancellation_requested_at,
+        retry_disposition=job.retry_disposition.value if job.retry_disposition else None,
+    )
+
+
+def asset_extraction_job_row_to_domain(row: MemoryAssetExtractionJobRow) -> AssetExtractionJob:
+    return AssetExtractionJob(
+        id=AssetExtractionJobId(row.id),
+        asset_id=MemoryAssetId(row.asset_id),
+        space_id=SpaceId(row.space_id),
+        memory_scope_id=MemoryScopeId(row.memory_scope_id),
+        thread_id=ThreadId(row.thread_id) if row.thread_id else None,
+        parser_profile=row.parser_profile,
+        parser_config_hash=row.parser_config_hash,
+        source_sha256_hex=row.source_sha256_hex,
+        status=AssetExtractionStatus(row.status),
+        attempt_count=row.attempt_count,
+        safe_error_code=row.safe_error_code,
+        safe_error_message=row.safe_error_message,
+        parser_name=row.parser_name,
+        parser_version=row.parser_version,
+        model_version=row.model_version,
+        result_document_ids=tuple(row.result_document_ids_json or ()),
+        metadata=dict(row.metadata_json or {}),
+        created_at=row.created_at,
+        updated_at=row.updated_at,
+        started_at=row.started_at,
+        finished_at=row.finished_at,
+        lease_owner=row.lease_owner,
+        lease_expires_at=row.lease_expires_at,
+        heartbeat_at=row.heartbeat_at,
+        retry_after_at=row.retry_after_at,
+        cancellation_requested_at=row.cancellation_requested_at,
+        retry_disposition=(
+            ExtractionRetryDisposition(row.retry_disposition) if row.retry_disposition else None
+        ),
+    )
+
+
+def apply_asset_extraction_job_to_row(
+    job: AssetExtractionJob,
+    row: MemoryAssetExtractionJobRow,
+) -> None:
+    row.asset_id = str(job.asset_id)
+    row.space_id = str(job.space_id)
+    row.memory_scope_id = str(job.memory_scope_id)
+    row.thread_id = str(job.thread_id) if job.thread_id else None
+    row.parser_profile = job.parser_profile
+    row.parser_config_hash = job.parser_config_hash
+    row.source_sha256_hex = job.source_sha256_hex
+    row.parser_name = job.parser_name
+    row.parser_version = job.parser_version
+    row.model_version = job.model_version
+    row.status = job.status.value
+    row.attempt_count = job.attempt_count
+    row.safe_error_code = job.safe_error_code
+    row.safe_error_message = job.safe_error_message
+    row.result_document_ids_json = list(job.result_document_ids)
+    row.metadata_json = dict(job.metadata)
+    row.created_at = job.created_at
+    row.updated_at = job.updated_at
+    row.started_at = job.started_at
+    row.finished_at = job.finished_at
+    row.lease_owner = job.lease_owner
+    row.lease_expires_at = job.lease_expires_at
+    row.heartbeat_at = job.heartbeat_at
+    row.retry_after_at = job.retry_after_at
+    row.cancellation_requested_at = job.cancellation_requested_at
+    row.retry_disposition = job.retry_disposition.value if job.retry_disposition else None
+
+
+def extraction_artifact_to_row(artifact: ExtractionArtifact) -> MemoryAssetExtractionArtifactRow:
+    return MemoryAssetExtractionArtifactRow(
+        id=str(artifact.id),
+        job_id=str(artifact.job_id),
+        asset_id=str(artifact.asset_id),
+        artifact_type=artifact.artifact_type.value,
+        storage_backend=artifact.storage_backend,
+        storage_key=artifact.storage_key,
+        sha256_hex=artifact.sha256_hex,
+        byte_size=artifact.byte_size,
+        metadata_json=dict(artifact.metadata),
+        created_at=artifact.created_at,
+    )
+
+
+def extraction_artifact_row_to_domain(
+    row: MemoryAssetExtractionArtifactRow,
+) -> ExtractionArtifact:
+    return ExtractionArtifact(
+        id=ExtractionArtifactId(row.id),
+        job_id=AssetExtractionJobId(row.job_id),
+        asset_id=MemoryAssetId(row.asset_id),
+        artifact_type=ExtractionArtifactType(row.artifact_type),
+        storage_backend=row.storage_backend,
+        storage_key=row.storage_key,
+        sha256_hex=row.sha256_hex,
+        byte_size=row.byte_size,
+        metadata=dict(row.metadata_json or {}),
+        created_at=row.created_at,
+    )
+
+
+def context_link_to_row(link: MemoryContextLink) -> MemoryContextLinkRow:
+    return MemoryContextLinkRow(
+        id=str(link.id),
+        space_id=str(link.space_id),
+        memory_scope_id=str(link.memory_scope_id),
+        source_type=link.source_type,
+        source_id=link.source_id,
+        target_type=link.target_type,
+        target_id=link.target_id,
+        relation_type=link.relation_type,
+        confidence=link.confidence,
+        reason=link.reason,
+        status=link.status.value,
+        metadata_json=dict(link.metadata),
+        created_at=link.created_at,
+        updated_at=link.updated_at,
+    )
+
+
+def apply_context_link_to_row(link: MemoryContextLink, row: MemoryContextLinkRow) -> None:
+    row.space_id = str(link.space_id)
+    row.memory_scope_id = str(link.memory_scope_id)
+    row.source_type = link.source_type
+    row.source_id = link.source_id
+    row.target_type = link.target_type
+    row.target_id = link.target_id
+    row.relation_type = link.relation_type
+    row.confidence = link.confidence
+    row.reason = link.reason
+    row.status = link.status.value
+    row.metadata_json = dict(link.metadata)
+    row.created_at = link.created_at
+    row.updated_at = link.updated_at
+
+
+def context_link_row_to_domain(row: MemoryContextLinkRow) -> MemoryContextLink:
+    return MemoryContextLink(
+        id=MemoryContextLinkId(row.id),
+        space_id=SpaceId(row.space_id),
+        memory_scope_id=MemoryScopeId(row.memory_scope_id),
+        source_type=row.source_type,
+        source_id=row.source_id,
+        target_type=row.target_type,
+        target_id=row.target_id,
+        relation_type=row.relation_type,
+        confidence=row.confidence,
+        reason=row.reason,
+        status=LifecycleStatus(row.status),
+        metadata=dict(row.metadata_json or {}),
+        created_at=row.created_at,
+        updated_at=row.updated_at,
+    )
+
+
+def context_link_suggestion_to_row(
+    suggestion: MemoryContextLinkSuggestion,
+) -> MemoryContextLinkSuggestionRow:
+    return MemoryContextLinkSuggestionRow(
+        id=str(suggestion.id),
+        space_id=str(suggestion.space_id),
+        memory_scope_id=str(suggestion.memory_scope_id),
+        source_type=suggestion.source_type,
+        source_id=suggestion.source_id,
+        target_type=suggestion.target_type,
+        target_id=suggestion.target_id,
+        relation_type=suggestion.relation_type,
+        confidence=suggestion.confidence,
+        reason=suggestion.reason,
+        score=suggestion.score,
+        status=suggestion.status.value,
+        metadata_json=dict(suggestion.metadata),
+        created_at=suggestion.created_at,
+        updated_at=suggestion.updated_at,
+        reviewed_at=suggestion.reviewed_at,
+        review_reason=suggestion.review_reason,
+    )
+
+
+def apply_context_link_suggestion_to_row(
+    suggestion: MemoryContextLinkSuggestion,
+    row: MemoryContextLinkSuggestionRow,
+) -> None:
+    row.space_id = str(suggestion.space_id)
+    row.memory_scope_id = str(suggestion.memory_scope_id)
+    row.source_type = suggestion.source_type
+    row.source_id = suggestion.source_id
+    row.target_type = suggestion.target_type
+    row.target_id = suggestion.target_id
+    row.relation_type = suggestion.relation_type
+    row.confidence = suggestion.confidence
+    row.reason = suggestion.reason
+    row.score = suggestion.score
+    row.status = suggestion.status.value
+    row.metadata_json = dict(suggestion.metadata)
+    row.created_at = suggestion.created_at
+    row.updated_at = suggestion.updated_at
+    row.reviewed_at = suggestion.reviewed_at
+    row.review_reason = suggestion.review_reason
+
+
+def context_link_suggestion_row_to_domain(
+    row: MemoryContextLinkSuggestionRow,
+) -> MemoryContextLinkSuggestion:
+    return MemoryContextLinkSuggestion(
+        id=MemoryContextLinkSuggestionId(row.id),
+        space_id=SpaceId(row.space_id),
+        memory_scope_id=MemoryScopeId(row.memory_scope_id),
+        source_type=row.source_type,
+        source_id=row.source_id,
+        target_type=row.target_type,
+        target_id=row.target_id,
+        relation_type=row.relation_type,
+        confidence=row.confidence,
+        reason=row.reason,
+        score=float(row.score),
+        status=ContextLinkSuggestionStatus(row.status),
+        metadata=dict(row.metadata_json or {}),
+        created_at=row.created_at,
+        updated_at=row.updated_at,
+        reviewed_at=row.reviewed_at,
+        review_reason=row.review_reason,
+    )