Merge pull request #1 from notime2/feature/ai-query

feat: AI query support via OpenRouter

Author: notime2

src/ai.rs

@@ -0,0 +1,58 @@
+//! AI query module for RustCast.
+//!
+//! Sends user queries to a configurable AI provider (e.g. OpenRouter)
+//! and returns the response text.
+
+use crate::config::AiConfig;
+use log::error;
+
+/// Sends a query to the configured AI provider and returns the response.
+///
+/// This function is blocking and should be called from within a
+/// `tokio::task::spawn_blocking` context.
+pub fn query_ai(config: &AiConfig, query: &str) -> String {
+    if config.api_key.is_empty() {
+        return "Error: AI api_key is not set in config.toml".to_string();
+    }
+
+    let body = serde_json::json!({
+        "model": config.model,
+        "messages": [
+            {
+                "role": "user",
+                "content": query
+            }
+        ]
+    });
+
+    let response = minreq::post(&config.provider_url)
+        .with_header("Authorization", format!("Bearer {}", config.api_key))
+        .with_header("Content-Type", "application/json")
+        .with_header("HTTP-Referer", "https://github.com/notime2/rustcast")
+        .with_header("X-Title", "RustCast")
+        .with_body(body.to_string())
+        .with_timeout(30)
+        .send();
+
+    match response {
+        Ok(resp) => {
+            let json: serde_json::Value =
+                match serde_json::from_str(resp.as_str().unwrap_or("")) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("AI response parse error: {e}");
+                        return format!("Error parsing response: {e}");
+                    }
+                };
+
+            json["choices"][0]["message"]["content"]
+                .as_str()
+                .unwrap_or("No response from AI")
+                .to_string()
+        }
+        Err(e) => {
+            error!("AI request error: {e}");
+            format!("Error: {e}")
+        }
+    }
+}

src/app.rs

@@ -82,6 +82,8 @@ pub enum Message {
     SwitchToPage(Page),
     ClipboardHistory(ClipBoardContentType),
     ChangeFocus(ArrowKey, u32),
+    AiQuery(String),
+    AiResponse(String),
 }
 
 /// The window settings for rustcast

src/app/tile/update.rs

@@ -15,6 +15,7 @@ use rayon::iter::IntoParallelRefIterator;
 use rayon::iter::ParallelIterator;
 use rayon::slice::ParallelSliceMut;
 
+use crate::ai;
 use crate::app::ToApp;
 use crate::app::ToApps;
 use crate::app::WINDOW_WIDTH;
@@ -26,9 +27,10 @@ use crate::app::menubar::menu_icon;
 use crate::app::tile::AppIndex;
 use crate::app::{Message, Page, tile::Tile};
 use crate::calculator::Expr;
+use crate::clipboard::ClipBoardContentType;
 use crate::commands::Function;
 use crate::commands::search_for_file;
-use crate::config::Config;
+use crate::config::{AiConfig, Config};
 use crate::unit_conversion;
 use crate::utils::is_valid_url;
 use crate::{app::ArrowKey, platform::focus_this_app};
@@ -431,6 +433,51 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
             Task::none()
         }
 
+        Message::AiQuery(query) => {
+            info!("AI query: {query}");
+            tile.results = vec![App {
+                ranking: 0,
+                open_command: AppCommand::Display,
+                desc: "AI Query".to_string(),
+                icons: None,
+                display_name: "Thinking...".to_string(),
+                search_name: String::new(),
+            }];
+            let ai_config = tile.config.ai.clone();
+            Task::perform(
+                async move {
+                    tokio::task::spawn_blocking(move || ai::query_ai(&ai_config, &query))
+                        .await
+                        .unwrap_or_else(|e| format!("Error: {e}"))
+                },
+                Message::AiResponse,
+            )
+        }
+
+        Message::AiResponse(response) => {
+            info!("AI response received");
+            tile.results = vec![App {
+                ranking: 0,
+                open_command: AppCommand::Function(Function::CopyToClipboard(
+                    ClipBoardContentType::Text(response.clone()),
+                )),
+                desc: "AI Response (click to copy)".to_string(),
+                icons: None,
+                display_name: response,
+                search_name: String::new(),
+            }];
+            let len = tile.results.len();
+            let max_elem = min(5, len);
+            window::latest()
+                .map(|x| x.unwrap())
+                .map(move |id| {
+                    Message::ResizeWindow(
+                        id,
+                        ((max_elem * 55) + 35 + DEFAULT_WINDOW_HEIGHT as usize) as f32,
+                    )
+                })
+        }
+
         Message::SearchQueryChanged(input, id) => {
             let mut task = Task::none();
             tile.focus_id = 0;
@@ -513,6 +560,24 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
                         return Task::batch([zero_item_resize_task(id), task]);
                     }
                 }
+                query if query.starts_with(&tile.config.ai.trigger)
+                    && query.len() > tile.config.ai.trigger.len()
+                    && query[tile.config.ai.trigger.len()..].starts_with(' ')
+                    && tile.page == Page::Main =>
+                {
+                    let ai_query = tile.query[tile.config.ai.trigger.len()..].trim().to_string();
+                    if !ai_query.is_empty() {
+                        tile.results = vec![App {
+                            ranking: 0,
+                            open_command: AppCommand::Message(Message::AiQuery(ai_query.clone())),
+                            desc: "AI Query".to_string(),
+                            icons: None,
+                            display_name: format!("Ask AI: {}", ai_query),
+                            search_name: String::new(),
+                        }];
+                        return single_item_resize_task(id);
+                    }
+                }
                 query => 'a: {
                     if !query.starts_with(">") || tile.page != Page::Main {
                         break 'a;

src/config.rs

@@ -30,6 +30,7 @@ pub struct Config {
     pub aliases: HashMap<String, String>,
     pub search_dirs: Vec<String>,
     pub log_path: String,
+    pub ai: AiConfig,
 }
 
 impl Default for Config {
@@ -53,6 +54,37 @@ impl Default for Config {
             modes: HashMap::new(),
             aliases: HashMap::new(),
             shells: vec![],
+            ai: AiConfig::default(),
+        }
+    }
+}
+
+/// Configuration for the AI query feature.
+///
+/// Add this to your `config.toml`:
+/// ```toml
+/// [ai]
+/// provider_url = "https://openrouter.ai/api/v1/chat/completions"
+/// api_key = "sk-or-v1-your-key-here"
+/// model = "anthropic/claude-sonnet-4"
+/// trigger = "ai"
+/// ```
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct AiConfig {
+    pub provider_url: String,
+    pub api_key: String,
+    pub model: String,
+    pub trigger: String,
+}
+
+impl Default for AiConfig {
+    fn default() -> Self {
+        Self {
+            provider_url: "https://openrouter.ai/api/v1/chat/completions".to_string(),
+            api_key: String::new(),
+            model: "anthropic/claude-sonnet-4".to_string(),
+            trigger: "ai".to_string(),
         }
     }
 }

src/main.rs

@@ -1,5 +1,6 @@
 #![deny(clippy::dbg_macro)]
 
+mod ai;
 mod app;
 mod calculator;
 mod clipboard;