#102: implement update & create commandlet

cli/src/main/java/com/devonfw/tools/ide/cli/Ide.java

@@ -155,7 +155,7 @@ private CliArgument initContext(CliArgument first) {
   }
 
   /**
-   * @param argument the current {@link CliArgument} (position) to match.
+   * @param current the current {@link CliArgument} (position) to match.
    * @param commandlet the potential {@link Commandlet} to {@link #apply(CliArgument, Commandlet) apply} and
    *        {@link Commandlet#run() run}.
    * @return {@code true} if the given {@link Commandlet} matched and did {@link Commandlet#run() run} successfully,

cli/src/main/java/com/devonfw/tools/ide/commandlet/CommandletManagerImpl.java

@@ -15,6 +15,7 @@
 import com.devonfw.tools.ide.tool.gh.Gh;
 import com.devonfw.tools.ide.tool.gradle.Gradle;
 import com.devonfw.tools.ide.tool.helm.Helm;
+import com.devonfw.tools.ide.tool.intellij.Intellij;
 import com.devonfw.tools.ide.tool.java.Java;
 import com.devonfw.tools.ide.tool.kotlinc.Kotlinc;
 import com.devonfw.tools.ide.tool.kotlinc.KotlincNative;
@@ -58,6 +59,8 @@ private CommandletManagerImpl(IdeContext context) {
     add(new VersionSetCommandlet(context));
     add(new VersionGetCommandlet(context));
     add(new VersionListCommandlet(context));
+    add(new RepositoryCommandlet(context));
+    add(new UpdateCommandlet(context));
     add(new Gh(context));
     add(new Helm(context));
     add(new Java(context));
@@ -72,6 +75,7 @@ private CommandletManagerImpl(IdeContext context) {
     add(new KotlincNative(context));
     add(new Vscode(context));
     add(new Azure(context));
+    add(new Intellij(context));
   }
 
   private void add(Commandlet commandlet) {

cli/src/main/java/com/devonfw/tools/ide/commandlet/RepositoryCommandlet.java

@@ -0,0 +1,169 @@
+package com.devonfw.tools.ide.commandlet;
+
+import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.process.ProcessContext;
+import com.devonfw.tools.ide.property.PathProperty;
+import com.devonfw.tools.ide.property.StringProperty;
+import com.devonfw.tools.ide.util.FilenameUtil;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * {@link Commandlet} to setup a repository
+ */
+public class RepositoryCommandlet extends Commandlet {
+
+  /** the repository to setup. */
+  public final PathProperty repository;
+
+  /**
+   * The constructor.
+   *
+   * @param context the {@link IdeContext}.
+   */
+  public RepositoryCommandlet(IdeContext context) {
+
+    super(context);
+    addKeyword(getName());
+    add(new StringProperty("setup", true, null));
+    this.repository = add(new PathProperty("", false, "repository"));
+  }
+
+  @Override
+  public String getName() {
+
+    return "repository";
+  }
+
+  @Override
+  public void run() {
+
+    Path repositoriesPath = this.context.getSettingsPath().resolve("repositories");
+    Path legacyRepositoriesPath = this.context.getSettingsPath().resolve("projects");
+    Path repositoryFile = repository.getValue();
+
+    if (repositoryFile != null) {
+      // Handle the case when a specific repository is provided
+      if (!Files.exists(repositoryFile)) {
+        repositoryFile = repositoriesPath.resolve(repositoryFile.getFileName().toString() + ".properties");
+      }
+      if (!Files.exists(repositoryFile)) {
+        Path legacyRepositoryFile = legacyRepositoriesPath.resolve(repositoryFile.getFileName().toString());
+        if (Files.exists(legacyRepositoryFile)) {
+          repositoryFile = legacyRepositoryFile;
+        } else {
+          this.context.warning("Could not find " + repositoryFile);
+          return;
+        }
+      }
+      doImportRepository(repositoryFile, true);
+    } else {
+      // If no specific repository is provided, check for repositories folder
+      Path repositories = Files.exists(repositoriesPath) ? repositoriesPath :
+          Files.exists(legacyRepositoriesPath) ? legacyRepositoriesPath : null;
+
+      if (repositories == null) return;
+
+      List <Path> propertiesFiles = this.context.getFileAccess().getFilesInDir(repositories,
+          path -> "properties".equals(FilenameUtil.getExtension(path.getFileName().toString())));
+
+      if (propertiesFiles != null) {
+        boolean forceMode = this.context.isForceMode();
+        for (Path propertiesFile : propertiesFiles) {
+          doImportRepository(propertiesFile, forceMode);
+        }
+      }
+    }
+  }
+
+  private void doImportRepository(Path repositoryFile, boolean forceMode) {
+
+    this.context.info("Importing from {} ...", repositoryFile.toString());
+    RepositoryConfig repositoryConfig = loadProperties(repositoryFile);
+
+    if (!repositoryConfig.active()) {
+      this.context.info("Repository is not active by default.");
+      if (forceMode) {
+        this.context.info("Repository setup is forced, hence proceeding ...");
+      } else {
+        this.context.info("Skipping repository - use force (-f) to setup all repositories ...");
+        return;
+      }
+    }
+
+    String repository = repositoryConfig.path();
+    String gitUrl = repositoryConfig.gitUrl();
+    if (repository == null || "".equals(repository) || gitUrl == null || "".equals(gitUrl)) {
+      this.context.warning("Invalid repository configuration {} - both 'path' and 'git-url' have to be defined."
+          , repositoryFile);
+      return;
+    }
+
+    this.context.debug(repositoryConfig.toString());
+    this.context.debug("Pull or clone git repository {} ...", repository);
+
+    String workspace = repositoryConfig.workspace() != null ? repositoryConfig.workspace() : "main";
+    Path workspacePath = this.context.getIdeHome().resolve("workspaces").resolve(workspace);
+    this.context.getFileAccess().mkdirs(workspacePath);
+
+    if (repositoryConfig.gitBranch() != null && !repositoryConfig.gitBranch().isEmpty()) {
+      gitUrl = gitUrl + "#" + repositoryConfig.gitBranch();
+    }
+
+    Path repositoryPath = workspacePath.resolve(repository);
+    this.context.gitPullOrClone(repositoryPath, gitUrl);
+
+    String buildCmd = repositoryConfig.buildCmd();
+    this.context.debug("Building project with ide command: {}", buildCmd);
+    if (buildCmd != null && !buildCmd.isEmpty()) {
+      String[] command = buildCmd.split("\\s+");
+      this.context.getCommandletManager().getToolCommandlet(command[0]).install(true);
+      ProcessContext pc = this.context.newProcess();
+      pc.executable(command[0]);
+      pc.addArgs(Arrays.copyOfRange(command, 1, command.length));
+      Path buildPath = repositoryPath;
+      if (repositoryConfig.buildPath() != null) {
+        buildPath = buildPath.resolve(repositoryConfig.buildPath());
+      }
+      pc.directory(buildPath);
+      pc.run();
+    } else {
+      this.context.info("Build command not set. Skipping build for repository.");
+    }
+
+    if ("import".equals(repositoryConfig.eclipse()) && !Files.exists(repositoryPath.resolve(".project"))) {
+      //TODO: import repository to eclipse
+    }
+  }
+
+
+  private RepositoryConfig loadProperties(Path filePath) {
+
+    Properties properties = new Properties();
+    try (InputStream input = new FileInputStream(filePath.toString())) {
+      properties.load(input);
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to read file: " + filePath, e);
+    }
+
+    return new RepositoryConfig(
+        properties.getProperty("path"),
+        properties.getProperty("workingsets"),
+        properties.getProperty("workspace"),
+        properties.getProperty("git_url"),
+        properties.getProperty("git_branch"),
+        properties.getProperty(("build_path")),
+        properties.getProperty("build_cmd"),
+        properties.getProperty("eclipse"),
+        Boolean.parseBoolean(properties.getProperty("active"))
+    );
+  }
+
+}

