@lamentis/naome 1.1.2 → 1.2.1

package/bin/naome.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,6 +12,7 @@ const packageVersion = packageMetadata.version;
 const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
 const args = process.argv.slice(2);
 const [command] = args;
+const helpCommands = "status [--json]|next [--json]|intent --prompt-file <path> [--json]|intent --prompt <text> [--json]|route --prompt-file <path> [--execute] [--json]|route --prompt <text> [--execute] [--json]|explain --prompt-file <path> [--json]|explain --prompt <text> [--json]|install|sync [--check-update]|update [--json] [--execute]|quality init [--json]|quality check --changed [--json]|quality report [--json]|structure report [--json]|structure explain --path <path> [--json]|cleanup plan [--json]|cleanup route --path <path> [--json]|refresh-integrity [--json]|workflow search-profile|check-search|phases|processes|mutations [--json]|commit -m \"type(scope): message\"".split("|");
 
 if (isHelpRequest(args)) {
   printHelp();
@@ -27,7 +28,12 @@ if (command === "install" || command === "sync") {
     requireCurrentCliBeforeSync();
   }
 
-  runNativePackageCommand(args.filter((arg) => arg !== "--check-update"));
+  const qualityConfigExisted = existsSync(repositoryQualityConfigPath(process.cwd()));
+  const result = runNativePackageCommand(args.filter((arg) => arg !== "--check-update"));
+  if (result.status === 0) {
+    ensureRepositoryQualityInitialized(result.nativeBinary, qualityConfigExisted);
+  }
+  process.exit(result.status === null ? 1 : result.status);
 }
 
 const commandPath = findHarnessCommand(process.cwd());
@@ -50,19 +56,7 @@ function isHelpRequest(args) {
 }
 
 function printHelp() {
-  console.log("Usage:");
-  console.log("  naome status [--json]");
-  console.log("  naome next [--json]");
-  console.log("  naome intent --prompt-file <path> [--json]");
-  console.log("  naome intent --prompt <text> [--json]");
-  console.log("  naome route --prompt-file <path> [--execute] [--json]");
-  console.log("  naome route --prompt <text> [--execute] [--json]");
-  console.log("  naome explain --prompt-file <path> [--json]");
-  console.log("  naome explain --prompt <text> [--json]");
-  console.log("  naome install");
-  console.log("  naome sync [--check-update]");
-  console.log("  naome update [--json] [--execute]");
-  console.log("  naome commit -m \"type(scope): message\"");
+  console.log(["Usage:", ...helpCommands.map((item) => `  naome ${item}`)].join("\n"));
 }
 
 function runUpdateCommand(commandArgs) {
@@ -266,7 +260,65 @@ function runNativePackageCommand(args) {
     stdio: "inherit"
   });
 
-  process.exit(result.status === null ? 1 : result.status);
+  return { nativeBinary, status: result.status };
+}
+
+function ensureRepositoryQualityInitialized(nativeBinary, qualityConfigExisted) {
+  const root = process.cwd();
+  if (!existsSync(join(root, ".naome"))) {
+    return;
+  }
+
+  if (qualityConfigExisted && repositoryQualitySupportFilesExist(root)) {
+    return;
+  }
+
+  if (!qualityConfigExisted) {
+    for (const path of repositoryQualityPaths(root)) {
+      if (existsSync(path)) {
+        unlinkSync(path);
+      }
+    }
+  }
+
+  const result = spawnSync(nativeBinary, ["quality", "init", "--json"], {
+    cwd: root,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      NAOME_NODE_BIN: process.execPath
+    }
+  });
+
+  if (result.status !== 0) {
+    console.error("NAOME: repository quality initialization failed.");
+    if (result.stdout.trim()) {
+      console.error(result.stdout.trim());
+    }
+    if (result.stderr.trim()) {
+      console.error(result.stderr.trim());
+    }
+    process.exit(result.status === null ? 1 : result.status);
+  }
+}
+
+function repositoryQualityConfigPath(root) {
+  return join(root, ".naome", "repository-quality.json");
+}
+
+function repositoryQualityPaths(root) {
+  return [
+    repositoryQualityConfigPath(root),
+    join(root, ".naome", "repository-structure.json"),
+    join(root, ".naome", "repository-quality-baseline.json")
+  ];
+}
+
+function repositoryQualitySupportFilesExist(root) {
+  return [
+    join(root, ".naome", "repository-structure.json"),
+    join(root, ".naome", "repository-quality-baseline.json")
+  ].every((path) => existsSync(path));
 }
 
 function resolveNativePackageBinary() {

package/crates/naome-cli/Cargo.toml

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

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

@@ -0,0 +1,135 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use naome_core::{
+    validate_harness_health, validate_task_state, validate_verification_contract,
+    HarnessHealthOptions, TaskStateMode, TaskStateOptions,
+};
+
+pub fn run_harness_health(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let errors = validate_harness_health(root, harness_health_options(args)?)?;
+    finish_gate(
+        errors,
+        "NAOME harness health OK.",
+        "NAOME harness health check failed.",
+    )
+}
+
+pub fn run_task_state(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let mode = task_state_mode(args);
+    let report = validate_task_state(
+        root,
+        TaskStateOptions {
+            mode,
+            harness_health: optional_harness_health(args)?,
+        },
+    )?;
+    if report.errors.is_empty() {
+        println!("{}", task_state_success_message(mode));
+        for notice in report.notices {
+            println!("- {notice}");
+        }
+        return Ok(());
+    }
+    print_errors(task_state_failure_message(mode), report.errors);
+    std::process::exit(1);
+}
+
+pub fn run_verification_contract(root: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    let errors = validate_verification_contract(root)?;
+    finish_gate(
+        errors,
+        "NAOME verification contract OK.",
+        "NAOME verification contract failed.",
+    )
+}
+
+fn finish_gate(
+    errors: Vec<String>,
+    success: &str,
+    failure: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if errors.is_empty() {
+        println!("{success}");
+        return Ok(());
+    }
+    print_errors(failure, errors);
+    std::process::exit(1);
+}
+
+fn print_errors(header: &str, errors: Vec<String>) {
+    eprintln!("{header}");
+    for error in errors {
+        eprintln!("- {error}");
+    }
+}
+
+fn harness_health_options(
+    args: &[String],
+) -> Result<HarnessHealthOptions, Box<dyn std::error::Error>> {
+    Ok(build_health_options(args, expected_integrity_from_env()?))
+}
+
+fn optional_harness_health(
+    args: &[String],
+) -> Result<Option<HarnessHealthOptions>, Box<dyn std::error::Error>> {
+    let expected_integrity = expected_integrity_from_env()?;
+    if expected_integrity.is_empty() && std::env::var("NAOME_ALLOW_MISSING_INTEGRITY").is_err() {
+        Ok(None)
+    } else {
+        Ok(Some(build_health_options(args, expected_integrity)))
+    }
+}
+
+fn build_health_options(
+    args: &[String],
+    expected_integrity: HashMap<String, String>,
+) -> HarnessHealthOptions {
+    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"),
+    }
+}
+
+fn task_state_mode(args: &[String]) -> TaskStateMode {
+    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
+    }
+}
+
+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-cli/src/cli_args.rs

@@ -0,0 +1,5 @@
+pub fn option_value(args: &[String], option: &str) -> Option<String> {
+    args.windows(2)
+        .find(|window| window[0] == option)
+        .map(|window| window[1].clone())
+}

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

@@ -0,0 +1,37 @@
+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, run_structure_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)?,
+        "structure" => run_structure_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
+}