@lamentis/naome 1.2.1 → 1.3.1

package/crates/naome-core/tests/quality.rs

@@ -1,8 +1,9 @@
 use std::fs;
 
 use naome_core::{
-    check_repository_quality, init_repository_quality, plan_quality_cleanup, route_quality_cleanup,
-    seed_builtin_verification_checks, QualityMode,
+    check_repository_quality, init_repository_quality, init_repository_quality_with_mode,
+    plan_quality_cleanup, reconcile_repository_quality, route_quality_cleanup,
+    seed_builtin_verification_checks, QualityInitMode, QualityMode,
 };
 use serde_json::Value;
 
@@ -65,6 +66,7 @@ fn changed_check_blocks_new_duplicate_blocks_against_existing_code() {
         "export function existing() {\n  const alpha = input.alpha;\n  const beta = input.beta;\n  const total = alpha + beta;\n  return total;\n}\n",
     );
     repo.commit_all("existing helper");
+    let _ = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
 
     repo.write(
         "src/copied.js",
@@ -92,6 +94,7 @@ fn duplicate_blocks_report_one_finding_per_overlapping_region() {
         "export function existing() {\n  const alpha = input.alpha;\n  const beta = input.beta;\n  const gamma = input.gamma;\n  const total = alpha + beta + gamma;\n  return total;\n}\n",
     );
     repo.commit_all("existing helper");
+    let _ = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
 
     repo.write(
         "src/copied.js",
@@ -186,7 +189,7 @@ fn near_duplicate_functions_do_not_compare_containers_with_child_symbols() {
 }
 
 #[test]
-fn init_writes_default_config_and_baselines_existing_debt() {
+fn init_writes_default_config_and_marks_baseline_pending() {
     let repo = QualityFixture::new("quality-init-baseline");
     let large_file = (0..520)
         .map(|index| format!("export const value{index} = {index};\n"))
@@ -197,13 +200,19 @@ fn init_writes_default_config_and_baselines_existing_debt() {
     let init = init_repository_quality(repo.path()).unwrap();
 
     assert!(init.config_written);
-    assert!(init.baseline_written);
+    assert!(!init.baseline_written);
+    assert!(init.baseline_pending);
     assert!(repo.path().join(".naome/repository-quality.json").is_file());
     assert!(repo
         .path()
         .join(".naome/repository-quality-baseline.json")
         .is_file());
-    assert!(init.baseline_violations > 0);
+    assert_eq!(init.baseline_violations, 0);
+
+    let baseline =
+        init_repository_quality_with_mode(repo.path(), QualityInitMode::Baseline).unwrap();
+    assert!(baseline.baseline_written);
+    assert!(baseline.baseline_violations > 0);
 }
 
 #[test]
@@ -239,6 +248,174 @@ fn init_generates_adapter_selection_without_product_specific_path_rules() {
     assert!(!serialized_config.contains("naome-template-harness"));
 }
 
+#[test]
+fn init_auto_detects_ios_swift_adapter_set() {
+    let repo = QualityFixture::new("quality-ios-swift-adapters");
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Demo.xcodeproj/project.pbxproj",
+        "// !$*UTF8*$!\n{ archiveVersion = 1; }\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "import SwiftUI\n@main struct DemoApp: App { var body: some Scene { WindowGroup { ContentView() } } }\n",
+    );
+    repo.write(
+        "Tests/AppTests/AppTests.swift",
+        "import XCTest\nfinal class AppTests: XCTestCase {}\n",
+    );
+    repo.write(
+        "Resources/Assets.xcassets/AppIcon.appiconset/Contents.json",
+        "{}\n",
+    );
+    repo.write("Generated/R.generated.swift", "enum R {}\n");
+    repo.commit_all("ios swift project");
+
+    init_repository_quality(repo.path()).unwrap();
+    let quality: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-quality.json")).unwrap(),
+    )
+    .unwrap();
+    let structure: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-structure.json")).unwrap(),
+    )
+    .unwrap();
+
+    for adapter in [
+        "swift",
+        "xcode",
+        "xctest",
+        "swiftui",
+        "ios-app-structure",
+        "swift-package",
+        "ios-resources",
+        "generated-ios",
+    ] {
+        assert!(
+            has_adapter(&quality, adapter),
+            "missing quality adapter {adapter}: {quality:#?}"
+        );
+        assert!(
+            has_adapter(&structure, adapter),
+            "missing structure adapter {adapter}: {structure:#?}"
+        );
+    }
+}
+
+#[test]
+fn changed_check_reports_stale_adapter_policy_after_stack_changes() {
+    let repo = QualityFixture::new("quality-stale-adapter-policy");
+    repo.write_quality_config_with_adapters(450, 100, 10, &[]);
+    repo.write_structure_config(serde_json::json!({
+        "enabledAdapters": []
+    }));
+    repo.commit_all("initial quality policy");
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "public struct DemoApp { public init() {} }\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "adapter-policy-stale"
+            && violation.path == ".naome/repository-quality.json"
+            && violation.message.contains("swift")
+            && violation
+                .related_paths
+                .contains(&".naome/repository-structure.json".to_string())
+    }));
+}
+
+#[test]
+fn changed_check_reports_stale_repository_model_after_stack_changes() {
+    let repo = QualityFixture::new("quality-repository-model-stale");
+    repo.write_quality_config();
+    repo.write_structure_config(serde_json::json!({}));
+    repo.write(
+        ".naome/repository-model.json",
+        "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n",
+    );
+    repo.write("README.md", "# Baseline\n");
+    repo.commit_all("baseline");
+
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"repository_model_stale".to_string()));
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "repository-model-stale"
+            && violation.path == ".naome/repository-model.json"
+            && violation
+                .related_paths
+                .contains(&"Package.swift".to_string())
+    }));
+}
+
+#[test]
+fn reconcile_write_updates_stale_quality_and_structure_adapter_policy() {
+    let repo = QualityFixture::new("quality-reconcile-adapters");
+    repo.write_quality_config_with_adapters(450, 100, 10, &[]);
+    repo.write_structure_config(serde_json::json!({
+        "enabledAdapters": []
+    }));
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "public struct DemoApp { public init() {} }\n",
+    );
+
+    let planned = reconcile_repository_quality(repo.path(), false).unwrap();
+    assert!(!planned.ok);
+    assert!(planned.stale);
+    assert!(planned
+        .missing_quality_adapters
+        .contains(&"swift".to_string()));
+    assert!(planned.updated_paths.is_empty());
+
+    let written = reconcile_repository_quality(repo.path(), true).unwrap();
+    assert!(written.ok);
+    assert!(!written.stale);
+    assert_eq!(
+        written.updated_paths,
+        vec![
+            ".naome/repository-quality.json".to_string(),
+            ".naome/repository-structure.json".to_string()
+        ]
+    );
+
+    let quality: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-quality.json")).unwrap(),
+    )
+    .unwrap();
+    let structure: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-structure.json")).unwrap(),
+    )
+    .unwrap();
+    assert!(has_adapter(&quality, "swift"));
+    assert!(has_adapter(&structure, "swift"));
+
+    let repeated = reconcile_repository_quality(repo.path(), true).unwrap();
+    assert!(repeated.ok);
+    assert!(repeated.updated_paths.is_empty());
+}
+
 #[test]
 fn enabled_adapters_apply_their_rules_without_materialized_path_rules() {
     let repo = QualityFixture::new("quality-adapter-runtime-config");
@@ -257,6 +434,14 @@ fn enabled_adapters_apply_their_rules_without_materialized_path_rules() {
     }));
 }
 
