@lamentis/naome 1.1.1 → 1.2.0

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

@@ -0,0 +1,36 @@
+use std::path::Path;
+
+use crate::check_commands::{run_harness_health, run_task_state, run_verification_contract};
+use crate::install_bridge::run_install_bridge;
+use crate::prompt_commands::{run_explain, run_intent, run_route};
+use crate::quality_commands::{run_cleanup_command, run_quality_command};
+use crate::simple_commands::{
+    print_install_plan, run_commit_paths, run_journal_task, seed_verification,
+};
+use crate::workflow_commands::{run_refresh_integrity, run_workflow_command};
+
+pub fn dispatch_command(
+    root: &Path,
+    command: &str,
+    args: &[String],
+) -> Result<bool, Box<dyn std::error::Error>> {
+    match command {
+        "install" | "sync" => run_install_bridge(command, args)?,
+        "install-plan" => print_install_plan(args)?,
+        "seed-verification" => seed_verification(root)?,
+        "refresh-integrity" => run_refresh_integrity(root, args)?,
+        "quality" => run_quality_command(root, args)?,
+        "cleanup" => run_cleanup_command(root, args)?,
+        "workflow" => run_workflow_command(root, args)?,
+        "check-harness-health" => run_harness_health(root, args)?,
+        "check-task-state" => run_task_state(root, args)?,
+        "validate-verification" => run_verification_contract(root)?,
+        "intent" => run_intent(root, args)?,
+        "route" => run_route(root, args)?,
+        "explain" => run_explain(root, args)?,
+        "journal-task" => run_journal_task(root, args)?,
+        "commit-paths" => run_commit_paths(root, args)?,
+        _ => return Ok(false),
+    }
+    Ok(true)
+}

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

@@ -0,0 +1,83 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+use crate::cli_args::option_value;
+
+pub fn run_install_bridge(
+    command: &str,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let package_root = option_value(args, "--package-root")
+        .map(PathBuf::from)
+        .or_else(|| std::env::var("NAOME_PACKAGE_ROOT").ok().map(PathBuf::from))
+        .or_else(resolve_package_root_from_exe)
+        .or_else(resolve_package_root_from_cwd);
+    let installer_js = option_value(args, "--installer-js")
+        .map(PathBuf::from)
+        .or_else(|| std::env::var("NAOME_INSTALLER_JS").ok().map(PathBuf::from))
+        .or_else(|| {
+            package_root
+                .as_ref()
+                .map(|root| root.join("bin").join("naome-node.js"))
+        });
+    let Some(installer_js) = installer_js.filter(|path| path.is_file()) else {
+        return Err(format!(
+            "native {command} needs naome-node.js. Install the naome npm package, or pass --package-root/--installer-js."
+        )
+        .into());
+    };
+
+    let node_bin = std::env::var("NAOME_NODE_BIN").unwrap_or_else(|_| "node".to_string());
+    let status = Command::new(node_bin)
+        .arg(installer_js)
+        .args(strip_install_bridge_options(args))
+        .status()?;
+
+    if status.success() {
+        return Ok(());
+    }
+
+    std::process::exit(status.code().unwrap_or(1));
+}
+
+fn strip_install_bridge_options(args: &[String]) -> Vec<String> {
+    let mut result = Vec::new();
+    let mut index = 1;
+    while index < args.len() {
+        let arg = &args[index];
+        if arg == "--package-root" || arg == "--installer-js" {
+            index += 2;
+            continue;
+        }
+        if arg.starts_with("--package-root=") || arg.starts_with("--installer-js=") {
+            index += 1;
+            continue;
+        }
+        result.push(arg.clone());
+        index += 1;
+    }
+    result
+}
+
+fn resolve_package_root_from_exe() -> Option<PathBuf> {
+    let exe = std::env::current_exe().ok()?;
+    let platform_dir = exe.parent()?;
+    let native_dir = platform_dir.parent()?;
+    if native_dir.file_name().and_then(|value| value.to_str()) == Some("native") {
+        let package_root = native_dir.parent()?.to_path_buf();
+        if package_root.join("bin").join("naome-node.js").is_file() {
+            return Some(package_root);
+        }
+    }
+    None
+}
+
+fn resolve_package_root_from_cwd() -> Option<PathBuf> {
+    let current = std::env::current_dir().ok()?;
+    for candidate in [current.join("packages").join("naome"), current] {
+        if candidate.join("bin").join("naome-node.js").is_file() {
+            return Some(candidate);
+        }
+    }
+    None
+}

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

