Update app.py

app.py

@@ -21,6 +21,7 @@ MEMORY_MANIFEST = {
 import os, sys, re, json, time, shutil, tempfile, subprocess, platform, socket, threading, importlib, hashlib, unicodedata, urllib.request, base64
 from dataclasses import dataclass
 from typing import Optional, List, Dict, Tuple
+from pathlib import Path as _Path
 # ----------- light bootstrap (safe) -----------
 def _ensure(pkgs: List[str]):
     for p in pkgs: # type: ignore
@@ -527,6 +528,27 @@ class ASRService:
     """Handles ASR, including transcription and language detection."""
     def __init__(self):
         self.model = get_asr()
+
+    def transcribe(self, audio_path: str, uid: Optional[str], forced_lang: Optional[str] = None) -> dict:
+        prior = _load_json(ADAPT_DB, {}).get(uid or "guest", {}).get("lang_prior")
+        language = forced_lang or prior or None
+        segs, info = self.model.transcribe(audio_path, language=language, beam_size=5, vad_filter=True)
+        text = " ".join([s.text for s in segs]).strip()
+
+        detected_lang = info.language
+        if not forced_lang and text:
+            prof = _load_json(ADAPT_DB, {})
+            p = prof.get(uid or "guest", {})
+            p["lang_prior"] = detected_lang
+            prof[uid or "guest"] = p
+            _save_json(ADAPT_DB, prof)
+
+        return {"text": text, "language": detected_lang, "confidence": info.language_probability, "segments": [{"start": s.start, "end": s.end, "text": s.text} for s in segs]}
+
+class ASRService_placeholder:
+    """Handles ASR, including transcription and language detection."""
+    def __init__(self):
+        self.model = get_asr()
 ASR_MODELS={"tiny":"tiny","base":"base","small":"small","medium":"medium","large":"large-v3"}
 def _asr_model_name(): return ASR_MODELS.get(CFG["VOICE_ASR_MODEL"],"small")
 _ASR=None
@@ -948,6 +970,14 @@ class VideoService(threading.Thread):
         while not self.stop_event.is_set():
             time.sleep(1)
 
+class EngineCurve:
+    def __init__(self):
+        self.stats={"runs":0,"ok":0,"latency_ms":[]}
+        self.router_rules=[]
+    def choose_route(self, msg:str)->str:
+        # This is a simplified version. The full logic is now in IntentRouter.
+        return "tutor"
+    def run(self, message:str, snippets:List[Dict])->Dict: return {"ok":True,"route":"tutor"}
 # ----------- wifi auto-connect (non-blocking) -----------
 NET_STATE_DB=os.path.join(CFG["STATE_DIR"],"wifi_known.json")
 
@@ -1404,6 +1434,13 @@ class SelfOptimizerModule(SelfOptimizer, IModule):
         IModule.__init__(self, hive_instance)
         SelfOptimizer.__init__(self, hive_instance)
 
+class LibrarianModule(LibrarianCurve, IModule):
+    def __init__(self, hive_instance: "Hive"):
+        IModule.__init__(self, hive_instance)
+        LibrarianCurve.__init__(self, hive_instance.store, hive_instance.k_store)
+        hive_instance.retrieval_k=6
+        hive_instance.web_threshold=0.40
+
 class PersistenceEngine(IModule):
     """Implements the PersistenceEngine from Part 1, Section 7.9."""
     def __init__(self, hive_instance: "Hive"):
@@ -1554,6 +1591,7 @@ class Hive:
         self.module_manager.register("compiler", CompilerModule(self))
         self.module_manager.register("selfopt", SelfOptimizerModule(self))
         self.module_manager.register("voice_video", VoiceServicesModule(self))
+        self.module_manager.register("engine", EngineModule(self))
         self.module_manager.register("persistence", PersistenceEngine(self))
         self.module_manager.register("kstore", KnowledgeStoreModule(self))
         self.dialogue_manager = DialogueManager(self)
@@ -1609,19 +1647,19 @@ class Hive:
             self.pipe = pipeline("text-generation", model=self.model, tokenizer=self.tok, device=self.device, stopping_criteria=self.stopping_criteria)
 
     @property
-    def store(self) -> CurveStore: return self.module_manager.modules["store"] # type: ignore
+    def store(self) -> 'CurveStore': return self.module_manager.modules["store"] # type: ignore
     @property
     def librarian(self) -> 'LibrarianCurve': return self.module_manager.modules["librarian"] # type: ignore
     @property
-    def engine(self) -> EngineCurve: return self.module_manager.modules["engine"] # type: ignore
+    def engine(self) -> 'EngineCurve': return self.module_manager.modules["engine"] # type: ignore
     @property
-    def overlay(self) -> RuntimeOverlay: return self.module_manager.modules["overlay"] # type: ignore
+    def overlay(self) -> 'RuntimeOverlay': return self.module_manager.modules["overlay"] # type: ignore
     @property
-    def changes(self) -> ChangeManager: return self.module_manager.modules["changes"] # type: ignore
+    def changes(self) -> 'ChangeManager': return self.module_manager.modules["changes"] # type: ignore
     @property
-    def compiler(self) -> PromptCompiler: return self.module_manager.modules["compiler"] # type: ignore
+    def compiler(self) -> 'PromptCompiler': return self.module_manager.modules["compiler"] # type: ignore
     @property
-    def selfopt(self) -> SelfOptimizer: return self.module_manager.modules["selfopt"] # type: ignore
+    def selfopt(self) -> 'SelfOptimizer': return self.module_manager.modules["selfopt"] # type: ignore
 
     def _prepare_chat_input(self, message: str, user_lang: str, phonics_on: bool, prompt_override: str | None) -> tuple[str, str]:
         """Determines intent and prepares the final message for the LLM."""
@@ -2404,6 +2442,7 @@ class Bootstrap:
         self.hive_instance: Optional[Hive] = None
         self.hive_lite_instance: Optional[Hive] = None
         self.hive_ready = threading.Event()
+        self.voice_ready = threading.Event()
         self.env: Optional[Dict] = None
         self.app: Optional[gr.Blocks] = None
         self.ui_thread: Optional[threading.Thread] = None
@@ -2438,12 +2477,14 @@ class Bootstrap:
         # but for now, we'll keep it for immediate responsiveness.
         if self.caps.get("is_low_memory"):
             print("[Bootstrap] Low memory mode: Lite instance will be minimal.")
+        self.hive_lite_instance = Hive(lite=True)
 
         self.video_service = VideoService()
         print("[Bootstrap] Lite Hive core is ready.")
 
         # Now initialize the full instance in the background. This is the slow part.
         def full_init_task():
+            # Voice init is part of the full core setup
             print("[Bootstrap] Initializing Full Hive core in background...")
             Hive.bootstrap_instance = self
             self.hive_instance = Hive(lite=False)
@@ -2451,12 +2492,17 @@ class Bootstrap:
             self.hive_instance.embedding_worker.start()
             self.hive_ready.set() # Signal that the full Hive instance is ready
             self.setup_memory()
+
+            print("[Bootstrap] Initializing Voice models (ASR/TTS) in background...")
+            get_asr()
+            get_tts(CFG["TTS_LANG"])
+            self.voice_ready.set()
+            print("[Bootstrap] Voice models are ready.")
+
             print("[Bootstrap] Full Hive core is ready.")
 
         self.ui_thread = threading.Thread(target=self.launch, daemon=True)
-
         threading.Thread(target=full_init_task, daemon=True).start()
-
         # Register graceful shutdown handler and launch the UI in the main thread
         import signal
         signal.signal(signal.SIGINT, self.graceful_shutdown)
@@ -2537,14 +2583,6 @@ class Bootstrap:
         print("[Bootstrap] Exiting.")
         sys.exit(0)
 
-# ----------- entry -----------
-class KnowledgeStoreModule(KnowledgeStore, IModule):
-    def __init__(self, hive_instance: "Hive"):
-        IModule.__init__(self, hive_instance)
-        KnowledgeStore.__init__(self, hive_instance.config["HIVE_HOME"])
-    def start(self): pass
-    def stop(self): pass
-
 if __name__=="__main__":
     bootstrap = Bootstrap(CFG)
     bootstrap.run()