@lamentis/naome 1.2.0 → 1.2.1

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

@@ -1,14 +1,18 @@
-use std::ffi::OsString;
-use std::fs;
 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;
-use crate::task_state::harness_refresh_diff;
+
+mod checks;
+mod idle;
+mod json;
+mod states;
+
+use self::checks::{extract_known_actions, run_node_check};
+use self::json::{json_bool, json_string, read_json};
+use self::states::{
+    active_task_decision, classify_idle_diff, completed_task_decision, task_decision,
+};
 
 #[derive(Debug, Clone, Copy)]
 pub struct EvaluationOptions {
@@ -31,175 +35,29 @@ impl EvaluationOptions {
 
 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(),
-        ];
+    let harness_health = run_harness_health(root, options)?;
+    if let Some(decision) = harness_health_decision(&changed_paths, &harness_health) {
         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(),
-        ];
+    let task_state = read_json(root, ".naome/task-state.json")?;
+    if let Some(decision) = setup_block_decision(root, &changed_paths, &harness_health)? {
         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 if has_completed_task_owned_paths(task.as_ref(), &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;
+        let mut decision = completed_task_decision(root, changed_paths, task.as_ref())?;
         decision.harness_health = harness_health;
         decision.task = task;
-        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(),
-        ];
         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
-        };
+        let mut decision = active_task_decision(changed_paths, task.as_ref());
         decision.harness_health = harness_health;
         decision.task = task;
-        decision.required_context = vec![
-            "docs/naome/execution.md".to_string(),
-            ".naome/task-state.json".to_string(),
-            "docs/naome/testing.md".to_string(),
-        ];
         return Ok(decision);
     }
 
@@ -210,15 +68,91 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
         return Ok(decision);
     }
 
