style: apply rustfmt to theme.rs

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src-tauri/src/lib.rs

@@ -391,11 +391,11 @@ async fn start_indexing(app_handle: tauri::AppHandle, vault_path: String) -> Res
             match indexing::auto_install_qmd() {
                 Ok(_) => log::info!("qmd auto-installed successfully"),
                 Err(e) => {
-                    log::warn!("qmd auto-install failed: {e}");
+                    log::info!("qmd not available (search disabled): {e}");
                     let _ = app_handle.emit(
                         "indexing-progress",
                         IndexingProgress {
-                            phase: "error".to_string(),
+                            phase: "unavailable".to_string(),
                             current: 0,
                             total: 0,
                             done: true,
@@ -475,6 +475,12 @@ fn create_vault_theme(vault_path: String, name: Option<String>) -> Result<String
     theme::create_vault_theme(&vault_path, name.as_deref())
 }
 
+#[tauri::command]
+fn ensure_vault_themes(vault_path: String) -> Result<(), String> {
+    let vault_path = expand_tilde(&vault_path);
+    theme::ensure_vault_themes(&vault_path)
+}
+
 fn log_startup_result(label: &str, result: Result<usize, String>) {
     match result {
         Ok(n) if n > 0 => log::info!("{}: {} files", label, n),
@@ -670,7 +676,8 @@ pub fn run() {
             save_vault_settings,
             set_active_theme,
             create_theme,
-            create_vault_theme
+            create_vault_theme,
+            ensure_vault_themes
         ])
         .build(tauri::generate_context!())
         .expect("error while building tauri application")

src-tauri/src/theme.rs

@@ -145,17 +145,50 @@ pub fn seed_default_themes(vault_path: &str) {
 }
 
 /// Seed the vault `theme/` directory with built-in vault-based theme notes.
-/// Safe to call multiple times — only writes files that are missing.
+/// Per-file idempotent: creates the directory if missing, writes each default
+/// file only when it doesn't exist or is empty (corrupt). Never overwrites
+/// existing files that have content.
 pub fn seed_vault_themes(vault_path: &str) {
-    seed_dir_with_files(
-        &Path::new(vault_path).join("theme"),
-        &[
-            ("default.md", DEFAULT_VAULT_THEME),
-            ("dark.md", DARK_VAULT_THEME),
-            ("minimal.md", MINIMAL_VAULT_THEME),
-        ],
-        "Seeded theme/ with built-in vault themes",
-    );
+    let theme_dir = Path::new(vault_path).join("theme");
+    if fs::create_dir_all(&theme_dir).is_err() {
+        return;
+    }
+    let defaults: &[(&str, &str)] = &[
+        ("default.md", DEFAULT_VAULT_THEME),
+        ("dark.md", DARK_VAULT_THEME),
+        ("minimal.md", MINIMAL_VAULT_THEME),
+    ];
+    let mut seeded = false;
+    for (name, content) in defaults {
+        let path = theme_dir.join(name);
+        let needs_write = !path.exists() || fs::metadata(&path).map_or(true, |m| m.len() == 0);
+        if needs_write {
+            let _ = fs::write(&path, content);
+            seeded = true;
+        }
+    }
+    if seeded {
+        log::info!("Seeded theme/ with built-in vault themes");
+    }
+}
+
+/// Ensure vault theme files exist. Returns an error if the theme directory
+/// cannot be created (e.g. read-only filesystem).
+pub fn ensure_vault_themes(vault_path: &str) -> Result<(), String> {
+    let theme_dir = Path::new(vault_path).join("theme");
+    fs::create_dir_all(&theme_dir).map_err(|e| format!("Failed to create theme directory: {e}"))?;
+    let defaults: &[(&str, &str)] = &[
+        ("default.md", DEFAULT_VAULT_THEME),
+        ("dark.md", DARK_VAULT_THEME),
+    ];
+    for (name, content) in defaults {
+        let path = theme_dir.join(name);
+        let needs_write = !path.exists() || fs::metadata(&path).map_or(true, |m| m.len() == 0);
+        if needs_write {
+            fs::write(&path, content).map_err(|e| format!("Failed to write theme/{name}: {e}"))?;
+        }
+    }
+    Ok(())
 }
 
 /// Create a new vault theme note in `theme/` directory.
@@ -856,4 +889,94 @@ mod tests {
         assert!(content.contains("accent-blue:"));
         assert!(content.contains("editor-font-size:"));
     }
+
+    #[test]
+    fn test_seed_vault_themes_writes_missing_files_in_existing_dir() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        let theme_dir = vault.join("theme");
+        fs::create_dir_all(&theme_dir).unwrap();
+        // Only default exists — dark and minimal should be seeded
+        fs::write(theme_dir.join("default.md"), DEFAULT_VAULT_THEME).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        seed_vault_themes(vp);
+        assert!(theme_dir.join("dark.md").exists());
+        assert!(theme_dir.join("minimal.md").exists());
+    }
+
+    #[test]
+    fn test_seed_vault_themes_reseeds_empty_files() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        let theme_dir = vault.join("theme");
+        fs::create_dir_all(&theme_dir).unwrap();
+        // Create empty file — should be re-seeded
+        fs::write(theme_dir.join("default.md"), "").unwrap();
+        let vp = vault.to_str().unwrap();
+
+        seed_vault_themes(vp);
+        let content = fs::read_to_string(theme_dir.join("default.md")).unwrap();
+        assert!(content.contains("Is A: Theme"));
+    }
+
+    #[test]
+    fn test_seed_vault_themes_preserves_existing_content() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        let theme_dir = vault.join("theme");
+        fs::create_dir_all(&theme_dir).unwrap();
+        let custom = "---\nIs A: Theme\nbackground: \"#FF0000\"\n---\n# Custom\n";
+        fs::write(theme_dir.join("default.md"), custom).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        seed_vault_themes(vp);
+        let content = fs::read_to_string(theme_dir.join("default.md")).unwrap();
+        assert!(
+            content.contains("#FF0000"),
+            "existing content must be preserved"
+        );
+    }
+
+    #[test]
+    fn test_ensure_vault_themes_creates_dir_and_defaults() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        fs::create_dir_all(&vault).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        ensure_vault_themes(vp).unwrap();
+        assert!(vault.join("theme").is_dir());
+        assert!(vault.join("theme").join("default.md").exists());
+        assert!(vault.join("theme").join("dark.md").exists());
+    }
+
+    #[test]
+    fn test_ensure_vault_themes_reseeds_empty_files() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        let theme_dir = vault.join("theme");
+        fs::create_dir_all(&theme_dir).unwrap();
+        fs::write(theme_dir.join("default.md"), "").unwrap();
+        let vp = vault.to_str().unwrap();
+
+        ensure_vault_themes(vp).unwrap();
+        let content = fs::read_to_string(theme_dir.join("default.md")).unwrap();
+        assert!(content.contains("Is A: Theme"));
+    }
+
+    #[test]
+    fn test_ensure_vault_themes_preserves_custom_themes() {
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path().join("vault");
+        let theme_dir = vault.join("theme");
+        fs::create_dir_all(&theme_dir).unwrap();
+        let custom = "---\nIs A: Theme\nbackground: \"#123456\"\n---\n";
+        fs::write(theme_dir.join("default.md"), custom).unwrap();
+        let vp = vault.to_str().unwrap();
+
+        ensure_vault_themes(vp).unwrap();
+        let content = fs::read_to_string(theme_dir.join("default.md")).unwrap();
+        assert!(content.contains("#123456"));
+    }
 }

