@lamentis/naome 1.3.0 → 1.3.1

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

@@ -3,8 +3,9 @@ mod repo_support;
 use std::fs;
 
 use naome_core::{
-    check_repository_quality, check_semantic_legacy, init_repository_quality,
-    init_repository_quality_with_mode, quality_cache_status, QualityInitMode, QualityMode,
+    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;
@@ -67,6 +68,42 @@ fn changed_fast_scans_only_changed_file_contents() {
     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");

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/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",

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

@@ -0,0 +1,281 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use naome_core::{explain_repository_model_path, refresh_repository_model, repository_model_drift};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[test]
+fn refresh_write_captures_deterministic_repository_facts() {
+    let repo = Repo::new("repository-model-refresh");
+    repo.write(
+        "Cargo.toml",
+        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+    );
+    repo.write("package.json", "{\"scripts\":{\"test\":\"node --test\"}}\n");
+    repo.write("src/lib.rs", "pub fn run() {}\n");
+    repo.write("tests/app.test.ts", "test('works', () => {});\n");
+    repo.write(
+        ".naome/verification.json",
+        "{\"checks\":[{\"id\":\"unit-test\",\"command\":\"cargo test\",\"cwd\":\".\",\"evidence\":[\"src/lib.rs\"]}]}\n",
+    );
+
+    let report = refresh_repository_model(repo.path(), true).unwrap();
+
+    assert!(report.ok);
+    assert_eq!(report.updated_paths, vec![".naome/repository-model.json"]);
+    assert_fact(&report.model, "language", "rust");
+    assert_fact(&report.model, "language", "javascript-typescript");
+    assert_fact(&report.model, "packageManager", "cargo");
+    assert_fact(&report.model, "packageManager", "npm");
+    assert_fact(&report.model, "sourceRoot", "src");
+    assert_fact(&report.model, "testRoot", "tests");
+    assert_fact(&report.model, "verificationCheck", "unit-test");
+    let js_fact = fact(&report.model, "language", "javascript-typescript");
+    assert_eq!(js_fact.evidence, vec!["package.json", "tests/app.test.ts"]);
+    assert!(repo.path().join(".naome/repository-model.json").is_file());
+}
+
+#[test]
+fn refresh_write_prefers_v2_world_model_sections() {
+    let repo = Repo::new("repository-world-model-v2");
+    repo.write(
+        "packages/mobile/Package.swift",
+        "// swift-tools-version: 5.9\n",
+    );
+    repo.write("packages/mobile/Sources/App/App.swift", "import SwiftUI\n");
+    repo.write(
+        "packages/mobile/Tests/AppTests/AppTests.swift",
+        "import XCTest\n",
+    );
+    repo.write(
+        "packages/web/package.json",
+        "{\"scripts\":{\"test\":\"vitest\"}}\n",
+    );
+    repo.write(
+        "packages/web/src/App.tsx",
+        "export function App() { return null; }\n",
+    );
+    repo.write(
+        "packages/web/src/App.test.tsx",
+        "test('works', () => {});\n",
+    );
+    repo.write(
+        ".naome/verification.json",
+        "{\"checks\":[{\"id\":\"unit-test\",\"command\":\"npm test\",\"cwd\":\".\",\"evidence\":[\"packages/web/src/App.tsx\"]}]}\n",
+    );
+
+    let report = refresh_repository_model(repo.path(), true).unwrap();
+
+    assert!(report.ok);
+    assert_eq!(report.model.schema, "naome.repository-model.v2");
+    assert_eq!(report.model.version, 2);
+    assert!(report
+        .model
+        .languages
+        .iter()
+        .any(|language| language.id == "swift"));
+    assert!(report
+        .model
+        .languages
+        .iter()
+        .any(|language| language.id == "javascript-typescript"));
+    assert!(report
+        .model
+        .adapters
+        .iter()
+        .any(|adapter| adapter.id == "swiftui"));
+    assert!(report
+        .model
+        .entities
+        .iter()
+        .any(|entity| entity.id == "package:packages/mobile"));
+    assert!(report
+        .model
+        .entities
+        .iter()
+        .any(|entity| entity.id == "package:packages/web"));
+    assert!(report
+        .model
+        .roots
+        .iter()
+        .any(|root| root.path == "packages/mobile/Sources" && root.role == "source"));
+    assert!(report
+        .model
+        .verification_checks
+        .iter()
+        .any(|check| check.id == "unit-test"));
+}
+
+#[test]
+fn v1_model_files_remain_readable_for_path_explain() {
+    let repo = Repo::new("repository-model-v1-readable");
+    repo.write(
+        ".naome/repository-model.json",
+        "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[{\"id\":\"language:rust\",\"category\":\"language\",\"value\":\"rust\",\"confidence\":\"high\",\"source\":\"deterministic-scan\",\"evidence\":[\"src/lib.rs\"]}]}\n",
+    );
+    repo.write("src/lib.rs", "pub fn run() {}\n");
+
+    let explanation = explain_repository_model_path(repo.path(), "src/lib.rs").unwrap();
+
+    assert_eq!(explanation.language.as_deref(), Some("rust"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert!(explanation
+        .facts
+        .iter()
+        .any(|fact| fact.id == "language:rust"));
+}
+
+#[test]
+fn path_explain_returns_world_model_entity_and_role() {
+    let repo = Repo::new("repository-model-explain-world");
+    repo.write("packages/api/Cargo.toml", "[package]\nname = \"api\"\n");
+    repo.write("packages/api/src/lib.rs", "pub fn run() {}\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let explanation =
+        explain_repository_model_path(repo.path(), "packages/api/src/lib.rs").unwrap();
+
+    assert_eq!(explanation.language.as_deref(), Some("rust"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert_eq!(explanation.module.as_deref(), Some("packages/api"));
+    assert_eq!(explanation.entity.as_deref(), Some("package:packages/api"));
+}
+
+#[test]
+fn check_reports_stale_model_until_refresh_write_updates_it() {
+    let repo = Repo::new("repository-model-stale");
+    repo.write(".naome/repository-model.json", "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n");
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+    repo.write("Sources/App/App.swift", "public struct App {}\n");
+
+    let check = refresh_repository_model(repo.path(), false).unwrap();
+    assert!(!check.ok);
+    assert!(check.stale);
+    assert_fact(&check.model, "language", "swift");
+
+    let written = refresh_repository_model(repo.path(), true).unwrap();
+    assert!(written.ok);
+    assert!(!written.stale);
+    assert_eq!(written.updated_paths, vec![".naome/repository-model.json"]);
+
+    let repeated = refresh_repository_model(repo.path(), false).unwrap();
+    assert!(repeated.ok);
+    assert!(!repeated.stale);
+}
+
+#[test]
+fn drift_detects_world_sections_when_fact_values_are_unchanged() {
+    let repo = Repo::new("repository-model-world-section-drift");
+    repo.write(
+        "packages/a/package.json",
+        "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    );
+    repo.write("packages/a/src/index.ts", "export const a = 1;\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let clean = repository_model_drift(repo.path()).unwrap();
+    assert!(clean.ok);
+
+    repo.write(
+        "packages/b/package.json",
+        "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    );
+
+    let drift = repository_model_drift(repo.path()).unwrap();
+
+    assert!(!drift.ok);
+    assert!(drift.stale);
+    assert!(drift
+        .related_paths
+        .contains(&"packages/b/package.json".to_string()));
+}
+
+#[test]
+fn explain_repository_model_path_uses_canonical_facts() {
+    let repo = Repo::new("repository-model-explain");
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+    repo.write("Sources/App/App.swift", "public struct App {}\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let explanation = explain_repository_model_path(repo.path(), "Sources/App/App.swift").unwrap();
+
+    assert_eq!(explanation.path, "Sources/App/App.swift");
+    assert_eq!(explanation.language.as_deref(), Some("swift"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert!(explanation
+        .evidence
+        .contains(&"Sources/App/App.swift".to_string()));
+}
+
+fn assert_fact(model: &naome_core::RepositoryModel, category: &str, value: &str) {
+    assert!(
+        model
+            .facts
+            .iter()
+            .any(|fact| fact.category == category && fact.value == value),
+        "missing {category}:{value}; facts: {:#?}",
+        model.facts
+    );
+}
+
+fn fact<'a>(
+    model: &'a naome_core::RepositoryModel,
+    category: &str,
+    value: &str,
+) -> &'a naome_core::RepositoryFact {
+    model
+        .facts
+        .iter()
+        .find(|fact| fact.category == category && fact.value == value)
+        .unwrap_or_else(|| panic!("missing {category}:{value}; facts: {:#?}", model.facts))
+}
+
+struct Repo {
+    root: PathBuf,
+}
+
+impl Repo {
+    fn new(name: &str) -> Self {
+        let root = std::env::temp_dir().join(format!(
+            "naome-{name}-{}-{}",
+            std::process::id(),
+            FIXTURE_COUNTER.fetch_add(1, Ordering::SeqCst)
+        ));
+        let _ = fs::remove_dir_all(&root);
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        git(&root, &["init"]);
+        git(&root, &["config", "user.email", "test@example.com"]);
+        git(&root, &["config", "user.name", "Test User"]);
+        Self { root }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    fn write(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        fs::write(path, content).unwrap();
+    }
+}
+
+impl Drop for Repo {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+fn git(root: &Path, args: &[&str]) {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+}

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

@@ -5,7 +5,10 @@ use serde_json::json;
 
 mod repo_support;
 
-use repo_support::{assert_user_diff_committed, route_commit_request, TestRepo};
+use repo_support::{
+    assert_user_diff_committed, change_type, quality_check, repository_quality_config_source,
+    route_commit_request, semantic_repository_quality_fixture_source, verification_value, TestRepo,
+};
 
 #[test]
 fn execute_route_does_not_mutate_or_offer_clear_commit_for_dirty_unowned_diff() {
@@ -69,6 +72,51 @@ fn execute_route_runs_repository_quality_check_without_shelling_to_repo_command(
     assert!(route.user_message.contains("file-length"));
 }
 
+#[test]
+fn execute_route_refuses_semantic_changed_findings_through_repository_quality_gate() {
+    let repo = TestRepo::new("route-semantic-quality-gate");
+    repo.init_git();
+    repo.write_file(
+        ".naome/repository-quality.json",
+        &repository_quality_config_source(),
+    );
+    repo.write_file("scripts/baseline.test.js", "const ok = { value: 1 };\n");
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_naome_json(
+        "verification.json",
+        verification_value(
+            "ready",
+            vec![quality_check(
+                "repository-quality-check",
+                "naome quality check --changed",
+                "Validate changed files against repository quality rules.",
+                "fast",
+                vec!["scripts/**"],
+            )],
+            vec![change_type(
+                "scripts",
+                "Script changes.",
+                vec!["scripts/**"],
+                vec!["repository-quality-check"],
+            )],
+        ),
+    );
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "scripts/new.test.js");
+    assert!(route.user_message.contains("repository-quality-check"));
+    assert!(route
+        .user_message
+        .contains("semantic-inline-legacy-fixture"));
+}
+
 #[test]
 fn execute_route_refuses_product_named_checks_without_generic_builtin_policy() {
     let repo = TestRepo::product_quality_repo("route-product-diff-quality-pass");

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

@@ -1,16 +1,23 @@
 mod repo_support;
 
-use naome_core::{check_semantic_legacy, semantic_route_for_finding, QualityMode};
+use naome_core::{
+    check_repository_quality, check_semantic_legacy, semantic_route_for_finding, QualityMode,
+};
 
-use repo_support::TestRepo;
+use repo_support::{
+    repository_quality_config_value, semantic_repository_quality_fixture_source, TestRepo,
+};
 
 #[test]
 fn report_groups_repeated_config_fixture_shapes_across_repository() {
     let repo = semantic_repo("semantic-report-groups");
-    repo.write_file("scripts/a.test.js", &fixture_object("qualityConfig"));
+    repo.write_file(
+        "scripts/a.test.js",
+        &semantic_repository_quality_fixture_source("qualityConfig"),
+    );
     repo.write_file(
         "scripts/b.test.js",
-        &fixture_object("repositoryQualityConfig"),
+        &semantic_repository_quality_fixture_source("repositoryQualityConfig"),
     );
     repo.commit_all("baseline");
 
@@ -36,14 +43,20 @@ fn report_groups_repeated_config_fixture_shapes_across_repository() {
 #[test]
 fn changed_check_blocks_new_inline_legacy_fixture_only() {
     let repo = semantic_repo("semantic-changed-only");
-    repo.write_file("scripts/old.test.js", &fixture_object("oldQualityConfig"));
+    repo.write_file(
+        "scripts/old.test.js",
+        &semantic_repository_quality_fixture_source("oldQualityConfig"),
+    );
     repo.commit_all("baseline");
     repo.write_file("README.md", "# harmless change\n");
 
     let unrelated = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
     assert!(unrelated.ok, "{:#?}", unrelated.findings);
 
-    repo.write_file("scripts/new.test.js", &fixture_object("newQualityConfig"));
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
 
     let changed = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
     assert!(!changed.ok);
@@ -53,6 +66,24 @@ fn changed_check_blocks_new_inline_legacy_fixture_only() {
         .any(|finding| finding.kind == "inline-legacy-fixture"));
 }
 
+#[test]
+fn repository_quality_changed_includes_semantic_changed_findings() {
+    let repo = semantic_repo("semantic-quality-gate");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "semantic-inline-legacy-fixture"
+            && violation.path == "scripts/new.test.js"
+    }));
+}
+
 #[test]
 fn changed_check_allows_shared_fixture_factory_objects() {
     let repo = semantic_repo("semantic-shared-factory");
@@ -80,13 +111,45 @@ fn changed_check_allows_shared_fixture_factory_objects() {
     assert!(report.ok, "{:#?}", report.findings);
 }
 
+#[test]
+fn changed_check_allows_shared_support_fixture_modules() {
+    let repo = semantic_repo("semantic-shared-support");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "tests/repo_support/verification_values.rs",
+        &[
+            "pub fn completed_task_state() -> serde_json::Value {",
+            "    serde_json::json!({",
+            "        \"schema\": \"naome.task-state.v1\",",
+            "        \"version\": 1,",
+            "        \"status\": \"complete\",",
+            "        \"activeTask\": {",
+            "            \"id\": \"readme-task\",",
+            "            \"requiredCheckIds\": [\"diff-check\"],",
+            "            \"proofResults\": []",
+            "        }",
+            "    })",
+            "}",
+            "",
+        ]
+        .join("\n"),
+    );
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.findings);
+}
+
 #[test]
 fn semantic_route_returns_complete_agent_cleanup_task() {
     let repo = semantic_repo("semantic-route");
-    repo.write_file("scripts/a.test.js", &fixture_object("qualityConfig"));
+    repo.write_file(
+        "scripts/a.test.js",
+        &semantic_repository_quality_fixture_source("qualityConfig"),
+    );
     repo.write_file(
         "scripts/b.test.js",
-        &fixture_object("repositoryQualityConfig"),
+        &semantic_repository_quality_fixture_source("repositoryQualityConfig"),
     );
     repo.commit_all("baseline");
     let report = check_semantic_legacy(repo.path(), QualityMode::DeepReport).unwrap();
@@ -106,35 +169,6 @@ fn semantic_repo(name: &str) -> TestRepo {
     let repo = TestRepo::new(name);
     repo.init_git();
     repo.write_file("README.md", "# Semantic fixture\n");
-    repo.write_naome_json(
-        "repository-quality.json",
-        serde_json::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":[]}),
-    );
+    repo.write_naome_json("repository-quality.json", repository_quality_config_value());
     repo
 }
-
-fn fixture_object(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")
-}