brainiac-cli 0.20.0__tar.gz → 0.20.2__tar.gz

{brainiac_cli-0.20.0/src/brainiac_cli.egg-info → brainiac_cli-0.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainiac-cli
-Version: 0.20.0
+Version: 0.20.2
 Summary: Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index).
 License-Expression: Apache-2.0
 Requires-Python: >=3.9

{brainiac_cli-0.20.0 → brainiac_cli-0.20.2}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 # check. The IMPORT package stays `brain` and the console script stays
 # `brain` — only the distribution/project name changes.
 name = "brainiac-cli"
-version = "0.20.0"
+version = "0.20.2"
 description = "Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index)."
 readme = "README.md"
 license = "Apache-2.0"

{brainiac_cli-0.20.0 → brainiac_cli-0.20.2}/src/brain/_version.py

@@ -9,4 +9,4 @@ pip-installed host, importlib.metadata stays primary; brain/__init__.py reads
 this file only as the fallback before 0.0.0+unknown.
 """
 
-__version__ = "0.20.0"
+__version__ = "0.20.2"

{brainiac_cli-0.20.0 → brainiac_cli-0.20.2}/src/brain/core.py

@@ -548,11 +548,29 @@ class BrainCore:
         t0 = time.monotonic()
         embedder.embed("warmup")  # triggers the real load/download if needed
         elapsed = time.monotonic() - t0
+        # The RERANKER too, since 0.20.1: reranking is default-on (BR-03), and
+        # a search is no longer allowed to download its weights mid-query — it
+        # degrades to the unreranked order instead. Warmup is now the one place
+        # those weights are fetched, so warming only the embedder would leave a
+        # user permanently unreranked without ever saying why.
+        from .rerank import warm_reranker_weights
+
+        rerank_info: dict[str, Any]
+        try:
+            progress_note("warmup: resolving the reranker...",
+                          json_mode=json_mode, verb="warmup")
+            rerank_info = dict(warm_reranker_weights())
+        except Exception as exc:
+            # Never fail the embedder warm because the optional precision
+            # booster could not be fetched — report it and move on.
+            rerank_info = {"downloaded": False, "cached": False,
+                           "error": f"{type(exc).__name__}: {exc}"}
         progress_note(f"warmup: ready in {elapsed:.1f}s", json_mode=json_mode, verb="warmup")
         return {
             "model_id": embedder.model_id,
             "already_cached": bool(was_cached),
             "elapsed_s": round(elapsed, 2),
+            "reranker": rerank_info,
         }
 
     def drafts_dir(self) -> Path:

{brainiac_cli-0.20.0 → brainiac_cli-0.20.2}/src/brain/rerank.py

@@ -306,6 +306,44 @@ OPEN_DEFAULT_RERANKER_ONNX = "onnx/model.onnx"
 OPEN_DEFAULT_RERANKER_MODEL_ID = "Alibaba-NLP/gte-multilingual-reranker-base"
 
 
+def _reranker_weights_cached(hf_repo: str, onnx_file: str) -> bool:
+    """Are this reranker's weights already in the local HF cache?
+
+    Offline-only probe: `local_files_only=True` never opens a socket, so this
+    is safe to call on every search. Any failure (not cached, no hub package,
+    unreadable cache) answers False — the caller degrades to identity.
+    """
+    try:
+        from huggingface_hub import snapshot_download
+
+        snapshot_download(
+            hf_repo,
+            allow_patterns=[onnx_file, onnx_file + "_data", "tokenizer*", "*.json"],
+            local_files_only=True,
+        )
+        return True
+    except Exception:
+        return False
+
+
+def warm_reranker_weights() -> dict[str, object]:
+    """Download the reranker weights — the ONE place allowed to use the network
+    for them. Called by `brain warmup` beside the embedder warm, so a user who
+    warms up still gets reranking; a user who does not gets the unreranked
+    order instead of a surprise download mid-query."""
+    repo = OPEN_DEFAULT_RERANKER_REPO
+    onnx_file = OPEN_DEFAULT_RERANKER_ONNX
+    if _reranker_weights_cached(repo, onnx_file):
+        return {"repo": repo, "downloaded": False, "cached": True}
+    from huggingface_hub import snapshot_download
+
+    snapshot_download(
+        repo,
+        allow_patterns=[onnx_file, onnx_file + "_data", "tokenizer*", "*.json"],
+    )
+    return {"repo": repo, "downloaded": True, "cached": True}
+
+
 class OnnxReranker:
     """Any HuggingFace ONNX cross-encoder reranker loaded DIRECTLY via ONNX
     Runtime — no fastembed-catalog dependency, no PyTorch at runtime.
