@lamentis/naome 1.1.2 → 1.2.1

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

package/crates/naome-core/src/verification/render.rs

@@ -0,0 +1,122 @@
+use serde_json::Value;
+
+pub(super) const CHECK_KEYS: &[&str] = &[
+    "id",
+    "command",
+    "cwd",
+    "purpose",
+    "cost",
+    "source",
+    "evidence",
+    "lastVerified",
+];
+
+pub(super) fn serialize_verification_preserving_order(verification: &Value) -> Option<String> {
+    let object = verification.as_object()?;
+    let ordered_keys = [
+        "schema",
+        "version",
+        "status",
+        "lastUpdated",
+        "checks",
+        "phases",
+        "changeTypes",
+        "releaseGates",
+    ];
+    let mut blocks = Vec::new();
+
+    for key in ordered_keys {
+        if let Some(value) = object.get(key) {
+            blocks.push(render_property(key, value)?);
+        }
+    }
+    for (key, value) in object {
+        if !ordered_keys.contains(&key.as_str()) {
+            blocks.push(render_property(key, value)?);
+        }
+    }
+
+    Some(format!("{{\n{}\n}}", blocks.join(",\n")))
+}
+
+fn render_property(key: &str, value: &Value) -> Option<String> {
+    let rendered = match key {
+        "checks" => render_ordered_array(value, CHECK_KEYS)?,
+        "phases" => render_ordered_array(value, &["id", "order", "checkIds"])?,
+        "changeTypes" => render_ordered_array(
+            value,
+            &[
+                "id",
+                "description",
+                "paths",
+                "requiredChecks",
+                "recommendedChecks",
+                "humanReview",
+            ],
+        )?,
+        "releaseGates" => render_ordered_array(value, &["checkId", "requiredWhen"])?,
+        _ => serde_json::to_string_pretty(value).ok()?,
+    };
+    render_named_value(key, &rendered, "  ")
+}
+
+fn render_ordered_array(value: &Value, ordered_keys: &[&str]) -> Option<String> {
+    let array = value.as_array()?;
+    if array.is_empty() {
+        return Some("[]".to_string());
+    }
+
+    let mut rendered_items = Vec::new();
+    for item in array {
+        rendered_items.push(render_ordered_object(item, ordered_keys)?);
+    }
+
+    Some(format!(
+        "[\n{}\n]",
+        rendered_items
+            .iter()
+            .map(|item| indent_block(item, "  "))
+            .collect::<Vec<_>>()
+            .join(",\n")
+    ))
+}
+
+pub(super) fn render_ordered_object(value: &Value, ordered_keys: &[&str]) -> Option<String> {
+    let object = value.as_object()?;
+    let mut properties = Vec::new();
+
+    for key in ordered_keys {
+        if let Some(value) = object.get(*key) {
+            let rendered = serde_json::to_string_pretty(value).ok()?;
+            properties.push(render_named_value(key, &rendered, "  ")?);
+        }
+    }
+    for (key, value) in object {
+        if !ordered_keys.contains(&key.as_str()) {
+            let rendered = serde_json::to_string_pretty(value).ok()?;
+            properties.push(render_named_value(key, &rendered, "  ")?);
+        }
+    }
+
+    Some(format!("{{\n{}\n}}", properties.join(",\n")))
+}
+
+fn render_named_value(key: &str, rendered: &str, indent: &str) -> Option<String> {
+    let mut lines = rendered.lines();
+    let first = lines.next()?;
+    let mut block = format!("{indent}\"{key}\": {first}");
+    for line in lines {
+        block.push('\n');
+        block.push_str(indent);
+        block.push_str(line);
+    }
+    Some(block)
+}
+
+pub(super) fn indent_block(content: &str, indent: &str) -> String {
+    content
+        .lines()
+        .map(|line| format!("{indent}{line}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}