Resolved an issue that caused mods to be packaged incompletely.

Corrected a bug whereby directly accessing fields via their 'named' identifiers failed in the runtime environment.
Updated the README.md.

Author: Alumopper

.gitignore

@@ -38,3 +38,5 @@ hs_err_*.log
 replay_*.log
 *.hprof
 *.jfr
+
+README.md

README.md

@@ -1,95 +1,233 @@
-> [!NOTE]
-> This project is now being developed by Bookshelf team and has been renamed to Sniffer. Bookshelf has added more features to Sniffer and developed a VSCode plugin! So head over to their repository to stay updated~
->
-> It's worth mentioning that the original author is still actively contributing to Sniffer's development~
->
-> Sniffer: <https://github.com/mcbookshelf/sniffer>
+# Sniffer
 
+## Overview
 
-# Datapack Breakpoint
+Sniffer is a debug adapter for Minecraft datapacks that allows you to debug your `.mcfunction` files directly from Visual Studio Code. It provides features like breakpoints, step execution, and variable inspection to make datapack development easier and more efficient.
 
-English | [简体中文](README_zh.md)
+## Features
 
-## Introduce
+- Set breakpoints in `.mcfunction` files
+- Connect to a running Minecraft instance
+- Inspect game state during debugging
+- Step through command execution
+- Path mapping between Minecraft and local files
+- Debug commands started with `#!`
+- Assert command
+- Log command (Much more powerful than `tellraw` or `say`)
+- Hot reload datapack changes
 
-This is a fabric mod for Minecraft 1.21, which allows you to set breakpoints in the game and "freeze" the game when 
-the breakpoint is reached.
+## Requirements
 
-## Usage
+- Minecraft with Fabric Loader
+- Visual Studio Code
 
-* Set a breakpoint
 
-In datapack, you can insert `#breakpoint` into .mcfunction file to set a breakpoint. For example:
+<!-- ## Installation
 
-```mcfunction
-#test:test
+### Minecraft Mod Installation
+
+1. Install [Fabric Loader](https://fabricmc.net/use/) for your Minecraft version
+2. Download the Sniffer mod JAR from the [releases page](https://github.com/mcbookshelf/sniffer/releases)
+3. Place the JAR file in your Minecraft `mods` folder
+4. Launch Minecraft with Fabric
+
+### VSCode Extension Installation
+
+1. Open Visual Studio Code
+2. Go to the Extensions view (Ctrl+Shift+X)
+3. Search for "Sniffer"
+4. Click Install -->
+
+## Mod Configuration
+The mod can be configured through the in-game configuration screen, accessible via Mod Menu.
+You can also configure the mod in the `config/sniffer.json` file.
+The following options are available:
+
+### Debug Server Settings
+- **Server Port**: The port number for the debug server (default: 25599)
+- **Server path**: The path to the debug server (default: `/dap`)
+
+## Connecting to Minecraft
+
+1. Open your datapack project in VSCode
+2. Create a `.vscode/launch.json` file with the following configuration:
+
+```json
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "sniffer",
+      "request": "attach",
+      "name": "Connect to Minecraft",
+      "address": "ws://localhost:25599/dap"
+    }
+  ]
+}
+```
+
+3. Start Minecraft with the Sniffer mod installed
+4. In VSCode, press F5 or click the "Run and Debug" button
+5. Select "Connect to Minecraft" from the dropdown menu
+
+You can now place breakpoints in your `.mcfunction` files and execute it from the game to step through the code.
+
+## Usage in Minecraft
+
+### Breakpoint
+
+The debugger can be controlled directly from Minecraft using the following commands:
+
+- `/breakpoint continue`: Resume execution after hitting a breakpoint
+- `/breakpoint step`: Execute the next command and pause
+- `/breakpoint step_over`: Skip to the next command in the current function
+- `/breakpoint step_out`: Continue execution until the current function returns
 
+All commands require operator permissions (level 2) to use.
+
+When execution is paused at a breakpoint, the gametick will be freezed.
+
+### Debug Command
+
+Comment started with `#!` are recognized as debug commands. They will be executed as same as the normal commands in the game but without Sniffer, those debug commands will only be considered as comments.
+
+Sniffer adds some useful commands for datapack developer. By using debug command, you can use those commands in your datapack without worrying about breaking your datapack in vanilla Minecraft.
+
+For example, if you want to place a breakpoint in your function:
+
+```mcfunction
 say 1
 say 2
-#breakpoint
 say 3
+
+#The function will stop at the line with `#!breakpoint`
+#!breakpoint
 say 4
+say 5
 ```
 
-In this case, after the game executes `say 2`, the game will be "frozen" because it meets the breakpoint. 
+Also you can execute normal commands in debug command line:
 
-When the game is "frozen", you can still move around, do whatever you want, just like execute the command `tick freeze`.
-So you can check the game state, or do some debugging.
-
-* Step
+```mcfunction
+say 1
+say 2
+say 3
 
