ltcai 8.1.0 → 8.2.0

package/latticeai/core/workspace_os_utils.py

@@ -0,0 +1,132 @@
+"""Helper utilities extracted from the monolithic WorkspaceOSStore module.
+
+These are internal (_-prefixed) helpers for JSON handling, slugging, timeline,
+and snapshot conversion. Moving them keeps workspace_os.py focused on the
+store class and public constants while preserving exact behavior.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def _now() -> str:
+    return datetime.now().isoformat(timespec="seconds")
+
+
+def _safe_slug(raw: str) -> str:
+    value = "".join(ch if ch.isalnum() or ch in "-_." else "-" for ch in str(raw or "").strip())
+    value = "-".join(part for part in value.split("-") if part)
+    return (value or "item")[:96]
+
+
+def _json_hash(value: Any) -> str:
+    import hashlib
+
+    payload = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
+    return hashlib.sha256(payload.encode("utf-8", errors="replace")).hexdigest()
+
+
+def _deep_merge(default: Any, loaded: Any) -> Any:
+    if isinstance(default, dict) and isinstance(loaded, dict):
+        merged = {key: _deep_merge(value, loaded.get(key)) for key, value in default.items()}
+        for key, value in loaded.items():
+            if key not in merged:
+                merged[key] = value
+        return merged
+    if loaded is None:
+        return default
+    return loaded
+
+
+def _atomic_write_json(path: Path, payload: Dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    tmp_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    os.replace(tmp_path, path)
+
+
+def _listify(value: Any) -> List[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _snapshot_graph_import_payload(graph_payload: Dict[str, Any], *, workspace_id: Optional[str]) -> Dict[str, Any]:
+    """Convert the UI graph snapshot shape into the logical import artifact."""
+
+    nodes = []
+    for node in _listify((graph_payload or {}).get("nodes")):
+        node_id = node.get("id")
+        if not node_id:
+            continue
+        metadata = node.get("metadata") if isinstance(node.get("metadata"), dict) else {}
+        raw = node.get("raw") if isinstance(node.get("raw"), dict) else {}
+        if workspace_id and not metadata.get("workspace_id"):
+            metadata = {**metadata, "workspace_id": workspace_id}
+        nodes.append({
+            "id": node_id,
+            "type": node.get("type") or "Concept",
+            "title": node.get("title") or node.get("label") or node_id,
+            "summary": node.get("summary") or "",
+            "metadata_json": json.dumps(metadata, ensure_ascii=False),
+            "raw_json": json.dumps(raw, ensure_ascii=False),
+        })
+
+    edges = []
+    for edge in _listify((graph_payload or {}).get("edges")):
+        source = edge.get("from_node") or edge.get("from") or edge.get("source")
+        target = edge.get("to_node") or edge.get("to") or edge.get("target")
+        if not source or not target:
+            continue
+        edges.append({
+            "from_node": source,
+            "to_node": target,
+            "type": edge.get("type") or "related_to",
+            "weight": edge.get("weight") or 1.0,
+            "metadata_json": json.dumps(edge.get("metadata") or {}, ensure_ascii=False),
+        })
+
+    return {
+        "header": {"graph_schema_version": 1, "workspace_id": workspace_id, "source": "workspace_snapshot"},
+        "nodes": nodes,
+        "edges": edges,
+        "chunks": [],
+        "knowledge_sources": [],
+        "provenance": [],
+        "counts": {"nodes": len(nodes), "edges": len(edges)},
+    }
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def _file_size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except Exception:
+        return 0
+
+
+def remove_skill_directory(skills_dir: Path, skill: str) -> Dict[str, Any]:
+    """Remove an installed skill directory after caller has performed auth checks.
+
+    Moved here from workspace_os.py for smaller focused surface.
+    """
+    safe_name = _safe_slug(skill)
+    target = (skills_dir / safe_name).resolve()
+    root = skills_dir.resolve()
+    if not str(target).startswith(str(root)):
+        raise ValueError("invalid skill path")
+    if not target.exists() or not target.is_dir():
+        raise FileNotFoundError(skill)
+    shutil.rmtree(target)
+    return {"status": "ok", "skill": safe_name, "removed_path": str(target)}

package/latticeai/core/workspace_permissions.py

@@ -0,0 +1,99 @@
+"""Workspace permission and role logic extracted from WorkspaceOSStore.
+
+Provides pure functions + a small PermissionManager for composition.
+All behavior preserved; main store continues to expose the same public methods.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .workspace_os_utils import _listify, _now
+
+# Avoid circular at import time: pull constants lazily from parent module.
+def _get_role_permissions():
+    from .workspace_os import ROLE_PERMISSIONS
+    return ROLE_PERMISSIONS
+
+def _get_workspace_roles():
+    from .workspace_os import WORKSPACE_ROLES
+    return WORKSPACE_ROLES
+
+
+def _member_role(ws: Dict[str, Any], user_id: Optional[str]) -> Optional[str]:
+    if ws.get("type") == "personal":
+        return "owner"
+    owner = ws.get("owner_user_id")
+    if not owner and not user_id:
+        return "owner"
+    if user_id and user_id == owner:
+        return "owner"
+    for member in _listify(ws.get("members")):
+        if member.get("user_id") == user_id:
+            return member.get("role")
+    return None
+
+
+def has_permission(ws_or_store: Any, workspace_id: str, user_id: Optional[str], permission: str) -> bool:
+    """Works both as standalone or delegated."""
+    if hasattr(ws_or_store, "load_state"):
+        # called as method on store
+        ws = (ws_or_store.load_state().get("workspaces") or {}).get(workspace_id)
+    else:
+        ws = ws_or_store
+    if not ws:
+        return False
+    role = _member_role(ws, user_id)
+    if role is None:
+        return False
+    return permission in _get_role_permissions().get(role, set())
+
+
+class WorkspacePermissionManager:
+    """Composable permission manager."""
+
+    def __init__(self, store: Any):
+        self._store = store
+
+    def get_member_role(self, workspace_id: str, user_id: Optional[str]) -> Optional[str]:
+        ws = (self._store.load_state().get("workspaces") or {}).get(workspace_id)
+        if not ws:
+            raise FileNotFoundError(workspace_id)
+        return _member_role(ws, user_id)
+
+    def has_permission(self, workspace_id: str, user_id: Optional[str], permission: str) -> bool:
+        try:
+            role = self.get_member_role(workspace_id, user_id)
+        except FileNotFoundError:
+            return False
+        if role is None:
+            return False
+        return permission in _get_role_permissions().get(role, set())
+
+    def require_permission(self, ws: Dict[str, Any], actor: Optional[str], permission: str) -> None:
+        role = _member_role(ws, actor)
+        if role is None or permission not in _get_role_permissions().get(role, set()):
+            raise PermissionError(
+                f"'{actor or 'anonymous'}' lacks '{permission}' on workspace '{ws.get('workspace_id')}'"
+            )
+
+    def add_member(self, workspace_id: str, *, user_id: str, role: str = "member", actor: Optional[str] = None) -> Dict[str, Any]:
+        if role not in _get_workspace_roles():
+            raise ValueError(f"unknown role: {role}")
+        if not str(user_id or "").strip():
+            raise ValueError("user_id is required")
+        state = self._store.load_state()
+        ws = self._store._load_org(state, workspace_id)
+        self.require_permission(ws, actor, "manage_members")
+        members = ws.setdefault("members", [])
+        existing = next((m for m in members if m.get("user_id") == user_id), None)
+        if existing:
+            existing["role"] = role
+            existing["updated_at"] = _now()
+        else:
+            members.append({"user_id": user_id, "role": role, "added_at": _now()})
+        ws["updated_at"] = _now()
+        self._store.save_state(state)
+        self._store.record_timeline_event("workspace", "member_added", {"workspace_id": workspace_id, "user_id": user_id, "role": role})
+        return self._store._workspace_public(ws, actor)
+
+    # add thin wrappers for update/remove if needed by store

