perf: optimistic thread creation, smooth animations, batch settings, loading skeletons, content-visibility

Author: Swofty-Developments

crates/persistence/src/db.rs

@@ -13,7 +13,14 @@ impl Database {
     /// Open (or create) a database file at the given path and run migrations.
     pub fn open(path: &Path) -> anyhow::Result<Self> {
         let conn = Connection::open(path)?;
-        conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;")?;
+        conn.execute_batch(
+            "PRAGMA journal_mode=WAL;
+             PRAGMA foreign_keys=ON;
+             PRAGMA synchronous=NORMAL;
+             PRAGMA cache_size=-8000;
+             PRAGMA mmap_size=268435456;
+             PRAGMA busy_timeout=5000;",
+        )?;
         run_migrations(&conn)?;
         Ok(Self { conn })
     }

crates/persistence/src/migrations.rs

@@ -83,5 +83,17 @@ pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
         conn.execute_batch("ALTER TABLE sessions ADD COLUMN claude_session_id TEXT;")?;
     }
 
+    // Performance indexes — idempotent via IF NOT EXISTS
+    conn.execute_batch(
+        "
+        CREATE INDEX IF NOT EXISTS idx_threads_project_id ON threads(project_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_thread_created ON messages(thread_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_sessions_thread_id ON sessions(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_sessions_thread_claude ON sessions(thread_id, claude_session_id);
+        CREATE INDEX IF NOT EXISTS idx_usage_logs_thread_id ON usage_logs(thread_id);
+        ",
+    )?;
+
     Ok(())
 }

crates/persistence/src/queries.rs

@@ -311,6 +311,35 @@ pub fn set_setting(conn: &Connection, key: &str, value: &str) -> anyhow::Result<
     Ok(())
 }
 
+pub fn get_settings_batch(
+    conn: &Connection,
+    keys: &[String],
+) -> anyhow::Result<std::collections::HashMap<String, String>> {
+    if keys.is_empty() {
+        return Ok(std::collections::HashMap::new());
+    }
+    // Build a parameterized IN clause
+    let placeholders: Vec<String> = (1..=keys.len()).map(|i| format!("?{i}")).collect();
+    let sql = format!(
+        "SELECT key, value FROM settings WHERE key IN ({})",
+        placeholders.join(", ")
+    );
+    let mut stmt = conn.prepare(&sql)?;
+    let params: Vec<&dyn rusqlite::types::ToSql> =
+        keys.iter().map(|k| k as &dyn rusqlite::types::ToSql).collect();
+    let rows = stmt.query_map(params.as_slice(), |row| {
+        Ok((row.get::<_, String>(0)?, row.get::<_, Option<String>>(1)?))
+    })?;
+    let mut map = std::collections::HashMap::new();
+    for row in rows {
+        let (key, value) = row?;
+        if let Some(v) = value {
+            map.insert(key, v);
+        }
+    }
+    Ok(map)
+}
+
 pub fn delete_setting(conn: &Connection, key: &str) -> anyhow::Result<()> {
     conn.execute("DELETE FROM settings WHERE key = ?1", params![key])?;
     Ok(())

crates/session/src/claude.rs

@@ -103,20 +103,36 @@ impl ClaudeSession {
         permission_mode: Option<&str>,
         session_id: Option<&str>,
     ) -> Result<(Self, mpsc::UnboundedReceiver<AgentEvent>)> {
-        // Resolve the sidecar script path.  Walk up from `cwd` looking for
-        // the workspace root (identified by a top-level Cargo.toml that
-        // contains `[workspace]`), then join the relative sidecar path.
-        let sidecar_path = find_workspace_root(cwd)
-            .map(|root| root.join(SIDECAR_SCRIPT))
-            .unwrap_or_else(|| {
-                // Fallback: try a few common locations.
-                let candidate = cwd.join(SIDECAR_SCRIPT);
+        // Resolve the sidecar script path relative to the executable, not cwd.
+        // In dev mode the exe is in target/debug/, so we walk up to find the workspace root.
+        // In production the sidecar would be bundled alongside the binary.
+        let sidecar_path = std::env::current_exe()
+            .ok()
+            .and_then(|exe| {
+                // Walk up from exe path to find workspace root
+                let mut dir = exe.parent()?;
+                for _ in 0..10 {
+                    let candidate = dir.join(SIDECAR_SCRIPT);
+                    if candidate.exists() {
+                        return Some(candidate);
+                    }
+                    dir = dir.parent()?;
+                }
+                None
+            })
+            .or_else(|| {
+                // Fallback: try from CARGO_MANIFEST_DIR (set at compile time).
+                // This crate is at crates/session/, sidecar is at crates/tauri-app/agent-sidecar/
+                let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+                // Go up to workspace root (crates/session -> crates -> root)
+                let workspace_root = manifest_dir.parent()?.parent()?;
+                let candidate = workspace_root.join(SIDECAR_SCRIPT);
                 if candidate.exists() {
-                    return candidate;
+                    return Some(candidate);
                 }
-                // Assume we're inside the workspace already.
-                std::path::PathBuf::from(SIDECAR_SCRIPT)
-            });
+                None
+            })
+            .unwrap_or_else(|| std::path::PathBuf::from(SIDECAR_SCRIPT));
 
         debug!("Spawning agent sidecar: node {}", sidecar_path.display());
 
@@ -125,13 +141,27 @@ impl ClaudeSession {
             .current_dir(cwd)
             .stdin(std::process::Stdio::piped())
             .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::null())
+            .stderr(std::process::Stdio::piped())
             .kill_on_drop(true)
             .spawn()
             .context("Failed to spawn node agent sidecar")?;
 
         let stdout = child.stdout.take().context("Failed to capture stdout")?;
         let stdin = child.stdin.take().context("Failed to capture stdin")?;
+        let stderr = child.stderr.take();
+
+        // Stderr reader — log sidecar errors
+        if let Some(stderr) = stderr {
+            tokio::spawn(async move {
+                let reader = BufReader::new(stderr);
+                let mut lines = reader.lines();
+                while let Ok(Some(line)) = lines.next_line().await {
+                    if !line.trim().is_empty() {
+                        tracing::warn!("sidecar stderr: {line}");
+                    }
+                }
+            });
+        }
 
         let (event_tx, event_rx) = mpsc::unbounded_channel();
         let (stdin_tx, mut stdin_rx) = mpsc::unbounded_channel::<String>();
@@ -204,6 +234,9 @@ impl ClaudeSession {
                         }
                         vec![AgentEvent::SessionReady { claude_session_id: sid }]
                     }
+                    "turn_started" => {
+                        vec![AgentEvent::TurnStarted { turn_id: "sidecar".to_string() }]
+                    }
                     "text_delta" => {
                         let text = obj.get("text").and_then(|t| t.as_str()).unwrap_or("").to_string();
                         if text.is_empty() {

crates/tauri-app/agent-sidecar/index.mjs

@@ -136,6 +136,41 @@ async function handleQuery(cmd) {
     options.resume = sessionId;
   }
 
+  // canUseTool callback — sends approval requests to Rust, waits for response
+  options.canUseTool = async (toolName, input) => {
+    const requestId = String(++approvalCounter);
+
+    // AskUserQuestion — forward to frontend
+    if (toolName === "AskUserQuestion") {
+      emit({
+        type: "ask_user_question",
+        requestId,
+        questions: input.questions || [],
+      });
+    } else {
+      // Regular tool approval
+      emit({
+        type: "approval_request",
+        requestId,
+        toolName,
+        input,
+      });
+    }
+
+    // Wait for the response from Rust
+    return new Promise((resolve) => {
+      pendingApprovals.set(requestId, {
+        resolve: (resp) => {
+          if (resp.decision === "allow") {
+            resolve({ behavior: "allow", updatedInput: input });
+          } else {
+            resolve({ behavior: "deny", message: resp.message || "User denied this action" });
+          }
+        },
+      });
+    });
+  };
+
   // Create an AbortController for this query.
   const abort = new AbortController();
   currentAbort = abort;
@@ -144,13 +179,18 @@ async function handleQuery(cmd) {
   let capturedSessionId = sessionId || null;
   let turnEmitted = false;
 
+  // Emit turn_started so the frontend shows "generating" state
+  emit({ type: "turn_started" });
+
   try {
     for await (const message of query({ prompt, options })) {
       // Abort was requested while iterating.
       if (abort.signal.aborted) break;
 
+      const msgType = message.type;
+
       // ── system messages ──
-      if (message.type === "system") {
+      if (msgType === "system") {
         if (message.subtype === "init" && message.session_id) {
           capturedSessionId = message.session_id;
           emit({ type: "session_ready", sessionId: message.session_id });
@@ -159,17 +199,44 @@ async function handleQuery(cmd) {
       }
 
       // ── result message (final) ──
-      if ("result" in message) {
-        // Extract usage if available.
-        if (message.usage) {
+      if (msgType === "result" || "result" in message) {
+        // Extract usage from various possible locations
+        const usage = message.usage || message.modelUsage;
+        const costUsd = message.total_cost_usd ?? message.cost_usd ?? 0;
+        const modelName = message.model ?? model ?? "unknown";
+
+        if (usage) {
+          // SDK may nest usage per-model or flat
+          let inputTokens = 0, outputTokens = 0, cacheRead = 0, cacheWrite = 0;
+
+          if (typeof usage === "object" && !Array.isArray(usage)) {
+            // Check if it's a flat usage object or per-model
+            if (usage.input_tokens != null || usage.inputTokens != null) {
+              inputTokens = usage.input_tokens ?? usage.inputTokens ?? 0;
+              outputTokens = usage.output_tokens ?? usage.outputTokens ?? 0;
+              cacheRead = usage.cache_read_input_tokens ?? usage.cacheReadInputTokens ?? 0;
+              cacheWrite = usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens ?? 0;
+            } else {
+              // Per-model usage: { "claude-...": { inputTokens, ... } }
+              for (const [, modelUsage] of Object.entries(usage)) {
+                if (typeof modelUsage === "object") {
+                  inputTokens += modelUsage.inputTokens ?? 0;
+                  outputTokens += modelUsage.outputTokens ?? 0;
+                  cacheRead += modelUsage.cacheReadInputTokens ?? 0;
+                  cacheWrite += modelUsage.cacheCreationInputTokens ?? 0;
+                }
+              }
+            }
+          }
+
           emit({
             type: "usage",
-            inputTokens: message.usage.input_tokens ?? 0,
-            outputTokens: message.usage.output_tokens ?? 0,
-            cacheRead: message.usage.cache_read_input_tokens ?? message.usage.cache_read_tokens ?? 0,
-            cacheWrite: message.usage.cache_creation_input_tokens ?? message.usage.cache_write_tokens ?? 0,
-            costUsd: message.cost_usd ?? message.total_cost_usd ?? 0,
-            model: message.model ?? model ?? "unknown",
+            inputTokens,
+            outputTokens,
+            cacheRead,
+            cacheWrite,
+            costUsd,
+            model: modelName,
           });
         }
 
@@ -181,17 +248,53 @@ async function handleQuery(cmd) {
       // ── streaming content messages ──
       // The SDK yields various message shapes. We normalise them to our protocol.
 
-      const msgType = message.type;
-
       // stream_event wrapping Anthropic API SSE events
       if (msgType === "stream_event" && message.event) {
         handleStreamEvent(message.event);
         continue;
       }
 
-      // assistant message snapshots (full content)
+      // assistant message — extract content blocks
       if (msgType === "assistant" && message.message?.content) {
-        // We prefer stream_event deltas; skip snapshot processing.
+        for (const block of message.message.content) {
+          if (block.type === "text" && block.text) {
+            emit({ type: "text_delta", text: block.text });
+          } else if (block.type === "tool_use") {
+            emit({
+              type: "tool_use_start",
+              toolId: block.id ?? "",
+              toolName: block.name ?? "tool",
+            });
+            if (block.input) {
+              emit({
+                type: "tool_use_input",
+                toolId: block.id ?? "",
+                inputJson: JSON.stringify(block.input),
+              });
+            }
+          } else if (block.type === "thinking" && block.thinking) {
+            emit({ type: "thinking_delta", text: block.thinking });
+          }
+        }
+        continue;
+      }
+
+      // user message — contains tool results
+      if (msgType === "user" && message.message?.content) {
+        for (const block of message.message.content) {
+          if (block.type === "tool_result") {
+            const content = typeof block.content === "string"
+              ? block.content
+              : JSON.stringify(block.content);
+            emit({
+              type: "tool_result",
+              toolId: block.tool_use_id ?? "",
+              toolName: "",
+              content,
+              isError: !!block.is_error,
+            });
+          }
+        }
         continue;
       }