Feature: Add local AI for folder name suggestions

- Optional 4.6GB download (Falcon-H1R-7B via llama-server)
- Notification-based install flow with progress & resume support
- AI suggestions appear in New Folder dialog (F7)
- Dev mode returns mock suggestions, no download required
- Attribution added to About window

Author: vdavid

apps/desktop/src-tauri/Cargo.lock

@@ -48,8 +48,11 @@ alphanumeric-sort = "1.5"
 ed25519-dalek = { version = "2.1", features = ["rand_core"] }
 env_logger = "0.11.8"
 log = "0.4"
-# HTTP client for license server validation
-reqwest = { version = "0.12", features = ["json", "rustls-tls"], default-features = false }
+# HTTP client for license server validation and AI downloads
+reqwest = { version = "0.12", features = ["json", "rustls-tls", "stream"], default-features = false }
+# AI model download: extracting llama-server from tar.gz
+tar = "0.4"
+flate2 = "1.1"
 # MCP server
 axum = "0.8"
 tokio = { version = "1", features = ["rt-multi-thread", "net", "time", "sync", "macros"] }

apps/desktop/src-tauri/Cargo.toml

@@ -0,0 +1,142 @@
+//! HTTP client for the local llama-server (OpenAI-compatible API).
+
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+/// Error types for AI client operations.
+#[derive(Debug, Clone)]
+pub enum AiError {
+    /// Server is not running or not reachable
+    Unavailable,
+    /// Request timed out
+    Timeout,
+    /// Server returned an error
+    ServerError(String),
+    /// Failed to parse the response
+    ParseError(String),
+}
+
+impl std::fmt::Display for AiError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Unavailable => write!(f, "AI server unavailable"),
+            Self::Timeout => write!(f, "AI request timed out"),
+            Self::ServerError(msg) => write!(f, "AI server error: {msg}"),
+            Self::ParseError(msg) => write!(f, "AI response parse error: {msg}"),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ChatMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Serialize)]
+struct ChatCompletionRequest {
+    model: String,
+    messages: Vec<ChatMessage>,
+    temperature: f32,
+    top_p: f32,
+    max_tokens: u32,
+    stream: bool,
+}
+
+#[derive(Deserialize)]
+struct ChatCompletionResponse {
+    choices: Vec<ChatChoice>,
+}
+
+#[derive(Deserialize)]
+struct ChatChoice {
+    message: ChatChoiceMessage,
+}
+
+#[derive(Deserialize)]
+struct ChatChoiceMessage {
+    content: String,
+}
+
+/// Sends a chat completion request to the local llama-server.
+///
+/// Returns the assistant's response text, or an error.
+/// Times out after 10 seconds.
+pub async fn chat_completion(port: u16, prompt: &str) -> Result<String, AiError> {
+    let url = format!("http://127.0.0.1:{port}/v1/chat/completions");
+
+    let request_body = ChatCompletionRequest {
+        model: String::from("falcon-h1r-7b"),
+        messages: vec![ChatMessage {
+            role: String::from("user"),
+            content: prompt.to_string(),
+        }],
+        temperature: 0.6,
+        top_p: 0.95,
+        max_tokens: 100,
+        stream: false,
+    };
+
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(10))
+        .build()
+        .map_err(|e| AiError::ServerError(e.to_string()))?;
+
+    let response = client.post(&url).json(&request_body).send().await.map_err(|e| {
+        if e.is_timeout() {
+            AiError::Timeout
+        } else if e.is_connect() {
+            AiError::Unavailable
+        } else {
+            AiError::ServerError(e.to_string())
+        }
+    })?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().await.unwrap_or_default();
+        return Err(AiError::ServerError(format!("HTTP {status}: {body}")));
+    }
+
+    let parsed: ChatCompletionResponse = response.json().await.map_err(|e| AiError::ParseError(e.to_string()))?;
+
+    parsed
+        .choices
+        .first()
+        .map(|c| c.message.content.clone())
+        .ok_or_else(|| AiError::ParseError(String::from("No choices in response")))
+}
+
+/// Checks if the llama-server is healthy.
+pub async fn health_check(port: u16) -> bool {
+    let url = format!("http://127.0.0.1:{port}/health");
+
+    let client = match reqwest::Client::builder().timeout(Duration::from_secs(2)).build() {
+        Ok(c) => c,
+        Err(_) => return false,
+    };
+
+    match client.get(&url).send().await {
+        Ok(response) => response.status().is_success(),
+        Err(_) => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ai_error_display() {
+        assert_eq!(AiError::Unavailable.to_string(), "AI server unavailable");
+        assert_eq!(AiError::Timeout.to_string(), "AI request timed out");
+        assert_eq!(
+            AiError::ServerError(String::from("bad")).to_string(),
+            "AI server error: bad"
+        );
+        assert_eq!(
+            AiError::ParseError(String::from("oops")).to_string(),
+            "AI response parse error: oops"
+        );
+    }
+}