@nexusbloom/cli 0.9.7 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/cli",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "NexusBloom CLI — run tools and workflows from your terminal",
   "type": "module",
   "bin": {

package/src/pipe.js

@@ -295,9 +295,23 @@ function splitSteps(text) {
   return chunks;
 }
 
+/**
+ * Is this pipe the start of a transform chain rather than the next step?
+ *
+ * The word after the pipe has to be a *whole* transform name, optionally
+ * followed by an argument list. Without the terminator check, a tool whose slug
+ * merely starts with a transform name — `base64-tool`, `split-words` — was read
+ * as the transform `base64` plus a stray slug, and the pipeline failed to parse
+ * with a confusing "Expected key=value" pointing at the pipe.
+ */
 function isKnownTransformWord(rest) {
-  const word = (rest.match(/^\s*([a-zA-Z_][a-zA-Z0-9_]*)/) || [])[1];
-  return word !== undefined && Object.hasOwn(TRANSFORMS, word);
+  const m = /^\s*([a-zA-Z_][a-zA-Z0-9_]*)/.exec(rest);
+  if (!m) return false;
+  if (!Object.hasOwn(TRANSFORMS, m[1])) return false;
+  // Whatever follows the name decides it: `len()`, `len` at the end of a step,
+  // then whitespace, or a pipe. A hyphen or dot means this is a slug.
+  const after = rest.slice(m.index + m[1].length);
+  return after === "" || /^\s*[(\s|]/.test(after);
 }
 
 /**

package/src/values.js

@@ -274,8 +274,22 @@ export const TRANSFORMS = {
     const nums = v.filter((n) => typeof n === "number");
     return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : MISSING;
   },
-  min: (v) => (Array.isArray(v) && v.length ? Math.min(...v.filter((n) => typeof n === "number")) : v),
-  max: (v) => (Array.isArray(v) && v.length ? Math.max(...v.filter((n) => typeof n === "number")) : v),
+  // These collapse an *array*; they do not compare against a bound. `clamp(lo,hi)`
+  // is the one that takes bounds. Ignoring a second argument silently was the
+  // reason `min(120, 60)` returned 120 instead of erroring, so it now returns the
+  // value untouched rather than pretending to have clamped anything.
+  min: (v, ...ignored) =>
+    ignored.length
+      ? v
+      : Array.isArray(v) && v.length
+        ? Math.min(...v.filter((n) => typeof n === "number"))
+        : v,
+  max: (v, ...ignored) =>
+    ignored.length
+      ? v
+      : Array.isArray(v) && v.length
+        ? Math.max(...v.filter((n) => typeof n === "number"))
+        : v,
   // Sum one field across an array of objects — the common "total of the column".
   sumBy: (v, key) => {
     if (!Array.isArray(v)) return v;
@@ -319,6 +333,11 @@ export const TRANSFORMS = {
     (Array.isArray(v) && v.length === 0) ||
     (typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0),
 
+  // Builds one string out of several values. Without this a report can only ever
+  // be as long as whatever single tool produced it: `join` needs an array that
+  // already exists, and there is no way to place an upstream value inside text.
+  concat: (v, ...parts) => [v, ...parts].map((p) => (p === MISSING || p === undefined || p === null ? "" : String(p))).join(""),
+
   // — branching —
   //
   // `then(cond, whenTrue, whenFalse)` is what a linear pipeline was missing: pick
@@ -471,6 +490,11 @@ export const TRANSFORM_ARITY = {
   // understate it, so the builder asks for one and a written pipeline may list
   // as many as it likes.
   coalesce: 2,
+  // Arity is the *minimum* argument count the parser enforces, so a variadic
+  // transform declares 1 — `concat()` with nothing after it is legal and just
+  // stringifies the piped value. `coalesce` above keeps its 2 because a coalesce
+  // with no fallback does nothing.
+  concat: 1,
   pluck: 2, chunk: 2, without: 2, where: 4,
   truncate: 3, repeat: 2, mask: 2,
 };
@@ -535,8 +559,8 @@ export const TRANSFORM_DOCS = {
   clamp: "keep a number between a low and a high",
   sum: "add up every number in an array",
   avg: "average of every number in an array",
-  min: "smallest number in an array",
-  max: "largest number in an array",
+  min: "smallest number in an array (to bound a single number use clamp)",
+  max: "largest number in an array (to bound a single number use clamp)",
   sumBy: "add up one field across an array of objects",
   eq: "is it equal to a value",
   ne: "is it different from a value",
@@ -551,6 +575,7 @@ export const TRANSFORM_DOCS = {
   matches: "does a string match a regular expression",
   isEmpty: "is the value empty — blank, [], or {}",
   then: "choose between two values on a condition",
+  concat: "combine several values into one string",
   coalesce: "first value that is not empty",
   pluck: "pull one field out of every object in an array",
   unique: "remove duplicates from an array",
@@ -607,6 +632,8 @@ export const TRANSFORM_GROUPS = [
     names: ["json", "unjson"] },
   { label: "default(v) / coalesce(a,b,…) / then(cond,a,b)", doc: "supply a value when one is missing, or choose on a condition",
     names: ["default", "coalesce", "then"] },
+  { label: "concat(a,b,…)", doc: "combine several values into one string",
+    names: ["concat"] },
   { label: "eq / ne / gt / gte / lt / lte / between(a,b)", doc: "compare — the result is true or false",
     names: ["eq", "ne", "gt", "gte", "lt", "lte", "between"] },
   { label: "includes / startsWith / endsWith / matches(re) / isEmpty", doc: "test text and arrays",