ltcai 8.0.0 → 8.2.0

package/latticeai/brain/__init__.py

@@ -22,7 +22,7 @@ warnings.warn(
     "latticeai.brain is deprecated; import lattice_brain instead",
     DeprecationWarning,
     stacklevel=2,
-)
+)  # one-time per import site in practice; shims remain for compat surface
 
 __all__ = [
     "AssembledContext",

package/latticeai/core/config.py

@@ -26,6 +26,8 @@ from typing import List, Mapping, Optional
 from latticeai.core.security import host_is_loopback
 
 
+__all__ = ["Config", "_value", "_str", "_bool", "_int"]
+
 def _value(env: Mapping[str, str], key: str, default: str = "") -> str:
     """Mirror the legacy ``env_value``: ``getenv(key) or default or ""`` (no strip)."""
     return env.get(key) or default or ""
@@ -68,6 +70,7 @@ class Config:
     host: str
     port: int
     network_exposed: bool
+    timezone: str
 
     # ── feature flags ───────────────────────────────────────────────
     enable_telegram: bool
@@ -93,6 +96,9 @@ class Config:
     local_model: str
     local_draft_model: str
     auto_read_chat_paths: bool
+    max_local_models: int
+    allow_model_downloads: bool
+    model_download_timeout: int
 
     # ── embeddings (retrieval vector signal) ────────────────────────
     embedding_provider: str
@@ -165,6 +171,7 @@ class Config:
             host=host,
             port=port,
             network_exposed=network_exposed,
+            timezone=_value(env, "LATTICE_TZ", "UTC") or "UTC",
             enable_telegram=_bool(env, "LATTICEAI_ENABLE_TELEGRAM", default=False),
             enable_graph=_bool(env, "LATTICEAI_ENABLE_GRAPH", default=True),
             autoload_models=_bool(env, "LATTICEAI_AUTOLOAD_MODELS", default=is_public),
@@ -184,6 +191,9 @@ class Config:
             local_model=local_model,
             local_draft_model=_value(env, "LATTICEAI_LOCAL_DRAFT_MODEL", ""),
             auto_read_chat_paths=_bool(env, "LATTICEAI_AUTO_READ_CHAT_PATHS", default=False),
+            max_local_models=_int(env, "LATTICEAI_MAX_LOCAL_MODELS", 1),
+            allow_model_downloads=_bool(env, "LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False),
+            model_download_timeout=_int(env, "LATTICEAI_MODEL_DOWNLOAD_TIMEOUT", 300),
             embedding_provider=_value(env, "LATTICEAI_EMBEDDING_PROVIDER", "hash").strip().lower(),
             embedding_profile=_value(env, "LATTICEAI_EMBEDDING_PROFILE", "").strip().lower(),
             embedding_model=_value(env, "LATTICEAI_EMBEDDING_MODEL", ""),

package/latticeai/core/local_embeddings.py

@@ -23,6 +23,10 @@ DEFAULT_EMBEDDING_DIM = 384
 EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_DIM}"
 
 
+def embedding_model_id(dim: int) -> str:
+    return f"lattice-local-hash-v1:{int(dim)}"
+
+
 def _tokenize(text: str) -> List[str]:
     raw = str(text or "").lower()
     tokens = re.findall(r"[a-z0-9][a-z0-9_.:/+-]{1,}|[가-힣]{2,}", raw)
@@ -57,6 +61,10 @@ class LocalEmbeddingModel:
     dim: int = DEFAULT_EMBEDDING_DIM
     model_id: str = EMBEDDING_MODEL_ID
 
+    def __post_init__(self) -> None:
+        if self.model_id == EMBEDDING_MODEL_ID and self.dim != DEFAULT_EMBEDDING_DIM:
+            object.__setattr__(self, "model_id", embedding_model_id(self.dim))
+
     def embed(self, text: str) -> List[float]:
         vector = [0.0] * self.dim
         features = _tokenize(text)

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "8.0.0"
+MARKETPLACE_VERSION = "8.2.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/mcp_registry.py

@@ -6,9 +6,12 @@ Extracted from server.py to reduce module size.
 
 import json
 import logging
+import os
+import subprocess
+import sys
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Callable, Dict, List, Optional
 
 import httpx
 from fastapi import HTTPException
@@ -789,3 +792,139 @@ async def install_skill(plugin: str, skill: str) -> Dict:
         "license": entry["license"],
         "author":  entry["author"],
     }