+fn has_adapter(config: &Value, adapter: &str) -> bool {
+    config["enabledAdapters"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|value| value.as_str() == Some(adapter))
+}
+
 #[test]
 fn seeding_builtin_verification_wires_repository_quality_into_change_types() {
     let repo = QualityFixture::new("quality-verification-wiring");

package/crates/naome-core/tests/quality_performance.rs

@@ -0,0 +1,268 @@
+mod repo_support;
+
+use std::fs;
+
+use naome_core::{
+    check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
+    init_repository_quality, init_repository_quality_with_mode, quality_cache_status,
+    QualityInitMode, QualityMode,
+};
+
+use repo_support::TestRepo;
+
+#[test]
+fn quality_init_seeds_policy_without_baseline_scan() {
+    let repo = quality_repo("quality-init-seed-only");
+    repo.write_file("src/large.js", &large_file());
+    repo.commit_all("legacy debt");
+
+    let init = init_repository_quality(repo.path()).unwrap();
+
+    assert!(init.config_written);
+    assert!(init.structure_config_written);
+    assert!(!init.baseline_written);
+    assert!(init.baseline_pending);
+    assert_eq!(init.baseline_violations, 0);
+    assert!(repo
+        .path()
+        .join(".naome/repository-quality-baseline.json")
+        .is_file());
+}
+
+#[test]
+fn quality_baseline_modes_are_explicit() {
+    let repo = quality_repo("quality-init-explicit-baseline");
+    repo.write_file("src/large.js", &large_file());
+    repo.commit_all("legacy debt");
+
+    let baseline =
+        init_repository_quality_with_mode(repo.path(), QualityInitMode::Baseline).unwrap();
+    assert!(baseline.baseline_written);
+    assert!(!baseline.baseline_pending);
+    assert!(baseline.baseline_violations > 0);
+
+    let deep =
+        init_repository_quality_with_mode(repo.path(), QualityInitMode::DeepBaseline).unwrap();
+    assert_eq!(deep.mode, "deep-baseline");
+    assert!(deep.baseline_violations >= baseline.baseline_violations);
+}
+
+#[test]
+fn changed_fast_scans_only_changed_file_contents() {
+    let repo = quality_repo("quality-changed-fast-focused");
+    for index in 0..1000 {
+        repo.write_file(
+            &format!("src/unchanged_{index}.js"),
+            "export const value = 1;\n",
+        );
+    }
+    repo.write_file("src/changed.js", "export const before = 1;\n");
+    repo.commit_all("large baseline");
+    repo.write_file("src/changed.js", "export const after = 2;\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.mode, "changed");
+    assert_eq!(report.summary.scanned_files, 1);
+    assert_eq!(report.summary.scanned_path_count, 1);
+    assert!(report.changed_paths.contains(&"src/changed.js".to_string()));
+}
+
+#[test]
+fn path_scoped_quality_scans_only_requested_file_after_write() {
+    let repo = quality_repo("quality-path-scoped-focused");
+    repo.write_file("src/target.js", "export const before = 1;\n");
+    repo.write_file("src/unrelated.js", "export const before = 1;\n");
+    repo.commit_all("baseline");
+    repo.write_file("src/target.js", &large_file());
+    repo.write_file("src/unrelated.js", &large_file());
+
+    let report = check_repository_quality_paths(repo.path(), &["src/target.js"]).unwrap();
+
+    assert_eq!(report.mode, "path");
+    assert_eq!(report.changed_paths, vec!["src/target.js"]);
+    assert_eq!(report.summary.scanned_files, 1);
+    assert_eq!(report.summary.scanned_path_count, 1);
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "file-length" && violation.path == "src/target.js"));
+    assert!(!report
+        .violations
+        .iter()
+        .any(|violation| violation.path == "src/unrelated.js"));
+}
+
+#[test]
+fn path_scoped_quality_rejects_paths_outside_repository() {
+    let repo = quality_repo("quality-path-scoped-boundary");
+    repo.write_file("src/target.js", "export const before = 1;\n");
+    repo.commit_all("baseline");
+
+    let error = check_repository_quality_paths(repo.path(), &["../outside.js"]).unwrap_err();
+
+    assert!(error.to_string().contains("repository-relative path"));
+}
+
+#[test]
+fn semantic_changed_check_scans_only_changed_file_contents() {
+    let repo = quality_repo("semantic-changed-fast-focused");
+    for index in 0..1000 {
+        repo.write_file(
+            &format!("src/unchanged_{index}.js"),
+            &legacy_fixture("oldConfig"),
+        );
+    }
+    repo.write_file("scripts/changed.test.js", "const value = 1;\n");
+    repo.commit_all("large baseline");
+    repo.write_file("scripts/changed.test.js", &legacy_fixture("newConfig"));
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.mode, "changed");
+    assert_eq!(report.summary.scanned_files, 1);
+}
+
+#[test]
+fn second_report_uses_file_analysis_cache() {
+    let repo = quality_repo("quality-cache-second-report");
+    repo.write_file("src/a.js", "export const value = 1;\n");
+    repo.write_file("src/b.js", "export const other = 2;\n");
+    repo.commit_all("baseline");
+
+    let first = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let cache = quality_cache_status(repo.path()).unwrap();
+    let second = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert_eq!(first.summary.scanned_files, 2);
+    assert!(cache.entry_count >= 2);
+    assert_eq!(second.summary.cache_hits, 2);
+    assert_eq!(second.summary.cache_misses, 0);
+}
+
+#[test]
+fn report_budget_marks_truncated_reports() {
+    let repo = quality_repo("quality-report-budget");
+    for index in 0..5005 {
+        repo.write_file(&format!("src/file_{index}.js"), "export const value = 1;\n");
+    }
+    repo.commit_all("large baseline");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(report.summary.truncated);
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"max_scanned_files".to_string()));
+    assert_eq!(report.summary.scanned_files, 5000);
+}
+
+#[test]
+fn report_skips_deep_only_duplicate_checks() {
+    let repo = quality_repo("quality-deep-only-duplicates");
+    repo.write_file("src/a.js", &duplicate_block("one"));
+    repo.write_file("src/b.js", &duplicate_block("two"));
+    repo.commit_all("duplicate baseline");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let deep = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
+
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"deep_checks_skipped".to_string()));
+    assert!(!report
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "duplicate-blocks"));
+    assert!(deep
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "duplicate-blocks"));
+}
+
+#[test]
+fn changed_fast_compares_changed_files_to_cached_candidates() {
+    let repo = quality_repo("quality-changed-cache-duplicates");
+    repo.write_file("src/existing.js", &duplicate_block("existing"));
+    repo.write_file("src/new.js", "export const value = 1;\n");
+    repo.commit_all("baseline");
+    let _ = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
+
+    repo.write_file("src/new.js", &duplicate_block("newCopy"));
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert!(report.summary.cache_hits >= 1);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "duplicate-blocks" && violation.path == "src/new.js"
+    }));
+}
+
+#[test]
+fn changed_fast_compares_changed_files_to_cold_cache_candidates() {
+    let repo = quality_repo("quality-changed-cold-cache-duplicates");
+    repo.write_file("src/existing.js", &duplicate_block("existing"));
+    repo.write_file("src/new.js", "export const value = 1;\n");
+    repo.commit_all("baseline");
+
+    repo.write_file("src/new.js", &duplicate_block("newCopy"));
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.summary.cache_hits, 0);
+    assert!(report.summary.cache_misses >= 2);
+    assert_eq!(report.summary.scanned_files, 1);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "duplicate-blocks"
+            && violation.path == "src/new.js"
+            && violation
+                .related_paths
+                .contains(&"src/existing.js".to_string())
+    }));
+}
+
+fn quality_repo(name: &str) -> TestRepo {
+    let repo = TestRepo::new(name);
+    repo.init_git();
+    fs::create_dir_all(repo.path().join(".naome")).unwrap();
+    repo
+}
+
+fn large_file() -> String {
+    (0..520)
+        .map(|index| format!("export const value{index} = {index};\n"))
+        .collect()
+}
+
+fn legacy_fixture(name: &str) -> String {
+    format!(
+        r#"const {name} = {{
+  schema: "naome.performance-fixture.v1",
+  version: 1,
+  status: "ready",
+  checks: [],
+  changeTypes: [],
+  releaseGates: []
+}};
+"#
+    )
+}
+
+fn duplicate_block(name: &str) -> String {
+    format!(
+        r#"export function {name}() {{
+  const one = 1;
+  const two = 2;
+  const three = 3;
+  const four = 4;
+  const five = 5;
+  const six = 6;
+  const seven = 7;
+  const eight = 8;
+  const nine = 9;
+  const ten = 10;
+  return one + two + three + four + five + six + seven + eight + nine + ten;
+}}
+"#
+    )
+}