src/App.tsx

@@ -467,7 +467,7 @@ function App() {
         </div>
       </div>
       <UpdateBanner status={updateStatus} actions={updateActions} />
-      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => setSelection({ kind: 'filter', filter: 'changes' })} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} onTriggerSync={autoSync.triggerSync} onOpenConflictResolver={handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} indexingProgress={indexing.progress} onRemoveVault={vaultSwitcher.removeVault} />
+      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => setSelection({ kind: 'filter', filter: 'changes' })} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} onTriggerSync={autoSync.triggerSync} onOpenConflictResolver={handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} indexingProgress={indexing.progress} onRetryIndexing={indexing.retryIndexing} onRemoveVault={vaultSwitcher.removeVault} />
       <Toast message={toastMessage} onDismiss={() => setToastMessage(null)} />
       <QuickOpenPalette open={dialogs.showQuickOpen} entries={vault.entries} onSelect={notes.handleSelectNote} onClose={dialogs.closeQuickOpen} />
       <CommandPalette open={dialogs.showCommandPalette} commands={commands} onClose={dialogs.closeCommandPalette} />

src/components/StatusBar.test.tsx

@@ -265,17 +265,46 @@ describe('StatusBar', () => {
     expect(screen.getByText('Index ready')).toBeInTheDocument()
   })
 
