use libgit2 to track PRs (#10)v0.2.0

* nix: don't depend on registry for nixpkgs input

* use libgit2 to track PRs

* nix: don't use ci devShell as defaul

* crates: bump serenity from `9ad74d4` to `0.12.2

* nix: fix cross compiled builds

* crates: split more from client

* bot-jobs: update remote refs more efficiently

* git-tracker: account for HEAD commits

* bot-config: use nixpkgs branches from environment

* bot-commands: don't display branches prs haven't landed in

* git-tracker: return false when commits aren't found

this is annoying as a hard error since it turns out github will report
garbage merge commit SHAs for PRs that *haven't* been merged yet. yay

* bot: improve docs in some places

* bot-client: display invite link on start

* bot-http: add TeawieClientExt

* bot-commands: add /about

* docs: update readme todos

* nix: enable StateDirectory in module

* crates: bump to 0.2.0

1 files changed, 112 insertions, 0 deletions

diff --git a/crates/bot-client/src/handler.rs b/crates/bot-client/src/handler.rs
new file mode 100644
index 0000000..2cd0082
--- /dev/null
+++ b/crates/bot-client/src/handler.rs
@@ -0,0 +1,112 @@
+use crate::{SharedConfig, SharedHttp};
+use bot_error::Error;
+
+use log::{debug, error, info, trace, warn};
+use serenity::all::CreateBotAuthParameters;
+use serenity::async_trait;
+use serenity::builder::{
+	CreateEmbed, CreateInteractionResponse, CreateInteractionResponseFollowup,
+	CreateInteractionResponseMessage,
+};
+use serenity::model::{
+	application::{Command, CommandInteraction, Interaction},
+	colour::Colour,
+	gateway::Ready,
+};
+use serenity::prelude::{Context, EventHandler};
+
+#[derive(Clone, Copy, Debug)]
+pub struct Handler;
+
+impl Handler {
+	async fn register_commands(&self, ctx: &Context) -> Result<(), Error> {
+		let commands = bot_commands::to_vec();
+		let commands_len = commands.len();
+		for command in commands {
+			Command::create_global_command(&ctx.http, command).await?;
+		}
+
+		debug!("Registered {} commands", commands_len);
+		Ok(())
+	}
+
+	/// Dispatch our commands from a [`CommandInteraction`]
+	async fn dispatch_command(ctx: &Context, command: &CommandInteraction) -> Result<(), Error> {
+		let command_name = command.data.name.as_str();
+
+		// grab our configuration & http client from the aether
+		let (http, config) = {
+			let read = ctx.data.read().await;
+			let http = read
+				.get::<SharedHttp>()
+				.ok_or("Couldn't get shared HTTP client! WHY??????")?
+				.clone();
+			let config = read
+				.get::<SharedConfig>()
+				.ok_or("Couldn't get shared bot configuration!")?
+				.clone();
+			(http, config)
+		};
+
+		match command_name {
+			"about" => bot_commands::about::respond(ctx, &http, command).await?,
+			"ping" => bot_commands::ping::respond(ctx, command).await?,
+			"track" => bot_commands::track::respond(ctx, &http, &config, command).await?,
+			_ => {
+				let message = CreateInteractionResponseMessage::new().content(format!(
+					"It doesn't look like you can use `{command_name}`. Sorry :("
+				));
+				let response = CreateInteractionResponse::Message(message);
+				command.create_response(&ctx, response).await?;
+			}
+		};
+
+		Ok(())
+	}
+
+	async fn invite_link(ctx: &Context) {
+		if let Ok(invite_link) = CreateBotAuthParameters::new().auto_client_id(ctx).await {
+			let link = invite_link.build();
+			info!("You can install me as an app at {link}");
+		} else {
+			warn!("Couldn't figure out our own client ID! Something might be wrong");
+		}
+	}
+}
+
+#[async_trait]
+impl EventHandler for Handler {
+	/// Dispatch our commands and try to handle errors from them
+	async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
+		if let Interaction::Command(command) = interaction {
+			let command_name = &command.data.name;
+			trace!("Received command: {}", command_name);
+
+			if let Err(why) = Handler::dispatch_command(&ctx, &command).await {
+				error!(
+					"Ran into an error while dispatching command {}:\n{why:?}",
+					command_name
+				);
+
+				let embed = CreateEmbed::new()
+					.title("An error occurred")
+					.description("Sorry about that!")
+					.color(Colour::RED);
+				let response = CreateInteractionResponseFollowup::new().embed(embed);
+
+				if let Err(why) = command.create_followup(&ctx.http, response).await {
+					error!("Ran into an error while trying to recover from an error!\n{why:?}");
+				}
+			}
+		}
+	}
+
+	async fn ready(&self, ctx: Context, ready: Ready) {
+		info!("Connected as {}!", ready.user.name);
+		Handler::invite_link(&ctx).await;
+
+		if let Err(why) = self.register_commands(&ctx).await {
+			error!("Couldn't register commands!\n{why:?}");
+		};
+	}
+}