send command

src/main.rs

@@ -1,3 +1,75 @@
-fn main() {
-    println!("Hello, world!");
+use poise::PrefixFrameworkOptions;
+use tracing::{error, info};
+
+mod checks;
+mod commands;
+
+pub mod prelude {
+    pub use poise::serenity_prelude as serenity;
+    pub struct KBotData {}
+    pub type Error = Box<dyn std::error::Error + Send + Sync>;
+    pub type Context<'a> = poise::Context<'a, KBotData, Error>;
+    pub type CommandResult = Result<(), Error>;
+}
+use prelude::*;
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+
+    dotenv::dotenv().ok();
+
+    let token = std::env::var("DISCORD_TOKEN").expect("missing DISCORD_TOKEN");
+
+    let intents =
+        serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
+
+    let framework = poise::Framework::builder()
+        .options(poise::FrameworkOptions {
+            commands: commands::get(),
+            prefix_options: PrefixFrameworkOptions {
+                prefix: Some(",".into()),
+                ..Default::default()
+            },
+            on_error: |error| Box::pin(on_error(error)),
+            ..Default::default()
+        })
+        .setup(|ctx, ready, framework| {
+            Box::pin(async move {
+                info!("Logged in as {}", ready.user.name);
+                poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                Ok(KBotData {})
+            })
+        })
+        .build();
+
+    let client = serenity::ClientBuilder::new(token, intents)
+        .framework(framework)
+        .await;
+    client.unwrap().start().await.unwrap();
+}
+
+async fn on_error(error: poise::FrameworkError<'_, KBotData, Error>) {
+    match error {
+        poise::FrameworkError::Command { error, ctx, .. } => {
+            let error = error;
+            error!("Error in command `{}`: {}", ctx.command().name, error,);
+            let _ = ctx.say("Failed to run command.".to_string()).await;
+        }
+        // poise::FrameworkError::ArgumentParse {
+        //     error, input, ctx, ..
+        // } => {
+        //     debug!(
+        //         "Failed to parse argument `{:?}` for command `{}`: {}",
+        //         input,
+        //         ctx.command().name,
+        //         error
+        //     );
+        // }
+        error => {
+            if let Err(e) = poise::builtins::on_error(error).await {
+                error!("Error while handling error: {}", e);
+            }
+        }
+    }
 }