memuron 0.1.1__py3-none-any.whl

memuron/spaces/service.py

@@ -0,0 +1,155 @@
+"""Space resolution helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import HTTPException
+from artha_engine.runtime.auth import AuthContext
+
+from memuron.persistence.identity_store import IdentityStore
+
+
+def resolve_space_reference(
+    identity: IdentityStore,
+    *,
+    org_id: str,
+    space_ref: str,
+) -> dict[str, Any] | None:
+    """Resolve a space UUID, slug, token, or filesystem path."""
+
+    value = space_ref.strip().rstrip("/")
+    if value.startswith("/spaces/"):
+        value = value.removeprefix("/spaces/")
+    spaces = identity.ensure_default_spaces(org_id)
+    for space in spaces:
+        if value in {
+            str(space["id"]),
+            str(space["slug"]),
+            str(space["token"]),
+        }:
+            return space
+    return None
+
+
+def resolve_ingest_hint_space(
+    identity: IdentityStore,
+    *,
+    user_id: str,
+    org_id: str,
+    space_id: str | None,
+) -> dict[str, Any]:
+    enabled = identity.get_enabled_org_spaces(user_id, org_id)
+    if not enabled:
+        raise HTTPException(
+            status_code=400,
+            detail="Enable at least one space before ingesting memories",
+        )
+    enabled_by_id = {space["id"]: space for space in enabled}
+    if space_id:
+        space = resolve_space_reference(
+            identity,
+            org_id=org_id,
+            space_ref=space_id,
+        )
+        if space is None:
+            raise HTTPException(status_code=404, detail="Space not found")
+        if space["id"] not in enabled_by_id:
+            raise HTTPException(status_code=400, detail="That space is disabled — enable it first")
+        return enabled_by_id[space["id"]]
+    for space in enabled:
+        if space.get("is_default"):
+            return space
+    return enabled[0]
+
+
+def _default_hint_space(enabled: list[dict[str, Any]]) -> dict[str, Any]:
+    for space in enabled:
+        if space.get("is_default"):
+            return space
+    return enabled[0]
+
+
+def guardian_space_context(
+    identity: IdentityStore,
+    *,
+    user_id: str,
+    org_id: str,
+    hint_space: dict[str, Any] | None = None,
+    space_mode: str = "assist",
+) -> dict[str, str]:
+    enabled = identity.get_enabled_org_spaces(user_id, org_id)
+    if not enabled:
+        raise HTTPException(
+            status_code=400,
+            detail="Enable at least one space before ingesting memories",
+        )
+    enabled_ids = {space["id"] for space in enabled}
+    if hint_space is None:
+        hint_space = _default_hint_space(enabled)
+    elif hint_space["id"] not in enabled_ids:
+        hint_space = _default_hint_space(enabled)
+
+    detail_lines: list[str] = []
+    registered_tokens: list[str] = []
+    for space in enabled:
+        registered_tokens.append(space["token"])
+        summary = space["description"] or space["name"]
+        prompt = space["guardian_prompt"] or summary
+        detail_lines.append(f"- {space['name']} ({space['token']}): {prompt}")
+
+    other_lines = [
+        f"- {space['name']} ({space['token']}): {space['description'] or space['name']}"
+        for space in enabled
+        if space["id"] != hint_space["id"]
+    ]
+    return {
+        "active_space_name": hint_space["name"],
+        "active_space_token": hint_space["token"],
+        "active_space_prompt": hint_space["guardian_prompt"],
+        "other_spaces_summary": "\n".join(other_lines) if other_lines else "(none)",
+        "all_spaces_detail": "\n".join(detail_lines) if detail_lines else "(none)",
+        "registered_tokens": ", ".join(registered_tokens),
+        "space_mode": space_mode,
+    }
+
+
+def apply_guardian_space_scope(
+    scope: list[str],
+    *,
+    space_context: dict[str, str],
+) -> list[str]:
+    registered = [
+        token.strip()
+        for token in space_context.get("registered_tokens", "").split(",")
+        if token.strip()
+    ]
+    registered_set = set(registered)
+    active = space_context.get("active_space_token")
+    mode = space_context.get("space_mode", "assist")
+
+    space_tokens = [token for token in scope if token in registered_set]
+    other_tokens = [token for token in scope if token not in registered_set]
+
+    if mode == "strict" and active:
+        if active not in space_tokens:
+            space_tokens.insert(0, active)
+    elif not space_tokens and active:
+        space_tokens = [active]
+
+    if not space_tokens and registered:
+        raise ValueError("Guardian must assign at least one enabled space token")
+
+    if len(space_tokens) > 1:
+        if mode == "strict" and active and active in space_tokens:
+            space_tokens = [active]
+        else:
+            space_tokens = [space_tokens[0]]
+
+    merged: list[str] = []
+    seen: set[str] = set()
+    for token in [*space_tokens, *other_tokens]:
+        if token not in seen:
+            seen.add(token)
+            merged.append(token)
+    return merged

memuron/sync/__init__.py

@@ -0,0 +1,25 @@
+"""Folder sync helpers."""
+
+from memuron.sync.folder import (
+    DEFAULT_MANIFEST_RELATIVE_PATH,
+    SyncManifest,
+    SyncPlan,
+    init_manifest,
+    load_manifest,
+    manifest_path_for_root,
+    plan_folder_sync,
+    run_folder_sync,
+    scan_folder,
+)
+
+__all__ = [
+    "DEFAULT_MANIFEST_RELATIVE_PATH",
+    "SyncManifest",
+    "SyncPlan",
+    "init_manifest",
+    "load_manifest",
+    "manifest_path_for_root",
+    "plan_folder_sync",
+    "run_folder_sync",
+    "scan_folder",
+]