ltcai 4.0.1 → 4.2.0

package/frontend/src/store/appStore.ts

@@ -0,0 +1,54 @@
+import { create } from "zustand";
+
+export type Theme = "dark" | "light";
+export type WorkspaceMode = "basic" | "advanced" | "admin";
+
+type AppState = {
+  theme: Theme;
+  mode: WorkspaceMode;
+  workspaceId: string | null;
+  apiBase: string | null;
+  setTheme: (theme: Theme) => void;
+  setMode: (mode: WorkspaceMode) => void;
+  setWorkspaceId: (workspaceId: string | null) => void;
+  setApiBase: (apiBase: string | null) => void;
+};
+
+function readTheme(): Theme {
+  try {
+    const saved = localStorage.getItem("lattice.theme");
+    if (saved === "light" || saved === "dark") return saved;
+  } catch {}
+  return "dark";
+}
+
+function readMode(): WorkspaceMode {
+  try {
+    const saved = localStorage.getItem("lattice.mode");
+    if (saved === "basic" || saved === "advanced" || saved === "admin") return saved;
+  } catch {}
+  return "basic";
+}
+
+export const useAppStore = create<AppState>((set) => ({
+  theme: readTheme(),
+  mode: readMode(),
+  workspaceId: null,
+  apiBase: null,
+  setTheme: (theme) => {
+    document.documentElement.dataset.theme = theme;
+    try { localStorage.setItem("lattice.theme", theme); } catch {}
+    set({ theme });
+  },
+  setMode: (mode) => {
+    try { localStorage.setItem("lattice.mode", mode); } catch {}
+    set({ mode });
+  },
+  setWorkspaceId: (workspaceId) => {
+    if (workspaceId) {
+      try { localStorage.setItem("lattice.workspace", workspaceId); } catch {}
+    }
+    set({ workspaceId });
+  },
+  setApiBase: (apiBase) => set({ apiBase }),
+}));

package/frontend/src/styles.css

@@ -0,0 +1,107 @@
+@import "tailwindcss";
+@import "reactflow/dist/style.css";
+
+:root {
+  color-scheme: dark;
+  --background: 220 18% 8%;
+  --foreground: 210 30% 96%;
+  --card: 220 16% 11%;
+  --card-foreground: 210 30% 96%;
+  --muted: 218 13% 18%;
+  --muted-foreground: 215 14% 66%;
+  --primary: 176 68% 48%;
+  --primary-foreground: 212 26% 8%;
+  --secondary: 221 14% 20%;
+  --secondary-foreground: 210 30% 96%;
+  --destructive: 355 78% 58%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 218 13% 23%;
+  --input: 218 13% 24%;
+  --ring: 176 68% 48%;
+  --brain: 176 68% 48%;
+  --ask: 216 78% 66%;
+  --capture: 142 58% 56%;
+  --act: 33 92% 58%;
+  --library: 262 68% 70%;
+  --system: 350 72% 68%;
+}
+
+:root[data-theme="light"] {
+  color-scheme: light;
+  --background: 210 30% 98%;
+  --foreground: 222 38% 9%;
+  --card: 0 0% 100%;
+  --card-foreground: 222 38% 9%;
+  --muted: 213 24% 92%;
+  --muted-foreground: 219 11% 38%;
+  --primary: 178 72% 32%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 211 24% 90%;
+  --secondary-foreground: 222 38% 9%;
+  --destructive: 355 72% 48%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 214 20% 83%;
+  --input: 214 20% 78%;
+  --ring: 178 72% 32%;
+}
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  min-width: 320px;
+  margin: 0;
+  background: hsl(var(--background));
+  color: hsl(var(--foreground));
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+button,
+input,
+textarea,
+select {
+  font: inherit;
+}
+
+.brain-grid {
+  background-image:
+    linear-gradient(hsl(var(--border) / 0.34) 1px, transparent 1px),
+    linear-gradient(90deg, hsl(var(--border) / 0.34) 1px, transparent 1px);
+  background-size: 32px 32px;
+}
+
+.scrollbar-thin {
+  scrollbar-width: thin;
+}
+
+.react-flow__node {
+  border: 1px solid hsl(var(--border));
+  border-radius: 8px;
+  background: hsl(var(--card));
+  color: hsl(var(--foreground));
+  padding: 8px 10px;
+  font-size: 12px;
+}
+
+.react-flow__edge-path {
+  stroke: hsl(var(--primary));
+}