cli/src/main/java/com/devonfw/tools/ide/commandlet/RepositoryConfig.java

@@ -0,0 +1,26 @@
+package com.devonfw.tools.ide.commandlet;
+
+/**
+ * Represents the configuration of a repository to be used by the {@link RepositoryCommandlet}.
+ *
+ * @param path Path into which the project is cloned. This path is relative to the workspace.
+ * @param workingSets The working sets associated with the repository.
+ * @param workspace Workspace to use for checkout and import. Default is main.
+ * @param gitUrl Git URL to use for cloning the project.
+ * @param gitBranch Git branch to checkout. Git default branch is default.
+ * @param buildPath The build path for the repository.
+ * @param buildCmd The command to invoke to build the repository after clone or pull. If omitted no build is triggered.
+ * @param eclipse Desired action for eclipse IDE. If equals to "import" all modules will be imported into eclipse.
+ * @param active {@code true} to setup the repository during setup, {@code false} to skip.
+ */
+public record RepositoryConfig(
+    String path,
+    String workingSets,
+    String workspace,
+    String gitUrl,
+    String gitBranch,
+    String buildPath,
+    String buildCmd,
+    String eclipse,
+    boolean active) {
+}

cli/src/main/java/com/devonfw/tools/ide/commandlet/UpdateCommandlet.java

