@lamentis/naome 1.2.0 → 1.2.1

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

@@ -0,0 +1,125 @@
+mod quality_structure_support;
+
+use naome_core::{
+    check_repository_quality, explain_repository_structure, route_quality_cleanup, QualityMode,
+};
+
+use quality_structure_support::{assert_has, StructureFixture};
+
+#[test]
+fn legacy_structure_debt_is_reported_but_not_changed_blocking() {
+    let repo = StructureFixture::new("structure-legacy-debt");
+    repo.write("random.tmp", "legacy scratch\n");
+    repo.commit_all("legacy debt");
+
+    let changed = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(changed.ok);
+    assert_has(&report, "random.tmp", "root-file-sprawl");
+}
+
+#[test]
+fn touched_file_inside_debt_directory_blocks_changed_gate() {
+    let repo = StructureFixture::new("structure-touched-debt-dir");
+    repo.write_js_package();
+    repo.write(
+        "src/utils/legacy-helper.js",
+        "export function legacy() {\n  return 1;\n}\n",
+    );
+    repo.commit_all("legacy dumping ground");
+    repo.write(
+        "src/utils/legacy-helper.js",
+        "export function legacy() {\n  return 2;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(
+        &report,
+        "src/utils/legacy-helper.js",
+        "dumping-ground-directory",
+    );
+}
+
+#[test]
+fn quality_report_and_cleanup_route_include_structure_findings() {
+    let repo = StructureFixture::new("structure-report-cleanup");
+    repo.write(
+        "src/utils/random.js",
+        "export function random() {\n  return 1;\n}\n",
+    );
+    repo.commit_all("legacy structure debt");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let route = route_quality_cleanup(repo.path(), "src/utils/random.js").unwrap();
+
+    assert_has(&report, "src/utils/random.js", "dumping-ground-directory");
+    assert!(route.agent_instructions.contains("structure"));
+    assert!(route
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "dumping-ground-directory"));
+}
+
+#[test]
+fn wildcard_module_roots_explain_monorepo_module_names() {
+    let repo = StructureFixture::new("structure-wildcard-module-root");
+    repo.write_structure_config(serde_json::json!({
+        "sourceRoots": ["packages/*/src/**"],
+        "moduleRoots": ["packages/*/src/**"]
+    }));
+    repo.write("packages/payments/src/lib.rs", "pub fn charge() {}\n");
+
+    let explanation =
+        explain_repository_structure(repo.path(), "packages/payments/src/lib.rs").unwrap();
+
+    assert_eq!(explanation.module.as_deref(), Some("payments"));
+}
+
+#[test]
+fn disabled_structure_checks_are_not_reported() {
+    let repo = StructureFixture::new("structure-disabled-checks");
+    repo.write_structure_config(serde_json::json!({
+        "allowedRootFiles": [".naomeignore", "package.json", "README.md"],
+        "disabledChecks": ["test-source-pairing"]
+    }));
+    repo.write(
+        "src/payment-flow.js",
+        "export function paymentFlow() {\n  return 1;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.violations);
+}
+
+#[test]
+fn directory_role_rules_can_allow_configured_role_mixes() {
+    let repo = StructureFixture::new("structure-directory-role-rule");
+    repo.write_structure_config(serde_json::json!({
+        "directoryRoleRules": [
+            {
+                "id": "generated-source-client",
+                "paths": ["src/generated/**"],
+                "allowedRoles": ["generated"],
+                "maxRoles": 1
+            }
+        ]
+    }));
+    repo.write(
+        "src/generated/client.ts",
+        "export const generated = true;\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(
+        !report
+            .violations
+            .iter()
+            .any(|violation| violation.check_id == "directory-role-mixing"),
+        "{:#?}",
+        report.violations
+    );
+}

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

@@ -0,0 +1,249 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use naome_core::QualityReport;
+use serde_json::json;
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub struct StructureFixture {
+    root: PathBuf,
+}
+
+#[allow(dead_code)]
+impl StructureFixture {
+    pub 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 }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn write(&self, relative_path: impl AsRef<Path>, content: &str) {
+        let destination = self.root.join(relative_path.as_ref());
+        let parent = destination.parent().expect("fixture paths are file paths");
+        fs::create_dir_all(parent)
+            .unwrap_or_else(|error| panic!("create {}: {error}", parent.display()));
+        fs::write(&destination, content)
+            .unwrap_or_else(|error| panic!("write {}: {error}", destination.display()));
+    }
+
+    pub fn write_js_package(&self) {
+        self.write("package.json", "{\"scripts\":{\"test\":\"node --test\"}}\n");
+    }
+
+    pub fn write_quality_config(&self) {
+        self.write(
+            ".naome/repository-quality.json",
+            concat!(
+                "{\n",
+                "  \"schema\": \"naome.repository-quality.v1\",\n",
+                "  \"version\": 1,\n",
+                "  \"status\": \"ready\",\n",
+                "  \"limits\": {\n",
+                "    \"maxFileLines\": 450,\n",
+                "    \"maxNewFileLines\": 300,\n",
+                "    \"maxDiffAddedLines\": 180,\n",
+                "    \"maxFunctionLines\": 100,\n",
+                "    \"maxTopLevelSymbols\": 30,\n",
+                "    \"duplicateBlockLines\": 10,\n",
+                "    \"nearDuplicateSimilarity\": 0.9\n",
+                "  },\n",
+                "  \"enabledAdapters\": [],\n",
+                "  \"disabledChecks\": [],\n",
+                "  \"ignoredPaths\": [],\n",
+                "  \"generatedPaths\": [],\n",
+                "  \"pathRules\": []\n",
+                "}\n"
+            ),
+        );
+    }
+
+    pub fn write_quality_limits(
+        &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,
+            &[],
+        );
+    }
+
+    pub fn write_quality_config_with_adapters(
+        &self,
+        max_file_lines: usize,
+        max_function_lines: usize,
+        duplicate_block_lines: usize,
+        enabled_adapters: &[&str],
+    ) {
+        self.write(
+            ".naome/repository-quality.json",
+            &format!(
+                "{}\n",
+                serde_json::to_string_pretty(&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": []
+                }))
+                .unwrap()
+            ),
+        );
+    }
+}
+
+#[allow(dead_code)]
+impl StructureFixture {
+    pub fn write_structure_config(&self, overrides: serde_json::Value) {
+        let mut config = json!({
+            "schema": "naome.repository-structure.v1",
+            "version": 1,
+            "status": "ready",
+            "enabledAdapters": [],
+            "sourceRoots": ["src/**"],
+            "testRoots": ["tests/**", "test/**"],
+            "docsRoots": ["docs/**"],
+            "generatedRoots": ["**/generated/**"],
+            "artifactRoots": ["dist/**", "build/**"],
+            "moduleRoots": ["src/**"],
+            "allowedRootFiles": ["README.md", "LICENSE", "package.json", "Cargo.toml"],
+            "directoryRoleRules": [],
+            "layerRules": [],
+            "ignoredPaths": [],
+            "disabledChecks": [],
+            "changedCodePolicy": "block",
+            "debtPolicy": "report",
+            "limits": {
+                "maxDirectoryFiles": 40,
+                "maxPathDepth": 10,
+                "maxDirectoryRoles": 2,
+                "maxDumpingGroundFiles": 8
+            }
+        });
+        merge(&mut config, overrides);
+        self.write(
+            ".naome/repository-structure.json",
+            &format!("{}\n", serde_json::to_string_pretty(&config).unwrap()),
+        );
+    }
+
+    pub fn commit_all(&self, message: &str) {
+        git(&self.root, &["add", "."]);
+        git(&self.root, &["commit", "-m", message]);
+    }
+
+    pub fn add_index_only_path(&self, relative_path: &str, content: &str) {
+        let mut hash = Command::new("git")
+            .args(["hash-object", "-w", "--stdin"])
+            .current_dir(&self.root)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .unwrap();
+        {
+            use std::io::Write;
+            hash.stdin
+                .as_mut()
+                .unwrap()
+                .write_all(content.as_bytes())
+                .unwrap();
+        }
+        let output = hash.wait_with_output().unwrap();
+        assert!(output.status.success());
+        let oid = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        git(
+            &self.root,
+            &[
+                "update-index",
+                "--add",
+                "--cacheinfo",
+                "100644",
+                &oid,
+                relative_path,
+            ],
+        );
+    }
+}
+
+impl Drop for StructureFixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+pub fn assert_has(report: &QualityReport, path: &str, check_id: &str) {
+    assert!(
+        report
+            .violations
+            .iter()
+            .any(|violation| violation.path == path && violation.check_id == check_id),
+        "missing {check_id} for {path}; violations: {:#?}",
+        report.violations
+    );
+}
+
+#[allow(dead_code)]
+fn merge(target: &mut serde_json::Value, overrides: serde_json::Value) {
+    let Some(target_object) = target.as_object_mut() else {
+        return;
+    };
+    let Some(overrides_object) = overrides.as_object() else {
+        return;
+    };
+    for (key, value) in overrides_object {
+        if let (Some(target_value), Some(_)) = (target_object.get_mut(key), value.as_object()) {
+            merge(target_value, value.clone());
+        } else {
+            target_object.insert(key.clone(), value.clone());
+        }
+    }
+}
+
+fn git(root: &Path, args: &[&str]) {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    if output.status.success() {
+        return;
+    }
+    panic!(
+        "git failed in {}\ncommand: git {}\nstdout: {}\nstderr: {}",
+        root.display(),
+        args.join(" "),
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

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

@@ -0,0 +1,16 @@
+#![allow(dead_code, unused_imports)]
+
+mod repo;
+mod repo_factories;
+mod repo_helpers;
+mod routes;
+mod verification;
+mod verification_values;
+
+pub use repo::TestRepo;
+pub use routes::{
+    assert_commit_paths, assert_isolated_worktree_ready, assert_user_diff_committed,
+    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};

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

@@ -0,0 +1,113 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub struct TestRepo {
+    root: PathBuf,
+}
+
+impl TestRepo {
+    pub 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 }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub 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();
+    }
+
+    pub fn write_naome_file(&self, file_name: &str, content: &str) {
+        fs::write(self.root.join(".naome").join(file_name), content).unwrap();
+    }
+
+    pub fn read_naome_json(&self, file_name: &str) -> serde_json::Value {
+        serde_json::from_str(&fs::read_to_string(self.root.join(".naome").join(file_name)).unwrap())
+            .unwrap()
+    }
+
+    pub fn read_naome_file(&self, file_name: &str) -> String {
+        fs::read_to_string(self.root.join(".naome").join(file_name)).unwrap()
+    }
+
+    pub fn write_testing_markdown(&self, content: &str) {
+        fs::create_dir_all(self.root.join("docs").join("naome")).unwrap();
+        fs::write(
+            self.root.join("docs").join("naome").join("testing.md"),
+            content,
+        )
+        .unwrap();
+    }
+
+    pub 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();
+        }
+        fs::write(path, content).unwrap();
+    }
+
+    pub fn init_git(&self) {
+        self.git(&["init"]);
+        self.git(&["config", "user.email", "naome@example.com"]);
+        self.git(&["config", "user.name", "NAOME Test"]);
+    }
+
+    pub 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)
+        );
+    }
+
+    pub fn git_stdout(&self, args: &[&str]) -> String {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(output.status.success());
+        String::from_utf8_lossy(&output.stdout).trim().to_string()
+    }
+
+    pub fn git_status_short(&self) -> String {
+        self.git_stdout(&["status", "--short"])
+    }
+
+    pub fn git_status_short_at(root: &Path) -> String {
+        let output = Command::new("git")
+            .args(["status", "--short"])
+            .current_dir(root)
+            .output()
+            .unwrap();
+        assert!(output.status.success());
+        String::from_utf8_lossy(&output.stdout).trim().to_string()
+    }
+
+    pub fn commit_all(&self, message: &str) {
+        self.git(&["add", "."]);
+        self.git(&["commit", "-m", message]);
+    }
+}

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

