@lamentis/naome 1.2.0 → 1.3.0

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
+    }
+}

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

@@ -0,0 +1,123 @@
+use std::fs;
+
+use serde_json::json;
+
+use super::repo::TestRepo;
+
+impl TestRepo {
+    pub fn product_quality_repo(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file(
+            "packages/naome/crates/naome-core/src/route.rs",
+            "pub fn baseline() {}\n",
+        );
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.write_product_quality_verification();
+        repo.commit_all("baseline");
+        repo
+    }
+
+    pub fn repository_quality_failure_repo(name: &str) -> Self {
+        let repo = Self::new(name);
+        repo.init_git();
+        repo.write_file(".naome/repository-quality.json", quality_limits_fixture());
+        repo.write_file(
+            "src/large.js",
+            "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
+        );
+        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+        repo.write_source_quality_verification();
+        repo.commit_all("baseline");
+        repo
+    }
+
+    pub fn readme_unsafe_diff_check_repo(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.write_unsafe_readme_diff_verification();
+        repo.commit_all("baseline");
+        repo
+    }
+
+    pub fn dirty_user_edit_repo(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.commit_all("baseline");
+        repo.write_file("USER.md", "user local edit\n");
+        repo
+    }
+
+    pub fn create_stale_task_worktrees(&self, count: usize) {
+        let common_dir = self.git_stdout(&["rev-parse", "--git-common-dir"]);
+        let worktree_root = self.path().join(common_dir).join("naome").join("worktrees");
+        fs::create_dir_all(&worktree_root).unwrap();
+        for index in 0..count {
+            fs::create_dir_all(worktree_root.join(format!("stale-{index}"))).unwrap();
+        }
+    }
+
+    pub fn head_commit_paths(&self) -> String {
+        self.git_stdout(&["show", "--name-only", "--format=", "HEAD"])
+    }
+
+    pub fn write_implementing_task_state(&self, allowed_path: &str, check_id: &str) {
+        self.write_naome_json(
+            "task-state.json",
+            json!({
+                "status": "implementing",
+                "activeTask": {
+                    "id": "rust-task",
+                    "allowedPaths": [allowed_path],
+                    "requiredCheckIds": [check_id],
+                    "proofResults": []
+                }
+            }),
+        );
+    }
+
+    pub fn write_current_harness_refresh(&self) {
+        self.write_file("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
+        self.write_harness_manifest("standard");
+    }
+
+    pub fn write_harness_manifest(&self, profile: &str) {
+        self.write_naome_json(
+            "manifest.json",
+            json!({
+                "name": "naome",
+                "harnessVersion": "1.1.0",
+                "profile": profile,
+                "machineOwned": ["AGENTS.md"],
+                "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
+                "integrity": {}
+            }),
+        );
+    }
+}
+
+fn quality_limits_fixture() -> &'static str {
+    r#"{
+  "schema": "naome.repository-quality.v1",
+  "version": 1,
+  "status": "ready",
+  "limits": {
+    "maxFileLines": 5,
+    "maxNewFileLines": 5,
+    "maxDiffAddedLines": 200,
+    "maxFunctionLines": 40,
+    "maxTopLevelSymbols": 30,
+    "duplicateBlockLines": 4,
+    "nearDuplicateSimilarity": 0.9
+  },
+  "disabledChecks": [],
+  "ignoredPaths": [],
+  "generatedPaths": []
+}
+"#
+}

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

@@ -0,0 +1,81 @@
+use std::path::Path;
+
+use naome_core::{evaluate_route, EvaluationOptions, NaomeError, RouteDecision, RouteOptions};
+
+use super::TestRepo;
+
+const NEW_README_TASK_PROMPT: &str = "Add another line to README as a new task.";
+
+pub fn route_commit_request(repo: &TestRepo) -> RouteDecision {
+    evaluate_route(
+        repo.path(),
+        "commit my changes",
+        RouteOptions {
+            execute: true,
+            evaluation: EvaluationOptions::offline(),
+        },
+    )
+    .unwrap()
+}
+
+pub fn route_new_task(repo: &TestRepo, prompt: &str, execute: bool) -> RouteDecision {
+    try_route_new_task(repo, prompt, execute).unwrap()
+}
+
+pub fn try_route_new_task(
+    repo: &TestRepo,
+    prompt: &str,
+    execute: bool,
+) -> Result<RouteDecision, NaomeError> {
+    evaluate_route(
+        repo.path(),
+        prompt,
+        RouteOptions {
+            execute,
+            evaluation: EvaluationOptions::offline(),
+        },
+    )
+}
+
+pub fn route_readme_task(repo: &TestRepo, execute: bool) -> RouteDecision {
+    route_new_task(repo, NEW_README_TASK_PROMPT, execute)
+}
+
+pub fn try_route_readme_task(repo: &TestRepo, execute: bool) -> Result<RouteDecision, NaomeError> {
+    try_route_new_task(repo, NEW_README_TASK_PROMPT, execute)
+}
+
+pub fn assert_isolated_worktree_ready(route: &RouteDecision, repo: &TestRepo, status: &str) {
+    assert!(route.can_create_task);
+    assert_eq!(route.next_decision.state, "ready_for_task");
+    assert!(route.worktree.is_some());
+    assert_eq!(repo.git_status_short(), status);
+    assert_eq!(
+        TestRepo::git_status_short_at(Path::new(&route.task_root)),
+        ""
+    );
+}
+
+pub fn assert_commit_paths(repo: &TestRepo, present: &[&str], absent: &[&str]) {
+    let committed_paths = repo.head_commit_paths();
+    for path in present {
+        assert!(committed_paths.contains(path));
+    }
+    for path in absent {
+        assert!(!committed_paths.contains(path));
+    }
+}
+
+pub fn assert_user_diff_committed(route: &RouteDecision, repo: &TestRepo) {
+    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
+    assert!(route.allowed);
+    assert!(route.mutation_performed);
+    assert_eq!(
+        route.executed_actions,
+        vec![
+            "run_user_diff_quality_gate".to_string(),
+            "commit_user_diff".to_string()
+        ]
+    );
+    assert_eq!(repo.git_status_short(), "");
+}