@nexusbloom/cli 0.9.8 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/cli",
-  "version": "0.9.8",
+  "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

@@ -333,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
@@ -485,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,
 };
@@ -565,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",
@@ -621,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",