@lamentis/naome 1.1.1 → 1.2.0

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

@@ -0,0 +1,133 @@
+#![allow(dead_code)]
+
+use std::fs;
+use std::path::PathBuf;
+use std::process::{Command, Output};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{evaluate_intent, EvaluationOptions, IntentDecision};
+use serde_json::{json, Value};
+
+static REPO_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub fn env(prompt: &str, workflow: &str, task: &str, risk: &str) -> String {
+    format!(
+        "```naome-intent-v2\n{{\"schema\":\"naome.intent.v2\",\"workflowAction\":\"{workflow}\",\"taskIntent\":\"{task}\",\"risk\":\"{risk}\"}}\n```\n\n{prompt}"
+    )
+}
+
+pub fn idle() -> Value {
+    json!({ "status": "idle", "activeTask": null })
+}
+
+pub fn completed_state(head: &str, valid: bool) -> Value {
+    let proof = if valid {
+        r#"[{"checkId":"diff-check","command":"git diff --check","cwd":".","exitCode":0,"checkedAt":"2026-05-06T00:00:00.000Z","evidence":["README.md"]}]"#
+    } else {
+        "[]"
+    };
+    serde_json::from_str(&format!(r#"{{"schema":"naome.task-state.v1","version":1,"status":"complete","activeTask":{{"id":"readme-task","request":"Change README.","userPrompt":{{"receivedAt":"2026-05-06T00:00:00.000Z","text":"Change README."}},"admission":{{"command":"node .naome/bin/check-task-state.js --admission","cwd":".","exitCode":0,"checkedAt":"2026-05-06T00:00:00.000Z","gitHead":"{head}","changedPaths":[]}},"allowedPaths":["README.md"],"declaredChangeTypes":["product-docs"],"requiredCheckIds":["diff-check"],"proofResults":{proof},"revisions":[],"humanReview":{{"required":false,"approved":false,"reason":null}}}},"blocker":null,"updatedAt":"2026-05-06T00:00:00.000Z"}}"#)).unwrap()
+}
+
+pub struct Repo {
+    root: PathBuf,
+}
+
+impl Repo {
+    pub fn clean(name: &str, state: Value) -> Self {
+        let repo = Self::new(name);
+        repo.git(["init"]);
+        repo.git(["config", "user.email", "naome@example.com"]);
+        repo.git(["config", "user.name", "NAOME Test"]);
+        repo.write("README.md", "# Baseline\n");
+        repo.write_base(state);
+        repo.git(["add", "."]);
+        repo.git(["commit", "-m", "baseline"]);
+        repo
+    }
+
+    pub fn completed(name: &str, valid: bool) -> Self {
+        let repo = Self::clean(name, idle());
+        let head = repo.git_stdout(["rev-parse", "HEAD"]);
+        repo.write_base(completed_state(&head, valid));
+        repo.git(["add", ".naome/task-state.json"]);
+        repo.git(["commit", "-m", "task state"]);
+        repo.write("README.md", "# Changed\n");
+        repo
+    }
+
+    pub fn intent(&self, prompt: &str) -> IntentDecision {
+        evaluate_intent(&self.root, prompt, EvaluationOptions::offline()).unwrap()
+    }
+
+    pub fn write(&self, path: &str, content: &str) {
+        let path = self.root.join(path);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        fs::write(path, content).unwrap();
+    }
+
+    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-intent-{name}-{}-{}-{nonce}",
+            std::process::id(),
+            REPO_COUNTER.fetch_add(1, Ordering::SeqCst)
+        ));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        Self { root }
+    }
+
+    fn write_base(&self, state: Value) {
+        self.write_json(
+            "init-state.json",
+            json!({ "initialized": true, "intakeStatus": "complete" }),
+        );
+        self.write_json("upgrade-state.json", json!({ "status": "complete" }));
+        self.write_json("verification.json", verification());
+        self.write_json("task-state.json", state);
+    }
+
+    fn write_json(&self, name: &str, value: Value) {
+        self.write(
+            &format!(".naome/{name}"),
+            &format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
+        );
+    }
+
+    fn git<const N: usize>(&self, args: [&str; N]) {
+        let output = self.git_output(args);
+        assert!(
+            output.status.success(),
+            "git failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    fn git_stdout<const N: usize>(&self, args: [&str; N]) -> String {
+        let output = self.git_output(args);
+        assert!(output.status.success());
+        String::from_utf8(output.stdout).unwrap().trim().to_owned()
+    }
+
+    fn git_output<const N: usize>(&self, args: [&str; N]) -> Output {
+        let mut command = Command::new("git");
+        command.current_dir(&self.root).args(args);
+        command.output().unwrap()
+    }
+}
+
+impl Drop for Repo {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+fn verification() -> Value {
+    serde_json::from_str(r#"{"schema":"naome.verification.v1","version":1,"status":"ready","checks":[{"id":"diff-check","command":"git diff --check","cwd":".","purpose":"Reject whitespace errors.","cost":"fast","source":"test","evidence":["README.md"],"lastVerified":null}],"changeTypes":[],"releaseGates":[]}"#).unwrap()
+}

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

@@ -0,0 +1,90 @@
+mod intent_support;
+
+use intent_support::{env, idle, Repo};
+
+#[test]
+fn feature_descriptions_with_workflow_terms_route_as_new_tasks() {
+    let repo = Repo::clean("intent-v2-feature-terms", idle());
+    for prompt in [
+        "Add a context budget dashboard to the product.",
+        "Build a commit gate simulator feature for docs.",
+        "Implement a review findings feature for pull request analysis.",
+        "Create a baseline flow visualization in the UI.",
+    ] {
+        let intent = repo.intent(prompt);
+        assert_eq!(intent.prompt_intent, "new_task", "{prompt}");
+        assert_eq!(intent.policy_action, "create_new_task", "{prompt}");
+        assert!(!intent.evidence.requests_commit, "{prompt}");
+        assert!(!intent.evidence.requests_review, "{prompt}");
+        assert!(!intent.evidence.has_risky_terms, "{prompt}");
+    }
+}
+
+#[test]
+fn enveloped_workflow_requests_keep_their_intent() {
+    let repo = Repo::clean("intent-v2-direct-workflow", idle());
+    let commit = repo.intent(&env(
+        "please commit the current task",
+        "commit_request",
+        "none",
+        "none",
+    ));
+    assert_eq!(commit.prompt_intent, "commit_request");
+    assert!(commit.evidence.requests_commit);
+
+    let review = repo.intent(&env(
+        "review the current diff",
+        "review_request",
+        "none",
+        "none",
+    ));
+    assert_eq!(review.prompt_intent, "review_request");
+    assert!(review.evidence.requests_review);
+
+    let status = repo.intent(&env("show status", "status_question", "none", "none"));
+    assert_eq!(status.prompt_intent, "status_question");
+    assert_eq!(status.policy_action, "answer_status_only");
+}
+
+#[test]
+fn envelope_is_canonical_over_legacy_prompt_words() {
+    let repo = Repo::clean("intent-v2-envelope-canonical", idle());
+    let intent = repo.intent(&env(
+        "please commit the current task",
+        "none",
+        "new_task",
+        "none",
+    ));
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert!(!intent.evidence.requests_commit);
+}
+
+#[test]
+fn token_boundaries_and_code_segments_avoid_false_workflow_actions() {
+    let repo = Repo::clean("intent-v2-segments", idle());
+    let async_intent = repo.intent("Add async sync-state naming examples to the documentation.");
+    assert_eq!(async_intent.prompt_intent, "new_task");
+    assert!(!async_intent.evidence.requests_repair);
+
+    let code_intent =
+        repo.intent("Add docs with examples like `naome commit` and ```sh\ngit push\n```.");
+    assert_eq!(code_intent.prompt_intent, "new_task");
+    assert!(!code_intent.evidence.requests_commit);
+    assert!(!code_intent.evidence.has_risky_terms);
+}
+
+#[test]
+fn explicit_credential_context_still_routes_as_unsafe() {
+    let repo = Repo::clean("intent-v2-risk", idle());
+    let intent = repo.intent(&env(
+        "Commit the current token and API key so the deployment can use the secret.",
+        "commit_request",
+        "none",
+        "credential_context",
+    ));
+    assert_eq!(intent.prompt_intent, "unsafe");
+    assert!(intent.evidence.has_risky_terms);
+    assert!(intent
+        .risk_codes
+        .contains(&"prompt_contains_risky_terms".to_string()));
+}

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

@@ -0,0 +1,425 @@
+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,
+};
+use serde_json::{json, Value};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[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(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
+    );
+    repo.commit_all("legacy baseline");
+
+    repo.write(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n  five();\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report
+        .violations
+        .iter()
+        .any(|violation| violation.path == "src/large.js" && violation.check_id == "file-length"));
+}
+
+#[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(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
+    );
+    repo.commit_all("legacy baseline");
+
+    let changed = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+    let full = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(changed.ok);
+    assert!(changed.violations.is_empty());
+    assert!(!full.ok);
+    assert!(full
+        .violations
+        .iter()
+        .any(|violation| violation.path == "src/large.js" && violation.check_id == "file-length"));
+}
+
+#[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(
+        "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");
+
+    repo.write(
+        "src/copied.js",
+        "export function copied() {\n  const alpha = input.alpha;\n  const beta = input.beta;\n  const total = alpha + beta;\n  return total;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.path == "src/copied.js"
+            && violation.check_id == "duplicate-blocks"
+            && violation
+                .related_paths
+                .contains(&"src/existing.js".to_string())
+    }));
+}
+
+#[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(
+        "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");
+
+    repo.write(
+        "src/copied.js",
+        "export function copied() {\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",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+    let duplicate_regions = report
+        .violations
+        .iter()
+        .filter(|violation| {
+            violation.path == "src/copied.js" && violation.check_id == "duplicate-blocks"
+        })
+        .count();
+
+    assert_eq!(duplicate_regions, 1);
+}
+
+#[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.commit_all("empty baseline");
+
+    repo.write(
+        "src/repeated.js",
+        concat!(
+            "export function repeated() {\n",
+            "  const alpha = input.alpha;\n",
+            "  const beta = input.beta;\n",
+            "  const total = alpha + beta;\n",
+            "  save(total);\n",
+            "  audit(total);\n",
+            "  const alpha = input.alpha;\n",
+            "  const beta = input.beta;\n",
+            "  const total = alpha + beta;\n",
+            "  save(total);\n",
+            "  return total;\n",
+            "}\n"
+        ),
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.path == "src/repeated.js"
+            && violation.check_id == "duplicate-blocks"
+            && violation
+                .related_paths
+                .contains(&"src/repeated.js".to_string())
+    }));
+}
+
+#[test]
+fn duplicate_blocks_ignore_generated_sha256_maps() {
+    let repo = QualityFixture::new("quality-generated-hash-map");
+    repo.write_quality_config(200, 80, 4);
+    let generated_map = concat!(
+        "const expected = Object.freeze({\n",
+        "  \"one.js\": \"sha256:1111111111111111111111111111111111111111111111111111111111111111\",\n",
+        "  \"two.js\": \"sha256:2222222222222222222222222222222222222222222222222222222222222222\",\n",
+        "  \"three.js\": \"sha256:3333333333333333333333333333333333333333333333333333333333333333\",\n",
+        "  \"four.js\": \"sha256:4444444444444444444444444444444444444444444444444444444444444444\",\n",
+        "  \"five.js\": \"sha256:5555555555555555555555555555555555555555555555555555555555555555\"\n",
+        "});\n"
+    );
+    repo.write("src/existing.js", generated_map);
+    repo.commit_all("generated hash baseline");
+
+    repo.write("src/copied.js", generated_map);
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok);
+}
+
+#[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(
+        "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",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(!report.violations.iter().any(|violation| {
+        violation.path == "src/lib.rs" && violation.check_id == "near-duplicate-functions"
+    }));
+}
+
+#[test]
+fn init_writes_default_config_and_baselines_existing_debt() {
+    let repo = QualityFixture::new("quality-init-baseline");
+    let large_file = (0..520)
+        .map(|index| format!("export const value{index} = {index};\n"))
+        .collect::<String>();
+    repo.write("src/large.js", &large_file);
+    repo.commit_all("legacy baseline");
+
+    let init = init_repository_quality(repo.path()).unwrap();
+
+    assert!(init.config_written);
+    assert!(init.baseline_written);
+    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);
+}
+
+#[test]
+fn init_generates_adapter_selection_without_product_specific_path_rules() {
+    let repo = QualityFixture::new("quality-adapter-selected-config");
+    repo.write("Cargo.toml", "[workspace]\nmembers = []\n");
+    repo.write("package.json", "{\"scripts\":{\"test\":\"node --test\"}}\n");
+    repo.write(
+        "packages/naome/templates/naome-root/.naome/bin/naome.js",
+        "#!/usr/bin/env node\nconsole.log('template');\n",
+    );
+    repo.commit_all("repo profile");
+
+    let init = init_repository_quality(repo.path()).unwrap();
+    let config: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-quality.json")).unwrap(),
+    )
+    .unwrap();
+    let enabled_adapters = config
+        .get("enabledAdapters")
+        .and_then(Value::as_array)
+        .expect("enabledAdapters should be generated");
+    let adapter_ids = enabled_adapters
+        .iter()
+        .filter_map(Value::as_str)
+        .collect::<Vec<_>>();
+    let serialized_config = fs::read_to_string(repo.path().join(".naome/repository-quality.json"))
+        .expect("config should be readable");
+
+    assert!(init.config_written);
+    assert_eq!(adapter_ids, vec!["rust", "javascript-typescript"]);
+    assert!(!serialized_config.contains("packages/naome/"));
+    assert!(!serialized_config.contains("naome-template-harness"));
+}
+
+#[test]
+fn enabled_adapters_apply_their_rules_without_materialized_path_rules() {
+    let repo = QualityFixture::new("quality-adapter-runtime-config");
+    repo.write_quality_config_with_adapters(8, 80, 4, &["javascript-typescript"]);
+    repo.write(
+        "scripts/example.test.js",
+        &(0..20)
+            .map(|index| format!("export const value{index} = {index};\n"))
+            .collect::<String>(),
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(!report.violations.iter().any(|violation| {
+        violation.path == "scripts/example.test.js" && violation.check_id == "file-length"
+    }));
+}
+
+#[test]
+fn seeding_builtin_verification_wires_repository_quality_into_change_types() {
+    let repo = QualityFixture::new("quality-verification-wiring");
+    repo.write(
+        ".naome/verification.json",
+        concat!(
+            "{\"schema\":\"naome.verification.v1\",\"version\":1,\"status\":\"ready\",",
+            "\"checks\":[{\"id\":\"diff-check\",\"command\":\"git diff --check\",",
+            "\"cwd\":\".\",\"purpose\":\"Reject whitespace errors.\",\"cost\":\"fast\",",
+            "\"source\":\"repository\",\"evidence\":[],\"lastVerified\":null}],",
+            "\"changeTypes\":[{\"id\":\"source\",\"description\":\"Source changes.\",",
+            "\"paths\":[\"src/**\"],\"requiredChecks\":[\"diff-check\"],",
+            "\"recommendedChecks\":[],\"humanReview\":false}],\"releaseGates\":[]}\n"
+        ),
+    );
+
+    let changed = seed_builtin_verification_checks(repo.path()).unwrap();
+    let verification: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/verification.json")).unwrap(),
+    )
+    .unwrap();
+    let source_change_type = verification
+        .get("changeTypes")
+        .and_then(Value::as_array)
+        .unwrap()
+        .iter()
+        .find(|change_type| change_type.get("id").and_then(Value::as_str) == Some("source"))
+        .unwrap();
+    let required_checks = source_change_type
+        .get("requiredChecks")
+        .and_then(Value::as_array)
+        .unwrap();
+
+    assert!(changed);
+    assert!(required_checks
+        .iter()
+        .any(|check| check.as_str() == Some("repository-quality-check")));
+}
+
+#[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(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
+    );
+    repo.commit_all("legacy baseline");
+
+    let plan = plan_quality_cleanup(repo.path()).unwrap();
+    let route = route_quality_cleanup(repo.path(), "src/large.js").unwrap();
+
+    assert_eq!(plan.tasks[0].path, "src/large.js");
+    assert!(plan.tasks[0].violation_count >= 1);
+    assert_eq!(route.path, "src/large.js");
+    assert!(route.agent_instructions.contains("Reduce or split"));
+    assert!(route
+        .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)
+    );
+}