@@ -1,13 +1,45 @@
-use std::collections::HashMap;
-use std::fs;
+mod check_commands;
+mod cli_args;
+mod dispatcher;
+mod install_bridge;
+mod prompt_commands;
+mod quality_commands;
+mod simple_commands;
+mod workflow_commands;
+
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
-use naome_core::{
-    evaluate_decision, format_decision, install_plan, seed_builtin_verification_checks,
-    validate_harness_health, validate_task_state, validate_verification_contract,
-    EvaluationOptions, HarnessHealthOptions, TaskStateMode, TaskStateOptions,
-};
+use cli_args::option_value;
+use dispatcher::dispatch_command;
+use naome_core::{evaluate_decision, format_decision, EvaluationOptions};
+
+const HELP: &str = r#"Usage:
+  naome status [--json]
+  naome next [--json]
+  naome intent --prompt-file <path> [--json]
+  naome intent --prompt <text> [--json]
+  naome route --prompt-file <path> [--execute] [--json]
+  naome route --prompt <text> [--execute] [--json]
+  naome explain --prompt-file <path> [--json]
+  naome explain --prompt <text> [--json]
+  naome install [--package-root <path>] [--installer-js <path>]
+  naome sync [--package-root <path>] [--installer-js <path>]
+  naome install-plan [--harness-version <version>]
+  naome seed-verification
+  naome refresh-integrity [--root <path>] [--json]
+  naome quality init [--json]
+  naome quality check --changed [--json]
+  naome quality report [--json]
+  naome cleanup plan [--json]
+  naome cleanup route --path <path> [--json]
+  naome workflow search-profile [--json]
+  naome workflow check-search --command <cmd> [--json]
+  naome workflow phases [--json]
+  naome workflow processes [--json]
+  naome workflow mutations --path <path> [path...] [--json]
+  naome check-harness-health [--root <path>] [--allow-missing-archive]
+  naome check-task-state [--root <path>] [--admission|--progress|--commit-gate|--push-gate] [--allow-missing-archive]
+  naome validate-verification [--root <path>]"#;
 
 fn main() {
     if let Err(error) = run() {
@@ -36,6 +68,10 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
         && command != "journal-task"
         && command != "commit-paths"
         && command != "seed-verification"
+        && command != "refresh-integrity"
+        && command != "workflow"
+        && command != "quality"
+        && command != "cleanup"
         && command != "install-plan"
         && command != "install"
         && command != "sync"
@@ -52,6 +88,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
     } else if command == "validate-verification"
         || command == "check-harness-health"
         || command == "check-task-state"
+        || command == "refresh-integrity"
     {
         option_value(&args, "--root")
             .map(PathBuf::from)
@@ -63,187 +100,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
         )?
     };
 
