ltcai 4.3.1 → 4.4.0

package/latticeai/brain/store.py

@@ -1,237 +1,17 @@
-from __future__ import annotations
+"""Deprecated shim: physically moved to lattice_brain.graph.store.
 
-# ruff: noqa: F403,F405
+Kept only for the compatibility window. The module aliases itself to the
+physical module so identity, singletons, and monkeypatching are preserved.
+"""
 
-from ._kg_common import *  # noqa: F403,F401
-from .documents import KnowledgeGraphDocumentsMixin
-from .discovery import KnowledgeGraphDiscoveryMixin
-from .ingest import KnowledgeGraphIngestMixin
-from .projection import KnowledgeGraphProjectionMixin
-from .provenance import KnowledgeGraphProvenanceMixin
-from .retrieval import KnowledgeGraphRetrievalMixin
-from .write_master import KnowledgeGraphWriteMixin
+import sys
+import warnings
 
+import lattice_brain.graph.store as _impl
 
-class KnowledgeGraphStore(
-    KnowledgeGraphProjectionMixin,
-    KnowledgeGraphWriteMixin,
-    KnowledgeGraphDiscoveryMixin,
-    KnowledgeGraphIngestMixin,
-    KnowledgeGraphProvenanceMixin,
-    KnowledgeGraphDocumentsMixin,
-    KnowledgeGraphRetrievalMixin,
-):
-    def __init__(
-        self,
-        db_path: Path,
-        blob_dir: Path,
-        embedder: Any = None,
-        storage_engine: Any = None,
-    ):
-        self.db_path = Path(db_path)
-        self.blob_dir = Path(blob_dir)
-        self.db_path.parent.mkdir(parents=True, exist_ok=True)
-        self.blob_dir.mkdir(parents=True, exist_ok=True)
-        if storage_engine is None:
-            from lattice_brain.storage import SQLiteEngine
-
-            storage_engine = SQLiteEngine(self.db_path)
-        storage_caps = storage_engine.capabilities()
-        if not storage_caps.available:
-            raise RuntimeError(storage_caps.reason or "Brain storage is unavailable.")
-        if storage_caps.engine != "sqlite":
-            raise RuntimeError(
-                "KnowledgeGraphStore currently requires SQLiteEngine. "
-                "Explicit non-SQLite storage must use the migration/scale tooling; "
-                "no SQLite fallback is attempted."
-            )
-        self.storage_engine = storage_engine
-        # The embedder is swappable behind a fixed interface
-        # (model_id/dim/embed/encode/decode/similarity). Defaults to the
-        # deterministic, offline hash model so the store works with no config;
-        # server_app injects a provider-backed embedder from Config.
-        self._embedding_model = (
-            embedder if embedder is not None else LocalEmbeddingModel()
-        )
-        self._v2_projection_available = False
-        self._init_db()
-        # Read graph queries from the v2 projection (kgv2_* views) when available.
-        # Toggle off (e.g. in tests) to compare against the legacy tables.
-        self._read_from_v2 = (
-            KGStoreV2 is not None
-            and _READ_FROM_V2_DEFAULT
-            and self._v2_projection_available
-        )
-
-    def _read_tables(self) -> tuple:
-        """Return (nodes_table, edges_table) for read queries.
-
-        Same read code runs against the legacy tables or the v2 reconstruction
-        views, so the two paths are equivalent by construction.
-        """
-        if self._read_from_v2:
-            return ("kgv2_nodes", "kgv2_edges")
-        return ("nodes", "edges")
-
-    def _connect(self) -> sqlite3.Connection:
-        return self.storage_engine.connect()
-
-    def _init_db(self) -> None:
-        with self._connect() as conn:
-            db_format = int(conn.execute("PRAGMA user_version").fetchone()[0] or 0)
-            if db_format > _KG_DB_FORMAT_VERSION:
-                raise RuntimeError(
-                    f"Knowledge Graph DB format {db_format} is newer than this build "
-                    f"({_KG_DB_FORMAT_VERSION}); restore a pre-upgrade backup or upgrade Lattice AI."
-                )
-            conn.executescript(
-                """
-                    CREATE TABLE IF NOT EXISTS graph_meta (
-                      key TEXT PRIMARY KEY,
-                      value TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS nodes (
-                      id TEXT PRIMARY KEY,
-                      type TEXT NOT NULL,
-                      title TEXT NOT NULL,
-                      summary TEXT,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      raw_json TEXT NOT NULL CHECK (json_valid(raw_json)),
-                      created_at TEXT NOT NULL,
-                      updated_at TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS edges (
-                      id TEXT PRIMARY KEY,
-                      from_node TEXT NOT NULL,
-                      to_node TEXT NOT NULL,
-                      type TEXT NOT NULL,
-                      weight REAL NOT NULL DEFAULT 1.0,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL,
-                      UNIQUE(from_node, to_node, type),
-                      FOREIGN KEY(from_node) REFERENCES nodes(id) ON DELETE CASCADE,
-                      FOREIGN KEY(to_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS chunks (
-                      id TEXT PRIMARY KEY,
-                      source_node TEXT NOT NULL,
-                      text TEXT NOT NULL,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL,
-                      FOREIGN KEY(source_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS knowledge_sources (
-                      id TEXT PRIMARY KEY,
-                      root_path TEXT NOT NULL UNIQUE,
-                      os_type TEXT NOT NULL,
-                      drive_id TEXT,
-                      label TEXT,
-                      status TEXT NOT NULL,
-                      include_ocr INTEGER NOT NULL DEFAULT 0,
-                      watch_enabled INTEGER NOT NULL DEFAULT 0,
-                      consent_json TEXT NOT NULL CHECK (json_valid(consent_json)),
-                      created_at TEXT NOT NULL,
-                      updated_at TEXT NOT NULL,
-                      last_scanned_at TEXT
-                    );
-                    CREATE TABLE IF NOT EXISTS local_file_index (
-                      id TEXT PRIMARY KEY,
-                      source_id TEXT NOT NULL,
-                      os_type TEXT NOT NULL,
-                      drive_id TEXT,
-                      root_path TEXT NOT NULL,
-                      file_path TEXT NOT NULL,
-                      relative_path TEXT NOT NULL,
-                      file_name TEXT NOT NULL,
-                      extension TEXT NOT NULL,
-                      size_bytes INTEGER,
-                      modified_at TEXT,
-                      sha256 TEXT,
-                      last_scanned_at TEXT,
-                      last_indexed_at TEXT,
-                      parser_type TEXT,
-                      status TEXT NOT NULL,
-                      error_message TEXT,
-                      graph_node_id TEXT,
-                      deleted INTEGER NOT NULL DEFAULT 0,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      UNIQUE(source_id, relative_path),
-                      FOREIGN KEY(source_id) REFERENCES knowledge_sources(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS vector_embeddings (
-                      item_id TEXT PRIMARY KEY,
-                      item_type TEXT NOT NULL,
-                      source_node TEXT NOT NULL,
-                      text_hash TEXT NOT NULL,
-                      embedding BLOB NOT NULL,
-                      embedding_dim INTEGER NOT NULL,
-                      embedding_model TEXT NOT NULL,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      indexed_at TEXT NOT NULL,
-                      FOREIGN KEY(source_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS vector_index_operations (
-                      id TEXT PRIMARY KEY,
-                      operation TEXT NOT NULL,
-                      status TEXT NOT NULL,
-                      requested_at TEXT NOT NULL,
-                      started_at TEXT,
-                      completed_at TEXT,
-                      items_total INTEGER NOT NULL DEFAULT 0,
-                      items_indexed INTEGER NOT NULL DEFAULT 0,
-                      items_skipped INTEGER NOT NULL DEFAULT 0,
-                      error_message TEXT,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json))
-                    );
-                    -- v3.6.0 Knowledge Graph First: per-ingestion provenance trail.
-                    -- Append-only audit of where every graph node came from, when it
-                    -- was captured, how it was processed, and whether it was embedded /
-                    -- linked / used by an agent. get_provenance() returns the latest row.
-                    CREATE TABLE IF NOT EXISTS ingestion_provenance (
-                      id TEXT PRIMARY KEY,
-                      node_id TEXT NOT NULL,
-                      source_type TEXT NOT NULL,
-                      source_uri TEXT,
-                      content_hash TEXT,
-                      title TEXT,
-                      pipeline TEXT NOT NULL,
-                      owner TEXT,
-                      workspace_id TEXT,
-                      captured_at TEXT,
-                      modified_at TEXT,
-                      embedded INTEGER NOT NULL DEFAULT 0,
-                      linked INTEGER NOT NULL DEFAULT 0,
-                      duplicate INTEGER NOT NULL DEFAULT 0,
-                      agent_used TEXT,
-                      chunk_count INTEGER NOT NULL DEFAULT 0,
-                      permissions_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(permissions_json)),
-                      metadata_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL
-                    );
-                    CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
-                    CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_node);
-                    CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_node);
-                    CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source_node);
-                    CREATE INDEX IF NOT EXISTS idx_knowledge_sources_root ON knowledge_sources(root_path);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_source ON local_file_index(source_id);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_status ON local_file_index(status);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_graph_node ON local_file_index(graph_node_id);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_type ON vector_embeddings(item_type);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_source ON vector_embeddings(source_node);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_model ON vector_embeddings(embedding_model);
-                    CREATE INDEX IF NOT EXISTS idx_vector_index_operations_requested ON vector_index_operations(requested_at);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_node ON ingestion_provenance(node_id);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_source_type ON ingestion_provenance(source_type);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_hash ON ingestion_provenance(content_hash);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_created ON ingestion_provenance(created_at);
-                    """
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO graph_meta(key, value) VALUES (?, ?)",
-                ("schema_version", str(GRAPH_SCHEMA_VERSION)),
-            )
-        self._init_v2_schema()
-        self._init_fts()
-
-
-__all__ = ["KnowledgeGraphStore"]
+warnings.warn(
+    "latticeai.brain.store is deprecated; import lattice_brain.graph.store instead",
+    DeprecationWarning,
+    stacklevel=2,
+)
+sys.modules[__name__] = _impl

