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

Gemini Code Assist wrote this python 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 Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.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

[]

# YAML Config Merger (Python)

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

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- Merge multiple files:
  ```bash
  python yaml_merger.py config1.yaml config2.yaml
  ```
- Use a specific array merge strategy:
  ```bash
  python yaml_merger.py config1.yaml config2.yaml --array-strategy append
  ```
- Validate against a schema:
  ```bash
  python yaml_merger.py config1.yaml config2.yaml --schema schema.json
  ```
- Run with generated sample data:
  ```bash
  python yaml_merger.py
  ```

## Features
- Deep merging of nested dictionaries.
- Environment variable interpolation: `${VAR:-default}`.
- Array strategies: `replace`, `append`, `unique`.

PyYAML==6.0.1
jsonschema==4.21.1

import yaml
import os
import re
import sys
import argparse
import json
from jsonschema import validate
from typing import Any, Dict, List, Optional

def interpolate_env_vars(data: Any) -> Any:
    if isinstance(data, str):
        # Match ${VAR_NAME} or ${VAR_NAME:-default}
        pattern = re.compile(r'\$\{(?P<var>[A-Z0-9_]+)(?::-(?P<default>.*))?\}')
        
        def replace(match):
            var = match.group('var')
            default = match.group('default')
            return os.environ.get(var, default if default is not None else match.group(0))
        
        return pattern.sub(replace, data)
    elif isinstance(data, dict):
        return {k: interpolate_env_vars(v) for k, v in data.items()}
    elif isinstance(data, list):
        return [interpolate_env_vars(i) for i in data]
    return data

def deep_merge(base: Dict, head: Dict, array_strategy: str = 'replace', path: str = "$") -> Dict:
    for key, value in head.items():
        current_path = f"{path}.{key}"
        if key in base:
            if isinstance(base[key], dict) and isinstance(value, dict):
                deep_merge(base[key], value, array_strategy, current_path)
            elif isinstance(base[key], list) and isinstance(value, list):
                if array_strategy == 'append':
                    base[key].extend(value)
                elif array_strategy == 'unique':
                    base[key] = list(dict.fromkeys(base[key] + value))
                else: # replace
                    base[key] = value
            else:
                base[key] = value
        else:
            base[key] = value
    return base

def generate_samples():
    print("Generating sample YAML files...")
    config1 = {
        "app": {"name": "MyApp", "port": 8080},
        "features": ["auth", "logging"],
        "db": {"host": "${DB_HOST:-localhost}"}
    }
    config2 = {
        "app": {"port": 9000},
        "features": ["metrics"],
        "db": {"user": "admin"}
    }
    with open("config1.yaml", "w") as f:
        yaml.dump(config1, f)
    with open("config2.yaml", "w") as f:
        yaml.dump(config2, f)
    return ["config1.yaml", "config2.yaml"]

def main():
    parser = argparse.ArgumentParser(description="YAML Config Merger")
    parser.add_argument("files", nargs="*", help="YAML files to merge")
    parser.add_argument("--array-strategy", choices=['replace', 'append', 'unique'], default='replace')
    parser.add_argument("--output", default="merged_config.yaml")
    parser.add_argument("--schema", help="JSON Schema file for validation")
    
    args = parser.parse_args()
    
    input_files = args.files
    if not input_files:
        input_files = generate_samples()

    merged_data = {}
    for f_path in input_files:
        try:
            with open(f_path, 'r') as f:
                data = yaml.safe_load(f) or {}
                merged_data = deep_merge(merged_data, data, args.array_strategy)
        except Exception as e:
            print(f"Error reading {f_path}: {e}")
            return

    # Interpolate environment variables
    final_data = interpolate_env_vars(merged_data)

    # Validate if schema provided
    if args.schema:
        try:
            with open(args.schema, 'r') as sf:
                schema = json.load(sf)
            validate(instance=final_data, schema=schema)
            print("Validation successful.")
        except Exception as e:
            print(f"Validation failed: {e}")
            return

    # Output
    output_yaml = yaml.dump(final_data, default_flow_style=False)
    with open(args.output, 'w') as f:
        f.write(output_yaml)
    
    print(f"
Merged configuration saved to {args.output}:")
    print(output_yaml)

if __name__ == "__main__":
    main()