-    if command == "install" || command == "sync" {
-        run_install_bridge(command, &args)?;
-        return Ok(());
-    }
-
-    if command == "install-plan" {
-        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))?
-        );
-        return Ok(());
-    }
-
-    if command == "seed-verification" {
-        if seed_builtin_verification_checks(&root)? {
-            println!("NAOME verification checks updated.");
-        } else {
-            println!("NAOME verification checks already present.");
-        }
-        return Ok(());
-    }
-
-    if command == "check-harness-health" {
-        let options = HarnessHealthOptions {
-            expected_integrity: expected_integrity_from_env()?,
-            allow_missing_integrity: std::env::var("NAOME_ALLOW_MISSING_INTEGRITY")
-                .is_ok_and(|value| value == "1"),
-            allow_missing_archive: args.iter().any(|arg| arg == "--allow-missing-archive"),
-        };
-        let errors = validate_harness_health(&root, options)?;
-        if errors.is_empty() {
-            println!("NAOME harness health OK.");
-            return Ok(());
-        }
-
-        eprintln!("NAOME harness health check failed.");
-        for error in errors {
-            eprintln!("- {error}");
-        }
-        std::process::exit(1);
-    }
-
-    if command == "check-task-state" {
-        let mode = if args.iter().any(|arg| arg == "--admission") {
-            TaskStateMode::Admission
-        } else if args.iter().any(|arg| arg == "--progress") {
-            TaskStateMode::Progress
-        } else if args.iter().any(|arg| arg == "--commit-gate") {
-            TaskStateMode::CommitGate
-        } else if args.iter().any(|arg| arg == "--push-gate") {
-            TaskStateMode::PushGate
-        } else {
-            TaskStateMode::State
-        };
-        let expected_integrity = expected_integrity_from_env()?;
-        let harness_health = if expected_integrity.is_empty()
-            && std::env::var("NAOME_ALLOW_MISSING_INTEGRITY").is_err()
-        {
-            None
-        } else {
-            Some(HarnessHealthOptions {
-                expected_integrity,
-                allow_missing_integrity: std::env::var("NAOME_ALLOW_MISSING_INTEGRITY")
-                    .is_ok_and(|value| value == "1"),
-                allow_missing_archive: args.iter().any(|arg| arg == "--allow-missing-archive"),
-            })
-        };
-        let report = validate_task_state(
-            &root,
-            TaskStateOptions {
-                mode,
-                harness_health,
-            },
-        )?;
-        if report.errors.is_empty() {
-            println!("{}", task_state_success_message(mode));
-            for notice in report.notices {
-                println!("- {notice}");
-            }
-            return Ok(());
-        }
-
-        eprintln!("{}", task_state_failure_message(mode));
-        for error in report.errors {
-            eprintln!("- {error}");
-        }
-        std::process::exit(1);
-    }
-
-    if command == "validate-verification" {
-        let errors = validate_verification_contract(&root)?;
-        if errors.is_empty() {
-            println!("NAOME verification contract OK.");
-            return Ok(());
-        }
-
-        eprintln!("NAOME verification contract failed.");
-        for error in errors {
-            eprintln!("- {error}");
-        }
-        std::process::exit(1);
-    }
-
-    if command == "intent" {
-        let prompt = prompt_from_args(&args)?;
-        let intent = naome_core::evaluate_intent(&root, &prompt, EvaluationOptions::online())?;
-        if args.iter().any(|arg| arg == "--json") {
-            println!("{}", serde_json::to_string_pretty(&intent)?);
-        } else {
-            print!("{}", naome_core::format_intent(&intent));
-        }
-        return Ok(());
-    }
-
-    if command == "route" {
-        let prompt = prompt_from_args(&args)?;
-        let route = naome_core::evaluate_route(
-            &root,
-            &prompt,
-            naome_core::RouteOptions {
-                execute: args.iter().any(|arg| arg == "--execute"),
-                evaluation: EvaluationOptions::online(),
-            },
-        )?;
-        if args.iter().any(|arg| arg == "--json") {
-            println!("{}", serde_json::to_string_pretty(&route)?);
-        } else {
-            println!("{}", route.user_message);
-            if !route.human_options.is_empty() {
-                println!("Human options: {}", route.human_options.join(", "));
-            }
-        }
-        return Ok(());
-    }
-
-    if command == "explain" {
-        let prompt = prompt_from_args(&args)?;
-        let explain = naome_core::explain_route(&root, &prompt, EvaluationOptions::online())?;
-        if args.iter().any(|arg| arg == "--json") {
-            println!("{}", serde_json::to_string_pretty(&explain)?);
-        } else {
-            println!("NAOME explain: {}", explain.winning_rule);
-            println!("Repo state: {}", explain.repo_state);
-            println!("Prompt intent: {}", explain.prompt_intent);
-            println!("Would mutate: {}", explain.would_mutate);
-            println!("Message: {}", explain.user_message);
-            if !explain.human_options.is_empty() {
-                println!("Human options: {}", explain.human_options.join(", "));
-            }
-        }
-        return Ok(());
-    }
-
-    if command == "journal-task" {
-        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.");
-        }
-        return Ok(());
-    }
-
-    if command == "commit-paths" {
-        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}");
-            }
-        }
+    if dispatch_command(&root, command, &args)? {
         return Ok(());
     }
 
