@lamentis/naome 1.4.1 → 1.4.3

package/crates/naome-cli/tests/task_cli_fast_flow.rs

@@ -0,0 +1,290 @@
+use std::fs;
+use std::process::Command;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{
+    active_task, fixture_root, git, init_git, run_json, task_state, task_state_with_active_task,
+    write_fixture_file, write_json,
+};
+
+#[test]
+fn agent_snapshot_reports_missing_proof_and_safe_commands() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["schema"], "naome.task.agent-snapshot.v1");
+    assert_eq!(snapshot["proof"]["missingChecks"], json!(["diff-check"]));
+    assert_eq!(snapshot["nextAction"]["type"], "run_checks");
+    assert_eq!(snapshot["checks"]["safeToRun"][0]["checkId"], "diff-check");
+}
+
+#[test]
+fn preflight_reports_path_policy_and_check_plan() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["scripts/*.js"],
+        "proofResults": []
+    }))));
+    fs::write(
+        root.join(".naomeignore"),
+        ".naome/archive/\n.naome/tasks/\ndist/\n",
+    )
+    .unwrap();
+    init_git(&root);
+
+    let allowed = run_json(
+        &root,
+        ["task", "preflight", "--path", "scripts/check.js", "--json"],
+    );
+    assert_eq!(allowed["paths"][0]["editable"], true);
+    assert_eq!(allowed["paths"][0]["risk"], "medium");
+
+    let ignored = run_json(
+        &root,
+        ["task", "preflight", "--path", "dist/bundle.js", "--json"],
+    );
+    assert_eq!(ignored["paths"][0]["editable"], false);
+    assert_eq!(ignored["findings"][0]["id"], "task.preflight.ignored_path");
+
+    let traversal = run_json(
+        &root,
+        ["task", "preflight", "--path", "..\\outside.js", "--json"],
+    );
+    assert_eq!(traversal["paths"][0]["editable"], false);
+    assert_eq!(traversal["findings"][0]["id"], "task.preflight.unsafe_path");
+
+    let control = run_json(
+        &root,
+        ["task", "preflight", "--path", ".naomeignore", "--json"],
+    );
+    assert_eq!(control["paths"][0]["editable"], false);
+    assert_eq!(control["findings"][0]["id"], "task.preflight.control_path");
+}
+
+#[test]
+fn preflight_blocks_when_no_target_paths_are_selected() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+
+    let preflight = run_json(&root, ["task", "preflight", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.preflight.v1");
+    assert_eq!(
+        preflight["findings"][0]["id"],
+        "task.preflight.missing_target_paths"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["safeToExecute"], false);
+}
+
+#[test]
+fn preflight_from_changed_allows_clean_changed_set() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    git(&root, ["add", ".naome/task-state.json"]);
+    git(&root, ["commit", "-m", "record admission head"]);
+
+    let preflight = run_json(&root, ["task", "preflight", "--from-changed", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.preflight.v1");
+    assert!(preflight["findings"].as_array().unwrap().is_empty());
+    assert_eq!(preflight["paths"], json!([]));
+    assert_eq!(preflight["nextAction"]["type"], "edit");
+}
+
+#[test]
+fn commit_preflight_blocks_missing_proof() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.commit-preflight.v1");
+    assert_eq!(preflight["wouldPass"], false);
+    assert_eq!(
+        preflight["blockingFindings"][0]["id"],
+        "task.proof.missing_check"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "rerun_checks");
+    assert_eq!(preflight["nextAction"]["checkIds"], json!(["diff-check"]));
+}
+
+#[test]
+fn agent_snapshot_prefers_commit_ready_over_more_editing() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        [
+            "task",
+            "run-check",
+            "--check",
+            "diff-check",
+            "--record-proof",
+            "--json",
+        ],
+    );
+    assert_eq!(checked["recordedProof"], true);
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["commit"]["canCommit"], true);
+    assert_eq!(snapshot["nextAction"]["type"], "commit_ready");
+    assert_eq!(snapshot["nextAction"]["safeToExecute"], false);
+}
+
+#[test]
+fn commit_preflight_surfaces_transition_blocker_action_and_exit_code() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": [],
+        "humanReview": {
+            "required": true,
+            "approved": false,
+            "reason": "Release owner approval required."
+        },
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+
+    assert_eq!(preflight["wouldPass"], false);
+    assert_eq!(
+        preflight["blockingFindings"][0]["id"],
+        "task.transition.human_review_required"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["safeToExecute"], false);
+
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "commit-preflight", "--json", "--exit-code"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(1));
+}
+
+#[test]
+fn compact_proof_dry_run_and_write_remove_verbose_fields() {
+    let root = fixture_root(task_state());
+    let path = root.join(".naome/task-state.json");
+    let mut state: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+    state["activeTask"]["proofPathSets"] = json!({ "current": ["README.md"] });
+    state["activeTask"]["proofBatches"] = json!([{
+        "id": "batch",
+        "checkedAt": "2026-05-14T00:00:00.000Z",
+        "evidencePathSet": "current",
+        "proofs": [{
+            "checkId": "diff-check",
+            "command": "git diff --check",
+            "cwd": ".",
+            "exitCode": 0,
+            "evidenceFingerprint": "fnv64:test",
+            "stdoutSummary": "large",
+            "stderrSummary": "large",
+            "durationMs": 42
+        }]
+    }]);
+    write_json(&root, ".naome/task-state.json", &state);
+
+    let dry = run_json(&root, ["task", "compact-proof", "--dry-run", "--json"]);
+    assert_eq!(dry["dryRun"], true);
+    assert_eq!(dry["removedVerboseFields"], 3);
+    let unchanged = fs::read_to_string(&path).unwrap();
+    assert!(unchanged.contains("stdoutSummary"));
+
+    let compacted = run_json(&root, ["task", "compact-proof", "--json"]);
+    assert_eq!(compacted["compacted"], true);
+    let changed = fs::read_to_string(&path).unwrap();
+    assert!(!changed.contains("stdoutSummary"));
+    assert!(changed.contains("evidenceFingerprint"));
+}
+
+#[test]
+fn record_proof_rejects_task_and_path_mismatched_receipts() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["README.md", "docs/**"],
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        ["task", "run-check", "--check", "diff-check", "--json"],
+    );
+    assert_eq!(checked["exitCode"], 0);
+
+    let mut state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    state["activeTask"]["id"] = json!("different-task");
+    write_json(&root, ".naome/task-state.json", &state);
+    let task_mismatch = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+    assert_eq!(
+        task_mismatch["findings"][0]["id"],
+        "task.proof.receipt_task_mismatch"
+    );
+
+    state["activeTask"]["id"] = json!("cli-task");
+    write_json(&root, ".naome/task-state.json", &state);
+    write_fixture_file(&root, "docs/new.md", "new\n");
+    let path_mismatch = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+    assert_eq!(
+        path_mismatch["findings"][0]["id"],
+        "task.proof.receipt_path_mismatch"
+    );
+}
+
+#[test]
+fn scope_suggestions_reports_test_support_helpers() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["scripts/**"],
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "scripts/new-flow.test.js", "test('x', () => {});\n");
+
+    let suggestions = run_json(
+        &root,
+        ["task", "scope-suggestions", "--from-changed", "--json"],
+    );
+
+    assert_eq!(suggestions["schema"], "naome.task.scope-suggestions.v1");
+    assert!(suggestions["suggestions"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|suggestion| suggestion["path"] == "scripts/naome-installer-support.js"));
+}
+
+#[test]
+fn commit_preflight_exit_code_reports_blocker() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "commit-preflight", "--json", "--exit-code"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(10));
+}

