@nexusbloom/cli 0.2.6 → 0.2.8

package/package.json

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

package/src/index.js

@@ -101,8 +101,12 @@ program
   .option("-s, --search <query>", "Search tools by name or description")
   .action(async (opts, cmd) => {
     const jsonMode = cmd.parent.opts().json || opts.json;
-    const tools = await fetchToolsWithFallback();
-    if (!tools || tools.length === 0) {
+    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;
@@ -120,7 +124,7 @@ program
     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]") : "";
+      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}`);
     });
     console.log();
@@ -286,20 +290,40 @@ async function executeLocal(slug, input, jsonMode) {
   ensureCacheDir();
   const cacheFile = path.join(CACHE_DIR, `${slug}.json`);
 
-  // Try loading from cache first
+  // Try loading from local filesystem first (fastest, most up-to-date)
   let 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, refetch
+  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");
     }
   }
 
-  // Fetch from API if not cached
+  // 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}...`));
 
@@ -443,6 +467,18 @@ program
       } catch { /* fallback failed */ }
     }
 
+    // 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.`));
@@ -976,6 +1012,72 @@ async function fetchToolsWithFallback() {
 
 // ─── 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 = [];