@lamentis/naome 1.1.1 → 1.2.0

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

@@ -0,0 +1,154 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::deleted_paths::read_historical_deleted_paths;
+use super::git_io::read_git_changed_entries;
+use super::types::{ALLOWED_EVIDENCE_STATUS, CONTROL_STATE_PATH};
+use super::util::{
+    is_non_empty_string, matches_any_pattern, normalize_path, require_string, string_array,
+};
+pub(super) fn validate_evidence_array(
+    evidence: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(evidence) = evidence.and_then(Value::as_array) else {
+        errors.push(format!("{field_name} must be an evidence array."));
+        return;
+    };
+
+    for (index, entry) in evidence.iter().enumerate() {
+        let prefix = format!("{field_name}[{index}]");
+        if entry.as_str().is_some_and(is_non_empty_string) {
+            continue;
+        }
+
+        let Some(object) = entry.as_object() else {
+            errors.push(format!(
+                "{prefix} must be a non-empty string path or an evidence object."
+            ));
+            continue;
+        };
+
+        require_string(object.get("path"), &format!("{prefix}.path"), errors);
+
+        if let Some(status) = object.get("status").and_then(Value::as_str) {
+            if !ALLOWED_EVIDENCE_STATUS.contains(&status) {
+                errors.push(format!(
+                    "{prefix}.status must be one of: {}.",
+                    ALLOWED_EVIDENCE_STATUS.join(", ")
+                ));
+            }
+        }
+
+        if object.contains_key("fromPath")
+            && !object
+                .get("fromPath")
+                .and_then(Value::as_str)
+                .is_some_and(is_non_empty_string)
+        {
+            errors.push(format!(
+                "{prefix}.fromPath must be a non-empty string when present."
+            ));
+        }
+    }
+}
+
+pub(super) fn validate_control_state_patterns(
+    patterns: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(patterns) = string_array(patterns) else {
+        return;
+    };
+
+    for pattern in patterns {
+        if matches_any_pattern(CONTROL_STATE_PATH, std::slice::from_ref(&pattern)) {
+            errors.push(format!(
+                "{field_name} cannot include NAOME control state: {pattern}"
+            ));
+        }
+    }
+}
+
+pub(super) fn validate_control_state_paths(
+    paths: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+) {
+    let Some(paths) = paths.and_then(Value::as_array) else {
+        return;
+    };
+
+    for entry in paths {
+        let Some(path) = evidence_entry_path(entry) else {
+            continue;
+        };
+        if normalize_path(&path) == CONTROL_STATE_PATH {
+            errors.push(format!(
+                "{field_name} cannot include NAOME control state: {path}"
+            ));
+        }
+    }
+}
+
+pub(super) fn validate_evidence_paths(
+    evidence: Option<&Value>,
+    field_name: &str,
+    root: &Path,
+    errors: &mut Vec<String>,
+    active_task: &Value,
+) -> Result<(), NaomeError> {
+    let Some(evidence) = evidence.and_then(Value::as_array) else {
+        return Ok(());
+    };
+
+    let mut deleted_paths: HashSet<String> = read_git_changed_entries(root)?
+        .into_iter()
+        .filter(|entry| entry.status == "deleted")
+        .map(|entry| entry.path)
+        .collect();
+    for path in read_historical_deleted_paths(active_task, root)? {
+        deleted_paths.insert(path);
+    }
+
+    for entry in evidence {
+        let Some(evidence_path) = evidence_entry_path(entry) else {
+            continue;
+        };
+        let normalized_path = normalize_path(&evidence_path);
+        if Path::new(&evidence_path).is_absolute()
+            || normalized_path.split('/').any(|part| part == "..")
+        {
+            errors.push(format!("{field_name} unsafe path: {evidence_path}"));
+            continue;
+        }
+
+        if !root.join(&normalized_path).exists() && !deleted_paths.contains(&normalized_path) {
+            errors.push(format!(
+                "{field_name} path does not exist or is not deleted in git diff: {evidence_path}"
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub(super) fn evidence_entry_path(entry: &Value) -> Option<String> {
+    entry
+        .as_str()
+        .filter(|value| is_non_empty_string(value))
+        .map(ToString::to_string)
+        .or_else(|| {
+            entry
+                .get("path")
+                .and_then(Value::as_str)
+                .filter(|value| is_non_empty_string(value))
+                .map(ToString::to_string)
+        })
+}

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

@@ -0,0 +1,86 @@
+use std::collections::HashMap;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+pub(super) use super::git_parse::{parse_name_status_output, split_nul, upsert_changed_entry};
+pub(super) use super::git_refs::{command_output, git_commit_exists, read_git_head, run_git};
+use super::types::ChangedEntry;
+use super::util::normalize_path;
+pub(super) fn read_git_changed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    Ok(read_git_changed_entries(root)?
+        .into_iter()
+        .map(|entry| entry.path)
+        .collect())
+}
+
+pub(super) fn read_git_staged_changed_entries(
+    root: &Path,
+) -> Result<Vec<ChangedEntry>, NaomeError> {
+    let output = Command::new("git")
+        .args(["diff", "--name-status", "--cached", "-z"])
+        .current_dir(root)
+        .output()?;
+    if !output.status.success() {
+        return Err(NaomeError::new(format!(
+            "git diff --name-status --cached -z failed: {}",
+            command_output(&output)
+        )));
+    }
+
+    Ok(parse_name_status_output(&output.stdout))
+}
+
+pub(super) fn read_git_changed_entries(root: &Path) -> Result<Vec<ChangedEntry>, NaomeError> {
+    let git_check = run_git(root, ["rev-parse", "--is-inside-work-tree"])?;
+    if !git_check.status.success() {
+        return Err(NaomeError::new(
+            "complete task validation requires a git work tree.",
+        ));
+    }
+
+    let mut entries: HashMap<String, ChangedEntry> = HashMap::new();
+    for args in [
+        vec!["diff", "--name-status", "-z"],
+        vec!["diff", "--name-status", "--cached", "-z"],
+    ] {
+        let output = Command::new("git").args(&args).current_dir(root).output()?;
+        if !output.status.success() {
+            return Err(NaomeError::new(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                command_output(&output)
+            )));
+        }
+
+        for entry in parse_name_status_output(&output.stdout) {
+            upsert_changed_entry(&mut entries, entry);
+        }
+    }
+
+    let untracked = run_git(root, ["ls-files", "--others", "--exclude-standard", "-z"])?;
+    if !untracked.status.success() {
+        return Err(NaomeError::new(format!(
+            "git ls-files --others --exclude-standard -z failed: {}",
+            command_output(&untracked)
+        )));
+    }
+
+    for token in split_nul(&untracked.stdout) {
+        let path = normalize_path(token.trim());
+        if !path.is_empty() {
+            upsert_changed_entry(
+                &mut entries,
+                ChangedEntry {
+                    path,
+                    status: "added".to_string(),
+                },
+            );
+        }
+    }
+
+    let mut entries: Vec<ChangedEntry> = entries.into_values().collect();
+    entries.sort_by(|left, right| left.path.cmp(&right.path));
+    Ok(entries)
+}

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

@@ -0,0 +1,86 @@
+use std::collections::HashMap;
+
+use super::types::ChangedEntry;
+use super::util::normalize_path;
+pub(super) fn parse_name_status_output(output: &[u8]) -> Vec<ChangedEntry> {
+    let tokens = split_nul(output);
+    let mut entries = Vec::new();
+    let mut index = 0;
+
+    while index < tokens.len() {
+        let raw_status = &tokens[index];
+        index += 1;
+        let status_code = raw_status.chars().next().unwrap_or('M');
+
+        if status_code == 'R' || status_code == 'C' {
+            let from_path = normalize_path(tokens.get(index).map(String::as_str).unwrap_or(""));
+            index += 1;
+            let to_path = normalize_path(tokens.get(index).map(String::as_str).unwrap_or(""));
+            index += 1;
+            if !from_path.is_empty() {
+                entries.push(ChangedEntry {
+                    path: from_path,
+                    status: "deleted".to_string(),
+                });
+            }
+            if !to_path.is_empty() {
+                entries.push(ChangedEntry {
+                    path: to_path,
+                    status: "renamed".to_string(),
+                });
+            }
+            continue;
+        }
+
+        let path = normalize_path(tokens.get(index).map(String::as_str).unwrap_or(""));
+        index += 1;
+        if path.is_empty() {
+            continue;
+        }
+
+        entries.push(ChangedEntry {
+            path,
+            status: git_status_code_to_evidence_status(status_code).to_string(),
+        });
+    }
+
+    entries
+}
+
+pub(super) fn split_nul(output: &[u8]) -> Vec<String> {
+    output
+        .split(|byte| *byte == 0)
+        .filter(|token| !token.is_empty())
+        .map(|token| String::from_utf8_lossy(token).to_string())
+        .collect()
+}
+
+pub(super) fn git_status_code_to_evidence_status(status_code: char) -> &'static str {
+    match status_code {
+        'A' => "added",
+        'D' => "deleted",
+        _ => "modified",
+    }
+}
+
+pub(super) fn upsert_changed_entry(
+    entries: &mut HashMap<String, ChangedEntry>,
+    entry: ChangedEntry,
+) {
+    let should_replace = entries
+        .get(&entry.path)
+        .map(|existing| status_rank(&entry.status) > status_rank(&existing.status))
+        .unwrap_or(true);
+    if should_replace {
+        entries.insert(entry.path.clone(), entry);
+    }
+}
+
+pub(super) fn status_rank(status: &str) -> u8 {
+    match status {
+        "deleted" => 4,
+        "renamed" => 3,
+        "added" => 2,
+        _ => 1,
+    }
+}

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

@@ -0,0 +1,37 @@
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+pub(super) fn read_git_head(root: &Path) -> Result<Option<String>, NaomeError> {
+    let output = run_git(root, ["rev-parse", "HEAD"])?;
+    if !output.status.success() {
+        return Ok(None);
+    }
+    Ok(Some(
+        String::from_utf8_lossy(&output.stdout).trim().to_string(),
+    ))
+}
+
+pub(super) fn git_commit_exists(root: &Path, commit: &str) -> Result<bool, NaomeError> {
+    Ok(
+        run_git(root, ["cat-file", "-e", &format!("{commit}^{{commit}}")])?
+            .status
+            .success(),
+    )
+}
+
+pub(super) fn run_git<const N: usize>(
+    root: &Path,
+    args: [&str; N],
+) -> Result<std::process::Output, NaomeError> {
+    Ok(Command::new("git").args(args).current_dir(root).output()?)
+}
+
+pub(super) fn command_output(output: &std::process::Output) -> String {
+    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+    if !stderr.is_empty() {
+        return stderr;
+    }
+    String::from_utf8_lossy(&output.stdout).trim().to_string()
+}

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

@@ -0,0 +1,31 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::diff::validate_human_review_blocker_paths;
+use super::proof::validate_proof_evidence_covers_changed_paths;
+use super::shape::{validate_active_task, validate_active_task_references, validate_blocker};
+
+pub(super) fn validate_human_review_state(
+    task_state: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    validate_active_task(task_state.get("activeTask"), errors);
+    validate_active_task_references(
+        task_state.get("activeTask"),
+        root,
+        errors,
+        Some("needs_human_review"),
+    )?;
+    validate_blocker(task_state.get("blocker"), errors);
+    validate_human_review_blocker_paths(
+        task_state.get("activeTask"),
+        task_state.get("blocker"),
+        root,
+        errors,
+    )?;
+    validate_proof_evidence_covers_changed_paths(task_state.get("activeTask"), root, errors)
+}

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

@@ -0,0 +1,38 @@
+mod admission;
+mod admission_proof;
+mod api;
+mod commit_gate;
+mod compact_proof;
+mod completed_refresh;
+mod completion;
+mod deleted_paths;
+mod diff;
+mod evidence;
+mod git_io;
+mod git_parse;
+mod git_refs;
+mod human_review_state;
+mod process_guard;
+mod progress;
+mod proof;
+mod proof_entry;
+mod proof_model;
+mod proof_sources;
+mod push_gate;
+mod reconcile;
+mod repair;
+mod shape;
+mod task_diff_api;
+mod task_records;
+mod task_references;
+mod types;
+mod util;
+
+pub use api::validate_task_state;
+pub use completed_refresh::completed_task_harness_refresh_diff;
+pub(crate) use proof_model::canonical_proof_check_ids;
+pub use task_diff_api::{
+    completed_task_commit_diff, completed_task_commit_paths, harness_refresh_diff,
+    harness_refresh_with_unrelated_diff,
+};
+pub use types::{TaskStateMode, TaskStateOptions, TaskStateReport};

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

@@ -0,0 +1,40 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+use crate::workflow::tracked_process_report;
+
+pub(super) enum ProcessGate {
+    Completion,
+    Commit,
+}
+
+pub(super) fn validate_no_active_processes(
+    root: &Path,
+    errors: &mut Vec<String>,
+    gate: ProcessGate,
+) -> Result<(), NaomeError> {
+    let report = tracked_process_report(root)?;
+    if report.active.is_empty() {
+        return Ok(());
+    }
+
+    let commands = report
+        .active
+        .iter()
+        .map(|process| process.command.clone())
+        .collect::<Vec<_>>();
+    errors.push(process_error_message(gate, &commands));
+    Ok(())
+}
+
+fn process_error_message(gate: ProcessGate, commands: &[String]) -> String {
+    let command_list = commands.join(", ");
+    match gate {
+        ProcessGate::Completion => format!(
+            "Task has active tracked processes: {command_list}. Stop them or document allowAfterCompletion before completion. Human options: stop_tracked_processes, document_long_running_process."
+        ),
+        ProcessGate::Commit => format!(
+            "NAOME commit gate blocked active tracked processes: {command_list}. Stop them or mark allowAfterCompletion before committing."
+        ),
+    }
+}

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

@@ -0,0 +1,123 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::diff::validate_changed_paths;
+use super::git_io::read_git_changed_paths;
+use super::human_review_state::validate_human_review_state;
+use super::reconcile::format_dirty_diff_admission_blocker;
+use super::shape::{
+    format_blocker, validate_active_task, validate_active_task_references, validate_blocker,
+    validate_pending_upgrade,
+};
+use super::util::{joined_strings, read_json};
+pub(super) fn validate_progress(
+    task_state: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let status = checked_status(task_state, root, errors)?;
+
+    match status {
+        "planning" | "implementing" | "revising" | "verifying" => {
+            validate_active_task(task_state.get("activeTask"), errors);
+            validate_pending_upgrade(task_state, root, errors)?;
+            validate_active_task_references(
+                task_state.get("activeTask"),
+                root,
+                errors,
+                Some(status),
+            )?;
+            if let Some(active_task) = task_state.get("activeTask") {
+                validate_changed_paths(active_task, root, errors)?;
+            }
+        }
+        "needs_human_review" => {
+            validate_human_review_state(task_state, root, errors)?;
+            errors.push(format_blocker(
+                "Human review required",
+                task_state.get("blocker"),
+            ));
+        }
+        "blocked" => {
+            validate_active_task(task_state.get("activeTask"), errors);
+            validate_blocker(task_state.get("blocker"), errors);
+            errors.push(format_blocker("Task is blocked", task_state.get("blocker")));
+        }
+        "complete" => errors.push(
+            "Task is complete; use node .naome/bin/check-task-state.js for completion validation."
+                .to_string(),
+        ),
+        "idle" => errors.push(
+            "No active task is in progress; use --admission before starting feature work."
+                .to_string(),
+        ),
+        _ => {}
+    }
+
+    Ok(())
+}
+
+pub(super) fn checked_status<'a>(
+    task_state: &'a Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<&'a str, NaomeError> {
+    validate_init_complete(root, errors)?;
+    validate_upgrade_complete(root, errors)?;
+    Ok(task_state
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("invalid"))
+}
+pub(super) fn validate_upgrade_complete(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    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("complete") {
+        let pending = joined_strings(upgrade_state.get("pending"), "unknown");
+        errors.push(format!("NAOME upgrade is not complete. Finish docs/naome/upgrade.md before feature work. Pending: {pending}"));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_init_complete(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let Some(init_state) = read_json(root, ".naome/init-state.json", errors)? else {
+        return Ok(());
+    };
+
+    if init_state.get("initialized").and_then(Value::as_bool) != Some(true)
+        || init_state.get("intakeStatus").and_then(Value::as_str) != Some("complete")
+    {
+        errors.push(
+            "NAOME intake is not complete. Finish docs/naome/first-run.md before feature work."
+                .to_string(),
+        );
+    }
+    Ok(())
+}
+
+pub(super) fn validate_clean_git_diff(
+    task_state: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let changed_paths = read_git_changed_paths(root)?;
+    if !changed_paths.is_empty() {
+        errors.push(format_dirty_diff_admission_blocker(
+            task_state,
+            root,
+            &changed_paths,
+        )?);
+    }
+    Ok(())
+}