@nexusbloom/cli 0.2.10 → 0.2.12

package/package.json

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

package/src/index.js

@@ -508,8 +508,12 @@ program
       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}`);
+        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) {
@@ -525,10 +529,13 @@ program
 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) => {
+    // Resolve abbreviation
+    slug = await resolveToolSlug(slug);
+
     const jsonMode = cmd.parent.opts().json;
     const apiKey = opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
 
@@ -748,6 +755,20 @@ program
     console.log();
   });
 
+// ─── Shared abbreviation resolver ─────────────────────────────────────────────
+// Extracts the abbr resolution logic so all commands that accept slugs can use it.
+
+async function resolveToolSlug(slug) {
+  const allTools = await fetchToolsWithFallback();
+  if (!allTools) return slug;
+  const slugs = allTools.map((t) => t.slug);
+  const abbrMap = generateAbbreviations(slugs);
+  if (abbrMap[slug] && slugs.includes(abbrMap[slug])) {
+    return abbrMap[slug];
+  }
+  return slug;
+}
+
 // ─── `nxb json` — create JSON input for tools ───────────────────────────────
 
 program
@@ -761,6 +782,9 @@ program
     const jsonMode = cmd.parent.opts().json;
 
     if (opts.template) {
+      // Resolve abbreviation
+      opts.template = await resolveToolSlug(opts.template);
+
       // Fetch tool schema — try API first, then Supabase
       let manifest = null;
       try {
@@ -793,8 +817,11 @@ program
           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 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;
@@ -1111,4 +1138,188 @@ async function renderQRCode(data, slug) {
   }
 }
 
+// ─── `nxb create` — scaffold a new tool locally ──────────────────────────
+const VALID_RUNTIMES = ["browser", "node", "both"];
+const VALID_CATEGORIES = [
+  "text", "image", "data", "network", "security", "development",
+  "education", "business", "utility", "math", "game", "Other",
+];
+
+program
+  .command("create")
+  .description("Scaffold a new tool locally")
+  .option("--slug <slug>", "Tool slug (lowercase, hyphenated)")
+  .option("--name <name>", "Display name")
+  .option("--desc <desc>", "Short description")
+  .option("--category <category>", `Category (${VALID_CATEGORIES.join(", ")})`)
+  .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 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();
+      if (!slug) { console.log(chalk.red("Slug is required.")); continue; }
+      if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
+        console.log(chalk.red("Slug must be lowercase, hyphenated (e.g. my-tool)."));
+        slug = null;
+      }
+    }
+
+    let name = options.name;
+    while (!name || name.length < 2) {
+      name = (await ask(chalk.cyan("Display name: "))).trim();
+      if (!name) console.log(chalk.red("Name is required."));
+    }
+
+    let desc = options.desc;
+    while (!desc) {
+      desc = (await ask(chalk.cyan("Short description: "))).trim();
+      if (!desc) console.log(chalk.red("Description is required."));
+    }
+
+    let category = options.category;
+    while (!category || !VALID_CATEGORIES.includes(category)) {
+      const catList = VALID_CATEGORIES.join(", ");
+      category = (await ask(chalk.cyan("Category (" + catList + "): "))).trim().toLowerCase();
+      if (category === "other") category = "Other";
+      if (!VALID_CATEGORIES.includes(category)) {
+        console.log(chalk.red("Invalid category. Choose from: " + catList));
+        category = null;
+      }
+    }
+
+    let runtime = options.runtime;
+    while (!runtime || !VALID_RUNTIMES.includes(runtime)) {
+      const rtList = VALID_RUNTIMES.join(", ");
+      runtime = (await ask(chalk.cyan("Runtime (" + rtList + "): "))).trim().toLowerCase();
+      if (!VALID_RUNTIMES.includes(runtime)) {
+        console.log(chalk.red("Invalid runtime. Choose from: " + rtList));
+        runtime = null;
+      }
+    }
+
+    rl.close();
+
+    // Generate v2.js source
+    const pascalName = slug
+      .split("-")
+      .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+      .join("");
+
+    const v2Source = `/**
+ * ${name} — ${desc}
+ * Auto-generated by nxb create
+ */
+
+export const MANIFEST = {
+  slug: "${slug}",
+  name: "${name}",
+  short_description: "${desc}",
+  icon: "🛠️",
+  category: "${category}",
+  tags: [],
+  runtime: "${runtime}",
+  pricing: "free",
+  version: "1.0.0",
+  timeout_ms: 5000,
+  input_schema: {
+    type: "object",
+    properties: {
+      input: {
+        type: "string",
+        description: "Input text to process",
+      },
+    },
+    required: ["input"],
+  },
+  output_schema: {
+    type: "object",
+    properties: {
+      result: {
+        type: "string",
+        description: "Processed output",
+      },
+    },
+  },
+};
+
+export async function coreLogic(input) {
+  // Replace with your tool's logic
+  return { result: \`Processed: \${input.input}\` };
+}
+`;
+
+    const indexSource = `import React from "react";
+import { MANIFEST } from "./v2";
+
+export default function ${pascalName}Tool({ onResult }) {
+  const [input, setInput] = React.useState("");
+  const [result, setResult] = React.useState(null);
+
+  const handleRun = async () => {
+    try {
+      const { coreLogic } = await import("./v2");
+      const output = await coreLogic({ input });
+      setResult(output);
+      if (onResult) onResult(output);
+    } catch (err) {
+      setResult({ error: err.message });
+    }
+  };
+
+  return (
+    <div className="nexusbloom-tool">
+      <h2 className="text-xl font-bold mb-4">{MANIFEST.name}</h2>
+      <p className="text-gray-600 dark:text-gray-400 mb-4">{MANIFEST.short_description}</p>
+      <textarea className="w-full p-2 border rounded" rows={4} value={input}
+        onChange={(e) => setInput(e.target.value)} placeholder="Enter input..." />
+      <button className="mt-2 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+        onClick={handleRun}>Run</button>
+      {result && <pre className="mt-4 p-3 bg-gray-100 rounded overflow-auto">{JSON.stringify(result, null, 2)}</pre>}
+    </div>
+  );
+}
+`;
+
+    // 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 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");
+
+    console.log(chalk.green(`\n  ✓ Tool "${name}" created successfully!\n`));
+    console.log(chalk.dim(`    ${v2Path}`));
+    console.log(chalk.dim(`    ${indexPath}\n`));
+    console.log(chalk.dim("  Next steps:"));
+    console.log(chalk.dim("    1. Edit v2.js to implement your tool logic"));
+    console.log(chalk.dim("    2. Run nxb run --local <slug> to test locally"));
+    console.log(chalk.dim("    3. Publish from the VS Code extension or API\n"));
+  });
+
 program.parse(process.argv);