Refactor: Modernize Memory Vault UI and enhance stability

This commit introduces a significant UI overhaul for the Memory Vault screens, focusing on a cleaner, more modern, and consistent design. It also enhances stability by improving vault initialization and adding a tool-calling bypass.

### UI Modernization

The `VaultDataExplorer`, `VaultStatsOverview`, and `VaultManagement` screens have been completely redesigned with a cohesive and modern aesthetic:

-   **Consistent Components:** Replaced custom layouts with standardized `Surface`-based cards, chips, and components for a unified look.
-   **Improved Layout:** Adopted a more spacious and organized layout using consistent padding, arrangement, and typography (`ManropeFontFamily`).
-   **`VaultDashboard`:** Replaced the navigation drawer with a top-level `ActionToggleGroup` for quicker switching between Explorer, Manage, Logs, and Debug tabs.
-   **`VaultDataExplorer`:**
    -   Redesigned data cards (`DataCard`) to be more compact and informative.
    -   Simplified filter chips, now including item counts directly.
    -   Removed the top search bar for a cleaner browsing experience.
    -   Updated the detail sheet with a more organized and modern layout.
-   **`VaultStatsOverview` & `VaultManagement`:**
    -   Refactored all stat cards (`StorageCard`, `QuickStats`, `ContentBreakdown`) to be more visually appealing and data-dense.
    -   Redesigned the management tools ("Defragment", "Backup", etc.) into cleaner `ToolCard` components, with a dedicated "Danger Zone" for destructive actions.
    -   Simplified chat list items for better readability.

### Features & Enhancements

-   **Tool-Calling Bypass:**
    -   Added a new "Bypass Model Check" option in Settings.
    -   When enabled, this allows any loaded model to attempt tool-calling, which is useful for models not explicitly marked as supporting it. A warning card accompanies this setting.
-   **LaTeX Rendering Improvements:**
    -   Significantly expanded LaTeX support in Markdown rendering to parse and display tables from `tabular`, `table`, and `array` environments.
    -   Added extensive support for over 500 AMS-LaTeX symbols, negated relations, and various font commands (`\mathfrak`, `\mathscr`, `\mathsf`, `\mathtt`).
    -   Improved parsing of multi-line math blocks and various LaTeX commands (`\overbrace`, `\cancel`, `\boxed`, etc.).

### Stability and Bug Fixes

-   **Robust Vault Initialization:**
    -   Refactored `VaultHelper` and `ChatManager` to ensure the vault is properly initialized before any operations are performed.
    -   Introduced `VaultHelper.awaitReady()` to prevent race conditions and crashes if the UI tries to access the vault before it's ready.
-   **Navigation Fix:** Correctly passed the `onNavigateBack` handler to `VaultDashboard` to ensure proper back navigation.

Author: Siddhesh2377

app/build.gradle.kts

@@ -22,8 +22,8 @@ android {
         applicationId = "com.dark.tool_neuron"
         minSdk = 31
         targetSdk = 36
-        versionCode = 23
-        versionName = "1.2.1"
+        versionCode = 24
+        versionName = "1.2.2"
         ndk {
             abiFilters += listOf("arm64-v8a", "x86_64")
         }

app/src/main/java/com/dark/tool_neuron/activity/MainActivity.kt

@@ -240,7 +240,7 @@ fun AppNavigation(
         }
 
         composable(Screen.VaultManager.route) {
-            VaultDashboard()
+            VaultDashboard(onNavigateBack = { navController.popBackStack() })
         }
     }
 }

app/src/main/java/com/dark/tool_neuron/data/AppSettingsDataStore.kt

@@ -17,6 +17,7 @@ class AppSettingsDataStore(private val context: Context) {
         private val STREAMING_ENABLED = booleanPreferencesKey("streaming_enabled")
         private val CHAT_MEMORY_ENABLED = booleanPreferencesKey("chat_memory_enabled")
         private val TOOL_CALLING_ENABLED = booleanPreferencesKey("tool_calling_enabled")
+        private val TOOL_CALLING_BYPASS_ENABLED = booleanPreferencesKey("tool_calling_bypass_enabled")
         private val IMAGE_BLUR_ENABLED = booleanPreferencesKey("image_blur_enabled")
         private val LOAD_TTS_ON_START = booleanPreferencesKey("load_tts_on_start")
     }
@@ -33,6 +34,10 @@ class AppSettingsDataStore(private val context: Context) {
         prefs[TOOL_CALLING_ENABLED] ?: true
     }
 
+    val toolCallingBypassEnabled: Flow<Boolean> = context.appSettingsDataStore.data.map { prefs ->
+        prefs[TOOL_CALLING_BYPASS_ENABLED] ?: false
+    }
+
     val imageBlurEnabled: Flow<Boolean> = context.appSettingsDataStore.data.map { prefs ->
         prefs[IMAGE_BLUR_ENABLED] ?: true
     }
