#1166: import maven repos in intellij by editing misc.xml

CHANGELOG.adoc

@@ -4,6 +4,8 @@ This file documents all notable changes to https://github.com/devonfw/IDEasy[IDE
 
 == 2025.12.001
 
+* https://github.com/devonfw/IDEasy/issues/1166[#1166]: Automatic project import for IntelliJ
+
 Release with new features and bugfixes:
 
 * https://github.com/devonfw/IDEasy/issues/39[#39]: Implement ToolCommandlet for pip

cli/src/main/java/com/devonfw/tools/ide/environment/ExtensibleEnvironmentVariables.java

@@ -0,0 +1,52 @@
+package com.devonfw.tools.ide.environment;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.devonfw.tools.ide.context.IdeContext;
+
+/**
+ * Subclass of {@link EnvironmentVariablesMap} that resolves variables recursively and allows new variables to be added to the resolver.
+ */
+public class ExtensibleEnvironmentVariables extends EnvironmentVariablesMap {
+
+  private final Map<String, String> additionalEnvironmentVariables;
+
+  /**
+   * The constructor.
+   *
+   * @param parent the parent {@link EnvironmentVariables} to inherit from.
+   * @param context the context to use.
+   */
+  public ExtensibleEnvironmentVariables(AbstractEnvironmentVariables parent, IdeContext context) {
+    super(parent, context);
+    this.additionalEnvironmentVariables = new HashMap<>();
+  }
+
+  /**
+   * @param name the variable string to be resolved
+   * @param value the string the variable should be resolved into
+   */
+  public void addVariableResolver(String name, String value) {
+    this.additionalEnvironmentVariables.put(name, value);
+  }
+
+  @Override
+  protected String getValue(String name, boolean ignoreDefaultValue) {
+    String value = this.additionalEnvironmentVariables.get(name);
+    if (value != null) {
+      return value;
+    }
+    return super.getValue(name, ignoreDefaultValue);
+  }
+
+  @Override
+  protected Map<String, String> getVariables() {
+    return this.additionalEnvironmentVariables;
+  }
+
+  @Override
+  public EnvironmentVariablesType getType() {
+    return EnvironmentVariablesType.TOOL;
+  }
+}

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

@@ -8,6 +8,7 @@
 import java.nio.file.attribute.PosixFilePermission;
 import java.time.Duration;
 import java.util.List;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
 import java.util.function.Consumer;
