YAML Config Merger (java, written by Gemini Code Assist)

Gemini Code Assist wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: YAML Config Merger

Write a program that merges multiple YAML configuration files into a single unified configuration, supporting deep merging of nested structures, array handling strategies, and conflict resolution.

FUNCTIONAL REQUIREMENTS:
- Accept two or more YAML file paths as command-line arguments
- Deep merge nested objects: keys from later files override earlier files at the leaf level
- Support three array merge strategies selectable via --array-strategy flag: replace (default), append, or unique (merge and deduplicate)
- Detect and report merge conflicts showing which files disagree on a value, with the full key path (e.g., database.connection.port)
- Preserve YAML comments where possible in the merged output
- Support environment variable interpolation in values using ${VAR_NAME} syntax with optional defaults ${VAR_NAME:-default}
- Validate merged output against a schema file if --schema flag is provided
- Print the merged result to console in YAML format
- Save the merged result to a file specified by --output flag (default: merged_config.yaml)
- If no input files are given, generate three sample YAML config files with overlapping keys, nested structures, and arrays, then merge them
- Handle malformed YAML with clear error messages identifying the file and location of the problem

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yamlmerger</groupId>
    <artifactId>yaml-config-merger</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- SnakeYAML for YAML parsing -->
        <dependency>
            <groupId>org.yaml</groupId>
            <artifactId>snakeyaml</artifactId>
            <version>2.2</version>
        </dependency>
        <!-- Jackson for JSON conversion and interpolation -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.16.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>2.16.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.yamlmerger.YamlConfigMerger</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

# YAML Config Merger (Java)

A tool for deep merging multiple YAML configuration files with environment variable support.

## Setup Instructions

1. Ensure JDK 17+ and Maven are installed.
2. Build the project:
   ```bash
   mvn clean package
   ```

## Run Commands

- Merge multiple files:
  ```bash
  java -jar target/yaml-config-merger-1.0-SNAPSHOT.jar config1.yaml config2.yaml
  ```
- Use a specific array merge strategy:
  ```bash
  java -jar target/yaml-config-merger-1.0-SNAPSHOT.jar config1.yaml config2.yaml --array-strategy append
  ```
- Run with generated sample data:
  ```bash
  java -jar target/yaml-config-merger-1.0-SNAPSHOT.jar
  ```

## Output
- Console: Merged YAML configuration.
- File: `merged_config.yaml` by default.

package com.yamlmerger;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;
import org.yaml.snakeyaml.Yaml;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class YamlConfigMerger {

    private static final Pattern ENV_PATTERN = Pattern.compile("\$\{(?<var>[A-Z0-9_]+)(?::-(?<default>.*))?\}");

    public static void main(String[] args) {
        String arrayStrategy = "replace";
        String outputPath = "merged_config.yaml";
        List<String> inputFiles = new ArrayList<>();

        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("--array-strategy") && i + 1 < args.length) {
                arrayStrategy = args[++i];
            } else if (args[i].equals("--output") && i + 1 < args.length) {
                outputPath = args[++i];
            } else {
                inputFiles.add(args[i]);
            }
        }

        if (inputFiles.isEmpty()) {
            generateSamples();
            inputFiles.addAll(Arrays.asList("config1.yaml", "config2.yaml"));
        }

        mergeFiles(inputFiles, outputPath, arrayStrategy);
    }

    private static void generateSamples() {
        System.out.println("Generating sample YAML files...");
        String c1 = "app:
  name: MyApp
  port: 8080
features:
  - auth
  - logging
db:
  host: "${DB_HOST:-localhost}"";
        String c2 = "app:
  port: 9000
features:
  - metrics
db:
  user: admin";
        try {
            Files.write(Paths.get("config1.yaml"), c1.getBytes());
            Files.write(Paths.get("config2.yaml"), c2.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void mergeFiles(List<String> files, String outPath, String strategy) {
        ObjectMapper mapper = new ObjectMapper(new YAMLFactory().disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER));
        ObjectNode root = mapper.createObjectNode();

        for (String filePath : files) {
            try {
                JsonNode node = mapper.readTree(new File(filePath));
                deepMerge(root, node, strategy);
            } catch (Exception e) {
                System.err.println("Error reading " + filePath + ": " + e.getMessage());
                return;
            }
        }

        JsonNode interpolated = interpolate(root);

        try {
            mapper.writerWithDefaultPrettyPrinter().writeValue(new File(outPath), interpolated);
            System.out.println("Merged configuration saved to " + outPath);
            System.out.println(mapper.writeValueAsString(interpolated));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void deepMerge(ObjectNode base, JsonNode head, String strategy) {
        Iterator<Map.Entry<String, JsonNode>> fields = head.fields();
        while (fields.hasNext()) {
            Map.Entry<String, JsonNode> field = fields.next();
            String key = field.getKey();
            JsonNode value = field.getValue();

            if (base.has(key)) {
                JsonNode baseValue = base.get(key);
                if (baseValue.isObject() && value.isObject()) {
                    deepMerge((ObjectNode) baseValue, value, strategy);
                } else if (baseValue.isArray() && value.isArray()) {
                    mergeArrays((ArrayNode) baseValue, (ArrayNode) value, strategy);
                } else {
                    base.set(key, value);
                }
            } else {
                base.set(key, value);
            }
        }
    }

    private static void mergeArrays(ArrayNode base, ArrayNode head, String strategy) {
        if (strategy.equals("append")) {
            base.addAll(head);
        } else if (strategy.equals("unique")) {
            Set<JsonNode> set = new LinkedHashSet<>();
            base.forEach(set::add);
            head.forEach(set::add);
            base.removeAll();
            set.forEach(base::add);
        } else {
            base.removeAll();
            base.addAll(head);
        }
    }

    private static JsonNode interpolate(JsonNode node) {
        if (node.isTextual()) {
            String val = node.asText();
            Matcher matcher = ENV_PATTERN.matcher(val);
            StringBuilder sb = new StringBuilder();
            while (matcher.find()) {
                String var = matcher.group("var");
                String def = matcher.group("default");
                String envVal = System.getenv(var);
                matcher.appendReplacement(sb, envVal != null ? envVal : (def != null ? def : matcher.group(0)));
            }
            matcher.appendTail(sb);
            return node.textNode(sb.toString());
        } else if (node.isObject()) {
            ObjectNode newNode = new ObjectMapper().createObjectNode();
            node.fields().forEachRemaining(entry -> newNode.set(entry.getKey(), interpolate(entry.getValue())));
            return newNode;
        } else if (node.isArray()) {
            ArrayNode newNode = new ObjectMapper().createArrayNode();
            node.forEach(i -> newNode.add(interpolate(i)));
            return newNode;
        }
        return node;
    }
}