@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-cli/src/quality_commands.rs

@@ -0,0 +1,229 @@
+use std::path::Path;
+
+use naome_core::{
+    check_repository_quality, explain_repository_structure, init_repository_quality,
+    plan_quality_cleanup, route_quality_cleanup, QualityMode,
+};
+
+use crate::cli_args::option_value;
+
+pub fn run_quality_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome quality requires init, check, or report.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "init" => {
+            let result = init_repository_quality(root)?;
+            if json {
+                println!("{}", serde_json::to_string_pretty(&result)?);
+            } else {
+                println!("NAOME repository quality initialized.");
+                println!("Baseline violations: {}", result.baseline_violations);
+            }
+        }
+        "check" => run_quality_check(root, args, json)?,
+        "report" => run_quality_report(root, json)?,
+        _ => return Err(format!("unknown naome quality command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+pub fn run_cleanup_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome cleanup requires plan or route.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "plan" => run_cleanup_plan(root, json)?,
+        "route" => run_cleanup_route(root, args, json)?,
+        _ => return Err(format!("unknown naome cleanup command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+pub fn run_structure_command(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome structure requires report or explain.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "report" => run_structure_report(root, json)?,
+        "explain" => run_structure_explain(root, args, json)?,
+        _ => return Err(format!("unknown naome structure command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+fn run_quality_check(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !args.iter().any(|arg| arg == "--changed") {
+        return Err("naome quality check requires --changed.".into());
+    }
+    let report = check_repository_quality(root, QualityMode::Changed)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.ok {
+        println!("NAOME repository quality OK.");
+    } else {
+        eprintln!(
+            "NAOME repository quality failed with {} violation(s).",
+            report.violations.len()
+        );
+        for violation in report.violations.iter().take(20) {
+            print_quality_violation(violation);
+        }
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_quality_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let report = check_repository_quality(root, QualityMode::Report)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.violations.is_empty() {
+        println!("NAOME repository quality report: no debt found.");
+    } else {
+        println!(
+            "NAOME repository quality report: {} violation(s) across {} scanned file(s).",
+            report.violations.len(),
+            report.summary.scanned_files
+        );
+        for violation in report.violations.iter().take(20) {
+            print_quality_violation(violation);
+        }
+    }
+    Ok(())
+}
+
+fn run_cleanup_plan(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let plan = plan_quality_cleanup(root)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&plan)?);
+    } else if plan.tasks.is_empty() {
+        println!("NAOME cleanup plan: no repository-quality debt found.");
+    } else {
+        println!("NAOME cleanup plan:");
+        for task in plan.tasks.iter().take(20) {
+            println!(
+                "- {}: {} violation(s) [{}]",
+                task.path,
+                task.violation_count,
+                task.check_ids.join(", ")
+            );
+        }
+    }
+    Ok(())
+}
+
+fn run_cleanup_route(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(path) = option_value(args, "--path") else {
+        return Err("naome cleanup route requires --path <path>.".into());
+    };
+    let route = route_quality_cleanup(root, path)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&route)?);
+    } else {
+        println!("NAOME cleanup route for {}", route.path);
+        println!("{}", route.agent_instructions);
+        if !route.related_paths.is_empty() {
+            println!("Related paths: {}", route.related_paths.join(", "));
+        }
+    }
+    Ok(())
+}
+
+fn run_structure_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let mut report = check_repository_quality(root, QualityMode::Report)?;
+    report
+        .violations
+        .retain(|violation| is_structure_check(&violation.check_id));
+    report.summary.violation_count = report.violations.len();
+    report.summary.blocking_violation_count = report.violations.len();
+    report.summary.baseline_violation_count = report
+        .violations
+        .iter()
+        .filter(|violation| violation.baseline)
+        .count();
+    report.ok = report.violations.is_empty();
+    report.schema = "naome.repository-structure-report.v1".to_string();
+
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.violations.is_empty() {
+        println!("NAOME repository structure report: no debt found.");
+    } else {
+        println!(
+            "NAOME repository structure report: {} violation(s).",
+            report.violations.len()
+        );
+        for violation in report.violations.iter().take(20) {
+            print_quality_violation(violation);
+        }
+    }
+    Ok(())
+}
+
+fn run_structure_explain(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(path) = option_value(args, "--path") else {
+        return Err("naome structure explain requires --path <path>.".into());
+    };
+    let explanation = explain_repository_structure(root, path)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&explanation)?);
+    } else {
+        println!(
+            "{} role={} layer={} directory={}",
+            explanation.path, explanation.role, explanation.layer, explanation.directory
+        );
+        if let Some(language) = explanation.language {
+            println!("language={language}");
+        }
+        if let Some(module) = explanation.module {
+            println!("module={module}");
+        }
+    }
+    Ok(())
+}
+
+fn is_structure_check(check_id: &str) -> bool {
+    matches!(
+        check_id,
+        "directory-role-mixing"
+            | "misplaced-file-role"
+            | "root-file-sprawl"
+            | "dumping-ground-directory"
+            | "directory-size"
+            | "path-depth"
+            | "case-collision"
+            | "test-source-pairing"
+    )
+}
+
+fn print_quality_violation(violation: &naome_core::QualityViolation) {
+    let location = violation
+        .line
+        .map(|line| format!("{}:{line}", violation.path))
+        .unwrap_or_else(|| violation.path.clone());
+    eprintln!("- {location} {}: {}", violation.check_id, violation.message);
+}