package/crates/naome-core/tests/quality_structure_adapters.rs

@@ -40,6 +40,45 @@ fn javascript_typescript_adapter_recognizes_package_source_and_tests() {
     assert_eq!(test.role, "test");
 }
 
+#[test]
+fn ios_swift_adapters_recognize_xcode_swiftui_tests_resources_and_generated_code() {
+    let repo = StructureFixture::new("structure-ios-swift-adapters");
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Demo.xcodeproj/project.pbxproj",
+        "// !$*UTF8*$!\n{ archiveVersion = 1; }\n",
+    );
+    repo.write(
+        "Sources/App/ContentView.swift",
+        "import SwiftUI\nstruct ContentView: View {}\n",
+    );
+    repo.write(
+        "Tests/AppTests/ContentViewTests.swift",
+        "import XCTest\nfinal class ContentViewTests: XCTestCase {}\n",
+    );
+    repo.write("Resources/Info.plist", "<?xml version=\"1.0\"?>\n");
+    repo.write("Resources/Assets.xcassets/Contents.json", "{}\n");
+    repo.write("Generated/R.generated.swift", "enum R {}\n");
+
+    let source =
+        explain_repository_structure(repo.path(), "Sources/App/ContentView.swift").unwrap();
+    let test =
+        explain_repository_structure(repo.path(), "Tests/AppTests/ContentViewTests.swift").unwrap();
+    let plist = explain_repository_structure(repo.path(), "Resources/Info.plist").unwrap();
+    let generated =
+        explain_repository_structure(repo.path(), "Generated/R.generated.swift").unwrap();
+
+    assert_eq!(source.role, "source");
+    assert_eq!(source.module.as_deref(), Some("App"));
+    assert_eq!(source.language.as_deref(), Some("swift"));
+    assert_eq!(test.role, "test");
+    assert_eq!(plist.role, "config");
+    assert_eq!(generated.role, "generated");
+}
+
 #[test]
 fn unknown_repository_gets_generic_roles() {
     let repo = StructureFixture::new("structure-generic-roles");

package/crates/naome-core/tests/quality_structure_policy.rs

@@ -62,6 +62,25 @@ fn quality_report_and_cleanup_route_include_structure_findings() {
         .any(|violation| violation.check_id == "dumping-ground-directory"));
 }
 