-    let task_admission = if options.run_external_checks {
-        Some(run_node_check(
+    ready_or_admission_blocked_decision(root, options, harness_health, task)
+}
+
+fn run_harness_health(
+    root: &Path,
+    options: EvaluationOptions,
+) -> Result<Option<CheckDecision>, NaomeError> {
+    if options.run_external_checks {
+        Ok(Some(run_node_check(
             root,
-            ".naome/bin/check-task-state.js",
-            &["--admission"],
-        )?)
+            ".naome/bin/check-harness-health.js",
+            &[],
+        )?))
     } else {
-        None
-    };
+        Ok(None)
+    }
+}
+
+fn harness_health_decision(
+    changed_paths: &[String],
+    harness_health: &Option<CheckDecision>,
+) -> Option<Decision> {
+    let check = harness_health.as_ref()?;
+    if check.ok {
+        return None;
+    }
+    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.to_vec();
+    decision.harness_health = harness_health.clone();
+    decision.required_context = vec![
+        ".naomeignore".to_string(),
+        "docs/naome/index.md".to_string(),
+        ".naome/manifest.json".to_string(),
+    ];
+    Some(decision)
+}
+
+fn setup_block_decision(
+    root: &Path,
+    changed_paths: &[String],
+    harness_health: &Option<CheckDecision>,
+) -> Result<Option<Decision>, NaomeError> {
+    let init_state = read_json(root, ".naome/init-state.json")?;
+    let upgrade_state = read_json(root, ".naome/upgrade-state.json")?;
+
+    if json_string(&upgrade_state, "status").as_deref() == Some("needs_agent_upgrade") {
+        return Ok(Some(static_block_decision(
+            "upgrade_required",
+            "NAOME upgrade requires agent follow-up.",
+            vec!["run_upgrade_protocol"],
+            "Run the NAOME upgrade protocol before feature work.",
+            &["docs/naome/upgrade.md", ".naome/upgrade-state.json"],
+            changed_paths,
+            harness_health,
+        )));
+    }
+
+    if json_bool(&init_state, "initialized") != Some(true) {
+        return Ok(Some(static_block_decision(
+            "first_run_required",
+            "NAOME first-run intake has not been completed.",
+            vec!["run_first_run_protocol"],
+            "Run the NAOME first-run protocol before feature work.",
+            &["docs/naome/first-run.md", ".naome/init-state.json"],
+            changed_paths,
+            harness_health,
+        )));
+    }
+
+    Ok(None)
+}
+
+fn ready_or_admission_blocked_decision(
+    root: &Path,
+    options: EvaluationOptions,
+    harness_health: Option<CheckDecision>,
+    task: Option<TaskDecision>,
+) -> Result<Decision, NaomeError> {
+    let task_admission = run_task_admission(root, options)?;
 
     if let Some(check) = &task_admission {
         if !check.ok {
@@ -259,6 +193,37 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
     Ok(decision)
 }
 
+fn run_task_admission(
+    root: &Path,
+    options: EvaluationOptions,
+) -> Result<Option<CheckDecision>, NaomeError> {
+    if options.run_external_checks {
+        Ok(Some(run_node_check(
+            root,
+            ".naome/bin/check-task-state.js",
+            &["--admission"],
+        )?))
+    } else {
+        Ok(None)
+    }
+}
+
+fn static_block_decision(
+    state: &str,
+    summary: &str,
+    actions: Vec<&str>,
+    next_action: &str,
+    required_context: &[&str],
+    changed_paths: &[String],
+    harness_health: &Option<CheckDecision>,
+) -> Decision {
+    let mut decision = Decision::new(state, true, summary, actions, next_action);
+    decision.changed_paths = changed_paths.to_vec();
+    decision.harness_health = harness_health.clone();
+    decision.required_context = required_context.iter().map(ToString::to_string).collect();
+    decision
+}
+
 pub fn format_decision(decision: &Decision, mode: &str) -> String {
     let title = if mode == "next" {
         "NAOME next"
@@ -314,190 +279,3 @@ fn is_intent_routed_baseline_state(state: &str) -> bool {
             | "harness_repair_unbaselined"
     )
 }
-
-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 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 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"],
-            "Review the unowned 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(),
-    ];
-    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 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 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; 11] = [
-        "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",
-        "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/install_plan.rs

@@ -22,11 +22,13 @@ pub const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/upgrade-state.json",
     ".naome/verification.json",
     ".naome/repository-quality.json",
+    ".naome/repository-structure.json",
     ".naome/repository-quality-baseline.json",
     "docs/naome/architecture.md",
     "docs/naome/decisions.md",
     "docs/naome/repo-profile.md",
     "docs/naome/repository-quality.md",
+    "docs/naome/repository-structure.md",
     "docs/naome/security.md",
     "docs/naome/testing.md",
 ];

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

@@ -16,13 +16,15 @@ mod workflow;
 pub use decision::{evaluate_decision, format_decision, EvaluationOptions};
 pub use harness_health::{validate_harness_health, HarnessHealthOptions};
 pub use install_plan::{install_plan, InstallPlan};
+pub use install_plan::{MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS};
 pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence};
 pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
 pub use quality::{
-    check_repository_quality, init_repository_quality, plan_quality_cleanup, route_quality_cleanup,
-    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitResult, QualityMode,
-    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+    check_repository_quality, explain_repository_structure, init_repository_quality,
+    plan_quality_cleanup, route_quality_cleanup, QualityCleanupPlan, QualityCleanupRoute,
+    QualityCleanupTask, QualityInitResult, QualityMode, QualityReport, QualitySummary,
+    QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig, StructurePathExplanation,
 };
 pub use route::{evaluate_route, explain_route, ExplainDecision, RouteDecision, RouteOptions};
 pub use task_state::{

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

@@ -13,7 +13,9 @@ fn matches_pattern(path: &str, pattern: &str) -> bool {
     }
 
     if let Some(prefix) = normalized_pattern.strip_suffix("/**") {
-        return normalized_path == prefix || normalized_path.starts_with(&format!("{prefix}/"));
+        if !prefix.contains('*') {
+            return normalized_path == prefix || normalized_path.starts_with(&format!("{prefix}/"));
+        }
     }
 
     if !normalized_pattern.contains('*') {

package/crates/naome-core/src/quality/adapter_support.rs

@@ -0,0 +1,89 @@
+use std::collections::HashSet;
+
+use crate::models::NaomeError;
+
+pub(crate) struct RepoSignals<'a> {
+    paths: &'a [String],
+}
+
+impl<'a> RepoSignals<'a> {
+    pub(crate) fn new(paths: &'a [String]) -> Self {
+        Self { paths }
+    }
+
+    pub(crate) fn has_manifest(&self, expected: &str) -> bool {
+        let nested_suffix = format!("/{expected}");
+        self.paths
+            .iter()
+            .any(|path| path == expected || path.ends_with(&nested_suffix))
+    }
+
+    pub(crate) fn has_extension(&self, extensions: &[&str]) -> bool {
+        self.paths
+            .iter()
+            .any(|path| extensions.iter().any(|extension| path.ends_with(extension)))
+    }
+}
+
+pub(crate) trait AdapterDescriptor {
+    fn id(&self) -> &'static str;
+    fn detects(&self, signals: &RepoSignals<'_>) -> bool;
+}
+
+pub(crate) fn detected_ids<T: AdapterDescriptor>(paths: &[String], registry: &[T]) -> Vec<String> {
+    let signals = RepoSignals::new(paths);
+    registry
+        .iter()
+        .filter(|adapter| adapter.detects(&signals))
+        .map(|adapter| adapter.id().to_string())
+        .collect()
+}
+
+pub(crate) fn find_adapter_by_id<'a, T: AdapterDescriptor>(
+    registry: &'a [T],
+    id: &str,
+    config_path: &str,
+) -> Result<&'a T, NaomeError> {
+    registry
+        .iter()
+        .find(|adapter| adapter.id() == id)
+        .ok_or_else(|| {
+            NaomeError::new(format!(
+                "{config_path} enabledAdapters contains unknown adapter '{id}'."
+            ))
+        })
+}
+
+pub(crate) fn validate_ids<T: AdapterDescriptor>(
+    ids: &[String],
+    registry: &[T],
+    config_path: &str,
+) -> Result<(), NaomeError> {
+    let mut seen = HashSet::new();
+    for adapter_id in ids {
+        if !seen.insert(adapter_id) {
+            return Err(NaomeError::new(format!(
+                "{config_path} enabledAdapters contains duplicate adapter '{adapter_id}'."
+            )));
+        }
+        find_adapter_by_id(registry, adapter_id, config_path)?;
+    }
+    Ok(())
+}
+
+pub(crate) fn extend_unique(target: &mut Vec<String>, values: &[&str]) {
+    for value in values {
+        if !target.iter().any(|existing| existing == value) {
+            target.push((*value).to_string());
+        }
+    }
+}
+
+pub(crate) fn detects_rust_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("Cargo.toml") || signals.has_extension(&[".rs"])
+}
+
+pub(crate) fn detects_javascript_typescript_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("package.json")
+        || signals.has_extension(&[".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"])
+}