topos-node 1.3.27__tar.gz → 1.3.29__tar.gz

{topos_node-1.3.27/topos_node.egg-info → topos_node-1.3.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.27
+Version: 1.3.29
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.27 → topos_node-1.3.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.27"
+version = "1.3.29"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.27 → topos_node-1.3.29}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.27"
-__version_info__ = (1, 3, 27)
+__version__ = "1.3.29"
+__version_info__ = (1, 3, 29)
 
 __all__ = ["__version__", "__version_info__"]

topos_node-1.3.29/topos/api/community_naming_config.py

@@ -0,0 +1,52 @@
+"""Read/update the owner-selected community-naming model (engine_config).
+
+PLAN_COMMUNITY_NAMING S4: surfaced under Settings → Node functions. Default is
+the local extraction model — naming stays on-device unless the owner points it
+elsewhere. Empty PUT clears the override.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection, set_engine_config_value
+from ..features.entities.community_naming import (
+    ENGINE_CONFIG_KEY_NAMING_MODEL,
+    resolve_naming_model,
+)
+
+logger = logging.getLogger("topos.api.community_naming_config")
+
+router = APIRouter(tags=["community-naming"])
+
+
+def _payload(conn) -> dict[str, Any]:
+    from ..core.state import get_engine_config_value
+
+    override = get_engine_config_value(conn, ENGINE_CONFIG_KEY_NAMING_MODEL)
+    return {
+        "model": resolve_naming_model(conn),
+        "override": str(override).strip() if override else None,
+    }
+
+
+@router.get("/v1/community-naming-config", dependencies=[Depends(require_api_key)])
+async def get_community_naming_config() -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    return {"status": "ok", **_payload(conn)}
+
+
+@router.put("/v1/community-naming-config", dependencies=[Depends(require_api_key)])
+async def put_community_naming_config(body: dict[str, Any] = Body(default=None)) -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    model = str((body or {}).get("model") or "").strip()
+    set_engine_config_value(conn, ENGINE_CONFIG_KEY_NAMING_MODEL, model or None)
+    return {"status": "ok", **_payload(conn)}

{topos_node-1.3.27 → topos_node-1.3.29}/topos/api/signal.py

@@ -1085,3 +1085,74 @@ async def post_fact_conflict_resolution(
     if not ok:
         raise HTTPException(status_code=404, detail=f"unknown conflict {conflict_id}")
     return {"conflict_id": conflict_id, "status": status}
+
+
+@router.post("/derivation/offers/resolve")
+async def post_pack_offer_resolution(
+    offer_id: str = Body(...),
+    action: str = Body(..., description="accept | dismiss"),
+    _api_key: str = Depends(require_api_key),
+):
+    """Self-gating offers: the node offered, the owner decides (W-B)."""
+    from ..features.derivation.surfaces import resolve_pack_offer
+
+    try:
+        out = resolve_pack_offer(_entities_conn(), offer_id, action)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if not out:
+        raise HTTPException(status_code=404, detail=f"unknown offer {offer_id}")
+    return out
+
+
+@router.post("/derivation/packs/{pack_id}/backfill")
+async def post_pack_backfill(
+    pack_id: str,
+    limit: int = Body(200, embed=True, ge=1, le=1000),
+    _api_key: str = Depends(require_api_key),
+):
+    """Bounded owner-initiated history backfill (lens catalog control)."""
+    import asyncio as _asyncio
+
+    from ..features.derivation.surfaces import run_pack_backfill
+
+    try:
+        stats = await _asyncio.to_thread(run_pack_backfill, _entities_conn(), pack_id, limit)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"pack_id": pack_id, **stats}
+
+
+@router.put("/entities/communities/{community_id}/name")
+async def put_community_name_route(
+    community_id: int,
+    name: str = Body(..., embed=True),
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner rename for a graph community (stable-naming S3)."""
+    from ..features.entities.community_names import core_fingerprint, rename_community
+    from ..features.entities.community_naming import valid_label
+
+    if not valid_label(name):
+        raise HTTPException(status_code=400, detail="a short name (2-4 words, letters) required")
+    conn = _entities_conn()
+    rows = conn.execute(
+        "SELECT entity_id, json_extract(metadata_json,'$.centrality.eigen')"
+        " FROM entities WHERE json_extract(metadata_json,'$.community_id')=?",
+        (community_id,),
+    ).fetchall()
+    if not rows:
+        raise HTTPException(status_code=404, detail=f"unknown community {community_id}")
+    ranked = [x[0] for x in sorted(rows, key=lambda x: -(x[1] or 0.0))]
+    weights = {x[0]: float(x[1] or 0.0) for x in rows}
+    from ..storage.db.write_gate import commit_connection, with_db_write
+    with with_db_write():
+        rename_community(conn, core_fingerprint(ranked, weights), name)
+        conn.execute(
+            "UPDATE entities SET metadata_json=json_patch(COALESCE(metadata_json,'{}'),"
+            " json_object('community_label', ?))"
+            " WHERE json_extract(metadata_json,'$.community_id')=?",
+            (name, community_id),
+        )
+        commit_connection(conn)
+    return {"community_id": community_id, "name": name, "members": len(rows)}

