@lamentis/naome 1.0.0

package/crates/naome-core/src/decision.rs

@@ -0,0 +1,432 @@
+use std::fs;
+use std::ffi::OsString;
+use std::path::Path;
+use std::process::Command;
+
+use serde_json::Value;
+
+use crate::git;
+use crate::models::{CheckDecision, Decision, NaomeError, TaskDecision};
+use crate::paths;
+
+#[derive(Debug, Clone, Copy)]
+pub struct EvaluationOptions {
+    pub run_external_checks: bool,
+}
+
+impl EvaluationOptions {
+    pub fn online() -> Self {
+        Self {
+            run_external_checks: true,
+        }
+    }
+
+    pub fn offline() -> Self {
+        Self {
+            run_external_checks: false,
+        }
+    }
+}
+
+pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Decision, NaomeError> {
+    let changed_paths = git::changed_paths(root)?;
+
+    let harness_health = if options.run_external_checks {
+        Some(run_node_check(
+            root,
+            ".naome/bin/check-harness-health.js",
+            &[],
+        )?)
+    } else {
+        None
+    };
+
+    if let Some(check) = &harness_health {
+        if !check.ok {
+            let mut decision = Decision::new(
+                "harness_unhealthy",
+                true,
+                "NAOME harness health failed.",
+                vec!["repair_harness", "review_harness_health"],
+                "Repair the machine-owned harness before feature work.",
+            );
+            decision.changed_paths = changed_paths;
+            decision.harness_health = harness_health;
+            decision.required_context = vec![
+                ".naomeignore".to_string(),
+                "docs/naome/index.md".to_string(),
+                ".naome/manifest.json".to_string(),
+            ];
+            return Ok(decision);
+        }
+    }
+
+    let init_state = read_json(root, ".naome/init-state.json")?;
+    let upgrade_state = read_json(root, ".naome/upgrade-state.json")?;
+    let task_state = read_json(root, ".naome/task-state.json")?;
+
+    if json_string(&upgrade_state, "status").as_deref() == Some("needs_agent_upgrade") {
+        let mut decision = Decision::new(
+            "upgrade_required",
+            true,
+            "NAOME upgrade requires agent follow-up.",
+            vec!["run_upgrade_protocol"],
+            "Run the NAOME upgrade protocol before feature work.",
+        );
+        decision.changed_paths = changed_paths;
+        decision.harness_health = harness_health;
+        decision.required_context = vec![
+            "docs/naome/upgrade.md".to_string(),
+            ".naome/upgrade-state.json".to_string(),
+        ];
+        return Ok(decision);
+    }
+
+    if json_bool(&init_state, "initialized") != Some(true) {
+        let mut decision = Decision::new(
+            "first_run_required",
+            true,
+            "NAOME first-run intake has not been completed.",
+            vec!["run_first_run_protocol"],
+            "Run the NAOME first-run protocol before feature work.",
+        );
+        decision.changed_paths = changed_paths;
+        decision.harness_health = harness_health;
+        decision.required_context = vec![
+            "docs/naome/first-run.md".to_string(),
+            ".naome/init-state.json".to_string(),
+        ];
+        return Ok(decision);
+    }
+
+    let task_status = json_string(&task_state, "status").unwrap_or_else(|| "invalid".to_string());
+    let task = task_decision(&task_state, &task_status);
+
+    if task_status == "complete" {
+        let mut decision = if changed_paths.is_empty() {
+            Decision::new(
+                "ready_for_task",
+                false,
+                "The last completed NAOME task has no open diff.",
+                vec!["create_task"],
+                "Task admission is clear; create the next task before feature work.",
+            )
+        } else {
+            Decision::new(
+                "completed_task_unbaselined",
+                true,
+                "A completed NAOME task still has an unbaselined diff.",
+                vec![
+                    "commit_task_baseline",
+                    "review_task_diff",
+                    "request_task_changes",
+                    "cancel_task_changes",
+                ],
+                "Choose how to resolve the completed task diff before accepting new feature work.",
+            )
+        };
+        decision.changed_paths = changed_paths;
+        decision.harness_health = harness_health;
+        decision.task = task;
+        decision.required_context = vec![
+            "docs/naome/execution.md".to_string(),
+            ".naome/task-state.json".to_string(),
+        ];
+        return Ok(decision);
+    }
+
+    if task_status != "idle" {
+        let allowed_paths = task
+            .as_ref()
+            .map(|task| task.allowed_paths.clone())
+            .unwrap_or_default();
+        let out_of_scope: Vec<String> = changed_paths
+            .iter()
+            .filter(|path| {
+                !is_control_state_path(path) && !paths::matches_any(path, &allowed_paths)
+            })
+            .cloned()
+            .collect();
+
+        let mut decision = if out_of_scope.is_empty() {
+            Decision::new(
+                "active_task_in_progress",
+                false,
+                "A NAOME task is active and the current diff is inside its declared scope.",
+                vec!["continue_task", "request_task_changes", "complete_task"],
+                "Continue the active task and keep proof current.",
+            )
+        } else {
+            Decision::new(
+                "active_task_blocked",
+                true,
+                "A NAOME task is active, but the current diff includes paths outside its declared scope.",
+                vec!["revise_task_scope", "revert_out_of_scope_diff", "request_human_review"],
+                "Resolve out-of-scope changes before completing this task.",
+            )
+        };
+        decision.changed_paths = if out_of_scope.is_empty() {
+            changed_paths
+        } else {
+            out_of_scope
+        };
+        decision.harness_health = harness_health;
+        decision.task = task;
+        decision.required_context = vec![
+            "docs/naome/execution.md".to_string(),
+            ".naome/task-state.json".to_string(),
+        ];
+        return Ok(decision);
+    }
+
+    if !changed_paths.is_empty() {
+        let mut decision = classify_idle_diff(root, changed_paths)?;
+        decision.harness_health = harness_health;
+        decision.task = task;
+        return Ok(decision);
+    }
+
+    let task_admission = if options.run_external_checks {
+        Some(run_node_check(
+            root,
+            ".naome/bin/check-task-state.js",
+            &["--admission"],
+        )?)
+    } else {
+        None
+    };
+
+    if let Some(check) = &task_admission {
+        if !check.ok {
+            let mut decision = Decision::new(
+                "task_admission_blocked",
+                true,
+                "NAOME task admission is blocked.",
+                extract_known_actions(&check.output),
+                "Follow the task admission options before accepting new feature work.",
+            );
+            decision.harness_health = harness_health;
+            decision.task_admission = task_admission;
+            decision.task = task;
+            decision.required_context = vec![
+                "docs/naome/execution.md".to_string(),
+                ".naome/task-state.json".to_string(),
+            ];
+            return Ok(decision);
+        }
+    }
+
+    let mut decision = Decision::new(
+        "ready_for_task",
+        false,
+        "NAOME is ready for a new task.",
+        vec!["create_task"],
+        "Create or update a NAOME task before feature work.",
+    );
+    decision.harness_health = harness_health;
+    decision.task_admission = task_admission;
+    decision.task = task;
+    Ok(decision)
+}
+
+pub fn format_decision(decision: &Decision, mode: &str) -> String {
+    let title = if mode == "next" {
+        "NAOME next"
+    } else {
+        "NAOME status"
+    };
+    let mut lines = vec![
+        format!("{title}: {}", decision.state),
+        format!("Blocked: {}", decision.blocked),
+        format!("Summary: {}", decision.summary),
+        format!("Next action: {}", decision.next_action),
+    ];
+
+    if !decision.allowed_actions.is_empty() {
+        lines.push(format!(
+            "Allowed actions: {}",
+            decision.allowed_actions.join(", ")
+        ));
+    }
+
+    if !decision.changed_paths.is_empty() {
+        lines.push(format!(
+            "Changed paths: {}",
+            decision.changed_paths.join(", ")
+        ));
+    }
+
+    if !decision.required_context.is_empty() {
+        lines.push(format!(
+            "Required context: {}",
+            decision.required_context.join(", ")
+        ));
+    }
+
+    lines.push(String::new());
+    lines.join("\n")
+}
+
+fn classify_idle_diff(root: &Path, changed_paths: Vec<String>) -> Result<Decision, NaomeError> {
+    let manifest = read_json(root, ".naome/manifest.json").unwrap_or(Value::Null);
+    let machine_owned = string_array_at(&manifest, "machineOwned");
+    let project_owned = string_array_at(&manifest, "projectOwned");
+
+    let mut known_harness_paths = machine_owned.clone();
+    known_harness_paths.extend(project_owned);
+
+    let all_machine_owned = !machine_owned.is_empty()
+        && changed_paths
+            .iter()
+            .all(|path| paths::matches_any(path, &machine_owned));
+    let all_harness_owned = !known_harness_paths.is_empty()
+        && changed_paths
+            .iter()
+            .all(|path| paths::matches_any(path, &known_harness_paths));
+
+    let mut decision = if all_machine_owned {
+        Decision::new(
+            "harness_repair_unbaselined",
+            true,
+            "Machine-owned NAOME harness files changed outside an active task.",
+            vec![
+                "commit_upgrade_baseline",
+                "review_diff_first",
+                "cancel_upgrade_baseline",
+            ],
+            "Review and baseline the harness repair or cancel it before feature work.",
+        )
+    } else if all_harness_owned {
+        Decision::new(
+            "install_or_upgrade_unbaselined",
+            true,
+            "NAOME setup or upgrade files changed outside an active task.",
+            vec![
+                "commit_upgrade_baseline",
+                "review_diff_first",
+                "cancel_upgrade_baseline",
+            ],
+            "Resolve the setup or upgrade diff before feature work.",
+        )
+    } else {
+        Decision::new(
+            "dirty_unowned_diff",
+            true,
+            "The repository has changes not owned by an active NAOME task.",
+            vec!["review_unowned_diff", "clear_or_commit_unowned_diff"],
+            "Review, commit, or clear the unowned diff before accepting new feature work.",
+        )
+    };
+
+    decision.changed_paths = changed_paths;
+    decision.required_context = vec![
+        "docs/naome/execution.md".to_string(),
+        ".naome/task-state.json".to_string(),
+    ];
+    Ok(decision)
+}
+
+fn task_decision(task_state: &Value, status: &str) -> Option<TaskDecision> {
+    let active_task = task_state.get("activeTask")?;
+    if active_task.is_null() {
+        return None;
+    }
+
+    Some(TaskDecision {
+        id: json_string(active_task, "id"),
+        status: status.to_string(),
+        request: json_string(active_task, "request"),
+        allowed_paths: string_array_at(active_task, "allowedPaths"),
+        required_check_ids: string_array_at(active_task, "requiredCheckIds"),
+    })
+}
+
+fn is_control_state_path(path: &str) -> bool {
+    path == ".naome/task-state.json"
+}
+
+fn run_node_check(root: &Path, script: &str, args: &[&str]) -> Result<CheckDecision, NaomeError> {
+    let mut command_args = vec![script.to_string()];
+    command_args.extend(args.iter().map(ToString::to_string));
+    let node_bin = std::env::var_os("NAOME_NODE_BIN").unwrap_or_else(|| OsString::from("node"));
+    let output = Command::new(&node_bin)
+        .args(&command_args)
+        .current_dir(root)
+        .output()?;
+    let mut combined = String::new();
+    combined.push_str(&String::from_utf8_lossy(&output.stdout));
+    combined.push_str(&String::from_utf8_lossy(&output.stderr));
+
+    Ok(CheckDecision {
+        command: format!(
+            "{} {}{}",
+            node_bin.to_string_lossy(),
+            script,
+            if args.is_empty() {
+                String::new()
+            } else {
+                format!(" {}", args.join(" "))
+            }
+        ),
+        exit_code: output.status.code(),
+        ok: output.status.success(),
+        output: combined.trim().to_string(),
+    })
+}
+
+fn read_json(root: &Path, relative_path: &str) -> Result<Value, NaomeError> {
+    let content = fs::read_to_string(root.join(relative_path))?;
+    Ok(serde_json::from_str(&content)?)
+}
+
+fn json_bool(value: &Value, key: &str) -> Option<bool> {
+    value.get(key).and_then(Value::as_bool)
+}
+
+fn json_string(value: &Value, key: &str) -> Option<String> {
+    value
+        .get(key)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+fn string_array_at(value: &Value, key: &str) -> Vec<String> {
+    value
+        .get(key)
+        .and_then(Value::as_array)
+        .map(|values| {
+            values
+                .iter()
+                .filter_map(Value::as_str)
+                .map(ToString::to_string)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn extract_known_actions(output: &str) -> Vec<&'static str> {
+    const KNOWN: [&str; 12] = [
+        "commit_task_baseline",
+        "review_task_diff",
+        "request_task_changes",
+        "cancel_task_changes",
+        "commit_upgrade_baseline",
+        "review_diff_first",
+        "cancel_upgrade_baseline",
+        "run_first_run_protocol",
+        "run_upgrade_protocol",
+        "review_unowned_diff",
+        "clear_or_commit_unowned_diff",
+        "create_task",
+    ];
+
+    let actions: Vec<&'static str> = KNOWN
+        .into_iter()
+        .filter(|action| output.contains(action))
+        .collect();
+    if actions.is_empty() {
+        vec!["review_task_admission"]
+    } else {
+        actions
+    }
+}

package/crates/naome-core/src/git.rs

@@ -0,0 +1,70 @@
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+use crate::paths;
+
+pub fn changed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let ignored_patterns = read_naomeignore_patterns(root);
+    let output = Command::new("git")
+        .args(["status", "--porcelain=v1", "-z", "-uall"])
+        .current_dir(root)
+        .output()?;
+
+    if !output.status.success() {
+        return Ok(Vec::new());
+    }
+
+    let mut paths = Vec::new();
+    let mut entries = output
+        .stdout
+        .split(|byte| *byte == 0)
+        .filter(|entry| !entry.is_empty());
+    while let Some(entry) = entries.next() {
+        if entry.len() < 4 {
+            continue;
+        }
+
+        let status = String::from_utf8_lossy(&entry[0..2]);
+        let path_bytes = &entry[3..];
+        if path_bytes.is_empty() {
+            continue;
+        }
+
+        let path = String::from_utf8_lossy(path_bytes).replace('\\', "/");
+        if !paths::matches_any(&path, &ignored_patterns) {
+            paths.push(path);
+        }
+
+        if status.contains('R') || status.contains('C') {
+            let _ = entries.next();
+        }
+    }
+
+    paths.sort();
+    paths.dedup();
+    Ok(paths)
+}
+
+fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(root.join(".naomeignore")) else {
+        return Vec::new();
+    };
+
+    content
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
+        .map(normalize_ignore_pattern)
+        .collect()
+}
+
+fn normalize_ignore_pattern(pattern: &str) -> String {
+    let normalized = pattern.trim_start_matches("./").replace('\\', "/");
+    if normalized.ends_with('/') {
+        format!("{normalized}**")
+    } else {
+        normalized
+    }
+}