-When the game is "frozen", you can use the command `/breakpoint step` to execute the next command. In above example, 
-after the game meets the breakpoint, you can use `/breakpoint step` to execute `say 3`, and then use `/breakpoint step`
-to execute `say 4`. When all commands are executed, the game will be unfrozen and continue running.
+#!execute if score @s test matches 1..10 run breakpoint
+say 4
+say 5
+```
 
-* Continue
+This breakpoint will only be triggerred when the score of the executor in test object is between 1 and 10.
 
-When the game is "frozen", you can use the command `/breakpoint move` to unfreeze the game and continue running.
+### Assert
 
-* Get Macro Arguments
+Assert command is used to check if a condition is true. If the condition is false, the mod will print an error message to the game chat.
 
-By using `/breakpoint get <key>`, you can get the value of the macro argument if the game is executing a macro function.
-For example:
+Syntax: `assert <expr>`
 
 ```mcfunction
-#test:test_macro
+say 1
+say 2
+say 3
 
-say start
-#breakpoint
-$say $(msg)
-say end
+#!assert {(score @s test ) <= 10}
+say 4
+say 5
 ```
 
-After executing `function test:test_macro {"msg":"test"}`, we passed the value `test` to the macro argument `msg` and 
-then the game will pause before `$say $(msg)`. At this time, you can use `/breakpoint get msg` to get the value `test`.
+This assert command will check if the score of the executor in test object is less than or equal to 10.
 
-* Get Function Stack
+#### Expression Argument
 
-By using `/breakpoint stack`, you can get the function stack of the current game. For example, if we have following two
-functions:
+In sniffer command, you can use complex expression as command argument. Normally, an expression is surrounded by curly braces `{}`. Within an expression, you may obtain a value from an argument enclosed in parentheses and employ it in the expression’s evaluation.
 
-```mcfunction
-#test:test1
+Supported expression arguments:
+- `score <score_holder> <objective>`: The same as `execute if score`. Returns an int value.
+- `data entity <entity>/storage <id>/block <pos> path`: The same as `execute if data`. Returns a nbt value.
+- `name <entity>`: return a text components with all names of the entities.
+
+> [!WARNING] 
+> Owing to inherent limitations in the command-parsing system, the closing parenthesis of an expression argument must be preceded by at least one space
+
+Supported operators:
+- `+`, `-`, `*`, `/`, `%`: Arithmetic operators
+- `==`, `!=`, `<`, `<=`, `>`, `>=`: Comparison operators
+- `&&`, `||`, `!`: Logical operators
+- `is`: Check if a value is a certain type. Returns a boolean value. Available types: `nbt`, `text`, `string`, `number`, `byte`, `short`, `int`, `long`, `float`, `double`, `int_array`, `long_array`,` byte_array`, `list`, `compound`, `
+
+> [!Note]
+> No operator possesses intrinsic precedence; expressions are evaluated strictly from left to right. By nesting subexpressions, however, you can enforce prioritized evaluation
 
+### Log
+
+Log command is used to print a message to the game chat. The log message can contain expression arguments.
+
+Syntax: `log <log>`
+
+```mcfunction
 say 1
-function test:test2
 say 2
+say 3
 
-#test: test2
-say A
-#breakpoint
-say B
+#!log The score of @s in test objective is {(score @s test )}
+say 4
+say 5
 ```
 
-When the game pauses at the breakpoint, you can use `/breakpoint stack` and the function stack will be printed in the
-chat screen:
+This log command will print `The score of @s in test objective is 10` to the game chat.
+
+### Hot reload
+
+Sniffer can watch the changes of the datapack files (only `*.mcfunction` files currently) and reload them automatically. Hot reloading will not reload all resources, as it will only reload the function that is changed. It will not trigger functions with `#minecraft:load` tag too. In large-scale datapack projects, or if you installed kubejs mod, hot reloading can markedly mitigate unnecessary reload-induced pauses and stuttering.
 
+Hot reloading will watch any changes, create or delete of the datapack files.
+
+Hot reloading is not enabled by default. You must use the `watch start` command to start watching a datapack. Each time you re-enter the world, the watcher must be reestablished. After making any changes in the datapack, you can use the `watch reload` command to trigger hot reloading and apply changes in your datapack. A message will be sent to the game chat to tell you what changes have been actually applied.
+
+If the command parser encounters any error while parsing a function, the changes in the function will not apply, and a message will be sent to the game chat to tell you the error.
+
+Command Syntax:
+
+- `watch start <Datapack Folder Name>`: Start watching a datapack folder.
+- `watch stop <Datapack Folder Name>`: Stop watching a datapack folder.
+- `watch reload`: Trigger the hot loading to apply changes.
+- `watch auto [true|false]`: Set whether auto reloading is enabled. Auto reloading will apply any change once the watcher detects it. Default is `false`. If value is not provided, it will tell you if the auto reloading is enabled.
+
+## Development
+
+### Project Structure
+
+- `src/main`: Main mod code for Minecraft
+- `src/client`: Client-side mod code
+- `vscode`: VSCode extension source code
+
+### Building the Project
+
+To build the Minecraft mod:
+
+```bash
+./gradlew build
 ```