package/kg_schema.py

@@ -1,3 +1,3 @@
 """Compatibility shim for the v4 Knowledge Graph schema."""
 
-from latticeai.brain.schema import *  # noqa: F403,F401
+from lattice_brain.schema import *  # noqa: F403,F401

package/knowledge_graph.py

@@ -1,10 +1,10 @@
-"""Compatibility shim for the v4 brain store.
+"""Compatibility shim for the v4.2 lattice-brain store.
 
-The implementation now lives under :mod:`latticeai.brain`. Root imports are
+The implementation now lives under :mod:`lattice_brain`. Root imports are
 kept for older integrations and tests.
 """
 
-from latticeai.brain._kg_common import (  # noqa: F401
+from lattice_brain._kg_common import (  # noqa: F401
     EDGE_VERB,
     GRAPH_SCHEMA_VERSION,
     LOCAL_CODE_EXTENSIONS,
@@ -24,7 +24,7 @@ from latticeai.brain._kg_common import (  # noqa: F401
     _slug,
     set_llm_router,
 )
-from latticeai.brain.store import KnowledgeGraphStore
+from lattice_brain.store import KnowledgeGraphStore
 
 __all__ = [
     "KnowledgeGraphStore",

package/lattice_brain/__init__.py

@@ -0,0 +1,70 @@
+"""lattice-brain — independent Brain Core package for Lattice AI.
+
+Heavy graph modules are lazy-loaded so storage and archive utilities remain
+usable without importing the FastAPI application or creating runtime globals.
+"""
+
+from .archive import BrainArchivePaths, EncryptedBrainArchive
+from .core import BrainCore, BrainCoreConfig
+from .storage import (
+    DockerPostgresPlan,
+    DockerPostgresWizard,
+    PostgresConfig,
+    PostgresEngine,
+    SQLiteEngine,
+    SQLiteToPostgresMigrator,
+    StorageCapabilities,
+    StorageEngine,
+    StorageUnavailable,
+    storage_from_env,
+)
+
+__version__ = "4.2.0"
+
+__all__ = [
+    "AssembledContext",
+    "BrainArchivePaths",
+    "BrainCore",
+    "BrainCoreConfig",
+    "BrainMemory",
+    "ContextAssembler",
+    "ContextSection",
+    "ConversationStore",
+    "DockerPostgresPlan",
+    "DockerPostgresWizard",
+    "EncryptedBrainArchive",
+    "KnowledgeGraphStore",
+    "PostgresConfig",
+    "PostgresEngine",
+    "SQLiteEngine",
+    "SQLiteToPostgresMigrator",
+    "StorageCapabilities",
+    "StorageEngine",
+    "StorageUnavailable",
+    "storage_from_env",
+    "__version__",
+]
+
+
+def __getattr__(name: str):
+    if name in {"AssembledContext", "ContextAssembler", "ContextSection"}:
+        from .context import AssembledContext, ContextAssembler, ContextSection
+
+        return {
+            "AssembledContext": AssembledContext,
+            "ContextAssembler": ContextAssembler,
+            "ContextSection": ContextSection,
+        }[name]
+    if name == "ConversationStore":
+        from .conversations import ConversationStore
+
+        return ConversationStore
+    if name == "BrainMemory":
+        from .memory import BrainMemory
+
+        return BrainMemory
+    if name == "KnowledgeGraphStore":
+        from .store import KnowledgeGraphStore
+
+        return KnowledgeGraphStore
+    raise AttributeError(name)

package/lattice_brain/_kg_common.py

@@ -0,0 +1 @@
+from latticeai.brain._kg_common import *  # noqa: F401,F403

package/lattice_brain/archive.py

@@ -0,0 +1,133 @@
+"""Encrypted .latticebrain archive support."""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import shutil
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Optional
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+
+ARCHIVE_FORMAT = "latticebrain.encrypted"
+ARCHIVE_VERSION = 1
+KDF_ITERATIONS = 390_000
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _derive_key(passphrase: str, salt: bytes) -> bytes:
+    if not passphrase:
+        raise ValueError("A passphrase is required for encrypted .latticebrain archives.")
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=KDF_ITERATIONS,
+    )
+    return kdf.derive(passphrase.encode("utf-8"))
+
+
+@dataclass(frozen=True)
+class BrainArchivePaths:
+    db_path: Path
+    blob_dir: Optional[Path] = None
+
+
+class EncryptedBrainArchive:
+    """Create and restore encrypted local Brain Core archives."""
+
+    def __init__(self, paths: BrainArchivePaths) -> None:
+        self.paths = paths
+
+    def create(self, destination: Path, *, passphrase: str) -> Dict[str, object]:
+        dest = Path(destination)
+        if dest.suffix != ".latticebrain":
+            dest = dest.with_suffix(".latticebrain")
+        if not self.paths.db_path.exists():
+            raise FileNotFoundError(f"Brain database not found: {self.paths.db_path}")
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory() as tmp_s:
+            tmp = Path(tmp_s)
+            payload = tmp / "payload.zip"
+            with zipfile.ZipFile(payload, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.write(self.paths.db_path, "knowledge_graph.sqlite")
+                if self.paths.blob_dir and self.paths.blob_dir.exists():
+                    for file in self.paths.blob_dir.rglob("*"):
+                        if file.is_file():
+                            zf.write(file, f"blobs/{file.relative_to(self.paths.blob_dir)}")
+            salt = os.urandom(16)
+            nonce = os.urandom(12)
+            key = _derive_key(passphrase, salt)
+            ciphertext = AESGCM(key).encrypt(nonce, payload.read_bytes(), None)
+            envelope = {
+                "format": ARCHIVE_FORMAT,
+                "format_version": ARCHIVE_VERSION,
+                "created_at": _now(),
+                "kdf": {
+                    "name": "PBKDF2HMAC-SHA256",
+                    "iterations": KDF_ITERATIONS,
+                    "salt": base64.b64encode(salt).decode("ascii"),
+                },
+                "cipher": {
+                    "name": "AES-256-GCM",
+                    "nonce": base64.b64encode(nonce).decode("ascii"),
+                },
+                "payload": base64.b64encode(ciphertext).decode("ascii"),
+            }
+            dest.write_text(json.dumps(envelope, indent=2), encoding="utf-8")
+        return {"path": str(dest), "bytes": dest.stat().st_size, "encrypted": True}
+
+    def restore(self, source: Path, *, passphrase: str, target: BrainArchivePaths) -> Dict[str, object]:
+        src = Path(source)
+        if not src.exists():
+            raise FileNotFoundError(f"Brain archive not found: {src}")
+        envelope = json.loads(src.read_text(encoding="utf-8"))
+        if envelope.get("format") != ARCHIVE_FORMAT:
+            raise ValueError("Not a .latticebrain encrypted archive.")
+        salt = base64.b64decode(envelope["kdf"]["salt"])
+        nonce = base64.b64decode(envelope["cipher"]["nonce"])
+        ciphertext = base64.b64decode(envelope["payload"])
+        key = _derive_key(passphrase, salt)
+        try:
+            plaintext = AESGCM(key).decrypt(nonce, ciphertext, None)
+        except InvalidTag as exc:
+            raise ValueError("Archive decryption failed; passphrase or archive data is invalid.") from exc
+        with tempfile.TemporaryDirectory() as tmp_s:
+            tmp = Path(tmp_s)
+            payload = tmp / "payload.zip"
+            payload.write_bytes(plaintext)
+            with zipfile.ZipFile(payload) as zf:
+                zf.extractall(tmp / "out")
+            db_src = tmp / "out" / "knowledge_graph.sqlite"
+            if not db_src.exists():
+                raise ValueError("Archive payload is missing knowledge_graph.sqlite.")
+            target.db_path.parent.mkdir(parents=True, exist_ok=True)
+            for sibling in (target.db_path, Path(str(target.db_path) + "-wal"), Path(str(target.db_path) + "-shm")):
+                if sibling.exists():
+                    sibling.unlink()
+            shutil.copyfile(db_src, target.db_path)
+            blobs_src = tmp / "out" / "blobs"
+            if target.blob_dir:
+                if target.blob_dir.exists():
+                    shutil.rmtree(target.blob_dir)
+                if blobs_src.exists():
+                    shutil.copytree(blobs_src, target.blob_dir)
+                else:
+                    target.blob_dir.mkdir(parents=True, exist_ok=True)
+        return {"restored": True, "path": str(target.db_path), "encrypted": True}
+
+
+__all__ = ["BrainArchivePaths", "EncryptedBrainArchive"]

package/lattice_brain/context.py

@@ -0,0 +1,3 @@
+from latticeai.brain.context import AssembledContext, ContextAssembler, ContextSection, approx_tokens
+
+__all__ = ["AssembledContext", "ContextAssembler", "ContextSection", "approx_tokens"]

package/lattice_brain/conversations.py

@@ -0,0 +1,3 @@
+from latticeai.brain.conversations import ConversationStore
+
+__all__ = ["ConversationStore"]

package/lattice_brain/core.py

@@ -0,0 +1,82 @@
+"""Independent Brain Core package facade."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+from .archive import BrainArchivePaths, EncryptedBrainArchive
+from .storage import SQLiteEngine, StorageEngine, StorageUnavailable
+
+
+@dataclass(frozen=True)
+class BrainCoreConfig:
+    data_dir: Path
+    blob_dir: Optional[Path] = None
+    storage_engine: Optional[StorageEngine] = None
+
+
+class BrainCore:
+    """Stable application boundary for the local Digital Brain.
+
+    FastAPI, CLI, tests, and future tools should depend on this package-level
+    facade instead of constructing scattered storage objects directly.
+    """
+
+    def __init__(self, config: BrainCoreConfig, *, embedder: Any = None) -> None:
+        self.config = config
+        self.data_dir = Path(config.data_dir)
+        self.db_path = self.data_dir / "knowledge_graph.sqlite"
+        self.blob_dir = Path(config.blob_dir) if config.blob_dir else self.data_dir / "knowledge_graph_blobs"
+        self.storage_engine = config.storage_engine or SQLiteEngine(self.db_path)
+        caps = self.storage_engine.capabilities()
+        if not caps.available:
+            raise StorageUnavailable(caps.reason or f"{caps.engine} storage is unavailable")
+        if caps.engine != "sqlite":
+            raise StorageUnavailable(
+                "The active FastAPI Brain Core runtime currently requires SQLiteEngine. "
+                "Use PostgresEngine through the explicit migration/scale tooling; no SQLite fallback was attempted."
+            )
+
+        from .conversations import ConversationStore
+        from .store import KnowledgeGraphStore
+
+        self.knowledge = KnowledgeGraphStore(
+            self.db_path,
+            self.blob_dir,
+            embedder=embedder,
+            storage_engine=self.storage_engine,
+        )
+        self.conversations = ConversationStore(self.db_path)
+        self.archive = EncryptedBrainArchive(
+            BrainArchivePaths(db_path=self.db_path, blob_dir=self.blob_dir)
+        )
+
+    @classmethod
+    def from_paths(
+        cls,
+        data_dir: Path,
+        *,
+        blob_dir: Optional[Path] = None,
+        embedder: Any = None,
+        storage_engine: Optional[StorageEngine] = None,
+    ) -> "BrainCore":
+        return cls(
+            BrainCoreConfig(
+                data_dir=Path(data_dir),
+                blob_dir=blob_dir,
+                storage_engine=storage_engine,
+            ),
+            embedder=embedder,
+        )
+
+    def status(self) -> dict:
+        return {
+            "storage": self.storage_engine.capabilities().as_dict(),
+            "db_path": str(self.db_path),
+            "blob_dir": str(self.blob_dir),
+        }
+
+
+__all__ = ["BrainCore", "BrainCoreConfig"]