package/crates/naome-cli/src/simple_commands.rs

@@ -0,0 +1,53 @@
+use std::path::Path;
+
+use naome_core::{install_plan, seed_builtin_verification_checks};
+
+use crate::cli_args::option_value;
+
+pub fn print_install_plan(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let harness_version = option_value(args, "--harness-version")
+        .or_else(|| option_value(args, "--version"))
+        .unwrap_or_else(|| env!("CARGO_PKG_VERSION").to_string());
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&install_plan(harness_version))?
+    );
+    Ok(())
+}
+
+pub fn seed_verification(root: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    if seed_builtin_verification_checks(root)? {
+        println!("NAOME verification checks updated.");
+    } else {
+        println!("NAOME verification checks already present.");
+    }
+    Ok(())
+}
+
+pub fn run_journal_task(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let outcome =
+        option_value(args, "--outcome").unwrap_or_else(|| "naome_commit_baseline".to_string());
+    let commit_before = option_value(args, "--commit-before");
+    let commit_after = option_value(args, "--commit-after");
+    let entry = naome_core::append_task_journal(root, &outcome, commit_before, commit_after)?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&entry)?);
+    } else if entry.is_some() {
+        println!("NAOME task journal updated.");
+    } else {
+        println!("NAOME task journal had no active task to record.");
+    }
+    Ok(())
+}
+
+pub fn run_commit_paths(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let paths = naome_core::completed_task_commit_paths(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&paths)?);
+    } else {
+        for path in paths {
+            println!("{path}");
+        }
+    }
+    Ok(())
+}

package/crates/naome-cli/src/workflow_commands.rs

@@ -0,0 +1,153 @@
+use std::path::Path;
+
+use naome_core::{
+    classify_mutations, refresh_integrity, safe_rg_args, tracked_process_report,
+    validate_search_command, verification_phase_plan,
+};
+
+use crate::cli_args::option_value;
+
+pub fn run_refresh_integrity(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let report = refresh_integrity(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.updated {
+        println!(
+            "NAOME integrity refreshed: {}.",
+            report.changed_paths.join(", ")
+        );
+    } else {
+        println!("NAOME integrity already current.");
+    }
+    Ok(())
+}
+
+pub fn run_workflow_command(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome workflow requires search-profile, check-search, phases, processes, or mutations.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "search-profile" => {
+            let args = safe_rg_args(root)?;
+            if json {
+                println!("{}", serde_json::to_string_pretty(&args)?);
+            } else {
+                println!(
+                    "{}",
+                    args.iter()
+                        .map(|arg| shell_quote(arg))
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                );
+            }
+        }
+        "check-search" => run_check_search(root, args, json)?,
+        "phases" => {
+            let plan = verification_phase_plan(root, &[])?;
+            if json {
+                println!("{}", serde_json::to_string_pretty(&plan)?);
+            } else {
+                println!(
+                    "Recommended checks: {}",
+                    empty_label(&plan.recommended_check_ids)
+                );
+                if !plan.withheld_check_ids.is_empty() {
+                    println!("Withheld checks: {}", plan.withheld_check_ids.join(", "));
+                }
+            }
+        }
+        "processes" => {
+            let report = tracked_process_report(root)?;
+            if json {
+                println!("{}", serde_json::to_string_pretty(&report)?);
+            } else if report.active.is_empty() {
+                println!("NAOME tracked processes OK.");
+            } else {
+                println!("Active tracked processes:");
+                for process in report.active {
+                    println!("- {} [{}]", process.command, process.cwd);
+                }
+            }
+        }
+        "mutations" => run_mutations(root, args, json)?,
+        _ => return Err(format!("unknown naome workflow command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+fn run_check_search(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(command) = option_value(args, "--command") else {
+        return Err("naome workflow check-search requires --command <command>.".into());
+    };
+    let findings = validate_search_command(root, &command)?;
+    if !json && findings.is_empty() {
+        println!("NAOME search command OK.");
+    }
+    if json {
+        println!("{}", serde_json::to_string_pretty(&findings)?);
+    } else {
+        for finding in &findings {
+            println!("- {}: {}", finding.check_id, finding.message);
+        }
+    }
+    if !findings.is_empty() {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_mutations(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let paths = args
+        .iter()
+        .skip_while(|arg| arg.as_str() != "--path")
+        .skip(1)
+        .filter(|arg| !arg.starts_with("--"))
+        .cloned()
+        .collect::<Vec<_>>();
+    if paths.is_empty() {
+        return Err("naome workflow mutations requires --path <path> [path...]".into());
+    }
+    let classes = classify_mutations(root, &paths)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&classes)?);
+    } else {
+        for entry in classes {
+            println!("{}: {}", entry.path, entry.mutation_class);
+        }
+    }
+    Ok(())
+}
+
+fn empty_label(values: &[String]) -> String {
+    if values.is_empty() {
+        "none".to_string()
+    } else {
+        values.join(", ")
+    }
+}
+
+fn shell_quote(value: &str) -> String {
+    if value
+        .chars()
+        .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.' | '/' | ':'))
+    {
+        return value.to_string();
+    }
+    format!("'{}'", value.replace('\'', "'\\''"))
+}

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.1.2"
+version = "1.2.1"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -0,0 +1,64 @@
+use std::ffi::OsString;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::{CheckDecision, NaomeError};
+
+pub(super) 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(),
+    })
+}
+
+pub(super) 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/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()
+}