@lamentis/naome 1.1.1 → 1.2.0

package/crates/naome-core/src/task_state/task_diff_api.rs

@@ -0,0 +1,170 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::harness_health::validate_harness_health;
+use crate::models::NaomeError;
+
+use super::completion::validate_complete_task_against_entries;
+use super::git_io::{read_git_changed_entries, read_git_changed_paths};
+use super::reconcile::{
+    is_packaged_machine_owned_path, is_repair_archive_path, is_safe_harness_refresh_path,
+};
+use super::shape::{
+    read_verification_check_ids, validate_active_task, validate_active_task_references,
+    validate_pending_upgrade, validate_required_check_ids, validate_task_state_shape,
+};
+use super::types::{
+    CompletedTaskCommitDiff, HarnessRefreshDiff, HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
+    CONTROL_STATE_PATH,
+};
+use super::util::{matches_any_pattern, read_json, string_array};
+
+pub fn completed_task_commit_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    Ok(completed_task_commit_diff(root)?
+        .map(|diff| diff.task_paths)
+        .unwrap_or_default())
+}
+
+pub fn completed_task_commit_diff(
+    root: &Path,
+) -> Result<Option<CompletedTaskCommitDiff>, NaomeError> {
+    let mut read_errors = Vec::new();
+    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut read_errors)? else {
+        return Ok(None);
+    };
+    if !read_errors.is_empty()
+        || task_state.get("status").and_then(Value::as_str) != Some("complete")
+    {
+        return Ok(None);
+    }
+    let Some(active_task) = task_state.get("activeTask") else {
+        return Ok(None);
+    };
+
+    let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
+    let mut task_entries = Vec::new();
+    let mut unrelated_paths = Vec::new();
+    for entry in read_git_changed_entries(root)? {
+        if entry.path == CONTROL_STATE_PATH || matches_any_pattern(&entry.path, &allowed_paths) {
+            task_entries.push(entry);
+        } else {
+            unrelated_paths.push(entry.path);
+        }
+    }
+
+    if task_entries.is_empty() {
+        return Ok(None);
+    }
+
+    let mut errors = Vec::new();
+    validate_task_state_shape(&task_state, &mut errors);
+    validate_active_task(Some(active_task), &mut errors);
+    validate_pending_upgrade(&task_state, root, &mut errors)?;
+    validate_active_task_references(Some(active_task), root, &mut errors, Some("complete"))?;
+    if !task_state.get("blocker").is_some_and(Value::is_null) {
+        errors.push("complete task state must have blocker set to null.".to_string());
+    }
+    let check_ids = read_verification_check_ids(root, &mut errors)?;
+    validate_required_check_ids(active_task, &check_ids, &mut errors);
+    validate_complete_task_against_entries(
+        active_task,
+        root,
+        &check_ids,
+        &task_entries,
+        &mut errors,
+    )?;
+    if !errors.is_empty() {
+        return Ok(None);
+    }
+
+    let mut task_paths: Vec<String> = task_entries
+        .into_iter()
+        .map(|entry| entry.path)
+        .collect::<HashSet<_>>()
+        .into_iter()
+        .collect();
+    task_paths.sort();
+    unrelated_paths.sort();
+
+    Ok(Some(CompletedTaskCommitDiff {
+        task_paths,
+        unrelated_paths,
+    }))
+}
+
+pub fn harness_refresh_diff(root: &Path) -> Result<Option<HarnessRefreshDiff>, NaomeError> {
+    let changed_paths = read_git_changed_paths(root)?;
+    let has_repair_signal = changed_paths
+        .iter()
+        .any(|path| is_packaged_machine_owned_path(path) || is_repair_archive_path(path));
+    if !has_repair_signal {
+        return Ok(None);
+    }
+
+    let mut harness_paths = Vec::new();
+    let mut unrelated_paths = Vec::new();
+
+    for path in changed_paths {
+        if is_safe_harness_refresh_path(&path) {
+            harness_paths.push(path);
+        } else {
+            unrelated_paths.push(path);
+        }
+    }
+
+    if harness_paths.is_empty() {
+        return Ok(None);
+    }
+
+    harness_paths.sort();
+    unrelated_paths.sort();
+
+    Ok(Some(HarnessRefreshDiff {
+        harness_paths,
+        unrelated_paths,
+    }))
+}
+
+pub fn harness_refresh_with_unrelated_diff(
+    root: &Path,
+) -> Result<Option<HarnessRefreshWithUnrelatedDiff>, NaomeError> {
+    let Some(diff) = harness_refresh_diff(root)? else {
+        return Ok(None);
+    };
+    if diff.unrelated_paths.is_empty() {
+        return Ok(None);
+    }
+
+    Ok(Some(HarnessRefreshWithUnrelatedDiff {
+        harness_paths: diff.harness_paths,
+        unrelated_paths: diff.unrelated_paths,
+    }))
+}
+
+pub(super) fn validate_harness_health_gate(
+    root: &Path,
+    options: &TaskStateOptions,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let Some(health_options) = options.harness_health.clone() else {
+        return Ok(());
+    };
+
+    let health_errors = validate_harness_health(root, health_options)?;
+    if health_errors.is_empty() {
+        return Ok(());
+    }
+
+    errors.push(
+        "Harness health failed; normal NAOME task work is repair-only until machine-owned harness files are healthy. Human options: repair_harness, review_harness_health."
+            .to_string(),
+    );
+    errors.extend(
+        health_errors
+            .into_iter()
+            .map(|error| format!("Harness health: {error}")),
+    );
+    Ok(())
+}

