feat: jbang deps add <deps> <file> (jbangdev#2260)

Author: maxandersen

build.gradle

@@ -24,6 +24,7 @@ plugins {
 
 def allureVersion = '2.29.1'
 def aspectJVersion = '1.9.25'
+def versionJline = '3.30.5'
 
 configurations {
 	agent {
@@ -166,13 +167,17 @@ dependencies {
 	runtimeOnly    "eu.maveniverse.maven.mima.runtime:standalone-static:2.4.36"
 	implementation "org.apache.maven:maven-model:3.9.11"
 
+	implementation "org.jline:jline-console-ui:$versionJline"
+	implementation "org.jline:jline-terminal-jni:$versionJline"
+
 	implementation "eu.maveniverse.maven.nisse:core:0.6.2"
 	implementation "eu.maveniverse.maven.nisse.sources:os-source:0.6.2"
 
 	testImplementation platform('org.junit:junit-bom:5.14.1')
 	testImplementation "org.junit.jupiter:junit-jupiter"
 	testImplementation "org.junit.platform:junit-platform-launcher"
 	testImplementation "com.github.stefanbirkner:system-rules:1.17.2"
+	testImplementation "org.assertj:assertj-core:3.24.2"
 	testImplementation "org.hamcrest:hamcrest-library:2.2"
 	testImplementation "org.wiremock:wiremock:3.13.2"
 	testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
@@ -324,15 +329,15 @@ compileJava9Java {
 }
 
 shadowJar {
-	minimize() {
+	/*minimize() {
 		//exclude(dependency('org.slf4j:slf4j-api:.*'))
 		exclude(dependency('dev.jbang:devkitman:.*'))
 		exclude(dependency('eu.maveniverse.maven.mima:context:.*'))
 		exclude(dependency('eu.maveniverse.maven.mima.runtime:standalone-static:.*'))
 		exclude(dependency('org.slf4j:jcl-over-slf4j:.*'))
 		exclude(dependency('org.slf4j:slf4j-nop:.*'))
 		exclude(dependency('org.jboss.logging:jboss-logging:.*'))
-	}
+	}*/
 	mergeServiceFiles()
 	manifest {
 		attributes(

src/main/java/dev/jbang/Main.java

@@ -22,6 +22,7 @@ public static void main(String... args) {
 		} catch (IOException e) {
 			// Ignore
 		}
+
 		CommandLine cli = JBang.getCommandLine();
 		args = handleDefaultRun(cli.getCommandSpec(), args);
 		int exitcode = cli.execute(args);

src/main/java/dev/jbang/cli/BaseCommand.java

@@ -30,7 +30,7 @@ public abstract class BaseCommand implements Callable<Integer> {
 	public static final int EXIT_INTERNAL_ERROR = 4;
 	public static final int EXIT_EXECUTE = 255;
 
-	private static final Logger logger = Logger.getLogger("org.jboss.shrinkwrap.resolver");
+	private static final Logger logger = Logger.getLogger("dev.jbang.cli");
 	static {
 		logger.setLevel(Level.SEVERE);
 	}

src/main/java/dev/jbang/cli/Deps.java

@@ -0,0 +1,168 @@
+package dev.jbang.cli;
+
+import java.io.IOError;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import org.eclipse.aether.artifact.Artifact;
+import org.jline.terminal.Terminal;
+import org.jline.terminal.TerminalBuilder;
+
+import dev.jbang.dependencies.DependencyUtil;
+import dev.jbang.search.ArtifactSearchWidget;
+import dev.jbang.source.update.FileUpdateStrategy;
+import dev.jbang.source.update.FileUpdaters;
+
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+
+@Command(name = "deps", description = "Manage dependencies in jbang files.", subcommands = { DepsAdd.class,
+		DepsSearch.class })
+public class Deps extends BaseCommand {
+
+	@Override
+	public Integer doCall() throws IOException {
+		// This is a parent command, subcommands handle the actual work
+		return EXIT_OK;
+	}
+}
+
+@Command(name = "search", header = "Search for artifacts in local and central Maven repositories.", description = {
+		"",
+		"  ${COMMAND-FULL-NAME}",
+		"        (to search for artifacts interactively)",
+		"  or  ${COMMAND-FULL-NAME} jash",
+		"        (to search for 'jash' interactively)",
+		"  or  ${COMMAND-FULL-NAME} myapp.java",
+		"        (to search for dependencies and add them to myapp.java)",
+		"  or  ${COMMAND-FULL-NAME} jash myapp.java",
+		"        (to search initially for 'jash' and add dependency to myapp.java)",
+		"",
+		" note: JBang will detect if the arguments are a file or query, but if you want to be explicit you can use the --query and --target options.",
+		"",
+		"" })
+class DepsSearch extends BaseCommand {
+
+	@CommandLine.Option(names = "--max", description = "Maximum number of results to return.", defaultValue = "100")
+	int max;
+
+	@CommandLine.Option(names = { "--query",
+			"-q" }, description = "Artifact pattern to search for.", arity = "0..1")
+	Optional<String> query;
+
+	@CommandLine.Option(names = {
+			"--target" }, description = "Target where to add the dependency, i.e. app.java or build.jbang", arity = "0..1")
+	Optional<Path> target;
+
+	@CommandLine.Parameters(arity = "0..2", paramLabel = "[query] [target]", description = "Artifact pattern to search for and target where to add the dependency, i.e. app.java or build.jbang. Query and target can both be optional")
+	List<String> args = new ArrayList<>();
+
+	private boolean looksLikeATarget(String a0) {
+		return Files.exists(Paths.get(a0));
+	}
+
+	private void updateTarget(String a0) throws IOException {
+		if (target.isPresent()) {
+			throw new IllegalArgumentException("Cannot provide both target as as parameter and as option");
+		} else {
+			target = Optional.of(Paths.get(a0));
+		}
+	}
+
+	private void updateQuery(String a0) {
+		if (query.isPresent()) {
+			throw new IllegalArgumentException("Cannot provide both query as as parameter and as option");
+		} else {
+			query = Optional.of(a0);
+		}
+	}
+
+	@Override
+	public Integer doCall() throws IOException {
+
+		if (args.size() == 1) { // either query or target
+			String a0 = args.get(0);
+			if (looksLikeATarget(a0)) {
+				updateTarget(a0);
+			} else {
+				updateQuery(a0);
+			}
+		} else if (args.size() == 2) { // both query and target
+			updateQuery(args.get(0));
+			updateTarget(args.get(1));
+		}
+
+		if (target.isPresent() && !Files.exists(target.get())) {
+			throw new ExitException(EXIT_INVALID_INPUT, "Target file does not exist: " + target.get());
+		}
+
+		try (Terminal terminal = TerminalBuilder.builder().system(true).build()) {
+			try {
+				Artifact artifact = new ArtifactSearchWidget(terminal).search(query.orElse(""));
+				if (target.isPresent()) {
+					DepsAdd.updateFile(target.get(), Collections.singletonList(artifactGav(artifact)));
+					info("Added " + artifactGav(artifact) + " to " + target.get());
+				} else {
+					System.out.printf("%s:%s:%s%n", artifact.getGroupId(), artifact.getArtifactId(),
+							artifact.getVersion());
+				}
+				return EXIT_OK;
+			} catch (IOError e) {
+				return EXIT_INVALID_INPUT;
+			}
+		}
+	}
+
+	private static String artifactGav(Artifact artifact) {
+		return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion();
+	}
+
+}
+
+@Command(name = "add", description = "Add dependencies to a jbang file.")
+class DepsAdd extends BaseCommand {
+
+	@CommandLine.Parameters(description = "Dependencies to add (groupId:artifactId:version) and target file (.java or build.jbang)")
+	List<String> parameters = new ArrayList<>();
+
+	@Override
+	public Integer doCall() throws IOException {
+		if (parameters.size() < 2) {
+			throw new ExitException(EXIT_INVALID_INPUT, "At least one dependency and target file are required");
+		}
+
+		// Last parameter is the target file
+		Path targetFile = Paths.get(parameters.get(parameters.size() - 1));
+		List<String> dependencies = parameters.subList(0, parameters.size() - 1);
+
+		if (!Files.exists(targetFile)) {
+			throw new ExitException(EXIT_INVALID_INPUT, "Target file does not exist: " + targetFile);
+		}
+
+		updateFile(targetFile, dependencies);
+
+		info("Added dependencies to " + targetFile);
+		return EXIT_OK;
+	}
+
+	static public void updateFile(Path file, List<String> dependencies) throws IOException {
+		// Validate dependencies
+		for (String dep : dependencies) {
+			if (!DependencyUtil.looksLikeAGav(dep)) {
+				throw new ExitException(EXIT_INVALID_INPUT, "Invalid dependency format: " + dep);
+			}
+		}
+		if (!Files.exists(file)) {
+			throw new ExitException(EXIT_INVALID_INPUT, "File does not exist: " + file);
+		}
+
+		FileUpdateStrategy strategy = FileUpdaters.forFile(file);
+		strategy.updateFile(file, dependencies);
+	}
+}

src/main/java/dev/jbang/cli/JBang.java

@@ -60,7 +60,7 @@
 		"" }, versionProvider = VersionProvider.class, subcommands = {
 				Run.class, Build.class, Edit.class, Init.class, Alias.class, Template.class, Catalog.class, Trust.class,
 				Cache.class, Completion.class, Jdk.class, Version.class, Wrapper.class, Info.class, App.class,
-				Export.class, Config.class })
+				Export.class, Config.class, Deps.class })
 public class JBang extends BaseCommand {
 
 	@CommandLine.Option(names = { "-V",
@@ -286,7 +286,7 @@ private Map<String, List<String>> sections() {
 			if (sections == null) {
 				sections = new LinkedHashMap<>();
 				sections.put("Essentials", asList("run", "build"));
-				sections.put("Editing", asList("init", "edit"));
+				sections.put("Editing", asList("init", "edit", "deps"));
 				sections.put("Caching", asList("cache", "export", "jdk"));
 				sections.put("Configuration", asList("config", "trust", "alias", "template", "catalog", "app"));
 				sections.put("Other", asList("completion", "info", "version", "wrapper"));
@@ -311,9 +311,15 @@ private Map<String, String> externals() {
 		 * 
 		 * @param help
 		 */
-		public void validate(CommandLine.Help help) {
+		public void validate(CommandLine.Help help, boolean ignoreExternalCommands) {
 			Set<String> cmds = new HashSet<>();
-			sections().forEach((key, value) -> cmds.addAll(value));
+			sections().forEach((key, value) -> {
+				if (ignoreExternalCommands && "External".equals(key)) {
+					return;
+				} else {
+					cmds.addAll(value);
+				}
+			});
 
 			Set<String> actualcmds = new HashSet<>(help.subcommands().keySet());
 
@@ -328,9 +334,6 @@ public void validate(CommandLine.Help help) {
 			if (actualcmds.size() > 0) {
 				throw new IllegalStateException(("Commands found with no assigned section" + actualcmds));
 			}
-
-			sections().forEach((key, value) -> cmds.addAll(value));
-
 		}
 
 		@Override
@@ -426,6 +429,7 @@ private static Map<String, String> findExternalCommands() {
 				Util.verboseMsg("Error trying to list aliases", ex);
 			}
 			// Now add any commands found on the PATH whose names start with "jbang-"
+			// but only if they don't already exist (catalog aliases take precedence)
 			try {
 				List<Path> paths = getPluginPaths();
 				List<Path> cmds = findCommandsWith(paths, p -> p.getFileName().toString().startsWith("jbang-"));

src/main/java/dev/jbang/search/ArtifactSearch.java

@@ -0,0 +1,106 @@
+package dev.jbang.search;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.aether.artifact.Artifact;
+
+public interface ArtifactSearch {
+
+	/**
+	 * Find artifacts matching the given pattern. This will return the first page of
+	 * results. If the pattern to search for is a simple name (there are no colons
+	 * in the string), the search will match any part of an artifact's group or
+	 * name. If there's a single colon, the search will match any part of the group
+	 * id and artifact id separately. If there are two colons, the search will match
+	 * the group id and artifact id exactly, and will return the artifact's
+	 * versions. If the pattern starts with "fc:", the search will match the full
+	 * class name. If the pattern starts with "c:", the search will match the class
+	 * name.
+	 *
+	 * @param artifactPattern The pattern to search for.
+	 * @param count           The maximum number of results to return.
+	 * @return The search result as an instance of {@link SearchResult}.
+	 * @throws IOException If an error occurred during the search.
+	 */
+	SearchResult findArtifacts(String artifactPattern, int count) throws IOException;
+
+	/**
+	 * Find the next page of artifacts. This takes a {@link SearchResult} returned
+	 * by a previous call to {@link #findArtifacts(String, int)} and returns the
+	 * next page of results.
+	 *
+	 * @param prevResult The previous search result.
+	 * @return The next search result as an instance of {@link SearchResult}.
+	 * @throws IOException If an error occurred during the search.
+	 */
+	SearchResult findNextArtifacts(SearchResult prevResult) throws IOException;
+
+	enum Backends {
+		rest_smo,
+		rest_csc;
+		// smo_smo,
+		// smo_csc;
+	}
+
+	static ArtifactSearch getBackend(Backends backend) {
+		if (backend != null) {
+			switch (backend) {
+			case rest_smo:
+				return SolrArtifactSearch.createSmo();
+			case rest_csc:
+				return SolrArtifactSearch.createCsc();
+			// case smo_smo:
+			// return SearchSmoApiImpl.createSmo();
+			// case smo_csc:
+			// return SearchSmoApiImpl.createCsc();
+			}
+		}
+		return SolrArtifactSearch.createSmo();
+	}
+
+	/**
+	 * Hold the result of a search while also functioning as a kind of bookmark for
+	 * paging purposes.
+	 */
+	class SearchResult {
+		/** The artifacts that matched the search query. */
+		public final List<? extends Artifact> artifacts;
+
+		/** The search query that produced this result. */
+		public final String query;
+
+		/**
+		 * The index of the first artifact in this result relative to the total result
+		 * set.
+		 */
+		public final int start;
+
+		/** The maximum number of results to return */
+		public final int count;
+
+		/** The total number of artifacts that matched the search query. */
+		public final int total;
+
+		/**
+		 * Create a new search result.
+		 *
+		 * @param artifacts The artifacts that matched the search query.
+		 * @param query     The search query that produced this result.
+		 * @param start     The index of the first artifact in this result relative to
+		 *                  the total result set.
+		 * @param count     The maximum number of results to return.
+		 * @param total     The total number of artifacts that matched the search query.
+		 */
+		public SearchResult(
+				List<? extends Artifact> artifacts, String query, int start, int count, int total) {
+			this.artifacts = Collections.unmodifiableList(artifacts);
+
+			this.query = query;
+			this.start = start;
+			this.count = count;
+			this.total = total;
+		}
+	}
+}