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

Gemini Code Assist wrote this javascript project from the task below. It installed and ran 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 JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

{
  "name": "yaml-config-merger",
  "version": "1.0.0",
  "description": "Deep YAML configuration merger",
  "main": "yaml_merger.js",
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "js-yaml": "4.1.0",
    "lodash": "4.17.21",
    "yargs": "17.7.2"
  },
  "scripts": {
    "start": "node yaml_merger.js"
  }
}

# YAML Config Merger (JavaScript)

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

## Setup Instructions

1. Ensure Node.js 20+ (LTS) is installed.
2. Install dependencies:
   ```bash
   npm install
   ```

## Run Commands

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

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

const fs = require('fs');
const yaml = require('js-yaml');
const _ = require('lodash');
const yargs = require('yargs/yargs');
const { hideBin } = require('yargs/helpers');

const argv = yargs(hideBin(process.argv))
    .option('array-strategy', { choices: ['replace', 'append', 'unique'], default: 'replace' })
    .option('output', { default: 'merged_config.yaml' })
    .argv;

function interpolate(data) {
    if (typeof data === 'string') {
        return data.replace(/\$\{(?<var>[A-Z0-9_]+)(?::-(?<default>.*?))?\}/g, (match, varName, defaultValue) => {
            return process.env[varName] || defaultValue || match;
        });
    } else if (_.isPlainObject(data)) {
        return _.mapValues(data, interpolate);
    } else if (_.isArray(data)) {
        return data.map(interpolate);
    }
    return data;
}

function customMerge(objValue, srcValue, key, object, source, stack) {
    if (_.isArray(objValue)) {
        if (argv.arrayStrategy === 'append') {
            return objValue.concat(srcValue);
        } else if (argv.arrayStrategy === 'unique') {
            return _.unionWith(objValue, srcValue, _.isEqual);
        }
        // default: replace (which lodash merge does by default for non-objects if not handled)
    }
}

function generateSamples() {
    console.log("Generating sample YAML files...");
    const c1 = { app: { name: 'MyApp', port: 8080 }, features: ['auth'], db: { host: '${DB_HOST:-localhost}' } };
    const c2 = { app: { port: 9000 }, features: ['logging'], db: { user: 'admin' } };
    fs.writeFileSync('config1.yaml', yaml.dump(c1));
    fs.writeFileSync('config2.yaml', yaml.dump(c2));
    return ['config1.yaml', 'config2.yaml'];
}

let inputFiles = argv._;
if (inputFiles.length === 0) {
    inputFiles = generateSamples();
}

let merged = {};
inputFiles.forEach(file => {
    try {
        const content = yaml.load(fs.readFileSync(file, 'utf8'));
        if (argv.arrayStrategy === 'replace') {
            _.merge(merged, content);
        } else {
            _.mergeWith(merged, content, customMerge);
        }
    } catch (e) {
        console.error(`Error reading ${file}:`, e.message);
    }
});

const finalConfig = interpolate(merged);
const outputYaml = yaml.dump(finalConfig);

fs.writeFileSync(argv.output, outputYaml);
console.log(`Merged configuration saved to ${argv.output}:`);
console.log(outputYaml);