+
+
+def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
+    """Return bound MCP state helpers for given data_dir. No global side effects."""
+    MCP_FILE = Path(data_dir) / "mcp_installs.json"
+
+    def load_mcp_installs() -> Dict:
+        if not os.path.exists(MCP_FILE):
+            return {"installed": {}, "updated_at": None}
+        try:
+            with open(MCP_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if "installed" not in data:
+                data["installed"] = {}
+            return data
+        except Exception as e:
+            logging.warning("load_mcp_installs failed: %s", e)
+            return {"installed": {}, "updated_at": None}
+
+    def save_mcp_installs(data: Dict) -> None:
+        data["updated_at"] = datetime.now().isoformat()
+        with open(MCP_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def mcp_public_item(item: Dict, installed_state: Dict) -> Dict:
+        state = installed_state.get(item.get("id"), {}) or {}
+        installed = item.get("install_mode") in {"builtin", "bundled"} or bool(state.get("installed"))
+        connector_pending = item.get("install_mode") == "connector" and not state.get("authenticated")
+        authenticated = item.get("install_mode") != "connector" or bool(state.get("authenticated"))
+        return {
+            "id": item.get("id"),
+            "name": item.get("name"),
+            "category": item.get("category", ""),
+            "install_mode": item.get("install_mode"),
+            "description": item.get("description", ""),
+            "capabilities": item.get("capabilities", []),
+            "connector_url": item.get("connector_url"),
+            "external_url": item.get("external_url"),
+            "package": item.get("package"),
+            "homepage": item.get("homepage"),
+            "source": item.get("source", "local"),
+            "installed": installed,
+            "status": state.get("status") or ("active" if installed and not connector_pending else "needs_auth" if connector_pending else "available"),
+            "authenticated": authenticated,
+            "updated_at": state.get("updated_at"),
+        }
+
+    async def recommend_mcps(query: str, limit: int = 5) -> List[Dict]:
+        text = (query or "").lower()
+        installed = load_mcp_installs().get("installed", {})
+        registry = await _get_combined_registry()
+        scored: List[Dict] = []
+        for item in registry:
+            score = 0
+            hits: List[str] = []
+            for keyword in item.get("keywords", []):
+                if keyword.lower() in text:
+                    score += 3 if len(keyword) > 2 else 1
+                    hits.append(keyword)
+            if not hits and text:
+                desc_words = item.get("description", "").lower().split()
+                for word in text.split():
+                    if len(word) > 2 and word in desc_words:
+                        score += 1
+                        hits.append(word)
+            if item.get("id") == "filesystem" and any(w in text for w in ["만들", "구현", "build", "deploy", "코드", "앱"]):
+                score += 2
+            if score:
+                public = mcp_public_item(item, installed)
+                public["score"] = score
+                public["matched_keywords"] = hits[:6]
+                scored.append(public)
+        if not scored:
+            fallback_ids = ["filesystem", "browser", "documents"]
+            scored = [
+                {**mcp_public_item(item, installed), "score": 1, "matched_keywords": []}
+                for item in registry if item.get("id") in fallback_ids
+            ]
+        return sorted(scored, key=lambda x: x["score"], reverse=True)[:max(1, min(limit, 24))]
+
+    async def install_mcp(mcp_id: str) -> Dict:
+        registry = await _get_combined_registry()
+        item = next((entry for entry in registry if entry.get("id") == mcp_id), None)
+        if not item:
+            raise HTTPException(status_code=404, detail="MCP를 찾을 수 없습니다.")
+        data = load_mcp_installs()
+        state = data.setdefault("installed", {})
+        status = "active"
+        message = "MCP가 활성화되었습니다."
+        if item.get("install_mode") == "connector":
+            status = "needs_auth"
+            message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
+        elif item.get("install_mode") == "pip":
+            packages = item.get("pip_packages") or []
+            for pkg in packages:
+                completed = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
+                    capture_output=True, text=True, timeout=900, check=False,
+                )
+                if completed.returncode != 0:
+                    raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"필수 패키지 설치 완료: {', '.join(packages)}"
+        elif item.get("install_mode") == "pypi":
+            pkg = item.get("package", "")
+            version = item.get("package_version")
+            pkg_str = f"{pkg}=={version}" if version else pkg
+            completed = subprocess.run([sys.executable, "-m", "pip", "install", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            if completed.returncode != 0:
+                raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"pip 패키지 설치 완료: {pkg_str}"
+        elif item.get("install_mode") == "npm":
+            pkg = item.get("package", "")
+            version = item.get("package_version")
+            pkg_str = f"{pkg}@{version}" if version else pkg
+            completed = subprocess.run(["npm", "install", "-g", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            if completed.returncode != 0:
+                raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
+            message = f"npm 패키지 설치 완료: {pkg_str}"
+        state[mcp_id] = {
+            "installed": True,
+            "status": status,
+            "authenticated": item.get("install_mode") != "connector",
+            "updated_at": datetime.now().isoformat(),
+        }
+        save_mcp_installs(data)
+        public = mcp_public_item(item, state)
+        public["message"] = message
+        return public
+
+    return {
+        "load_mcp_installs": load_mcp_installs,
+        "save_mcp_installs": save_mcp_installs,
+        "mcp_public_item": mcp_public_item,
+        "recommend_mcps": recommend_mcps,
+        "install_mcp": install_mcp,
+    }

package/latticeai/core/tool_registry.py

@@ -9,6 +9,16 @@ effects at import time.
 
 from __future__ import annotations
 
+__all__ = [
+    "ToolPolicy",
+    "ToolPermission",
+    "TOOL_CATALOG_BRIEF",
+    "FILE_CREATE_ACTIONS",
+    "LOCAL_WRITE_BLOCKED_PREFIXES",
+    "RISK_LEVEL_MAP",
+    "ToolRegistry",
+]
+
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, Mapping, Optional, TypedDict
 

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