-test:test2
-test:test
 
+To build the VSCode extension:
+
+```bash
+cd vscode
+npm install
+npm run build
 ```
 
-* Run command in current context
+## License
+
+This project is licensed under the MPL-2.0 License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Acknowledgements
 
-By using `/breakpoint run <command>`, you can run any command in the current context, just like `execute ... run ...`.
+- [Fabric](https://fabricmc.net/) - Mod loader for Minecraft
+- [VSCode Debug Adapter](https://code.visualstudio.com/api/extension-guides/debugger-extension) - VSCode debugging API
+- [Datapack Debugger](https://github.com/Alumopper/Datapack-Debugger/) by [Alumopper](https://github.com/Alumopper) - Original implementation of the debugger, without the DAP layer

build.gradle

@@ -2,6 +2,7 @@ plugins {
 	id 'fabric-loom' version '1.11-SNAPSHOT'
 	id 'maven-publish'
 	id "org.jetbrains.kotlin.jvm" version "2.1.0"
+	id "com.gradleup.shadow" version "9.2.2"
 }
 
 version = project.mod_version
@@ -37,6 +38,12 @@ loom {
 
 }
 
+configurations {
+	shadowImpl
+}
+
+configurations.shadowImpl.extendsFrom(configurations.implementation)
+
 dependencies {
 	implementation 'org.eclipse.lsp4j:org.eclipse.lsp4j:0.24.0'
 	implementation 'org.eclipse.lsp4j:org.eclipse.lsp4j.debug:0.24.0'
@@ -52,7 +59,6 @@ dependencies {
 
 	// Fabric API. This is technically optional, but you probably want it anyway.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-	modImplementation "net.fabricmc.fabric-api:fabric-key-binding-api-v1:${project.fabric_version}"
 	modImplementation "net.fabricmc:fabric-language-kotlin:${project.fabric_kotlin_version}"
 
 	// Added Cloth Config and ModMenu
@@ -80,6 +86,22 @@ tasks.withType(JavaCompile).configureEach {
 	it.options.release = 21
 }
 
+
+tasks.named("shadowJar") {
+	archiveClassifier.set("all")
+	from(sourceSets.main.output)
+	from(sourceSets.client.output)
+	configurations = [project.configurations.shadowImpl]
+}
+
+tasks.named("remapJar") {
+	dependsOn("shadowJar")
+	inputFile.set(tasks.named("shadowJar").flatMap { it.archiveFile })
+	archiveClassifier.set("")
+}
+
+tasks.build { dependsOn(tasks.remapJar) }
+
 java {
 	// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
 	// if it is present.

gradle.properties

@@ -13,7 +13,7 @@ loom_version=1.13-SNAPSHOT
 fabric_kotlin_version=1.13.0+kotlin.2.1.0
 
 # Mod Properties
-mod_version=0.1.0
+mod_version=0.2.0
 maven_group=net.gunivers
 archives_base_name=sniffer
 

src/main/java/net/gunivers/sniffer/Utils.java

@@ -15,18 +15,6 @@
  */
 public class Utils {
 
-    /**
-     * Retrieves the identifier from an ExpandedMacro function.
-     * This method uses EncapsulationBreaker to access the private field
-     * that contains the function's identifier.
-     *
-     * @param function The ExpandedMacro function to get the ID from
-     * @return The Identifier of the function, or a fallback identifier if not found
-     */
-    public static Identifier getId(ExpandedMacro<?> function) {
-        return ReflectUtil.getT(function, "functionIdentifier", Identifier.class).getDataOrElse(Identifier.of("foo:bar"));
-    }
-
     private static final String MESSAGE_PREFIX = "[Sniffer] ";
 
     public static Text addSnifferPrefix(Text text) {

src/main/java/net/gunivers/sniffer/mixin/CommandExecutionContextMixin.java

@@ -418,7 +418,7 @@ private Optional<SourcedCommandAction<?>> getNextCommand(CommandQueueEntry<T> co
             return Optional.empty();
         }
 
-        int index = ReflectUtil.getT(steppedAction, "nextActionIndex", int.class).getData();
+        int index = ((SteppedCommandActionAccessors) steppedAction).getNextActionIndex();
         if(index < 0) {
             return Optional.empty();
         }

src/main/java/net/gunivers/sniffer/mixin/CommandFunctionManagerAccessors.java

@@ -0,0 +1,13 @@
+package net.gunivers.sniffer.mixin;
+
+import net.minecraft.server.function.CommandFunctionManager;
+import net.minecraft.server.function.FunctionLoader;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(CommandFunctionManager.class)
+public interface CommandFunctionManagerAccessors {
+
+    @Accessor("loader")
+    FunctionLoader getLoader();
+}