@lamentis/naome 1.2.0 → 1.3.0

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

@@ -0,0 +1,67 @@
+use std::path::Path;
+
+use crate::models::{Decision, NaomeError};
+use crate::paths;
+use crate::task_state::harness_refresh_diff;
+
+pub(super) fn idle_diff_decision(
+    root: &Path,
+    changed_paths: &[String],
+    machine_owned: &[String],
+    known_harness_paths: &[String],
+) -> Result<Decision, NaomeError> {
+    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));
+
+    if harness_refresh_diff(root)?.is_some_and(|diff| diff.unrelated_paths.is_empty()) {
+        Ok(harness_repair_decision(
+            "Machine-owned NAOME harness refresh files changed outside an active task.",
+            "Run NAOME intent for the next natural-language request; deterministic policy can baseline a pure harness refresh automatically.",
+        ))
+    } else if all_machine_owned {
+        Ok(harness_repair_decision(
+            "Machine-owned NAOME harness files changed outside an active task.",
+            "Review and baseline the harness repair or cancel it before feature work.",
+        ))
+    } else if all_harness_owned {
+        Ok(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 {
+        Ok(Decision::new(
+            "dirty_unowned_diff",
+            true,
+            "The repository has changes not owned by an active NAOME task.",
+            vec!["review_unowned_diff"],
+            "Review the unowned diff, or route a new task so NAOME can isolate task work without touching it.",
+        ))
+    }
+}
+
+fn harness_repair_decision(user_message: &str, next_action: &str) -> Decision {
+    Decision::new(
+        "harness_repair_unbaselined",
+        true,
+        user_message,
+        vec![
+            "commit_upgrade_baseline",
+            "review_diff_first",
+            "cancel_upgrade_baseline",
+        ],
+        next_action,
+    )
+}

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

@@ -0,0 +1,36 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub(super) 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)?)
+}
+
+pub(super) fn json_bool(value: &Value, key: &str) -> Option<bool> {
+    value.get(key).and_then(Value::as_bool)
+}
+
+pub(super) fn json_string(value: &Value, key: &str) -> Option<String> {
+    value
+        .get(key)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+pub(super) 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()
+}

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

@@ -0,0 +1,165 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::{Decision, NaomeError, TaskDecision};
+use crate::paths;
+use crate::task_state::harness_refresh_diff;
+
+use super::idle::idle_diff_decision;
+use super::json::{json_string, read_json, string_array_at};
+
+pub(super) fn completed_task_decision(
+    root: &Path,
+    changed_paths: Vec<String>,
+    task: Option<&TaskDecision>,
+) -> Result<Decision, NaomeError> {
+    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 if has_completed_task_owned_paths(task, &changed_paths) {
+        Decision::new(
+            "completed_task_unbaselined",
+            true,
+            "A completed NAOME task is verified and waiting for the next routing decision.",
+            vec![
+                "commit_task_baseline",
+                "review_task_diff",
+                "request_task_changes",
+                "cancel_task_changes",
+            ],
+            "Run NAOME intent for the next natural-language request; deterministic policy can baseline a valid completed task automatically.",
+        )
+    } else if harness_refresh_diff(root)?.is_some_and(|diff| diff.unrelated_paths.is_empty()) {
+        Decision::new(
+            "harness_repair_unbaselined",
+            true,
+            "Machine-owned NAOME harness refresh files changed outside an active task.",
+            vec![
+                "commit_upgrade_baseline",
+                "review_diff_first",
+                "cancel_upgrade_baseline",
+            ],
+            "Run NAOME intent for the next natural-language request; deterministic policy can baseline a pure harness refresh automatically.",
+        )
+    } else {
+        Decision::new(
+            "dirty_unowned_diff",
+            true,
+            "The completed NAOME task has been baselined, but unrelated user changes remain.",
+            vec!["review_unowned_diff"],
+            "Review the unrelated diff, or route a new task so NAOME can isolate task work without touching it.",
+        )
+    };
+
+    decision.changed_paths = changed_paths;
+    decision.required_context = vec![
+        "docs/naome/execution.md".to_string(),
+        ".naome/task-state.json".to_string(),
+        "docs/naome/agent-workflow.md".to_string(),
+        "docs/naome/testing.md".to_string(),
+    ];
+    Ok(decision)
+}
+
+pub(super) fn active_task_decision(
+    changed_paths: Vec<String>,
+    task: Option<&TaskDecision>,
+) -> Decision {
+    let allowed_paths = task
+        .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.required_context = vec![
+        "docs/naome/execution.md".to_string(),
+        ".naome/task-state.json".to_string(),
+        "docs/naome/testing.md".to_string(),
+    ];
+    decision
+}
+
+pub(super) 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 mut decision =
+        idle_diff_decision(root, &changed_paths, &machine_owned, &known_harness_paths)?;
+
+    decision.changed_paths = changed_paths;
+    decision.required_context = vec![
+        "docs/naome/execution.md".to_string(),
+        ".naome/task-state.json".to_string(),
+    ];
+    Ok(decision)
+}
+
+pub(super) 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 has_completed_task_owned_paths(task: Option<&TaskDecision>, changed_paths: &[String]) -> bool {
+    let Some(task) = task else {
+        return false;
+    };
+
+    changed_paths
+        .iter()
+        .any(|path| is_control_state_path(path) || paths::matches_any(path, &task.allowed_paths))
+}
+
+fn is_control_state_path(path: &str) -> bool {
+    path == ".naome/task-state.json"
+}