@@ -154,8 +155,8 @@ default void copy(Path source, Path target) {
   /**
    * @param source the source {@link Path file or folder} to copy.
    * @param target the {@link Path} to copy {@code source} to. Unlike the Linux {@code cp} command this method will not take the filename of {@code source}
-   *     and copy that to {@code target} in case that is an existing folder. Instead it will always be simple and stupid and just copy from {@code source} to
-   *     {@code target}. Therefore the result is always clear and easy to predict and understand. Also you can easily rename a file to copy. While
+   *     and copy that to {@code target} in case that is an existing folder. Instead, it will always be simple and stupid and just copy from {@code source} to
+   *     {@code target}. Therefore, the result is always clear and easy to predict and understand. Also, you can easily rename a file to copy. While
    *     {@code cp my-file target} may lead to a different result than {@code cp my-file target/} this method will always ensure that in the end you will find
    *     the same content of {@code source} in {@code target}.
    * @param mode the {@link FileCopyMode}.
@@ -168,8 +169,8 @@ default void copy(Path source, Path target, FileCopyMode mode) {
   /**
    * @param source the source {@link Path file or folder} to copy.
    * @param target the {@link Path} to copy {@code source} to. Unlike the Linux {@code cp} command this method will not take the filename of {@code source}
-   *     and copy that to {@code target} in case that is an existing folder. Instead it will always be simple and stupid and just copy from {@code source} to
-   *     {@code target}. Therefore the result is always clear and easy to predict and understand. Also you can easily rename a file to copy. While
+   *     and copy that to {@code target} in case that is an existing folder. Instead, it will always be simple and stupid and just copy from {@code source} to
+   *     {@code target}. Therefore, the result is always clear and easy to predict and understand. Also, you can easily rename a file to copy. While
    *     {@code cp my-file target} may lead to a different result than {@code cp my-file target/} this method will always ensure that in the end you will find
    *     the same content of {@code source} in {@code target}.
    * @param mode the {@link FileCopyMode}.
@@ -331,6 +332,23 @@ default void extract(Path archiveFile, Path targetDir, Consumer<Path> postExtrac
    */
   Path findFirst(Path dir, Predicate<Path> filter, boolean recursive);
 
+  /**
+   * Searches upward from the given starting path to find the nearest ancestor directory that contains a specific subfolder. The search stops before ascending
+   * into any parent directory whose name matches the provided stop boundary.
+   *
+   * @param start the starting {@link Path} from which to begin the upward traversal. Must not be {@code null}.
+   * @param folderName the name of the subfolder to look for in each ancestor directory (e.g., ".idea"). Must not be {@code null} or empty.
+   * @param stopBeforeParentName the name of a parent directory at which the search should stop (case-insensitive). The method will not ascend into this
+   *     directory. For example, if this is "workspaces", the search will stop at the child of "workspaces" and will not check inside "workspaces" itself.
+   * @return {@link Path} of the ancestor directory that contains the specified subfolder, or {@link Optional#empty()} if no such ancestor is found before
+   *     reaching the stop boundary.
+   */
+  Path findAncestorWithFolder(
+      Path start,
+      String folderName,
+      String stopBeforeParentName
+  );
+
   /**
    * @param dir the {@link Path} to the directory where to list the children.
    * @param filter the {@link Predicate} used to {@link Predicate#test(Object) decide} which children to include (if {@code true} is returned).
@@ -510,7 +528,7 @@ default void writeProperties(Properties properties, Path file) {
   /**
    * @param properties the {@link Properties} to save.
    * @param file the {@link Path} to the file where to save the properties.
-   * @param createParentDir if {@code true}, the parent directory will created if it does not already exist, {@code false} otherwise (fail if parent does
+   * @param createParentDir if {@code true}, the parent directory will be created if it does not already exist, {@code false} otherwise (fail if parent does
    *     not exist).
    */
   void writeProperties(Properties properties, Path file, boolean createParentDir);

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

@@ -1025,6 +1025,39 @@ private Path findFirstRecursive(Path dir, Predicate<Path> filter, boolean recurs
     return null;
   }
 
+  @Override
+  public Path findAncestorWithFolder(
+      Path start,
+      String folderName,
+      String stopBeforeParentName
+  ) {
+
+    Path current = start.toAbsolutePath().normalize();
+
+    while (current != null) {
+
+      Path candidate = current.resolve(folderName);
+      if (Files.isDirectory(candidate)) {
+        return current;
+      }
+
+      Path parent = current.getParent();
+      if (parent == null) {
+        break;
+      }
+
+      Path parentName = parent.getFileName();
+      if (parentName != null &&
+          parentName.toString().equalsIgnoreCase(stopBeforeParentName)) {
+        break;
+      }
+
+      // Ascend
+      current = parent;
+    }
+    return null;
+  }
+
   @Override
   public List<Path> listChildrenMapped(Path dir, Function<Path, Path> filter) {
 

cli/src/main/java/com/devonfw/tools/ide/merge/xml/XmlMerger.java

@@ -112,8 +112,8 @@ protected void doMerge(Path setup, Path update, EnvironmentVariables resolver, P
   public Document merge(XmlMergeDocument templateDocument, XmlMergeDocument workspaceDocument, boolean workspaceFileExists) {
 
     Document resultDocument;
-    Path source = templateDocument.getPath();
-    Path template = workspaceDocument.getPath();
+    Path template = templateDocument.getPath();
+    Path source = workspaceDocument.getPath();
     this.context.debug("Merging {} into {} ...", template, source);
     Element templateRoot = templateDocument.getRoot();
     QName templateQName = XmlMergeSupport.getQualifiedName(templateRoot);
@@ -185,6 +185,19 @@ public XmlMergeDocument load(Path file) {
     }
   }
 
+  /**
+   * Creates an empty but valid xml file.
+   *
+   * @param tagName name of the tag to use for the root node.
+   * @param file Path of the file to create.
+   */
+  public void createValidEmptyXmlFile(String tagName, Path file) {
+    Document document = DOCUMENT_BUILDER.newDocument();
+    Element root = document.createElement(tagName);
+    document.appendChild(root);
+    save(new XmlMergeDocument(document, file));
+  }
+
   /**
    * @param document the XML {@link XmlMergeDocument} to save.
    */

cli/src/main/java/com/devonfw/tools/ide/tool/gradle/Gradle.java

@@ -17,8 +17,11 @@
  */
 public class Gradle extends LocalToolCommandlet {
 
-  private static final String BUILD_GRADLE = "build.gradle";
-  private static final String BUILD_GRADLE_KTS = "build.gradle.kts";
+  /** build.gradle file name */
+  public static final String BUILD_GRADLE = "build.gradle";
+
+  /** build.gradle.kts file name */
+  public static final String BUILD_GRADLE_KTS = "build.gradle.kts";
   private static final String GRADLE_WRAPPER_FILENAME = "gradlew";
 
   /**

cli/src/main/java/com/devonfw/tools/ide/tool/intellij/Intellij.java

@@ -1,14 +1,27 @@
 package com.devonfw.tools.ide.tool.intellij;
 
+import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Set;
 
+import org.w3c.dom.Document;
+
 import com.devonfw.tools.ide.common.Tag;
 import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.environment.AbstractEnvironmentVariables;
+import com.devonfw.tools.ide.environment.EnvironmentVariables;
+import com.devonfw.tools.ide.environment.ExtensibleEnvironmentVariables;
+import com.devonfw.tools.ide.io.FileAccess;
+import com.devonfw.tools.ide.io.FileAccessImpl;
+import com.devonfw.tools.ide.merge.xml.XmlMergeDocument;
+import com.devonfw.tools.ide.merge.xml.XmlMerger;
 import com.devonfw.tools.ide.process.EnvironmentContext;
 import com.devonfw.tools.ide.tool.ToolInstallation;
+import com.devonfw.tools.ide.tool.gradle.Gradle;
 import com.devonfw.tools.ide.tool.ide.IdeToolCommandlet;
 import com.devonfw.tools.ide.tool.ide.IdeaBasedIdeToolCommandlet;
+import com.devonfw.tools.ide.tool.mvn.Mvn;
 
 /**
  * {@link IdeToolCommandlet} for <a href="https://www.jetbrains.com/idea/">IntelliJ</a>.
@@ -21,6 +34,11 @@ public class Intellij extends IdeaBasedIdeToolCommandlet {
 
   private static final String IDEA_BASH_SCRIPT = IDEA + ".sh";
 
+  private static final String TEMPLATE_LOCATION = "intellij/workspace/repository/.idea";
+  private static final String GRADLE_XML = "gradle.xml";
+  private static final String MISC_XML = "misc.xml";
+  private static final String IDEA_PROPERTIES = "idea.properties";
+
   /**
    * The constructor.
    *
@@ -49,9 +67,89 @@ protected String getBinaryName() {
 
   @Override
   public void setEnvironment(EnvironmentContext environmentContext, ToolInstallation toolInstallation, boolean additionalInstallation) {
-
     super.setEnvironment(environmentContext, toolInstallation, additionalInstallation);
-    environmentContext.withEnvVar("IDEA_PROPERTIES", this.context.getWorkspacePath().resolve("idea.properties").toString());
+    environmentContext.withEnvVar("IDEA_PROPERTIES", this.context.getWorkspacePath().resolve(IDEA_PROPERTIES).toString());
+  }
+
+  private EnvironmentVariables getIntellijEnvironmentVariables(Path projectPath) {
+    ExtensibleEnvironmentVariables environmentVariables = new ExtensibleEnvironmentVariables(
+        (AbstractEnvironmentVariables) this.context.getVariables().getParent(), this.context);
+
+    environmentVariables.addVariableResolver("PROJECT_PATH", projectPath.toString());
+    return environmentVariables.resolved();
+  }
+
+  private void mergeConfig(Path repositoryPath, String configName) throws IOException {
+    Path workspacePath = getOrCreateWorkspaceXmlFile(repositoryPath, configName);
+
+    if (workspacePath != null) {
+      XmlMerger xmlMerger = new XmlMerger(context);
+      Path templatePath = this.context.getSettingsPath().resolve(TEMPLATE_LOCATION).resolve(configName);
+
+      EnvironmentVariables environmentVariables = getIntellijEnvironmentVariables(repositoryPath.getFileName());
+
+      if (!Files.exists(workspacePath)) {
+        xmlMerger.createValidEmptyXmlFile("project", workspacePath);
+      }
+      XmlMergeDocument workspaceDocument = xmlMerger.load(workspacePath);
+      XmlMergeDocument templateDocument = xmlMerger.loadAndResolve(templatePath, environmentVariables);
+
+      Document mergedDocument = xmlMerger.merge(templateDocument, workspaceDocument, false);
+
+      xmlMerger.save(mergedDocument, workspacePath);
+    }
+  }
+
+  private Path getOrCreateWorkspaceXmlFile(Path repositoryPath, String fileName) {
+    FileAccess fileAccess = new FileAccessImpl(context);
+
+    Path ideaParentPath = fileAccess
+        .findAncestorWithFolder(repositoryPath, "." + IDEA, "workspaces");
+
+    if (ideaParentPath != null) {
+      return ideaParentPath.resolve("." + IDEA).resolve(fileName);
+    }
+    return null;
+  }
+
+  private boolean importTemplatesExist() {
+    Path templatePath = this.context.getSettingsPath().resolve(TEMPLATE_LOCATION);
+    Path miscXml = templatePath.resolve(MISC_XML);
+    Path gradleXml = templatePath.resolve(GRADLE_XML);
+    return Files.exists(miscXml) && Files.exists(gradleXml);
+  }
+
+  @Override
+  public void importRepository(Path repositoryPath) {
+    if (!importTemplatesExist()) {
+      this.context.warning("Could not automatically import repository due to missing template files.");
+      return;
+    }
+    // check if pom.xml exists
+    Path pomPath = repositoryPath.resolve(Mvn.POM_XML);
+    if (Files.exists(pomPath)) {
+      try {
+        mergeConfig(repositoryPath, MISC_XML);
+      } catch (IOException e) {
+        this.context.error(e);
+      }
+
+    } else {
+      this.context.debug("no pom.xml found was found in {}", pomPath);
+    }
+
+    // check if build.gradle exists
+    Path javaGradlePath = repositoryPath.resolve(Gradle.BUILD_GRADLE);
+    Path kotlinGradlePath = repositoryPath.resolve(Gradle.BUILD_GRADLE_KTS);
+    if (Files.exists(javaGradlePath) || Files.exists(kotlinGradlePath)) {
+      try {
+        mergeConfig(repositoryPath, GRADLE_XML);
+      } catch (IOException e) {
+        this.context.error(e);
+      }
+    } else {
+      this.context.debug("no build.gradle found in {} and {}", javaGradlePath, kotlinGradlePath);
+    }
   }
 
 }