ltcai 11.5.2 → 11.6.0

package/latticeai/core/workspace_memory.py

@@ -1,77 +0,0 @@
-"""Memory methods extracted from WorkspaceOSStore for decomposition.
-
-WorkspaceMemory manager.
-"""
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import _json_hash, _listify
-
-
-class WorkspaceMemory:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def upsert_memory(
-        self,
-        *,
-        kind: str,
-        content: str,
-        user_email: Optional[str],
-        tags: Optional[List[str]] = None,
-        memory_id: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        graph: Any = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        MEMORY_KINDS = {"short_term", "workspace", "preferences", "decisions", "working_style", "frequently_used_tools", "long_term"}
-        if kind not in MEMORY_KINDS:
-            raise ValueError(f"unknown memory kind: {kind}")
-        if not str(content or "").strip():
-            raise ValueError("content is required")
-        state = self._store.load_state()
-        memories = _listify(state.get("memories"))
-        now = _now()
-        memory_id = memory_id or f"memory-{_json_hash([kind, content, user_email, now])[:16]}"
-        existing = next((item for item in memories if item.get("id") == memory_id), None)
-        record = existing or {"id": memory_id, "created_at": now}
-        record.update({
-            "kind": kind,
-            "content": content,
-            "user_email": user_email,
-            "tags": tags or [],
-            "metadata": {**(metadata or {}), "memory_scope": kind},
-            "workspace_id": self._store._resolve_scope(workspace_id, state) if existing is None else self._store._record_workspace(record),
-            "updated_at": now,
-        })
-        if graph is not None:
-            try:
-                ingested = graph.ingest_event(
-                    "Memory",
-                    f"{kind}: {content[:80]}",
-                    user_email=user_email,
-                    source="workspace_os",
-                    workspace_id=record["workspace_id"],
-                    metadata={"memory_id": memory_id, "kind": kind, "tags": tags or []},
-                )
-                record["graph_node_id"] = ingested.get("node_id")
-            except Exception as exc:
-                record["graph_error"] = str(exc)
-        if existing is None:
-            memories.append(record)
-        state["memories"] = memories
-        self._store.save_state(state)
-        self._store.record_timeline_event("memory", "memory_upserted", {"memory_id": memory_id, "kind": kind}, workspace_id=record.get("workspace_id"))
-        return record
-
-    def list_memories(self, user_email: Optional[str] = None, kind: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        memories = self._store._scoped(_listify(self._store.load_state().get("memories")), workspace_id)
-        if user_email:
-            memories = [item for item in memories if item.get("user_email") in {None, user_email}]
-        if kind:
-            memories = [item for item in memories if item.get("kind") == kind]
-        return {"memories": list(reversed(memories))}
-
-    # search_memories can be added similarly if needed

package/latticeai/core/workspace_onboarding.py

@@ -1,104 +0,0 @@
-"""First-run onboarding progress.
-
-Extracted from ``WorkspaceOSStore``. Owns the ``onboarding`` branch of the
-state document: which named step the person is on, what each step recorded, and
-whether the whole run is finished.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from .timeutil import now_iso as _now
-from .workspace_os_constants import ONBOARDING_STEPS
-
-__all__ = ["WorkspaceOnboarding", "ONBOARDING_STATUSES"]
-
-#: The statuses a single step may hold. Anything else is a caller bug, not a
-#: value to store — an unknown status would silently stall the flow, because
-#: `current_step` only advances on `complete`/`skipped`.
-ONBOARDING_STATUSES = frozenset({"pending", "running", "complete", "failed", "skipped"})
-
-
-class WorkspaceOnboarding:
-    """Tracks the named first-run steps and where the person stopped."""
-
-    def __init__(self, store: Any) -> None:
-        self.store = store
-
-    def status(
-        self,
-        users: Optional[Dict[str, Any]] = None,
-        graph_stats: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        state = self.store.load_state()
-        users = users or {}
-        admins = [
-            email for email, user in users.items()
-            if isinstance(user, dict) and user.get("role") == "admin"
-        ]
-        onboarding = state.get("onboarding") or {}
-        steps = onboarding.get("steps") or {}
-        return {
-            **onboarding,
-            "steps": [steps.get(step, {"id": step, "status": "pending"}) for step in ONBOARDING_STEPS],
-            "has_account": bool(users),
-            "has_admin": bool(admins) or bool(users),
-            "graph_ready": bool(graph_stats and not graph_stats.get("disabled")),
-            "required_steps": list(ONBOARDING_STEPS),
-        }
-
-    def update_step(
-        self,
-        step: str,
-        *,
-        status: str = "complete",
-        data: Optional[Dict[str, Any]] = None,
-        error: str = "",
-        user_email: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        if step not in ONBOARDING_STEPS:
-            raise ValueError(f"unknown onboarding step: {step}")
-        if status not in ONBOARDING_STATUSES:
-            raise ValueError(f"unknown onboarding status: {status}")
-        state = self.store.load_state()
-        onboarding = state.setdefault("onboarding", {})
-        steps = onboarding.setdefault("steps", {})
-        record = steps.setdefault(step, {"id": step})
-        record.update({
-            "id": step,
-            "status": status,
-            "data": data or record.get("data") or {},
-            "error": error,
-            "updated_at": _now(),
-            "user_email": user_email,
-        })
-        if status in {"complete", "skipped"}:
-            index = ONBOARDING_STEPS.index(step)
-            if step == "complete":
-                onboarding["completed"] = True
-                onboarding["completed_at"] = _now()
-                onboarding["current_step"] = "complete"
-            elif index + 1 < len(ONBOARDING_STEPS):
-                onboarding["current_step"] = ONBOARDING_STEPS[index + 1]
-        elif status == "failed":
-            onboarding["current_step"] = step
-        self.store.save_state(state)
-        self.store.record_timeline_event(
-            "workspace", "onboarding_step", {"step": step, "status": status}
-        )
-        return self.status()
-
-    def complete(
-        self,
-        data: Optional[Dict[str, Any]] = None,
-        user_email: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        for step in ONBOARDING_STEPS:
-            self.update_step(
-                step,
-                status="complete",
-                data=data if step == "complete" else None,
-                user_email=user_email,
-            )
-        return self.status()