Add namespace options and improve jar remapping process

- Introduced `--from` and `--to` options for specifying source and target namespaces in the CLI.
- Enhanced `RemapService` to handle namespace parameters.
- Improved jar remapping by excluding signature files and ensuring output jar creation.

Author: builtbyjonas

build.gradle

@@ -38,4 +38,12 @@ jar {
         configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
     }
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    // Robustly exclude signature files from all merged jars
+    exclude 'META-INF/**/*.SF', 'META-INF/**/*.DSA', 'META-INF/**/*.RSA'
+    eachFile { file ->
+        if (file.path ==~ /META-INF\/.*\.(SF|DSA|RSA)/) {
+            file.exclude()
+        }
+    }
 }

src/main/java/com/threadmc/trc/Main.java

@@ -20,14 +20,32 @@ public class Main implements Callable<Integer> {
     @Option(names = {"--output"}, description = "Output jar file (remapped)", required = true)
     Path outputJar;
 
+    @Option(names = {"--from"}, description = "Source namespace", required = true)
+    String fromNamespace;
+
+    @Option(names = {"--to"}, description = "Target namespace", required = true)
+    String toNamespace;
+
     public static void main(String[] args) {
         int exitCode = new CommandLine(new Main()).execute(args);
         System.exit(exitCode);
     }
 
     @Override
     public Integer call() throws Exception {
-        RemapService remapper = new RemapService(inputJar, mappingsFile, outputJar);
+        if (inputJar.toString().contains("/")) {
+            System.err.println("Error: Input jar path must use '\\' instead of '/'.");
+            return 1;
+        }
+        if (mappingsFile.toString().contains("/")) {
+            System.err.println("Error: Mappings file path must use '\\' instead of '/'.");
+            return 1;
+        }
+        if (outputJar.toString().contains("/")) {
+            System.err.println("Error: Output jar path must use '\\' instead of '/'.");
+            return 1;
+        }
+        RemapService remapper = new RemapService(inputJar, mappingsFile, outputJar, fromNamespace, toNamespace);
         remapper.run();
         return 0;
     }

src/main/java/com/threadmc/trc/RemapService.java

@@ -8,27 +8,33 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
+import java.util.jar.JarFile;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.io.InputStream;
+import java.nio.file.Files;
 
 public class RemapService {
 
     private final Path inputJar;
     private final Path mappingsFile;
     private final Path outputJar;
+    private final String fromNamespace;
+    private final String toNamespace;
 
-    public RemapService(Path inputJar, Path mappingsFile, Path outputJar) {
+    public RemapService(Path inputJar, Path mappingsFile, Path outputJar, String fromNamespace, String toNamespace) {
         this.inputJar = inputJar;
         this.mappingsFile = mappingsFile;
         this.outputJar = outputJar;
+        this.fromNamespace = fromNamespace;
+        this.toNamespace = toNamespace;
     }
 
     public void run() throws IOException {
         System.out.println("Loading mappings...");
         MemoryMappingTree tree = new MemoryMappingTree();
         MappingReader.read(mappingsFile, tree);
 
-        String fromNamespace = "official";
-        String toNamespace = "named";
-
         System.out.println("Setting up TinyRemapper...");
 
         TinyRemapper remapper = TinyRemapper.newRemapper()
@@ -39,12 +45,43 @@ public void run() throws IOException {
                 .build();
 
         System.out.println("Remapping jar...");
-        try ( @SuppressWarnings("deprecation") OutputConsumerPath outputConsumer = new OutputConsumerPath(outputJar) ) {
+        try (@SuppressWarnings("deprecation") OutputConsumerPath outputConsumer = new OutputConsumerPath(outputJar)) {
             outputConsumer.addNonClassFiles(inputJar);
             remapper.readInputs(inputJar);
             remapper.apply(outputConsumer);
         }
 
+        if (!Files.exists(outputJar)) {
+            throw new IOException("Remapped output jar was not created: " + outputJar);
+        }
+
+        Path tempJar = Files.createTempFile("remapped-filtered", ".jar");
+        try (
+            JarFile jarFile = new JarFile(outputJar.toFile());
+            JarOutputStream jos = new JarOutputStream(Files.newOutputStream(tempJar))
+        ) {
+            for (JarEntry entry : java.util.Collections.list(jarFile.entries())) {
+                String n = entry.getName().replace('\\', '/');
+                if (n.startsWith("META-INF/") && (n.endsWith(".SF") || n.endsWith(".DSA") || n.endsWith(".RSA"))) {
+                    continue;
+                }
+                JarEntry newEntry = new JarEntry(entry.getName());
+                if (entry.getMethod() == JarEntry.STORED) {
+                    newEntry.setMethod(JarEntry.STORED);
+                    newEntry.setSize(entry.getSize());
+                    newEntry.setCompressedSize(entry.getCompressedSize());
+                    newEntry.setCrc(entry.getCrc());
+                }
+                jos.putNextEntry(newEntry);
+                try (InputStream is = jarFile.getInputStream(entry)) {
+                    is.transferTo(jos);
+                }
+                jos.closeEntry();
+            }
+        }
+        
+        Files.move(tempJar, outputJar, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+
         remapper.finish();
         System.out.println("Remapped jar created at: " + outputJar.toAbsolutePath());
     }