ltcai 11.5.2 → 11.7.0

package/latticeai/core/workspace_os_constants.py

@@ -1,126 +0,0 @@
-"""Workspace OS vocabulary: types, roles, permissions, areas, defaults.
-
-Split out of ``workspace_os.py`` in 10.2.0 so the store module holds behaviour
-and this one holds the vocabulary that behaviour is written against. Every name
-is re-exported from ``workspace_os`` — the import path callers use has not
-changed.
-"""
-
-from __future__ import annotations
-
-from typing import Dict
-
-WORKSPACE_OS_VERSION = "11.5.2"
-
-# Workspace types separate single-user Personal workspaces from shared
-# Organization workspaces. Both keep the same local-first JSON store; the type
-# only changes how membership and permissions are evaluated.
-WORKSPACE_TYPES = ("personal", "organization")
-
-DEFAULT_WORKSPACE_ID = "personal"
-
-# Role hierarchy for Organization workspaces. Personal workspaces always grant
-# their single local user the owner role.
-WORKSPACE_ROLES = ("owner", "admin", "member", "viewer")
-
-# Capability-style permissions. Kept intentionally small so Enterprise editions
-# can layer advanced RBAC/ABAC on top via the enterprise seam without changing
-# these community defaults.
-WORKSPACE_PERMISSIONS = ("read", "write", "manage_members", "manage_workspace")
-
-ROLE_PERMISSIONS: Dict[str, set] = {
-    "owner": {"read", "write", "manage_members", "manage_workspace"},
-    "admin": {"read", "write", "manage_members", "manage_workspace"},
-    "member": {"read", "write"},
-    "viewer": {"read"},
-}
-
-WORKSPACE_AREAS = [
-    "graph",
-    "snapshot",
-    "memory",
-    "agent",
-    "workflow",
-    "plugins",
-    "skills",
-    "marketplace",
-    "timeline",
-]
-
-ONBOARDING_STEPS = [
-    "account",
-    "admin",
-    "hardware",
-    "model_recommendation",
-    "model_install",
-    "model_connection",
-    "folder_connection",
-    "first_question",
-    "complete",
-]
-
-MEMORY_KINDS = {
-    "short_term",
-    "workspace",
-    "preferences",
-    "decisions",
-    "working_style",
-    "frequently_used_tools",
-    "long_term",
-}
-
-EXECUTION_EVENT_TYPES = {
-    "agent_started",
-    "handoff_created",
-    "handoff_accepted",
-    "handoff_completed",
-    "review_requested",
-    "review_approved",
-    "review_rejected",
-    "retry_requested",
-    "workflow_started",
-    "workflow_completed",
-    "plugin_started",
-    "plugin_completed",
-    "execution_failed",
-    "execution_cancelled",
-    "execution_interrupted",
-}
-
-DEFAULT_AGENTS = [
-    {
-        "id": "agent:planner",
-        "name": "Planner",
-        "role": "Breaks workspace goals into executable plans.",
-        "status": "available",
-        "relationships": ["agent:executor", "agent:reviewer"],
-    },
-    {
-        "id": "agent:executor",
-        "name": "Executor",
-        "role": "Runs approved tool and code workflows.",
-        "status": "available",
-        "relationships": ["agent:planner", "agent:reviewer"],
-    },
-    {
-        "id": "agent:reviewer",
-        "name": "Reviewer",
-        "role": "Checks outputs, tests, and regressions.",
-        "status": "available",
-        "relationships": ["agent:executor", "agent:release"],
-    },
-    {
-        "id": "agent:researcher",
-        "name": "Researcher",
-        "role": "Finds and curates relevant workspace knowledge.",
-        "status": "available",
-        "relationships": ["agent:planner"],
-    },
-    {
-        "id": "agent:release",
-        "name": "Release Agent",
-        "role": "Coordinates versioning, packaging, and release checks.",
-        "status": "available",
-        "relationships": ["agent:reviewer"],
-    },
-]

package/latticeai/core/workspace_os_state.py

