fix: brigadier error when only optional flags and switches

brigadier/src/main/java/revxrsal/commands/brigadier/BrigadierParser.java

@@ -101,107 +101,109 @@
      * @param command Command to wrap
      * @return The equivalent node
      */
     public @NotNull LiteralCommandNode<S> createNode(@NotNull ExecutableCommand<A> command) {
         final BNode<S> firstNode = BNode.literal(command.firstNode().name());
         firstNode.requires(createRequirement(command.permission(), command.lamp()));
 
         BNode<S> lastNode = firstNode;
 
         @Unmodifiable List<revxrsal.commands.node.CommandNode<A>> nodes = command.nodes();
         for (int i = 1; i < nodes.size(); i++) {
             revxrsal.commands.node.CommandNode<A> node = nodes.get(i);
             BNode<S> elementNode;
             if (node.isLiteral()) {
                 elementNode = BNode.literal(node.name());
                 elementNode.requires(createRequirement(command.permission(), command.lamp()));
             } else if (node instanceof ParameterNode) {
                 ParameterNode<A, ?> parameter = (ParameterNode<A, ?>) node;
                 if (parameter.isSwitch() || parameter.isFlag())
                     break;
                 elementNode = BNode.of(ofParameter(parameter));
 
                 if (parameter.isOptional())
                     lastNode.executes(createAction(command));
 
             } else {
                 throw new UnsupportedOperationException(); // for completeness
             }
             lastNode.then(elementNode);
             lastNode = elementNode;
         }
         if (!command.containsFlags()) {
             lastNode.executes(createAction(command));
             return (LiteralCommandNode<S>) firstNode.asBrigadierNode();
         }
 
         List<ParameterNode<A, Object>> flags = filter(command.parameters().values(), v -> v.isFlag() || v.isSwitch());
         if (command.flagCount() <= 4) { // An arbitrary limit that is a good balance between a large tree and a beautiful one
             List<RootCommandNode<S>> roots = new ArrayList<>();
             for (List<ParameterNode<A, Object>> p : generatePermutations(flags)) {
                 RootCommandNode<S> root = new RootCommandNode<>();
                 roots.add(root);
                 BNode<S> thisNode = BNode.of(root);
                 for (ParameterNode<A, Object> parameter : p) {
                     if (parameter.isSwitch()) {
                         BNode<S> ofSwitch = ofSwitch(parameter);
                         thisNode.then(ofSwitch);
                         thisNode.executes(createAction(command));
 
                         thisNode = ofSwitch;
                     } else {
                         BNode<S> ofFlag = ofFlag(parameter);
                         thisNode.then(ofFlag);
 
                         if (parameter.isOptional()) {
                             thisNode.executes(createAction(command));
                         }
 
                         thisNode = ofFlag.nextChild();
                     }
                 }
                 thisNode.executes(createAction(command));
             }
             for (RootCommandNode<S> root : roots) {
                 for (CommandNode<S> child : root.getChildren()) {
                     lastNode.then(child);
                 }
             }
+            if (flags.stream().allMatch(p -> p.isSwitch() || p.isOptional()))
+                lastNode.executes(createAction(command));
             return (LiteralCommandNode<S>) firstNode.asBrigadierNode();
         }
         List<BNode<S>> addOptionalsTo = new ArrayList<>();
         for (ParameterNode<A, Object> parameter : flags) {
             if (parameter.isSwitch()) {
                 BNode<S> ofSwitch = ofSwitch(parameter);
                 addOptionalsTo.forEach(genNode -> {
                     genNode.then(ofSwitch);
                     genNode.executes(createAction(command));
                 });
                 lastNode.then(ofSwitch);
                 lastNode.executes(createAction(command));
                 addOptionalsTo.add(ofSwitch);
             } else if (parameter.isFlag()) {
                 BNode<S> ofFlag = ofFlag(parameter);
                 addOptionalsTo.forEach(genNode -> genNode.then(ofFlag));
                 if (parameter.isOptional()) {
                     if (addOptionalsTo.isEmpty())
                         lastNode.executes(createAction(command));
                     else
                         addOptionalsTo.forEach(genNode -> genNode.executes(createAction(command)));
                 }
                 lastNode.then(ofFlag);
                 addOptionalsTo.add(ofFlag.nextChild());
                 if (parameter.isRequired()) {
                     lastNode = ofFlag.nextChild();
                 }
             }
         }
         if (!addOptionalsTo.isEmpty())
             addOptionalsTo.forEach(genNode -> genNode.executes(createAction(command)));
         else
             lastNode.executes(createAction(command));
         return (LiteralCommandNode<S>) firstNode.asBrigadierNode();
     }
 
     private @NotNull <T> ArgumentCommandNode<S, T> ofParameter(ParameterNode<A, T> parameter) {
         @SuppressWarnings("unchecked")
         RequiredArgumentBuilder<S, T> builder = (RequiredArgumentBuilder<S, T>) RequiredArgumentBuilder