memuron 0.1.1__py3-none-any.whl

memuron/graphfs/read_model.py

@@ -0,0 +1,574 @@
+"""Indexed reads over the Memuron filesystem projection."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from artha_engine.store.projection_sql import sql_store_fetchall, sql_store_has_tables
+
+MAX_READ_ROWS = 1000
+
+
+def _parse(value: Any, default: Any) -> Any:
+    if value is None:
+        return default
+    if isinstance(value, (dict, list)):
+        return value
+    try:
+        return json.loads(str(value))
+    except json.JSONDecodeError:
+        return default
+
+
+def _node(row: dict[str, Any]) -> dict[str, Any]:
+    placement = None
+    if row.get("placement_id"):
+        placement = {
+            "id": str(row["placement_id"]),
+            "parent_id": str(row["parent_id"]),
+            "child_id": str(row["node_id"]),
+            "name": str(row["placement_name"]),
+            "metadata": _parse(row.get("placement_metadata_json"), {}),
+            "inherit_parent_scope": bool(row.get("inherit_parent_scope", True)),
+        }
+    content = str(row.get("content") or "")
+    node_type = str(row.get("node_type") or "text")
+    display = str(row.get("placement_name") or row.get("display") or "")
+    preview = " ".join(content.split())
+    return {
+        "kind": "node",
+        "id": str(row["node_id"]),
+        "type": node_type,
+        "node_type": node_type,
+        "display": display,
+        "preview": preview[:240] + ("..." if len(preview) > 240 else ""),
+        "content": content,
+        "content_length": len(content),
+        "truncated": len(preview) > len(display),
+        "encoding": str(row.get("encoding") or "memory"),
+        "scope": _parse(row.get("scope_json"), []),
+        "payload": _parse(row.get("payload_json"), {}),
+        "metadata": _parse(row.get("metadata_json"), {}),
+        "degree": int(row.get("degree") or 0),
+        "placement": placement,
+    }
+
+
+def _degree_sql(alias: str = "n") -> str:
+    return f"""
+      (
+        SELECT COUNT(*) FROM memuron_fs_edges es
+        WHERE es.org_token = {alias}.org_token
+          AND es.space_token = {alias}.space_token
+          AND es.source_id = {alias}.node_id
+          AND es.target_id != {alias}.node_id
+      ) + (
+        SELECT COUNT(*) FROM memuron_fs_edges et
+        WHERE et.org_token = {alias}.org_token
+          AND et.space_token = {alias}.space_token
+          AND et.target_id = {alias}.node_id
+          AND et.source_id != {alias}.node_id
+      )
+    """
+
+
+def list_entries(
+    store: object,
+    *,
+    org_token: str,
+    space_token: str,
+    collection_id: str | None = None,
+    node_type: str | None = None,
+    encoding: str | None = None,
+    node_id: str | None = None,
+    name: str | None = None,
+    floating: bool = False,
+    collections_only: bool = False,
+    limit: int = MAX_READ_ROWS,
+) -> list[dict[str, Any]]:
+    if not sql_store_has_tables(store):
+        return _memory_list_entries(
+            store,
+            org_token=org_token,
+            space_token=space_token,
+            collection_id=collection_id,
+            node_type=node_type,
+            encoding=encoding,
+            node_id=node_id,
+            name=name,
+            floating=floating,
+            collections_only=collections_only,
+            limit=limit,
+        )
+    params: list[Any] = [org_token, space_token]
+    filters = ["n.org_token = ?", "n.space_token = ?"]
+    if node_type:
+        filters.append("n.node_type = ?")
+        params.append(node_type)
+    if encoding:
+        filters.append("n.encoding = ?")
+        params.append(encoding)
+    if node_id:
+        filters.append("n.node_id = ?")
+        params.append(node_id)
+    if name:
+        filters.append("lower(n.display) LIKE lower(?)")
+        params.append(f"%{name.replace('*', '')}%")
+    if collections_only:
+        filters.append("n.node_type = 'collection'")
+    if floating:
+        filters.extend(
+            [
+                "n.node_type != 'collection'",
+                """
+                NOT EXISTS (
+                  SELECT 1 FROM memuron_fs_entries fp
+                  WHERE fp.org_token = n.org_token
+                    AND fp.space_token = n.space_token
+                    AND fp.child_id = n.node_id
+                )
+                """,
+            ]
+        )
+
+    if collection_id:
+        filters.append("p.parent_id = ?")
+        params.append(collection_id)
+        rows = sql_store_fetchall(
+            store,
+            f"""
+            SELECT n.*, p.placement_id, p.parent_id, p.name AS placement_name,
+                   p.metadata_json AS placement_metadata_json,
+                   p.inherit_parent_scope,
+                   {_degree_sql()} AS degree
+            FROM memuron_fs_entries p
+            JOIN memuron_fs_nodes n ON n.node_id = p.child_id
+            WHERE {' AND '.join(filters)}
+            ORDER BY p.sequence DESC
+            LIMIT ?
+            """,
+            (*params, limit),
+        )
+    else:
+        rows = sql_store_fetchall(
+            store,
+            f"""
+            SELECT n.*, NULL AS placement_id, NULL AS parent_id,
+                   NULL AS placement_name, NULL AS placement_metadata_json,
+                   NULL AS inherit_parent_scope,
+                   {_degree_sql()} AS degree
+            FROM memuron_fs_nodes n
+            WHERE {' AND '.join(filters)}
+            ORDER BY n.sequence DESC
+            LIMIT ?
+            """,
+            (*params, limit),
+        )
+    return [_node(row) for row in rows]
+
+
+def list_root(
+    store: object,
+    *,
+    org_token: str,
+    space_token: str,
+    collections_only: bool = False,
+    floating_only: bool = False,
+    limit: int = MAX_READ_ROWS,
+) -> list[dict[str, Any]]:
+    if collections_only:
+        return list_entries(
+            store,
+            org_token=org_token,
+            space_token=space_token,
+            collections_only=True,
+            limit=limit,
+        )
+    if floating_only:
+        return list_entries(
+            store,
+            org_token=org_token,
+            space_token=space_token,
+            floating=True,
+            limit=limit,
+        )
+    collections = list_entries(
+        store,
+        org_token=org_token,
+        space_token=space_token,
+        collections_only=True,
+        limit=limit,
+    )
+    floating = list_entries(
+        store,
+        org_token=org_token,
+        space_token=space_token,
+        floating=True,
+        limit=max(0, limit - len(collections)),
+    )
+    return [*collections, *floating]
+
+
+def get_nodes(
+    store: object,
+    node_ids: list[str],
+    *,
+    org_token: str | None = None,
+    space_token: str | None = None,
+) -> list[dict[str, Any]]:
+    unique = list(dict.fromkeys(node_ids))
+    if not unique:
+        return []
+    if not sql_store_has_tables(store):
+        rows = getattr(store, "memuron_fs_nodes", {})
+        output = []
+        for node_id in unique:
+            row = rows.get(node_id)
+            if not row:
+                continue
+            if org_token is not None and row.get("org_token") != org_token:
+                continue
+            if space_token is not None and row.get("space_token") != space_token:
+                continue
+            output.append(_memory_node(row, store))
+        return output
+    placeholders = ", ".join("?" for _ in unique)
+    filters = [f"n.node_id IN ({placeholders})"]
+    params: list[Any] = list(unique)
+    if org_token is not None:
+        filters.append("n.org_token = ?")
+        params.append(org_token)
+    if space_token is not None:
+        filters.append("n.space_token = ?")
+        params.append(space_token)
+    rows = sql_store_fetchall(
+        store,
+        f"""
+        SELECT n.*, NULL AS placement_id, NULL AS parent_id,
+               NULL AS placement_name, NULL AS placement_metadata_json,
+               NULL AS inherit_parent_scope,
+               {_degree_sql()} AS degree
+        FROM memuron_fs_nodes n
+        WHERE {' AND '.join(filters)}
+        """,
+        tuple(params),
+    )
+    by_id = {str(row["node_id"]): _node(row) for row in rows}
+    return [by_id[node_id] for node_id in unique if node_id in by_id]
+
+
+def grep_entries(
+    store: object,
+    query: str,
+    *,
+    org_token: str,
+    space_token: str,
+    allowed_ids: set[str] | None = None,
+    limit: int = 100,
+    literal: bool = False,
+    case_sensitive: bool = False,
+    invert: bool = False,
+) -> list[dict[str, Any]]:
+    if not query.strip():
+        return []
+    if allowed_ids is not None and not allowed_ids:
+        return []
+
+    candidates = list_entries(
+        store,
+        org_token=org_token,
+        space_token=space_token,
+        limit=MAX_READ_ROWS,
+    )
+    if literal:
+        needle = query if case_sensitive else query.casefold()
+
+        def matches(content: str) -> bool:
+            haystack = content if case_sensitive else content.casefold()
+            return needle in haystack
+
+    else:
+        pattern = re.compile(query, 0 if case_sensitive else re.IGNORECASE)
+
+        def matches(content: str) -> bool:
+            return pattern.search(content) is not None
+
+    output = []
+    for item in candidates:
+        if allowed_ids is not None and item["id"] not in allowed_ids:
+            continue
+        if matches(item["content"]) == invert:
+            continue
+        item["score"] = 1.0
+        output.append(item)
+        if len(output) >= limit:
+            break
+    return output
+
+
+def expand_neighbors(
+    store: object,
+    seed_ids: set[str],
+    *,
+    org_token: str,
+    space_token: str,
+    depth: int,
+    direction: str,
+    include_placements: bool,
+    include_self: bool,
+) -> list[dict[str, Any]]:
+    visited = set(seed_ids)
+    frontier = set(seed_ids)
+    for _hop in range(depth):
+        if not frontier:
+            break
+        edge_rows = _edges_for_frontier(
+            store,
+            frontier,
+            org_token=org_token,
+            space_token=space_token,
+            direction=direction,
+            include_placements=include_placements,
+        )
+        next_ids: set[str] = set()
+        for edge in edge_rows:
+            source = str(edge["source_id"])
+            target = str(edge["target_id"])
+            if source == target:
+                continue
+            if direction in {"both", "outbound"} and source in frontier:
+                next_ids.add(target)
+            if direction in {"both", "inbound"} and target in frontier:
+                next_ids.add(source)
+        next_ids -= visited
+        visited |= next_ids
+        frontier = next_ids
+    if not include_self:
+        visited -= seed_ids
+    return get_nodes(
+        store,
+        sorted(visited),
+        org_token=org_token,
+        space_token=space_token,
+    )
+
+
+def node_edges(
+    store: object,
+    node_ids: set[str],
+    *,
+    org_token: str,
+    space_token: str,
+) -> list[dict[str, Any]]:
+    return _edges_for_frontier(
+        store,
+        node_ids,
+        org_token=org_token,
+        space_token=space_token,
+        direction="both",
+        include_placements=True,
+    )
+
+
+def space_edges(
+    store: object,
+    *,
+    org_token: str,
+    space_token: str,
+    include_placements: bool = True,
+) -> list[dict[str, Any]]:
+    if not sql_store_has_tables(store):
+        return [
+            dict(row)
+            for row in getattr(store, "memuron_fs_edges", {}).values()
+            if row["org_token"] == org_token
+            and row["space_token"] == space_token
+            and (include_placements or row["edge_type"] == "semantic_link")
+        ]
+    edge_filter = "" if include_placements else " AND edge_type = 'semantic_link'"
+    return sql_store_fetchall(
+        store,
+        f"""
+        SELECT edge_id, source_id, target_id, edge_type, description
+        FROM memuron_fs_edges
+        WHERE org_token = ? AND space_token = ?{edge_filter}
+        ORDER BY sequence DESC
+        """,
+        (org_token, space_token),
+    )
+
+
+def containing_collection(
+    store: object,
+    node_id: str,
+    *,
+    org_token: str,
+    space_token: str,
+) -> str | None:
+    if not sql_store_has_tables(store):
+        matches = [
+            row
+            for row in getattr(store, "memuron_fs_entries", {}).values()
+            if row["child_id"] == node_id
+            and row["org_token"] == org_token
+            and row["space_token"] == space_token
+        ]
+        matches.sort(key=lambda row: -int(row["sequence"]))
+        return str(matches[0]["parent_id"]) if matches else None
+    rows = sql_store_fetchall(
+        store,
+        """
+        SELECT parent_id FROM memuron_fs_entries
+        WHERE child_id = ? AND org_token = ? AND space_token = ?
+        ORDER BY sequence DESC
+        LIMIT 1
+        """,
+        (node_id, org_token, space_token),
+    )
+    return str(rows[0]["parent_id"]) if rows else None
+
+
+def _edges_for_frontier(
+    store: object,
+    frontier: set[str],
+    *,
+    org_token: str,
+    space_token: str,
+    direction: str,
+    include_placements: bool,
+) -> list[dict[str, Any]]:
+    if not frontier:
+        return []
+    if not sql_store_has_tables(store):
+        output = []
+        for row in getattr(store, "memuron_fs_edges", {}).values():
+            if row["org_token"] != org_token or row["space_token"] != space_token:
+                continue
+            if not include_placements and row["edge_type"] != "semantic_link":
+                continue
+            source_match = direction in {"both", "outbound"} and row["source_id"] in frontier
+            target_match = direction in {"both", "inbound"} and row["target_id"] in frontier
+            if source_match or target_match:
+                output.append(dict(row))
+        return output
+    placeholders = ", ".join("?" for _ in frontier)
+    directions: list[str] = []
+    params: list[Any] = [org_token, space_token]
+    sorted_ids = sorted(frontier)
+    if direction in {"both", "outbound"}:
+        directions.append(f"source_id IN ({placeholders})")
+        params.extend(sorted_ids)
+    if direction in {"both", "inbound"}:
+        directions.append(f"target_id IN ({placeholders})")
+        params.extend(sorted_ids)
+    edge_filter = "" if include_placements else " AND edge_type = 'semantic_link'"
+    return sql_store_fetchall(
+        store,
+        f"""
+        SELECT edge_id, source_id, target_id, edge_type, description
+        FROM memuron_fs_edges
+        WHERE org_token = ? AND space_token = ?
+          AND ({' OR '.join(directions)}){edge_filter}
+        """,
+        tuple(params),
+    )
+
+
+def _memory_degree(store: object, node_id: str, org_token: str, space_token: str) -> int:
+    return sum(
+        1
+        for row in getattr(store, "memuron_fs_edges", {}).values()
+        if row["org_token"] == org_token
+        and row["space_token"] == space_token
+        and node_id in {row["source_id"], row["target_id"]}
+        and row["source_id"] != row["target_id"]
+    )
+
+
+def _memory_node(
+    row: dict[str, Any],
+    store: object,
+    placement: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    return _node(
+        {
+            "node_id": row["node_id"],
+            "node_type": row["node_type"],
+            "display": row["display"],
+            "content": row["content"],
+            "encoding": row["encoding"],
+            "payload_json": row.get("payload", {}),
+            "metadata_json": row.get("metadata", {}),
+            "scope_json": row.get("scope", []),
+            "degree": _memory_degree(
+                store,
+                str(row["node_id"]),
+                str(row["org_token"]),
+                str(row["space_token"]),
+            ),
+            "placement_id": placement.get("placement_id") if placement else None,
+            "parent_id": placement.get("parent_id") if placement else None,
+            "placement_name": placement.get("name") if placement else None,
+            "placement_metadata_json": placement.get("metadata") if placement else None,
+            "inherit_parent_scope": placement.get("inherit_parent_scope") if placement else None,
+        }
+    )
+
+
+def _memory_list_entries(
+    store: object,
+    *,
+    org_token: str,
+    space_token: str,
+    collection_id: str | None,
+    node_type: str | None,
+    encoding: str | None,
+    node_id: str | None,
+    name: str | None,
+    floating: bool,
+    collections_only: bool,
+    limit: int,
+) -> list[dict[str, Any]]:
+    nodes = getattr(store, "memuron_fs_nodes", {})
+    placements = getattr(store, "memuron_fs_entries", {})
+    placed_ids = {
+        row["child_id"]
+        for row in placements.values()
+        if row["org_token"] == org_token and row["space_token"] == space_token
+    }
+    output: list[dict[str, Any]] = []
+    if collection_id:
+        rows = sorted(
+            (
+                row
+                for row in placements.values()
+                if row["parent_id"] == collection_id
+                and row["org_token"] == org_token
+                and row["space_token"] == space_token
+            ),
+            key=lambda row: -int(row["sequence"]),
+        )
+        candidates = [(nodes.get(row["child_id"]), row) for row in rows]
+    else:
+        candidates = [(row, None) for row in nodes.values()]
+    for row, placement in candidates:
+        if not row or row["org_token"] != org_token or row["space_token"] != space_token:
+            continue
+        if node_type and row["node_type"] != node_type:
+            continue
+        if encoding and row["encoding"] != encoding:
+            continue
+        if node_id and row["node_id"] != node_id:
+            continue
+        if collections_only and row["node_type"] != "collection":
+            continue
+        if floating and (row["node_type"] == "collection" or row["node_id"] in placed_ids):
+            continue
+        if name and name.replace("*", "").lower() not in row["display"].lower():
+            continue
+        output.append(_memory_node(row, store, placement))
+        if len(output) >= limit:
+            break
+    return output

memuron/ingest/__init__.py

@@ -0,0 +1 @@
+"""Guardian ingest planning, prompts, and asynchronous job workers."""