@lamentis/naome 1.2.0 → 1.3.0

package/crates/naome-core/src/verification.rs

@@ -243,6 +243,7 @@ fn builtin_checks() -> Vec<BuiltinCheck> {
             purpose: "Validate changed files against deterministic NAOME repository quality rules.",
             evidence: &[
                 ".naome/repository-quality.json",
+                ".naome/repository-structure.json",
                 ".naome/repository-quality-baseline.json",
             ],
         },

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/decision.rs

@@ -1,12 +1,14 @@
 use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
 use std::sync::Mutex;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use naome_core::{evaluate_decision, format_decision, EvaluationOptions};
 use serde_json::json;
 
+mod repo_support;
+
+use repo_support::TestRepo;
+
 static ENV_LOCK: Mutex<()> = Mutex::new(());
 
 #[test]
@@ -34,20 +36,7 @@ fn completed_task_diff_returns_baseline_choices() {
     let repo = TestRepo::new("completed-task");
     repo.init_git();
     repo.write_file("README.md", "# Baseline\n");
-    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
-    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-    repo.write_naome_json(
-        "task-state.json",
-        json!({
-            "status": "complete",
-            "activeTask": {
-                "id": "readme-task",
-                "allowedPaths": ["README.md"],
-                "requiredCheckIds": ["diff-check"],
-                "proofResults": []
-            }
-        }),
-    );
+    repo.write_base_naome_state(completed_without_proof_state());
     repo.git(&["add", "."]);
     repo.git(&["commit", "-m", "baseline"]);
     repo.write_file("README.md", "# Changed\n");
@@ -71,17 +60,7 @@ fn completed_task_diff_returns_baseline_choices() {
 
 #[test]
 fn idle_unowned_diff_blocks_new_feature_work() {
-    let repo = TestRepo::new("unowned-diff");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
-    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-    repo.write_naome_json(
-        "task-state.json",
-        json!({ "status": "idle", "activeTask": null }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
+    let repo = TestRepo::idle_readme("unowned-diff");
     repo.write_file("README.md", "# Manual change\n");
 
     let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
@@ -96,12 +75,7 @@ fn changed_paths_handle_worktree_renames_without_corrupting_old_path_tokens() {
     let repo = TestRepo::new("worktree-rename");
     repo.init_git();
     repo.write_file("packages/old/file.txt", "baseline\n");
-    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
-    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-    repo.write_naome_json(
-        "task-state.json",
-        json!({ "status": "idle", "activeTask": null }),
-    );
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
     repo.git(&["add", "."]);
     repo.git(&["commit", "-m", "baseline"]);
 
@@ -129,19 +103,10 @@ fn active_task_allows_control_state_and_untracked_files_inside_scope() {
     let repo = TestRepo::new("active-scope");
     repo.init_git();
     repo.write_file("README.md", "# Baseline\n");
-    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
-    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-    repo.write_naome_json(
-        "task-state.json",
-        json!({
-            "status": "implementing",
-            "activeTask": {
-                "id": "rust-task",
-                "allowedPaths": ["packages/naome/crates/naome-core/src/lib.rs"],
-                "requiredCheckIds": ["decision-engine-tests"],
-                "proofResults": []
-            }
-        }),
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_implementing_task_state(
+        "packages/naome/crates/naome-core/src/lib.rs",
+        "decision-engine-tests",
     );
     repo.git(&["add", "."]);
     repo.git(&["commit", "-m", "baseline"]);
@@ -149,17 +114,9 @@ fn active_task_allows_control_state_and_untracked_files_inside_scope() {
         "packages/naome/crates/naome-core/src/lib.rs",
         "pub fn marker() {}\n",
     );
-    repo.write_naome_json(
-        "task-state.json",
-        json!({
-            "status": "implementing",
-            "activeTask": {
-                "id": "rust-task",
-                "allowedPaths": ["packages/naome/crates/naome-core/src/lib.rs"],
-                "requiredCheckIds": ["decision-engine-tests"],
-                "proofResults": []
-            }
-        }),
+    repo.write_implementing_task_state(
+        "packages/naome/crates/naome-core/src/lib.rs",
+        "decision-engine-tests",
     );
 
     let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
@@ -202,12 +159,7 @@ fn online_checks_use_explicit_node_binary_from_environment() {
     let _guard = ENV_LOCK.lock().unwrap();
     let repo = TestRepo::new("explicit-node-bin");
     repo.init_git();
-    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
-    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-    repo.write_naome_json(
-        "task-state.json",
-        json!({ "status": "idle", "activeTask": null }),
-    );
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
     repo.git(&["add", "."]);
     repo.git(&["commit", "-m", "baseline"]);
     let fake_node = std::env::temp_dir().join(format!(
@@ -240,60 +192,14 @@ fn online_checks_use_explicit_node_binary_from_environment() {
     );
 }
 
-struct TestRepo {
-    root: PathBuf,
-}
-
-impl TestRepo {
-    fn new(name: &str) -> Self {
-        let nonce = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let root = std::env::temp_dir().join(format!("naome-core-{name}-{nonce}"));
-        fs::create_dir_all(root.join(".naome")).unwrap();
-        Self { root }
-    }
-
-    fn path(&self) -> &Path {
-        &self.root
-    }
-
-    fn write_file(&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();
+fn completed_without_proof_state() -> serde_json::Value {
+    json!({
+        "status": "complete",
+        "activeTask": {
+            "id": "readme-task",
+            "allowedPaths": ["README.md"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": []
         }
-        fs::write(path, content).unwrap();
-    }
-
-    fn write_naome_json(&self, file_name: &str, value: serde_json::Value) {
-        let path = self.root.join(".naome").join(file_name);
-        fs::write(
-            path,
-            format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
-        )
-        .unwrap();
-    }
-
-    fn init_git(&self) {
-        self.git(&["init"]);
-        self.git(&["config", "user.email", "naome@example.com"]);
-        self.git(&["config", "user.name", "NAOME Test"]);
-    }
-
-    fn git(&self, args: &[&str]) {
-        let output = Command::new("git")
-            .args(args)
-            .current_dir(&self.root)
-            .output()
-            .unwrap();
-        assert!(
-            output.status.success(),
-            "git {:?} failed\nstdout:\n{}\nstderr:\n{}",
-            args,
-            String::from_utf8_lossy(&output.stdout),
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
+    })
 }

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

@@ -30,11 +30,13 @@ const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/upgrade-state.json",
     ".naome/verification.json",
     ".naome/repository-quality.json",
+    ".naome/repository-structure.json",
     ".naome/repository-quality-baseline.json",
     "docs/naome/architecture.md",
     "docs/naome/decisions.md",
     "docs/naome/repo-profile.md",
     "docs/naome/repository-quality.md",
+    "docs/naome/repository-structure.md",
     "docs/naome/security.md",
     "docs/naome/testing.md",
 ];

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,20 +1,20 @@
 use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::atomic::{AtomicU64, Ordering};
 
 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::{json, Value};
+use serde_json::Value;
 
-static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+mod quality_structure_support;
+
+use quality_structure_support::StructureFixture as QualityFixture;
 
 #[test]
 fn changed_check_blocks_touched_legacy_file_until_it_conforms() {
     let repo = QualityFixture::new("quality-touched-legacy");
-    repo.write_quality_config(5, 40, 4);
+    repo.write_quality_limits(5, 40, 4);
     repo.write(
         "src/large.js",
         "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
@@ -38,7 +38,7 @@ fn changed_check_blocks_touched_legacy_file_until_it_conforms() {
 #[test]
 fn whole_repo_debt_is_visible_without_blocking_clean_changed_check() {
     let repo = QualityFixture::new("quality-clean-legacy-report");
-    repo.write_quality_config(5, 40, 4);
+    repo.write_quality_limits(5, 40, 4);
     repo.write(
         "src/large.js",
         "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
@@ -60,12 +60,13 @@ fn whole_repo_debt_is_visible_without_blocking_clean_changed_check() {
 #[test]
 fn changed_check_blocks_new_duplicate_blocks_against_existing_code() {
     let repo = QualityFixture::new("quality-duplicate-block");
-    repo.write_quality_config(200, 40, 4);
+    repo.write_quality_limits(200, 40, 4);
     repo.write(
         "src/existing.js",
         "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",
@@ -87,12 +88,13 @@ fn changed_check_blocks_new_duplicate_blocks_against_existing_code() {
 #[test]
 fn duplicate_blocks_report_one_finding_per_overlapping_region() {
     let repo = QualityFixture::new("quality-duplicate-region");
-    repo.write_quality_config(200, 80, 4);
+    repo.write_quality_limits(200, 80, 4);
     repo.write(
         "src/existing.js",
         "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",
@@ -114,7 +116,7 @@ fn duplicate_blocks_report_one_finding_per_overlapping_region() {
 #[test]
 fn duplicate_blocks_detect_repeated_regions_in_the_same_file() {
     let repo = QualityFixture::new("quality-same-file-duplicate-region");
-    repo.write_quality_config(200, 80, 4);
+    repo.write_quality_limits(200, 80, 4);
     repo.commit_all("empty baseline");
 
     repo.write(
@@ -150,7 +152,7 @@ fn duplicate_blocks_detect_repeated_regions_in_the_same_file() {
 #[test]
 fn duplicate_blocks_ignore_generated_sha256_maps() {
     let repo = QualityFixture::new("quality-generated-hash-map");
-    repo.write_quality_config(200, 80, 4);
+    repo.write_quality_limits(200, 80, 4);
     let generated_map = concat!(
         "const expected = Object.freeze({\n",
         "  \"one.js\": \"sha256:1111111111111111111111111111111111111111111111111111111111111111\",\n",
@@ -173,7 +175,7 @@ fn duplicate_blocks_ignore_generated_sha256_maps() {
 #[test]
 fn near_duplicate_functions_do_not_compare_containers_with_child_symbols() {
     let repo = QualityFixture::new("quality-container-child-similarity");
-    repo.write_quality_config(200, 120, 10);
+    repo.write_quality_limits(200, 120, 10);
     repo.write(
         "src/lib.rs",
         "pub struct Runner;\n\nimpl Runner {\n    pub fn execute(&self) {\n        alpha();\n        beta();\n        gamma();\n        delta();\n        epsilon();\n        zeta();\n        eta();\n        theta();\n        iota();\n        kappa();\n        lambda();\n        mu();\n        nu();\n        xi();\n        omicron();\n        pi();\n    }\n}\n",
@@ -187,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"))
@@ -198,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]
@@ -300,7 +308,7 @@ fn seeding_builtin_verification_wires_repository_quality_into_change_types() {
 #[test]
 fn cleanup_plan_and_route_turn_debt_into_agent_work() {
     let repo = QualityFixture::new("quality-cleanup-plan");
-    repo.write_quality_config(5, 40, 4);
+    repo.write_quality_limits(5, 40, 4);
     repo.write(
         "src/large.js",
         "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
@@ -318,108 +326,3 @@ fn cleanup_plan_and_route_turn_debt_into_agent_work() {
         .required_checks
         .contains(&"naome quality check --changed".to_string()));
 }
-
-struct QualityFixture {
-    root: PathBuf,
-}
-
-impl QualityFixture {
-    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();
-        fs::write(root.join(".naomeignore"), ".naome/archive/\n").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();
-    }
-
-    fn write_quality_config(
-        &self,
-        max_file_lines: usize,
-        max_function_lines: usize,
-        duplicate_block_lines: usize,
-    ) {
-        self.write_quality_config_with_adapters(
-            max_file_lines,
-            max_function_lines,
-            duplicate_block_lines,
-            &[],
-        );
-    }
-
-    fn write_quality_config_with_adapters(
-        &self,
-        max_file_lines: usize,
-        max_function_lines: usize,
-        duplicate_block_lines: usize,
-        enabled_adapters: &[&str],
-    ) {
-        let config = json!({
-            "schema": "naome.repository-quality.v1",
-            "version": 1,
-            "status": "ready",
-            "limits": {
-                "maxFileLines": max_file_lines,
-                "maxNewFileLines": max_file_lines,
-                "maxDiffAddedLines": 200,
-                "maxFunctionLines": max_function_lines,
-                "maxTopLevelSymbols": 30,
-                "duplicateBlockLines": duplicate_block_lines,
-                "nearDuplicateSimilarity": 0.9
-            },
-            "enabledAdapters": enabled_adapters,
-            "disabledChecks": [],
-            "ignoredPaths": [],
-            "generatedPaths": [],
-            "pathRules": []
-        });
-        self.write(
-            ".naome/repository-quality.json",
-            &format!("{}\n", serde_json::to_string_pretty(&config).unwrap()),
-        );
-    }
-
-    fn commit_all(&self, message: &str) {
-        git(&self.root, &["add", "."]);
-        git(&self.root, &["commit", "-m", message]);
-    }
-}
-
-impl Drop for QualityFixture {
-    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(),
-        "git {} failed\nstdout: {}\nstderr: {}",
-        args.join(" "),
-        String::from_utf8_lossy(&output.stdout),
-        String::from_utf8_lossy(&output.stderr)
-    );
-}