fix: resolve 3 additional critical bugs

- Fix diff computation race condition: add request ID tracking to prevent
  stale diff results from overwriting current branch selection when user
  switches branches quickly
- Fix token counting error handling: log errors instead of throwing from
  useEffect to prevent unhandled promise rejections and app crashes
- Fix rename detection in git_diff: call find_similar() to enable proper
  rename and copy detection instead of showing as delete+add pairs

Author: kccarlos

apps/desktop/src-tauri/src/git.rs

@@ -110,10 +110,14 @@ pub fn git_diff(path: &str, base: &str, compare: &str) -> Result<DiffResult, Str
         .map_err(|e| format!("Failed to get compare tree: {}", e))?;
 
     // Compute diff
-    let diff = repo
+    let mut diff = repo
         .diff_tree_to_tree(Some(&base_tree), Some(&compare_tree), None)
         .map_err(|e| format!("Failed to compute diff: {}", e))?;
 
+    // Enable rename and copy detection
+    diff.find_similar(None)
+        .map_err(|e| format!("Failed to find similar files: {}", e))?;
+
     let mut files = Vec::new();
 
     diff.foreach(

apps/web/src/hooks/useFileTree.ts

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react'
+import { useCallback, useState, useRef } from 'react'
 import type { GitWorkerClient } from '../utils/gitWorkerClient'
 import type { AppStatus } from '../types/appStatus'
 import { isBinaryPath, LARGE_REPO_FILE_THRESHOLD, type FileDiffStatus, type FileTreeNode } from '@gitcontext/core'
@@ -18,6 +18,9 @@ export function useFileTree(setAppStatus?: (s: AppStatus) => void) {
   const [selectedPaths, setSelectedPaths] = useState<Set<string>>(new Set())
   const [isComputing, setIsComputing] = useState<boolean>(false)
 
+  // Track diff computation request IDs to prevent race conditions
+  const diffRequestIdRef = useRef(0)
+
   const buildTreeFromPaths = useCallback((allPaths: string[], diffMap: Map<string, FileDiffStatus>): { tree: FileTreeNode; statusByPath: Map<string, FileDiffStatus> } => {
     const root: FileTreeNode = { name: '', path: '', type: 'dir', children: [] }
     const dirMap = new Map<string, FileTreeNode>()
@@ -85,21 +88,35 @@ export function useFileTree(setAppStatus?: (s: AppStatus) => void) {
         setExpandedPaths(new Set())
         return
       }
+
+      // Increment request ID to track this specific diff computation
+      const requestId = ++diffRequestIdRef.current
       setIsComputing(true)
-      
+
       try {
         setAppStatus?.({ state: 'LOADING', task: 'diff', message: 'Computing file differences…', progress: 25 })
         try { console.info('[app-status]', { state: 'LOADING', task: 'diff', message: 'Computing file differences…', progress: 25 }) } catch {}
         setProgress?.({ message: 'Computing file differences…', percent: 25 })
-        
+
         const res = await gitClient.diff(baseBranch, compareBranch)
+
+        // Check if this request is still the latest one (prevent race condition)
+        if (requestId !== diffRequestIdRef.current) {
+          return // A newer diff request has been made, ignore this result
+        }
+
         setDiffFiles(res.files)
 
         setProgress?.({ message: 'Fetching file list…', percent: 50 })
         setAppStatus?.({ state: 'LOADING', task: 'diff', message: 'Fetching file list…', progress: 50 })
         try { console.info('[app-status]', { state: 'LOADING', task: 'diff', message: 'Fetching file list…', progress: 50 }) } catch {}
         const baseList = await gitClient.listFiles(baseBranch)
         const compareList = await gitClient.listFiles(compareBranch)
+
+        // Check again after async operations
+        if (requestId !== diffRequestIdRef.current) {
+          return
+        }
         const diffMap = new Map<string, FileDiffStatus>()
         for (const f of res.files) diffMap.set(f.path, f.type as FileDiffStatus)
         // Build union from both sides to keep unchanged files present on either side
@@ -108,6 +125,12 @@ export function useFileTree(setAppStatus?: (s: AppStatus) => void) {
         setAppStatus?.({ state: 'LOADING', task: 'diff', message: 'Building file tree…', progress: 75 })
         try { console.info('[app-status]', { state: 'LOADING', task: 'diff', message: 'Building file tree…', progress: 75 }) } catch {}
         const { tree, statusByPath: statusMap } = buildTreeFromPaths(Array.from(union), diffMap)
+
+        // Final check before committing all state updates
+        if (requestId !== diffRequestIdRef.current) {
+          return
+        }
+
         setFileTree(tree)
         setStatusByPath(statusMap)
 

apps/web/src/hooks/useTokenCounts.ts

@@ -5,6 +5,7 @@ import type { FileDiffStatus } from './useFileTree'
 import { buildUnifiedDiffForStatus } from '../utils/diff'
 import { isBinaryPath, MAX_CONCURRENT_READS } from '@gitcontext/core'
 import { mapWithConcurrency } from '../utils/concurrency'
+import { logError } from '../utils/logger'
 
 // Helper to infer language from file extension for syntax highlighting
 function inferLangFromPath(p: string): string {
@@ -152,8 +153,10 @@ export function useTokenCounts({
         }
         setCounts(next)
       } catch (err: any) {
+        // Don't throw from effect to avoid unhandled promise rejection
         if (err?.message !== 'Operation cancelled') {
-          throw err
+          logError('tokenCounts', err)
+          setCounts(new Map()) // Reset to empty on error
         }
       } finally {
         setBusy(false)