+#[test]
+fn cleanup_route_gives_specific_test_pairing_instructions() {
+    let repo = StructureFixture::new("structure-cleanup-test-pairing");
+    repo.write_js_package();
+    repo.write(
+        "src/billing/invoice.js",
+        "export function invoiceTotal() {\n  return 1;\n}\n",
+    );
+
+    let route = route_quality_cleanup(repo.path(), "src/billing/invoice.js").unwrap();
+
+    assert!(route
+        .agent_instructions
+        .contains("Create or update a nearby or module-matched test"));
+    assert!(route
+        .required_checks
+        .contains(&"naome quality check --changed".to_string()));
+}
+
 #[test]
 fn wildcard_module_roots_explain_monorepo_module_names() {
     let repo = StructureFixture::new("structure-wildcard-module-root");

package/crates/naome-core/tests/repo_support/mod.rs

@@ -13,4 +13,8 @@ pub use routes::{
     route_commit_request, route_new_task, route_readme_task, try_route_new_task,
     try_route_readme_task,
 };
-pub use verification_values::{change_type, diff_check, verification_value};
+pub use verification_values::{
+    change_type, diff_check, quality_check, repository_quality_config_source,
+    repository_quality_config_value, semantic_repository_quality_fixture_source,
+    verification_value,
+};

package/crates/naome-core/tests/repo_support/verification_values.rs

@@ -73,6 +73,35 @@ pub fn verification_value(
     })
 }
 
