@nexusbloom/cli 0.2.11 → 0.3.0

package/README.md

@@ -8,15 +8,31 @@ CLI tool for NexusBloom — run tools and workflows from your terminal.
 npm install -g @nexusbloom/cli
 ```
 
-## Usage
+## Quick Start
 
 ```bash
-# List available tools
+# List available tools (interactive pagination, 10 per page)
 nxb list
 
+# Search with pagination
+nxb list -s ssl
+
+# Non-interactive mode (single page dump)
+nxb list --no-interactive
+
+# JSON output (all commands)
+nxb --json list
+
+# Show tool abbreviations (paginated)
+nxb abbr
+
 # Search tools
 nxb search "ssl"
+```
 
+## Running Tools
+
+```bash
 # Run a tool (remote API, requires API key)
 nxb run ssl-certificate-checker domain=example.com --key YOUR_API_KEY
 
@@ -26,46 +42,107 @@ nxb run css-gradient-generator --input '{"colors":["#ff6b6b","#4ecdc4"],"angle":
 # Run with file input
 nxb run css-gradient-generator --file ./gradient-input.json
 
-# Run a tool locally (fetches + caches tool source, executes coreLogic on your machine)
+# Run a tool locally (fetches + caches tool source, executes on your machine)
 nxb run ssl-certificate-checker domain=example.com --local
 
+# Interactive runner (select tool → pick inputs → auto-build command)
+nxb run
+
 # Pipe stdin through a tool
 echo '{"domain":"example.com"}' | nxb transform ssl-certificate-checker
+```
 
-# Describe what you want
-nxb chat "check if my website example.com is secure"
+## Discovery
 
-# Show tool schema
+```bash
+# Show tool schema and details
 nxb info ssl-certificate-checker
 
-# Manage local tool cache
+# Show abbreviations (useful for quick tool references)
+nxb abbr
+nxb abbr ip                  # Filter abbreviations by query
+
+# Interactive pagination for lists
+nxb list                      # Browse pages with prev / next / done
+nxb list -s validate           # Filtered + paginated
+
+# Search (full-text across slugs, names, descriptions, tags)
+nxb search "validate"
+```
+
+## Configuration
+
+```bash
+# Set config values
+nxb config set key YOUR_KEY               # Set an API key
+nxb config set default-tool ssl-scanner    # Set default tool
+
+# Get config values
+nxb config get key                         # Get specific value
+nxb config get                             # List all config values
+
+# Environment variables (alternative to config)
+#   NEXUSBLOOM_API_KEY        — API key (can also use `--key`)
+#   NEXUSBLOOM_API_URL        — API base URL (default: https://nexusbloom.dev)
+#   NEXUSBLOOM_SUPABASE_URL   — Supabase URL (for fallback fetching)
+#   NEXUSBLOOM_SUPABASE_ANON_KEY — Supabase anon key (for fallback fetching)
+```
+
+## Local Tool Cache
+
+```bash
+# List cached tools
 nxb cache list
+
+# Clear the local tool cache
 nxb cache clear
 ```
 
+## Scaffolding
+
+```bash
+# Interactive tool creation
+nxb create
+
+# Non-interactive tool creation
+nxb create --slug my-tool --name "My Tool" --desc "Does something useful"
+```
+
+## JSON Input Generation
+
+```bash
+# Generate JSON template with defaults
+nxb json --template data-generator
+
+# Interactive JSON generation (prompts for each field)
+nxb json --template css-gradient-generator -i
+
+# Set specific fields
+nxb json --template data-generator -s count=10 format=csv
+
+# Full pipeline example
+nxb json --template data-generator -s count=3 | nxb run data-generator --input @-
+```
+
 ## Options
 
 | Flag | Description |
 |------|-------------|
-| `--json` | Output results in JSON format |
-| `--key <key>` | API key (can also set via `NEXUSBLOOM_API_KEY` env var) |
-| `--input <json>` | Inline JSON input (e.g. `'{"domain":"example.com"}'`) |
-| `--file <path>` | Read input from a JSON file |
-| `--local` | Execute coreLogic locally (fetches + caches tool source) |
+| `--json` | Output results in JSON format (global flag, place before subcommand) |
+| `--no-interactive` | Disable interactive pagination for `list`/`abbr` |
 
-## Environment Variables
+## Interactive Mode Features
 
-- `NEXUSBLOOM_API_KEY` — Your API key (can also be passed with `--key`)
-- `NEXUSBLOOM_API_URL` — API base URL (default: https://nexusbloom.dev)
+- **Paginated browsing**: `nxb list` and `nxb abbr` show 10 items per page with prev/next navigation
+- **Interactive runner**: `nxb run` without a slug opens a tool selector, then prompts for each input field, then builds and executes the command
+- **Abbreviation resolution**: Tool slugs can be typed using auto-generated abbreviations (e.g. `scc` for `ssl-certificate-checker`)
 
 ## Local Execution
 
-The `--local` flag fetches the tool's v2 source code from the NexusBloom API,
-caches it locally, and executes the `coreLogic()` function directly on your
-machine. This is useful for:
+The `--local` flag fetches the tool's v2 source code from the NexusBloom API, caches it locally, and executes the `coreLogic()` function directly on your machine. This is useful for:
 
 - Offline use (after initial fetch)
 - Faster repeated execution (cached)
 - Privacy-sensitive inputs (data stays on your machine)
 
-Use `nxb cache clear` to clear the local cache.
+Use `nxb cache clear` to clear the local source cache.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/cli",
-  "version": "0.2.11",
+  "version": "0.3.0",
   "description": "NexusBloom CLI — run tools and workflows from your terminal",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.7.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "ora": "^8.0.0",

package/src/abbr.js

@@ -0,0 +1,111 @@
+/**
+ * abbr.js — `nxb abbr` command.
+ *
+ * Displays the tool abbreviation map in a paginated, table-style view.
+ *
+ *   nxb abbr                   — interactive pagination (10/page)
+ *   nxb abbr ip                — filter by query (matches slug, abbr, or name)
+ *   nxb abbr --json           — raw JSON
+ *   nxb abbr --no-interactive — single dump
+ */
+
+import chalk from "chalk";
+import { fetchTools, resolveToolSlug, generateAbbreviations } from "./tools.js";
+import { renderHeader, renderTable, paginate, paginateInteractive, typeBadge, PAGE_SIZE, renderPageInfo } 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."));
+    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);
+}
+
+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();
+    filtered = tools.filter((t) => {
+      const abbr = abbrMap[t.slug];
+      return (
+        abbr?.toLowerCase().includes(q) ||
+        t.slug.toLowerCase().includes(q) ||
+        (t.name || "").toLowerCase().includes(q) ||
+        (t.short_description || "").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;
+    }, {});
+    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` });
+    const result = paginate(filtered, filtered.length, 1);
+    renderAbbrPage(result, abbrMap);
+    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)}`,
+      });
+      renderAbbrPage(result, abbrMap);
+    },
+    {}
+  );
+}
+
+export default abbrAction;