@nexusbloom/cli 0.8.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "NexusBloom CLI — run tools and workflows from your terminal",
   "type": "module",
   "bin": {
@@ -30,4 +30,4 @@
     "test:watch": "node --test --watch --import ./test/setup.mjs test/*.test.js",
     "lint": "node --check src/index.js"
   }
-}
+}

package/src/index.js

@@ -40,7 +40,7 @@ import {
   fetchTools, fetchToolSource, resolveToolSlug,
   generateAbbreviations, normalizeSlug, readStdin,
 } from "./tools.js";
-import { runLocal, runRemote, buildInputBody, runInteractive, reportError } from "./run.js";
+import { runLocal, runRemote, buildInputBody, runInteractive, runInteractiveFor, isExitPromptError, reportError } from "./run.js";
 import listAction from "./list.js";
 import { pipeAction, listTransforms, doctorAction } from "./commands.js";
 import { buildWizard } from "./wizard.js";
@@ -167,6 +167,21 @@ program
     const body = await buildInputBody(opts, args);
     if (body === null) return;
 
+    // ── No input at all: configure the tool interactively ──
+    // `nxb run text-statistics` with nothing to send used to fail schema
+    // validation ("Missing required fields: text"), which is a dead end for a
+    // human at a terminal. Ask for the fields instead. Only when the body is
+    // genuinely empty: any explicit input (--input/--file, key=value, piped
+    // stdin) means the caller is scripting, and a prompt there would hang CI.
+    if (Object.keys(body).length === 0 && isInteractive()) {
+      return await runInteractiveFor(resolved, {
+        json: jsonMode,
+        tools: allTools,
+        local: Boolean(opts.local),
+        key: opts.key,
+      });
+    }
+
     // ── Local vs remote ──
     if (opts.local || (!opts.key && !process.env.NEXUSBLOOM_API_KEY && !configGet("apiKey") && !configGet("key"))) {
       return await runLocal(resolved, body, { jsonMode, slugResolved: true });
@@ -710,4 +725,11 @@ function renderToolInfo(manifest, resolved) {
   console.log();
 }
 
-program.parse(process.argv);
+// `parse` does not await the async action handlers, so a Ctrl+C inside an
+// inquirer prompt surfaces here as a rejected promise rather than a thrown
+// error. Catching it turns a stack trace into a clean, conventional exit.
+program.parseAsync(process.argv).catch((err) => {
+  if (!isExitPromptError(err)) throw err;
+  process.stderr.write("\n  Cancelled.\n");
+  process.exit(130);
+});

package/src/pipe.js

@@ -135,7 +135,7 @@ function tokenize(spec) {
  * @returns {{kind:"stdin"|"connection"|"literal", headPath?: string,
  *            accessors?: Array, chain?: Array, literal?: any}}
  */
-function parseValueExpr(expr) {
+export function parseValueExpr(expr) {
   const raw = String(expr ?? "");
 
   if (raw === "@in" || raw === "@stdin") return { kind: "stdin" };

package/src/run.js

@@ -200,6 +200,21 @@ export async function runLocal(slug, input, { jsonMode, slugResolved, quiet } =
   return { ok: true, result: res.result, durationMs: res.durationMs };
 }
 
+/**
+ * True when an error is inquirer's "the user pressed Ctrl+C" signal.
+ *
+ * @inquirer/core rejects with an `ExitPromptError` from inside a readline
+ * `SIGINT` handler. Because the CLI parses with `program.parse()` — which does
+ * not await the async action handlers — that rejection used to escape as an
+ * unhandled rejection and dump an inquirer stack trace over the user's
+ * terminal. The class is not exported from `@inquirer/prompts`, and importing
+ * `@inquirer/core` directly would tie us to a transitive dependency, so it is
+ * matched by name.
+ */
+export function isExitPromptError(err) {
+  return Boolean(err) && err.name === "ExitPromptError";
+}
+
 /** Print an error on stderr (or as JSON) and set a non-zero exit code. */
 export function reportError(jsonMode, message) {
   if (jsonMode) {
@@ -365,15 +380,30 @@ export async function runInteractive(opts = {}) {
   const selected = await promptSelect("Choose a tool:", choices, { pageSize: 15 });
   if (!selected) return;
 
-  const slug = selected.slug;
-  const resolved = await resolveToolSlug(slug, tools);
+  return await runInteractiveFor(selected.slug, { ...opts, json: jsonMode, tools });
+}
+
+/**
+ * Interactive configuration for a slug that is already known.
+ *
+ * Shared by the tool picker above and by `nxb run <slug>` with no input of any
+ * kind: a bare `nxb run text-statistics` has nothing to send, so asking for the
+ * fields is the useful behaviour rather than failing schema validation with
+ * "Missing required fields: text".
+ *
+ * Returns the executed slug, or undefined when the user backs out or the tool
+ * has no schema to configure.
+ */
+export async function runInteractiveFor(slug, opts = {}) {
+  const { json: jsonMode, tools: knownTools } = opts;
+  const resolved = await resolveToolSlug(slug, knownTools);
 
   // 2. Fetch manifest / schema
   const toolInfo = await fetchToolSource(resolved);
   if (!toolInfo?.manifest) {
     console.log(chalk.yellow(`  No schema available for "${resolved}". Falling back to raw input.`));
     await runCommand(resolved, {}, { ...opts, json: jsonMode });
-    return;
+    return resolved;
   }
 
   const { manifest } = toolInfo;
@@ -419,10 +449,11 @@ export async function runInteractive(opts = {}) {
   if (!runIt) {
     console.log(chalk.dim("  Command copied to clipboard (if available):"));
     console.log(chalk.gray(`  ${fullCommand}`));
-    return;
+    return resolved;
   }
 
   await runCommand(resolved, body, { ...opts, json: jsonMode, resolved });
+  return resolved;
 }
 
 /** Prompt for a single schema field based on its type. */

package/src/wizard.js

@@ -33,7 +33,8 @@ import { execInSandbox } from "./sandbox.js";
 import { configGet } from "./tools.js";
 import { runRemote } from "./run.js";
 import { inferType, schemaTypes, typeLabel, compatibility } from "./types.js";
-import { formatPath, parsePath, preview, transformNames } from "./values.js";
+import { formatPath, parsePath, preview, transformNames, MISSING } from "./values.js";
+import { parseValueExpr, resolveAccessors } from "./pipe.js";
 import { isInteractive } from "./ui.js";
 import { renderHeader } from "./ui.js";
 
@@ -283,7 +284,10 @@ export async function buildWizard(opts = {}) {
 
     console.log(chalk.gray(`\n  Running  ${spec}\n`));
     const started = Date.now();
-    const result = await execute(tool.slug, literalInput(assignments));
+    const result = await execute(
+      tool.slug,
+      literalInput(assignments, outputs.length ? outputs[outputs.length - 1].value : undefined)
+    );
 
     if (!result.ok) {
       console.log(chalk.red(`  ✗ ${result.error}`));
@@ -328,15 +332,51 @@ export async function buildWizard(opts = {}) {
   return { ok: true, spec: pipeline };
 }
 
-/** Build the input object for the trial run from literal assignments. */
-function literalInput(assignments) {
+/**
+ * Build the input object for a step's trial run.
+ *
+ * Wired fields (`$path`, `$path|transform`) are resolved against the previous
+ * step's real output, using the *same* parser and resolver the pipeline engine
+ * uses at run time. That matters twice over:
+ *
+ *   - correctness: a step whose required input is wired previously ran with that
+ *     input simply absent, so `password-generator → base64-tool` failed with
+ *     "text must be a non-empty string" no matter what the user chose;
+ *   - consistency: the trial the wizard shows is the run the replay command
+ *     will later reproduce, because both go through `parseValueExpr` +
+ *     `resolveAccessors` rather than a second, drifting implementation.
+ *
+ * A reference that resolves to nothing is omitted rather than passed as
+ * `undefined`, so schema validation reports the field by name.
+ */
+function literalInput(assignments, upstream) {
   const input = {};
   for (const a of assignments) {
     const eq = a.text.indexOf("=");
     if (eq === -1) continue;
     const key = a.text.slice(0, eq);
     const raw = a.text.slice(eq + 1);
-    if (raw.startsWith("$")) continue; // wired fields are not needed for a first run
+
+    if (raw.startsWith("$")) {
+      if (upstream === undefined) continue;
+      let expr;
+      try {
+        expr = parseValueExpr(raw);
+      } catch {
+        continue;
+      }
+      if (expr.kind !== "connection" || !expr.accessors) continue;
+      let value;
+      try {
+        value = resolveAccessors(upstream, expr.accessors);
+      } catch {
+        continue;
+      }
+      if (value === MISSING || value === undefined) continue;
+      input[key] = value;
+      continue;
+    }
+
     try {
       input[key] = JSON.parse(raw);
     } catch {