@@ -0,0 +1,109 @@
+package com.devonfw.tools.ide.commandlet;
+
+import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.repo.CustomTool;
+import com.devonfw.tools.ide.tool.CustomToolCommandlet;
+import com.devonfw.tools.ide.tool.ToolCommandlet;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+
+/**
+ * {@link Commandlet} to update settings, software and repositories
+ */
+public class UpdateCommandlet extends Commandlet {
+
+  private static final String SETTINGS_REPO_URL = "https://github.com/devonfw/ide-settings";
+
+  /**
+   * The constructor.
+   *
+   * @param context the {@link IdeContext}.
+   */
+  public UpdateCommandlet(IdeContext context) {
+
+    super(context);
+    addKeyword(getName());
+  }
+
+  @Override
+  public String getName() {
+
+    return "update";
+  }
+
+  @Override
+  public void run() {
+
+    updateSettings();
+    updateSoftware();
+    updateRepositories();
+  }
+
+
+  private void updateSettings() {
+
+    this.context.info("Updating settings repository ...");
+    Path settingsPath = this.context.getSettingsPath();
+    if (Files.isDirectory(settingsPath)) {
+      // perform git pull on the settings repo
+      this.context.gitPullOrClone(settingsPath, SETTINGS_REPO_URL);
+      this.context.success("Successfully updated settings repository.");
+    } else {
+      throw new IllegalStateException("Cannot find settings repository.");
+    }
+  }
+
+  private void updateSoftware() {
+
+    Set<ToolCommandlet> toolCommandlets = new HashSet<>();
+
+    // installed tools in IDE_HOME/software
+    List<Path> softwares = this.context.getFileAccess().getFilesInDir(this.context.getSoftwarePath(), path -> true);
+    for (Path software : softwares) {
+      String toolName = software.getFileName().toString();
+      try {
+        toolCommandlets.add(this.context.getCommandletManager().getToolCommandlet(toolName));
+      } catch (IllegalArgumentException e) {
+        //tool is a custom tool, ignore ...
+      }
+    }
+
+    // regular tools in $IDE_TOOLS
+    String regularToolsString = this.context.getVariables().get("IDE_TOOLS");
+    String[] regularTools = regularToolsString.split(",\\s");
+    for (String regularTool : regularTools) {
+      toolCommandlets.add(this.context.getCommandletManager().getToolCommandlet(regularTool));
+    }
+
+    // custom tools
+    for (CustomTool customTool : this.context.getCustomToolRepository().getTools()) {
+      CustomToolCommandlet customToolCommandlet = new CustomToolCommandlet(this.context, customTool);
+      toolCommandlets.add(customToolCommandlet);
+    }
+
+    // update/install the toolCommandlets
+    Map<String, String> tool2exception = new HashMap<>();
+    for (ToolCommandlet toolCommandlet : toolCommandlets) {
+      try {
+        this.context.step("Setting up {}", toolCommandlet.getName());
+        toolCommandlet.install(false);
+      } catch (Exception e) {
+        tool2exception.put(toolCommandlet.getName(), e.getMessage());
+      }
+    }
+
+    if (tool2exception.isEmpty()) {
+      this.context.success("All tools were successfully installed.");
+    } else {
+      this.context.warning("Following tools could not be installed:");
+      for (String toolName : tool2exception.keySet())
+      this.context.warning("{}: {}", toolName, tool2exception.get(toolName));
+    }
+  }
+
+  private void updateRepositories() {
+    this.context.getCommandletManager().getCommandlet(RepositoryCommandlet.class).run();
+  }
+}

cli/src/main/java/com/devonfw/tools/ide/common/SystemPath.java

@@ -166,6 +166,7 @@ public Path getPath(String tool) {
    */
   public void setPath(String tool, Path path) {
 
+    this.paths.add(path);
     this.tool2pathMap.put(tool, path);
   }
 

cli/src/main/java/com/devonfw/tools/ide/io/FileAccess.java

@@ -1,6 +1,7 @@
 package com.devonfw.tools.ide.io;
 
 import java.nio.file.Path;
+import java.util.List;
 import java.util.function.Predicate;
 
 /**
@@ -131,4 +132,12 @@ default void copy(Path source, Path target) {
    */
   Path findFirst(Path dir, Predicate<Path> filter, boolean recursive);
 
+  /**
+   * Retrieves a list of file paths from the specified directory that satisfy the given predicate.
+   * @param dir the folder to iterate through
+   * @param filter the {@link Predicate} that determines whether a file should be included in the list.
+   * @return a list of paths that satisfy the provided {@link Predicate} or {@code null} if no match was found.
+   */
+  List<Path> getFilesInDir(Path dir, Predicate<Path> filter);
+
 }

cli/src/main/java/com/devonfw/tools/ide/io/FileAccessImpl.java

@@ -458,4 +458,21 @@ private Path findFirstRecursive(Path dir, Predicate<Path> filter, boolean recurs
     return null;
   }
 
+  @Override
+  public List<Path> getFilesInDir(Path dir, Predicate<Path> filter) {
+    List<Path> files = new ArrayList<>();
+    try (Stream<Path> childStream = Files.list(dir)) {
+      Iterator<Path> iterator = childStream.iterator();
+      while (iterator.hasNext()) {
+        Path child = iterator.next();
+        if (filter.test(child)) {
+          files.add(child);
+        }
+      }
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to iterate through " + dir, e);
+    }
+    return files;
+  }
+
 }