@nexusbloom/cli 0.2.11 → 0.3.0

package/src/index.js

@@ -4,88 +4,46 @@
  * NexusBloom CLI (nxb)
  *
  * Usage:
- *   nxb list                          — List available tools
+ *   nxb list                           — List available tools (interactive pagination)
+ *   nxb list -s <query>                — Filter + paginate
  *   nxb search <query>                 — Search tools
- *   nxb run <slug> [args...]          — Execute a tool (remote API)
- *   nxb run <slug> --input '{}'       — Execute with inline JSON input
- *   nxb run <slug> --file input.json  — Execute with file input
- *   nxb run <slug> --local            — Execute coreLogic locally (cached)
+ *   nxb run <slug> [args...]           — Execute a tool (remote API)
+ *   nxb run <slug> --input '{}'        — Execute with inline JSON input
+ *   nxb run <slug> --file input.json   — Execute with file input
+ *   nxb run <slug> --local             — Execute coreLogic locally (cached)
+ *   nxb run                            — Interactive: select tool → pick inputs → auto-build command
  *   nxb info <slug>                    — Show tool schema
- *   nxb transform <slug>              — Pipe stdin through a tool
- *   nxb config set <key> [value]      — Set config (interactive if value omitted)
- *   nxb config get [key]              — Get config
- *   nxb cache clear                   — Clear local tool cache
+ *   nxb abbr                           — Show tool abbreviations (paginated)
+ *   nxb transform <slug>               — Pipe stdin through a tool
+ *   nxb config set <key> [value]       — Set config (interactive if value omitted)
+ *   nxb config get [key]               — Get config
+ *   nxb cache clear                    — Clear local tool cache
+ *   nxb cache list                     — List cached tools
+ *   nxb create                         — Scaffold a new tool locally
+ *   nxb json --template <slug>         — Create JSON input for tools
  */
 
 import { program } from "commander";
 import chalk from "chalk";
-import { createRequire } from "module";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
 import readline from "readline";
