@lamentis/naome 1.0.0

package/bin/naome.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
+const args = process.argv.slice(2);
+const [command] = args;
+
+if (isHelpRequest(args)) {
+  printHelp();
+  process.exit(0);
+}
+
+if (command === "install" || command === "sync") {
+  runNativePackageCommand(args);
+}
+
+const commandPath = findHarnessCommand(process.cwd());
+
+if (!commandPath) {
+  console.error("NAOME: installed harness command not found. Run this inside a repository with .naome/bin/naome.js.");
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, [commandPath, ...process.argv.slice(2)], {
+  cwd: process.cwd(),
+  encoding: "utf8",
+  stdio: "inherit",
+});
+
+process.exit(result.status === null ? 1 : result.status);
+
+function isHelpRequest(args) {
+  return ["help", "--help", "-h"].includes(args[0]) || ["help", "--help", "-h"].includes(args[1]);
+}
+
+function printHelp() {
+  console.log("Usage:");
+  console.log("  naome status [--json]");
+  console.log("  naome next [--json]");
+  console.log("  naome install");
+  console.log("  naome sync");
+  console.log("  naome commit -m \"type(scope): message\"");
+}
+
+function runNativePackageCommand(args) {
+  const nativeBinary = resolveNativePackageBinary();
+  if (!nativeBinary) {
+    console.error("NAOME: native CLI is unavailable.");
+    console.error("Install Cargo or provide NAOME_NATIVE_BIN with a built naome binary.");
+    process.exit(1);
+  }
+
+  const result = spawnSync(nativeBinary, [
+    ...args,
+    "--package-root",
+    packageRoot,
+    "--installer-js",
+    join(packageRoot, "bin", "naome-node.js")
+  ], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      NAOME_NODE_BIN: process.execPath
+    },
+    stdio: "inherit"
+  });
+
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+function resolveNativePackageBinary() {
+  const candidates = [
+    process.env.NAOME_NATIVE_BIN && resolve(process.cwd(), process.env.NAOME_NATIVE_BIN),
+    join(packageRoot, "native", `${process.platform}-${process.arch}`, nativeBinaryName),
+    join(packageRoot, "target", "release", nativeBinaryName)
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  const built = buildNativePackageBinary();
+  return built && existsSync(built) ? built : null;
+}
+
+function buildNativePackageBinary() {
+  const manifestPath = join(packageRoot, "Cargo.toml");
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+
+  const result = spawnSync("cargo", ["build", "--release", "--manifest-path", manifestPath, "-p", "naome-cli"], {
+    cwd: packageRoot,
+    encoding: "utf8",
+    stdio: "inherit"
+  });
+
+  if (result.status !== 0) {
+    return null;
+  }
+
+  return join(packageRoot, "target", "release", nativeBinaryName);
+}
+
+function findHarnessCommand(startPath) {
+  let current = resolve(startPath);
+
+  while (true) {
+    const candidate = join(current, ".naome", "bin", "naome.js");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+
+    current = parent;
+  }
+}

package/crates/naome-cli/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "naome-cli"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[[bin]]
+name = "naome"
+path = "src/main.rs"
+
+[dependencies]
+naome-core = { path = "../naome-core" }
+serde_json = "1"

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

@@ -0,0 +1,341 @@
+use std::collections::HashMap;
+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,
+};
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("NAOME: {error}");
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let Some(command) = args.first().map(String::as_str) else {
+        print_help();
+        return Ok(());
+    };
+
+    if is_help_request(&args) {
+        print_help();
+        return Ok(());
+    }
+
+    if command != "status"
+        && command != "next"
+        && command != "seed-verification"
+        && command != "install-plan"
+        && command != "install"
+        && command != "sync"
+        && command != "check-harness-health"
+        && command != "check-task-state"
+        && command != "validate-verification"
+    {
+        print_help();
+        return Err(format!("unknown command: {command}").into());
+    }
+
+    let root = if command == "install-plan" || command == "install" || command == "sync" {
+        std::env::current_dir()?
+    } else if command == "validate-verification"
+        || command == "check-harness-health"
+        || command == "check-task-state"
+    {
+        option_value(&args, "--root")
+            .map(PathBuf::from)
+            .or_else(|| find_manifest_root(&std::env::current_dir().ok()?))
+            .unwrap_or(std::env::current_dir()?)
+    } else {
+        find_harness_root(&std::env::current_dir()?).ok_or(
+            "NAOME harness root not found. Run this inside a repository with .naome/task-state.json.",
+        )?
+    };
+
+    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);
+    }
+
+    let decision = evaluate_decision(&root, EvaluationOptions::online())?;
+
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&decision)?);
+    } else {
+        print!("{}", format_decision(&decision, command));
+    }
+
+    Ok(())
+}
+
+fn is_help_request(args: &[String]) -> bool {
+    matches!(args.first().map(String::as_str), Some("help" | "--help" | "-h"))
+        || args
+            .get(1)
+            .is_some_and(|arg| arg == "--help" || arg == "-h" || arg == "help")
+}
+
+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;
+        }
+    }
+}
+
+fn find_manifest_root(start: &Path) -> Option<PathBuf> {
+    let mut current = start.to_path_buf();
+    loop {
+        if current.join(".naome").join("manifest.json").is_file() {
+            return Some(current);
+        }
+
+        if !current.pop() {
+            return None;
+        }
+    }
+}
+
+fn print_help() {
+    println!("Usage:");
+    println!("  naome status [--json]");
+    println!("  naome next [--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 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.",
+    }
+}

package/crates/naome-core/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "naome-core"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sha2 = "0.10"