package/lattice_brain/discovery.py

@@ -0,0 +1 @@
+from latticeai.brain.discovery import *  # noqa: F401,F403

package/lattice_brain/documents.py

@@ -0,0 +1 @@
+from latticeai.brain.documents import *  # noqa: F401,F403

package/lattice_brain/embeddings.py

@@ -0,0 +1,82 @@
+"""Local deterministic embeddings used by the standalone Brain Core package."""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import re
+import struct
+from dataclasses import dataclass
+from typing import Iterable, List
+
+
+DEFAULT_EMBEDDING_DIM = int(os.getenv("LATTICEAI_VECTOR_DIM", "384"))
+EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_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)
+    features: List[str] = []
+    for token in tokens:
+        features.append(f"tok:{token}")
+        if len(token) >= 5 and re.search(r"[a-z]", token):
+            for i in range(0, len(token) - 2):
+                features.append(f"tri:{token[i:i+3]}")
+        if re.search(r"[가-힣]", token) and len(token) >= 3:
+            for i in range(0, len(token) - 1):
+                features.append(f"ko:{token[i:i+2]}")
+    return features
+
+
+def _hash_to_index(feature: str, dim: int) -> tuple[int, float]:
+    digest = hashlib.blake2b(feature.encode("utf-8"), digest_size=8).digest()
+    value = int.from_bytes(digest, "big", signed=False)
+    sign = 1.0 if (value & 1) == 0 else -1.0
+    return value % dim, sign
+
+
+@dataclass(frozen=True)
+class LocalEmbeddingModel:
+    """Deterministic local embedder.
+
+    This is intentionally not presented as a production semantic model. It is
+    a real, offline cosine signal for local-first operation and tests; setup
+    wizard provisioning can replace it with a user-consented model/provider.
+    """
+
+    dim: int = DEFAULT_EMBEDDING_DIM
+    model_id: str = EMBEDDING_MODEL_ID
+
+    def embed(self, text: str) -> List[float]:
+        vector = [0.0] * self.dim
+        features = _tokenize(text)
+        if not features:
+            return vector
+        for feature in features:
+            index, sign = _hash_to_index(feature, self.dim)
+            vector[index] += sign
+        norm = math.sqrt(sum(value * value for value in vector))
+        if norm <= 0:
+            return vector
+        return [value / norm for value in vector]
+
+    def similarity(self, left: Iterable[float], right: Iterable[float]) -> float:
+        return float(sum(a * b for a, b in zip(left, right)))
+
+    def encode(self, vector: Iterable[float]) -> bytes:
+        values = list(vector)
+        return struct.pack(f"<{len(values)}f", *values)
+
+    def decode(self, payload: bytes, dim: int | None = None) -> List[float]:
+        if not payload:
+            return []
+        count = int(dim or self.dim)
+        expected = count * 4
+        if len(payload) != expected:
+            count = len(payload) // 4
+        return list(struct.unpack(f"<{count}f", payload[: count * 4]))
+
+
+__all__ = ["DEFAULT_EMBEDDING_DIM", "EMBEDDING_MODEL_ID", "LocalEmbeddingModel"]

