@nexusbloom/cli 0.3.0 → 0.3.1

package/package.json

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

package/src/abbr.js

@@ -1,7 +1,7 @@
 /**
  * abbr.js — `nxb abbr` command.
  *
- * Displays the tool abbreviation map in a paginated, table-style view.
+ * Simple paginated abbreviation view.
  *
  *   nxb abbr                   — interactive pagination (10/page)
  *   nxb abbr ip                — filter by query (matches slug, abbr, or name)
@@ -10,48 +10,30 @@
  */
 
 import chalk from "chalk";
-import { fetchTools, resolveToolSlug, generateAbbreviations } from "./tools.js";
-import { renderHeader, renderTable, paginate, paginateInteractive, typeBadge, PAGE_SIZE, renderPageInfo } from "./ui.js";
+import { fetchTools, generateAbbreviations } from "./tools.js";
+import { paginate, paginateInteractive, PAGE_SIZE } from "./ui.js";
 
-/**
- * Render a single page of abbreviations as a table.
- */
 function renderAbbrPage(result, abbrMap) {
   if (result.total === 0) {
-    console.log(chalk.yellow("  No tools available. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
+    console.log(chalk.yellow("  No tools available."));
     return;
   }
 
-  const rows = result.items.map((t, i) => ({
-    "#": chalk.gray(result.startIndex + i + 1),
-    abbr: chalk.green.bold(abbrMap[t.slug] || ""),
-    slug: chalk.cyan(t.slug),
-    name: t.name || "",
-    type: typeBadge(t),
-  }));
-
-  const cols = [
-    { key: "#", header: "#", width: 4 },
-    { key: "abbr", header: "Abbr", width: 10, align: "center" },
-    { key: "slug", header: "Slug", width: 28 },
-    { key: "name", header: "Tool", width: 30 },
-    { key: "type", header: "Type", width: 10, align: "center" },
-  ];
-
-  renderTable(cols, rows, { headColor: "bold" });
-  console.log();
-  renderPageInfo(result);
+  for (let i = 0; i < result.items.length; i++) {
+    const t = result.items[i];
+    const idx = chalk.gray(String(result.startIndex + i + 1).padStart(2));
+    const abbr = chalk.green.bold((abbrMap[t.slug] || "").padEnd(10));
+    const slug = chalk.cyan(t.slug || "");
+    console.log(`  ${idx}  ${abbr} ${slug}`);
+  }
 }
 
 export async function abbrAction(opts = {}) {
   const { query, json: jsonMode, interactive = true, force = false, offline = false } = opts;
 
   const tools = await fetchTools({ force, offline });
-
-  // Build abbreviation map
   const abbrMap = generateAbbreviations(tools.map((t) => t.slug));
 
-  // Filter
   let filtered = tools;
   if (query) {
     const q = query.toLowerCase();
@@ -60,52 +42,39 @@ export async function abbrAction(opts = {}) {
       return (
         abbr?.toLowerCase().includes(q) ||
         t.slug.toLowerCase().includes(q) ||
-        (t.name || "").toLowerCase().includes(q) ||
-        (t.short_description || "").toLowerCase().includes(q)
+        (t.name || "").toLowerCase().includes(q)
       );
     });
   }
 
-  if (filtered.length === 0 && !jsonMode) {
-    console.log(chalk.yellow(`  No abbreviations${query ? ` matching "${query}"` : ``}.`));
-    return;
-  }
-
-  // JSON mode
   if (jsonMode) {
-    const output = filtered.reduce((acc, t) => {
-      acc[t.slug] = abbrMap[t.slug];
-      return acc;
-    }, {});
+    const output = filtered.reduce((acc, t) => { acc[t.slug] = abbrMap[t.slug]; return acc; }, {});
     console.log(JSON.stringify({ abbreviations: output, count: filtered.length }, null, 2));
     return;
   }
 
-  // Non-interactive single dump
   if (!interactive) {
-    renderHeader("Tool Abbreviations", { subtitle: `${filtered.length} tool${filtered.length === 1 ? "" : "s"} available` });
+    if (filtered.length === 0) {
+      console.log(chalk.yellow(`  No abbreviations${query ? ` matching "${query}"` : ""}.`));
+      return;
+    }
     const result = paginate(filtered, filtered.length, 1);
+    console.log(chalk.bold(`\n  Tool Abbreviations  (${filtered.length} total)\n`));
     renderAbbrPage(result, abbrMap);
+    console.log();
     return;
   }
 
-  // Interactive paginated view
-  renderHeader("Tool Abbreviations", {
-    subtitle: `${filtered.length} abbreviation${filtered.length === 1 ? "" : "s"} available`,
-  });
-
   await paginateInteractive(
     filtered,
     PAGE_SIZE,
     (result) => {
       console.clear();
-      renderHeader("Tool Abbreviations", {
-        subtitle: `${result.total} abbreviation${result.total === 1 ? "" : "s"} · page ${chalk.cyan(result.page)} of ${chalk.cyan(result.totalPages)}`,
-      });
+      console.log(chalk.bold(`\n  Tool Abbreviations  (${result.total} · page ${result.page}/${result.totalPages})\n`));
       renderAbbrPage(result, abbrMap);
     },
     {}
   );
 }
 
-export default abbrAction;
+export default abbrAction;

package/src/list.js

@@ -1,54 +1,37 @@
 /**
  * list.js — `nxb list` command.
  *
- * Lists available tools in a paginated, table-style view with icons,
- * categories, and type badges.  Supports:
+ * Simple paginated tool listing.  Clean lines, no fancy backgrounds, no tables.
  *
  *   nxb list                 — interactive pagination (10/page, prev/next)
- *   nxb list -s ssl          — filter + still paginated
+ *   nxb list -s ssl          — filter + paginated
  *   nxb list --json          — raw JSON
- *   nxb list --no-interactive— non-interactive single dump
+ *   nxb list --no-interactive— single dump
  */
 
 import chalk from "chalk";
-import { fetchTools, resolveToolSlug, generateAbbreviations } from "./tools.js";
-import { renderHeader, renderTable, paginate, paginateInteractive, typeBadge, categoryBadge, PAGE_SIZE, renderPageInfo } from "./ui.js";
+import { fetchTools } from "./tools.js";
+import { paginate, paginateInteractive, PAGE_SIZE } from "./ui.js";
 
-/**
- * Render a single page of tools as a table.
- */
 function renderToolsPage(result) {
   if (result.total === 0) {
-    console.log(chalk.yellow("  No tools found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
+    console.log(chalk.yellow("  No tools found."));
     return;
   }
 
-  const rows = result.items.map((t, i) => ({
-    "#": chalk.gray(result.startIndex + i + 1),
-    name: `${t.icon || "🔧"}  ${t.name || t.slug}`,
-    slug: chalk.cyan(t.slug || ""),
-    cat: categoryBadge(t.category || "uncategorized"),
-    type: typeBadge(t),
-    tags: t.tags && t.tags.length ? chalk.gray(t.tags.slice(0, 3).join(",")) : "",
-  }));
-
-  const cols = [
-    { key: "#", header: "#", width: 4 },
-    { key: "name", header: "Tool", width: 32 },
-    { key: "slug", header: "Slug", width: 26 },
-    { key: "cat", header: "Category", width: 14, align: "center" },
-    { key: "type", header: "Type", width: 12, align: "center" },
-    { key: "tags", header: "Tags", width: 20 },
-  ];
-
-  renderTable(cols, rows, { headColor: "bold" });
-  console.log();
-  renderPageInfo(result);
+  for (let i = 0; i < result.items.length; i++) {
+    const t = result.items[i];
+    const idx = chalk.gray(String(result.startIndex + i + 1).padStart(2));
+    const icon = t.icon || "🔧";
+    const slug = chalk.cyan(t.slug || "");
+    const desc = (t.short_description || t.description || "").slice(0, 55);
+    console.log(`  ${idx}  ${icon} ${slug.padEnd(28)} ${chalk.dim(desc)}`);
+    if (t.tags && t.tags.length) {
+      console.log(`      ${chalk.gray(t.tags.map(tg => `#${tg}`).join(" "))}`);
+    }
+  }
 }
 
-/**
- * The `nxb list` action.
- */
 export async function listAction(opts = {}) {
   const { search, json: jsonMode, interactive = true, force = false, offline = false } = opts;
 
@@ -67,41 +50,33 @@ export async function listAction(opts = {}) {
     );
   }
 
-  // ── JSON mode: dump everything, no pagination ──
   if (jsonMode) {
     console.log(JSON.stringify({ tools: filtered }, null, 2));
     return;
   }
 
-  // ── Non-interactive: single-page dump ──
   if (!interactive) {
-    renderHeader("NexusBloom Tools", { subtitle: `${filtered.length} tool${filtered.length === 1 ? "" : "s"} available` });
-    if (filtered.length === 0) return;
+    if (filtered.length === 0) {
+      console.log(chalk.yellow("  No tools found."));
+      return;
+    }
     const result = paginate(filtered, filtered.length, 1);
+    console.log(chalk.bold(`\n  NexusBloom Tools  (${filtered.length} available)\n`));
     renderToolsPage(result);
+    console.log();
     return;
   }
 
-  // ── Interactive: paginated with live navigation ──
-  const abbrMap = generateAbbreviations(filtered.map((t) => t.slug));
-  const abbrCount = Object.keys(abbrMap).filter((k) => !(k in filtered.map((t) => t.slug))).length;
-
-  renderHeader("NexusBloom Tools", {
-    subtitle: `${filtered.length} tool${filtered.length === 1 ? "" : "s"} available · page 1 of ${Math.ceil(filtered.length / PAGE_SIZE) || 1}`,
-  });
-
   await paginateInteractive(
     filtered,
     PAGE_SIZE,
     (result) => {
       console.clear();
-      renderHeader("NexusBloom Tools", {
-        subtitle: `${result.total} tool${result.total === 1 ? "" : "s"} · page ${chalk.cyan(result.page)} of ${chalk.cyan(result.totalPages)}`,
-      });
+      console.log(chalk.bold(`\n  NexusBloom Tools  (${result.total} · page ${result.page}/${result.totalPages})\n`));
       renderToolsPage(result);
     },
     {}
   );
 }
 
-export default listAction;
+export default listAction;

package/src/ui.js

@@ -1,15 +1,8 @@
 /**
  * ui.js — Terminal UI helpers for the nxb CLI.
  *
- * Everything rendering / prompting related lives here so command modules
- * stay lean and the look-and-feel is consistent across `list`, `abbr`, `run`, etc.
- *
- * Exports:
- *   - Visual primitives  : renderHeader, renderBox, renderBadge, divider
- *   - Table printer       : renderTable
- *   - Pagination engine   : paginate (pure) + paginateInteractive (live nav)
- *   - Prompt wrappers     : promptSelect, promptInput, promptConfirm,
- *                           promptNumber, promptCheckbox, promptMultiSelect
+ * Lightweight: pagination engine, inquirer prompt wrappers, simple text helpers.
+ * No box drawing, no background badges, no heavy tables.
  */
 
 import chalk from "chalk";
@@ -26,167 +19,75 @@ import {
 
 export const PAGE_SIZE = 10;
 
-// Box-drawing palette
-const BOX = {
-  topLeft: "┌",
-  topRight: "┐",
-  bottomLeft: "└",
-  bottomRight: "┘",
-  h: "─",
-  v: "│",
-};
-
-// Badge style map per tool type / category
-const BADGE_STYLES = {
-  local: { label: chalk.bgBlueBright.white(" local   "), border: "blueBright" },
-  builtin: { label: chalk.bgGreen.white(" builtin "), border: "green" },
-  community: { label: chalk.bgMagenta.white("community"), border: "magenta" },
-  uncategorized: { label: chalk.bgGray.white("  uncat  "), border: "gray" },
-};
-
 // ─── Simple helpers ──────────────────────────────────────────────────────────
 
-/** Print a thin horizontal rule across the terminal. */
-export function divider(width = 60) {
-  return console.log(chalk.gray("─".repeat(width)));
-}
-
 /**
- * Render a centered header with a title and optional subtitle.
- * Clears any previous inquirer prompt state.
+ * Print a simple bold header line.
+ *
+ *   renderHeader("Results", { subtitle: "3 items" })
+ *   // → "Results  —  3 items"
  */
-export function renderHeader(title, { subtitle, color = "cyanBright" } = {}) {
-  const bar = "═".repeat(Math.max(title.length + 4, 30));
-  const line1 = chalk[color].bold(`  ${bar}`);
-  const line2 = chalk[color].bold(`  ║  ${title.padEnd(title.length)}  ║`);
-  const line3 = chalk[color].bold(`  ${bar}`);
-  console.log("\n" + line1);
-  console.log(line2);
-  console.log(line3);
+export function renderHeader(title, { subtitle, color = "cyan" } = {}) {
+  const prefix = chalk.bold[color](`  ${title}`);
   if (subtitle) {
-    console.log(chalk.dim(`  ${subtitle}\n`));
+    console.log(`\n${prefix}  ${chalk.gray("—")}  ${chalk.dim(subtitle)}\n`);
   } else {
-    console.log();
+    console.log(`\n${prefix}\n`);
   }
 }
 
 /**
- * Render a bordered box around arbitrary content lines.
- *
- *   renderBox("Results", ["line one", "line two"], { footer: "done." })
+ * Wraps an array of content lines in a simple bordered box.
+ * Used sparingly (e.g. in the interactive runner's generated command).
  */
-export function renderBox(title, lines = [], { footer, width, borderColor = "gray" } = {}) {
-  const border = chalk[borderColor];
-  const innerWidth = (width || Math.min(72, Math.max(40, Math.max(...(lines || []).map(l => (l || "").length), title.length)))) - 4;
-  const top = border(`${BOX.topLeft}${BOX.h.repeat(innerWidth + 2)}${BOX.topRight}`);
-
-  const titleLine = border(BOX.v) + " " + chalk.bold(title) + " " + border(BOX.v);
-
-  const body = (lines || []).map((line) => {
-    const cleaned = typeof line === "string" ? line : String(line);
-    return border(BOX.v) + " " + cleaned.padEnd(innerWidth) + " " + border(BOX.v);
-  });
-
-  const bottom = border(`${BOX.bottomLeft}${BOX.h.repeat(innerWidth + 2)}${BOX.bottomRight}`);
-
-  console.log("\n" + top);
-  console.log(titleLine);
-  if (body.length) console.log(body.join("\n"));
-  if (footer) console.log(" " + chalk.dim(footer));
-  console.log(bottom + "\n");
+export function renderBox(title, lines = [], { width = 60 } = {}) {
+  const inner = Math.max(width - 4, 30);
+  const top = chalk.gray(`┌─ ${chalk.bold(title)} ${"─".repeat(Math.max(0, inner - title.length - 2))}┐`);
+  console.log(`\n${top}`);
+  for (const line of lines) {
+    if (line === "") {
+      console.log(chalk.gray(`│ ${" ".repeat(inner)} │`));
+    } else {
+      console.log(`${chalk.gray("│ ")}${String(line).padEnd(inner)}${chalk.gray(" │")}`);
+    }
+  }
+  const bottom = chalk.gray(`└${"─".repeat(inner + 2)}┘\n`);
+  console.log(bottom);
 }
 
 /**
- * Render a small colored badge.
+ * Simple text badge, no background colours.
  *
- *   renderBadge("local")          → blue background
- *   renderBadge("image")          → category badge
- *   renderBadge("custom", "info") → generic info badge
+ *   renderBadge("builtin")   → "[builtin]"
+ *   renderBadge("text")      → "[text]"
  */
-export function renderBadge(text, type = "info") {
-  if (type === "tool") {
-    const style = BADGE_STYLES[text] || BADGE_STYLES.uncategorized;
-    return style.label;
-  }
-  // Generic info badge
-  return chalk.gray(`[${text}]`);
+export function renderBadge(text) {
+  return chalk.bold(chalk.gray(`[${text}]`));
 }
 
-/** Pre-built type badge for tool objects. */
+/** Short type indicator for a tool. */
 export function typeBadge(tool) {
   const t = tool?.type || "builtin";
-  return renderBadge(t, "tool");
-}
-
-/** Pre-built category badge — shows the category name in a muted block. */
-export function categoryBadge(cat) {
-  const c = (cat || "uncategorized").toLowerCase();
-  // Known categories get a coloured block
-  const known = {
-    text: chalk.bgWhite.black(" text  "),
-    image: chalk.bgCyan.black(" image "),
-    data: chalk.bgYellow.black(" data  "),
-    network: chalk.bgBlue.white("network"),
-    security: chalk.bgRed.white("secure"),
-    development: chalk.bgGreen.white("  dev  "),
-    utility: chalk.bgGray.white("utils "),
-    math: chalk.bgGray.white(" math  "),
-    business: chalk.bgGray.white("biz   "),
-    education: chalk.bgGray.white(" learn "),
+  const styles = {
+    local: chalk.cyan,
+    builtin: chalk.green,
+    community: chalk.magenta,
   };
-  if (known[c]) return known[c];
-  // Show first 6 chars for unknown categories
-  const label = c === "uncategorized" ? " any   " : c.slice(0, 6).padEnd(6);
-  return chalk.bgGray.white(` ${label} `);
+  const colorFn = styles[t] || chalk.gray;
+  return colorFn(`[${t}]`);
 }
 
-// ─── Table printer ───────────────────────────────────────────────────────────
-
-/**
- * Render an aligned text table.
- *
- *   cols: [{ key, header, width?, align?, color? }]
- *   rows: array of objects keyed by `key`
- */
-export function renderTable(cols, rows, { indent = "  ", headColor = "bold" } = {}) {
-  const computed = cols.map((c) => ({
-    ...c,
-    width: c.width || Math.max(c.header.length, ...rows.map((r) => stringWidth(r[c.key]))),
-  }));
-
-  const fmt = (val, col) => {
-    const str = val == null ? "" : String(val);
-    const trimmed = str.length > col.width ? str.slice(0, col.width - 1) + "…" : str;
-    let cell = trimmed.padEnd(col.width);
-    if (col.align === "right") cell = trimmed.padStart(col.width);
-    if (col.color) return col.color(cell);
-    return cell;
-  };
-
-  // Header
-  const headLine = indent + computed.map((c) => chalk[headColor](c.header.padEnd(c.width))).join("  ");
-  const sepLine = indent + computed.map((c) => chalk.gray("─".repeat(c.width))).join("  ");
-
-  console.log(headLine);
-  console.log(sepLine);
-  for (const row of rows) {
-    console.log(indent + computed.map((c) => fmt(row[c.key], c)).join("  "));
-  }
-}
-
-/** Byte-safe string width (strips ANSI, handles emoji roughly). */
-function stringWidth(str) {
-  return (str || "").replace(/\x1b\[[0-9;]*m/g, "").length;
+/** Short category indicator. */
+export function categoryBadge(cat) {
+  return chalk.gray(`[${(cat || "other").slice(0, 10)}]`);
 }
 
 // ─── Pagination engine ───────────────────────────────────────────────────────
 
 /**
- * Pure pagination.  Given a flat list, return a slice plus navigation metadata.
+ * Pure pagination: slice a list + return navigation metadata.
  *
- *   const page = paginate(items, 10, 2);
- *   // { items, page, totalPages, total, pageSize, startIndex, endIndex,
- *       hasPrev, hasNext }
+ *   paginate(items, 10, 2) → { items, page, totalPages, total, ... }
  */
 export function paginate(items, pageSize = PAGE_SIZE, currentPage = 1) {
   const list = items || [];
@@ -209,14 +110,8 @@ export function paginate(items, pageSize = PAGE_SIZE, currentPage = 1) {
 }
 
 /**
- * Interactive paginator: renders the current page via `renderPage`, then offers
- * prev / next / cancel navigation until the user settles.
- *
- *   renderPage(pageResult)  → returns a value or Promise; its return is used as
- *                             the final resolved value when the user picks "Done".
- *
- * Returns the last rendered page object (with `selected` set when applicable)
- * or `null` on cancel.
+ * Interactive paginator: renders via `renderPage`, offers prev/next/done/cancel.
+ * Returns the last page result or null on cancel.
  */
 export async function paginateInteractive(items, pageSize, renderPage, options = {}) {
   const all = items || [];
@@ -229,143 +124,52 @@ export async function paginateInteractive(items, pageSize, renderPage, options =
   let result = paginate(all, pageSize, page);
 
   while (true) {
-    // Clear and re-render the page
-    if (process.stdout.isTTY) process.stdout.write("\x1b[?25l"); // hide cursor
     renderPage(result);
 
-    if (result.totalPages === 1) {
-      if (process.stdout.isTTY) process.stdout.write("\x1b[?25h");
-      return result;
-    }
-
-    // Build navigator choices
-    const footer = [];
-    if (result.hasPrev) footer.push({ name: `${chalk.cyan("◀  Prev page")}`, value: "prev", description: "Show previous page" });
-    footer.push({ name: `${chalk.cyan("→  Done")}`, value: "done", description: "Keep current view" });
-    if (result.hasNext) footer.push({ name: `${chalk.cyan("▶  Next page")}`, value: "next", description: "Show next page" });
-    footer.push({ name: `${chalk.red("✕  Cancel")}`, value: "cancel", description: "Abort" });
+    if (result.totalPages <= 1) return result;
 
-    const choices = [
-      new Separator(),
-      ...footer,
-    ];
+    const nav = [];
+    if (result.hasPrev) nav.push({ name: "◀ Prev", value: "prev" });
+    nav.push({ name: "→ Done", value: "done" });
+    if (result.hasNext) nav.push({ name: "Next ▶", value: "next" });
+    nav.push({ name: "✕ Cancel", value: "cancel" });
 
     const action = await select({
-      message: chalk.gray(`Page ${result.page} of ${result.totalPages} · ${result.total} items`),
-      choices,
-      pageSize: options.pageSize || 8,
+      message: chalk.gray(`Page ${result.page}/${result.totalPages} · ${result.total} items`),
+      choices: [new Separator(), ...nav],
+      pageSize: 8,
     });
 
-    if (process.stdout.isTTY) process.stdout.write("\x1b[?25l"); // hide again before re-render
-    if (options.beforeRender) await options.beforeRender();
-    if (action === "cancel") {
-      if (process.stdout.isTTY) process.stdout.write("\x1b[?25h");
-      return null;
-    }
-    if (action === "done") {
-      if (process.stdout.isTTY) process.stdout.write("\x1b[?25h");
-      return result;
-    }
+    if (action === "cancel") return null;
+    if (action === "done") return result;
     if (action === "prev") page = Math.max(1, page - 1);
     if (action === "next") page = Math.min(result.totalPages, page + 1);
     result = paginate(all, pageSize, page);
   }
 }
 
-/** Pagination footer: `Page 1 of 5 · 42 items` in a subtle style. */
-export function renderPageInfo(result) {
-  console.log(
-    chalk.dim(
-      `  Page ${chalk.cyan(result.page)} of ${chalk.cyan(result.totalPages)} ` +
-      chalk.gray(`· ${result.total} items`)
-    )
-  );
-}
-
-// ─── Prompt wrappers (consistent styling + sensible defaults) ─────────────────
+// ─── Prompt wrappers ─────────────────────────────────────────────────────────
 
-/**
- * Present a list of choices and return the selected value.
- *
- * choices: [{ name, value, description? }] or plain strings
- *          Use a Separator anywhere in the array.
- */
 export async function promptSelect(message, choices, opts = {}) {
-  return select({
-    message: chalk.cyan(message),
-    choices,
-    pageSize: opts.pageSize || 10,
-    ...opts,
-  });
+  return select({ message: chalk.cyan(message), choices, pageSize: opts.pageSize || 10, ...opts });
 }
 
-/** Single-line text input. */
 export async function promptInput(message, { defaultValue, validate, ...opts } = {}) {
-  return input({
-    message: chalk.cyan(message),
-    default: defaultValue,
-    ...(validate ? { validate } : {}),
-    ...opts,
-  });
+  return input({ message: chalk.cyan(message), default: defaultValue, ...(validate ? { validate } : {}), ...opts });
 }
 
-/** Yes/no confirmation. */
 export async function promptConfirm(message, { default: def = true } = {}) {
-  return confirm({
-    message: chalk.cyan(message),
-    default: def,
-  });
+  return confirm({ message: chalk.cyan(message), default: def });
 }
 
-/** Numeric input. */
 export async function promptNumber(message, { min, max, ...opts } = {}) {
-  return number({
-    message: chalk.cyan(message),
-    ...(min != null ? { min } : {}),
-    ...(max != null ? { max } : {}),
-    ...opts,
-  });
+  return number({ message: chalk.cyan(message), ...(min != null ? { min } : {}), ...(max != null ? { max } : {}), ...opts });
 }
 
-/**
- * Multi-select (checkbox) — returns array of selected values.
- * Pass `isCheckedAll` to offer a "toggle all" separator-less convenience.
- */
 export async function promptCheckbox(message, choices, opts = {}) {
-  return checkbox({
-    message: chalk.cyan(message),
-    choices,
-    pageSize: opts.pageSize || 10,
-    ...opts,
-  });
+  return checkbox({ message: chalk.cyan(message), choices, pageSize: opts.pageSize || 10, ...opts });
 }
 
-/** Convenience: separator for checkbox/choice lists. */
 export function sep(label = "") {
   return new Separator(label ? ` — ${label} — ` : "");
-}
-
-// ─── Tool-specific renderers ─────────────────────────────────────────────────
-
-/** Render a single tool row for `nxb list` / `nxb search`. */
-export function renderToolCard(tool, { compact = false } = {}) {
-  const icon = tool.icon || "🔧";
-  const name = chalk.bold.cyan(tool.name || tool.slug);
-  const slug = chalk.dim(tool.slug);
-  const badge = typeBadge(tool);
-  const desc = chalk.dim(tool.short_description || tool.description || "");
-
-  if (compact) {
-    console.log(
-      `  ${icon} ${chalk.cyan(tool.slug.padEnd(28))} ${desc.slice(0, 55)}${badge ? " " + badge : ""}`
-    );
-    return;
-  }
-
-  console.log(`  ${icon}  ${name}  ${badge}`);
-  console.log(`     ${slug}`);
-  if (desc) console.log(`     ${desc}`);
-  const tags = tool.tags && tool.tags.length ? chalk.gray(tool.tags.map((t) => `#${t}`).join(" ")) : "";
-  if (tags) console.log(`     ${tags}`);
-  console.log();
-}
+}