add registerCommands() method

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ApplicationCommandDefinition.java

@@ -0,0 +1,20 @@
+package net.tomatentum.marinara.interaction.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public record ApplicationCommandDefinition(
+    List<ExecutableCommandDefinition> executableDefinitons,
+    String applicationCommand
+) {
+
+    public ApplicationCommandDefinition(String applicationCommand) {
+        this(new ArrayList<>(), applicationCommand);
+    }
+
+    public ApplicationCommandDefinition addExecutableCommand(ExecutableCommandDefinition def) {
+        executableDefinitons.add(def);
+        return this;
+    }
+
+}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ExecutableCommandDefinition.java

@@ -1,12 +1,22 @@
 package net.tomatentum.marinara.interaction.commands;
 
-public record CommandDefinition(String applicationCommand, String applicationCommandDescription, String[] subCommandGroups, String subCommand, String subCommandDescription) {
+import org.apache.logging.log4j.core.tools.picocli.CommandLine.Command;
+
+import net.tomatentum.marinara.interaction.commands.annotation.CommandOption;
+
+public record ExecutableCommandDefinition(
+    String applicationCommand,
+    String applicationCommandDescription, 
+    String[] subCommandGroups, 
+    String subCommand, 
+    String subCommandDescription,
+    CommandOption[] options) {
 
     @Override
     public final boolean equals(Object o) {
-        if (!(o instanceof CommandDefinition))
+        if (!(o instanceof ExecutableCommandDefinition))
             return false;
-        CommandDefinition other = (CommandDefinition) o;
+        ExecutableCommandDefinition other = (ExecutableCommandDefinition) o;
         return other.applicationCommand.equals(this.applicationCommand) && 
             other.subCommandGroups.equals(this.subCommandGroups) &&
             other.subCommand.equals(this.subCommand);
@@ -18,16 +28,17 @@ public record CommandDefinition(String applicationCommand, String applicationCom
         private String[] subCommandGroupNames;
         private String subCommandName;
         private String subCommandDescription;
+        public CommandOption[] options;
 
         public Builder() {
             this.subCommandGroupNames = new String[0];
         }
 
-        public CommandDefinition build() {
+        public ExecutableCommandDefinition build() {
             if (applicationCommandName == null)
                 throw new IllegalArgumentException("applicationCommandName cant be null");
 
-            return new CommandDefinition(applicationCommandName, applicationCommandDescription, subCommandGroupNames, subCommandName, subCommandDescription);
+            return new ExecutableCommandDefinition(applicationCommandName, applicationCommandDescription, subCommandGroupNames, subCommandName, subCommandDescription, options);
         }
 
         public void setApplicationCommandName(String applicationCommandName) {
@@ -50,6 +61,10 @@ public record CommandDefinition(String applicationCommand, String applicationCom
             this.subCommandDescription = subCommandDescription;
         }
 
+        public void setOptions(CommandOption[] options) {
+            this.options = options;
+        }
+
         public String getApplicationCommandName() {
             return applicationCommandName;
         }
@@ -69,5 +84,9 @@ public record CommandDefinition(String applicationCommand, String applicationCom
         public String getSubCommandDescription() {
             return subCommandDescription;
         }
+
+        public CommandOption[] getOptions() {
+            return options;
+        }
     }
 }

lib/src/main/java/net/tomatentum/marinara/interaction/methods/CommandInteractionMethod.java

@@ -3,7 +3,7 @@ package net.tomatentum.marinara.interaction.methods;
 import java.lang.reflect.Method;
 
 import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.CommandDefinition;
+import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.CommandOption;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
@@ -14,9 +14,7 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class CommandInteractionMethod extends InteractionMethod {
 
-    private CommandOption[] options;
+    private ExecutableCommandDefinition commandDefinition;
-
-    private CommandDefinition commandDefinition;
 
     CommandInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
         super(method, handler, wrapper);
@@ -25,12 +23,12 @@ public class CommandInteractionMethod extends InteractionMethod {
 
     @Override
     public Object getParameter(Object context, int index) {
-        return wrapper.convertCommandOption(context, options[index].type(), options[index].name());
+        return wrapper.convertCommandOption(context, commandDefinition.options()[index].type(), commandDefinition.options()[index].name());
     }
 
     @Override
     public boolean canRun(Object context) {
-        CommandDefinition other = wrapper.getCommandDefinition(context);
+        ExecutableCommandDefinition other = wrapper.getCommandDefinition(context);
         return commandDefinition.equals(other);
     }
 
@@ -39,22 +37,18 @@ public class CommandInteractionMethod extends InteractionMethod {
         return InteractionType.COMMAND;
     }
 
-    public CommandOption[] getOptions() {
+    public ExecutableCommandDefinition getCommandDefinition() {
-        return options;
-    }
-
-    public CommandDefinition getCommandDefinition() {
         return commandDefinition;
     }
 
     private void parseMethod() {
         ReflectionUtil.checkValidCommandMethod(method);
-        parseOptions();
 
         ApplicationCommand cmd = ReflectionUtil.getAnnotation(method, ApplicationCommand.class);
-        CommandDefinition.Builder builder = new CommandDefinition.Builder();
+        ExecutableCommandDefinition.Builder builder = new ExecutableCommandDefinition.Builder();
         builder.setApplicationCommandName(cmd.name());
         builder.setApplicationCommandDescription(cmd.description());
+        builder.setOptions(parseOptions());
 
         if (ReflectionUtil.isAnnotationPresent(method, SubCommandGroup.class)) {
             SubCommandGroup cmdGroup = ReflectionUtil.getAnnotation(method, SubCommandGroup.class);

lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java

@@ -1,10 +1,15 @@
 package net.tomatentum.marinara.registry;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 import net.tomatentum.marinara.handler.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.commands.ApplicationCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
+import net.tomatentum.marinara.interaction.methods.CommandInteractionMethod;
 import net.tomatentum.marinara.interaction.methods.InteractionMethod;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
@@ -23,6 +28,24 @@ public class InteractionRegistry {
         }
     }
 
+    public void registerCommands() {
+        List<ApplicationCommandDefinition> defs = new ArrayList<>();
+        List<ExecutableCommandDefinition> execDefs = interactionMethods.stream()
+            .filter((x) -> x.getClass().isAssignableFrom(CommandInteractionMethod.class))
+            .map((x) -> ((CommandInteractionMethod)x).getCommandDefinition())
+            .toList();
+
+        execDefs.forEach((def) -> {
+            Optional<ApplicationCommandDefinition> appDef = defs.stream()
+                .filter((x) -> x.applicationCommand().equals(def.applicationCommand()))
+                .findFirst();
+            if (appDef.isPresent())
+                appDef.get().addExecutableCommand(def);
+            else
+                defs.add(new ApplicationCommandDefinition(def.applicationCommand()).addExecutableCommand(def));
+        });
+    }
+
     public void handle(Object context) {
         interactionMethods.forEach((m) -> {
             InteractionType type = wrapper.getInteractionType(context.getClass());

lib/src/main/java/net/tomatentum/marinara/wrapper/LibraryWrapper.java

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
-import net.tomatentum.marinara.interaction.commands.CommandDefinition;
+import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.option.OptionType;
 import net.tomatentum.marinara.interaction.InteractionType;
 
@@ -32,5 +32,5 @@ public abstract class LibraryWrapper {
 
     public abstract InteractionType getInteractionType(Class<?> clazz);
     public abstract Object convertCommandOption(Object context, OptionType type, String optionName);
-    public abstract CommandDefinition getCommandDefinition(Object context);
+    public abstract ExecutableCommandDefinition getCommandDefinition(Object context);
 }