@@ -268,22 +125,21 @@ fn is_help_request(args: &[String]) -> bool {
 }
 
 fn find_harness_root(start: &Path) -> Option<PathBuf> {
-    let mut current = start.to_path_buf();
-    loop {
-        if current.join(".naome").join("task-state.json").is_file() {
-            return Some(current);
-        }
-
-        if !current.pop() {
-            return None;
-        }
-    }
+    find_root_with_marker(start, &[".naome", "task-state.json"])
 }
 
 fn find_manifest_root(start: &Path) -> Option<PathBuf> {
+    find_root_with_marker(start, &[".naome", "manifest.json"])
+}
+
+fn find_root_with_marker(start: &Path, marker: &[&str]) -> Option<PathBuf> {
     let mut current = start.to_path_buf();
     loop {
-        if current.join(".naome").join("manifest.json").is_file() {
+        if marker
+            .iter()
+            .fold(current.clone(), |path, part| path.join(part))
+            .is_file()
+        {
             return Some(current);
         }
 
@@ -294,145 +150,5 @@ fn find_manifest_root(start: &Path) -> Option<PathBuf> {
 }
 
 fn print_help() {
-    println!("Usage:");
-    println!("  naome status [--json]");
-    println!("  naome next [--json]");
-    println!("  naome intent --prompt-file <path> [--json]");
-    println!("  naome intent --prompt <text> [--json]");
-    println!("  naome route --prompt-file <path> [--execute] [--json]");
-    println!("  naome route --prompt <text> [--execute] [--json]");
-    println!("  naome explain --prompt-file <path> [--json]");
-    println!("  naome explain --prompt <text> [--json]");
-    println!("  naome install [--package-root <path>] [--installer-js <path>]");
-    println!("  naome sync [--package-root <path>] [--installer-js <path>]");
-    println!("  naome install-plan [--harness-version <version>]");
-    println!("  naome seed-verification");
-    println!("  naome check-harness-health [--root <path>] [--allow-missing-archive]");
-    println!("  naome check-task-state [--root <path>] [--admission|--progress|--commit-gate|--push-gate] [--allow-missing-archive]");
-    println!("  naome validate-verification [--root <path>]");
-}
-
-fn option_value(args: &[String], option: &str) -> Option<String> {
-    args.windows(2)
-        .find(|window| window[0] == option)
-        .map(|window| window[1].clone())
-}
-
-fn prompt_from_args(args: &[String]) -> Result<String, Box<dyn std::error::Error>> {
-    if let Some(prompt_file) = option_value(args, "--prompt-file") {
-        return Ok(fs::read_to_string(prompt_file)?);
-    }
-
-    if let Some(prompt) = option_value(args, "--prompt") {
-        return Ok(prompt);
-    }
-
-    Err("naome prompt routing requires --prompt-file <path> or --prompt <text>.".into())
-}
-
-fn run_install_bridge(command: &str, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
-    let package_root = option_value(args, "--package-root")
-        .map(PathBuf::from)
-        .or_else(|| std::env::var("NAOME_PACKAGE_ROOT").ok().map(PathBuf::from))
-        .or_else(resolve_package_root_from_exe)
-        .or_else(resolve_package_root_from_cwd);
-    let installer_js = option_value(args, "--installer-js")
-        .map(PathBuf::from)
-        .or_else(|| std::env::var("NAOME_INSTALLER_JS").ok().map(PathBuf::from))
-        .or_else(|| {
-            package_root
-                .as_ref()
-                .map(|root| root.join("bin").join("naome-node.js"))
-        });
-    let Some(installer_js) = installer_js.filter(|path| path.is_file()) else {
-        return Err(format!(
-            "native {command} needs naome-node.js. Install the naome npm package, or pass --package-root/--installer-js."
-        )
-        .into());
-    };
-
-    let node_bin = std::env::var("NAOME_NODE_BIN").unwrap_or_else(|_| "node".to_string());
-    let pass_through_args = strip_install_bridge_options(args);
-    let status = Command::new(node_bin)
-        .arg(installer_js)
-        .args(pass_through_args)
-        .status()?;
-
-    if status.success() {
-        return Ok(());
-    }
-
-    std::process::exit(status.code().unwrap_or(1));
-}
-
-fn strip_install_bridge_options(args: &[String]) -> Vec<String> {
-    let mut result = Vec::new();
-    let mut index = 1;
-    while index < args.len() {
-        let arg = &args[index];
-        if arg == "--package-root" || arg == "--installer-js" {
-            index += 2;
-            continue;
-        }
-
-        if arg.starts_with("--package-root=") || arg.starts_with("--installer-js=") {
-            index += 1;
-            continue;
-        }
-
-        result.push(arg.clone());
-        index += 1;
-    }
-    result
-}
-
-fn resolve_package_root_from_exe() -> Option<PathBuf> {
-    let exe = std::env::current_exe().ok()?;
-    let platform_dir = exe.parent()?;
-    let native_dir = platform_dir.parent()?;
-    if native_dir.file_name().and_then(|value| value.to_str()) == Some("native") {
-        let package_root = native_dir.parent()?.to_path_buf();
-        if package_root.join("bin").join("naome-node.js").is_file() {
-            return Some(package_root);
-        }
-    }
-    None
-}
-
-fn resolve_package_root_from_cwd() -> Option<PathBuf> {
-    let current = std::env::current_dir().ok()?;
-    for candidate in [current.join("packages").join("naome"), current.clone()] {
-        if candidate.join("bin").join("naome-node.js").is_file() {
-            return Some(candidate);
-        }
-    }
-    None
-}
-
-fn expected_integrity_from_env() -> Result<HashMap<String, String>, Box<dyn std::error::Error>> {
-    let Ok(value) = std::env::var("NAOME_EXPECTED_INTEGRITY_JSON") else {
-        return Ok(HashMap::new());
-    };
-
-    Ok(serde_json::from_str(&value)?)
-}
-
-fn task_state_failure_message(mode: TaskStateMode) -> &'static str {
-    match mode {
-        TaskStateMode::Admission => "NAOME task admission check failed.",
-        TaskStateMode::Progress => "NAOME task progress check failed.",
-        TaskStateMode::CommitGate => "NAOME commit gate failed.",
-        TaskStateMode::PushGate => "NAOME push gate failed.",
-        TaskStateMode::State => "NAOME task state check failed.",
-    }
-}
-
-fn task_state_success_message(mode: TaskStateMode) -> &'static str {
-    match mode {
-        TaskStateMode::Admission => "NAOME task admission OK.",
-        TaskStateMode::Progress => "NAOME task progress OK.",
-        TaskStateMode::CommitGate => "NAOME commit gate OK.",
-        TaskStateMode::PushGate => "NAOME push gate OK.",
-        TaskStateMode::State => "NAOME task state OK.",
-    }
+    println!("{HELP}");
 }

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

@@ -0,0 +1,68 @@
+use std::fs;
+use std::path::Path;
+
+use naome_core::EvaluationOptions;
+
+use crate::cli_args::option_value;
+
+pub fn run_intent(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let prompt = prompt_from_args(args)?;
+    let intent = naome_core::evaluate_intent(root, &prompt, EvaluationOptions::online())?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&intent)?);
+    } else {
+        print!("{}", naome_core::format_intent(&intent));
+    }
+    Ok(())
+}
+
+pub fn run_route(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let prompt = prompt_from_args(args)?;
+    let route = naome_core::evaluate_route(
+        root,
+        &prompt,
+        naome_core::RouteOptions {
+            execute: args.iter().any(|arg| arg == "--execute"),
+            evaluation: EvaluationOptions::online(),
+        },
+    )?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&route)?);
+    } else {
+        println!("{}", route.user_message);
+        if !route.human_options.is_empty() {
+            println!("Human options: {}", route.human_options.join(", "));
+        }
+    }
+    Ok(())
+}
+
+pub fn run_explain(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let prompt = prompt_from_args(args)?;
+    let explain = naome_core::explain_route(root, &prompt, EvaluationOptions::online())?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&explain)?);
+    } else {
+        println!("NAOME explain: {}", explain.winning_rule);
+        println!("Repo state: {}", explain.repo_state);
+        println!("Prompt intent: {}", explain.prompt_intent);
+        println!("Would mutate: {}", explain.would_mutate);
+        println!("Message: {}", explain.user_message);
+        if !explain.human_options.is_empty() {
+            println!("Human options: {}", explain.human_options.join(", "));
+        }
+    }
+    Ok(())
+}
+
+fn prompt_from_args(args: &[String]) -> Result<String, Box<dyn std::error::Error>> {
+    if let Some(prompt_file) = option_value(args, "--prompt-file") {
+        return Ok(fs::read_to_string(prompt_file)?);
+    }
+
+    if let Some(prompt) = option_value(args, "--prompt") {
+        return Ok(prompt);
+    }
+
+    Err("naome prompt routing requires --prompt-file <path> or --prompt <text>.".into())
+}