@lamentis/naome 1.1.2 → 1.2.1

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

@@ -0,0 +1,130 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{validate_task_state, TaskStateMode, TaskStateOptions};
+use serde_json::{json, Value};
+
+static REPO_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+pub struct MiniRepo {
+    root: PathBuf,
+}
+
+impl MiniRepo {
+    pub fn new() -> Self {
+        let stamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = REPO_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let root = std::env::temp_dir().join(format!("naome-compact-proof-{stamp}-{counter}"));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        let repo = Self { root };
+        repo.git(["init"]);
+        repo.git(["config", "user.email", "compact@example.test"]);
+        repo.git(["config", "user.name", "Compact Proof"]);
+        repo
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn seed(&self) -> String {
+        fs::write(self.root.join(".naomeignore"), "").unwrap();
+        fs::write(self.root.join("README.md"), "before\n").unwrap();
+        fs::write(
+            self.root.join(".naome/init-state.json"),
+            json_text(json!({
+                "schema": "naome.init-state.v1",
+                "version": 1,
+                "initialized": true,
+                "intakeStatus": "complete"
+            })),
+        )
+        .unwrap();
+        fs::write(
+            self.root.join(".naome/upgrade-state.json"),
+            json_text(json!({
+                "schema": "naome.upgrade-state.v1",
+                "version": 1,
+                "status": "complete",
+                "fromVersion": "1.1.2",
+                "toVersion": "1.2.1",
+                "pending": [],
+                "completed": []
+            })),
+        )
+        .unwrap();
+        fs::write(
+            self.root.join(".naome/verification.json"),
+            json_text(verification_contract()),
+        )
+        .unwrap();
+        self.git(["add", "."]);
+        self.git(["commit", "-m", "seed"]);
+        self.git_stdout(["rev-parse", "HEAD"])
+    }
+
+    pub fn change_readme(&self) {
+        fs::write(self.root.join("README.md"), "after\n").unwrap();
+    }
+
+    pub fn write_task_state(&self, state: Value) {
+        fs::write(self.root.join(".naome/task-state.json"), json_text(state)).unwrap();
+    }
+
+    pub fn validate(&self, mode: TaskStateMode) -> naome_core::TaskStateReport {
+        validate_task_state(
+            &self.root,
+            TaskStateOptions {
+                mode,
+                harness_health: None,
+            },
+        )
+        .unwrap()
+    }
+
+    pub fn git<const N: usize>(&self, args: [&str; N]) {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "{}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    fn git_stdout<const N: usize>(&self, args: [&str; N]) -> 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()
+    }
+}
+
+fn verification_contract() -> Value {
+    json!({
+        "schema": "naome.verification.v1",
+        "version": 1,
+        "status": "ready",
+        "checks": [
+            { "id": "alpha", "command": "npm run alpha", "cwd": ".", "evidence": ["README.md"] },
+            { "id": "beta", "command": "npm run beta", "cwd": ".", "evidence": ["README.md"] }
+        ],
+        "changeTypes": []
+    })
+}
+
+fn json_text(value: Value) -> String {
+    format!("{}\n", serde_json::to_string_pretty(&value).unwrap())
+}

package/crates/naome-core/tests/task_state_compact_support/states.rs

@@ -0,0 +1,151 @@
+use serde_json::{json, Value};
+
+const T0: &str = "2026-05-07T00:00:00.000Z";
+
+pub fn compact_state(admission_head: &str) -> Value {
+    base_state(
+        admission_head,
+        json!({
+            "proofPathSets": {
+                "changed-readme": ["README.md"]
+            },
+            "proofBatches": [
+                {
+                    "checkedAt": T0,
+                    "evidencePathSet": "changed-readme",
+                    "proofs": [
+                        {
+                            "checkId": "alpha",
+                            "exitCode": 0
+                        },
+                        {
+                            "checkId": "beta",
+                            "command": "npm run beta -- --changed README.md",
+                            "cwd": "tools",
+                            "exitCode": 0
+                        }
+                    ]
+                }
+            ]
+        }),
+    )
+}
+
+pub fn legacy_state(admission_head: &str) -> Value {
+    let mut state = base_state(
+        admission_head,
+        json!({
+            "proofResults": [
+                proof("alpha", "npm run alpha", "."),
+                proof("beta", "npm run beta", ".")
+            ]
+        }),
+    );
+    state["schema"] = json!("naome.task-state.v1");
+    state["version"] = json!(1);
+    state
+}
+
+pub fn large_compact_state(admission_head: &str) -> Value {
+    let evidence: Vec<Value> = (0..12)
+        .map(|index| json!(format!("src/module_{index}.rs")))
+        .collect();
+    let proofs: Vec<Value> = (0..8)
+        .map(|index| {
+            json!({
+                "checkId": format!("check-{index}"),
+                "exitCode": 0
+            })
+        })
+        .collect();
+    base_state(
+        admission_head,
+        json!({
+            "proofPathSets": {
+                "large-change": evidence
+            },
+            "proofBatches": [
+                {
+                    "checkedAt": T0,
+                    "command": "cargo test",
+                    "cwd": ".",
+                    "evidencePathSet": "large-change",
+                    "proofs": proofs
+                }
+            ]
+        }),
+    )
+}
+
+pub fn large_expanded_state(admission_head: &str) -> Value {
+    let evidence: Vec<Value> = (0..12)
+        .map(|index| json!(format!("src/module_{index}.rs")))
+        .collect();
+    let proofs: Vec<Value> = (0..8)
+        .map(|index| {
+            json!({
+                "checkId": format!("check-{index}"),
+                "command": "cargo test",
+                "cwd": ".",
+                "exitCode": 0,
+                "checkedAt": T0,
+                "evidence": evidence
+            })
+        })
+        .collect();
+    base_state(
+        admission_head,
+        json!({
+            "proofResults": proofs
+        }),
+    )
+}
+
+fn base_state(admission_head: &str, proof_payload: Value) -> Value {
+    let mut task = json!({
+        "id": "compact-proof",
+        "request": "Update README.",
+        "userPrompt": {
+            "receivedAt": T0,
+            "text": "Update README."
+        },
+        "admission": {
+            "command": "node .naome/bin/check-task-state.js --admission",
+            "cwd": ".",
+            "exitCode": 0,
+            "checkedAt": T0,
+            "gitHead": admission_head,
+            "changedPaths": []
+        },
+        "allowedPaths": ["README.md"],
+        "declaredChangeTypes": ["docs"],
+        "requiredCheckIds": ["alpha", "beta"],
+        "humanReview": {
+            "required": false,
+            "approved": false,
+            "reason": null
+        }
+    });
+    task.as_object_mut()
+        .unwrap()
+        .extend(proof_payload.as_object().unwrap().clone());
+    json!({
+        "schema": "naome.task-state.v2",
+        "version": 2,
+        "status": "complete",
+        "activeTask": task,
+        "blocker": null,
+        "updatedAt": T0
+    })
+}
+
+fn proof(check_id: &str, command: &str, cwd: &str) -> Value {
+    json!({
+        "checkId": check_id,
+        "command": command,
+        "cwd": cwd,
+        "exitCode": 0,
+        "checkedAt": T0,
+        "evidence": ["README.md"]
+    })
+}

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

@@ -0,0 +1,163 @@
+mod states;
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{HarnessHealthOptions, MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS};
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+pub use states::{
+    active_task, complete_task_state, idle_task_state, successful_admission, successful_proof,
+};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub struct TaskFixture {
+    root: PathBuf,
+}
+
+impl TaskFixture {
+    pub fn new(task_state: Value) -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed);
+        let root = std::env::temp_dir().join(format!(
+            "naome-task-state-rust-{}-{nonce}-{counter}",
+            std::process::id()
+        ));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        write_json(&root, ".naome/task-state.json", task_state);
+        write_json(&root, ".naome/init-state.json", init_state());
+        write_json(&root, ".naome/upgrade-state.json", upgrade_state());
+        write_json(&root, ".naome/verification.json", verification_state());
+        Self { root }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn write(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        fs::write(path, content).unwrap();
+    }
+
+    pub fn write_json(&self, relative_path: &str, value: Value) {
+        write_json(&self.root, relative_path, value);
+    }
+
+    pub fn install_healthy_harness(&self) -> HashMap<String, String> {
+        let mut integrity = HashMap::new();
+        for relative_path in MACHINE_OWNED_PATHS {
+            let content = machine_content(relative_path);
+            self.write(relative_path, &content);
+            let digest = Sha256::digest(content.as_bytes());
+            integrity.insert((*relative_path).to_string(), format!("sha256:{digest:x}"));
+        }
+        for relative_path in PROJECT_OWNED_PATHS {
+            let path = self.root.join(relative_path);
+            if *relative_path == ".naome/manifest.json" || path.exists() {
+                continue;
+            }
+            let content = if *relative_path == ".naomeignore" {
+                ".naome/archive/\n".to_string()
+            } else {
+                format!("# {relative_path}\n")
+            };
+            self.write(relative_path, &content);
+        }
+        fs::create_dir_all(self.root.join(".naome/archive")).unwrap();
+        self.write_json(".naome/manifest.json", manifest_state(integrity.clone()));
+        integrity
+    }
+
+    pub fn init_git(&self) {
+        self.git(["init"]);
+        self.git(["config", "user.email", "naome@example.com"]);
+        self.git(["config", "user.name", "NAOME Test"]);
+        self.git(["add", "."]);
+        self.git(["commit", "-m", "baseline"]);
+        self.refresh_admission_head();
+    }
+
+    pub fn git<const N: usize>(&self, args: [&str; N]) -> String {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "{}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        String::from_utf8_lossy(&output.stdout).to_string()
+    }
+
+    fn refresh_admission_head(&self) {
+        let path = self.root.join(".naome/task-state.json");
+        let mut task_state: Value =
+            serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+        let Some(admission) = task_state
+            .get_mut("activeTask")
+            .and_then(|task| task.get_mut("admission"))
+        else {
+            return;
+        };
+        admission["gitHead"] = Value::String(self.git(["rev-parse", "HEAD"]).trim().to_string());
+        fs::write(
+            path,
+            format!("{}\n", serde_json::to_string_pretty(&task_state).unwrap()),
+        )
+        .unwrap();
+    }
+}
+
+pub fn strict_health_options(expected_integrity: HashMap<String, String>) -> HarnessHealthOptions {
+    HarnessHealthOptions {
+        expected_integrity,
+        allow_missing_integrity: false,
+        allow_missing_archive: false,
+    }
+}
+
+pub fn write_json(root: &Path, relative_path: &str, value: Value) {
+    let path = root.join(relative_path);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(
+        path,
+        format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
+    )
+    .unwrap();
+}
+
+fn machine_content(relative_path: &str) -> String {
+    match relative_path {
+        "AGENTS.md" => "# Agent Instructions\nRun node .naome/bin/check-task-state.js --admission before task work.\n".to_string(),
+        ".naome/package.json" => format!("{}\n", json!({ "type": "commonjs" })),
+        _ => format!("# {relative_path}\n"),
+    }
+}
+
+fn init_state() -> Value {
+    json!({ "initialized": true, "intakeStatus": "complete", "initializedAt": "2026-05-04T12:00:00.000Z", "initializedBy": "naome-test", "blockedReason": null, "requiredDocs": [] })
+}
+
+fn upgrade_state() -> Value {
+    json!({ "status": "complete", "fromVersion": null, "toVersion": "0.6.1", "pending": [], "completed": [] })
+}
+
+fn verification_state() -> Value {
+    json!({ "schema": "naome.verification.v1", "version": 1, "status": "ready", "lastUpdated": "2026-05-04", "checks": [{ "id": "diff-check", "command": "git diff --check", "cwd": ".", "purpose": "Detect whitespace and patch formatting issues.", "cost": "fast", "source": "git", "evidence": ["README.md"], "lastVerified": "2026-05-04" }], "changeTypes": [], "releaseGates": [] })
+}
+
+fn manifest_state(integrity: HashMap<String, String>) -> Value {
+    json!({ "name": "naome", "harnessVersion": "0.6.1", "profile": "standard", "installedAt": "2026-05-05T00:00:00.000Z", "machineOwned": MACHINE_OWNED_PATHS, "projectOwned": PROJECT_OWNED_PATHS, "integrity": integrity })
+}

