@bitpub/cli 2.0.4 → 2.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitpub/cli",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "BitPub CLI — local-first shared memory for AI agents. Six daily verbs (save/load/list/find/sync/delete), zero-config private namespace, encrypted client-side.",
   "bin": {
     "bitpub": "./bin/bitpub.js"

package/src/commands/load.js

@@ -12,7 +12,23 @@
  *      "did you mean…" search across the user's full private namespace.
  *      With exactly one match, auto-load and print a transparency note to
  *      stderr saying where it actually came from. With multiple, list
- *      them and exit. With zero, print an actionable not-found error.
+ *      them and exit. With zero, fall through.
+ *   4. If still empty, check whether the address is a *folder* — i.e. it
+ *      has descendants under it — and if so, auto-load them in one shot.
+ *      Capped at `--limit` (default 20) so a stray `load` on a deep
+ *      prefix can't blow up output. A stderr breadcrumb tells the caller
+ *      what we did and (if truncated) how to get the rest. This catches
+ *      the common mistake of `load`-ing a prefix like
+ *      `bitpub://group:foo/Agents/x` when the real slices live at
+ *      `.../Agents/x/README`, `.../script`, etc. A single wildcard
+ *      remote pull is attempted on cache miss so this works without a
+ *      separate `sync` step.
+ *   5. Otherwise: actionable not-found error.
+ *
+ * Multi-slice raw output (from explicit wildcards or from the folder
+ * auto-load in step 4) is prefixed with a `=== <address> ===` header
+ * per slice so the caller can tell which content came from which slice.
+ * Single-slice loads keep their clean stdout-only output (no header).
  *
  * The DWIM step exists because agents holding a fully-qualified URL will
  * sometimes (incorrectly) strip it down to a short name before calling
@@ -33,6 +49,11 @@ module.exports = function registerLoad(program) {
     .description('Load a slice by short name (this project) or full bitpub:// address')
     .option('--no-fetch', 'Do not fetch from cloud if missing locally')
     .option('--format <raw|json>', 'Output format', 'raw')
+    .option(
+      '--limit <n>',
+      'Max slices to return when the address resolves to a folder (default 20)',
+      '20'
+    )
     .action(async (name, opts) => {
       const config = requireConfig();
       const wasShortName = !name.startsWith('bitpub://') && !isAliasRef(name);
@@ -84,7 +105,58 @@ module.exports = function registerLoad(program) {
           console.error(`  bitpub load <one-of-the-addresses-above>`);
           process.exit(1);
         }
-        // Zero candidates: fall through to the not-found block below.
+        // Zero candidates: fall through to the folder/not-found block below.
+      }
+
+      // Folder check: the exact address didn't resolve to a slice, but it
+      // may be a *prefix* with children under it (e.g. user typed
+      // `bitpub://group:foo/Agents/x` when the real slices live at
+      // `.../Agents/x/README`, `.../script`, etc). Auto-load up to
+      // --limit children so the caller doesn't have to round-trip.
+      // Skip if the user already passed a wildcard — querySlices already
+      // handles that path and a 0-result wildcard is a real not-found.
+      if (slices.length === 0 && !hcu.includes('*')) {
+        const cleanHcu = hcu.replace(/\/$/, '');
+        const folderPattern = cleanHcu + '/**';
+        // Cap raised slightly above the user-facing default so a folder
+        // with N=21 items doesn't get silently truncated below the cap
+        // the user asked for; we still slice() to `limit` for display.
+        const limit = Math.max(1, parseInt(opts.limit, 10) || 20);
+        let descendants = querySlices(folderPattern);
+
+        if (descendants.length === 0 && opts.fetch !== false) {
+          try {
+            const api = createApiClient(config);
+            const remote = await api.pull(folderPattern, Math.max(limit, 50));
+            decryptSlices(remote, config.api_key);
+            remote.forEach(upsertSlice);
+            descendants = querySlices(folderPattern);
+          } catch {
+            // Non-fatal — if there's nothing remote either, we'll fall
+            // through to the regular not-found message below.
+          }
+        }
+
+        if (descendants.length > 0) {
+          const total = descendants.length;
+          const truncated = total > limit;
+          slices = descendants.slice(0, limit);
+
+          // Transparency breadcrumb → stderr (keeps stdout pure for pipes).
+          // The agent gets a single useful message that tells it (a) what
+          // we did and (b) how to escape the cap if 20 wasn't enough.
+          if (truncated) {
+            console.error(
+              `(loaded ${slices.length} of ${total} descendants of "${cleanHcu}" — ` +
+              `it's a folder, not a slice; pass --limit ${total} for all of them)`
+            );
+          } else {
+            console.error(
+              `(loaded ${slices.length} descendant${slices.length === 1 ? '' : 's'} of ` +
+              `"${cleanHcu}" — it's a folder, not a slice)`
+            );
+          }
+        }
       }
 
       if (slices.length === 0) {
@@ -113,10 +185,15 @@ module.exports = function registerLoad(program) {
         return;
       }
 
+      // Multi-slice raw output (wildcard input or folder auto-load) gets
+      // a `=== <address> ===` header per slice so the caller can attribute
+      // each chunk. Single-slice loads keep their clean header-free output.
       const parts = slices.map(s => {
         const payload = JSON.parse(s.payload);
-        return payload.content ?? '';
+        const content = payload.content ?? '';
+        if (slices.length === 1) return content;
+        return `=== ${s.hcu} ===\n${content}`;
       });
-      console.log(parts.join('\n---\n'));
+      console.log(parts.join(slices.length === 1 ? '' : '\n\n'));
     });
 };