package/lattice_brain/identity.py

@@ -0,0 +1,13 @@
+from latticeai.brain.identity import (
+    DeviceIdentity,
+    fingerprint_of,
+    verify_manifest,
+    verify_signature,
+)
+
+__all__ = [
+    "DeviceIdentity",
+    "fingerprint_of",
+    "verify_manifest",
+    "verify_signature",
+]

package/lattice_brain/ingest.py

@@ -0,0 +1 @@
+from latticeai.brain.ingest import *  # noqa: F401,F403

package/lattice_brain/memory.py

@@ -0,0 +1,3 @@
+from latticeai.brain.memory import BrainMemory
+
+__all__ = ["BrainMemory"]

package/lattice_brain/network.py

@@ -0,0 +1 @@
+from latticeai.brain.network import *  # noqa: F401,F403

package/lattice_brain/projection.py

@@ -0,0 +1 @@
+from latticeai.brain.projection import *  # noqa: F401,F403

package/lattice_brain/provenance.py

@@ -0,0 +1 @@
+from latticeai.brain.provenance import *  # noqa: F401,F403

package/lattice_brain/retrieval.py

@@ -0,0 +1 @@
+from latticeai.brain.retrieval import *  # noqa: F401,F403

package/lattice_brain/schema.py

@@ -0,0 +1 @@
+from latticeai.brain.schema import *  # noqa: F401,F403

package/lattice_brain/storage/__init__.py

@@ -0,0 +1,22 @@
+"""Pluggable storage layer for lattice-brain."""
+
+from .base import StorageCapabilities, StorageEngine, StorageUnavailable
+from .docker import DockerPostgresPlan, DockerPostgresWizard
+from .factory import storage_from_env
+from .migration import SQLiteToPostgresMigrator, TablePlan
+from .postgres import PostgresConfig, PostgresEngine
+from .sqlite import SQLiteEngine
+
+__all__ = [
+    "DockerPostgresPlan",
+    "DockerPostgresWizard",
+    "PostgresConfig",
+    "PostgresEngine",
+    "SQLiteEngine",
+    "SQLiteToPostgresMigrator",
+    "StorageCapabilities",
+    "StorageEngine",
+    "StorageUnavailable",
+    "TablePlan",
+    "storage_from_env",
+]