+pub fn repository_quality_config_value() -> serde_json::Value {
+    json!({
+        "schema": "naome.repository-quality.v1",
+        "version": 1,
+        "status": "ready",
+        "limits": {
+            "maxFileLines": 450,
+            "maxNewFileLines": 300,
+            "maxDiffAddedLines": 180,
+            "maxFunctionLines": 100,
+            "maxTopLevelSymbols": 30,
+            "duplicateBlockLines": 10,
+            "nearDuplicateSimilarity": 0.9
+        },
+        "enabledAdapters": [],
+        "disabledChecks": [],
+        "ignoredPaths": [],
+        "generatedPaths": [],
+        "pathRules": []
+    })
+}
+
+pub fn repository_quality_config_source() -> String {
+    format!(
+        "{}\n",
+        serde_json::to_string_pretty(&repository_quality_config_value()).unwrap()
+    )
+}
+
 pub fn change_type(
     id: &str,
     description: &str,
@@ -121,6 +150,32 @@ pub fn repository_quality_check() -> serde_json::Value {
     })
 }
 
+pub fn semantic_repository_quality_fixture_source(name: &str) -> String {
+    [
+        format!("const {name} = {{"),
+        "  schema: \"naome.repository-quality.v1\",".to_string(),
+        "  version: 1,".to_string(),
+        "  status: \"ready\",".to_string(),
+        "  limits: {".to_string(),
+        "    maxFileLines: 450,".to_string(),
+        "    maxNewFileLines: 300,".to_string(),
+        "    maxDiffAddedLines: 180,".to_string(),
+        "    maxFunctionLines: 100,".to_string(),
+        "    maxTopLevelSymbols: 30,".to_string(),
+        "    duplicateBlockLines: 10,".to_string(),
+        "    nearDuplicateSimilarity: 0.9".to_string(),
+        "  },".to_string(),
+        "  enabledAdapters: [],".to_string(),
+        "  disabledChecks: [],".to_string(),
+        "  ignoredPaths: [],".to_string(),
+        "  generatedPaths: [],".to_string(),
+        "  pathRules: []".to_string(),
+        "};".to_string(),
+        String::new(),
+    ]
+    .join("\n")
+}
+
 pub fn mutating_diff_check() -> serde_json::Value {
     json!({
         "id": "diff-check",