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

Gemini Code Assist wrote this cpp 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 C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.22)
project(YamlConfigMerger)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)

# Pinned yaml-cpp
FetchContent_Declare(
    yaml-cpp
    GIT_REPOSITORY https://github.com/jbeder/yaml-cpp.git
    GIT_TAG 0.8.0
)

FetchContent_MakeAvailable(yaml-cpp)

add_executable(yaml_merger main.cpp)
target_link_libraries(yaml_merger PRIVATE yaml-cpp)

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <regex>
#include <yaml-cpp/yaml.h>

std::string interpolate(const std::string& input) {
    std::regex env_re("\$\{([A-Z0-9_]+)(?::-(.*?))?\}");
    std::smatch match;
    std::string result = input;
    
    while (std::regex_search(result, match, env_re)) {
        std::string var_name = match[1];
        std::string default_val = match[2].matched ? match[2].str() : match[0].str();
        char* env_val = std::getenv(var_name.c_str());
        std::string replacement = env_val ? std::string(env_val) : default_val;
        result.replace(match.position(), match.length(), replacement);
    }
    return result;
}

void deep_merge(YAML::Node& base, const YAML::Node& head, const std::string& strategy) {
    if (!head.IsMap()) return;

    for (auto it = head.begin(); it != head.end(); ++it) {
        std::string key = it->first.as<std::string>();
        if (base[key] && base[key].IsMap() && it->second.IsMap()) {
            YAML::Node sub_node = base[key];
            deep_merge(sub_node, it->second, strategy);
        } else if (base[key] && base[key].IsSequence() && it->second.IsSequence()) {
            if (strategy == "append") {
                for (auto item : it->second) base[key].push_back(item);
            } else if (strategy == "unique") {
                std::vector<std::string> items;
                for (auto item : base[key]) items.push_back(item.as<std::string>());
                for (auto item : it->second) {
                    std::string val = item.as<std::string>();
                    if (std::find(items.begin(), items.end(), val) == items.end()) {
                        base[key].push_back(item);
                        items.push_back(val);
                    }
                }
            } else {
                base[key] = it->second;
            }
        } else {
            base[key] = it->second;
        }
    }
}

void generate_samples() {
    std::cout << "Generating sample YAML files..." << std::endl;
    std::ofstream f1("config1.yaml");
    f1 << "app:
  name: MyApp
  port: 8080
features:
  - auth
db:
  host: "${DB_HOST:-localhost}"";
    std::ofstream f2("config2.yaml");
    f2 << "app:
  port: 9000
features:
  - logging
db:
  user: admin";
}

int main(int argc, char* argv[]) {
    std::string strategy = "replace";
    std::string output_path = "merged_config.yaml";
    std::vector<std::string> input_files;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg == "--array-strategy" && i + 1 < argc) strategy = argv[++i];
        else if (arg == "--output" && i + 1 < argc) output_path = argv[++i];
        else input_files.push_back(arg);
    }

    if (input_files.empty()) {
        generate_samples();
        input_files = {"config1.yaml", "config2.yaml"};
    }

    YAML::Node merged;
    for (const auto& file : input_files) {
        try {
            YAML::Node node = YAML::LoadFile(file);
            deep_merge(merged, node, strategy);
        } catch (const std::exception& e) {
            std::cerr << "Error loading " << file << ": " << e.what() << std::endl;
            return 1;
        }
    }

    std::ofstream out(output_path);
    out << merged;
    std::cout << "Merged configuration saved to " << output_path << std::endl;
    std::cout << merged << std::endl;

    return 0;
}

# YAML Config Merger (C++)

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

## Setup Instructions

1. Ensure G++ 12+ and CMake 3.22+ are installed.
2. Build the project:
   ```bash
   mkdir build && cd build
   cmake ..
   make
   ```

## Run Commands

- Merge multiple files:
  ```bash
  ./yaml_merger ../config1.yaml ../config2.yaml
  ```
- Use a specific array merge strategy:
  ```bash
  ./yaml_merger ../config1.yaml ../config2.yaml --array-strategy append
  ```
- Run with generated sample data:
  ```bash
  ./yaml_merger
  ```

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