@zemerik/gemini-assist 1.1.1-beta

package/src/gemini_client.rs

@@ -0,0 +1,159 @@
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChatMessage {
+    pub role: String,
+    pub parts: Vec<Part>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Part {
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerateContentRequest {
+    contents: Vec<Content>,
+    generation_config: Option<GenerationConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Content {
+    role: String,
+    parts: Vec<Part>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerationConfig {
+    temperature: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerateContentResponse {
+    candidates: Vec<Candidate>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Candidate {
+    content: Content,
+}
+
+pub struct GeminiClient {
+    api_key: String,
+    model_name: String,
+    temperature: f64,
+    base_url: String,
+    chat_history: Vec<ChatMessage>,
+}
+
+impl GeminiClient {
+    pub fn new(api_key: String, model_name: String, temperature: f64) -> Self {
+        let base_url = format!(
+            "https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent",
+            model_name
+        );
+
+        GeminiClient {
+            api_key,
+            model_name,
+            temperature,
+            base_url,
+            chat_history: Vec::new(),
+        }
+    }
+
+    pub async fn chat(&mut self, prompt: &str) -> Result<String> {
+        // Add user message to history
+        self.chat_history.push(ChatMessage {
+            role: "user".to_string(),
+            parts: vec![Part {
+                text: prompt.to_string(),
+            }],
+        });
+
+        // Build request with chat history
+        let contents: Vec<Content> = self
+            .chat_history
+            .iter()
+            .map(|msg| Content {
+                role: msg.role.clone(),
+                parts: msg.parts.clone(),
+            })
+            .collect();
+
+        let request = GenerateContentRequest {
+            contents,
+            generation_config: Some(GenerationConfig {
+                temperature: self.temperature,
+            }),
+        };
+
+        // Make API call
+        let client = reqwest::Client::new();
+        let url = format!("{}?key={}", self.base_url, self.api_key);
+
+        let response = client
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request to Gemini API")?;
+
+        // Save status before consuming response body
+        let status = response.status();
+        
+        // Handle errors
+        if status.is_client_error() {
+            let error_text = response.text().await.unwrap_or_default();
+            if error_text.contains("API_KEY") || status == 401 {
+                anyhow::bail!("Invalid API key. Please check your GEMINI_API_KEY.");
+            } else if error_text.contains("quota") || error_text.contains("rate limit") {
+                anyhow::bail!("API quota exceeded or rate limit reached. Please try again later.");
+            } else if error_text.contains("safety") {
+                anyhow::bail!("Content was blocked by safety filters.");
+            } else {
+                anyhow::bail!("Gemini API error: {}", error_text);
+            }
+        }
+
+        if !status.is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("HTTP error {}: {}", status, error_text);
+        }
+
+        let api_response: GenerateContentResponse = response
+            .json()
+            .await
+            .context("Failed to parse Gemini API response")?;
+
+        if api_response.candidates.is_empty() {
+            anyhow::bail!("No response candidates from Gemini API");
+        }
+
+        let response_text = api_response.candidates[0]
+            .content
+            .parts
+            .first()
+            .map(|p| p.text.clone())
+            .unwrap_or_default();
+
+        // Add assistant response to history
+        self.chat_history.push(ChatMessage {
+            role: "model".to_string(),
+            parts: vec![Part {
+                text: response_text.clone(),
+            }],
+        });
+
+        Ok(response_text)
+    }
+
+    pub fn clear_history(&mut self) {
+        self.chat_history.clear();
+    }
+
+    pub fn get_history_count(&self) -> usize {
+        self.chat_history.len()
+    }
+}

package/src/lib.rs

@@ -0,0 +1,58 @@
+pub mod gemini_client;
+
+use gemini_client::GeminiClient;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+#[napi]
+pub struct RustGeminiClient {
+    client: Arc<Mutex<GeminiClient>>,
+}
+
+#[napi]
+impl RustGeminiClient {
+    #[napi(constructor)]
+    pub fn new(api_key: String, model_name: Option<String>, temperature: Option<f64>) -> Self {
+        let model = model_name.unwrap_or_else(|| "gemini-2.5-flash".to_string());
+        let temp = temperature.unwrap_or(0.7);
+        let client = GeminiClient::new(api_key, model, temp);
+        
+        RustGeminiClient {
+            client: Arc::new(Mutex::new(client)),
+        }
+    }
+
+    #[napi]
+    pub async fn chat(&self, prompt: String) -> Result<String> {
+        let mut client = self.client.lock().await;
+        client
+            .chat(&prompt)
+            .await
+            .map_err(|e| Error::new(Status::GenericFailure, format!("{}", e)))
+    }
+
+    #[napi]
+    pub async fn clear_history(&self) -> Result<()> {
+        let mut client = self.client.lock().await;
+        client.clear_history();
+        Ok(())
+    }
+
+    #[napi]
+    pub async fn get_history_count(&self) -> Result<u32> {
+        let client = self.client.lock().await;
+        Ok(client.get_history_count() as u32)
+    }
+}
+
+#[napi]
+pub fn validate_api_key_rust(api_key: String) -> bool {
+    api_key.len() > 10 && api_key.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-')
+}
+
+#[napi]
+pub fn rust_version() -> String {
+    format!("Rust-powered Gemini Client v1.1.1-Beta")
+}

package/src/rust/gemini_client.rs

@@ -0,0 +1,157 @@
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChatMessage {
+    pub role: String,
+    pub parts: Vec<Part>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Part {
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerateContentRequest {
+    contents: Vec<Content>,
+    generation_config: Option<GenerationConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Content {
+    role: String,
+    parts: Vec<Part>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerationConfig {
+    temperature: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GenerateContentResponse {
+    candidates: Vec<Candidate>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Candidate {
+    content: Content,
+}
+
+pub struct GeminiClient {
+    api_key: String,
+    model_name: String,
+    temperature: f64,
+    base_url: String,
+    chat_history: Vec<ChatMessage>,
+}
+
+impl GeminiClient {
+    pub fn new(api_key: String, model_name: String, temperature: f64) -> Self {
+        let base_url = format!(
+            "https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent",
+            model_name
+        );
+
+        GeminiClient {
+            api_key,
+            model_name,
+            temperature,
+            base_url,
+            chat_history: Vec::new(),
+        }
+    }
+
+    pub async fn chat(&mut self, prompt: &str) -> Result<String> {
+        // Add user message to history
+        self.chat_history.push(ChatMessage {
+            role: "user".to_string(),
+            parts: vec![Part {
+                text: prompt.to_string(),
+            }],
+        });
+
+        // Build request with chat history
+        let contents: Vec<Content> = self
+            .chat_history
+            .iter()
+            .map(|msg| Content {
+                role: msg.role.clone(),
+                parts: msg.parts.clone(),
+            })
+            .collect();
+
+        let request = GenerateContentRequest {
+            contents,
+            generation_config: Some(GenerationConfig {
+                temperature: self.temperature,
+            }),
+        };
+
+        // Make API call
+        let client = reqwest::Client::new();
+        let url = format!("{}?key={}", self.base_url, self.api_key);
+
+        let response = client
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request to Gemini API")?;
+
+        // Handle errors
+        if response.status().is_client_error() {
+            let error_text = response.text().await.unwrap_or_default();
+            if error_text.contains("API_KEY") || response.status() == 401 {
+                anyhow::bail!("Invalid API key. Please check your GEMINI_API_KEY.");
+            } else if error_text.contains("quota") || error_text.contains("rate limit") {
+                anyhow::bail!("API quota exceeded or rate limit reached. Please try again later.");
+            } else if error_text.contains("safety") {
+                anyhow::bail!("Content was blocked by safety filters.");
+            } else {
+                anyhow::bail!("Gemini API error: {}", error_text);
+            }
+        }
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("HTTP error {}: {}", response.status(), error_text);
+        }
+
+        let api_response: GenerateContentResponse = response
+            .json()
+            .await
+            .context("Failed to parse Gemini API response")?;
+
+        if api_response.candidates.is_empty() {
+            anyhow::bail!("No response candidates from Gemini API");
+        }
+
+        let response_text = api_response.candidates[0]
+            .content
+            .parts
+            .first()
+            .map(|p| p.text.clone())
+            .unwrap_or_default();
+
+        // Add assistant response to history
+        self.chat_history.push(ChatMessage {
+            role: "model".to_string(),
+            parts: vec![Part {
+                text: response_text.clone(),
+            }],
+        });
+
+        Ok(response_text)
+    }
+
+    pub fn clear_history(&mut self) {
+        self.chat_history.clear();
+    }
+
+    pub fn get_history_count(&self) -> usize {
+        self.chat_history.len()
+    }
+}

package/src/rust/lib.rs

@@ -0,0 +1,57 @@
+mod gemini_client;
+
+use gemini_client::GeminiClient;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+#[napi]
+pub struct RustGeminiClient {
+    client: Arc<Mutex<GeminiClient>>,
+}
+
+#[napi]
+impl RustGeminiClient {
+    #[napi(constructor)]
+    pub fn new(api_key: String, model_name: Option<String>, temperature: Option<f64>) -> Self {
+        let model = model_name.unwrap_or_else(|| "gemini-pro".to_string());
+        let temp = temperature.unwrap_or(0.7);
+        let client = GeminiClient::new(api_key, model, temp);
+        
+        RustGeminiClient {
+            client: Arc::new(Mutex::new(client)),
+        }
+    }
+
+    #[napi]
+    pub async fn chat(&self, prompt: String) -> Result<String> {
+        let mut client = self.client.lock().await;
+        client
+            .chat(&prompt)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("{}", e)))
+    }
+
+    #[napi]
+    pub async fn clear_history(&self) -> Result<()> {
+        let mut client = self.client.lock().await;
+        client.clear_history();
+        Ok(())
+    }
+
+    #[napi]
+    pub async fn get_history_count(&self) -> Result<u32> {
+        let client = self.client.lock().await;
+        Ok(client.get_history_count() as u32)
+    }
+}
+
+#[napi]
+pub fn validate_api_key_rust(api_key: String) -> bool {
+    api_key.len() > 10 && api_key.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-')
+}
+
+#[napi]
+pub fn rust_version() -> String {
+    format!("Rust-powered Gemini Client v1.1.1-Beta")
+}

package/src/utils.js

@@ -0,0 +1,62 @@
+const chalk = require('chalk');
+
+// Try to use Rust validation, fallback to JS
+let validateApiKeyRust;
+try {
+  const native = require('../../index.node');
+  validateApiKeyRust = native.validate_api_key_rust;
+} catch (error) {
+  validateApiKeyRust = null;
+}
+
+function validateApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== 'string') {
+    return false;
+  }
+  
+  // Use Rust validation if available, otherwise JS
+  if (validateApiKeyRust) {
+    return validateApiKeyRust(apiKey);
+  }
+  
+  // JS fallback
+  return apiKey.length > 10 && /^[A-Za-z0-9_-]+$/.test(apiKey);
+}
+
+function printWelcome() {
+  // Check if Rust is available
+  let rustInfo = '';
+  try {
+    const native = require('../../index.node');
+    const rustVersion = native.rust_version();
+    rustInfo = chalk.green(' (Rust-powered)');
+  } catch (error) {
+    rustInfo = chalk.yellow(' (JS mode)');
+  }
+  
+  console.clear();
+  console.log(chalk.bold.cyan('╔═══════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║      ') + chalk.bold.white('Gemini Assist v1.1.1-Beta') + rustInfo + chalk.bold.cyan('      ║'));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════╝'));
+  console.log(chalk.gray('AI Assistant powered by Google Gemini\n'));
+}
+
+function printError(message) {
+  console.error(chalk.red.bold('✗ Error: ') + chalk.red(message));
+}
+
+function printSuccess(message) {
+  console.log(chalk.green.bold('✓ ') + chalk.green(message));
+}
+
+function printInfo(message) {
+  console.log(chalk.blue.bold('ℹ ') + chalk.blue(message));
+}
+
+module.exports = {
+  validateApiKey,
+  printWelcome,
+  printError,
+  printSuccess,
+  printInfo
+};