@lamentis/naome 1.1.2 → 1.2.1

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(), "");
+}

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

@@ -0,0 +1,168 @@
+use serde_json::{json, Value};
+
+use super::repo::TestRepo;
+use super::verification_values::{
+    change_type, diff_check, mutating_diff_check, repository_quality_check, verification_value,
+};
+
+impl TestRepo {
+    pub fn write_base_naome_state(&self, task_state: serde_json::Value) {
+        self.write_naome_json(
+            "init-state.json",
+            json!({ "initialized": true, "intakeStatus": "complete" }),
+        );
+        self.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+        self.write_naome_json(
+            "verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "checks": [diff_check(vec!["README.md"])],
+                "changeTypes": [],
+                "releaseGates": []
+            }),
+        );
+        self.write_naome_json("task-state.json", task_state);
+    }
+
+    pub fn write_readme_quality_verification(
+        &self,
+        extra_checks: Vec<Value>,
+        required_checks: Vec<&str>,
+    ) {
+        let mut checks = vec![diff_check(vec!["README.md"])];
+        checks.extend(extra_checks);
+
+        self.write_naome_json(
+            "verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "checks": checks,
+                "changeTypes": [
+                    {
+                        "id": "readme",
+                        "description": "README changes.",
+                        "paths": ["README.md"],
+                        "requiredChecks": required_checks,
+                        "recommendedChecks": [],
+                        "humanReview": false
+                    }
+                ],
+                "releaseGates": []
+            }),
+        );
+    }
+
+    pub fn write_product_quality_verification(&self) {
+        self.write_naome_json(
+            "verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "checks": product_quality_checks(),
+                "changeTypes": [
+                    {
+                        "id": "product-installer-or-template",
+                        "description": "NAOME product changes.",
+                        "paths": ["packages/naome/**", "scripts/**"],
+                        "requiredChecks": [
+                            "installer-tests",
+                            "rust-build",
+                            "decision-engine-tests",
+                            "package-dry-run"
+                        ],
+                        "recommendedChecks": [],
+                        "humanReview": false
+                    }
+                ],
+                "releaseGates": []
+            }),
+        );
+    }
+
+    pub fn write_source_quality_verification(&self) {
+        self.write_naome_json(
+            "verification.json",
+            verification_value(
+                "ready",
+                vec![repository_quality_check()],
+                vec![change_type(
+                    "source",
+                    "Source changes.",
+                    vec!["src/**"],
+                    vec!["repository-quality-check"],
+                )],
+            ),
+        );
+    }
+
+    pub fn write_readme_rename_verification(&self) {
+        self.write_naome_json(
+            "verification.json",
+            verification_value(
+                "ready",
+                vec![diff_check(vec!["README.md", "INTRO.md"])],
+                vec![change_type(
+                    "docs",
+                    "Repository docs.",
+                    vec!["README.md", "INTRO.md"],
+                    vec!["diff-check"],
+                )],
+            ),
+        );
+    }
+
+    pub fn write_unsafe_readme_diff_verification(&self) {
+        self.write_naome_json(
+            "verification.json",
+            verification_value(
+                "ready",
+                vec![mutating_diff_check()],
+                vec![change_type(
+                    "readme",
+                    "README changes.",
+                    vec!["README.md"],
+                    vec!["diff-check"],
+                )],
+            ),
+        );
+    }
+}
+
+fn product_quality_checks() -> Vec<serde_json::Value> {
+    vec![
+        super::verification_values::quality_check(
+            "installer-tests",
+            "npm run test:naome-installer",
+            "Validate installer behavior.",
+            "medium",
+            vec!["scripts/naome-installer.test.js"],
+        ),
+        super::verification_values::quality_check(
+            "rust-build",
+            "npm run build:rust",
+            "Build native CLI.",
+            "medium",
+            vec!["packages/naome/Cargo.toml"],
+        ),
+        super::verification_values::quality_check(
+            "decision-engine-tests",
+            "npm run test:decision-engine",
+            "Validate route decisions.",
+            "fast",
+            vec!["packages/naome/crates/naome-core/tests/route.rs"],
+        ),
+        super::verification_values::quality_check(
+            "package-dry-run",
+            "npm run pack:dry-run",
+            "Validate package metadata.",
+            "medium",
+            vec!["packages/naome/package.json"],
+        ),
+        diff_check(vec!["packages/naome/crates/naome-core/src/route.rs"]),
+    ]
+}

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