@@ -1,180 +0,0 @@
-"""Workspace OS state: the shape of a new file, and upgrades to old ones.
-
-Split out of ``workspace_os.py`` in 10.2.0. Neither concern belongs to the
-store: ``default_state`` describes a brand-new workspace file, ``new_workspace_record``
-builds one workspace entry, and ``migrate_workspaces`` upgrades a file written
-by an older version. All three were already free of instance state — two were
-``@staticmethod`` in all but name — so they move without behaviour change.
-
-``WorkspaceOSStore`` keeps thin delegating methods, so its public surface and
-every existing call site are unchanged.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from .timeutil import now_iso as _now
-from .workspace_os_constants import (
-    DEFAULT_AGENTS,
-    DEFAULT_WORKSPACE_ID,
-    ONBOARDING_STEPS,
-    ROLE_PERMISSIONS,
-    WORKSPACE_AREAS,
-    WORKSPACE_OS_VERSION,
-    WORKSPACE_TYPES,
-)
-
-
-def new_workspace_record(
-    *,
-    workspace_id: str,
-    name: str,
-    workspace_type: str,
-    owner_user_id: Optional[str],
-    settings: Optional[Dict[str, Any]] = None,
-    members: Optional[List[Dict[str, Any]]] = None,
-) -> Dict[str, Any]:
-    if workspace_type not in WORKSPACE_TYPES:
-        raise ValueError(f"unknown workspace type: {workspace_type}")
-    now = _now()
-    member_list = list(members or [])
-    if owner_user_id and not any(m.get("user_id") == owner_user_id for m in member_list):
-        member_list.insert(0, {"user_id": owner_user_id, "role": "owner", "added_at": now})
-    return {
-        "workspace_id": workspace_id,
-        "id": workspace_id,
-        "name": name,
-        "type": workspace_type,
-        "owner_user_id": owner_user_id,
-        "members": member_list,
-        "roles": {role: sorted(perms) for role, perms in ROLE_PERMISSIONS.items()},
-        "status": "active",
-        "areas": list(WORKSPACE_AREAS),
-        "settings": settings or {},
-        "created_at": now,
-        "updated_at": now,
-    }
-
-
-def migrate_workspaces(state: Dict[str, Any]) -> Dict[str, Any]:
-    """Non-destructive upgrade of legacy workspace entries to the v1.1 model.
-
-    Existing 1.0.x state files stored minimal ``{id,name,type,areas}`` dicts.
-    This backfills membership/role/timestamp fields without dropping data and
-    guarantees the default Personal workspace always exists.
-    """
-    workspaces = state.get("workspaces")
-    if not isinstance(workspaces, dict):
-        workspaces = {}
-    migrated: Dict[str, Any] = {}
-    for ws_id, ws in workspaces.items():
-        if not isinstance(ws, dict):
-            continue
-        ws_type = str(ws.get("type")) if ws.get("type") in WORKSPACE_TYPES else "organization"
-        if ws_id == DEFAULT_WORKSPACE_ID:
-            ws_type = "personal"
-        base = new_workspace_record(
-            workspace_id=ws_id,
-            name=ws.get("name") or ws_id,
-            workspace_type=ws_type,
-            owner_user_id=ws.get("owner_user_id"),
-            settings=ws.get("settings") or {},
-            members=ws.get("members") if isinstance(ws.get("members"), list) else None,
-        )
-        # Preserve any pre-existing timestamps / status from the loaded record.
-        base["created_at"] = ws.get("created_at") or base["created_at"]
-        base["updated_at"] = ws.get("updated_at") or base["updated_at"]
-        base["status"] = ws.get("status") or base["status"]
-        migrated[ws_id] = base
-    if DEFAULT_WORKSPACE_ID not in migrated:
-        migrated[DEFAULT_WORKSPACE_ID] = new_workspace_record(
-            workspace_id=DEFAULT_WORKSPACE_ID,
-            name="Personal Workspace",
-            workspace_type="personal",
-            owner_user_id=None,
-        )
-    state["workspaces"] = migrated
-    active = state.get("active_workspace")
-    if active not in migrated:
-        state["active_workspace"] = DEFAULT_WORKSPACE_ID
-    return state
-
-
-def default_state() -> Dict[str, Any]:
-    return {
-        "version": WORKSPACE_OS_VERSION,
-        "identity": "AI Workspace OS",
-        "created_at": _now(),
-        "updated_at": _now(),
-        "active_workspace": DEFAULT_WORKSPACE_ID,
-        "workspaces": {
-            DEFAULT_WORKSPACE_ID: new_workspace_record(
-                workspace_id=DEFAULT_WORKSPACE_ID,
-                name="Personal Workspace",
-                workspace_type="personal",
-                owner_user_id=None,
-            ),
-        },
-        "feature_flags": {
-            "workspace_os": True,
-            "graph_trace": True,
-            "snapshots": True,
-            "personal_memory": True,
-            "multi_agent_graph": True,
-            "workflow_graph": True,
-            "skill_marketplace": True,
-            "local_computer_memory": False,
-            "organization_workspaces": True,
-            "enterprise_seam": True,
-            "plugin_sdk": True,
-            "workflow_designer": True,
-            "multi_agent_runtime": True,
-            "realtime_collaboration": True,
-            "agent_handoff": True,
-            "agent_context_packets": True,
-            "review_retry_loops": True,
-            "timeline_replay": True,
-            "agent_memory": True,
-            "agent_planning": True,
-            "marketplace_foundation": True,
-            "realtime_execution_observability": True,
-        },
-        "onboarding": {
-            "completed": False,
-            "current_step": "account",
-            "steps": {
-                step: {
-                    "id": step,
-                    "status": "pending",
-                    "data": {},
-                    "error": "",
-                    "updated_at": None,
-                }
-                for step in ONBOARDING_STEPS
-            },
-        },
-        "snapshots": [],
-        "traces": [],
-        "memories": [],
-        "memory_snapshots": [],
-        "agents": list(DEFAULT_AGENTS),
-        "agent_runs": [],
-        "handoffs": [],
-        "workflows": [],
-        "workflow_runs": [],
-        "review_items": [],
-        "skill_registry": {},
-        "plugin_registry": {},
-        "template_registry": {},
-        "computer_memory": {
-            "enabled": False,
-            "approved": False,
-            "approved_at": None,
-            "approved_by": None,
-            "scopes": ["Downloads", "Documents", "Repositories"],
-            "activities": [],
-            "notice": "Local Computer Memory is OFF by default and requires explicit approval.",
-        },
-        "timeline": [],
-    }

package/latticeai/core/workspace_os_utils.py

@@ -1,103 +0,0 @@
-"""Helper utilities extracted from the monolithic WorkspaceOSStore module.
-
-These are internal (_-prefixed) helpers for JSON handling, slugging, and
-timeline data. 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 shutil
-from pathlib import Path
-from typing import Any, Dict, List
-
-from .io_utils import (
-    atomic_write_json as _atomic_write_json,  # noqa: F401 - legacy helper re-export
-)
-from .io_utils import parse_iso as _parse_iso  # noqa: F401 - legacy helper re-export
-
-
-class WorkspaceStoreMixin:
-    """A collaborator that reads and writes through ``WorkspaceOSStore``.
-
-    The store was decomposed into managers that each own one branch of the state
-    document, and every one of them needs the same two things: a reference to the
-    store, and for anything it does not implement itself (``load_state``,
-    ``_scoped``, ``record_timeline_event``) to reach the store instead of raising
-    ``AttributeError``. Four managers wrote that out identically; the pair lives
-    here so a fifth cannot invent a third spelling of it.
-    """
-
-    def __init__(self, store: Any) -> None:
-        self._store = store
-
-    def __getattr__(self, name: str) -> Any:
-        # Only reached for attributes this manager does not define, so the
-        # store is the answer for every state-document operation.
-        return getattr(self._store, name)
-
-
-def graph_scope_kwargs(workspace_id: Any) -> Dict[str, Any]:
-    """The scoped-read kwargs the graph store expects (house pattern).
-
-    ``workspace_id is None`` means "unscoped caller": it reads everything it is
-    allowed to, legacy rows that predate workspaces included. A named workspace
-    reads only that workspace and never the legacy pool — which is the whole
-    isolation guarantee, so it is stated once.
-    """
-    return {
-        "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
-        "include_legacy_global": workspace_id is None,
-    }
-
-
-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 _listify(value: Any) -> List[Any]:
-    return value if isinstance(value, list) else []
-
-
-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

@@ -1,101 +0,0 @@
-"""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 .timeutil import now_iso as _now
-from .workspace_os_utils import _listify
-
-
-# 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

@@ -1,97 +0,0 @@
-"""Plugins, marketplace templates, and skill management extracted from WorkspaceOSStore.
-
-Provides PluginManager for composition.
-"""
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from .timeutil import now_iso as _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