@lamentis/naome 1.2.1 → 1.3.0

package/crates/naome-core/src/workflow/doctor.rs

@@ -0,0 +1,144 @@
+use std::fs;
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
+use crate::models::NaomeError;
+use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
+use crate::verification_contract::validate_verification_contract;
+
+use super::phases::verification_phase_plan;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DoctorReport {
+    pub schema: String,
+    pub ok: bool,
+    pub harness_health: DoctorSection,
+    pub task_state: DoctorSection,
+    pub verification: DoctorSection,
+    pub repository_quality: RepositoryPolicySection,
+    pub repository_structure: RepositoryPolicySection,
+    pub recommended_check_ids: Vec<String>,
+    pub withheld_check_ids: Vec<String>,
+    pub next_action: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DoctorSection {
+    pub status: String,
+    pub messages: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryPolicySection {
+    pub config_present: bool,
+    pub baseline_present: bool,
+    pub status: String,
+}
+
+pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
+    let harness_errors = validate_harness_health(
+        root,
+        HarnessHealthOptions {
+            allow_missing_integrity: true,
+            allow_missing_archive: true,
+            ..HarnessHealthOptions::default()
+        },
+    )?;
+    let task_report = validate_task_state(
+        root,
+        TaskStateOptions {
+            mode: TaskStateMode::State,
+            harness_health: None,
+        },
+    )?;
+    let verification_errors = validate_verification_contract(root)?;
+    let phase_plan = verification_phase_plan(root, &[])?;
+
+    let repository_quality = policy_section(
+        root,
+        ".naome/repository-quality.json",
+        ".naome/repository-quality-baseline.json",
+    );
+    let repository_structure = policy_section(root, ".naome/repository-structure.json", "");
+
+    let harness_health = section(harness_errors);
+    let task_state = section(task_report.errors);
+    let verification = section(verification_errors);
+    let ok = harness_health.status == "ok"
+        && task_state.status == "ok"
+        && verification.status == "ok"
+        && repository_quality.status == "ok"
+        && repository_structure.status == "ok";
+    let next_action = next_action(
+        &harness_health,
+        &task_state,
+        &verification,
+        &repository_quality,
+        &repository_structure,
+    );
+
+    Ok(DoctorReport {
+        schema: "naome.doctor.v1".to_string(),
+        ok,
+        harness_health,
+        task_state,
+        verification,
+        repository_quality,
+        repository_structure,
+        recommended_check_ids: phase_plan.recommended_check_ids,
+        withheld_check_ids: phase_plan.withheld_check_ids,
+        next_action,
+    })
+}
+
+fn section(messages: Vec<String>) -> DoctorSection {
+    DoctorSection {
+        status: if messages.is_empty() { "ok" } else { "blocked" }.to_string(),
+        messages,
+    }
+}
+
+fn policy_section(root: &Path, config_path: &str, baseline_path: &str) -> RepositoryPolicySection {
+    let config_present =
+        fs::metadata(root.join(config_path)).is_ok_and(|metadata| metadata.is_file());
+    let baseline_present = baseline_path.is_empty()
+        || fs::metadata(root.join(baseline_path)).is_ok_and(|metadata| metadata.is_file());
+    RepositoryPolicySection {
+        config_present,
+        baseline_present,
+        status: if config_present && baseline_present {
+            "ok"
+        } else {
+            "missing"
+        }
+        .to_string(),
+    }
+}
+
+fn next_action(
+    harness_health: &DoctorSection,
+    task_state: &DoctorSection,
+    verification: &DoctorSection,
+    repository_quality: &RepositoryPolicySection,
+    repository_structure: &RepositoryPolicySection,
+) -> String {
+    if task_state.status != "ok" {
+        return "Finish or resolve the active task before starting new work.".to_string();
+    }
+    if harness_health.status != "ok" {
+        return "Repair the NAOME harness before feature work.".to_string();
+    }
+    if verification.status != "ok" {
+        return "Fix .naome/verification.json before relying on gates.".to_string();
+    }
+    if repository_quality.status != "ok" || repository_structure.status != "ok" {
+        return "Run naome quality init or naome sync to seed repository quality policy."
+            .to_string();
+    }
+    "NAOME is ready for task work; follow the recommended verification phase order.".to_string()
+}

package/crates/naome-core/src/workflow/mod.rs

@@ -1,3 +1,4 @@
+mod doctor;
 mod integrity;
 mod integrity_normalize;
 mod integrity_support;
@@ -9,6 +10,7 @@ mod policy;
 mod processes;
 mod types;
 
+pub use doctor::{doctor_report, DoctorReport, DoctorSection, RepositoryPolicySection};
 pub use integrity::{refresh_integrity, IntegrityRefreshReport};
 pub use mutation::classify_mutations;
 pub use output::{summarize_command_output, CommandOutputSummary};

package/crates/naome-core/src/workflow/mutation.rs

@@ -34,13 +34,12 @@ fn mutation_class(path: &str) -> &'static str {
     {
         return "local-only repair";
     }
-    if path.starts_with("packages/naome/templates/") || path.starts_with(".naome/bin/") {
+    if path.starts_with(".naome/bin/") {
         return "harness template";
     }
     if path.ends_with(".tgz")
         || path.starts_with("dist/")
         || path.contains("/dist/")
-        || path.starts_with("packages/naome/native/")
         || path.starts_with("native/")
     {
         return "release artifact";

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

@@ -28,6 +28,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .gitignore_entries
         .contains(&".naome/task-journal.jsonl"));
     assert!(plan.git_exclude_entries.contains(&".naome/archive/"));
+    assert!(plan.git_exclude_entries.contains(&".naome/cache/"));
     assert!(plan.git_exclude_entries.contains(&".naome/bin/naome-rust*"));
     assert!(plan
         .git_exclude_entries
@@ -36,6 +37,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .git_exclude_entries
         .contains(&".naome/bin/check-harness-health.js"));
     assert!(plan.git_untrack_paths.contains(&".naome/archive"));
+    assert!(plan.git_untrack_paths.contains(&".naome/cache"));
     assert!(plan.git_untrack_paths.contains(&".naome/bin/naome-rust"));
     assert!(plan
         .git_untrack_paths

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, 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]

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

@@ -0,0 +1,231 @@
+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,
+};
+
+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 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_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/route_user_diff.rs

@@ -70,20 +70,24 @@ fn execute_route_runs_repository_quality_check_without_shelling_to_repo_command(
 }
 
 #[test]
-fn execute_route_commits_product_diff_with_declared_safe_quality_checks() {
+fn execute_route_refuses_product_named_checks_without_generic_builtin_policy() {
     let repo = TestRepo::product_quality_repo("route-product-diff-quality-pass");
     repo.write_file(
         "packages/naome/crates/naome-core/src/route.rs",
         "pub fn changed() {}\n",
     );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
 
     let route = route_commit_request(&repo);
 
-    assert_user_diff_committed(&route, &repo);
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("packages/naome/crates/naome-core/src/route.rs"));
-    assert!(route.user_message.contains("quality gates passed"));
+    assert_quality_gate_blocked(
+        &repo,
+        &route,
+        before_head,
+        "packages/naome/crates/naome-core/src/route.rs",
+    );
+    assert!(route.user_message.contains("installer-tests"));
+    assert!(route.user_message.contains("not a built-in safe check"));
 }
 
 #[test]

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

@@ -0,0 +1,140 @@
+mod repo_support;
+
+use naome_core::{check_semantic_legacy, semantic_route_for_finding, QualityMode};
+
+use repo_support::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/b.test.js",
+        &fixture_object("repositoryQualityConfig"),
+    );
+    repo.commit_all("baseline");
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::DeepReport).unwrap();
+
+    let finding = report
+        .findings
+        .iter()
+        .find(|finding| finding.kind == "copied-config-object")
+        .expect("expected copied config finding");
+    assert_eq!(finding.occurrences.len(), 2);
+    assert!(finding
+        .occurrences
+        .iter()
+        .any(|occurrence| occurrence.path == "scripts/a.test.js"));
+    assert!(finding
+        .cleanup_route
+        .agent_instructions
+        .iter()
+        .any(|instruction| instruction.contains("every occurrence")));
+}
+
+#[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.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"));
+
+    let changed = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+    assert!(!changed.ok);
+    assert!(changed
+        .findings
+        .iter()
+        .any(|finding| finding.kind == "inline-legacy-fixture"));
+}
+
+#[test]
+fn changed_check_allows_shared_fixture_factory_objects() {
+    let repo = semantic_repo("semantic-shared-factory");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/test-support.js",
+        &[
+            "function verificationContract() {",
+            "  return {",
+            "    schema: \"naome.verification.v1\",",
+            "    version: 1,",
+            "    status: \"ready\",",
+            "    checks: [],",
+            "    changeTypes: [],",
+            "    releaseGates: []",
+            "  };",
+            "}",
+            "",
+        ]
+        .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/b.test.js",
+        &fixture_object("repositoryQualityConfig"),
+    );
+    repo.commit_all("baseline");
+    let report = check_semantic_legacy(repo.path(), QualityMode::DeepReport).unwrap();
+    let finding_id = report.findings[0].id.clone();
+
+    let finding = semantic_route_for_finding(&report, &finding_id).unwrap();
+
+    assert_eq!(finding.id, finding_id);
+    assert!(!finding.cleanup_route.target_suggestion.is_empty());
+    assert!(finding
+        .cleanup_route
+        .required_checks
+        .contains(&"naome semantic check --changed".to_string()));
+}
+
+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
+}
+
+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")
+}