package/latticeai/core/workspace_plugins.py

@@ -0,0 +1,97 @@
+"""Plugins, marketplace templates, and skill management extracted from WorkspaceOSStore.
+
+Provides PluginManager for composition.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .workspace_os_utils import _now
+
+
+class WorkspacePluginManager:
+    """Composable plugin + marketplace manager."""
+
+    def __init__(self, store: Any):
+        self._store = store
+
+    def list_plugin_registry(self) -> Dict[str, Any]:
+        return dict(self._store.load_state().get("plugin_registry") or {})
+
+    def set_plugin_enabled(self, plugin_id: str, enabled: bool) -> Dict[str, Any]:
+        state = self._store.load_state()
+        entry = state.setdefault("plugin_registry", {}).setdefault(plugin_id, {"id": plugin_id})
+        entry["enabled"] = bool(enabled)
+        entry["updated_at"] = _now()
+        self._store.save_state(state)
+        self._store.record_timeline_event("plugins", "plugin_toggled", {"plugin": plugin_id, "enabled": enabled})
+        return entry
+
+    def mark_plugin_installed(self, plugin_id: str, *, version: str = "0.0.0", metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        state = self._store.load_state()
+        entry = state.setdefault("plugin_registry", {}).setdefault(plugin_id, {"id": plugin_id})
+        entry.update({
+            "id": plugin_id,
+            "installed": True,
+            "enabled": entry.get("enabled", True),
+            "version": version,
+            "install_status": "ready",
+            "validation_status": "valid",
+            "metadata": metadata or entry.get("metadata") or {},
+            "updated_at": _now(),
+        })
+        self._store.save_state(state)
+        self._store.record_timeline_event("plugins", "plugin_installed", {"plugin": plugin_id, "version": version})
+        return entry
+
+    def mark_plugin_uninstalled(self, plugin_id: str) -> Dict[str, Any]:
+        state = self._store.load_state()
+        entry = state.setdefault("plugin_registry", {}).setdefault(plugin_id, {"id": plugin_id})
+        entry.update({"installed": False, "enabled": False, "updated_at": _now()})
+        self._store.save_state(state)
+        self._store.record_timeline_event("plugins", "plugin_uninstalled", {"plugin": plugin_id})
+        return {"status": "ok", "plugin_id": plugin_id, "registry": entry}
+
+    # Marketplace templates
+    @staticmethod
+    def _template_registry_key(kind: str, template_id: str, workspace_id: str) -> str:
+        base = f"{kind}:{template_id}"
+        return base if workspace_id == "personal" else f"{workspace_id}:{base}"
+
+    def list_template_registry(self, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        state = self._store.load_state()
+        registry = dict(state.get("template_registry") or {})
+        if workspace_id is None:
+            return registry
+        scope = self._store._resolve_scope(workspace_id, state)
+        return {
+            key: value
+            for key, value in registry.items()
+            if self._store._record_workspace(value) == scope
+        }
+
+    def mark_template_installed(
+        self,
+        *,
+        kind: str,
+        template_id: str,
+        version: str = "1.0.0",
+        metadata: Optional[Dict[str, Any]] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        state = self._store.load_state()
+        scope = self._store._resolve_scope(workspace_id, state)
+        key = self._template_registry_key(kind, template_id, scope)
+        entry = state.setdefault("template_registry", {}).setdefault(key, {"id": template_id, "kind": kind})
+        entry.update({
+            "id": template_id,
+            "kind": kind,
+            "version": version,
+            "installed": True,
+            "workspace_id": scope,
+            "metadata": metadata or entry.get("metadata") or {},
+            "updated_at": _now(),
+        })
+        self._store.save_state(state)
+        self._store.record_timeline_event("marketplace", "template_installed", {"kind": kind, "template_id": template_id}, workspace_id=scope)
+        return entry