-import QRCode from "qrcode";
+import { createRequire } from "module";
 
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 
-const API_BASE = process.env.NEXUSBLOOM_API_URL || "https://www.nexusbloom.dev";
-
-// ─── Simple file-based config (avoids `conf` dependency issues) ───────────
-const CONFIG_DIR = path.join(process.env.XDG_CONFIG_HOME || path.join(require("os").homedir(), ".config"), "nexusbloom");
-const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
-
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_PATH)) {
-      return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
-    }
-  } catch { /* ignore corrupt config */ }
-  return {};
-}
-
-function saveConfig(store) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(store, null, 2), "utf-8");
-}
-
-function configGet(key) {
-  const store = loadConfig();
-  if (key) return store[key];
-  return store;
-}
-
-function configSet(key, value) {
-  const store = loadConfig();
-  store[key] = value;
-  saveConfig(store);
-}
-
-function promptValue(key) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(chalk.cyan(`  Enter value for "${key}": `), (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-// ─── Cache directory for local tool execution ────────────────────────────────
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CACHE_DIR = path.resolve(__dirname, "../.cache/tools");
-
-function ensureCacheDir() {
-  if (!fs.existsSync(CACHE_DIR)) {
-    fs.mkdirSync(CACHE_DIR, { recursive: true });
-  }
-}
+// ─── Local modules ──────────────────────────────────────────────────────────
+import { API_BASE } from "./tools.js";
+import {
+  loadConfig, saveConfig, configGet, configSet,
+  fetchTools, fetchToolSource, resolveToolSlug,
+  generateAbbreviations, readStdin,
+} from "./tools.js";
+import { runLocal, runRemote, buildInputBody, runInteractive } from "./run.js";
+import listAction from "./list.js";
+import abbrAction from "./abbr.js";
+import { TOOLS_CACHE_DIR, TOOLS_LIST_CACHE_PATH } from "./paths.js";
 
 // ─── Program ─────────────────────────────────────────────────────────────────
 program
@@ -94,61 +52,42 @@ program
   .version(version)
   .option("--json", "Output in JSON format");
 
-// ─── `nxb list` — list available tools ───────────────────────────────────────
+// ─── `nxb list` ──────────────────────────────────────────────────────────────
 program
   .command("list")
-  .description("List available tools")
-  .option("-s, --search <query>", "Search tools by name or description")
+  .description("List available tools (interactive pagination)")
+  .option("-s, --search <query>", "Search tools by name, slug, category, or tags")
+  .option("--no-interactive", "Disable interactive navigation")
   .action(async (opts, cmd) => {
-    const jsonMode = cmd.parent.opts().json || opts.json;
-    let tools = await fetchToolsWithFallback() || [];
-    // Merge in local tools from filesystem
-    const localTools = scanLocalTools();
-    const localSlugs = new Set(localTools.map(t => t.slug));
-    tools = [...localTools, ...tools.filter(t => !localSlugs.has(t.slug))];
-    if (tools.length === 0) {
-      if (jsonMode) return console.log(JSON.stringify({ tools: [] }));
-      console.log(chalk.yellow("No tools found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
-      return;
-    }
-    let filtered = tools;
-    if (opts.search) {
-      const q = opts.search.toLowerCase();
-      filtered = tools.filter(t =>
-        (t.slug || "").includes(q) ||
-        (t.name || "").toLowerCase().includes(q) ||
-        (t.description || "").toLowerCase().includes(q) ||
-        (t.category || "").includes(q)
-      );
-    }
-    if (jsonMode) return console.log(JSON.stringify({ tools: filtered }, null, 2));
-    console.log(chalk.bold(`\n  ${filtered.length} tool${filtered.length > 1 ? "s" : ""} available\n`));
-    filtered.forEach((t) => {
-      const typeBadge = t.type === "community" ? chalk.dim("[community]") : t.type === "local" ? chalk.cyan("[local]") : "";
-      console.log(`  ${chalk.cyan((t.slug || "").padEnd(30))} ${chalk.dim((t.description || "").slice(0, 50))} ${typeBadge}`);
+    const jsonMode = cmd.parent.opts().json;
+    await listAction({
+      search: opts.search,
+      json: jsonMode,
+      interactive: opts.interactive !== false,
     });
-    console.log();
   });
 
-// ─── `nxb search <query>` — search tools ─────────────────────────────────────
+// ─── `nxb search <query>` ────────────────────────────────────────────────────
 program
   .command("search")
   .description("Search for tools")
   .argument("<query>", "Search query")
   .action(async (query, opts, cmd) => {
-    const jsonMode = (cmd?.parent?.opts().json) || false;
-    const tools = await fetchToolsWithFallback();
+    const jsonMode = cmd?.parent?.opts().json || false;
+    const tools = await fetchTools();
     if (!tools || tools.length === 0) {
       if (jsonMode) return console.log(JSON.stringify({ tools: [], query }));
       console.log(chalk.yellow(`No tools found matching "${query}".`));
       return;
     }
     const q = query.toLowerCase();
-    const filtered = tools.filter(t =>
-      (t.slug || "").includes(q) ||
-      (t.name || "").toLowerCase().includes(q) ||
-      (t.description || "").toLowerCase().includes(q) ||
-      (t.category || "").includes(q)
+    const filtered = tools.filter(
+      (t) =>
+        (t.slug || "").includes(q) ||
+        (t.name || "").toLowerCase().includes(q) ||
+        (t.short_description || t.description || "").toLowerCase().includes(q) ||
+        (t.category || "").includes(q) ||
+        (t.tags || []).some((tg) => tg.toLowerCase().includes(q))
     );
     if (filtered.length === 0) {
       if (jsonMode) return console.log(JSON.stringify({ tools: [], query }));
@@ -156,18 +95,19 @@ program
       return;
     }
     if (jsonMode) return console.log(JSON.stringify({ tools: filtered, query }, null, 2));
+
     console.log(chalk.bold(`\n  ${filtered.length} result${filtered.length > 1 ? "s" : ""} for "${query}"\n`));
     filtered.forEach((t) => {
-      console.log(`  ${chalk.cyan((t.slug || "").padEnd(30))} ${chalk.dim((t.description || "").slice(0, 60))}`);
+      console.log(`  ${chalk.cyan((t.slug || "").padEnd(30))} ${chalk.dim((t.short_description || t.description || "").slice(0, 60))}`);
     });
     console.log();
   });
 
-// ─── `nxb run <slug>` — execute a tool ───────────────────────────────────────
+// ─── `nxb run [slug] [args...]` ──────────────────────────────────────────────
 program
   .command("run")
-  .description("Execute a tool")
-  .argument("<slug>", "Tool slug")
+  .description("Execute a tool (interactive if no slug is given)")
+  .argument("[slug]", "Tool slug or abbreviation")
   .argument("[args...]", "Key=value arguments (e.g. domain=example.com)")
   .option("-k, --key <key>", "API key (or set NEXUSBLOOM_API_KEY env var)")
   .option("-i, --input <json>", "Inline JSON input or @- for stdin (e.g. '{\"domain\":\"example.com\"}' or @-)")
@@ -176,367 +116,77 @@ program
   .action(async (slug, args, opts, cmd) => {
     const jsonMode = cmd.parent.opts().json;
 
-    // ── Resolve abbreviation ────────────────────────────────────────────
-    const allTools = await fetchToolsWithFallback();
+    // ── Interactive mode: no slug provided ──
+    if (!slug) {
+      return await runInteractive({ json: jsonMode });
+    }
+
+    // ── Resolve abbreviation ──
+    const allTools = await fetchTools();
     const slugs = (allTools || []).map((t) => t.slug);
     const abbrMap = generateAbbreviations(slugs);
+    let resolved = slug;
     if (abbrMap[slug] && slugs.includes(abbrMap[slug])) {
-      if (!jsonMode) console.log(chalk.dim(`  Resolved: ${slug} → ${abbrMap[slug]}`));
-      slug = abbrMap[slug];
-    }
-
-    // ── Build input body ────────────────────────────────────────────────
-    let body = {};
-
-    // 0. Detect stdin pipe (auto-detect or explicit @-)
-    const isPiped = opts.input === "@-" || opts.input === "@stdin" || (!opts.input && !opts.file && !process.stdin.isTTY);
-    if (isPiped) {
-      try {
-        const stdin = await readStdin();
-        if (stdin && stdin.trim()) {
-          body = JSON.parse(stdin);
-        }
-      } catch {
-        if (jsonMode) return console.log(JSON.stringify({ error: "Invalid JSON from stdin" }));
-        console.error(chalk.red("Error: Invalid JSON received from stdin"));
-        process.exit(1);
-      }
-    }
-
-    // 1. --input flag takes highest priority (skip if @- was used)
-    if (opts.input && opts.input !== "@-" && opts.input !== "@stdin") {
-      try {
-        body = JSON.parse(opts.input);
-      } catch {
-        if (jsonMode) return console.log(JSON.stringify({ error: "Invalid JSON in --input flag" }));
-        console.error(chalk.red("Error: --input must be valid JSON"));
-        process.exit(1);
-      }
+      resolved = abbrMap[slug];
+      if (!jsonMode) console.log(chalk.dim(`  Resolved: ${slug} → ${resolved}`));
     }
 
-    // 2. --file flag reads from a file
-    if (opts.file) {
-      try {
-        const fileContent = fs.readFileSync(path.resolve(opts.file), "utf-8");
-        const fileData = JSON.parse(fileContent);
-        // Merge file data, with --input taking precedence
-        body = { ...fileData, ...body };
-      } catch (err) {
-        if (jsonMode) return console.log(JSON.stringify({ error: `Failed to read --file: ${err.message}` }));
-        console.error(chalk.red(`Error reading file: ${err.message}`));
-        process.exit(1);
-      }
-    }
-
-    // 3. Key=value args (lowest priority, merged in)
-    if (!opts.input && !opts.file) {
-      (args || []).forEach((arg) => {
-        const [k, ...v] = arg.split("=");
-        body[k] = v.join("=");
-      });
-    }
-
-    // ── Local execution mode ────────────────────────────────────────────
-    if (opts.local) {
-      return await executeLocal(slug, body, jsonMode);
-    }
+    // ── Build input body ──
+    const body = await buildInputBody(opts, args);
+    if (body === null) return;
 
-    // ── Remote API execution ────────────────────────────────────────────
-    const apiKey = opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
-    if (!apiKey) {
-      // No API key — try local mode automatically
-      return await executeLocal(slug, body, jsonMode);
+    // ── 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 });
     }
 
-    try {
-      const res = await fetch(`${API_BASE}/api/run/${slug}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify(body),
-      });
-
-      if (!res.ok && !res.headers.get("content-type")?.includes("json")) {
-        // API returned non-JSON (likely not deployed) — fall back to local
-        if (!jsonMode) console.log(chalk.dim(`  API not deployed, falling back to local execution...`));
-        return await executeLocal(slug, body, jsonMode);
-      }
-
-      const data = await res.json();
-      if (data.success) {
-        if (jsonMode) return console.log(JSON.stringify({ success: true, data: data.data }, null, 2));
-        console.log(chalk.green("\n  Result:"));
-        // Try to render QR code if the output is SVG-based
-        if (data.data && typeof data.data === "object" && data.data.svg) {
-          await renderQRCode(body.data || body.text || JSON.stringify(body), slug);
-        }
-        console.log(`  ${JSON.stringify(data.data, null, 2)}`);
-      } else {
-        if (jsonMode) return console.log(JSON.stringify({ success: false, error: data.error || "Unknown error" }, null, 2));
-        console.error(chalk.red(`\n  Error: ${data.error || "Unknown error"}`));
-        process.exit(1);
-      }
-    } catch (err) {
-      // Network error — fall back to local
-      if (!jsonMode) console.log(chalk.dim(`  API unreachable, falling back to local execution...`));
-      return await executeLocal(slug, body, jsonMode);
-    }
+    return await runRemote(resolved, body, {
+      apiKey: opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key"),
+      jsonMode,
+      slugResolved: true,
+    });
   });
 
-// ─── Local execution helper ──────────────────────────────────────────────────
-async function executeLocal(slug, input, jsonMode) {
-  ensureCacheDir();
-  const cacheFile = path.join(CACHE_DIR, `${slug}.json`);
-
-  // Try loading from local filesystem first (fastest, most up-to-date)
-  let manifest, coreLogicSource;
-  const localToolPath = findLocalTool(slug);
-  if (localToolPath) {
-    if (!jsonMode) console.log(chalk.dim(`  Using local tool: ${slug}`));
-    const source = fs.readFileSync(localToolPath, "utf-8");
-    const manifestMatch = source.match(/export\s+const\s+MANIFEST\s*=\s*({[\s\S]*?});/);
-    if (manifestMatch) {
-      try {
-        manifest = new Function("return " + manifestMatch[1])();
-      } catch { /* will fall through to cache/API */ }
-    }
-    coreLogicSource = source;
-    // Save to cache for next time
-    if (manifest) {
-      fs.writeFileSync(cacheFile, JSON.stringify({ manifest, coreLogicSource, cachedAt: new Date().toISOString() }), "utf-8");
-    }
-  }
-
-  // Try loading from cache second
-  if (!manifest || !coreLogicSource) {
-    if (fs.existsSync(cacheFile)) {
-      try {
-        const cached = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
-        manifest = cached.manifest;
-        coreLogicSource = cached.coreLogicSource;
-        if (!jsonMode) console.log(chalk.dim(`  Using cached tool: ${slug}`));
-      } catch {
-        // Cache corrupted
-      }
-    }
-  }
-
-  // Fetch from API or Supabase if still not found
-  if (!manifest || !coreLogicSource) {
-    if (!jsonMode) console.log(chalk.dim(`  Fetching tool: ${slug}...`));
-
-    // Try API first
-    let apiSuccess = false;
-    try {
-      const res = await fetch(`${API_BASE}/api/run/${slug}`);
-      if (res.ok) {
-        const data = await res.json();
-        manifest = data.data?.manifest || data.manifest || data;
-
-        const sourceRes = await fetch(`${API_BASE}/api/run/${slug}?source=true`);
-        if (sourceRes.ok) {
-          const sourceData = await sourceRes.json();
-          coreLogicSource = sourceData.data?.v2_source;
-        }
-        apiSuccess = true;
-      }
-    } catch {
-      // API failed, try Supabase fallback
-    }
-
-    // Fallback: query Supabase directly via shared helper
-    if (!apiSuccess) {
-      try {
-        const toolInfo = await fetchToolFromSupabase(slug);
-        if (toolInfo) {
-          manifest = toolInfo.manifest;
-          coreLogicSource = toolInfo.coreLogicSource;
-          apiSuccess = true;
-        }
-      } catch {
-        // Supabase fallback also failed
-      }
-    }
-
-    if (!apiSuccess) {
-      if (jsonMode) return console.log(JSON.stringify({ error: `Tool "${slug}" not found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or run \`nxb config set supabaseKey <your-anon-key>\` for offline mode.` }));
-      console.error(chalk.red(`Tool "${slug}" not found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or run \`nxb config set supabaseKey <your-anon-key>\` for offline mode.`));
-      process.exit(1);
-    }
-
-    // Cache it
-    if (manifest) {
-      fs.writeFileSync(cacheFile, JSON.stringify({ manifest, coreLogicSource, cachedAt: new Date().toISOString() }), "utf-8");
-    }
-  }
-
-  if (!coreLogicSource) {
-    // Fallback: try to extract coreLogic from the manifest itself
-    if (jsonMode) return console.log(JSON.stringify({ error: "No v2 source available for local execution. Set NEXUSBLOOM_SUPABASE_ANON_KEY or run `nxb config set supabaseKey <your-key>`." }));
-    console.error(chalk.yellow("No v2 source available for local execution. Set NEXUSBLOOM_SUPABASE_ANON_KEY or run `nxb config set supabaseKey <your-key>`."));
-    process.exit(1);
-  }
-
-  // Execute coreLogic locally
-  try {
-    // Strip imports and exports, then wrap the full module scope in an IIFE
-    // that returns coreLogic — this preserves module-scoped helpers (e.g. generateField)
-    const cleanSource = coreLogicSource
-      .replace(/^import\s+.*?;?\s*$/gm, "")   // Remove import statements
-      .replace(/^export\s+/gm, "");            // Remove export keywords
-    const wrappedSource = `(function() {\n${cleanSource}\nreturn coreLogic;\n})()`;
-    const coreLogicFn = new Function("return " + wrappedSource)();
-    const isAsync = /export\s+async\s+function\s+coreLogic/.test(coreLogicSource);
-
-    // Validate input against manifest
-    const schema = manifest.input_schema || {};
-    const required = schema.required || [];
-    const missing = required.filter((k) => input[k] === undefined || input[k] === null);
-    if (missing.length > 0) {
-      if (jsonMode) return console.log(JSON.stringify({ error: `Missing required fields: ${missing.join(", ")}` }));
-      console.error(chalk.red(`Missing required fields: ${missing.join(", ")}`));
-      process.exit(1);
-    }
-
-    // Apply defaults
-    if (schema.properties) {
-      for (const [key, prop] of Object.entries(schema.properties)) {
-        if (input[key] === undefined && prop.default !== undefined) {
-          input[key] = prop.default;
-        }
-      }
-    }
-
-    // Create and execute the function
-    const timeoutMs = manifest.timeout_ms || 5000;
-    let result;
-
-    if (isAsync) {
-      result = await Promise.race([
-        coreLogicFn(input),
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs)),
-      ]);
-    } else {
-      result = coreLogicFn(input);
-    }
-
-    // Fire-and-forget: track the run for total runs counting and api_usage
-    const apiKey = process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
-    const trackHeaders = { "Content-Type": "application/json" };
-    if (apiKey) trackHeaders["Authorization"] = `Bearer ${apiKey}`;
-    fetch(`${API_BASE}/api/track-run`, {
-      method: "POST",
-      headers: trackHeaders,
-      body: JSON.stringify({ slug, source: "cli" }),
-    }).catch(() => {});
-
-    if (jsonMode) return console.log(JSON.stringify({ success: true, data: result }, null, 2));
-    console.log(chalk.green("\n  Result (local):"));
-    console.log(`  ${JSON.stringify(result, null, 2)}`);
-  } catch (err) {
-    if (jsonMode) return console.log(JSON.stringify({ error: err.message }));
-    console.error(chalk.red(`\n  Local execution error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-// ─── `nxb info <slug>` — show tool schema ────────────────────────────────────
+// ─── `nxb info <slug>` ───────────────────────────────────────────────────────
 program
   .command("info")
   .description("Show tool schema and details")
   .argument("<slug>", "Tool slug or abbreviation")
   .action(async (slug, opts, cmd) => {
-    const jsonMode = (cmd?.parent?.opts().json) || false;
-
-    // Resolve abbreviation
-    const allTools = await fetchToolsWithFallback();
-    const slugs = (allTools || []).map((t) => t.slug);
-    const abbrMap = generateAbbreviations(slugs);
-    if (abbrMap[slug] && slugs.includes(abbrMap[slug])) {
-      if (!jsonMode) console.log(chalk.dim(`  Resolved: ${slug} → ${abbrMap[slug]}`));
-      slug = abbrMap[slug];
-    }
+    const jsonMode = cmd?.parent?.opts().json || false;
+    const resolved = await resolveToolSlug(slug);
 
-    // Try to get manifest — API first, then Supabase fallback
-    let manifest = null;
-    try {
-      const res = await fetch(`${API_BASE}/api/run/${slug}`);
-      if (res.ok) {
-        const data = await res.json();
-        manifest = data.data?.manifest || data.manifest || data;
-      }
-    } catch { /* API failed */ }
-
-    if (!manifest) {
-      // Try Supabase fallback
-      try {
-        const toolInfo = await fetchToolFromSupabase(slug);
-        if (toolInfo) manifest = toolInfo.manifest;
-      } catch { /* fallback failed */ }
-    }
+    const toolInfo = await fetchToolSource(resolved);
+    const manifest = toolInfo?.manifest;
 
-    // Fallback: check local filesystem
     if (!manifest) {
-      const localPath = findLocalTool(slug);
-      if (localPath) {
-        const source = fs.readFileSync(localPath, "utf-8");
-        const match = source.match(/export\s+const\s+MANIFEST\s*=\s*({[\s\S]*?});/);
-        if (match) {
-          try { manifest = new Function("return " + match[1])(); } catch {}
-        }
-      }
-    }
-
-    if (!manifest) {
-      if (jsonMode) return console.log(JSON.stringify({ error: `Tool "${slug}" not found.` }));
-      console.error(chalk.red(`Tool "${slug}" not found.`));
+      if (jsonMode) return console.log(JSON.stringify({ error: `Tool "${resolved}" not found.` }));
+      console.error(chalk.red(`Tool "${resolved}" not found.`));
       return;
     }
 
     if (jsonMode) return console.log(JSON.stringify(manifest, null, 2));
-    const toolName = manifest.name || manifest.slug || slug;
-    console.log(chalk.bold(`\n  ${toolName}`));
-    console.log(`  ${chalk.dim(manifest.short_description || "")}`);
-    console.log(`  Version: ${chalk.cyan(manifest.version || "1.0.0")}`);
-    console.log(`  Runtime: ${chalk.cyan(manifest.runtime || "browser")}`);
-    console.log(`  Pricing: ${chalk.green("free")}`);
-    if (manifest.input_schema?.properties) {
-      console.log(chalk.bold(`\n  Input Parameters:`));
-      const props = manifest.input_schema.properties;
-      const required = manifest.input_schema.required || [];
-      for (const [name, prop] of Object.entries(props)) {
-        const req = required.includes(name) ? chalk.red(" *required") : "";
-        console.log(`    ${chalk.cyan(name)} (${prop.type})${req}`);
-        if (prop.description) console.log(`      ${chalk.dim(prop.description)}`);
-      }
-    }
-    if (manifest.output_schema?.properties) {
-      console.log(chalk.bold(`\n  Output:`));
-      for (const [name, prop] of Object.entries(manifest.output_schema.properties)) {
-        console.log(`    ${chalk.cyan(name)} (${prop.type})`);
-      }
-    }
-    console.log();
+
+    renderToolInfo(manifest, resolved);
   });
 
-// ─── `nxb transform <slug>` — pipe stdin through a tool ──────────────────────
+// ─── `nxb transform <slug>` ──────────────────────────────────────────────────
 program
   .command("transform")
   .description("Pipe stdin through a tool and write result to stdout")
-  .argument("<slug>", "Tool slug")
+  .argument("<slug>", "Tool slug or abbreviation")
   .option("-k, --key <key>", "API key (or set NEXUSBLOOM_API_KEY env var)")
   .option("--local", "Execute locally (faster for repeated use)")
   .action(async (slug, opts, cmd) => {
+    const resolved = await resolveToolSlug(slug);
     const jsonMode = cmd.parent.opts().json;
-    const apiKey = opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
 
     const input = await readStdin();
     if (!input) {
       if (jsonMode) return console.log(JSON.stringify({ error: "No input received from stdin" }));
       console.error(chalk.red("No input received from stdin. Pipe data into this command."));
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
 
     let body;
@@ -546,46 +196,37 @@ program
       body = { input };
     }
 
-    if (opts.local) {
-      return await executeLocal(slug, body, jsonMode);
+    if (opts.local || (!opts.key && !process.env.NEXUSBLOOM_API_KEY && !configGet("apiKey") && !configGet("key"))) {
+      return await runLocal(resolved, body, { jsonMode, slugResolved: true });
     }
 
+    const apiKey = opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
     if (!apiKey) {
       if (jsonMode) return console.log(JSON.stringify({ error: "API key required" }));
       console.error(chalk.red("API key required. Set NEXUSBLOOM_API_KEY, pass --key, or use --local mode."));
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
 
-    try {
-      const res = await fetch(`${API_BASE}/api/run/${slug}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify(body),
-      });
-      if (!res.ok && !res.headers.get("content-type")?.includes("json")) {
-        if (!jsonMode) console.log(chalk.dim(`  API not deployed, falling back to local execution...`));
-        return await executeLocal(slug, body, jsonMode);
-      }
-      const data = await res.json();
-      if (data.success) {
-        const output = typeof data.data === "string" ? data.data : JSON.stringify(data.data, null, 2);
-        if (jsonMode) return console.log(JSON.stringify({ success: true, data: data.data }, null, 2));
-        process.stdout.write(output + "\n");
-      } else {
-        if (jsonMode) return console.log(JSON.stringify({ success: false, error: data.error || "Unknown error" }, null, 2));
-        console.error(chalk.red(`\n  Error: ${data.error || "Unknown error"}`));
-        process.exit(1);
-      }
-    } catch (err) {
-      if (!jsonMode) console.log(chalk.dim(`  API unreachable, falling back to local execution...`));
-      return await executeLocal(slug, body, jsonMode);
-    }
+    await runRemote(resolved, body, { apiKey, jsonMode, slugResolved: true });
   });
 
-// ─── `nxb config` — manage configuration ─────────────────────────────────────
+// ─── `nxb abbr [query]` ──────────────────────────────────────────────────────
+program
+  .command("abbr")
+  .description("Show tool abbreviations (paginated)")
+  .argument("[query]", "Search/filter abbreviations")
+  .option("--no-interactive", "Disable interactive navigation")
+  .action(async (query, opts, cmd) => {
+    const jsonMode = cmd.parent.opts().json;
+    await abbrAction({
+      query,
+      json: jsonMode,
+      interactive: opts.interactive !== false,
+    });
+  });
+
+// ─── `nxb config` ────────────────────────────────────────────────────────────
 const configCmd = program
   .command("config")
   .description("Manage CLI configuration");
@@ -645,7 +286,7 @@ configCmd
     }
   });
 