package/crates/naome-core/tests/task_state_support/states.rs

@@ -0,0 +1,84 @@
+use serde_json::{json, Value};
+
+pub fn idle_task_state() -> Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "idle",
+        "activeTask": null,
+        "blocker": null,
+        "updatedAt": null
+    })
+}
+
+pub fn complete_task_state(overrides: Value) -> Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "complete",
+        "activeTask": active_task(overrides),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    })
+}
+
+pub fn active_task(overrides: Value) -> Value {
+    let mut task = json!({
+        "id": "readme-test",
+        "request": "Update the README.",
+        "userPrompt": {
+            "receivedAt": "2026-05-04T12:00:00.000Z",
+            "text": "Update the README."
+        },
+        "admission": successful_admission(json!({})),
+        "allowedPaths": ["README.md"],
+        "declaredChangeTypes": ["docs"],
+        "requiredCheckIds": ["diff-check"],
+        "proofResults": [],
+        "humanReview": {
+            "required": false,
+            "approved": false,
+            "reason": null
+        }
+    });
+    merge_object(&mut task, overrides);
+    task
+}
+
+pub fn successful_admission(overrides: Value) -> Value {
+    let mut admission = json!({
+        "command": "node .naome/bin/check-task-state.js --admission",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-04T12:00:00.000Z",
+        "gitHead": "pending-test-head",
+        "changedPaths": []
+    });
+    merge_object(&mut admission, overrides);
+    admission
+}
+
+pub fn successful_proof(overrides: Value) -> Value {
+    let mut proof = json!({
+        "checkId": "diff-check",
+        "command": "git diff --check",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-04T12:00:00.000Z",
+        "evidence": ["README.md"]
+    });
+    merge_object(&mut proof, overrides);
+    proof
+}
+
+fn merge_object(target: &mut Value, overrides: 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 {
+        target_object.insert(key.clone(), value.clone());
+    }
+}

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

@@ -1,10 +1,10 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
-
 use naome_core::seed_builtin_verification_checks;
 use serde_json::json;
 
+mod repo_support;
+
+use repo_support::TestRepo;
+
 #[test]
 fn seeds_builtin_checks_without_removing_repo_specific_checks() {
     let repo = TestRepo::new("verification-seed");
@@ -122,44 +122,3 @@ fn check_command<'a>(verification: &'a serde_json::Value, check_id: &str) -> Opt
         .get("command")?
         .as_str()
 }
-
-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_naome_json(&self, file_name: &str, value: serde_json::Value) {
-        fs::write(
-            self.root.join(".naome").join(file_name),
-            format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
-        )
-        .unwrap();
-    }
-
-    fn write_naome_file(&self, file_name: &str, content: &str) {
-        fs::write(self.root.join(".naome").join(file_name), content).unwrap();
-    }
-
-    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()
-    }
-
-    fn read_naome_file(&self, file_name: &str) -> String {
-        fs::read_to_string(self.root.join(".naome").join(file_name)).unwrap()
-    }
-}