#101: implement create & update commandlet

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

@@ -39,7 +39,8 @@ public interface CommandletManager {
 
   /**
    * @param name the {@link Commandlet#getName() name} of the requested {@link ToolCommandlet}.
-   * @return the requested {@link ToolCommandlet} or {@code null} if not found.
+   * @return the requested {@link ToolCommandlet} if found.
+   * @throws IllegalArgumentException if the commandlet with the given name is not a {@link ToolCommandlet}
    */
   default ToolCommandlet getToolCommandlet(String name) {
 
@@ -50,4 +51,16 @@ default ToolCommandlet getToolCommandlet(String name) {
     throw new IllegalArgumentException("The commandlet " + name + " is not a ToolCommandlet!");
   }
 
+  /**
+   * @param name the {@link Commandlet#getName() name} of the requested {@link ToolCommandlet}.
+   * @return the requested {@link ToolCommandlet} or {@code null} if not found.
+   */
+  default ToolCommandlet getToolCommandletOrNull(String name) {
+
+    Commandlet commandlet = getCommandlet(name);
+    if (commandlet instanceof ToolCommandlet) {
+      return (ToolCommandlet) commandlet;
+    }
+    return null;
+  }
 }

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

@@ -70,6 +70,8 @@ public CommandletManagerImpl(IdeContext context) {
     add(new EditionListCommandlet(context));
     add(new VersionCommandlet(context));
     add(new RepositoryCommandlet(context));
+    add(new UpdateCommandlet(context));
+    add(new CreateCommandlet(context));
     add(new Gh(context));
     add(new Helm(context));
     add(new Java(context));

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

@@ -0,0 +1,77 @@
+package com.devonfw.tools.ide.commandlet;
+
+import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.io.FileAccess;
+import com.devonfw.tools.ide.process.ProcessContext;
+import com.devonfw.tools.ide.process.ProcessResult;
+import com.devonfw.tools.ide.property.StringProperty;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * {@link Commandlet} to create a new IDEasy instance
+ */
+public class CreateCommandlet extends Commandlet {
+
+  private final StringProperty newInstance;
+
+  /**
+   * The constructor.
+   *
+   * @param context the {@link IdeContext}.
+   */
+  public CreateCommandlet(IdeContext context) {
+
+    super(context);
+    addKeyword(getName());
+    newInstance = add(new StringProperty("", false, "newInstance"));
+  }
+
+  @Override
+  public String getName() {
+
+    return "create";
+  }
+
+  @Override
+  public void run() {
+
+    String newInstanceName = newInstance.getValue();
+    Path newInstancePath;
+
+    if (newInstanceName == null) {
+      newInstancePath = this.context.getCwd();
+    } else {
+      newInstancePath = this.context.getIdeRoot().resolve(newInstanceName);
+      this.context.getFileAccess().mkdirs(newInstancePath);
+    }
+
+    this.context.info("Creating new IDEasy instance in {}", newInstancePath);
+    if (!this.context.getFileAccess().isEmptyDir(newInstancePath)) {
+      this.context.askToContinue("Directory is not empty, continue?");
+    }
+
+    initializeInstance(newInstancePath);
+    ProcessContext pc = this.context.newProcess().executable("ideasy");
+    pc.addArgs("update");
+    pc.directory(newInstancePath);
+    if (pc.run() == ProcessResult.SUCCESS) {
+      this.context.success("IDEasy Instance successfully created in {}", newInstancePath);
+    } else {
+      this.context.warning("Could not create IDEasy Instance.");
+    }
+  }
+
+  private void initializeInstance(Path newInstancePath) {
+
+    FileAccess fileAccess = this.context.getFileAccess();
+    fileAccess.mkdirs(newInstancePath.resolve(IdeContext.FOLDER_SOFTWARE));
+    fileAccess.mkdirs(newInstancePath.resolve(IdeContext.FOLDER_UPDATES));
+    fileAccess.mkdirs(newInstancePath.resolve(IdeContext.FOLDER_PLUGINS));
+    fileAccess.mkdirs(newInstancePath.resolve(IdeContext.FOLDER_WORKSPACES));
+    fileAccess.mkdirs(newInstancePath.resolve(IdeContext.FOLDER_SETTINGS));
+
+  }
+}

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

@@ -0,0 +1,169 @@
+package com.devonfw.tools.ide.commandlet;
+
+import com.devonfw.tools.ide.common.StepContainer;
+import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.property.StringProperty;
+import com.devonfw.tools.ide.repo.CustomTool;
+import com.devonfw.tools.ide.tool.CustomToolCommandlet;
+import com.devonfw.tools.ide.tool.ToolCommandlet;
+import com.devonfw.tools.ide.variable.IdeVariables;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Stream;
+
+/**
+ * {@link Commandlet} to update settings, software and repositories
+ */
+public class UpdateCommandlet extends Commandlet {
+
+  private static final String DEFAULT_SETTINGS_REPO_URL = "https://github.com/devonfw/ide-settings";
+
+  private final StringProperty settingsRepo;
+
+  /**
+   * The constructor.
+   *
+   * @param context the {@link IdeContext}.
+   */
+  public UpdateCommandlet(IdeContext context) {
+
+    super(context);
+    addKeyword(getName());
+    settingsRepo = add(new StringProperty("", false, "settingsRepository"));
+  }
+
+  @Override
+  public String getName() {
+
+    return "update";
+  }
+
+  @Override
+  public void run() {
+
+    updateSettings();
+    this.context.getFileAccess().mkdirs(this.context.getWorkspacePath());
+    Path templatesFolder = this.context.getSettingsPath().resolve(IdeContext.FOLDER_TEMPLATES);
+    if (!Files.exists(templatesFolder)) {
+      Path legacyTemplatesFolder = this.context.getSettingsPath().resolve(IdeContext.FOLDER_LEGACY_TEMPLATES);
+      if (Files.exists(legacyTemplatesFolder)) {
+        templatesFolder = legacyTemplatesFolder;
+      } else {
+        this.context.warning("Templates folder is missing in settings folder.");
+        return;
+      }
+    }
+    setupConf(templatesFolder, this.context.getIdeHome());
+    updateSoftware();
+    updateRepositories();
+  }
+
+  private void setupConf(Path template, Path conf) {
+
+    List<Path> children = this.context.getFileAccess().listChildren(template, f -> true);
+    for (Path child : children) {
+
+      String basename = child.getFileName().toString();
+      Path confPath = conf.resolve(basename);
+
+      if (Files.isDirectory(child)) {
+        if (!Files.isDirectory(confPath)) {
+          this.context.getFileAccess().mkdirs(confPath);
+        }
+        setupConf(child, confPath);
+      } else if (Files.isRegularFile(child)) {
+        if (Files.isRegularFile(confPath)) {
+          this.context.debug("Configuration {} already exists - skipping to copy from {}", confPath, child);
+        } else {
+          if (!basename.equals("settings.xml")) {
+            this.context.info("Copying template {} to {}.", child, confPath);
+            this.context.getFileAccess().copy(child, confPath);
+          }
+        }
+      }
+    }
+  }
+
+  private void updateSettings() {
+
+    this.context.info("Updating settings repository ...");
+    Path settingsPath = this.context.getSettingsPath();
+    if (Files.isDirectory(settingsPath) && !this.context.getFileAccess().isEmptyDir(settingsPath)) {
+      // perform git pull on the settings repo
+      this.context.getGitContext().pull(settingsPath);
+      this.context.success("Successfully updated settings repository.");
+    } else {
+      // check if a settings repository is given then clone, otherwise prompt user for a repository.
+      String repository = settingsRepo.getValue();
+      if (repository == null) {
+        if (this.context.isBatchMode()) {
+          repository = DEFAULT_SETTINGS_REPO_URL;
+        } else {
+          this.context.info("Missing your settings at {} and no SETTINGS_URL is defined.", settingsPath);
+          this.context.info("Further details can be found here:");
+          this.context.info("https://github.com/devonfw/IDEasy/blob/main/documentation/settings.asciidoc");
+          this.context.info("Please contact the technical lead of your project to get the SETTINGS_URL for your project.");
+          this.context.info("In case you just want to test IDEasy you may simply hit return to install the default settings.");
+          this.context.info("");
+          this.context.info("Settings URL [{}]:", DEFAULT_SETTINGS_REPO_URL);
+          repository = this.context.readLine();
+        }
+      }
+      if (repository.isBlank()) {
+        repository = DEFAULT_SETTINGS_REPO_URL;
+      }
+      this.context.getGitContext().pullOrClone(repository, settingsPath);
+      this.context.success("Successfully cloned settings repository.");
+    }
+  }
+
+  private void updateSoftware() {
+
+    Set<ToolCommandlet> toolCommandlets = new HashSet<>();
+
+    // installed tools in IDE_HOME/software
+    List<Path> softwares = this.context.getFileAccess().listChildren(this.context.getSoftwarePath(), Files::isDirectory);
+    for (Path software : softwares) {
+      String toolName = software.getFileName().toString();
+      ToolCommandlet toolCommandlet = this.context.getCommandletManager().getToolCommandletOrNull(toolName);
+      if (toolCommandlet != null) {
+        toolCommandlets.add(toolCommandlet);
+      }
+    }
+
+    // regular tools in $IDE_TOOLS
+    List<String> regularTools =  IdeVariables.IDE_TOOLS.get(this.context);
+    if (regularTools != null) {
+      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
+    StepContainer container = new StepContainer(this.context);
+    for (ToolCommandlet toolCommandlet : toolCommandlets) {
+      try {
+        container.startStep(toolCommandlet.getName());
+        toolCommandlet.install(false);
+        container.endStep(toolCommandlet.getName(), true, null);
+      } catch (Exception e) {
+        container.endStep(toolCommandlet.getName(), false, e);
+      }
+    }
+    // summary
+    container.complete();
+  }
+
+  private void updateRepositories() {
+    this.context.getCommandletManager().getCommandlet(RepositoryCommandlet.class).run();
+  }
+}

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

@@ -0,0 +1,89 @@
+package com.devonfw.tools.ide.common;
+
+import com.devonfw.tools.ide.cli.CliException;
+import com.devonfw.tools.ide.context.IdeContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A utility class to manage and log the progress of steps in a process.
+ * Each step can be started, ended with success or failure, and the overall completion
+ * status can be checked.
+ * @throws CliException if one or more steps fail.
+ */
+public class StepContainer {
+
+  private final IdeContext context;
+
+  /** List of steps that ended successfully. */
+  private List<String> successfulSteps;
+
+  /** List of steps that failed. */
+  private List<String> failedSteps;
+
+  /**
+   * The constructor.
+   *
+   * @param context the {@link IdeContext}.
+   */
+  public StepContainer(IdeContext context) {
+
+    this.context = context;
+    successfulSteps = new ArrayList<>();
+    failedSteps = new ArrayList<>();
+  }
+
+  /**
+   * Logs the start of a step.
+   *
+   * @param stepName the name of the step.
+   */
+  public void startStep(String stepName) {
+
+    this.context.step("Starting step: {}", stepName);
+  }
+
+  /**
+   * Logs the end of a step, indicating success or failure.
+   *
+   * @param stepName the name of the step.
+   * @param success {@code true} if the step succeeded, {@code false} otherwise.
+   * @param e the exception associated with the failure, or {@code null} if the step succeeded.
+   */
+  public void endStep(String stepName, boolean success, Throwable e) {
+
+    if (success) {
+      successfulSteps.add(stepName);
+      this.context.success("Step '{}' succeeded.", stepName);
+    } else {
+      failedSteps.add(stepName);
+      this.context.warning("Step '{}' failed.", stepName);
+      if (e != null) {
+        this.context.error(e);
+      }
+    }
+  }
+
+  /**
+   * Checks the overall completion status of all steps.
+   *
+   * @throws CliException if one or more steps fail, providing a detailed summary.
+   */
+  public void complete() {
+
+    if (failedSteps.isEmpty()) {
+      this.context.success("All {} steps ended successfully!", successfulSteps.size());
+    } else {
+      throw new CliException(String.format("%d step(s) failed (%d%%) and %d step(s) succeeded (%d%%) out of %d step(s)!",
+          failedSteps.size(), calculatePercentage(failedSteps.size()), successfulSteps.size(),
+          100 - calculatePercentage(failedSteps.size()), successfulSteps.size() + failedSteps.size()));
+    }
+  }
+
+  private int calculatePercentage(int count) {
+
+    return (count * 100) / (successfulSteps.size() + failedSteps.size());
+  }
+
+}

cli/src/main/java/com/devonfw/tools/ide/context/AbstractIdeContext.java

@@ -688,7 +688,7 @@ public <O> O question(String question, O... options) {
   /**
    * @return the input from the end-user (e.g. read from the console).
    */
-  protected abstract String readLine();
+  public abstract String readLine();
 
   private static <O> void addMapping(Map<String, O> mapping, String key, O option) {