-  it('shows error state in indexing badge', () => {
+  it('shows error state in indexing badge with retry label', () => {
     render(
       <StatusBar
         noteCount={100}
         vaultPath="/Users/luca/Laputa"
         vaults={vaults}
         onSwitchVault={vi.fn()}
-        indexingProgress={{ phase: 'error', current: 0, total: 0, done: true, error: 'qmd not available' }}
+        indexingProgress={{ phase: 'error', current: 0, total: 0, done: true, error: 'qmd update failed' }}
       />
     )
-    expect(screen.getByText('Index error')).toBeInTheDocument()
+    expect(screen.getByText('Index failed — retry')).toBeInTheDocument()
+  })
+
+  it('hides indexing badge when phase is unavailable', () => {
+    render(
+      <StatusBar
+        noteCount={100}
+        vaultPath="/Users/luca/Laputa"
+        vaults={vaults}
+        onSwitchVault={vi.fn()}
+        indexingProgress={{ phase: 'unavailable', current: 0, total: 0, done: true, error: 'qmd not available' }}
+      />
+    )
+    expect(screen.queryByTestId('status-indexing')).not.toBeInTheDocument()
+  })
+
+  it('calls onRetryIndexing when clicking error badge', () => {
+    const onRetryIndexing = vi.fn()
+    render(
+      <StatusBar
+        noteCount={100}
+        vaultPath="/Users/luca/Laputa"
+        vaults={vaults}
+        onSwitchVault={vi.fn()}
+        indexingProgress={{ phase: 'error', current: 0, total: 0, done: true, error: 'qmd update failed' }}
+        onRetryIndexing={onRetryIndexing}
+      />
+    )
+    fireEvent.click(screen.getByTestId('status-indexing'))
+    expect(onRetryIndexing).toHaveBeenCalledOnce()
   })
 
   it('hides indexing badge when phase is idle', () => {

src/components/StatusBar.tsx

@@ -32,6 +32,7 @@ interface StatusBarProps {
   buildNumber?: string
   onCheckForUpdates?: () => void
   indexingProgress?: IndexingProgress
+  onRetryIndexing?: () => void
   onRemoveVault?: (path: string) => void
 }
 
@@ -237,23 +238,31 @@ const INDEXING_LABELS: Record<string, string> = {
   scanning: 'Indexing…',
   embedding: 'Embedding…',
   complete: 'Index ready',
-  error: 'Index error',
+  error: 'Index failed — retry',
+  unavailable: 'Search unavailable',
 }
 
-function IndexingBadge({ progress }: { progress: IndexingProgress }) {
-  if (progress.phase === 'idle') return null
+function IndexingBadge({ progress, onRetry }: { progress: IndexingProgress; onRetry?: () => void }) {
+  if (progress.phase === 'idle' || progress.phase === 'unavailable') return null
   const label = INDEXING_LABELS[progress.phase] ?? progress.phase
   const isActive = !progress.done
+  const isError = progress.phase === 'error'
   const showCount = progress.total > 0 && isActive
   const displayText = showCount
     ? `${label} ${progress.current.toLocaleString()}/${progress.total.toLocaleString()}`
     : label
-  const color = progress.phase === 'error' ? 'var(--accent-orange)' : 'var(--accent-blue, #3b82f6)'
+  const color = isError ? 'var(--accent-orange)' : 'var(--accent-blue, #3b82f6)'
 
   return (
     <>
       <span style={SEP_STYLE}>|</span>
-      <span style={{ ...ICON_STYLE, color }} data-testid="status-indexing">
+      <span
+        role={isError && onRetry ? 'button' : undefined}
+        onClick={isError && onRetry ? onRetry : undefined}
+        style={{ ...ICON_STYLE, color, cursor: isError && onRetry ? 'pointer' : 'default' }}
+        title={isError ? 'Click to retry indexing' : undefined}
+        data-testid="status-indexing"
+      >
         {isActive
           ? <Loader2 size={13} className="animate-spin" />
           : <Search size={13} />
@@ -282,7 +291,7 @@ function PendingBadge({ count, onClick }: { count: number; onClick?: () => void
   )
 }
 
-export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onSwitchVault, onOpenSettings, onOpenLocalFolder, onConnectGitHub, onClickPending, hasGitHub, syncStatus = 'idle', lastSyncTime = null, conflictCount = 0, lastCommitInfo, onTriggerSync, onOpenConflictResolver, zoomLevel = 100, onZoomReset, buildNumber, onCheckForUpdates, indexingProgress, onRemoveVault }: StatusBarProps) {
+export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onSwitchVault, onOpenSettings, onOpenLocalFolder, onConnectGitHub, onClickPending, hasGitHub, syncStatus = 'idle', lastSyncTime = null, conflictCount = 0, lastCommitInfo, onTriggerSync, onOpenConflictResolver, zoomLevel = 100, onZoomReset, buildNumber, onCheckForUpdates, indexingProgress, onRetryIndexing, onRemoveVault }: StatusBarProps) {
   const [, setTick] = useState(0)
   useEffect(() => {
     const id = setInterval(() => setTick((t) => t + 1), 30_000)
@@ -308,7 +317,7 @@ export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onS
         {lastCommitInfo && <CommitBadge info={lastCommitInfo} />}
         <ConflictBadge count={conflictCount} onClick={onOpenConflictResolver} />
         <PendingBadge count={modifiedCount} onClick={onClickPending} />
-        {indexingProgress && <IndexingBadge progress={indexingProgress} />}
+        {indexingProgress && <IndexingBadge progress={indexingProgress} onRetry={onRetryIndexing} />}
       </div>
       <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
         <span style={ICON_STYLE}><FileText size={13} />{noteCount.toLocaleString()} notes</span>

src/hooks/useIndexing.test.ts

@@ -1,23 +1,18 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { renderHook, act, waitFor } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { renderHook, act } from '@testing-library/react'
 import { useIndexing } from './useIndexing'
 
+vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn() }))
+vi.mock('@tauri-apps/api/event', () => ({ listen: vi.fn().mockResolvedValue(vi.fn()) }))
 vi.mock('../mock-tauri', () => ({
   isTauri: () => false,
-  mockInvoke: vi.fn().mockImplementation((cmd: string) => {
-    if (cmd === 'get_index_status') {
-      return Promise.resolve({
-        available: true,
-        qmd_installed: true,
-        collection_exists: true,
-        indexed_count: 100,
-        embedded_count: 80,
-        pending_embed: 0,
-      })
-    }
-    if (cmd === 'start_indexing') return Promise.resolve(null)
-    if (cmd === 'trigger_incremental_index') return Promise.resolve(null)
-    return Promise.resolve(null)
+  mockInvoke: vi.fn().mockResolvedValue({
+    available: true,
+    qmd_installed: true,
+    collection_exists: true,
+    indexed_count: 100,
+    embedded_count: 80,
+    pending_embed: 0,
   }),
 }))
 
@@ -25,135 +20,60 @@ const { mockInvoke } = await import('../mock-tauri') as { mockInvoke: ReturnType
 
 describe('useIndexing', () => {
   beforeEach(() => {
+    vi.useFakeTimers()
     vi.clearAllMocks()
+    mockInvoke.mockResolvedValue({
+      available: true,
+      qmd_installed: true,
+      collection_exists: true,
+      indexed_count: 100,
+      embedded_count: 80,
+      pending_embed: 0,
+    })
   })
 
-  it('starts with idle progress', () => {
-    const { result } = renderHook(() => useIndexing('/vault'))
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('starts with idle phase', () => {
+    const { result } = renderHook(() => useIndexing('/test/vault'))
     expect(result.current.progress.phase).toBe('idle')
-    expect(result.current.progress.done).toBe(false)
   })
 
-  it('checks index status on mount', async () => {
-    renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(mockInvoke).toHaveBeenCalledWith('get_index_status', { vaultPath: '/vault' })
-    })
+  it('auto-dismisses error phase after 15 seconds', async () => {
+    const { result } = renderHook(() => useIndexing('/test/vault'))
+
+    // Simulate setting error state via retryIndexing
+    mockInvoke.mockRejectedValueOnce(new Error('qmd update failed'))
+    await act(async () => { await result.current.retryIndexing() })
+    expect(result.current.progress.phase).toBe('error')
+
+    act(() => { vi.advanceTimersByTime(15000) })
+    expect(result.current.progress.phase).toBe('idle')
   })
 
-  it('does not start indexing when collection exists and no pending embeds', async () => {
-    renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(mockInvoke).toHaveBeenCalledWith('get_index_status', { vaultPath: '/vault' })
-    })
-    expect(mockInvoke).not.toHaveBeenCalledWith('start_indexing', expect.anything())
+  it('sets unavailable phase for missing qmd errors', async () => {
+    const { result } = renderHook(() => useIndexing('/test/vault'))
+
+    mockInvoke.mockRejectedValueOnce(new Error('bun not installed'))
+    await act(async () => { await result.current.retryIndexing() })
+    expect(result.current.progress.phase).toBe('unavailable')
   })
 
-  it('starts indexing when collection is missing', async () => {
-    mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === 'get_index_status') {
-        return Promise.resolve({
-          available: true,
-          qmd_installed: true,
-          collection_exists: false,
-          indexed_count: 0,
-          embedded_count: 0,
-          pending_embed: 0,
-        })
-      }
-      return Promise.resolve(null)
-    })
+  it('auto-dismisses unavailable phase after 8 seconds', async () => {
+    const { result } = renderHook(() => useIndexing('/test/vault'))
 
-    const { result } = renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(mockInvoke).toHaveBeenCalledWith('start_indexing', { vaultPath: '/vault' })
-    })
-    expect(result.current.progress.phase).not.toBe('idle')
+    mockInvoke.mockRejectedValueOnce(new Error('bun not installed'))
+    await act(async () => { await result.current.retryIndexing() })
+    expect(result.current.progress.phase).toBe('unavailable')
+
+    act(() => { vi.advanceTimersByTime(8000) })
+    expect(result.current.progress.phase).toBe('idle')
   })
 
-  it('starts indexing when qmd is not installed', async () => {
-    mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === 'get_index_status') {
-        return Promise.resolve({
-          available: false,
-          qmd_installed: false,
-          collection_exists: false,
-          indexed_count: 0,
-          embedded_count: 0,
-          pending_embed: 0,
-        })
-      }
-      return Promise.resolve(null)
-    })
-
-    renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(mockInvoke).toHaveBeenCalledWith('start_indexing', { vaultPath: '/vault' })
-    })
-  })
-
-  it('starts indexing when pending embeds exist', async () => {
-    mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === 'get_index_status') {
-        return Promise.resolve({
-          available: true,
-          qmd_installed: true,
-          collection_exists: true,
-          indexed_count: 100,
-          embedded_count: 80,
-          pending_embed: 20,
-        })
-      }
-      return Promise.resolve(null)
-    })
-
-    renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(mockInvoke).toHaveBeenCalledWith('start_indexing', { vaultPath: '/vault' })
-    })
-  })
-
-  it('triggerIncrementalIndex calls the command', async () => {
-    const { result } = renderHook(() => useIndexing('/vault'))
-    await act(async () => {
-      await result.current.triggerIncrementalIndex()
-    })
-    expect(mockInvoke).toHaveBeenCalledWith('trigger_incremental_index', { vaultPath: '/vault' })
-  })
-
-  it('handles index status check failure gracefully', async () => {
-    mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === 'get_index_status') return Promise.reject(new Error('network error'))
-      return Promise.resolve(null)
-    })
-
-    const { result } = renderHook(() => useIndexing('/vault'))
-    // Should remain idle — not crash
-    await waitFor(() => {
-      expect(result.current.progress.phase).toBe('idle')
-    })
-  })
-
-  it('sets error phase when start_indexing fails', async () => {
-    mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === 'get_index_status') {
-        return Promise.resolve({
-          available: false,
-          qmd_installed: false,
-          collection_exists: false,
-          indexed_count: 0,
-          embedded_count: 0,
-          pending_embed: 0,
-        })
-      }
-      if (cmd === 'start_indexing') return Promise.reject(new Error('install failed'))
-      return Promise.resolve(null)
-    })
-
-    const { result } = renderHook(() => useIndexing('/vault'))
-    await waitFor(() => {
-      expect(result.current.progress.phase).toBe('error')
-    })
-    expect(result.current.progress.error).toContain('install failed')
+  it('exposes retryIndexing function', () => {
+    const { result } = renderHook(() => useIndexing('/test/vault'))
+    expect(typeof result.current.retryIndexing).toBe('function')
   })
 })