package/crates/naome-cli/tests/task_cli_loop.rs

@@ -0,0 +1,383 @@
+use std::fs;
+use std::process::Command;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{
+    active_task, fixture_root, git, init_git, run_json, task_state, task_state_with_active_task,
+    write_fixture_file, write_verification_checks,
+};
+
+#[test]
+fn run_check_rejects_unknown_and_records_successful_safe_checks() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let unknown = run_json(&root, ["task", "run-check", "--check", "missing", "--json"]);
+    assert_eq!(unknown["schema"], "naome.task.run-check.v1");
+    assert_eq!(unknown["executed"], false);
+    assert_eq!(unknown["findings"][0]["id"], "task.check.unknown");
+
+    let result = run_json(
+        &root,
+        [
+            "task",
+            "run-check",
+            "--check",
+            "diff-check",
+            "--record-proof",
+            "--json",
+            "--agent-session",
+            "loop-a",
+        ],
+    );
+    assert_eq!(result["executed"], true);
+    assert_eq!(result["exitCode"], 0);
+    assert_eq!(result["recordedProof"], true);
+    assert_eq!(result["agentSession"], "loop-a");
+
+    let task_state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    assert_eq!(
+        task_state["activeTask"]["proofBatches"][0]["proofs"][0]["agentSession"],
+        "loop-a"
+    );
+    assert_eq!(
+        task_state["activeTask"]["proofBatches"][0]["proofs"][0]["command"],
+        "git diff --check"
+    );
+    assert_eq!(
+        task_state["activeTask"]["proofBatches"][0]["proofs"][0]["cwd"],
+        "."
+    );
+}
+
+#[test]
+fn record_proof_requires_recent_success_evidence() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let recorded = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+
+    assert_eq!(recorded["recorded"], false);
+    assert_eq!(
+        recorded["findings"][0]["id"],
+        "task.proof.no_recent_success"
+    );
+}
+
+#[test]
+fn record_proof_rejects_receipts_from_older_same_path_content() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        ["task", "run-check", "--check", "diff-check", "--json"],
+    );
+    assert_eq!(checked["executed"], true);
+    assert_eq!(checked["exitCode"], 0);
+
+    write_fixture_file(&root, "README.md", "changed with trailing whitespace \n");
+    let recorded = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+
+    assert_eq!(recorded["recorded"], false);
+    assert_eq!(
+        recorded["findings"][0]["id"],
+        "task.proof.stale_receipt_content"
+    );
+}
+
+#[test]
+fn record_proof_rejects_receipts_from_old_check_metadata() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        ["task", "run-check", "--check", "diff-check", "--json"],
+    );
+    assert_eq!(checked["executed"], true);
+    assert_eq!(checked["exitCode"], 0);
+
+    write_verification_checks(
+        &root,
+        json!([{
+            "id": "diff-check",
+            "command": "node .naome/bin/naome.js quality check --changed",
+            "cwd": ".",
+            "purpose": "Updated check command.",
+            "cost": "fast",
+            "source": "test",
+            "evidence": ["README.md"],
+            "lastVerified": null
+        }]),
+    );
+    git(&root, ["add", ".naome/verification.json"]);
+    git(&root, ["commit", "-m", "update verification metadata"]);
+
+    let recorded = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+
+    assert_eq!(recorded["recorded"], false);
+    assert_eq!(
+        recorded["findings"][0]["id"],
+        "task.proof.no_recent_success"
+    );
+}
+
+#[test]
+fn run_check_diff_check_covers_staged_diff() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "staged trailing whitespace \n");
+    git(&root, ["add", "README.md"]);
+
+    let result = run_json(
+        &root,
+        [
+            "task",
+            "run-check",
+            "--check",
+            "diff-check",
+            "--record-proof",
+            "--json",
+        ],
+    );
+
+    assert_eq!(result["executed"], true);
+    assert_ne!(result["exitCode"], 0);
+    assert_eq!(result["recordedProof"], false);
+    assert!(result["stdoutSummary"]
+        .as_str()
+        .is_some_and(|summary| summary.contains("trailing whitespace")));
+}
+
+#[test]
+fn repair_execute_safe_runs_checks_but_refuses_scope_repairs() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+    write_fixture_file(&root, "src/lib.rs", "outside\n");
+
+    let scope = run_json(
+        &root,
+        [
+            "task",
+            "repair",
+            "--plan",
+            "remove_out_of_scope_change_src_lib_rs",
+            "--execute-safe",
+            "--json",
+        ],
+    );
+    assert_eq!(scope["executed"], false);
+    assert_eq!(scope["requiresUserApproval"], true);
+
+    fs::remove_file(root.join("src/lib.rs")).unwrap();
+    let check = run_json(
+        &root,
+        [
+            "task",
+            "repair",
+            "--plan",
+            "rerun_diff-check",
+            "--execute-safe",
+            "--json",
+        ],
+    );
+    assert_eq!(check["executed"], true);
+    assert_eq!(check["steps"][0]["schema"], "naome.task.run-check.v1");
+}
+
+#[test]
+fn repair_execute_safe_rejects_dry_run_combo_and_unsafe_check_plans() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": ["unsafe-check"],
+        "proofResults": []
+    }))));
+    write_verification_checks(
+        &root,
+        json!([{
+                "id": "unsafe-check",
+                "command": "sh -c 'echo unsafe'",
+                "cwd": ".",
+                "purpose": "Unsafe check for repair planning tests.",
+                "cost": "fast",
+                "source": "test",
+                "evidence": ["README.md"],
+                "lastVerified": null
+        }]),
+    );
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let combo = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args([
+            "task",
+            "repair",
+            "--plan",
+            "rerun_unsafe-check",
+            "--dry-run",
+            "--execute-safe",
+            "--json",
+        ])
+        .current_dir(&root)
+        .output()
+        .unwrap();
+    assert!(!combo.status.success());
+    assert!(String::from_utf8_lossy(&combo.stderr).contains("--dry-run"));
+
+    let unsafe_repair = run_json(
+        &root,
+        [
+            "task",
+            "repair",
+            "--plan",
+            "rerun_unsafe-check",
+            "--execute-safe",
+            "--json",
+        ],
+    );
+    assert_eq!(unsafe_repair["executed"], false);
+    assert_eq!(unsafe_repair["requiresUserApproval"], true);
+    assert!(unsafe_repair["steps"].as_array().unwrap().is_empty());
+}
+
+#[test]
+fn run_check_rejects_changed_npm_scripts_from_safe_execution() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": ["task-state-tests"],
+        "allowedPaths": ["package.json"],
+        "proofResults": []
+    }))));
+    write_verification_checks(
+        &root,
+        json!([{
+            "id": "task-state-tests",
+            "command": "npm run test:task-state",
+            "cwd": ".",
+            "purpose": "Task-state regression tests.",
+            "cost": "medium",
+            "source": "test",
+            "evidence": ["package.json"],
+            "lastVerified": null
+        }]),
+    );
+    init_git(&root);
+    write_fixture_file(
+        &root,
+        "package.json",
+        r#"{"scripts":{"test:task-state":"node -e \"process.exit(0)\"}}"#,
+    );
+
+    let result = run_json(
+        &root,
+        ["task", "run-check", "--check", "task-state-tests", "--json"],
+    );
+
+    assert_eq!(result["executed"], false);
+    assert_eq!(result["findings"][0]["id"], "task.check.unsafe_command");
+}
+
+#[test]
+fn run_check_rejects_pack_dry_run_as_not_read_only() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": ["package-dry-run"],
+        "proofResults": []
+    }))));
+    write_verification_checks(
+        &root,
+        json!([{
+            "id": "package-dry-run",
+            "command": "npm run pack:dry-run",
+            "cwd": ".",
+            "purpose": "Package dry run.",
+            "cost": "medium",
+            "source": "test",
+            "evidence": ["README.md"],
+            "lastVerified": null
+        }]),
+    );
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let result = run_json(
+        &root,
+        ["task", "run-check", "--check", "package-dry-run", "--json"],
+    );
+
+    assert_eq!(result["executed"], false);
+    assert_eq!(result["findings"][0]["id"], "task.check.unsafe_command");
+}
+
+#[test]
+fn task_loop_read_only_and_execute_safe_drive_proof_to_completion() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let read_only = run_json(&root, ["task", "loop", "--json"]);
+    assert_eq!(read_only["schema"], "naome.task.loop.v1");
+    assert_eq!(read_only["mode"], "read_only");
+    assert!(read_only["executedSteps"].as_array().unwrap().is_empty());
+    assert_eq!(
+        read_only["status"]["proof"]["missingChecks"],
+        json!(["diff-check"])
+    );
+
+    let executed = run_json(&root, ["task", "loop", "--execute-safe", "--json"]);
+    assert_eq!(executed["mode"], "execute_safe");
+    assert_eq!(
+        executed["executedSteps"][0]["schema"],
+        "naome.task.run-check.v1"
+    );
+    assert_eq!(executed["executedSteps"][0]["recordedProof"], true);
+
+    let completed = run_json(
+        &root,
+        ["task", "complete", "--from-can-transition", "--json"],
+    );
+    assert_eq!(completed["schema"], "naome.task.complete.v1");
+    assert_eq!(completed["completed"], true);
+
+    let state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    assert_eq!(state["status"], "complete");
+}
+
+#[test]
+fn complete_blocks_when_transition_is_not_allowed() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let completed = run_json(
+        &root,
+        ["task", "complete", "--from-can-transition", "--json"],
+    );
+
+    assert_eq!(completed["completed"], false);
+    assert_eq!(
+        completed["blockingFindings"][0]["id"],
+        "task.proof.missing_check"
+    );
+}