@@ -0,0 +1,99 @@
+use serde_json::{json, Value};
+
+use super::repo::TestRepo;
+use super::verification_values::completed_task_state;
+
+impl TestRepo {
+    pub fn completed_task_with_diff(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.git(&["add", "."]);
+        repo.git(&["commit", "-m", "baseline"]);
+        let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+        repo.write_base_naome_state(completed_task_state(&admission_head));
+        repo.git(&["add", ".naome/task-state.json"]);
+        repo.git(&["commit", "-m", "task state"]);
+        repo.write_file("README.md", "# Changed\n");
+        repo
+    }
+
+    pub fn completed_task_with_unrelated_user_edit(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_file("USER.md", "user baseline\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.git(&["add", "."]);
+        repo.git(&["commit", "-m", "baseline"]);
+        let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+        repo.write_base_naome_state(completed_task_state(&admission_head));
+        repo.git(&["add", ".naome/task-state.json"]);
+        repo.git(&["commit", "-m", "task state"]);
+        repo.write_file("README.md", "# Changed\n");
+        repo.write_file("USER.md", "user local edit\n");
+        repo
+    }
+
+    pub fn completed_task_with_harness_refresh_diff(name: &str) -> Self {
+        let repo = Self::completed_task_with_diff(name);
+        repo.write_current_harness_refresh();
+        repo
+    }
+
+    pub fn completed_task_with_harness_refresh_only(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_file("AGENTS.md", "# Agent Instructions\n\nOld harness.\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.write_harness_manifest("old");
+        repo.commit_all("baseline");
+        let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+        repo.write_base_naome_state(completed_task_state(&admission_head));
+        repo.git(&["add", ".naome/task-state.json"]);
+        repo.git(&["commit", "-m", "task state"]);
+        repo.write_current_harness_refresh();
+        repo
+    }
+
+    pub fn dirty_harness_refresh_repo(name: &str, with_user_edit: bool) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_file("USER.md", "user baseline\n");
+        repo.write_file("AGENTS.md", "# Agent Instructions\n\nOld harness.\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.write_harness_manifest("old");
+        repo.commit_all("baseline");
+        repo.write_current_harness_refresh();
+        if with_user_edit {
+            repo.write_file("USER.md", "user local edit\n");
+        }
+        repo
+    }
+
+    pub fn idle_readme(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.commit_all("baseline");
+        repo
+    }
+
+    pub fn readme_quality_repo(
+        name: &str,
+        extra_checks: Vec<Value>,
+        required_checks: Vec<&str>,
+    ) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file("README.md", "# Baseline\n");
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.write_readme_quality_verification(extra_checks, required_checks);
+        repo.commit_all("baseline");
+        repo
+    }
+}