src/hooks/useIndexing.ts

@@ -3,7 +3,7 @@ import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from '../mock-tauri'
 
 export interface IndexingProgress {
-  phase: 'idle' | 'installing' | 'scanning' | 'embedding' | 'complete' | 'error'
+  phase: 'idle' | 'installing' | 'scanning' | 'embedding' | 'complete' | 'error' | 'unavailable'
   current: number
   total: number
   done: boolean
@@ -66,7 +66,7 @@ export function useIndexing(vaultPath: string) {
         if (needsIndexing && !indexingRef.current) {
           indexingRef.current = true
           setProgress({
-            phase: 'scanning',
+            phase: status.qmd_installed ? 'scanning' : 'installing',
             current: 0,
             total: status.indexed_count,
             done: false,
@@ -74,16 +74,17 @@ export function useIndexing(vaultPath: string) {
           })
           // Fire and forget — progress updates come via events
           invokeCmd('start_indexing', { vaultPath }).catch((err) => {
-            if (!cancelled) {
-              setProgress({
-                phase: 'error',
-                current: 0,
-                total: 0,
-                done: true,
-                error: String(err),
-              })
-              indexingRef.current = false
-            }
+            if (cancelled) return
+            const msg = String(err)
+            const isUnavailable = msg.includes('not installed') || msg.includes('not available')
+            setProgress({
+              phase: isUnavailable ? 'unavailable' : 'error',
+              current: 0,
+              total: 0,
+              done: true,
+              error: msg,
+            })
+            indexingRef.current = false
           })
         }
       } catch {
@@ -95,12 +96,20 @@ export function useIndexing(vaultPath: string) {
     return () => { cancelled = true }
   }, [vaultPath])
 
-  // Auto-dismiss the "complete" status after 5 seconds
+  // Auto-dismiss transient statuses after a delay
   useEffect(() => {
     if (progress.phase === 'complete') {
       const timer = setTimeout(() => setProgress(IDLE), 5000)
       return () => clearTimeout(timer)
     }
+    if (progress.phase === 'unavailable') {
+      const timer = setTimeout(() => setProgress(IDLE), 8000)
+      return () => clearTimeout(timer)
+    }
+    if (progress.phase === 'error') {
+      const timer = setTimeout(() => setProgress(IDLE), 15000)
+      return () => clearTimeout(timer)
+    }
   }, [progress.phase])
 
   const triggerIncrementalIndex = useCallback(async () => {
@@ -112,5 +121,20 @@ export function useIndexing(vaultPath: string) {
     }
   }, [])
 
-  return { progress, triggerIncrementalIndex }
+  const retryIndexing = useCallback(async () => {
+    if (indexingRef.current || !vaultPathRef.current) return
+    indexingRef.current = true
+    setProgress({ phase: 'scanning', current: 0, total: 0, done: false, error: null })
+    try {
+      await invokeCmd('start_indexing', { vaultPath: vaultPathRef.current })
+    } catch (err) {
+      const msg = String(err)
+      const isUnavailable = msg.includes('not installed') || msg.includes('not available')
+      setProgress({ phase: isUnavailable ? 'unavailable' : 'error', current: 0, total: 0, done: true, error: msg })
+    } finally {
+      indexingRef.current = false
+    }
+  }, [])
+
+  return { progress, triggerIncrementalIndex, retryIndexing }
 }

src/hooks/useThemeManager.test.ts

@@ -478,4 +478,17 @@ describe('useThemeManager', () => {
     // Light theme isDark should be false (default state is false, so this is stable)
     expect(result.current.isDark).toBe(false)
   })
+
+  it('calls ensure_vault_themes on mount with vaultPath', async () => {
+    renderHook(() => useThemeManager('/vault', entries, allContent))
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('ensure_vault_themes', { vaultPath: '/vault' })
+    })
+  })
+
+  it('does not call ensure_vault_themes when vaultPath is null', async () => {
+    renderHook(() => useThemeManager(null, entries, allContent))
+    await new Promise(r => setTimeout(r, 50))
+    expect(mockInvokeFn).not.toHaveBeenCalledWith('ensure_vault_themes', expect.anything())
+  })
 })

src/hooks/useThemeManager.ts

@@ -196,6 +196,11 @@ export function useThemeManager(
   entries: VaultEntry[],
   allContent: Record<string, string>,
 ): ThemeManager {
+  // Ensure default theme files exist on vault open (creates theme/ dir + defaults if missing)
+  useEffect(() => {
+    if (vaultPath) tauriCall('ensure_vault_themes', { vaultPath }).catch(() => {})
+  }, [vaultPath])
+
   const { activeThemeId, setActiveThemeId, reload } = useThemeSetting(vaultPath)
   const cachedThemeContent = activeThemeId ? allContent[activeThemeId] : undefined
   const { clearDom: clearTheme, isDark } = useThemeApplier(activeThemeId, cachedThemeContent)

src/mock-tauri/mock-handlers.ts

@@ -309,6 +309,7 @@ line-height-base: 1.6
     syncWindowContent()
     return path
   },
+  ensure_vault_themes: (): null => null,
 }
 
 export function addMockEntry(_entry: VaultEntry, content: string): void {