Redirects are Brigadier's form of aliases and subcommands. The redirect method takes a command node and an optional modifier of context. The command node can be a specific node after a registration of dispathcer, or just the root node.

In vanilla Minecraft, /tell and /w are redirected to /msg, which you can see in MessageCommand.

The example shows how /foo2 redirects to /foo.

public class ExampleMod implements ModInitializer {
  @Override
  public void onInitialize() {
    CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
      final LiteralCommandNode<ServerCommandSource> fooNode = dispatcher.register(literal("foo")
          .executes(context -> {
            context.getSource().sendFeedback(() -> Text.literal("Called /foo with no arguments"), true);
 
            return 1;
          }));
      dispatcher.register(literal("foo2").redirect(fooNode));
    });
  }
}

The redirect tells brigadier to continue parsing the command at another command node. That's to say, what's after the “foo2” node is right what's after the “foo” node.

The redirection target may not always be the root node. Commans can be redirected to sub-nodes, including arguments.

Commands such as /execute as @e[type=player] in the_end run tp ~ ~ ~ are also possible because of redirects.

Let's first consider the vanilla /execute command. There is a node after the literal("execute"). After dispatching subcommands, the dispatcher is redirected to that node (with some modifiers), making you possible to, after completing sub-command arguments, type whatever can be typed directly after /execute. In the sub-command run, the dispatcher is redirected to the root node (dispatcher.getRoot()), allowing you to type another complete command after the word “run”.

Below is an example of a chainable command:

LiteralCommandNode<ServerCommandSource> rootNode = dispatcher.register(literal("fabric_test"));
LiteralCommandNode<ServerCommandSource> root1 = dispatcher.register(literal("fabric_test") 
    // You can register under the same literal more than once, it will just register new parts 
    // of the branch as shown below if you register a duplicate branch an error will popup in 
    // console warning of conflicting commands but one will still work.
    .then(literal("extra")
        .then(literal("long")
            .redirect(rootNode, this::lengthen)) // Return to root for chaining
        .then(literal("short")
            .redirect(rootNode, this::shorten))) // Return to root for chaining
        .then(literal("command")
            .executes(ctx -> {
                ctx.getSource().sendFeedback(() -> Text.literal("Chainable Command"), true);
                return Command.SINGLE_SUCCESS;
            })));

The redirect can also modify the CommandSource by use of a “redirect modifier” (SingleRedirectModifier<S>), which is usually used as a lambda.

            .redirect(rootNode, context -> {
                // When redirecting, modify the looking direction of the command source.
                return context.getSource().withLookingAt(Vec3ArgumentType.getVec3(context, "pos"));
            })

In the redirect modifier, only arguments after the redirected nodes can be used. Meanwhile, arguments before the redirect modifier cannot be used in subsequent redirections (if any) or the final execution.