@lamentis/naome 1.0.1 → 1.1.0

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.0.1"
+version = "1.1.0"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.0.1"
+version = "1.1.0"
 dependencies = [
  "serde",
  "serde_json",

package/README.md

@@ -17,4 +17,11 @@ Set up a repository:
 naome sync
 ```
 
-Then paste the printed first-run prompt into your coding agent. Use `naome status`, `naome next`, and `naome commit` to inspect state, choose the next safe action, and baseline completed work.
+Keep the CLI current before refreshing an existing repo:
+
+```sh
+naome update
+naome sync
+```
+
+Then paste the printed first-run prompt into your coding agent. Use `naome status`, `naome next`, `naome route`, and `naome commit` to inspect state, route natural-language follow-ups, choose the next safe action, and baseline completed work.

package/bin/naome-node.js

@@ -34,6 +34,7 @@ let machineOwnedPaths = [];
 let projectOwnedPaths = [];
 let localOnlyMachineOwnedPaths = [];
 let localOnlyGitIgnoreEntries = [];
+let localOnlyGitExcludeEntries = [];
 let localOnlyGitUntrackPaths = [];
 
 const executableMachineOwnedPaths = new Set([
@@ -57,7 +58,8 @@ Then read .naome/upgrade-state.json, .naome/task-state.json, and docs/naome/exec
 Run node .naome/bin/check-harness-health.js before feature work.
 If initialized is false, follow docs/naome/first-run.md.
 Do not begin feature work until NAOME intake is complete.
-After intake, ask the user to commit or clear NAOME changes, then run node .naome/bin/check-task-state.js --admission before accepting feature work.`;
+After intake, save the user's next natural-language request to a temporary prompt file, then run node .naome/bin/naome.js route --prompt-file <path> --execute --json.
+Follow userMessage, humanOptions, requiredContext, and canCreateTask from the route output before creating the requested task.`;
 
 let summaryTitle = "NAOME intake harness installed";
 let nextStepPrompt = firstRunPrompt;
@@ -363,12 +365,14 @@ function loadInstallPlan() {
   assertInstallPlanArray("projectOwned");
   assertInstallPlanArray("localOnlyMachineOwned");
   assertInstallPlanArray("gitignoreEntries");
+  assertInstallPlanArray("gitExcludeEntries");
   assertInstallPlanArray("gitUntrackPaths");
 
   machineOwnedPaths = installPlan.machineOwned;
   projectOwnedPaths = installPlan.projectOwned;
   localOnlyMachineOwnedPaths = installPlan.localOnlyMachineOwned;
   localOnlyGitIgnoreEntries = installPlan.gitignoreEntries;
+  localOnlyGitExcludeEntries = installPlan.gitExcludeEntries;
   localOnlyGitUntrackPaths = installPlan.gitUntrackPaths;
 
   return installPlan;
@@ -521,6 +525,7 @@ function runExistingInstall(existingInstall) {
     printError("This repository already uses a newer NAOME harness.");
     console.error(`Installed: v${existingInstall.version}`);
     console.error(`Package:   v${packageVersion}`);
+    console.error("Run `naome update`, then rerun `naome sync` from the repository root.");
     process.exit(1);
   }
 
@@ -820,11 +825,19 @@ function ensureNaomeIgnore() {
 }
 
 function ensureLocalOnlySourceControlBoundary() {
-  ensureLocalOnlyGitIgnore();
+  if (!isInsideGitWorkTree()) {
+    ensureLocalOnlyGitIgnoreFallback();
+    skipped.push("local git exclude");
+    skipped.push("local-only git index cleanup");
+    return;
+  }
+
+  cleanupLegacyLocalOnlyGitIgnore();
+  ensureLocalOnlyGitExclude();
   untrackLocalOnlyGitPaths();
 }
 
-function ensureLocalOnlyGitIgnore() {
+function ensureLocalOnlyGitIgnoreFallback() {
   const relativePath = ".gitignore";
   const targetPath = join(targetRoot, relativePath);
 
@@ -841,7 +854,7 @@ function ensureLocalOnlyGitIgnore() {
 
   const content = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
   const existingLines = new Set(content.split(/\r?\n/).map((line) => line.trim()));
-  const missingEntries = localOnlyGitIgnoreEntries.filter((entry) => !existingLines.has(entry));
+  const missingEntries = legacyLocalOnlyGitIgnoreEntries().filter((entry) => !existingLines.has(entry));
 
   if (missingEntries.length === 0) {
     skipped.push(relativePath);
@@ -857,6 +870,110 @@ function ensureLocalOnlyGitIgnore() {
   }
 }
 
+function cleanupLegacyLocalOnlyGitIgnore() {
+  const relativePath = ".gitignore";
+  const targetPath = join(targetRoot, relativePath);
+
+  if (!existsSync(targetPath)) {
+    skipped.push(relativePath);
+    return;
+  }
+
+  if (hasSymlinkInTargetPath(relativePath)) {
+    printError("NAOME cannot clean up .gitignore safely.");
+    console.error(".gitignore must be a regular file or must not exist.");
+    process.exit(1);
+  }
+
+  if (!lstatSync(targetPath).isFile()) {
+    printError("NAOME cannot update .gitignore because that path is not a file.");
+    process.exit(1);
+  }
+
+  const content = readFileSync(targetPath, "utf8");
+  const legacyEntries = new Set(legacyLocalOnlyGitIgnoreEntries());
+  const nextContent = cleanBlankLines(content
+    .split(/\r?\n/)
+    .filter((line) => !legacyEntries.has(line.trim()))
+    .join("\n"));
+
+  if (nextContent === content) {
+    skipped.push(relativePath);
+    return;
+  }
+
+  if (nextContent.trim().length === 0) {
+    unlinkSync(targetPath);
+  } else {
+    writeFileSync(targetPath, nextContent);
+  }
+  updated.push(relativePath);
+}
+
+function ensureLocalOnlyGitExclude() {
+  if (!isInsideGitWorkTree()) {
+    skipped.push("local git exclude");
+    return;
+  }
+
+  const gitDirResult = spawnSync("git", ["rev-parse", "--absolute-git-dir"], {
+    cwd: targetRoot,
+    encoding: "utf8",
+  });
+
+  if (gitDirResult.status !== 0 || !gitDirResult.stdout.trim()) {
+    skipped.push("local git exclude");
+    unsafeSkipped.push("local git exclude");
+    return;
+  }
+
+  const excludePath = join(gitDirResult.stdout.trim(), "info", "exclude");
+  mkdirSync(dirname(excludePath), { recursive: true });
+
+  if (existsSync(excludePath) && !lstatSync(excludePath).isFile()) {
+    printError("NAOME cannot update local git exclude because that path is not a file.");
+    process.exit(1);
+  }
+
+  const content = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
+  const existingLines = new Set(content.split(/\r?\n/).map((line) => line.trim()));
+  const missingEntries = localOnlyGitExcludeEntries.filter((entry) => !existingLines.has(entry));
+
+  if (missingEntries.length === 0) {
+    skipped.push(".git/info/exclude");
+    return;
+  }
+
+  const nextContent = `${content.trimEnd()}${content.trimEnd() ? "\n\n" : ""}${missingEntries.join("\n")}\n`;
+  writeFileSync(excludePath, nextContent);
+  updated.push(".git/info/exclude");
+}
+
+function legacyLocalOnlyGitIgnoreEntries() {
+  return [
+    "# NAOME local machine-owned harness files.",
+    ".naome/archive/",
+    ".naome/bin/naome-rust*",
+    ...localOnlyMachineOwnedPaths,
+    ...localOnlyGitIgnoreEntries,
+  ];
+}
+
+function cleanBlankLines(content) {
+  const lines = content.split(/\r?\n/);
+  const cleaned = [];
+
+  for (const line of lines) {
+    if (line.trim() === "" && cleaned.at(-1)?.trim() === "") {
+      continue;
+    }
+    cleaned.push(line);
+  }
+
+  const trimmed = cleaned.join("\n").trimEnd();
+  return trimmed ? `${trimmed}\n` : "";
+}
+
 function untrackLocalOnlyGitPaths() {
   if (!isInsideGitWorkTree()) {
     skipped.push("local-only git index cleanup");

package/bin/naome.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } 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 packageMetadata = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+const packageName = packageMetadata.name;
+const packageVersion = packageMetadata.version;
 const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
 const args = process.argv.slice(2);
 const [command] = args;
@@ -15,8 +18,16 @@ if (isHelpRequest(args)) {
   process.exit(0);
 }
 
+if (command === "update") {
+  runUpdateCommand(args.slice(1));
+}
+
 if (command === "install" || command === "sync") {
-  runNativePackageCommand(args);
+  if (args.includes("--check-update")) {
+    requireCurrentCliBeforeSync();
+  }
+
+  runNativePackageCommand(args.filter((arg) => arg !== "--check-update"));
 }
 
 const commandPath = findHarnessCommand(process.cwd());
@@ -42,11 +53,195 @@ 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");
+  console.log("  naome sync [--check-update]");
+  console.log("  naome update [--json] [--execute]");
   console.log("  naome commit -m \"type(scope): message\"");
 }
 
+function runUpdateCommand(commandArgs) {
+  const json = commandArgs.includes("--json");
+  const execute = commandArgs.includes("--execute");
+
+  if (json && execute) {
+    console.error("NAOME: update --execute does not support --json output.");
+    process.exit(1);
+  }
+
+  const update = getUpdateState();
+  if (!update.ok) {
+    if (json) {
+      console.log(JSON.stringify(formatUpdateState(update), null, 2));
+    } else {
+      console.error("NAOME CLI update check failed.");
+      console.error(update.error);
+    }
+    process.exit(1);
+  }
+
+  if (!execute) {
+    if (json) {
+      console.log(JSON.stringify(formatUpdateState(update), null, 2));
+    } else if (update.outdated) {
+      printUpdateInstructions(update);
+    } else {
+      console.log(`NAOME CLI is current: v${update.currentVersion}.`);
+    }
+    process.exit(0);
+  }
+
+  if (!update.outdated) {
+    console.log(`NAOME CLI is current: v${update.currentVersion}.`);
+    process.exit(0);
+  }
+
+  printUpdateInstructions(update);
+  const result = spawnSync("npm", ["install", "-g", `${packageName}@latest`, "--force"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "inherit"
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status === null ? 1 : result.status);
+  }
+
+  console.log("NAOME CLI updated. Run `naome sync` from the repository root.");
+  process.exit(0);
+}
+
+function requireCurrentCliBeforeSync() {
+  const update = getUpdateState();
+
+  if (!update.ok) {
+    console.error("NAOME CLI update check failed.");
+    console.error(update.error);
+    process.exit(1);
+  }
+
+  if (!update.outdated) {
+    return;
+  }
+
+  console.error("NAOME CLI update required before sync.");
+  console.error(`Installed CLI: v${update.currentVersion}`);
+  console.error(`Latest CLI:    v${update.latestVersion}`);
+  console.error(`Run: ${update.installCommand}`);
+  console.error(`Then: ${update.nextCommand}`);
+  process.exit(1);
+}
+
+function getUpdateState() {
+  const latest = getLatestPackageVersion();
+  if (!latest.ok) {
+    return {
+      ok: false,
+      packageName,
+      currentVersion: packageVersion,
+      latestVersion: null,
+      outdated: false,
+      installCommand: `npm install -g ${packageName}@latest --force`,
+      nextCommand: "naome sync",
+      error: latest.error
+    };
+  }
+
+  return {
+    ok: true,
+    packageName,
+    currentVersion: packageVersion,
+    latestVersion: latest.version,
+    outdated: compareVersions(packageVersion, latest.version) < 0,
+    installCommand: `npm install -g ${packageName}@latest --force`,
+    nextCommand: "naome sync"
+  };
+}
+
+function formatUpdateState(update) {
+  return {
+    schema: "naome.update.v1",
+    ok: update.ok,
+    packageName: update.packageName,
+    currentVersion: update.currentVersion,
+    latestVersion: update.latestVersion,
+    outdated: update.outdated,
+    installCommand: update.installCommand,
+    nextCommand: update.nextCommand,
+    ...(update.ok ? {} : { error: update.error })
+  };
+}
+
+function printUpdateInstructions(update) {
+  console.log(`NAOME update available: v${update.currentVersion} -> v${update.latestVersion}.`);
+  console.log(`Run: ${update.installCommand}`);
+  console.log(`Then: ${update.nextCommand}`);
+}
+
+function getLatestPackageVersion() {
+  if (process.env.NAOME_TEST_NPM_LATEST_VERSION) {
+    return parseLatestVersion(process.env.NAOME_TEST_NPM_LATEST_VERSION);
+  }
+
+  const result = spawnSync("npm", ["view", packageName, "version", "--json"], {
+    cwd: process.cwd(),
+    encoding: "utf8"
+  });
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: (result.stderr || result.stdout || "npm view failed").trim()
+    };
+  }
+
+  return parseLatestVersion(result.stdout);
+}
+
+function parseLatestVersion(value) {
+  let version = String(value).trim();
+  if (!version) {
+    return { ok: false, error: "npm returned an empty package version." };
+  }
+
+  try {
+    const parsed = JSON.parse(version);
+    if (typeof parsed === "string") {
+      version = parsed;
+    }
+  } catch {
+    // npm can also emit the bare version when registry tooling changes output.
+  }
+
+  if (!isSemver(version)) {
+    return { ok: false, error: `npm returned an invalid package version: ${version}` };
+  }
+
+  return { ok: true, version };
+}
+
+function compareVersions(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+
+  for (let index = 0; index < 3; index += 1) {
+    if (leftParts[index] !== rightParts[index]) {
+      return leftParts[index] < rightParts[index] ? -1 : 1;
+    }
+  }
+
+  return 0;
+}
+
+function isSemver(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
 function runNativePackageCommand(args) {
   const nativeBinary = resolveNativePackageBinary();
   if (!nativeBinary) {

package/crates/naome-cli/Cargo.toml

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

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

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
@@ -29,6 +30,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 
     if command != "status"
         && command != "next"
+        && command != "intent"
+        && command != "route"
+        && command != "explain"
+        && command != "journal-task"
+        && command != "commit-paths"
         && command != "seed-verification"
         && command != "install-plan"
         && command != "install"
@@ -163,6 +169,84 @@ fn run() -> Result<(), Box<dyn std::error::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}");
+            }
+        }
+        return Ok(());
+    }
+
     let decision = evaluate_decision(&root, EvaluationOptions::online())?;
 
     if args.iter().any(|arg| arg == "--json") {
@@ -175,10 +259,12 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 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")
+    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> {
@@ -211,6 +297,12 @@ 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>]");
@@ -226,6 +318,18 @@ fn option_value(args: &[String], option: &str) -> Option<String> {
         .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)
@@ -288,11 +392,7 @@ fn resolve_package_root_from_exe() -> Option<PathBuf> {
     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()
-        {
+        if package_root.join("bin").join("naome-node.js").is_file() {
             return Some(package_root);
         }
     }
@@ -301,10 +401,7 @@ fn resolve_package_root_from_exe() -> Option<PathBuf> {
 
 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(),
-    ] {
+    for candidate in [current.join("packages").join("naome"), current.clone()] {
         if candidate.join("bin").join("naome-node.js").is_file() {
             return Some(candidate);
         }

package/crates/naome-core/Cargo.toml

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