@@ -0,0 +1,135 @@
+use serde_json::json;
+
+pub fn completed_task_state(admission_head: &str) -> serde_json::Value {
+    json!({
+        "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": admission_head,
+                "changedPaths": []
+            },
+            "allowedPaths": ["README.md"],
+            "declaredChangeTypes": ["product-docs"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": [
+                {
+                    "checkId": "diff-check",
+                    "command": "git diff --check",
+                    "cwd": ".",
+                    "exitCode": 0,
+                    "checkedAt": "2026-05-06T00:00:00.000Z",
+                    "evidence": ["README.md"]
+                }
+            ],
+            "revisions": [],
+            "humanReview": {
+                "required": false,
+                "approved": false,
+                "reason": null
+            }
+        },
+        "blocker": null,
+        "updatedAt": "2026-05-06T00:00:00.000Z"
+    })
+}
+
+pub fn diff_check(evidence: Vec<&str>) -> serde_json::Value {
+    json!({
+        "id": "diff-check",
+        "command": "git diff --check",
+        "cwd": ".",
+        "purpose": "Reject whitespace errors.",
+        "cost": "fast",
+        "source": "test",
+        "evidence": evidence,
+        "lastVerified": null
+    })
+}
+
+pub fn verification_value(
+    status: &str,
+    checks: Vec<serde_json::Value>,
+    change_types: Vec<serde_json::Value>,
+) -> serde_json::Value {
+    json!({
+        "schema": "naome.verification.v1",
+        "version": 1,
+        "status": status,
+        "checks": checks,
+        "changeTypes": change_types,
+        "releaseGates": []
+    })
+}
+
+pub fn change_type(
+    id: &str,
+    description: &str,
+    paths: Vec<&str>,
+    required_checks: Vec<&str>,
+) -> serde_json::Value {
+    json!({
+        "id": id,
+        "description": description,
+        "paths": paths,
+        "requiredChecks": required_checks,
+        "recommendedChecks": [],
+        "humanReview": false
+    })
+}
+
+pub fn quality_check(
+    id: &str,
+    command: &str,
+    purpose: &str,
+    cost: &str,
+    evidence: Vec<&str>,
+) -> serde_json::Value {
+    json!({
+        "id": id,
+        "command": command,
+        "cwd": ".",
+        "purpose": purpose,
+        "cost": cost,
+        "source": "test",
+        "evidence": evidence,
+        "lastVerified": null
+    })
+}
+
+pub fn repository_quality_check() -> serde_json::Value {
+    json!({
+        "id": "repository-quality-check",
+        "command": "naome quality check --changed",
+        "cwd": ".",
+        "purpose": "Validate changed files against repository quality rules.",
+        "cost": "fast",
+        "source": "NAOME built-in",
+        "evidence": ["src/**"],
+        "lastVerified": null
+    })
+}
+
+pub fn mutating_diff_check() -> serde_json::Value {
+    json!({
+        "id": "diff-check",
+        "command": "node -e \"const fs = require('fs'); const marker = '.git/naome-diff-check-marker'; if (fs.existsSync(marker)) { fs.writeFileSync('NEW.md', '# unexpected\\\\n'); } else { fs.writeFileSync(marker, 'x'); }\"",
+        "cwd": ".",
+        "purpose": "Simulate a mutating diff check.",
+        "cost": "fast",
+        "source": "test",
+        "evidence": ["README.md"],
+        "lastVerified": null
+    })
+}