@@ -334,14 +372,34 @@ class OnnxReranker:
         self._in_names: list[str] | None = None
 
     @staticmethod
-    def available() -> bool:
+    def available(*, hf_repo: str | None = None, onnx_file: str | None = None) -> bool:
+        """Usable RIGHT NOW, WITHOUT the network.
+
+        This used to answer "are onnxruntime and tokenizers importable?", which
+        made `get_reranker("auto")` hand back a reranker whose `_ensure()` then
+        went and DOWNLOADED the cross-encoder mid-search. Once BR-03 made
+        reranking default-on, that turned every first `brain search` on a cold
+        machine into a model download — on a path that has no business touching
+        the network, including `BRAIN_EMBEDDER=hash` (which asks for no model at
+        all) and the Cowork VM (which has no HF egress). Measured 2026-08-07:
+        the distribution-matrix "offline retrieval smoke (no network)" job
+        downloaded 6 files on both macOS and Windows.
+
+        So availability now also requires the weights to be in the local cache.
+        Absent, this returns False, `get_reranker("auto")` returns NoopReranker,
+        and RET-02's skippable contract degrades retrieval to the unreranked
+        order cleanly — no exception, no per-query warning, no network. The one
+        sanctioned way to fetch the weights is `brain warmup`.
+        """
         try:
             import onnxruntime  # noqa: F401
             import tokenizers  # noqa: F401
-
-            return True
         except Exception:
             return False
+        if os.environ.get("BRAIN_RERANKER_ONNX_DIR"):
+            return True
+        return _reranker_weights_cached(hf_repo or OPEN_DEFAULT_RERANKER_REPO,
+                                       onnx_file or OPEN_DEFAULT_RERANKER_ONNX)
 
     def _ensure(self):
         if self._sess is None:
@@ -361,6 +419,12 @@ class OnnxReranker:
                 else:
                     from huggingface_hub import snapshot_download
 
+                    # local_files_only: belt AND braces. `available()` already
+                    # refuses to hand out this reranker uncached, but a caller
+                    # can construct OnnxReranker directly (tests, an explicit
+                    # BRAIN_RERANKER_PREFER=onnx), and a search must never open
+                    # a socket. Uncached => raises => RET-02 degrades to the
+                    # unreranked order. `brain warmup` is the download path.
                     base = snapshot_download(
                         self._hf_repo,
                         allow_patterns=[
@@ -369,6 +433,7 @@ class OnnxReranker:
                             "tokenizer*",
                             "*.json",
                         ],
+                        local_files_only=True,
                     )
                     onnx_path = os.path.join(base, self._onnx_file)
                 so = ort.SessionOptions()
@@ -471,8 +536,13 @@ def get_reranker(prefer: str = "noop") -> Reranker:
     # replaces the CC-BY-NC jina-reranker-v2). Preferred over the fastembed path.
     if OnnxReranker.available():
         return OnnxReranker()
-    if GteReranker.available():
-        return GteReranker()
+    # NOT GteReranker here any more (0.20.1). Its `available()` answers "is
+    # fastembed importable?", so auto used to fall through to it whenever the
+    # open ONNX weights were uncached — and it would then download from
+    # fastembed's own catalogue mid-search, which is the very thing this
+    # release stops. It is also the CC-BY-NC jina path, which auto should
+    # never reach for on its own. Still selectable deliberately, with
+    # `BRAIN_RERANKER_PREFER=gte` or `get_reranker("gte")`.
     return NoopReranker()
 
 

{brainiac_cli-0.20.0 → brainiac_cli-0.20.2/src/brainiac_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainiac-cli
-Version: 0.20.0
+Version: 0.20.2
 Summary: Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index).
 License-Expression: Apache-2.0
 Requires-Python: >=3.9