infinity-context 0.1.0__py3-none-any.whl

infinity_context_server/features/memory_facts/suggestion_responses.py

@@ -0,0 +1,382 @@
+"""Suggestion response mappers owned by the memory_facts server seam."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from infinity_context_server.features.memory_facts.mappers import (
+    _redact_sensitive_text,
+    fact_to_response,
+    source_ref_to_response,
+)
+
+_MAX_METADATA_DEPTH = 4
+_MAX_METADATA_DICT_ITEMS = 120
+_MAX_METADATA_LIST_ITEMS = 50
+_MAX_PUBLIC_SUGGESTION_REVIEW_AUDIT_EVENTS = 10
+_PUBLIC_SUGGESTION_REVIEW_AUDIT_FIELDS = {
+    "event_type": 120,
+    "suggestion_id": 160,
+    "space_id": 80,
+    "memory_scope_id": 80,
+    "operation": 40,
+    "action": 16,
+    "previous_status": 40,
+    "new_status": 40,
+    "reviewed_at": 80,
+    "target_fact_id": 160,
+    "target_fact_version": 40,
+    "created_from_capture_id": 160,
+    "reason": 320,
+}
+_DUPLICATE_FACT_MERGE_REVIEW_KIND = "duplicate_fact_merge"
+
+
+def suggestion_to_response(suggestion: object) -> dict[str, Any]:
+    status = _enum_or_text(_required_value(suggestion, "status"))
+    review_actionable = status == "pending"
+    review_payload = _safe_public_metadata(
+        _review_payload_with_default_contract(_value(suggestion, "review_payload", {}) or {}),
+        max_items=40,
+    )
+    review_kind = _suggestion_review_kind(review_payload)
+    target_fact_id = _value(suggestion, "target_fact_id", None)
+    expires_at = _value(suggestion, "expires_at", None)
+    reviewed_at = _value(suggestion, "reviewed_at", None)
+    return {
+        "id": str(_required_value(suggestion, "id")),
+        "space_id": str(_required_value(suggestion, "space_id")),
+        "memory_scope_id": str(_required_value(suggestion, "memory_scope_id")),
+        "candidate_text": _required_value(suggestion, "candidate_text"),
+        "kind": _enum_or_text(_required_value(suggestion, "kind")),
+        "operation": _enum_or_text(_required_value(suggestion, "operation")),
+        "status": status,
+        "source_refs": [
+            source_ref_to_response(ref) for ref in _value(suggestion, "source_refs", ())
+        ],
+        "confidence": _enum_or_text(_required_value(suggestion, "confidence")),
+        "trust_level": _enum_or_text(_required_value(suggestion, "trust_level")),
+        "safe_reason": _safe_public_reason(
+            str(_required_value(suggestion, "safe_reason")),
+            limit=320,
+        ),
+        "target_fact_id": str(target_fact_id) if target_fact_id else None,
+        "target_fact_version": _value(suggestion, "target_fact_version", None),
+        "category": _value(suggestion, "category", None),
+        "tags": list(_value(suggestion, "tags", ())),
+        "ttl_policy": _value(suggestion, "ttl_policy", None),
+        "expires_at": expires_at.isoformat() if expires_at else None,
+        "expiry_reason": _value(suggestion, "expiry_reason", None),
+        "created_from_capture_id": _value(suggestion, "created_from_capture_id", None),
+        "candidate_fingerprint": _value(suggestion, "candidate_fingerprint", None),
+        "review_payload": review_payload,
+        "review_kind": review_kind,
+        "review_actionable": review_actionable,
+        "available_review_actions": _available_review_actions(
+            review_actionable,
+            review_kind=review_kind,
+        ),
+        "review_state_reason": _suggestion_review_state_reason(status),
+        "review_resolution_options": _suggestion_review_resolution_options(review_payload),
+        "review_reason": _safe_optional_reason(
+            _value(suggestion, "review_reason", None),
+            limit=320,
+        ),
+        "review_audit": _suggestion_review_audit_to_response(suggestion),
+        "created_at": _required_value(suggestion, "created_at").isoformat(),
+        "updated_at": _required_value(suggestion, "updated_at").isoformat(),
+        "reviewed_at": reviewed_at.isoformat() if reviewed_at else None,
+    }
+
+
+def suggestion_result_to_response(result: object) -> dict[str, Any]:
+    body: dict[str, Any] = {
+        "suggestion": suggestion_to_response(_required_value(result, "suggestion"))
+    }
+    fact = _value(result, "fact", None)
+    if fact is not None:
+        body["fact"] = fact_to_response(fact, _value(result, "indexing_status", None))
+    return body
+
+
+def review_suggestions_batch_to_response(result: object) -> dict[str, Any]:
+    return {
+        "applied": _required_value(result, "applied"),
+        "failed": _required_value(result, "failed"),
+        "stopped": _required_value(result, "stopped"),
+        "results": [
+            {
+                "suggestion_id": _required_value(item, "suggestion_id"),
+                "action": _required_value(item, "action"),
+                "status": _required_value(item, "status"),
+                **_review_batch_item_payload(item),
+            }
+            for item in _required_value(result, "results")
+        ],
+    }
+
+
+def create_suggestions_batch_to_response(result: object) -> dict[str, Any]:
+    return {
+        "created": _required_value(result, "created"),
+        "existing": _required_value(result, "existing"),
+        "failed": _required_value(result, "failed"),
+        "stopped": _required_value(result, "stopped"),
+        "results": [
+            {
+                "index": _required_value(item, "index"),
+                "status": _required_value(item, "status"),
+                **_create_batch_item_payload(item),
+            }
+            for item in _required_value(result, "results")
+        ],
+    }
+
+
+def _review_batch_item_payload(item: object) -> dict[str, Any]:
+    result = _value(item, "result", None)
+    if result is None:
+        return {
+            "error_code": _value(item, "error_code", None),
+            "error_message": _value(item, "error_message", None),
+        }
+    return suggestion_result_to_response(result)
+
+
+def _create_batch_item_payload(item: object) -> dict[str, Any]:
+    result = _value(item, "result", None)
+    if result is None:
+        return {
+            "error_code": _value(item, "error_code", None),
+            "error_message": _value(item, "error_message", None),
+        }
+    return {"suggestion": suggestion_to_response(_required_value(result, "suggestion"))}
+
+
+def _suggestion_review_kind(review_payload: dict[str, Any]) -> str:
+    value = review_payload.get("review_kind")
+    return str(value).strip() if value else "candidate_review"
+
+
+def _available_review_actions(review_actionable: bool, *, review_kind: str) -> list[str]:
+    if not review_actionable:
+        return []
+    actions = ["approve", "reject", "expire"]
+    if review_kind == "conflict_review":
+        actions.append("resolve_conflict")
+    if review_kind == "duplicate_fact_merge":
+        actions.append("resolve_duplicate")
+    return actions
+
+
+def _suggestion_review_state_reason(status: str) -> str:
+    if status == "pending":
+        return "pending_review"
+    return f"{status}_review"
+
+
+def _suggestion_review_resolution_options(
+    review_payload: dict[str, Any],
+) -> list[dict[str, Any]]:
+    options = review_payload.get("resolution_options")
+    if not isinstance(options, list):
+        return []
+    safe_options: list[dict[str, Any]] = []
+    for option in options[:10]:
+        if isinstance(option, dict):
+            safe_option = _safe_public_metadata(option, max_items=20)
+            if safe_option:
+                safe_options.append(safe_option)
+    return safe_options
+
+
+def _suggestion_review_audit_to_response(suggestion: object) -> dict[str, Any]:
+    review_payload = _value(suggestion, "review_payload", {}) or {}
+    raw_events = review_payload.get("review_events") if isinstance(review_payload, dict) else None
+    events = (
+        [item for item in raw_events if isinstance(item, dict)]
+        if isinstance(raw_events, list)
+        else []
+    )
+    public_events = [
+        _suggestion_review_audit_event_to_response(item)
+        for item in events[-_MAX_PUBLIC_SUGGESTION_REVIEW_AUDIT_EVENTS:]
+    ]
+    return {
+        "events": public_events,
+        "event_count": len(events),
+        "truncated": len(events) > len(public_events),
+    }
+
+
+def _suggestion_review_audit_event_to_response(event: dict[str, Any]) -> dict[str, Any]:
+    public: dict[str, Any] = {}
+    for key, limit in _PUBLIC_SUGGESTION_REVIEW_AUDIT_FIELDS.items():
+        value = event.get(key)
+        if value is None:
+            continue
+        if isinstance(value, str | int | float | bool):
+            sanitizer = _safe_public_reason if key == "reason" else _safe_public_text
+            public[key] = sanitizer(str(value), limit=limit)
+    return public
+
+
+def _review_payload_with_default_contract(payload: dict[str, Any]) -> dict[str, Any]:
+    if payload.get("review_kind") == _DUPLICATE_FACT_MERGE_REVIEW_KIND:
+        return {**_duplicate_fact_merge_review_contract(), **payload}
+    return dict(payload)
+
+
+def _duplicate_fact_merge_review_contract() -> dict[str, Any]:
+    return {
+        "review_kind": _DUPLICATE_FACT_MERGE_REVIEW_KIND,
+        "recommended_action": "merge_source_refs_into_existing_fact",
+        "recommended_resolution_action": "merge_source_refs",
+        "default_resolution": "merge_or_keep_separate_after_review",
+        "duplicate_merge_policy_version": "duplicate-merge-review-v1",
+        "review_risk": "medium",
+        "recommendation_confidence": "medium",
+        "requires_review": True,
+        "auto_merge_eligible": False,
+        "recommendation_reason_codes": ["human_review_required", "legacy_payload"],
+        "resolution_options": [
+            {
+                "id": "merge_source_refs",
+                "review_action": "resolve_duplicate",
+                "effect": "merge_source_refs_into_existing_fact",
+                "availability": "available",
+                "resolution_action": "merge_source_refs",
+            },
+            {
+                "id": "keep_separate_fact",
+                "review_action": "resolve_duplicate",
+                "effect": "create_new_fact_keep_existing_fact",
+                "availability": "available",
+                "resolution_action": "keep_separate_fact",
+            },
+            {
+                "id": "reject_duplicate_candidate",
+                "review_action": "reject",
+                "effect": "keep_existing_fact_without_candidate_source_refs",
+                "availability": "available",
+                "resolution_action": "reject_candidate",
+            },
+            {
+                "id": "expire_duplicate_candidate",
+                "review_action": "expire",
+                "effect": "hide_pending_duplicate_merge_review",
+                "availability": "available",
+                "resolution_action": "expire_candidate",
+            },
+        ],
+    }
+
+
+def _safe_optional_reason(value: object, *, limit: int) -> str | None:
+    if value is None:
+        return None
+    return _safe_public_reason(str(value), limit=limit)
+
+
+def _safe_public_reason(value: str, *, limit: int = 500) -> str:
+    if _contains_sensitive_text(value):
+        return "[redacted]"
+    return _safe_public_text(value, limit=limit)
+
+
+def _safe_public_text(value: str, *, limit: int = 500) -> str:
+    return _redact_sensitive_text(value)[:limit]
+
+
+def _contains_sensitive_text(value: str | None) -> bool:
+    return bool(value) and _redact_sensitive_text(value) != value
+
+
+def _safe_public_metadata(
+    metadata: Any,
+    *,
+    max_items: int = _MAX_METADATA_DICT_ITEMS,
+) -> dict[str, Any]:
+    if isinstance(metadata, Mapping):
+        metadata = dict(metadata)
+    safe = _safe_metadata_value(metadata, depth=0, max_items=max_items)
+    return safe if isinstance(safe, dict) else {}
+
+
+def _safe_metadata_value(value: object, *, depth: int, max_items: int) -> object:
+    if isinstance(value, str):
+        return _safe_public_text(value)
+    if isinstance(value, int | float | bool) or value is None:
+        return value
+    if depth >= _MAX_METADATA_DEPTH:
+        return None
+    if isinstance(value, dict):
+        safe: dict[str, object] = {}
+        for raw_key, raw_value in list(value.items())[:max_items]:
+            key = _safe_public_text(str(raw_key), limit=120)
+            if not key or _looks_sensitive_metadata_key(key) or "[redacted]" in key:
+                continue
+            item = _safe_metadata_value(raw_value, depth=depth + 1, max_items=max_items)
+            if _is_safe_metadata_value(item):
+                safe[key] = item
+        return safe
+    if isinstance(value, list | tuple):
+        safe_items: list[object] = []
+        for raw_item in list(value)[:_MAX_METADATA_LIST_ITEMS]:
+            item = _safe_metadata_value(raw_item, depth=depth + 1, max_items=max_items)
+            if _is_safe_metadata_value(item):
+                safe_items.append(item)
+        return safe_items
+    return None
+
+
+def _is_safe_metadata_value(value: object) -> bool:
+    if isinstance(value, str | int | float | bool) or value is None:
+        return True
+    return isinstance(value, dict | list)
+
+
+def _looks_sensitive_metadata_key(key: str) -> bool:
+    lowered = key.lower()
+    return any(
+        marker in lowered
+        for marker in (
+            "api_key",
+            "apikey",
+            "auth",
+            "authorization",
+            "credential",
+            "password",
+            "passwd",
+            "private_key",
+            "secret",
+            "token",
+        )
+    )
+
+
+def _required_value(source: object, name: str) -> Any:
+    value = _value(source, name, None)
+    if value is None:
+        raise KeyError(name)
+    return value
+
+
+def _value(source: object, name: str, default: object) -> Any:
+    if isinstance(source, Mapping):
+        return source.get(name, default)
+    return getattr(source, name, default)
+
+
+def _enum_or_text(value: object) -> str:
+    raw = getattr(value, "value", value)
+    return str(raw)
+
+
+__all__ = (
+    "create_suggestions_batch_to_response",
+    "review_suggestions_batch_to_response",
+    "suggestion_result_to_response",
+    "suggestion_to_response",
+)

infinity_context_server/features/memory_scopes/__init__.py

@@ -0,0 +1,5 @@
+"""Server feature mirror for memory_scopes."""
+
+from infinity_context_server.features.memory_scopes import public
+
+__all__ = ("public",)

infinity_context_server/features/memory_scopes/compatibility.py

@@ -0,0 +1,231 @@
+"""Compatibility HTTP mapping for the legacy /v1/memory-scopes API."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from infinity_context_contracts.features.memory_scopes import (
+    CreateMemoryScopeRequestDto,
+)
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CreateMemoryScopeRequest(BaseModel):
+    """Legacy-compatible request body for creating a memory scope."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    space_id: str = Field(min_length=1, max_length=80)
+    external_ref: str = Field(min_length=1, max_length=200)
+    name: str = Field(min_length=1, max_length=240)
+
+
+class CreateSpaceRequest(BaseModel):
+    """Legacy-compatible request body for creating a memory space."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    slug: str = Field(min_length=1, max_length=160)
+    name: str = Field(min_length=1, max_length=240)
+
+
+class UpdateMemoryScopeRequest(BaseModel):
+    """Legacy-compatible request body for updating a memory scope."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    external_ref: str | None = Field(default=None, min_length=1, max_length=200)
+    name: str | None = Field(default=None, min_length=1, max_length=240)
+
+
+@dataclass(frozen=True, slots=True)
+class CreateMemoryScopeCompatibilityCommand:
+    """Core-agnostic command payload for legacy scope creation."""
+
+    space_id: str
+    external_ref: str
+    name: str
+
+
+@dataclass(frozen=True, slots=True)
+class UpdateMemoryScopeCompatibilityCommand:
+    """Core-agnostic command payload for legacy scope updates."""
+
+    memory_scope_id: str
+    external_ref: str | None = None
+    name: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class DeleteMemoryScopeCompatibilityCommand:
+    """Core-agnostic command payload for legacy scope deletion."""
+
+    memory_scope_id: str
+
+
+def create_memory_scope_contract_from_http_request(
+    request: object,
+) -> CreateMemoryScopeRequestDto:
+    """Map a legacy-compatible HTTP request into the public scope contract."""
+
+    return CreateMemoryScopeRequestDto(
+        space_id=_required_text(_value(request, "space_id", None), "space_id"),
+        external_ref=_required_text(
+            _value(request, "external_ref", None),
+            "external_ref",
+        ),
+        name=_required_text(_value(request, "name", None), "name"),
+    )
+
+
+def create_memory_scope_compatibility_command_from_request(
+    request: CreateMemoryScopeRequest | Mapping[str, object],
+) -> CreateMemoryScopeCompatibilityCommand:
+    """Map a legacy create request into a core-agnostic command payload."""
+
+    contract = create_memory_scope_contract_from_http_request(request)
+    return CreateMemoryScopeCompatibilityCommand(
+        space_id=_required_text(contract.space_id, "space_id"),
+        external_ref=_required_text(contract.external_ref, "external_ref"),
+        name=_required_text(contract.name, "name"),
+    )
+
+
+def update_memory_scope_compatibility_command_from_request(
+    memory_scope_id: str,
+    request: UpdateMemoryScopeRequest | Mapping[str, object],
+) -> UpdateMemoryScopeCompatibilityCommand:
+    """Map a legacy update request into a core-agnostic command payload."""
+
+    external_ref = _optional_text(_value(request, "external_ref", None))
+    name = _optional_text(_value(request, "name", None))
+    if external_ref is None and name is None:
+        raise ValueError("At least one memory_scope field is required")
+    return UpdateMemoryScopeCompatibilityCommand(
+        memory_scope_id=_required_text(memory_scope_id, "memory_scope_id"),
+        external_ref=external_ref,
+        name=name,
+    )
+
+
+def delete_memory_scope_compatibility_command_from_path(
+    memory_scope_id: str,
+) -> DeleteMemoryScopeCompatibilityCommand:
+    """Map a legacy delete path parameter into a core-agnostic command payload."""
+
+    return DeleteMemoryScopeCompatibilityCommand(
+        memory_scope_id=_required_text(memory_scope_id, "memory_scope_id"),
+    )
+
+
+def memory_scope_compatibility_response(memory_scope: object) -> dict[str, Any]:
+    """Return the legacy response envelope for one memory scope."""
+
+    return {"data": memory_scope_to_response(memory_scope)}
+
+
+def memory_scope_collection_compatibility_response(
+    memory_scopes: Iterable[object],
+) -> dict[str, Any]:
+    """Return the legacy response envelope for a memory scope collection."""
+
+    return {"data": [memory_scope_to_response(memory_scope) for memory_scope in memory_scopes]}
+
+
+def memory_scope_to_response(memory_scope: object) -> dict[str, Any]:
+    """Map a memory scope entity-like object to the legacy response body."""
+
+    return {
+        "id": str(_required_value(memory_scope, "id")),
+        "space_id": str(_required_value(memory_scope, "space_id")),
+        "external_ref": _value(memory_scope, "external_ref", None),
+        "name": _value(memory_scope, "name", None),
+        "status": _enum_or_text(_value(memory_scope, "status", "active")),
+        "created_at": _datetime_to_string(_required_value(memory_scope, "created_at")),
+        "updated_at": _datetime_to_string(_required_value(memory_scope, "updated_at")),
+    }
+
+
+def space_to_response(space: object) -> dict[str, Any]:
+    """Map a memory space entity-like object to the legacy response body."""
+
+    return {
+        "id": str(_required_value(space, "id")),
+        "slug": str(_required_value(space, "slug")),
+        "name": str(_required_value(space, "name")),
+        "status": _enum_or_text(_value(space, "status", "active")),
+        "created_at": _datetime_to_string(_required_value(space, "created_at")),
+        "updated_at": _datetime_to_string(_required_value(space, "updated_at")),
+    }
+
+
+def thread_to_response(thread: object) -> dict[str, Any]:
+    """Map a memory thread entity-like object to the legacy browser response body."""
+
+    return {
+        "id": str(_required_value(thread, "id")),
+        "space_id": str(_required_value(thread, "space_id")),
+        "memory_scope_id": str(_required_value(thread, "memory_scope_id")),
+        "external_ref": _value(thread, "external_ref", None),
+        "status": _enum_or_text(_required_value(thread, "status")),
+        "created_at": _datetime_to_string(_required_value(thread, "created_at")),
+        "updated_at": _datetime_to_string(_required_value(thread, "updated_at")),
+    }
+
+
+def _required_value(source: object, name: str) -> object:
+    value = _value(source, name, None)
+    if value is None:
+        raise ValueError(f"{name} is required")
+    return value
+
+
+def _value(source: object, name: str, default: object) -> Any:
+    if isinstance(source, Mapping):
+        return source.get(name, default)
+    return getattr(source, name, default)
+
+
+def _required_text(value: object, field_name: str) -> str:
+    text = str(value) if value is not None else ""
+    if not text:
+        raise ValueError(f"{field_name} is required")
+    return text
+
+
+def _optional_text(value: object) -> str | None:
+    text = str(value) if value is not None else ""
+    return text or None
+
+
+def _datetime_to_string(value: datetime | None) -> str | None:
+    if value is None:
+        return None
+    return value.isoformat()
+
+
+def _enum_or_text(value: object) -> str:
+    raw = getattr(value, "value", value)
+    return str(raw)
+
+
+__all__ = (
+    "CreateMemoryScopeCompatibilityCommand",
+    "CreateMemoryScopeRequest",
+    "CreateSpaceRequest",
+    "DeleteMemoryScopeCompatibilityCommand",
+    "UpdateMemoryScopeCompatibilityCommand",
+    "UpdateMemoryScopeRequest",
+    "create_memory_scope_compatibility_command_from_request",
+    "create_memory_scope_contract_from_http_request",
+    "delete_memory_scope_compatibility_command_from_path",
+    "memory_scope_collection_compatibility_response",
+    "memory_scope_compatibility_response",
+    "memory_scope_to_response",
+    "space_to_response",
+    "thread_to_response",
+    "update_memory_scope_compatibility_command_from_request",
+)

infinity_context_server/features/memory_scopes/composition.py

@@ -0,0 +1,49 @@
+"""Composition helpers for the memory_scopes server feature."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import infinity_context_core.features.memory_scopes.public as memory_scopes
+from fastapi import APIRouter
+
+from infinity_context_server.features.memory_scopes.routes import (
+    create_memory_scopes_router,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class MemoryScopesServerFeature:
+    """Server-side assembly for memory_scopes routes and use cases."""
+
+    use_cases: memory_scopes.MemoryScopeUseCases
+    route_prefix: str = ""
+
+    @property
+    def feature_id(self) -> str:
+        return memory_scopes.FEATURE_ID
+
+    def create_router(self) -> APIRouter:
+        return create_memory_scopes_router(
+            self.use_cases,
+            prefix=self.route_prefix,
+        )
+
+
+def build_memory_scopes_server_feature(
+    use_cases: memory_scopes.MemoryScopeUseCases,
+    *,
+    route_prefix: str = "",
+) -> MemoryScopesServerFeature:
+    """Create the server seam without constructing feature business logic."""
+
+    return MemoryScopesServerFeature(
+        use_cases=use_cases,
+        route_prefix=route_prefix,
+    )
+
+
+__all__ = (
+    "MemoryScopesServerFeature",
+    "build_memory_scopes_server_feature",
+)