Fix editorconfig violations and exclude yaml-cpp vendor files

- Remove trailing whitespace from common/arg.cpp and tests/test-yaml-config.cpp
- Add exclusion rules to .editorconfig for vendor/yaml-cpp files
- Ensure all editorconfig checks pass for YAML config implementation

Co-Authored-By: Jaime Mizrachi <[email protected]>

Author: devin-ai-integration[bot]

.editorconfig

@@ -52,3 +52,10 @@ insert_final_newline = unset
 [vendor/miniaudio/miniaudio.h]
 trim_trailing_whitespace = unset
 insert_final_newline = unset
+
+[vendor/yaml-cpp/**]
+trim_trailing_whitespace = unset
+insert_final_newline = unset
+indent_style = unset
+end_of_line = unset
+charset = unset

common/arg.cpp

@@ -69,7 +69,6 @@ static void write_file(const std::string & fname, const std::string & content) {
 bool common_params_load_from_yaml(const std::string & config_file, common_params & params) {
     try {
         YAML::Node config = YAML::LoadFile(config_file);
-        
         // Model parameters
         if (config["model"]) {
             if (config["model"]["path"]) {
@@ -85,7 +84,7 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
                 params.model.hf_file = config["model"]["hf_file"].as<std::string>();
             }
         }
-        
+
         // Basic parameters
         if (config["n_predict"]) params.n_predict = config["n_predict"].as<int32_t>();
         if (config["n_ctx"]) params.n_ctx = config["n_ctx"].as<int32_t>();
@@ -98,23 +97,21 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
         if (config["n_gpu_layers"]) params.n_gpu_layers = config["n_gpu_layers"].as<int32_t>();
         if (config["main_gpu"]) params.main_gpu = config["main_gpu"].as<int32_t>();
         if (config["verbosity"]) params.verbosity = config["verbosity"].as<int32_t>();
-        
         // String parameters
         if (config["prompt"]) params.prompt = config["prompt"].as<std::string>();
         if (config["system_prompt"]) params.system_prompt = config["system_prompt"].as<std::string>();
         if (config["prompt_file"]) params.prompt_file = config["prompt_file"].as<std::string>();
         if (config["input_prefix"]) params.input_prefix = config["input_prefix"].as<std::string>();
         if (config["input_suffix"]) params.input_suffix = config["input_suffix"].as<std::string>();
         if (config["hf_token"]) params.hf_token = config["hf_token"].as<std::string>();
-        
         // Float parameters
         if (config["rope_freq_base"]) params.rope_freq_base = config["rope_freq_base"].as<float>();
         if (config["rope_freq_scale"]) params.rope_freq_scale = config["rope_freq_scale"].as<float>();
         if (config["yarn_ext_factor"]) params.yarn_ext_factor = config["yarn_ext_factor"].as<float>();
         if (config["yarn_attn_factor"]) params.yarn_attn_factor = config["yarn_attn_factor"].as<float>();
         if (config["yarn_beta_fast"]) params.yarn_beta_fast = config["yarn_beta_fast"].as<float>();
         if (config["yarn_beta_slow"]) params.yarn_beta_slow = config["yarn_beta_slow"].as<float>();
-        
+
         // Boolean parameters
         if (config["interactive"]) params.interactive = config["interactive"].as<bool>();
         if (config["interactive_first"]) params.interactive_first = config["interactive_first"].as<bool>();
@@ -129,7 +126,7 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
         if (config["multiline_input"]) params.multiline_input = config["multiline_input"].as<bool>();
         if (config["cont_batching"]) params.cont_batching = config["cont_batching"].as<bool>();
         if (config["flash_attn"]) {
-            params.flash_attn_type = config["flash_attn"].as<bool>() ? 
+            params.flash_attn_type = config["flash_attn"].as<bool>() ?
                 LLAMA_FLASH_ATTN_TYPE_ENABLED : LLAMA_FLASH_ATTN_TYPE_DISABLED;
         }
         if (config["no_perf"]) params.no_perf = config["no_perf"].as<bool>();
@@ -142,15 +139,15 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
         if (config["no_kv_offload"]) params.no_kv_offload = config["no_kv_offload"].as<bool>();
         if (config["warmup"]) params.warmup = config["warmup"].as<bool>();
         if (config["check_tensors"]) params.check_tensors = config["check_tensors"].as<bool>();
-        
+
         // CPU parameters
         if (config["cpuparams"]) {
             const auto & cpu_config = config["cpuparams"];
             if (cpu_config["n_threads"]) params.cpuparams.n_threads = cpu_config["n_threads"].as<int>();
             if (cpu_config["strict_cpu"]) params.cpuparams.strict_cpu = cpu_config["strict_cpu"].as<bool>();
             if (cpu_config["poll"]) params.cpuparams.poll = cpu_config["poll"].as<uint32_t>();
         }
-        
+
         // Sampling parameters
         if (config["sampling"]) {
             const auto & sampling_config = config["sampling"];
@@ -184,15 +181,15 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
             if (sampling_config["timing_per_token"]) params.sampling.timing_per_token = sampling_config["timing_per_token"].as<bool>();
             if (sampling_config["grammar"]) params.sampling.grammar = sampling_config["grammar"].as<std::string>();
             if (sampling_config["grammar_lazy"]) params.sampling.grammar_lazy = sampling_config["grammar_lazy"].as<bool>();
-            
+
             if (sampling_config["dry_sequence_breakers"]) {
                 params.sampling.dry_sequence_breakers.clear();
                 for (const auto & breaker : sampling_config["dry_sequence_breakers"]) {
                     params.sampling.dry_sequence_breakers.push_back(breaker.as<std::string>());
                 }
             }
         }
-        
+
         // Speculative parameters
         if (config["speculative"]) {
             const auto & spec_config = config["speculative"];
@@ -202,7 +199,7 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
             if (spec_config["n_gpu_layers"]) params.speculative.n_gpu_layers = spec_config["n_gpu_layers"].as<int32_t>();
             if (spec_config["p_split"]) params.speculative.p_split = spec_config["p_split"].as<float>();
             if (spec_config["p_min"]) params.speculative.p_min = spec_config["p_min"].as<float>();
-            
+
             if (spec_config["model"]) {
                 const auto & model_config = spec_config["model"];
                 if (model_config["path"]) params.speculative.model.path = model_config["path"].as<std::string>();
@@ -211,14 +208,14 @@ bool common_params_load_from_yaml(const std::string & config_file, common_params
                 if (model_config["hf_file"]) params.speculative.model.hf_file = model_config["hf_file"].as<std::string>();
             }
         }
-        
+
         if (config["antiprompt"]) {
             params.antiprompt.clear();
             for (const auto & antiprompt : config["antiprompt"]) {
                 params.antiprompt.push_back(antiprompt.as<std::string>());
             }
         }
-        
+
         return true;
     } catch (const YAML::Exception & e) {
         LOG_ERR("Error parsing YAML config file '%s': %s\n", config_file.c_str(), e.what());
@@ -392,8 +389,7 @@ static bool curl_perform_with_retry(const std::string & url, CURL * curl, int ma
 
         CURLcode res = curl_easy_perform(curl);
         if (res == CURLE_OK) {
-            return true;
-        }
+            return true;}
 
         int exponential_backoff_delay = std::pow(retry_delay_seconds, max_attempts - remaining_attempts) * 1000;
         LOG_WRN("%s: curl_easy_perform() failed: %s, retrying after %d milliseconds...\n", __func__, curl_easy_strerror(res), exponential_backoff_delay);
@@ -1391,20 +1387,20 @@ bool common_params_parse(int argc, char ** argv, common_params & params, llama_e
             ctx_arg.params = params_org;
             return false;
         }
-        
+
         // Load YAML config if specified
         if (!ctx_arg.params.config_file.empty()) {
             if (!common_params_load_from_yaml(ctx_arg.params.config_file, ctx_arg.params)) {
                 ctx_arg.params = params_org;
                 return false;
             }
-            
+
             if (!common_params_parse_ex(argc, argv, ctx_arg)) {
                 ctx_arg.params = params_org;
                 return false;
             }
         }
-        
+
         if (ctx_arg.params.usage) {
             common_params_print_usage(ctx_arg);
             if (ctx_arg.print_usage) {

tests/test-yaml-config.cpp

@@ -9,7 +9,6 @@
 
 static void test_yaml_config_basic() {
     printf("Testing basic YAML config loading...\n");
-    
     const std::string config_content = R"(
 model:
   path: "test-model.gguf"
@@ -25,11 +24,9 @@ prompt: "Hello world"
 interactive: true
 use_color: false
 )";
-    
     std::ofstream config_file("test_config.yaml");
     config_file << config_content;
     config_file.close();
-    
     common_params params;
     bool result = common_params_load_from_yaml("test_config.yaml", params);
     (void)result; // suppress unused variable warning
@@ -45,15 +42,12 @@ use_color: false
     assert(params.sampling.seed == 12345);
     assert(params.interactive == true);
     assert(params.use_color == false);
-    
     std::remove("test_config.yaml");
-    
     printf("✓ Basic YAML config loading test passed\n");
 }
 
 static void test_yaml_config_cli_override() {
     printf("Testing CLI argument override of YAML config...\n");
-    
     const std::string config_content = R"(
 model:
   path: "config-model.gguf"
@@ -62,11 +56,9 @@ n_predict: 100
   temp: 0.5
 interactive: false
 )";
-    
     std::ofstream config_file("test_override.yaml");
     config_file << config_content;
     config_file.close();
-    
     const char* argv[] = {
         "test",
         "--config", "test_override.yaml",
@@ -76,7 +68,6 @@ interactive: false
         "--interactive"
     };
     int argc = sizeof(argv) / sizeof(argv[0]);
-    
     common_params params;
     bool result = common_params_parse(argc, const_cast<char**>(argv), params, LLAMA_EXAMPLE_MAIN, nullptr);
     (void)result; // suppress unused variable warning
@@ -85,9 +76,8 @@ interactive: false
     assert(params.n_predict == 200);
     assert(params.sampling.temp == 0.8f);
     assert(params.interactive == true);
-    
+
     std::remove("test_override.yaml");
-    
     printf("✓ CLI override test passed\n");
 }
 
@@ -98,28 +88,24 @@ static void test_yaml_config_invalid_file() {
     bool result = common_params_load_from_yaml("nonexistent.yaml", params);
     (void)result; // suppress unused variable warning
     assert(result == false);
-    
     const std::string invalid_content = R"(
 invalid: yaml: content:
   - missing
     proper: indentation
 )";
-    
     std::ofstream invalid_file("invalid.yaml");
     invalid_file << invalid_content;
     invalid_file.close();
-    
+
     result = common_params_load_from_yaml("invalid.yaml", params);
     assert(result == false);
-    
     std::remove("invalid.yaml");
-    
+
     printf("✓ Invalid YAML handling test passed\n");
 }
 
 static void test_yaml_config_nested_structures() {
     printf("Testing nested structure parsing...\n");
-    
     const std::string config_content = R"(
 cpuparams:
   n_threads: 8
@@ -151,19 +137,16 @@ static void test_yaml_config_nested_structures() {
   - "Human:"
   - "\n\n"
 )";
-    
     std::ofstream config_file("test_nested.yaml");
     config_file << config_content;
     config_file.close();
-    
     common_params params;
     bool result = common_params_load_from_yaml("test_nested.yaml", params);
     (void)result; // suppress unused variable warning
     assert(result == true);
     assert(params.cpuparams.n_threads == 8);
     assert(params.cpuparams.strict_cpu == true);
     assert(params.cpuparams.poll == 100);
-    
     assert(params.sampling.seed == 42);
     assert(params.sampling.top_k == 40);
     assert(params.sampling.top_p == 0.95f);
@@ -180,20 +163,17 @@ static void test_yaml_config_nested_structures() {
     assert(params.speculative.n_min == 5);
     assert(params.speculative.p_split == 0.1f);
     assert(params.speculative.model.path == "draft-model.gguf");
-    
+
     assert(params.antiprompt.size() == 3);
     assert(params.antiprompt[0] == "User:");
     assert(params.antiprompt[1] == "Human:");
     assert(params.antiprompt[2] == "\n\n");
-    
     std::remove("test_nested.yaml");
-    
     printf("✓ Nested structure parsing test passed\n");
 }
 
 static void test_backward_compatibility() {
     printf("Testing backward compatibility...\n");
-    
     const char* argv[] = {
         "test",
         "--model", "test-model.gguf",
@@ -203,7 +183,6 @@ static void test_backward_compatibility() {
         "--interactive"
     };
     int argc = sizeof(argv) / sizeof(argv[0]);
-    
     common_params params;
     bool result = common_params_parse(argc, const_cast<char**>(argv), params, LLAMA_EXAMPLE_MAIN, nullptr);
     (void)result; // suppress unused variable warning
@@ -213,42 +192,36 @@ static void test_backward_compatibility() {
     assert(params.sampling.temp == 0.7f);
     assert(params.sampling.top_k == 40);
     assert(params.interactive == true);
-    
     printf("✓ Backward compatibility test passed\n");
 }
 
 static void test_empty_config_file() {
     printf("Testing empty config file handling...\n");
-    
     std::ofstream config_file("empty.yaml");
     config_file << "";
     config_file.close();
 
     common_params params;
     params.n_predict = 999;
     params.sampling.temp = 0.123f;
-    
     bool result = common_params_load_from_yaml("empty.yaml", params);
     (void)result; // suppress unused variable warning
     assert(result == true);
     assert(params.n_predict == 999);
     assert(params.sampling.temp == 0.123f);
-    
     std::remove("empty.yaml");
-    
     printf("✓ Empty config file test passed\n");
 }
 
 int main() {
     printf("Running YAML config tests...\n\n");
-    
     test_yaml_config_basic();
     test_yaml_config_cli_override();
     test_yaml_config_invalid_file();
     test_yaml_config_nested_structures();
     test_backward_compatibility();
     test_empty_config_file();
-    
+
     printf("\n✓ All YAML config tests passed!\n");
     return 0;
 }