changes

Author: Tricked-dev

src/ai_message.rs

@@ -1,45 +1,35 @@
 use color_eyre::Result;
 use r2d2_sqlite::SqliteConnectionManager;
-use rig::{
-    completion::{Prompt, ToolDefinition},
-    prelude::*,
-    providers,
-    tool::Tool,
-};
-use rusqlite::params;
-use serde::{Deserialize, Serialize};
-use serde_json::json;
+use rig::{completion::Prompt, prelude::*, providers};
 use serde_rusqlite::from_row;
 
-use crate::{
-    brave::BraveApi,
-    database::{self, User},
-};
+use crate::{brave::BraveApi, database::User};
 
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-
-// Tool call logger to track which tools are called
-type ToolCallLogger = Arc<Mutex<Vec<String>>>;
-
-#[derive(Debug, thiserror::Error)]
-#[error("Error")]
-pub enum ToolError {
-    Generic(#[from] color_eyre::Report),
-    Pool(#[from] r2d2::Error),
-}
 
 pub async fn main(
     database: r2d2::Pool<SqliteConnectionManager>,
     user_id: u64,
     message: &str,
     context: &str,
-    brave: BraveApi,
+    _brave: BraveApi,
     user_mentions: HashMap<String, u64>,
 ) -> Result<String> {
     // Create OpenAI client
     let openai_client = providers::openai::Client::from_env();
 
+    // Replace user mentions with usernames in context
+    let mut processed_context = context.to_string();
+    for (mention, mentioned_user_id) in &user_mentions {
+        let db = database.get()?;
+        let mut statement = db.prepare("SELECT * FROM user WHERE id = ?").unwrap();
+        if let Ok(mentioned_user) = statement.query_one([mentioned_user_id.to_string()], |row| {
+            from_row::<User>(row).map_err(|_| rusqlite::Error::QueryReturnedNoRows)
+        }) {
+            processed_context = processed_context.replace(mention, &mentioned_user.name);
+        }
+    }
+
     let user = {
         let db = database.get()?;
         let mut statement = db.prepare("SELECT * FROM user WHERE id = ?").unwrap();
@@ -59,12 +49,7 @@ pub async fn main(
         }
     };
 
-    let User {
-        name,
-        level,
-        xp,
-        ..
-    } = user;
+    let User { name, level, xp, .. } = user;
 
     // Create agent - smarter and more annoying
     let smart_agent = openai_client
@@ -91,7 +76,7 @@ You are replying to {name}.
 {name} is level: {level}, xp: {xp}.
 
 message context:
-{context}", ).replace("\\\n", ""))
+{}", processed_context).replace("\\\n", ""))
         .max_tokens(2048)
         .build();
 

src/brave.rs

@@ -51,6 +51,6 @@ impl BraveApi {
             .json::<BraveApiResponse>()
             .await?;
 
-        Ok(resp.web.and_then(|w| Some(w.results)).unwrap_or_default())
+        Ok(resp.web.map(|w| w.results).unwrap_or_default())
     }
 }

src/commands/level.rs

@@ -2,7 +2,6 @@
 
 use std::sync::Arc;
 
-use num_format::{Locale, ToFormattedString};
 use serde_rusqlite::{from_row, from_rows};
 use tokio::sync::Mutex;
 

src/config.rs

@@ -31,8 +31,8 @@ pub struct Config {
     pub openai_api_key: Option<String>,
     #[arg(long, env)]
     pub today_i_channel: Option<u64>,
-    #[arg(long,env)]
-    pub brave_api: Option<String>
+    #[arg(long, env)]
+    pub brave_api: Option<String>,
 }
 
 fn parse_str_array(src: &str) -> Result<Arc<Vec<String>>, io::Error> {
@@ -44,7 +44,7 @@ fn parse_invites(src: &str) -> Result<HashMap<String, String>, io::Error> {
     for pair in src.split(',') {
         let (key, value) = match pair.split_once(':') {
             Some(v) => v,
-            None => return Err(io::Error::new(io::ErrorKind::Other, "Invalid invite format")),
+            None => return Err(io::Error::other("Invalid invite format")),
         };
         map.insert(key.to_string(), value.parse().unwrap());
     }

src/event_handler.rs

@@ -4,22 +4,11 @@ use rand::Rng;
 use tokio::{join, sync::Mutex};
 use twilight_gateway::Event;
 use twilight_http::{request::channel::reaction::RequestReactionType, Client as HttpClient};
-use twilight_model::{
-    channel::message::AllowedMentions,
-    gateway::presence::Status,
-    id::{
-        marker::{ChannelMarker, UserMarker},
-        Id,
-    },
-};
+use twilight_model::{channel::message::AllowedMentions, id::Id};
 use vesper::prelude::*;
 
 use std::{sync::Arc, time::Duration};
 
-const AETHOR_ID: Id<UserMarker> = Id::new(870383692403593226);
-const GENERAL_ID: Id<ChannelMarker> = Id::new(748957504666599507);
-const TRICKED_ID: u64 = 336465356304678913;
-
 pub async fn handle_event(
     event: Event,
     http: &Arc<HttpClient>,
@@ -28,20 +17,6 @@ pub async fn handle_event(
 ) -> color_eyre::Result<()> {
     let mut locked_state = state.lock().await;
     match event {
-        Event::PresenceUpdate(p) => {
-            if p.user.id() == AETHOR_ID && p.status == Status::Offline {
-                for _ in 0..10 {
-                    http.create_message(GENERAL_ID)
-                        .content("AETHOR WENT OFFLINE <@{TRICKED_ID}> <@{TRICKED_ID}>")?
-                        .allowed_mentions(Some(&AllowedMentions {
-                            users: vec![Id::new(TRICKED_ID)],
-                            ..Default::default()
-                        }))
-                        .exec()
-                        .await?;
-                }
-            }
-        }
         Event::InteractionCreate(i) => {
             tracing::info!("Slash Command!");
             tokio::spawn(async move {
@@ -135,14 +110,6 @@ pub async fn handle_event(
             if rand::thread_rng().gen_range(0..100) != 1 {
                 return Ok(());
             }
-
-            if !locked_state
-                .config
-                .message_indicator_channels
-                .contains(&event.channel_id.get())
-            {
-                return Ok(());
-            }
             if event.user_id.get() == locked_state.last_typer {
                 return Ok(());
             }

src/message_handler.rs

@@ -228,7 +228,7 @@ pub async fn handle_message(
             Ok(Command::text(text.join(" ")).reply())
         }
 
-        _ if locked_state.rng.gen_range(0..40) == 2 && !locked_state.config.shit_reddits.is_empty() => {
+        _ if locked_state.rng.gen_range(0..30) == 2 && !locked_state.config.shit_reddits.is_empty() => {
             let res = locked_state
                 .client
                 .get(format!(

src/structs.rs

@@ -10,10 +10,7 @@ use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use twilight_bucket::{Bucket, Limit};
 use twilight_cache_inmemory::InMemoryCache;
-use twilight_model::{
-    channel::message::Embed,
-    http::attachment::Attachment, id::Id,
-};
+use twilight_model::{channel::message::Embed, http::attachment::Attachment, id::Id};
 use vesper::twilight_exports::ChannelMarker;
 
 use crate::{brave::BraveApi, config::Config};
@@ -76,7 +73,6 @@ impl Command {
     }
 }
 
-
 /// This struct is used to store the state of the bot.\
 /// It is used to store the cache, the database connection, the config and the http client.
 pub struct State {