package/crates/naome-core/src/task_state/task_records.rs

@@ -0,0 +1,131 @@
+use serde_json::Value;
+
+use super::util::{
+    is_iso_datetime, is_non_empty_string, require_string, require_string_array,
+    require_string_array_allow_empty, string_array,
+};
+pub(super) fn validate_revisions(revisions: Option<&Value>, errors: &mut Vec<String>) {
+    let Some(revisions) = revisions else {
+        return;
+    };
+    let Some(revisions) = revisions.as_array() else {
+        errors.push("activeTask.revisions must be an array when present.".to_string());
+        return;
+    };
+
+    for (index, revision) in revisions.iter().enumerate() {
+        let prefix = format!("activeTask.revisions[{index}]");
+        let Some(object) = revision.as_object() else {
+            errors.push(format!("{prefix} must be an object."));
+            continue;
+        };
+
+        require_string(object.get("request"), &format!("{prefix}.request"), errors);
+        validate_prompt_record(
+            object.get("userPrompt"),
+            &format!("{prefix}.userPrompt"),
+            errors,
+        );
+
+        if !object
+            .get("requestedAt")
+            .and_then(Value::as_str)
+            .is_some_and(is_iso_datetime)
+        {
+            errors.push(format!("{prefix}.requestedAt must be an ISO timestamp."));
+        }
+
+        if let Some(proof_stale) = object.get("proofStale") {
+            if !proof_stale.is_boolean() {
+                errors.push(format!("{prefix}.proofStale must be boolean when present."));
+            }
+        }
+    }
+}
+
+pub(super) fn validate_prompt_record(
+    prompt_record: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(object) = prompt_record.and_then(Value::as_object) else {
+        errors.push(format!(
+            "{field_name} must be an object with receivedAt and text."
+        ));
+        return;
+    };
+
+    if !object
+        .get("receivedAt")
+        .and_then(Value::as_str)
+        .is_some_and(is_iso_datetime)
+    {
+        errors.push(format!("{field_name}.receivedAt must be an ISO timestamp."));
+    }
+
+    require_string(object.get("text"), &format!("{field_name}.text"), errors);
+}
+
+pub(super) fn validate_human_review(human_review: Option<&Value>, errors: &mut Vec<String>) {
+    let Some(object) = human_review.and_then(Value::as_object) else {
+        errors.push("activeTask.humanReview must be an object.".to_string());
+        return;
+    };
+
+    if !object.get("required").is_some_and(Value::is_boolean) {
+        errors.push("activeTask.humanReview.required must be boolean.".to_string());
+    }
+
+    if !object.get("approved").is_some_and(Value::is_boolean) {
+        errors.push("activeTask.humanReview.approved must be boolean.".to_string());
+    }
+
+    if let Some(reason) = object.get("reason") {
+        if !reason.is_null() && !reason.as_str().is_some_and(is_non_empty_string) {
+            errors.push("activeTask.humanReview.reason must be a string or null.".to_string());
+        }
+    }
+}
+
+pub(super) fn validate_blocker(blocker: Option<&Value>, errors: &mut Vec<String>) {
+    let Some(object) = blocker.and_then(Value::as_object) else {
+        errors.push(
+            "blocker must be an object when task state is blocked or needs human review."
+                .to_string(),
+        );
+        return;
+    };
+
+    require_string(object.get("type"), "blocker.type", errors);
+    require_string(object.get("message"), "blocker.message", errors);
+    require_string_array_allow_empty(object.get("paths"), "blocker.paths", errors);
+    require_string_array(object.get("humanOptions"), "blocker.humanOptions", errors);
+}
+
+pub(super) fn format_blocker(prefix: &str, blocker: Option<&Value>) -> String {
+    let Some(object) = blocker.and_then(Value::as_object) else {
+        return format!("{prefix}.");
+    };
+
+    let mut parts = vec![format!(
+        "{prefix}: {}",
+        object
+            .get("message")
+            .and_then(Value::as_str)
+            .unwrap_or("No message recorded.")
+    )];
+
+    if let Some(paths) = string_array(object.get("paths")) {
+        if !paths.is_empty() {
+            parts.push(format!("Paths: {}", paths.join(", ")));
+        }
+    }
+
+    if let Some(options) = string_array(object.get("humanOptions")) {
+        if !options.is_empty() {
+            parts.push(format!("Human options: {}", options.join(", ")));
+        }
+    }
+
+    parts.join(" ")
+}