@@ -54,6 +59,10 @@ class AppSettingsDataStore(private val context: Context) {
         context.appSettingsDataStore.edit { it[TOOL_CALLING_ENABLED] = enabled }
     }
 
+    suspend fun updateToolCallingBypassEnabled(enabled: Boolean) {
+        context.appSettingsDataStore.edit { it[TOOL_CALLING_BYPASS_ENABLED] = enabled }
+    }
+
     suspend fun updateImageBlurEnabled(enabled: Boolean) {
         context.appSettingsDataStore.edit { it[IMAGE_BLUR_ENABLED] = enabled }
     }

app/src/main/java/com/dark/tool_neuron/di/AppContainer.kt

@@ -28,9 +28,12 @@ object AppContainer {
     private val appScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private val chatManager = ChatManager()
     private var generationManager = GenerationManager()
-    private var vaultInitialized = false
+
+    // Keep track of context for re-initialization if needed
+    private lateinit var appContext: Context
 
     fun init(context: Context, application: Application) {
+        appContext = context.applicationContext
         database = AppDatabase.getDatabase(context)
 
         modelRepository = ModelRepository(
@@ -50,22 +53,35 @@ object AppContainer {
         appScope.launch {
             try {
                 VaultHelper.initialize(context)
-                vaultInitialized = true
             } catch (e: Exception) {
                 e.printStackTrace()
+                // Retry once after a short delay
+                kotlinx.coroutines.delay(500)
+                try {
+                    VaultHelper.initialize(context)
+                } catch (retryException: Exception) {
+                    retryException.printStackTrace()
+                }
             }
         }
     }
 
+    /**
+     * Re-initialize vault if needed (e.g., after configuration change or process death)
+     * This can be called from Activities/Fragments to ensure vault is ready
+     */
+    fun ensureVaultInitialized() {
+        if (!VaultHelper.isInitialized() && ::appContext.isInitialized) {
+            initVault(appContext)
+        }
+    }
+
     fun shutdown() {
-        if (vaultInitialized) {
-            appScope.launch {
-                try {
-                    VaultHelper.close()
-                    vaultInitialized = false
-                } catch (e: Exception) {
-                    e.printStackTrace()
-                }
+        appScope.launch {
+            try {
+                VaultHelper.close()
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
         }
     }
@@ -83,5 +99,10 @@ object AppContainer {
     fun getChatViewModelFactory(): ChatViewModelFactory = chatViewModelFactory
 
 
-    fun isVaultReady(): Boolean = vaultInitialized
+    fun isVaultReady(): Boolean = VaultHelper.isInitialized()
+
+    /**
+     * Exposes the vault readiness StateFlow for UI observation
+     */
+    val vaultReadyState = VaultHelper.isReady
 }

app/src/main/java/com/dark/tool_neuron/plugins/PluginManager.kt

@@ -81,17 +81,32 @@ object PluginManager {
     private val _isToolCallingModelLoaded = MutableStateFlow(false)
     val isToolCallingModelLoaded: StateFlow<Boolean> = _isToolCallingModelLoaded.asStateFlow()
 
+    // Bypass model check for tool calling
+    private val _toolCallingBypassEnabled = MutableStateFlow(false)
+    val toolCallingBypassEnabled: StateFlow<Boolean> = _toolCallingBypassEnabled.asStateFlow()
+
+    /**
+     * Set whether to bypass the tool calling model check.
+     * When enabled, tool calling is available for any loaded model.
+     */
+    fun setToolCallingBypassEnabled(enabled: Boolean) {
+        _toolCallingBypassEnabled.value = enabled
+        Log.d(TAG, "Tool calling bypass: ${if (enabled) "enabled" else "disabled"}")
+    }
+
     /**
      * Update whether the loaded model supports tool calling.
      * Should be called when a model is loaded or unloaded.
      */
     fun setToolCallingModelLoaded(modelName: String?) {
-        _isToolCallingModelLoaded.value = modelName != null && (
+        val modelSupportsToolCalling = modelName != null && (
                 TOOL_CALLING_MODEL_IDS.any { modelName.contains(it, ignoreCase = true) } ||
                 modelName.contains("Code", ignoreCase = true) ||
                 modelName.contains("tool", ignoreCase = true) ||
                 modelName.contains("qwen", ignoreCase = true)
         )
+        // If bypass is enabled, always report as loaded when any model is present
+        _isToolCallingModelLoaded.value = modelSupportsToolCalling || (_toolCallingBypassEnabled.value && modelName != null)
     }
 
     /**