start adding "hot-commands"

shortcut commands that can be trusted

Author: diamonddevv

autodocs/autodoc.lua

@@ -2,7 +2,7 @@
 
 --#region Information
 -- GENERATED AUTODOC
--- Generated: 2026-01-30T13:06:47.943709500
+-- Generated: 2026-02-04T09:55:52.319589400
 -- Luafy Version: 2.0.0
 -- Format: Lua LS library file
 --#endregion

src/main/java/dev/diamond/luafy/Luafy.java

@@ -51,6 +51,7 @@ public void onInitialize() {
 		ScriptPlugins.registerAll();
 		ScriptEnums.registerAll();
 		ScriptObjects.registerAll();
+		ScriptArgtypes.registerAll();
 		ScriptEvents.registerAll();
 		ScriptEvents.applyEvents();
 		AutodocGenerators.registerAll();

src/main/java/dev/diamond/luafy/autodoc/Argtype.java

@@ -1,5 +1,49 @@
 package dev.diamond.luafy.autodoc;
 
-public interface Argtype {
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.suggestion.SuggestionProvider;
+import dev.diamond.luafy.script.LuaScript;
+import net.minecraft.commands.CommandBuildContext;
+import net.minecraft.commands.CommandSourceStack;
+import org.jspecify.annotations.Nullable;
+import org.luaj.vm2.LuaValue;
+
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+public interface Argtype<T extends LuaValue, S> {
     String getArgtypeString();
+    Optional<ArgumentType<?>> getCommandArgumentType(CommandBuildContext ctx);
+    Optional<T> parseCommand(CommandContext<CommandSourceStack> cmdCtx, String argName, LuaScript script);
+    Optional<SuggestionProvider<CommandSourceStack>> suggest();
+
+    static <T extends LuaValue, S> Argtype<T, S> of(String arg, @Nullable ArgumentType<S> commandArgumentType, @Nullable BiFunction<CommandContext<?>, String, T> parser, @Nullable SuggestionProvider<CommandSourceStack> suggestionProvider) {
+        return new Argtype<>() {
+            @Override
+            public String getArgtypeString() {
+                return arg;
+            }
+
+            @Override
+            public Optional<ArgumentType<?>> getCommandArgumentType(CommandBuildContext ctx) {
+                return Optional.ofNullable(commandArgumentType);
+            }
+
+            @Override
+            public Optional<T> parseCommand(CommandContext<CommandSourceStack> cmdCtx, String argName, LuaScript script) {
+                if (parser == null) return Optional.empty();
+                return Optional.ofNullable(parser.apply(cmdCtx, argName));
+            }
+
+            @Override
+            public Optional<SuggestionProvider<CommandSourceStack>> suggest() {
+                return Optional.ofNullable(suggestionProvider);
+            }
+        };
+    }
+
+    static <T extends LuaValue, S> Argtype<T, S> of(String arg) {
+        return of(arg, null, null, null);
+    }
 }

src/main/java/dev/diamond/luafy/autodoc/Argtypes.java

@@ -1,26 +1,36 @@
 package dev.diamond.luafy.autodoc;
 
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.arguments.FloatArgumentType;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.datafixers.util.Either;
+import org.luaj.vm2.*;
+
+import java.util.List;
+import java.util.Optional;
+
 public class Argtypes {
 
     // since these are "primitives" they are in lowercase; this also ensures parity with LuaCATS and lua
     // other argtypes (enums, classes) should adhere to PascalCase like java class names
 
-    public static final Argtype NIL = () -> "nil";
-    public static final Argtype BOOLEAN = () -> "boolean";
-    public static final Argtype NUMBER = () -> "number";
-    public static final Argtype STRING = () -> "string";
-    public static final Argtype VALUE = () -> "any";
-    public static final Argtype INTEGER = () -> "integer";
-    public static final Argtype TABLE = () -> "table";
+    public static final Argtype<?, ?> NIL = Argtype.of("nil");
+    public static final Argtype<LuaBoolean, Boolean> BOOLEAN = Argtype.of("boolean", BoolArgumentType.bool(), (ctx, s) -> LuaValue.valueOf(BoolArgumentType.getBool(ctx, s)), null);
+    public static final Argtype<LuaNumber, Float> NUMBER = Argtype.of("number", FloatArgumentType.floatArg(), (ctx, s) -> LuaValue.valueOf(FloatArgumentType.getFloat(ctx, s)), null);
+    public static final Argtype<LuaString, String> STRING = Argtype.of("string", StringArgumentType.string(), (ctx, s) -> LuaValue.valueOf(StringArgumentType.getString(ctx, s)), null);
+    public static final Argtype<LuaValue, ?> VALUE = Argtype.of("any");
+    public static final Argtype<LuaInteger, Integer> INTEGER = Argtype.of("integer", IntegerArgumentType.integer(), (ctx, s) -> LuaValue.valueOf(IntegerArgumentType.getInteger(ctx, s)), null);
+    public static final Argtype<LuaTable, ?> TABLE = Argtype.of("table");
 
 
-    public static Argtype array(Argtype argtype) {
-        return () -> argtype.getArgtypeString() + "[]";
+    public static Argtype<?, ?> array(Argtype<?, ?> argtype) {
+        return Argtype.of(argtype.getArgtypeString() + "[]");
     }
-    public static Argtype or(Argtype a, Argtype b) {
-        return () -> a.getArgtypeString() + " | " + b.getArgtypeString();
+    public static Argtype<?, ?> or(Argtype<?, ?> a, Argtype<?, ?> b) {
+        return Argtype.of(a.getArgtypeString() + " | " + b.getArgtypeString());
     }
-    public static Argtype maybe(Argtype argtype) {
-        return () -> argtype.getArgtypeString() + " | nil";
+    public static Argtype<?, ?> maybe(Argtype<?, ?> argtype) {
+        return Argtype.of(argtype.getArgtypeString() + " | nil");
     }
 }

src/main/java/dev/diamond/luafy/command/HotCommand.java

@@ -1,16 +1,40 @@
 package dev.diamond.luafy.command;
 
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
 import com.mojang.brigadier.CommandDispatcher;
-import net.fabricmc.loader.api.FabricLoader;
+import com.mojang.brigadier.builder.ArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.JsonOps;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import dev.diamond.luafy.Luafy;
+import dev.diamond.luafy.autodoc.Argtype;
+import dev.diamond.luafy.lua.LuaTableBuilder;
+import dev.diamond.luafy.registry.LuafyRegistries;
+import dev.diamond.luafy.script.LuaScript;
 import net.fabricmc.loader.impl.FabricLoaderImpl;
+import net.minecraft.ChatFormatting;
 import net.minecraft.commands.CommandBuildContext;
 import net.minecraft.commands.CommandSourceStack;
 import net.minecraft.commands.Commands;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import org.luaj.vm2.LuaValue;
 
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
 import java.io.IOException;
 import java.nio.file.*;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class HotCommand {
 
@@ -19,39 +43,203 @@ public class HotCommand {
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher,
                                 CommandBuildContext buildCtx, Commands.CommandSelection selection) {
         // load files
-        // decode with codec
-        // register
+        List<JsonObject> objs = fetchHotCommandSources();
 
-    }
+        Luafy.LOGGER.info("Found {} hot-commands.", objs.size());
 
+        for (JsonObject obj : objs) {
+            // decode with codec
+            CommandBean bean = CommandBean.CODEC.decode(JsonOps.INSTANCE, obj).resultOrPartial(Luafy.LOGGER::error).orElseThrow().getFirst();
 
-    public static ArrayList<String> fetchHotCommandSources() {
-        Path path = FabricLoaderImpl.INSTANCE.getGameDir().resolve(PATH);
-        try {
-            Files.walkFileTree(path, new FileVisitor<>() {
+            // build
+            ArrayList<RequiredArgumentBuilder<CommandSourceStack, ?>> args = new ArrayList<>();
 
-                @Override
-                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
-                    
+            for (CommandArgumentBean arg : bean.args) {
+
+                Argtype<?, ?> argtype = LuafyRegistries.SERIALIZABLE_ARGTYPES.getValue(arg.argType);
+
+                if (argtype == null) {
+                    throw new RuntimeException("Argtype " + arg.argType + " was not in the registry!");
                 }
 
-                @Override
-                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
-                    return null;
+                RequiredArgumentBuilder<CommandSourceStack, ?> argument = argument(
+                        arg.argument,
+                        argtype.getCommandArgumentType(buildCtx).orElseThrow(
+                                () -> new RuntimeException("Argtype " + arg.argType + " is not deserializable from commands."))
+                );
+
+                var suggestor = argtype.suggest();
+                if (suggestor.isPresent()) {
+                    argument = argument.suggests(suggestor.get());
                 }
 
-                @Override
-                public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
-                    return null;
+                args.add(argument);
+            }
+
+            // build chain
+            var last = args.getLast().executes(ctx -> {
+
+                if (!Luafy.SCRIPT_MANAGER.has(bean.scriptId)) {
+                    ctx.getSource().sendSystemMessage(
+                            Component.literal("Script with id " + bean.scriptId + " was not found!").withStyle(ChatFormatting.RED)
+                    );
+                    return 0;
                 }
+                LuaScript script = Luafy.SCRIPT_MANAGER.get(bean.scriptId);
+
+                // build context table
+                var table = new LuaTableBuilder();
+                for (CommandArgumentBean arg : bean.args) {
+
+                    Argtype<?, ?> argtype = LuafyRegistries.SERIALIZABLE_ARGTYPES.getValue(arg.argType);
+
+                    if (argtype == null) {
+                        ctx.getSource().sendSystemMessage(
+                                Component.literal("Argtype " + arg.argType + " was not in the registry!").withStyle(ChatFormatting.RED)
+                        );
+                        return 0;
+                    }
+
+                    Optional<LuaValue> value = (Optional<LuaValue>) argtype.parseCommand(ctx, arg.argument, script);
+
+
+                    if (value.isPresent()) {
+                        table.add(arg.argument, value.get());
+                    } else {
+                        ctx.getSource().sendSystemMessage(
+                                Component.literal("Argument " +
+                                        arg.argument +
+                                        " of type " +
+                                        arg.argType +
+                                        " could not be deserialised.").withStyle(ChatFormatting.RED)
+                        );
+                        return 0;
+                    }
 
-                @Override
-                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
-                    return null;
                 }
+
+                var future = script.execute(
+                        ctx.getSource(),
+                        table.build()
+                );
+
+                if (bean.awaits) {
+                    try {
+                        var ignored = future.get(); // get to block until done
+                    } catch (InterruptedException | ExecutionException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+                return 1;
             });
+
+
+            for (int i = args.size() - 2; i >= 0; i--) {
+                last = args.get(i).then(last);
+            }
+
+            var branch = literal(bean.root).then(last);
+            
+            // register
+            dispatcher.register(branch);
+            Luafy.LOGGER.info("Registered hot-command branch '{}'.", bean.root);
+        }
+    }
+
+
+    public static List<JsonObject> fetchHotCommandSources() {
+        ArrayList<String> paths = new ArrayList<>();
+        Path path = FabricLoaderImpl.INSTANCE.getGameDir().resolve(PATH);
+
+        path.toFile().mkdirs();
+
+        try {
+            for (Path file : Files.walk(path).toList()) {
+                if (Files.isRegularFile(file)) {
+                    paths.add(file.toString());
+                }
+            }
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
+
+        Gson gson = new Gson();
+        return paths.stream().map(p -> {
+            try (FileReader reader = new FileReader(p)) {
+                return gson.fromJson(reader, JsonObject.class);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).toList();
+    }
+
+    public static class CommandBean {
+
+        public static final Codec<CommandBean> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.STRING.fieldOf("root_command").forGetter(CommandBean::getRootCommand),
+                CommandArgumentBean.CODEC.listOf().optionalFieldOf("args", new ArrayList<>()).forGetter(CommandBean::getArgs),
+                Identifier.CODEC.fieldOf("script").forGetter(CommandBean::getScriptId),
+                Codec.BOOL.optionalFieldOf("awaits", false).forGetter(CommandBean::awaits),
+                Codec.BOOL.optionalFieldOf("non_ops_can_run", false).forGetter(CommandBean::nonOpsCanRun)
+        ).apply(instance, CommandBean::new));
+
+
+        public String root;
+        public List<CommandArgumentBean> args;
+        public Identifier scriptId;
+        public boolean awaits;
+        public boolean nonOpsCanRun;
+
+        public CommandBean(String root, List<CommandArgumentBean> args, Identifier scriptId, boolean awaits, boolean nonOpsCanRun) {
+            this.root = root;
+            this.args = args;
+            this.scriptId = scriptId;
+            this.awaits = awaits;
+            this.nonOpsCanRun = nonOpsCanRun;
+        }
+
+        public String getRootCommand() {
+            return this.root;
+        }
+
+        public List<CommandArgumentBean> getArgs() {
+            return this.args;
+        }
+
+        public Identifier getScriptId() {
+            return this.scriptId;
+        }
+
+        public boolean awaits() {
+            return this.awaits;
+        }
+
+        public boolean nonOpsCanRun() {
+            return this.nonOpsCanRun;
+        }
+    }
+
+    public static class CommandArgumentBean {
+        public static final Codec<CommandArgumentBean> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.STRING.fieldOf("argument").forGetter(CommandArgumentBean::getArgument),
+                Identifier.CODEC.fieldOf("arg_type").forGetter(CommandArgumentBean::getArgType)
+        ).apply(instance, CommandArgumentBean::new));
+
+        public String argument;
+        public Identifier argType;
+
+        public CommandArgumentBean(String argument, Identifier argType) {
+            this.argument = argument;
+            this.argType = argType;
+        }
+
+        public String getArgument() {
+            return this.argument;
+        }
+
+        public Identifier getArgType() {
+            return argType;
+        }
     }
 }