package/crates/naome-core/src/task_state/task_references.rs

@@ -0,0 +1,126 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub(super) use super::admission_proof::validate_admission_proof;
+use super::git_io::read_git_head;
+use super::proof::validate_proof_result_entries;
+use super::util::{joined_strings, read_json};
+pub(super) fn validate_pending_upgrade(
+    _task_state: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    if !root.join(".naome/upgrade-state.json").exists() {
+        return Ok(());
+    }
+
+    let Some(upgrade_state) = read_json(root, ".naome/upgrade-state.json", errors)? else {
+        return Ok(());
+    };
+
+    if upgrade_state.get("status").and_then(Value::as_str) == Some("needs_agent_upgrade") {
+        let pending = joined_strings(upgrade_state.get("pending"), "unknown");
+        errors.push(format!(
+            "NAOME upgrade is pending. Finish docs/naome/upgrade.md before feature work. Pending: {pending}"
+        ));
+    }
+
+    Ok(())
+}
+
+pub(super) fn validate_active_task_references(
+    active_task: Option<&Value>,
+    root: &Path,
+    errors: &mut Vec<String>,
+    status: Option<&str>,
+) -> Result<(), NaomeError> {
+    let Some(active_task) = active_task else {
+        return Ok(());
+    };
+
+    validate_admission_proof(active_task.get("admission"), root, errors)?;
+    validate_external_git_reconciliation(active_task, status, root, errors)?;
+    let check_ids = read_verification_check_ids(root, errors)?;
+    validate_required_check_ids(active_task, &check_ids, errors);
+    validate_proof_result_entries(active_task, &check_ids, root, errors)?;
+    Ok(())
+}
+
+pub(super) fn validate_external_git_reconciliation(
+    active_task: &Value,
+    status: Option<&str>,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    if status == Some("complete") {
+        return Ok(());
+    }
+
+    let Some(admission_head) = active_task
+        .get("admission")
+        .and_then(|admission| admission.get("gitHead"))
+        .and_then(Value::as_str)
+        .filter(|head| !head.trim().is_empty())
+    else {
+        return Ok(());
+    };
+
+    let Some(current_head) = read_git_head(root)? else {
+        return Ok(());
+    };
+
+    if current_head != admission_head {
+        errors.push(format!("Task git HEAD changed after admission from {admission_head} to {current_head}. Reconcile external git work before continuing. Human options: mark_task_complete_from_git, reopen_task_revision, recover_current_diff, cancel_task_state."));
+    }
+
+    Ok(())
+}
+
+pub(super) fn read_verification_check_ids(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<HashSet<String>, NaomeError> {
+    let mut check_ids = HashSet::new();
+    let Some(verification) = read_json(root, ".naome/verification.json", errors)? else {
+        return Ok(check_ids);
+    };
+
+    if let Some(checks) = verification.get("checks").and_then(Value::as_array) {
+        for check in checks {
+            if let Some(id) = check.get("id").and_then(Value::as_str) {
+                if !id.trim().is_empty() {
+                    check_ids.insert(id.to_string());
+                }
+            }
+        }
+    }
+
+    Ok(check_ids)
+}
+
+pub(super) fn validate_required_check_ids(
+    active_task: &Value,
+    check_ids: &HashSet<String>,
+    errors: &mut Vec<String>,
+) {
+    let Some(required_check_ids) = active_task
+        .get("requiredCheckIds")
+        .and_then(Value::as_array)
+    else {
+        return;
+    };
+
+    for check_id in required_check_ids {
+        if let Some(check_id) = check_id.as_str().filter(|value| !value.trim().is_empty()) {
+            if !check_ids.contains(check_id) {
+                errors.push(format!(
+                    "activeTask.requiredCheckIds unknown check id: {check_id}"
+                ));
+            }
+        }
+    }
+}

package/crates/naome-core/src/task_state/types.rs

@@ -0,0 +1,87 @@
+use crate::harness_health::HarnessHealthOptions;
+
+pub(super) const CONTROL_STATE_PATH: &str = ".naome/task-state.json";
+pub(super) const ALLOWED_STATUS: &[&str] = &[
+    "idle",
+    "planning",
+    "implementing",
+    "revising",
+    "verifying",
+    "needs_human_review",
+    "blocked",
+    "complete",
+];
+pub(super) const BLOCKING_STATUS: &[&str] = &[
+    "planning",
+    "implementing",
+    "revising",
+    "verifying",
+    "needs_human_review",
+    "blocked",
+];
+pub(super) const ALLOWED_EVIDENCE_STATUS: &[&str] = &["added", "modified", "deleted", "renamed"];
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TaskStateMode {
+    State,
+    Admission,
+    Progress,
+    CommitGate,
+    PushGate,
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskStateOptions {
+    pub mode: TaskStateMode,
+    pub harness_health: Option<HarnessHealthOptions>,
+}
+
+impl Default for TaskStateOptions {
+    fn default() -> Self {
+        Self {
+            mode: TaskStateMode::State,
+            harness_health: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TaskStateReport {
+    pub errors: Vec<String>,
+    pub notices: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct ChangedEntry {
+    pub(super) path: String,
+    pub(super) status: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CompletedTaskHarnessRefreshDiff {
+    pub harness_paths: Vec<String>,
+    pub task_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HarnessRefreshWithUnrelatedDiff {
+    pub harness_paths: Vec<String>,
+    pub unrelated_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HarnessRefreshDiff {
+    pub harness_paths: Vec<String>,
+    pub unrelated_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CompletedTaskCommitDiff {
+    pub task_paths: Vec<String>,
+    pub unrelated_paths: Vec<String>,
+}
+
+pub(super) struct TaskDiff {
+    pub(super) diff_paths: Vec<String>,
+    pub(super) outside_paths: Vec<String>,
+}

package/crates/naome-core/src/task_state/util.rs

@@ -0,0 +1,137 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub(super) fn matches_any_pattern(path: &str, patterns: &[String]) -> bool {
+    crate::paths::matches_any(path, patterns)
+}
+pub(super) fn read_json(
+    root: &Path,
+    relative_path: &str,
+    errors: &mut Vec<String>,
+) -> Result<Option<Value>, NaomeError> {
+    let json_path = root.join(relative_path);
+    if !json_path.is_file() {
+        errors.push(format!("{relative_path} is missing."));
+        return Ok(None);
+    }
+
+    let content = fs::read_to_string(json_path)?;
+    match serde_json::from_str::<Value>(&content) {
+        Ok(parsed) => Ok(Some(parsed)),
+        Err(error) => {
+            errors.push(format!("{relative_path} is not valid JSON: {error}"));
+            Ok(None)
+        }
+    }
+}
+
+pub(super) fn require_string(value: Option<&Value>, field_name: &str, errors: &mut Vec<String>) {
+    if !value
+        .and_then(Value::as_str)
+        .is_some_and(is_non_empty_string)
+    {
+        errors.push(format!("{field_name} must be a non-empty string."));
+    }
+}
+
+pub(super) fn require_string_array(
+    value: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(values) = value.and_then(Value::as_array) else {
+        errors.push(format!("{field_name} must be a non-empty string array."));
+        return;
+    };
+
+    if values.is_empty()
+        || values
+            .iter()
+            .any(|entry| !entry.as_str().is_some_and(is_non_empty_string))
+    {
+        errors.push(format!("{field_name} must be a non-empty string array."));
+    }
+}
+
+pub(super) fn require_string_array_allow_empty(
+    value: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(values) = value.and_then(Value::as_array) else {
+        errors.push(format!("{field_name} must be a string array."));
+        return;
+    };
+
+    if values
+        .iter()
+        .any(|entry| !entry.as_str().is_some_and(is_non_empty_string))
+    {
+        errors.push(format!("{field_name} must be a string array."));
+    }
+}
+
+pub(super) fn string_array(value: Option<&Value>) -> Option<Vec<String>> {
+    value.and_then(Value::as_array).and_then(|values| {
+        values
+            .iter()
+            .map(|entry| {
+                entry
+                    .as_str()
+                    .filter(|value| is_non_empty_string(value))
+                    .map(ToString::to_string)
+            })
+            .collect()
+    })
+}
+
+pub(super) fn joined_strings(value: Option<&Value>, fallback: &str) -> String {
+    string_array(value)
+        .filter(|values| !values.is_empty())
+        .map(|values| values.join(", "))
+        .unwrap_or_else(|| fallback.to_string())
+}
+
+pub(super) fn is_non_empty_string(value: &str) -> bool {
+    !value.trim().is_empty()
+}
+
+pub(super) fn is_id(value: &str) -> bool {
+    let mut chars = value.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first.is_ascii_lowercase() || first.is_ascii_digit())
+        && value
+            .chars()
+            .all(|ch| ch.is_ascii_lowercase() || ch.is_ascii_digit() || ch == '-')
+}
+
+pub(super) fn is_iso_datetime(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    bytes.len() == 24
+        && bytes[4] == b'-'
+        && bytes[7] == b'-'
+        && bytes[10] == b'T'
+        && bytes[13] == b':'
+        && bytes[16] == b':'
+        && bytes[19] == b'.'
+        && bytes[23] == b'Z'
+        && bytes
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| ![4, 7, 10, 13, 16, 19, 23].contains(index))
+            .all(|(_, byte)| byte.is_ascii_digit())
+}
+
+pub(super) fn normalize_path(value: impl AsRef<str>) -> String {
+    value
+        .as_ref()
+        .replace('\\', "/")
+        .trim_start_matches("./")
+        .to_string()
+}