-// ─── `nxb cache` — manage local tool cache ─────────────────────────────────
+// ─── `nxb cache` ─────────────────────────────────────────────────────────────
 const cacheCmd = program
   .command("cache")
   .description("Manage local tool cache");
@@ -654,13 +295,20 @@ cacheCmd
   .command("clear")
   .description("Clear the local tool cache")
   .action(() => {
-    ensureCacheDir();
-    const files = fs.readdirSync(CACHE_DIR);
+    if (!fs.existsSync(TOOLS_CACHE_DIR)) {
+      console.log(chalk.yellow("  No cache directory found."));
+      return;
+    }
+    const files = fs.readdirSync(TOOLS_CACHE_DIR);
     let count = 0;
     for (const file of files) {
-      fs.unlinkSync(path.join(CACHE_DIR, file));
+      fs.unlinkSync(path.join(TOOLS_CACHE_DIR, file));
       count++;
     }
+    // Also remove tools-list.json
+    if (fs.existsSync(TOOLS_LIST_CACHE_PATH)) {
+      fs.unlinkSync(TOOLS_LIST_CACHE_PATH);
+    }
     console.log(chalk.green(`  Cleared ${count} cached tool${count !== 1 ? "s" : ""}.`));
   });
 
@@ -668,8 +316,11 @@ cacheCmd
   .command("list")
   .description("List cached tools")
   .action(() => {
-    ensureCacheDir();
-    const files = fs.readdirSync(CACHE_DIR);
+    if (!fs.existsSync(TOOLS_CACHE_DIR)) {
+      console.log(chalk.yellow("  No cached tools."));
+      return;
+    }
+    const files = fs.readdirSync(TOOLS_CACHE_DIR);
     if (files.length === 0) {
       console.log(chalk.yellow("  No cached tools."));
       return;
@@ -677,441 +328,14 @@ cacheCmd
     console.log(chalk.bold(`\n  ${files.length} cached tool${files.length > 1 ? "s" : ""}:\n`));
     files.forEach((f) => {
       const slug = f.replace(/\.json$/, "");
-      const stats = fs.statSync(path.join(CACHE_DIR, f));
+      const stats = fs.statSync(path.join(TOOLS_CACHE_DIR, f));
       const age = Math.round((Date.now() - stats.mtimeMs) / 1000 / 60);
       console.log(`  ${chalk.cyan(slug.padEnd(30))} ${chalk.dim(`${age}m ago`)}`);
     });
     console.log();
   });
 
-// ─── Abbreviation generator ──────────────────────────────────────────────────
-
-function generateAbbreviations(slugs) {
-  const abbrMap = {};
-  const used = new Set();
-
-  for (const slug of slugs) {
-    // Try first letter of each word
-    const parts = slug.split("-");
-    let abbr = parts.map((p) => p[0]).join("").toLowerCase();
-
-    // If taken, try longer combinations
-    if (used.has(abbr) || abbr.length < 2) {
-      for (let len = 2; len <= slug.length; len++) {
-        abbr = slug.slice(0, len);
-        if (!used.has(abbr)) break;
-      }
-    }
-
-    used.add(abbr);
-    abbrMap[slug] = abbr;
-    abbrMap[abbr] = slug;
-  }
-
-  return abbrMap;
-}
-
-// ─── `nxb abbr` — show tool abbreviations ────────────────────────────────────
-
-program
-  .command("abbr")
-  .description("Show tool abbreviations")
-  .argument("[query]", "Search/filter abbreviations (e.g. 'ip' shows all IP-related tools)")
-  .action(async (query, opts, cmd) => {
-    const tools = await fetchToolsWithFallback();
-    if (!tools || tools.length === 0) {
-      console.log(chalk.yellow("  No tools available. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
-      return;
-    }
-    const slugs = tools.map((t) => t.slug);
-    const abbrMap = generateAbbreviations(slugs);
-
-      // Filter by query if provided
-      let filtered = slugs;
-      if (query) {
-        const q = query.toLowerCase();
-        filtered = slugs.filter(
-          (slug) => slug.includes(q) || abbrMap[slug].includes(q) || (tools || []).find(t => t.slug === slug)?.name?.toLowerCase().includes(q)
-        );
-        if (filtered.length === 0) {
-          console.log(chalk.yellow(`  No abbreviations matching "${query}"`));
-          return;
-        }
-      }
-
-      console.log(chalk.bold(`\n  Tool Abbreviations${query ? ` matching "${query}"` : ""}:\n`));
-    filtered.forEach((slug) => {
-      const tool = (tools || []).find(t => t.slug === slug);
-      const name = tool?.name || slug;
-      console.log(`  ${chalk.cyan(abbrMap[slug].padEnd(15))} → ${chalk.dim(slug.padEnd(30))} ${chalk.gray(name)}`);
-    });
-    console.log();
-  });
-
-// ─── `nxb json` — create JSON input for tools ───────────────────────────────
-
-program
-  .command("json")
-  .description("Create JSON input for tools (pipe into nxb run)")
-  .option("-t, --template <slug>", "Generate JSON template for a specific tool")
-  .option("-i, --interactive", "Interactive mode - prompts for each field")
-  .option("-s, --set <key=value...>", "Set specific field values (e.g. -s count=10 format=csv)")
-  .option("-a, --add <json>", "Merge additional JSON into the output (e.g. -a '{\"count\":20}')")
-  .action(async (opts, cmd) => {
-    const jsonMode = cmd.parent.opts().json;
-
-    if (opts.template) {
-      // Fetch tool schema — try API first, then Supabase
-      let manifest = null;
-      try {
-        const res = await fetch(`${API_BASE}/api/run/${opts.template}`);
-        if (res.ok) {
-          const data = await res.json();
-          manifest = data.data?.manifest || data.manifest || data;
-        }
-      } catch { /* API failed */ }
-
-      if (!manifest) {
-        const toolInfo = await fetchToolFromSupabase(opts.template);
-        if (toolInfo) manifest = toolInfo.manifest;
-      }
-
-      if (!manifest) {
-        console.error(chalk.red(`Tool "${opts.template}" not found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API.`));
-        process.exit(1);
-      }
-      const schema = manifest.input_schema || {};
-
-      let result = {};
-
-      if (opts.interactive) {
-        // Interactive mode
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const ask = (q) => new Promise((r) => rl.question(q, r));
-
-        if (schema.properties) {
-          for (const [key, prop] of Object.entries(schema.properties)) {
-            const required = schema.required?.includes(key);
-            const hint = prop.description ? ` (${prop.description})` : "";
-            const def = prop.default ? ` [${prop.default}]` : "";
-            const answer = await ask(chalk.cyan(`  ${key}${hint}${def}: `));
-            const val = answer || prop.default;
-            if (val !== undefined && val !== "") {
-              result[key] = prop.type === "number" || prop.type === "integer" ? Number(val) : val;
-            }
-          }
-        }
-        rl.close();
-      } else {
-        // Generate template with defaults
-        if (schema.properties) {
-          for (const [key, prop] of Object.entries(schema.properties)) {
-            if (prop.default !== undefined) {
-              result[key] = prop.default;
-            } else if (prop.type === "string") {
-              result[key] = prop.enum ? prop.enum[0] : "";
-            } else if (prop.type === "number" || prop.type === "integer") {
-              result[key] = 0;
-            } else if (prop.type === "boolean") {
-              result[key] = false;
-            } else if (prop.type === "array") {
-              result[key] = [];
-            } else if (prop.type === "object") {
-              result[key] = {};
-            }
-          }
-        }
-      }
-
-      // ── Apply --set overrides ──────────────────────────────────────
-      if (opts.set) {
-        const sets = Array.isArray(opts.set) ? opts.set : [opts.set];
-        for (const pair of sets) {
-          const eqIdx = pair.indexOf("=");
-          if (eqIdx > 0) {
-            const k = pair.slice(0, eqIdx);
-            let v = pair.slice(eqIdx + 1);
-            // Try parsing as number or boolean
-            if (v === "true") v = true;
-            else if (v === "false") v = false;
-            else if (!isNaN(v) && v.trim() !== "") v = Number(v);
-            result[k] = v;
-          }
-        }
-      }
-
-      // ── Apply --add merge ──────────────────────────────────────────
-      if (opts.add) {
-        try {
-          const extra = typeof opts.add === "string" ? JSON.parse(opts.add) : opts.add;
-          result = { ...result, ...extra };
-        } catch {
-          console.error(chalk.red("Error: --add must be valid JSON"));
-          process.exit(1);
-        }
-      }
-
-      const output = JSON.stringify(result, null, jsonMode ? 2 : 0);
-      if (jsonMode) return console.log(output);
-      console.log(output);
-    } else {
-      console.log(chalk.yellow("Usage:"));
-      console.log(chalk.dim("  nxb json --template <slug>              Generate JSON template with defaults"));
-      console.log(chalk.dim("  nxb json --template <slug> -i            Interactive mode (prompts for fields)"));
-      console.log(chalk.dim("  nxb json --template <slug> -s count=10   Set specific field values"));
-      console.log(chalk.dim("  nxb json --template <slug> -a '{\"x\":1}'  Merge additional JSON"));
-      console.log(chalk.dim(""));
-      console.log(chalk.dim("  Examples:"));
-      console.log(chalk.dim("    nxb json --template data-generator | nxb run data-generator --input @-"));
-      console.log(chalk.dim("    nxb run data-generator --input \"$(nxb json --template dg -s count=5)\""));
-      console.log(chalk.dim("    nxb json --template color-palette -s color=#4A5D23 --json"));
-    }
-  });
-
-// ─── Supabase Helpers ─────────────────────────────────────────────────────────
-
-const SUPABASE_URL_DEFAULT = "https://dhxaqatmuprehrkszxzs.supabase.co";
-const SUPABASE_ANON_KEY_DEFAULT = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImRoeGFxYXRtdXByZWhya3N6eHpzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzMxNjIzNTQsImV4cCI6MjA4ODczODM1NH0.pq7DxW66ETQt6QlIAu2WiLO08tfA7JHQVPd2SvvA3sM";
-
-function getSupabaseKey() {
-  return process.env.NEXUSBLOOM_SUPABASE_ANON_KEY 
-    || configGet("supabaseKey") 
-    || SUPABASE_ANON_KEY_DEFAULT;
-}
-
-function getSupabaseUrl() {
-  return process.env.NEXUSBLOOM_SUPABASE_URL 
-    || SUPABASE_URL_DEFAULT;
-}
-
-function supabaseHeaders() {
-  const key = getSupabaseKey();
-  return { apikey: key, Authorization: `Bearer ${key}` };
-}
-
-/**
- * Fetch tool list from Supabase directly (fallback when API is down).
- * Returns array of {slug, name, short_description, category, runtime, version, icon} or null.
- */
-async function fetchToolsFromSupabase() {
-  const headers = supabaseHeaders();
-  const supabaseUrl = getSupabaseUrl();
-  try {
-    const res = await fetch(
-      `${supabaseUrl}/rest/v1/tools?select=slug,name,short_description,tool_type,runtime,version,icon&published=eq.true&order=name.asc`,
-      { headers }
-    );
-    if (!res.ok) return null;
-    const tools = await res.json();
-    if (!Array.isArray(tools)) return null;
-
-    // Also fetch community tools
-    const communityRes = await fetch(
-      `${supabaseUrl}/rest/v1/community_tools?select=slug,name,short_description,category,version,icon,author_id&status=eq.published&order=name.asc`,
-      { headers }
-    );
-    const communityTools = communityRes.ok ? (await communityRes.json()) : [];
-
-    const allTools = [
-      ...tools.map(t => ({
-        slug: t.slug,
-        name: t.name,
-        description: t.short_description || "",
-        category: t.tool_type || "uncategorized",
-        runtime: t.runtime || "both",
-        version: t.version || "1.0.0",
-        icon: t.icon || "🔧",
-        type: "builtin",
-      })),
-      ...communityTools.map(t => ({
-        slug: t.slug,
-        name: t.name,
-        description: t.short_description || "",
-        category: t.category || "uncategorized",
-        runtime: "both",
-        version: t.version || "1.0.0",
-        icon: t.icon || "🛠️",
-        type: "community",
-        author_id: t.author_id,
-      })),
-    ];
-
-    return allTools;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Fetch a single tool's v2_source from Supabase (fallback).
- * Returns {manifest, coreLogicSource, v2Source} or null.
- */
-async function fetchToolFromSupabase(slug) {
-  const headers = supabaseHeaders();
-  const supabaseUrl = getSupabaseUrl();
-  try {
-    // Try builtin tools first
-    const toolRes = await fetch(
-      `${supabaseUrl}/rest/v1/tools?slug=eq.${slug}&select=id&published=eq.true`,
-      { headers }
-    );
-    let tools = await toolRes.json();
-    let toolId = tools?.[0]?.id;
-    let toolType = "builtin";
-
-    // Fall back to community tools
-    if (!toolId) {
-      const comRes = await fetch(
-        `${supabaseUrl}/rest/v1/community_tools?slug=eq.${slug}&select=id&status=eq.published`,
-        { headers }
-      );
-      const comTools = await comRes.json();
-      toolId = comTools?.[0]?.id;
-      toolType = "community";
-    }
-
-    if (!toolId) return null;
-
-    const versionRes = await fetch(
-      `${supabaseUrl}/rest/v1/tool_versions?tool_id=eq.${toolId}&tool_type=eq.${toolType}&status=eq.published&select=v2_source&order=created_at.desc&limit=1`,
-      { headers }
-    );
-    const versions = await versionRes.json();
-    const v2Source = versions?.[0]?.v2_source;
-    if (!v2Source) return null;
-
-    const manifestMatch = v2Source.match(/export\s+const\s+MANIFEST\s*=\s*({[\s\S]*?});\s*\n/);
-    let manifest = null;
-    if (manifestMatch) {
-      try {
-        manifest = new Function("return " + manifestMatch[1])();
-      } catch {
-        try {
-          manifest = JSON.parse(manifestMatch[1].replace(/(\w+):/g, '"$1":').replace(/'/g, '"'));
-        } catch {
-          manifest = eval("(" + manifestMatch[1] + ")");
-        }
-      }
-    }
-    return { manifest, coreLogicSource: v2Source, v2Source };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Try API first, fall back to Supabase. Returns array or null.
- */
-async function fetchToolsWithFallback() {
-  // Try API first
-  try {
-    const url = new URL("/api/tools", API_BASE);
-    const res = await fetch(url);
-    const ct = res.headers.get("content-type") || "";
-    if (ct.includes("json")) {
-      const { tools } = await res.json();
-      if (Array.isArray(tools) && tools.length > 0) return tools;
-    }
-  } catch { /* API failed */ }
-
-  // Fall back to Supabase
-  const supabaseTools = await fetchToolsFromSupabase();
-  if (supabaseTools) return supabaseTools;
-  return null;
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-/**
- * Search the local filesystem for a tool v2.js file.
- * Checks common locations relative to CWD.
- */
-function findLocalTool(slug) {
-  const cwd = process.cwd();
-  const candidates = [
-    path.join(cwd, "src", "tools", slug, "v2.js"),
-    path.join(cwd, "tools", slug, "v2.js"),
-    path.join(cwd, slug, "v2.js"),
-    path.join(cwd, "apps", "main-site", "frontend", "src", "tools", slug, "v2.js"),
-    path.join(cwd, "..", "apps", "main-site", "frontend", "src", "tools", slug, "v2.js"),
-  ];
-  try {
-    const config = loadConfig();
-    const toolsDir = config.toolsDir;
-    if (toolsDir && !candidates.some(c => c.includes(toolsDir))) {
-      candidates.unshift(path.join(cwd, toolsDir, slug, "v2.js"));
-    }
-  } catch {}
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
-/**
- * Scan the local filesystem for all tool v2.js files.
- * Returns array of { slug, name, description, type: "local" }.
- */
-function scanLocalTools() {
-  const cwd = process.cwd();
-  const searchDirs = [
-    path.join(cwd, "src", "tools"),
-    path.join(cwd, "tools"),
-    path.join(cwd, "apps", "main-site", "frontend", "src", "tools"),
-  ];
-  const tools = [];
-  for (const dir of searchDirs) {
-    if (!fs.existsSync(dir)) continue;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const v2Path = path.join(dir, entry.name, "v2.js");
-      if (!fs.existsSync(v2Path)) continue;
-      const source = fs.readFileSync(v2Path, "utf-8");
-      const match = source.match(/export\s+const\s+MANIFEST\s*=\s*({[\s\S]*?});/);
-      if (!match) continue;
-      try {
-        const m = new Function("return " + match[1])();
-        tools.push({
-          slug: m.slug || entry.name,
-          name: m.name || entry.name,
-          description: m.short_description || "",
-          category: m.category || "uncategorized",
-          runtime: m.runtime || "both",
-          version: m.version || "1.0.0",
-          icon: m.icon || "🔧",
-          type: "local",
-        });
-      } catch {}
-    }
-  }
-  return tools;
-}
-
-function readStdin() {
-  return new Promise((resolve) => {
-    const chunks = [];
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve(chunks.join("")));
-    if (process.stdin.isTTY) resolve("");
-  });
-}
-
-// ─── QR Code Terminal Renderer ────────────────────────────────────────────
-
-async function renderQRCode(data, slug) {
-  try {
-    const qr = await QRCode.toString(data, { type: "terminal", small: true });
-    console.log(chalk.cyan("\n  QR Code:"));
-    console.log(qr);
-    console.log(chalk.dim(`  Data: ${data.slice(0, 80)}${data.length > 80 ? "..." : ""}`));
-  } catch {
-    // Silently skip if QR rendering fails
-  }
-}
-
-// ─── `nxb create` — scaffold a new tool locally ──────────────────────────
+// ─── `nxb create` ────────────────────────────────────────────────────────────
 const VALID_RUNTIMES = ["browser", "node", "both"];
 const VALID_CATEGORIES = [
   "text", "image", "data", "network", "security", "development",
@@ -1128,13 +352,9 @@ program
   .option("--runtime <runtime>", `Runtime (${VALID_RUNTIMES.join(", ")})`)
   .option("--dir <dir>", "Target directory (default: ./src/tools/<slug>)")
   .action(async (options) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise((r) => rl.question(q, r));
 
-    // Gather inputs
     let slug = options.slug;
     while (!slug || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
       slug = (await ask(chalk.cyan("Tool slug (e.g. my-tool): "))).trim().toLowerCase();
@@ -1180,7 +400,6 @@ program
 
     rl.close();
 
-    // Generate v2.js source
     const pascalName = slug
       .split("-")
       .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
@@ -1261,27 +480,24 @@ export default function ${pascalName}Tool({ onResult }) {
 }
 `;
 
-    // Determine target directory
     const targetDir = options.dir || path.join(process.cwd(), "src/tools", slug);
     const v2Path = path.join(targetDir, "v2.js");
     const indexPath = path.join(targetDir, "index.js");
 
-    // Check for existing files
     if (fs.existsSync(v2Path) || fs.existsSync(indexPath)) {
-      const overwrite = (await new Promise((r) => {
+      const overwrite = await new Promise((r) => {
         const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
         rl2.question(chalk.yellow(`Tool "${slug}" already exists. Overwrite? (y/N): `), (a) => {
           rl2.close();
           r(a.trim().toLowerCase() === "y");
         });
-      }));
+      });
       if (!overwrite) {
         console.log(chalk.dim("Aborted."));
         return;
       }
     }
 
-    // Write files
     fs.mkdirSync(targetDir, { recursive: true });
     fs.writeFileSync(v2Path, v2Source, "utf-8");
     fs.writeFileSync(indexPath, indexSource, "utf-8");
@@ -1295,4 +511,153 @@ export default function ${pascalName}Tool({ onResult }) {
     console.log(chalk.dim("    3. Publish from the VS Code extension or API\n"));
   });
 
-program.parse(process.argv);
+// ─── `nxb json` ─────────────────────────────────────────────────────────────
+program
+  .command("json")
+  .description("Create JSON input for tools (pipe into nxb run)")
+  .option("-t, --template <slug>", "Generate JSON template for a specific tool")
+  .option("-i, --interactive", "Interactive mode - prompts for each field")
+  .option("-s, --set <key=value...>", "Set specific field values (e.g. -s count=10 format=csv)")
+  .option("-a, --add <json>", "Merge additional JSON into the output (e.g. -a '{\"count\":20}')")
+  .action(async (opts, cmd) => {
+    const jsonMode = cmd.parent.opts().json;
+
+    if (opts.template) {
+      const resolved = await resolveToolSlug(opts.template);
+      const toolInfo = await fetchToolSource(resolved);
+      const manifest = toolInfo?.manifest;
+
+      if (!manifest) {
+        console.error(chalk.red(`Tool "${resolved}" not found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API.`));
+        process.exitCode = 1;
+        return;
+      }
+
+      const schema = manifest.input_schema || {};
+      let result = {};
+
+      if (opts.interactive) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (q) => new Promise((r) => rl.question(q, r));
+
+        if (schema.properties) {
+          for (const [key, prop] of Object.entries(schema.properties)) {
+            const required = schema.required?.includes(key);
+            const hint = prop.description ? ` (${prop.description})` : "";
+            const def = prop.default !== undefined ? ` [${JSON.stringify(prop.default)}]` : "";
+            const enumInfo = prop.enum && prop.enum.length > 0
+              ? ` {${prop.enum.map((v) => JSON.stringify(v)).join("|")}}`
+              : "";
+            const answer = await ask(chalk.cyan(`  ${key}${hint}${enumInfo}${def}: `));
+            const val = answer || prop.default;
+            if (val !== undefined && val !== "") {
+              result[key] = prop.type === "number" || prop.type === "integer" ? Number(val) : val;
+            }
+          }
+        }
+        rl.close();
+      } else {
+        if (schema.properties) {
+          for (const [key, prop] of Object.entries(schema.properties)) {
+            if (prop.default !== undefined) {
+              result[key] = prop.default;
+            } else if (prop.type === "string") {
+              result[key] = prop.enum ? prop.enum[0] : "";
+            } else if (prop.type === "number" || prop.type === "integer") {
+              result[key] = 0;
+            } else if (prop.type === "boolean") {
+              result[key] = false;
+            } else if (prop.type === "array") {
+              result[key] = [];
+            } else if (prop.type === "object") {
+              result[key] = {};
+            }
+          }
+        }
+      }
+
+      if (opts.set) {
+        const sets = Array.isArray(opts.set) ? opts.set : [opts.set];
+        for (const pair of sets) {
+          const eqIdx = pair.indexOf("=");
+          if (eqIdx > 0) {
+            const k = pair.slice(0, eqIdx);
+            let v = pair.slice(eqIdx + 1);
+            if (v === "true") v = true;
+            else if (v === "false") v = false;
+            else if (!isNaN(v) && v.trim() !== "") v = Number(v);
+            result[k] = v;
+          }
+        }
+      }
+
+      if (opts.add) {
+        try {
+          const extra = typeof opts.add === "string" ? JSON.parse(opts.add) : opts.add;
+          result = { ...result, ...extra };
+        } catch {
+          console.error(chalk.red("Error: --add must be valid JSON"));
+          process.exitCode = 1;
+        }
+      }
+
+      const output = JSON.stringify(result, null, jsonMode ? 2 : 0);
+      if (jsonMode) return console.log(output);
+      console.log(output);
+    } else {
+      console.log(chalk.yellow("Usage:"));
+      console.log(chalk.dim("  nxb json --template <slug>              Generate JSON template with defaults"));
+      console.log(chalk.dim("  nxb json --template <slug> -i            Interactive mode (prompts for fields)"));
+      console.log(chalk.dim("  nxb json --template <slug> -s count=10   Set specific field values"));
+      console.log(chalk.dim("  nxb json --template <slug> -a '{\"x\":1}'  Merge additional JSON"));
+      console.log(chalk.dim(""));
+      console.log(chalk.dim("  Examples:"));
+      console.log(chalk.dim("    nxb json --template data-generator | nxb run data-generator --input @-"));
+      console.log(chalk.dim("    nxb run data-generator --input \"$(nxb json --template dg -s count=5)\""));
+      console.log(chalk.dim("    nxb json --template color-palette -s color=#4A5D23 --json"));
+    }
+  });
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function promptValue(key) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(chalk.cyan(`  Enter value for "${key}": `), (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function renderToolInfo(manifest, resolved) {
+  const toolName = manifest.name || manifest.slug || resolved;
+  console.log(chalk.bold(`\n  ${toolName}`));
+  console.log(`  ${chalk.dim(manifest.short_description || "")}`);
+  console.log(`  Version: ${chalk.cyan(manifest.version || "1.0.0")}`);
+  console.log(`  Runtime: ${chalk.cyan(manifest.runtime || "browser")}`);
+  console.log(`  Pricing: ${chalk.green("free")}`);
+  if (manifest.input_schema?.properties) {
+    console.log(chalk.bold(`\n  Input Parameters:`));
+    const props = manifest.input_schema.properties;
+    const required = manifest.input_schema.required || [];
+    for (const [name, prop] of Object.entries(props)) {
+      const req = required.includes(name) ? chalk.red(" *required") : "";
+      const def = prop.default !== undefined ? chalk.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
+      console.log(`    ${chalk.cyan(name)} (${prop.type})${req}${def}`);
+      if (prop.description) console.log(`      ${chalk.dim(prop.description)}`);
+      if (prop.enum && prop.enum.length > 0) {
+        console.log(`      ${chalk.dim("Allowed values:")} ${chalk.cyan(prop.enum.map((v) => JSON.stringify(v)).join(", "))}`);
+      }
+    }
+  }
+  if (manifest.output_schema?.properties) {
+    console.log(chalk.bold(`\n  Output:`));
+    for (const [name, prop] of Object.entries(manifest.output_schema.properties)) {
+      console.log(`    ${chalk.cyan(name)} (${prop.type})`);
+    }
+  }
+  console.log();
+}
+
+program.parse(process.argv);