style: black format 4 files — CI black --check fix

Author: Flamehaven CI

flamehaven_filesearch/_search_local.py

@@ -10,7 +10,11 @@
 from urllib.parse import quote
 
 from .engine.hybrid_search import BM25, reciprocal_rank_fusion
-from .engine.quality_gate import SearchQualityGate, SearchMetaLearner, compute_search_confidence
+from .engine.quality_gate import (
+    SearchQualityGate,
+    SearchMetaLearner,
+    compute_search_confidence,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -100,18 +104,13 @@ def _resolve_fused_docs(
     def _run_hybrid_rerank(
         self, store_name: str, query: str, semantic_results: List
     ) -> Tuple[List[Dict[str, Any]], float]:
-        """BM25 + ChronosGrid semantic -> RRF -> resolved docs + confidence score.
-
-        Returns:
-            (resolved_docs, confidence) where confidence is rank-divergence-gated [0, 1].
-        """
+        """BM25 + ChronosGrid semantic -> RRF -> resolved docs + confidence score."""
         if store_name not in self._bm25_indices or store_name in self._bm25_dirty:
             self._rebuild_bm25(store_name)
 
         # alpha->0 (keyword-dominant): expand BM25 pool; alpha->1: contract it.
         alpha = (getattr(self, "_meta_alpha", {})).get(store_name, 0.5)
-        bm25_multiplier = max(0.5, 1.5 - alpha)  # alpha=0.2->1.3x, 0.5->1.0x, 0.8->0.7x
-        bm25_top_k = max(1, int(self.config.max_sources * 2 * bm25_multiplier))
+        bm25_top_k = int(self.config.max_sources * 2 * max(0.5, 1.5 - alpha))
 
         bm25_ranked = self._collect_bm25_ranked(store_name, query, bm25_top_k)
         sem_ranked = self._collect_sem_ranked(store_name, semantic_results)
@@ -120,11 +119,10 @@ def _run_hybrid_rerank(
             [sem_ranked, bm25_ranked], k=60, top_k=self.config.max_sources
         )
 
-        bm25_uri_set = {r["id"] for r in bm25_ranked}
-        sem_uri_set = {r["id"] for r in sem_ranked}
         raw_score = fused[0]["score"] if fused else 0.0
-        confidence = compute_search_confidence(raw_score, bm25_uri_set, sem_uri_set)
-
+        confidence = compute_search_confidence(
+            raw_score, {r["id"] for r in bm25_ranked}, {r["id"] for r in sem_ranked}
+        )
         return self._resolve_fused_docs(store_name, fused), confidence
 
     # ------------------------------------------------------------------
@@ -186,22 +184,28 @@ def _local_search(
         }
 
         if not docs:
-            result = {
+            res = {
                 "status": "success",
                 "answer": "No documents indexed yet.",
                 "sources": [],
                 **base,
             }
             if search_mode in ["semantic", "hybrid", "multimodal"]:
-                result["semantic_results"] = semantic_results or []
-            return result
+                res["semantic_results"] = semantic_results or []
+            return res
 
-        quality_gate: SearchQualityGate = getattr(self, "_quality_gate", SearchQualityGate())
-        meta_learner: SearchMetaLearner = getattr(self, "_meta_learner", SearchMetaLearner())
+        quality_gate: SearchQualityGate = getattr(
+            self, "_quality_gate", SearchQualityGate()
+        )
+        meta_learner: SearchMetaLearner = getattr(
+            self, "_meta_learner", SearchMetaLearner()
+        )
 
         # Hybrid: BM25 + semantic RRF with quality gate
         if search_mode == "hybrid" and semantic_results:
-            fused_docs, confidence = self._run_hybrid_rerank(store_name, query, semantic_results)
+            fused_docs, confidence = self._run_hybrid_rerank(
+                store_name, query, semantic_results
+            )
             verdict = quality_gate.evaluate(confidence)
 
             if fused_docs:
@@ -270,7 +274,9 @@ def _local_search(
             result["semantic_results"] = semantic_results or []
         return result
 
-    def _run_meta_adapt(self, store_name: str, meta_learner: "SearchMetaLearner") -> None:
+    def _run_meta_adapt(
+        self, store_name: str, meta_learner: "SearchMetaLearner"
+    ) -> None:
         """Apply MetaLearner alpha recommendation when adaptation cycle triggers."""
         if not meta_learner.should_adapt():
             return
@@ -282,7 +288,10 @@ def _run_meta_adapt(self, store_name: str, meta_learner: "SearchMetaLearner") ->
             self._meta_alpha[store_name] = new_alpha
             logger.info(
                 "[QualityGate] store=%s alpha %.3f -> %.3f trend=%s",
-                store_name, current, new_alpha, meta_learner.store_trend(store_name),
+                store_name,
+                current,
+                new_alpha,
+                meta_learner.store_trend(store_name),
             )
 
     # ------------------------------------------------------------------
@@ -313,7 +322,8 @@ def _resolve_semantic_sources(
         if not resolved:
             return None
         snippets = [
-            self._build_snippet(d.get("content", ""), query) or d.get("content", "")[:200]
+            self._build_snippet(d.get("content", ""), query)
+            or d.get("content", "")[:200]
             for d in resolved[:5]
         ]
         answer = " ".join(s for s in snippets if s) or (

flamehaven_filesearch/engine/__init__.py

@@ -12,7 +12,11 @@
 from .parse_cache import get as parse_cache_get
 from .parse_cache import put as parse_cache_put
 from .parse_cache import stats as parse_cache_stats
-from .quality_gate import SearchQualityGate, SearchMetaLearner, compute_search_confidence
+from .quality_gate import (
+    SearchQualityGate,
+    SearchMetaLearner,
+    compute_search_confidence,
+)
 
 __all__ = [
     "BM25",

flamehaven_filesearch/engine/quality_gate.py

@@ -7,19 +7,20 @@
   LEDA 4.0.1 forge_loop.py        -> FORGE retry concept in SearchQualityGate
   LEDA 4.0.1 meta_learning.py     -> SearchMetaLearner
 
-Zero new dependencies: only Python stdlib (math, statistics).
+Zero new dependencies: only Python stdlib (statistics).
 """
+
 from __future__ import annotations
 
 import statistics
 from typing import Dict, List, Set, Tuple
 
 # -- Tuning constants (analogous to LOGOS jsd_gate=0.06, LEDA theta_low/high) --
-_DIV_GATE: float = 0.50    # Jaccard divergence at which confidence halves
+_DIV_GATE: float = 0.50  # Jaccard divergence at which confidence halves
 _THETA_PASS: float = 0.75  # confidence above this -> PASS
-_THETA_FORGE: float = 0.45 # confidence above this (but <= PASS) -> FORGE
-_ADAPT_EVERY: int = 100    # queries between MetaLearner adaptation cycles
-_MOMENTUM: float = 0.70    # EMA weight on current alpha (LEDA ema_alpha=0.30 complement)
+_THETA_FORGE: float = 0.45  # confidence above this (but <= PASS) -> FORGE
+_ADAPT_EVERY: int = 100  # queries between MetaLearner adaptation cycles
+_MOMENTUM: float = 0.70  # EMA weight on current alpha (LEDA ema_alpha=0.30 complement)
 
 
 def compute_search_confidence(
@@ -157,9 +158,7 @@ def recommend_alpha(self, store_name: str, current_alpha: float = 0.5) -> float:
         for mode, conf in entries:
             by_mode.setdefault(mode, []).append(conf)
 
-        avg: Dict[str, float] = {
-            m: statistics.mean(v) for m, v in by_mode.items() if v
-        }
+        avg: Dict[str, float] = {m: statistics.mean(v) for m, v in by_mode.items() if v}
 
         sem_avg = avg.get("semantic", avg.get("hybrid", current_alpha))
         kw_avg = avg.get("keyword", current_alpha)

tests/test_quality_gate.py

@@ -2,14 +2,14 @@
 Tests for engine/quality_gate.py
 Covers: compute_search_confidence, SearchQualityGate, SearchMetaLearner.
 """
+
 import pytest
 from flamehaven_filesearch.engine.quality_gate import (
     SearchMetaLearner,
     SearchQualityGate,
     compute_search_confidence,
 )
 
-
 # ---------------------------------------------------------------------------
 # compute_search_confidence
 # ---------------------------------------------------------------------------