@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-core/src/route/execution_baselines.rs

@@ -0,0 +1,146 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+use crate::task_state::{
+    completed_task_harness_refresh_diff, harness_refresh_diff, harness_refresh_with_unrelated_diff,
+};
+
+use super::execution::RouteExecution;
+use super::execution_support::{commit_completed_task, commit_harness_paths, set_created_worktree};
+use super::git_ops::{git_add_all, git_commit, git_head};
+use super::worktree::{
+    create_isolated_task_worktree_with_name_head, preflight_isolated_task_worktree,
+    task_worktree_name_head,
+};
+
+pub(super) fn baseline_completed_task(
+    root: &Path,
+    journal_action: &str,
+    message: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    commit_completed_task(root, git_head(root)?, journal_action, execution)?;
+    execution.user_message = message.to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_completed_task_then_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let name_head = task_worktree_name_head(root)?;
+    preflight_isolated_task_worktree(root, prompt, &name_head)?;
+    commit_completed_task(
+        root,
+        Some(name_head.clone()),
+        "route_auto_baseline",
+        execution,
+    )?;
+    let created = create_isolated_task_worktree_with_name_head(root, prompt, &name_head)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME baselined the completed task and created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn baseline_harness_refresh_then_completed_task(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(split) = completed_task_harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to split harness refresh paths from completed task diff.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    baseline_completed_task(
+        root,
+        "route_auto_baseline",
+        "NAOME baselined the harness refresh and completed task, then admitted the next task.",
+        execution,
+    )
+}
+
+pub(super) fn baseline_harness_refresh_then_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let name_head = task_worktree_name_head(root)?;
+    preflight_isolated_task_worktree(root, prompt, &name_head)?;
+    let Some(split) = harness_refresh_with_unrelated_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to split harness refresh paths from unrelated dirty paths.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    let created = create_isolated_task_worktree_with_name_head(root, prompt, &name_head)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME baselined the harness refresh and created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn baseline_pure_harness_refresh(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(diff) = harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to find deterministic harness refresh paths.",
+        ));
+    };
+    if !diff.unrelated_paths.is_empty() {
+        return Err(NaomeError::new(
+            "Harness refresh baseline expected no unrelated dirty paths.",
+        ));
+    }
+    commit_harness_paths(root, &diff.harness_paths, execution)?;
+    execution.user_message =
+        "NAOME baselined the harness refresh and is ready to create the next task in the same worktree."
+            .to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_harness_refresh(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(split) = harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to find deterministic harness refresh paths.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    execution.user_message =
+        "NAOME baselined the deterministic harness refresh and left unrelated user edits untouched."
+            .to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_setup(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    commit_upgrade_baseline(root, execution)?;
+    execution.user_message =
+        "NAOME baselined the setup changes and is ready to create the next task.".to_string();
+    Ok(())
+}
+
+pub(super) fn commit_upgrade_baseline(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_add_all(root)?;
+    git_commit(root, "chore(naome): baseline setup")?;
+    execution.mark_action("commit_upgrade_baseline");
+    Ok(())
+}

package/crates/naome-core/src/route/execution_support.rs

@@ -0,0 +1,57 @@
+use std::path::{Path, PathBuf};
+
+use crate::journal::append_task_journal;
+use crate::models::{Decision, NaomeError};
+
+use super::execution::RouteExecution;
+use super::git_ops::{git_add_completed_task_paths, git_commit, git_head, git_stage_only_paths};
+use super::RouteWorktree;
+
+pub(super) fn initial_decision_completed(decision: &Decision) -> bool {
+    decision
+        .task
+        .as_ref()
+        .map(|task| task.status.clone())
+        .as_deref()
+        .is_some_and(|status| status == "complete")
+}
+
+pub(super) fn commit_completed_task(
+    root: &Path,
+    before: Option<String>,
+    journal_action: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_add_completed_task_paths(root)?;
+    git_commit(root, "chore(naome): baseline completed task")?;
+    execution.journal_entry = append_task_journal(root, journal_action, before, git_head(root)?)?;
+    execution.mark_action("commit_task_baseline");
+    Ok(())
+}
+
+pub(super) fn commit_harness_paths(
+    root: &Path,
+    paths: &[String],
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_stage_only_paths(root, paths)?;
+    git_commit(root, "chore(naome): baseline harness refresh")?;
+    execution.mark_action("commit_harness_refresh_baseline");
+    Ok(())
+}
+
+pub(super) fn set_created_worktree(
+    root: &Path,
+    created: RouteWorktree,
+    prefix: &str,
+    execution: &mut RouteExecution,
+) {
+    execution.task_root = PathBuf::from(&created.path);
+    execution.mark_action("create_task_worktree");
+    execution.user_message = format!(
+        "{prefix} at {}. Continue the new task there; unrelated user edits remain untouched in the original worktree.",
+        created.path
+    );
+    debug_assert_eq!(created.source_root, root.to_string_lossy().to_string());
+    execution.worktree = Some(created);
+}

package/crates/naome-core/src/route/execution_tasks.rs

@@ -0,0 +1,71 @@
+use std::path::Path;
+
+use crate::git;
+use crate::journal::append_task_journal;
+use crate::models::{Decision, NaomeError};
+
+use super::execution::RouteExecution;
+use super::execution_support::{initial_decision_completed, set_created_worktree};
+use super::git_ops::{git_commit, git_head, git_stage_only_paths};
+use super::quality_gate::run_user_diff_quality_gate;
+use super::worktree::create_isolated_task_worktree;
+
+pub(super) fn create_task_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let created = create_isolated_task_worktree(root, prompt)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn commit_user_diff(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let paths = git::changed_paths(root)?;
+    execution
+        .executed_actions
+        .push("run_user_diff_quality_gate".to_string());
+    match run_user_diff_quality_gate(root, &paths) {
+        Ok(check_ids) => {
+            git_stage_only_paths(root, &paths)?;
+            git_commit(root, "chore(user): baseline verified user changes")?;
+            execution.mark_action("commit_user_diff");
+            execution.user_message = format!(
+                "NAOME quality gates passed ({}) and committed only the current user-owned changed paths.",
+                check_ids.join(", ")
+            );
+        }
+        Err(error) => {
+            execution.route_allowed = false;
+            execution.human_options = vec!["review_unowned_diff".to_string()];
+            execution.user_message =
+                format!("NAOME user-diff quality gate failed, so no commit was created. {error}");
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn journal_external_baseline_if_needed(
+    root: &Path,
+    initial_decision: &Decision,
+    repo_state_before: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    if repo_state_before != "ready_for_task" || !initial_decision_completed(initial_decision) {
+        return Ok(());
+    }
+    execution.journal_entry =
+        append_task_journal(root, "external_baseline", None, git_head(root)?)?;
+    if execution.journal_entry.is_some() {
+        execution.mark_action("journal_external_task_baseline");
+    }
+    Ok(())
+}

package/crates/naome-core/src/route/git_ops.rs

@@ -0,0 +1,72 @@
+use std::path::Path;
+use std::process::{Command, Output};
+
+use crate::models::NaomeError;
+use crate::task_state::completed_task_commit_paths;
+
+pub(super) fn git_head(root: &Path) -> Result<Option<String>, NaomeError> {
+    let output = git_output(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_add_all(root: &Path) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["add", "-A"])?)
+}
+
+pub(super) fn git_add_completed_task_paths(root: &Path) -> Result<(), NaomeError> {
+    let paths = completed_task_commit_paths(root)?;
+    if paths.is_empty() {
+        return Err(NaomeError::new(
+            "No task-owned paths are available to commit.",
+        ));
+    }
+    git_stage_only_paths(root, &paths)
+}
+
+pub(super) fn git_stage_only_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["reset", "-q", "--", "."])?)?;
+    git_add_paths(root, paths)
+}
+
+fn git_add_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    if paths.is_empty() {
+        return Ok(());
+    }
+    let mut args = vec!["add", "--"];
+    args.extend(paths.iter().map(String::as_str));
+    let output = Command::new("git").args(args).current_dir(root).output()?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(command_output(&output)))
+    }
+}
+
+pub(super) fn git_commit(root: &Path, message: &str) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["commit", "-m", message])?)
+}
+
+pub(super) fn git_output(root: &Path, args: &[&str]) -> Result<Output, NaomeError> {
+    Ok(Command::new("git").args(args).current_dir(root).output()?)
+}
+
+pub(super) fn ensure_git_success(output: Output) -> Result<(), NaomeError> {
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(command_output(&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/route/quality_gate.rs

@@ -0,0 +1,73 @@
+use std::path::Path;
+
+use crate::git;
+use crate::models::NaomeError;
+
+use super::builtin_checks::run_quality_check;
+pub(super) use super::quality_gate_config::QualityCheck;
+use super::quality_gate_config::{user_diff_check_ids, verification_checks};
+use super::quality_gate_snapshot::{
+    changed_path_snapshot, read_head_verification, sorted_path_set,
+    validate_changed_text_whitespace,
+};
+
+pub(super) fn run_user_diff_quality_gate(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<Vec<String>, NaomeError> {
+    if changed_paths.is_empty() {
+        return Err(NaomeError::new("No changed paths are available to commit."));
+    }
+    let verification = read_head_verification(root)?;
+    let checks = verification_checks(&verification);
+    let check_ids = user_diff_check_ids(&verification, changed_paths, &checks)?;
+
+    let initial_paths = sorted_path_set(changed_paths);
+    let mut previous_snapshot = changed_path_snapshot(root, changed_paths)?;
+    for _ in 0..3 {
+        validate_changed_text_whitespace(root, changed_paths)?;
+
+        for check_id in &check_ids {
+            let Some(check) = checks.get(check_id.as_str()) else {
+                return Err(NaomeError::new(format!(
+                    "Quality check {check_id} is referenced but not defined."
+                )));
+            };
+            run_quality_check(root, check_id, check)?;
+        }
+
+        let current_paths = git::changed_paths(root)?;
+        let current_set = sorted_path_set(&current_paths);
+        if current_set != initial_paths {
+            return Err(NaomeError::new(format!(
+                "Quality checks changed the diff path set from [{}] to [{}].",
+                initial_paths.iter().cloned().collect::<Vec<_>>().join(", "),
+                current_set.iter().cloned().collect::<Vec<_>>().join(", ")
+            )));
+        }
+
+        validate_changed_text_whitespace(root, changed_paths)?;
+        if let Some(check) = checks.get("diff-check") {
+            run_quality_check(root, "diff-check", check)?;
+        }
+        let current_paths = git::changed_paths(root)?;
+        let current_set = sorted_path_set(&current_paths);
+        if current_set != initial_paths {
+            return Err(NaomeError::new(format!(
+                "Quality checks changed the diff path set from [{}] to [{}].",
+                initial_paths.iter().cloned().collect::<Vec<_>>().join(", "),
+                current_set.iter().cloned().collect::<Vec<_>>().join(", ")
+            )));
+        }
+
+        let next_snapshot = changed_path_snapshot(root, changed_paths)?;
+        if next_snapshot == previous_snapshot {
+            return Ok(check_ids);
+        }
+        previous_snapshot = next_snapshot;
+    }
+
+    Err(NaomeError::new(
+        "Quality checks did not stabilize the user-owned diff after three runs.",
+    ))
+}

package/crates/naome-core/src/route/quality_gate_config.rs

@@ -0,0 +1,126 @@
+use std::collections::HashMap;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::paths;
+
+#[derive(Debug, Clone)]
+pub(super) struct QualityCheck {
+    pub(super) command: String,
+    pub(super) cwd: String,
+}
+
+pub(super) fn verification_checks(verification: &Value) -> HashMap<&str, QualityCheck> {
+    let mut checks = HashMap::new();
+    let Some(items) = verification.get("checks").and_then(Value::as_array) else {
+        return checks;
+    };
+
+    for item in items {
+        let Some(id) = item.get("id").and_then(Value::as_str) else {
+            continue;
+        };
+        let Some(command) = item.get("command").and_then(Value::as_str) else {
+            continue;
+        };
+        let cwd = item
+            .get("cwd")
+            .and_then(Value::as_str)
+            .unwrap_or(".")
+            .to_string();
+        checks.insert(
+            id,
+            QualityCheck {
+                command: command.to_string(),
+                cwd,
+            },
+        );
+    }
+
+    checks
+}
+
+pub(super) fn user_diff_check_ids(
+    verification: &Value,
+    changed_paths: &[String],
+    checks: &HashMap<&str, QualityCheck>,
+) -> Result<Vec<String>, NaomeError> {
+    let mut ids = Vec::new();
+    if checks.contains_key("diff-check") {
+        push_unique_string(&mut ids, "diff-check");
+    }
+    if checks.contains_key("naome-harness-health") {
+        push_unique_string(&mut ids, "naome-harness-health");
+    }
+
+    let Some(change_types) = verification.get("changeTypes").and_then(Value::as_array) else {
+        return Err(no_quality_coverage());
+    };
+    if change_types.is_empty() {
+        return Err(no_quality_coverage());
+    }
+
+    let mut uncovered_paths = Vec::new();
+    for change_type in change_types {
+        let patterns = string_array(change_type.get("paths"));
+        if patterns.is_empty()
+            || !changed_paths
+                .iter()
+                .any(|path| paths::matches_any(path, &patterns))
+        {
+            continue;
+        }
+
+        for check_id in string_array(change_type.get("requiredChecks")) {
+            push_unique_string(&mut ids, &check_id);
+        }
+    }
+
+    for path in changed_paths {
+        let covered = change_types.iter().any(|change_type| {
+            let patterns = string_array(change_type.get("paths"));
+            !patterns.is_empty() && paths::matches_any(path, &patterns)
+        });
+        if !covered {
+            uncovered_paths.push(path.clone());
+        }
+    }
+
+    if !uncovered_paths.is_empty() {
+        return Err(NaomeError::new(format!(
+            "No quality coverage is configured for changed path(s): {}.",
+            uncovered_paths.join(", ")
+        )));
+    }
+    if ids.is_empty() {
+        return Err(NaomeError::new(
+            "No quality checks are configured for these changed paths.",
+        ));
+    }
+
+    Ok(ids)
+}
+
+fn no_quality_coverage() -> NaomeError {
+    NaomeError::new("No quality coverage is configured for user-owned changed paths.")
+}
+
+fn string_array(value: Option<&Value>) -> Vec<String> {
+    value
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(Value::as_str)
+                .map(ToString::to_string)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn push_unique_string(values: &mut Vec<String>, value: &str) {
+    if !values.iter().any(|item| item == value) {
+        values.push(value.to_string());
+    }
+}

package/crates/naome-core/src/route/quality_gate_snapshot.rs

@@ -0,0 +1,69 @@
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub(super) fn validate_changed_text_whitespace(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<(), NaomeError> {
+    for relative_path in changed_paths {
+        let path = root.join(relative_path);
+        if !path.is_file() {
+            continue;
+        }
+        let Ok(content) = fs::read_to_string(&path) else {
+            continue;
+        };
+        for (index, line) in content.lines().enumerate() {
+            if line.ends_with(' ') || line.ends_with('\t') {
+                return Err(NaomeError::new(format!(
+                    "{relative_path}:{} has trailing whitespace.",
+                    index + 1
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn read_head_verification(root: &Path) -> Result<Value, NaomeError> {
+    let output = Command::new("git")
+        .args(["show", "HEAD:.naome/verification.json"])
+        .current_dir(root)
+        .output()?;
+
+    if !output.status.success() {
+        return Err(NaomeError::new(
+            "No committed NAOME verification profile is available for user-diff quality gating.",
+        ));
+    }
+
+    Ok(serde_json::from_slice(&output.stdout)?)
+}
+
+pub(super) fn sorted_path_set(paths: &[String]) -> BTreeSet<String> {
+    paths.iter().cloned().collect()
+}
+
+pub(super) fn changed_path_snapshot(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<Vec<(String, Option<Vec<u8>>)>, NaomeError> {
+    let mut snapshot = Vec::new();
+    for relative_path in changed_paths {
+        let path = root.join(relative_path);
+        let content = if path.is_file() {
+            Some(fs::read(&path)?)
+        } else {
+            None
+        };
+        snapshot.push((relative_path.clone(), content));
+    }
+    snapshot.sort_by(|left, right| left.0.cmp(&right.0));
+    Ok(snapshot)
+}

package/crates/naome-core/src/route/worktree.rs

@@ -0,0 +1,75 @@
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+use crate::route::{
+    git_ops::{command_output, git_head},
+    RouteWorktree,
+};
+
+use super::worktree_files::copy_local_harness_files;
+use super::worktree_plan::{available_worktree_candidates, worktree_plan};
+
+pub(super) fn create_isolated_task_worktree(
+    root: &Path,
+    prompt: &str,
+) -> Result<RouteWorktree, NaomeError> {
+    let name_head = task_worktree_name_head(root)?;
+    create_isolated_task_worktree_with_name_head(root, prompt, &name_head)
+}
+
+pub(super) fn create_isolated_task_worktree_with_name_head(
+    root: &Path,
+    prompt: &str,
+    name_head: &str,
+) -> Result<RouteWorktree, NaomeError> {
+    let base_head = git_head(root)?.ok_or_else(|| {
+        NaomeError::new("Cannot create task worktree because the repository has no HEAD.")
+    })?;
+    let plan = worktree_plan(root, prompt, name_head)?;
+    for candidate in available_worktree_candidates(root, &plan)? {
+        let path_text = candidate.path.to_string_lossy().to_string();
+        let output = Command::new("git")
+            .args([
+                "worktree",
+                "add",
+                "-b",
+                &candidate.branch,
+                &path_text,
+                "HEAD",
+            ])
+            .current_dir(root)
+            .output()?;
+        if !output.status.success() {
+            return Err(NaomeError::new(command_output(&output)));
+        }
+
+        copy_local_harness_files(root, &candidate.path)?;
+
+        return Ok(RouteWorktree {
+            path: path_text,
+            branch: candidate.branch,
+            base_head,
+            source_root: root.to_string_lossy().to_string(),
+        });
+    }
+
+    Err(NaomeError::new(
+        "Cannot create a unique NAOME task worktree after 99 attempts.",
+    ))
+}
+
+pub(super) fn preflight_isolated_task_worktree(
+    root: &Path,
+    prompt: &str,
+    name_head: &str,
+) -> Result<(), NaomeError> {
+    let plan = worktree_plan(root, prompt, name_head)?;
+    available_worktree_candidates(root, &plan).map(|_| ())
+}
+
+pub(super) fn task_worktree_name_head(root: &Path) -> Result<String, NaomeError> {
+    git_head(root)?.ok_or_else(|| {
+        NaomeError::new("Cannot create task worktree because the repository has no HEAD.")
+    })
+}