{topos_node-1.3.27 → topos_node-1.3.29}/topos/app.py

@@ -42,6 +42,7 @@ from .api import (
     data_explorer_table_prefs as data_explorer_table_prefs_routes,
     sanitization_ollama_config as sanitization_ollama_config_routes,
     facts_llm_config as facts_llm_config_routes,
+    community_naming_config as community_naming_config_routes,
     signal_extraction_config as signal_extraction_config_routes,
     filter_lab as filter_lab_routes,
     enrichment_lab as enrichment_lab_routes,
@@ -144,6 +145,7 @@ app.include_router(data_explorer_table_prefs_routes.router)
 app.include_router(user_identity_routes.router)
 app.include_router(sanitization_ollama_config_routes.router)
 app.include_router(facts_llm_config_routes.router)
+app.include_router(community_naming_config_routes.router)
 app.include_router(signal_extraction_config_routes.router)
 app.include_router(filter_lab_routes.router)
 app.include_router(enrichment_lab_routes.router)

{topos_node-1.3.27 → topos_node-1.3.29}/topos/core/handlers/derivation.py

@@ -77,3 +77,45 @@ async def handle_put_fact_conflict(message: Dict[str, Any]) -> Optional[Dict[str
         return {"id": req_id, "status": "error", "error": str(exc)}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_pack_offer")
+async def handle_put_pack_offer(message):
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    try:
+        from ...features.derivation.surfaces import resolve_pack_offer
+        out = resolve_pack_offer(conn, str(payload.get("offer_id") or ""),
+                                 str(payload.get("action") or ""))
+        if not out:
+            return {"id": req_id, "status": "error", "error": "unknown offer"}
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **out}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("run_pack_backfill")
+async def handle_run_pack_backfill(message):
+    """Owner-initiated bounded history backfill for one enabled pack (W-B #4).
+    Runs in a worker thread; bounded by `limit` hit-records per call."""
+    import asyncio as _asyncio
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    pack_id = str(payload.get("pack_id") or "").strip()
+    limit = min(int(payload.get("limit") or 200), 1000)
+    try:
+        from ...features.derivation.surfaces import run_pack_backfill
+        stats = await _asyncio.to_thread(run_pack_backfill, conn, pack_id, limit)
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", "pack_id": pack_id, **stats}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.27 → topos_node-1.3.29}/topos/core/handlers/signal_features.py

@@ -1192,3 +1192,49 @@ async def handle_signal_retire_intent(message: Dict[str, Any]) -> Optional[Dict[
         return {"id": req_id, "status": "ok", "payload": {"intents": active_intents(conn)}}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_community_name")
+async def handle_put_community_name(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Owner rename for a graph community (PLAN_COMMUNITY_NAMING S3): retires
+    any derived name for the community's core and records the owner's, which
+    wins ties forever after. Stamps the label onto members immediately."""
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    community_id = payload.get("community_id")
+    new_name = str(payload.get("name") or "").strip()
+    try:
+        from ...features.entities.community_names import core_fingerprint, rename_community
+        from ...features.entities.community_naming import valid_label
+
+        if not isinstance(community_id, int) or not valid_label(new_name):
+            return {"id": req_id, "status": "error",
+                    "error": "community_id (int) and a short name (2-4 words, letters) required"}
+        conn = hub.get_db_connection()
+        rows = conn.execute(
+            "SELECT entity_id, json_extract(metadata_json,'$.centrality.eigen')"
+            " FROM entities WHERE json_extract(metadata_json,'$.community_id')=?",
+            (community_id,),
+        ).fetchall()
+        if not rows:
+            return {"id": req_id, "status": "error", "error": f"unknown community {community_id}"}
+        ranked = [r[0] for r in sorted(rows, key=lambda r: -(r[1] or 0.0))]
+        weights = {r[0]: float(r[1] or 0.0) for r in rows}
+        fp = core_fingerprint(ranked, weights)
+        from ...storage.db.write_gate import commit_connection, with_db_write
+        with with_db_write():
+            rename_community(conn, fp, new_name)
+            conn.execute(
+                "UPDATE entities SET metadata_json=json_patch(COALESCE(metadata_json,'{}'),"
+                " json_object('community_label', ?))"
+                " WHERE json_extract(metadata_json,'$.community_id')=?",
+                (new_name, community_id),
+            )
+            commit_connection(conn)
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "community_id": community_id, "name": new_name,
+                            "members": len(rows)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}