ltcai 8.1.0 → 8.2.0

package/latticeai/core/workspace_graph_trace.py

@@ -0,0 +1,132 @@
+"""Graph answer trace persistence extracted from WorkspaceOSStore."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .workspace_os_utils import _json_hash, _listify, _now
+
+
+class WorkspaceGraphTrace:
+    def __init__(self, store: Any):
+        self._store = store
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._store, name)
+
+    def build_graph_trace(self, question: str, graph: Any, context: str = "", *, limit: int = 8) -> Dict[str, Any]:
+        if graph is None:
+            return {
+                "source_files": [],
+                "graph_nodes": [],
+                "graph_edges": [],
+                "confidence": 0.0,
+                "retrieval_metadata": {
+                    "query": question,
+                    "matched_nodes": 0,
+                    "graph_enabled": False,
+                    "context_chars": len(context or ""),
+                },
+            }
+
+        matches: List[Dict[str, Any]] = []
+        search_error = ""
+        try:
+            matches = graph.search(question, limit=limit).get("matches", [])
+        except Exception as exc:
+            search_error = str(exc)
+            matches = []
+
+        source_files: List[Dict[str, Any]] = []
+        seen_sources = set()
+        for match in matches:
+            meta = match.get("metadata") or {}
+            source = (
+                meta.get("relative_path")
+                or meta.get("file_path")
+                or meta.get("filename")
+                or meta.get("blob_path")
+                or meta.get("source")
+            )
+            if source and source not in seen_sources:
+                seen_sources.add(source)
+                source_files.append({
+                    "source": source,
+                    "node_id": match.get("id"),
+                    "node_title": match.get("title"),
+                    "node_type": match.get("type"),
+                    "jump": {
+                        "graph": f"/graph?node={match.get('id')}",
+                        "source": source,
+                    },
+                })
+
+        edges: List[Dict[str, Any]] = []
+        edge_seen = set()
+        for match in matches[:5]:
+            node_id = match.get("id")
+            if not node_id:
+                continue
+            try:
+                for edge in graph.neighbors(node_id).get("edges", []):
+                    key = (edge.get("from"), edge.get("to"), edge.get("type"))
+                    if key in edge_seen:
+                        continue
+                    edge_seen.add(key)
+                    edges.append(edge)
+                    if len(edges) >= 24:
+                        break
+            except Exception:
+                continue
+
+        if matches:
+            confidence = min(0.95, 0.35 + min(len(matches), limit) / max(limit, 1) * 0.45 + (0.10 if edges else 0.0))
+        else:
+            confidence = 0.05 if context else 0.0
+
+        return {
+            "source_files": source_files,
+            "graph_nodes": matches,
+            "graph_edges": edges,
+            "confidence": round(confidence, 4),
+            "retrieval_metadata": {
+                "query": question,
+                "matched_nodes": len(matches),
+                "matched_edges": len(edges),
+                "graph_enabled": True,
+                "context_chars": len(context or ""),
+                "search_error": search_error,
+            },
+        }
+
+    def record_trace(
+        self,
+        *,
+        question: str,
+        response: str,
+        conversation_id: Optional[str],
+        user_email: Optional[str],
+        trace: Dict[str, Any],
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        state = self.load_state()
+        trace_id = f"trace-{_json_hash([question, response, conversation_id, _now()])[:16]}"
+        record = {
+            "id": trace_id,
+            "question": question,
+            "response_preview": str(response or "")[:700],
+            "conversation_id": conversation_id,
+            "user_email": user_email,
+            "workspace_id": self._resolve_scope(workspace_id, state),
+            "created_at": _now(),
+            **trace,
+        }
+        state.setdefault("traces", []).append(record)
+        self.save_state(state)
+        self.record_timeline_event("graph", "answer_trace", {"trace_id": trace_id, "conversation_id": conversation_id})
+        return record
+
+    def list_traces(self, conversation_id: Optional[str] = None, limit: int = 50, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        traces = self._scoped(_listify(self.load_state().get("traces")), workspace_id)
+        if conversation_id:
+            traces = [trace for trace in traces if trace.get("conversation_id") == conversation_id]
+        return {"traces": list(reversed(traces[-max(1, min(limit, 200)):]))}

package/latticeai/core/workspace_memory.py

@@ -0,0 +1,75 @@
+"""Memory methods extracted from WorkspaceOSStore for decomposition.
+
+WorkspaceMemory manager.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .workspace_os_utils import _json_hash, _listify, _now
+
+
+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",
+                    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