Add alias for compound labels

Configure relabel command aliases from the `triagebot.toml`.
When a valid alias is parsed, it will be replaced with the labels configured.

Example configuration:
```
[relabel.cmd-alias]
add-labels = ["Foo", "Bar"]
rem-labels = ["Baz"]
```

The command `@rustbot label cmd-alias` will translate to:
```
@rustbot label +Foo +Bar -Baz
```

The command `@rustbot label -cmd-alias` will translate to:
```
@rustbot label +Baz -Foo -Bar
```

Note: self-canceling labels will be omitted.
The command `@rustbot label cmd-alias +Bar` will translate to:
```
@rustbot label -Foo -Bar
```

Author: apiraino

parser/src/command/relabel.rs

@@ -102,6 +102,7 @@ fn delta_empty() {
 }
 
 impl RelabelCommand {
+    /// Parse and validate command tokens
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
         let mut toks = input.clone();
 

src/config.rs

@@ -1,5 +1,6 @@
 use crate::changelogs::ChangelogFormat;
 use crate::github::{GithubClient, Repository};
+use parser::command::relabel::{Label, LabelDelta, RelabelCommand};
 use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::sync::{Arc, LazyLock, RwLock};
@@ -250,10 +251,62 @@ pub(crate) struct MentionsEntryConfig {
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
-#[serde(deny_unknown_fields)]
 pub(crate) struct RelabelConfig {
     #[serde(default)]
     pub(crate) allow_unauthenticated: Vec<String>,
+    // alias identifier -> labels
+    #[serde(flatten)]
+    pub(crate) configs: Option<HashMap<String, RelabelRuleConfig>>,
+}
+
+impl RelabelConfig {
+    pub(crate) fn retrieve_command_from_alias(&self, input: RelabelCommand) -> RelabelCommand {
+        match &self.configs {
+            Some(configs) => {
+                dbg!(&configs);
+                // get only the first token from the command
+                // extract the "alias" from the RelabelCommand
+                if input.0.len() > 0 {
+                    let name = input.0.get(0).unwrap();
+                    let name = name.label().as_str();
+                    // check if this alias matches any RelabelRuleConfig key in our config
+                    // extract the labels and build a new command
+                    if configs.contains_key(name) {
+                        let (_alias, cfg) = configs.get_key_value(name).unwrap();
+                        return cfg.to_command();
+                    }
+                }
+            }
+            None => {
+                return input;
+            }
+        };
+        input
+    }
+}
+
+#[derive(Default, PartialEq, Eq, Debug, serde::Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[serde(deny_unknown_fields)]
+pub(crate) struct RelabelRuleConfig {
+    /// Labels to be added
+    pub(crate) add_labels: Vec<String>,
+    /// Labels to be removed
+    pub(crate) rem_labels: Vec<String>,
+}
+
+impl RelabelRuleConfig {
+    /// Translate a RelabelRuleConfig into a RelabelCommand for GitHub consumption
+    pub fn to_command(&self) -> RelabelCommand {
+        let mut deltas = Vec::new();
+        for l in self.add_labels.iter() {
+            deltas.push(LabelDelta::Add(Label(l.into())));
+        }
+        for l in self.rem_labels.iter() {
+            deltas.push(LabelDelta::Remove(Label(l.into())));
+        }
+        RelabelCommand(deltas)
+    }
 }
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
@@ -761,11 +814,11 @@ mod tests {
 
             [mentions."src/"]
             cc = ["@someone"]
-            
+
             [mentions."target/"]
             message = "This is a message."
             cc = ["@someone"]
-            
+
             [mentions."#[rustc_attr]"]
             type = "content"
             message = "This is a message."
@@ -835,6 +888,7 @@ mod tests {
             Config {
                 relabel: Some(RelabelConfig {
                     allow_unauthenticated: vec!["C-*".into()],
+                    configs: Some(HashMap::new())
                 }),
                 assign: Some(AssignConfig {
                     warn_non_default_branch: WarnNonDefaultBranchConfig::Simple(false),
@@ -1092,5 +1146,36 @@ Multi text body with ${mcp_issue} and ${mcp_title}
                 })
             })
         );
+
+        fn relabel_new_config() {
+            let config = r#"
+            [relabel]
+            allow-unauthenticated = ["ABCD-*"]
+
+            [relabel.to-stable]
+            add-labels = ["regression-from-stable-to-stable"]
+            rem-labels = ["regression-from-stable-to-beta", "regression-from-stable-to-nightly"]
+        "#;
+            let config = toml::from_str::<Config>(&config).unwrap();
+
+            let mut relabel_configs = HashMap::new();
+            relabel_configs.insert(
+                "to-stable".into(),
+                RelabelRuleConfig {
+                    add_labels: vec!["regression-from-stable-to-stable".to_string()],
+                    rem_labels: vec![
+                        "regression-from-stable-to-beta".to_string(),
+                        "regression-from-stable-to-nightly".to_string(),
+                    ],
+                },
+            );
+
+            let expected_cfg = RelabelConfig {
+                allow_unauthenticated: vec!["ABCD-*".to_string()],
+                configs: Some(relabel_configs),
+            };
+
+            assert_eq!(config.relabel, Some(expected_cfg));
+        }
     }
 }

src/handlers/relabel.rs

@@ -26,14 +26,18 @@ pub(super) async fn handle_command(
     event: &Event,
     input: RelabelCommand,
 ) -> anyhow::Result<()> {
-    let Some(issue) = event.issue() else {
-        return user_error!("Can only add and remove labels on an issue");
-    };
+    let mut to_rem = vec![];
+    let mut to_add = vec![];
+
+    // If the input matches a valid alias, read the [relabel] config.
+    // if any alias matches, extract the alias config (RelabelRuleConfig) and build a new RelabelCommand.
+    // Discard anything after the alias.
+    let new_input = config.retrieve_command_from_alias(input);
 
-    // Check label authorization for the current user
-    for delta in &input.0 {
-        let name = delta.label() as &str;
-        let err = match check_filter(name, config, is_member(event.user(), &ctx.team).await) {
+    // Parse input label command, checks permissions, built GitHub commands
+    for delta in &new_input.0 {
+        let name = delta.label().as_str();
+        let err = match check_filter(name, config, is_member(&event.user(), &ctx.team).await) {
             Ok(CheckFilterResult::Allow) => None,
             Ok(CheckFilterResult::Deny) => {
                 Some(format!("Label {name} can only be set by Rust team members"))
@@ -44,6 +48,7 @@ pub(super) async fn handle_command(
             )),
             Err(err) => Some(err),
         };
+
         if let Some(err) = err {
             // bail-out and inform the user why
             return user_error!(err);
@@ -103,6 +108,8 @@ enum CheckFilterResult {
     DenyUnknown,
 }
 
+/// Check if the team member is allowed to apply labels
+/// configured in `allow_unauthenticated`
 fn check_filter(
     label: &str,
     config: &RelabelConfig,
@@ -232,6 +239,7 @@ mod tests {
             ($($member:ident { $($label:expr => $res:ident,)* })*) => {
                 let config = RelabelConfig {
                     allow_unauthenticated: vec!["T-*".into(), "I-*".into(), "!I-*nominated".into()],
+                    configs: None
                 };
                 $($(assert_eq!(
                     check_filter($label, &config, TeamMembership::$member),