package/latticeai/brain/write_master.py

@@ -1,225 +1,17 @@
-from __future__ import annotations
+"""Deprecated shim: physically moved to lattice_brain.graph.write_master.
 
-# ruff: noqa: F403,F405
+Kept only for the compatibility window. The module aliases itself to the
+physical module so identity, singletons, and monkeypatching are preserved.
+"""
 
-from ._kg_common import *  # noqa: F403,F401
+import sys
+import warnings
 
+import lattice_brain.graph.write_master as _impl
 
-class KnowledgeGraphWriteMixin:
-    def _upsert_node(
-        self,
-        conn: sqlite3.Connection,
-        node_id: str,
-        node_type: str,
-        title: str,
-        summary: str = "",
-        metadata: Optional[Dict[str, Any]] = None,
-        raw: Optional[Dict[str, Any]] = None,
-        owner: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        visibility: Optional[str] = None,
-    ) -> str:
-        now = _now()
-        # v4 write-mastering: nodes_v2 is authoritative; the legacy nodes
-        # table is maintained as the compatibility projection.
-        title_s = title[:240]
-        summary_s = summary[:1000]
-        meta_json = _json(metadata)
-        self._v2_project_node(
-            conn,
-            node_id,
-            node_type,
-            title_s,
-            summary_s,
-            meta_json,
-            created_at=now,
-            updated_at=now,
-            owner=owner,
-            workspace_id=workspace_id,
-            visibility=visibility,
-            strict=True,
-        )
-        conn.execute(
-            """
-                INSERT INTO nodes(id, type, title, summary, metadata_json, raw_json, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(id) DO UPDATE SET
-                  title=excluded.title,
-                  summary=excluded.summary,
-                  metadata_json=excluded.metadata_json,
-                  raw_json=excluded.raw_json,
-                  updated_at=excluded.updated_at
-                """,
-            (node_id, node_type, title_s, summary_s, meta_json, _json(raw), now, now),
-        )
-        if node_type != "Chunk":
-            self._upsert_vector_item(
-                conn,
-                item_id=node_id,
-                item_type="node",
-                source_node=node_id,
-                text=self._vector_text_for_node(
-                    title=title_s, summary=summary_s, metadata=metadata
-                ),
-                metadata={"node_type": node_type, **(metadata or {})},
-            )
-        return node_id
-
-    def _upsert_edge(
-        self,
-        conn: sqlite3.Connection,
-        from_node: str,
-        to_node: str,
-        edge_type: str,
-        weight: float = 1.0,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> str:
-        # v4 write door: every new edge stores the canonical EdgeType value —
-        # free-string types (e.g. '포함함', '언급함') are normalized here, so no
-        # caller can mint new legacy taxonomy. The original label survives in
-        # metadata.legacy_label for traceability.
-        if EdgeType is not None:
-            canonical = EdgeType.from_legacy(edge_type).value
-            if canonical != edge_type:
-                metadata = dict(metadata or {})
-                metadata.setdefault("legacy_label", edge_type)
-            edge_type = canonical
-        edge_id = f"edge:{_sha256_text(f'{from_node}|{edge_type}|{to_node}')[:24]}"
-        now = _now()
-        meta_json = _json(metadata)  # canonical string shared with the projection
-        self._v2_project_edge(
-            conn,
-            from_node,
-            to_node,
-            edge_type,
-            float(weight),
-            meta_json,
-            edge_id=edge_id,
-            created_at=now,
-            strict=True,
-        )
-        conn.execute(
-            """
-                INSERT INTO edges(id, from_node, to_node, type, weight, metadata_json, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(from_node, to_node, type) DO UPDATE SET
-                  weight=max(edges.weight, excluded.weight),
-                  metadata_json=excluded.metadata_json
-                """,
-            (edge_id, from_node, to_node, edge_type, float(weight), meta_json, now),
-        )
-        return edge_id
-
-    def _vector_text_for_node(
-        self,
-        *,
-        title: str,
-        summary: str = "",
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> str:
-        metadata = metadata or {}
-        meta_parts = []
-        for key in (
-            "filename",
-            "relative_path",
-            "file_path",
-            "conversation_id",
-            "source",
-            "category",
-            "ext",
-            "role",
-        ):
-            value = metadata.get(key)
-            if value:
-                meta_parts.append(str(value))
-        return _clean_text(
-            "\n".join([str(title or ""), str(summary or ""), " ".join(meta_parts)])
-        )
-
-    def _upsert_vector_item(
-        self,
-        conn: sqlite3.Connection,
-        *,
-        item_id: str,
-        item_type: str,
-        source_node: str,
-        text: str,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> bool:
-        text = _clean_text(text)
-        if len(text) < 2:
-            conn.execute("DELETE FROM vector_embeddings WHERE item_id=?", (item_id,))
-            return False
-        text_hash = _sha256_text(text)
-        existing = conn.execute(
-            """
-                SELECT text_hash, embedding_dim, embedding_model
-                FROM vector_embeddings
-                WHERE item_id=?
-                """,
-            (item_id,),
-        ).fetchone()
-        if (
-            existing
-            and existing["text_hash"] == text_hash
-            and existing["embedding_dim"] == self._embedding_model.dim
-            and existing["embedding_model"] == self._embedding_model.model_id
-        ):
-            return False
-        embedding = self._embedding_model.encode(
-            self._embedding_model.embed(text[:50_000])
-        )
-        conn.execute(
-            """
-                INSERT INTO vector_embeddings(
-                  item_id, item_type, source_node, text_hash, embedding,
-                  embedding_dim, embedding_model, metadata_json, indexed_at
-                )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(item_id) DO UPDATE SET
-                  item_type=excluded.item_type,
-                  source_node=excluded.source_node,
-                  text_hash=excluded.text_hash,
-                  embedding=excluded.embedding,
-                  embedding_dim=excluded.embedding_dim,
-                  embedding_model=excluded.embedding_model,
-                  metadata_json=excluded.metadata_json,
-                  indexed_at=excluded.indexed_at
-                """,
-            (
-                item_id,
-                item_type,
-                source_node,
-                text_hash,
-                embedding,
-                self._embedding_model.dim,
-                self._embedding_model.model_id,
-                _json(metadata),
-                _now(),
-            ),
-        )
-        return True
-
-    def _upsert_chunk(
-        self,
-        conn: sqlite3.Connection,
-        *,
-        chunk_id: str,
-        source_node: str,
-        text: str,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        metadata = metadata or {}
-        conn.execute(
-            "INSERT OR REPLACE INTO chunks(id, source_node, text, metadata_json, created_at) "
-            "VALUES (?, ?, ?, ?, ?)",
-            (chunk_id, source_node, text, _json(metadata), _now()),
-        )
-        self._upsert_vector_item(
-            conn,
-            item_id=chunk_id,
-            item_type="chunk",
-            source_node=chunk_id,
-            text=text,
-            metadata={**metadata, "parent_source_node": source_node},
-        )
+warnings.warn(
+    "latticeai.brain.write_master is deprecated; import lattice_brain.graph.write_master instead",
+    DeprecationWarning,
+    stacklevel=2,
+)
+sys.modules[__name__] = _impl

package/latticeai/core/agent.py

@@ -29,7 +29,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, FrozenSet, List, Optional
 
-from latticeai.core.hooks import dispatch_tool
+from lattice_brain.runtime.hooks import dispatch_tool
 from tools import ToolError
 
 

package/latticeai/core/agent_registry.py

@@ -8,7 +8,7 @@ first-class entry with stable metadata: ``id``, ``type``, ``version``,
 the /app views read this registry instead of any hardcoded list.
 
 Built-in role agents are projected from the single source of truth in
-:mod:`latticeai.core.multi_agent` (so adding a role there flows through here).
+:mod:`lattice_brain.runtime.multi_agent` (so adding a role there flows through here).
 Custom agents and config overrides are persisted to
 ``data_dir/agent_registry.json``.
 """
@@ -22,7 +22,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from latticeai.core.multi_agent import (
+from lattice_brain.runtime.multi_agent import (
     AGENT_ROLES,
     CORE_PIPELINE,
     MULTI_AGENT_VERSION,

package/latticeai/core/builtin_hooks.py

@@ -1,11 +1,11 @@
 """Real runners for the built-in lifecycle hooks.
 
-Each built-in hook in :data:`latticeai.core.hooks.BUILTIN_HOOKS` is bound here to
+Each built-in hook in :data:`lattice_brain.runtime.hooks.BUILTIN_HOOKS` is bound here to
 an actual callable so dispatch performs real platform work rather than a silent
 no-op. Kept out of ``server_app`` to keep the assembly file lean; ``server_app``
 calls :func:`register_builtin_hook_runners` once with the platform dependencies.
 
-A runner receives a :class:`~latticeai.core.hooks.HookContext` and returns a
+A runner receives a :class:`~lattice_brain.runtime.hooks.HookContext` and returns a
 status dict (``{status, output, block?, detail?}``). It may mutate the context
 payload (e.g. redaction) or call ``context.block()`` to gate a ``pre_*`` action.
 """