@thingd/cli 0.54.0 → 0.56.0

package/dist/interactive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactive.d.ts","sourceRoot":"","sources":["../src/interactive.ts"],"names":[],"mappings":"AAyvEA,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CA0FvD"}
+{"version":3,"file":"interactive.d.ts","sourceRoot":"","sources":["../src/interactive.ts"],"names":[],"mappings":"AAu8FA,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CA0FvD"}

package/dist/interactive.js

@@ -69,6 +69,7 @@ let collections = [];
 let streams = [];
 let queues = [];
 let objectsByCollection = new Map();
+const collectionOptions = new Map();
 const expandedSet = new Set(["cat:collections", "cat:streams", "cat:queues"]);
 let cursorIndex = 0;
 let maintenanceCursor = 0;
@@ -80,6 +81,8 @@ let totalActiveJobsCount = 0;
 let totalDeadJobsCount = 0;
 let totalLinksCount = 0;
 let cloudError = null;
+const eventsByStream = new Map();
+const jobsByQueue = new Map();
 let objectsHistory = [];
 let eventsHistory = [];
 let activeJobsHistory = [];
@@ -242,7 +245,21 @@ async function fetchResourcesFallback() {
     objectsByCollection.clear();
     await Promise.all(collections.map(async (col) => {
         try {
-            const list = await db.listObjects(col);
+            const opts = collectionOptions.get(col);
+            const listOpts = {};
+            if (opts?.sortBy) {
+                listOpts.sortBy = { field: opts.sortBy, direction: opts.sortDir ?? "asc" };
+            }
+            if (opts?.limit) {
+                listOpts.limit = opts.limit;
+            }
+            if (opts?.offset) {
+                listOpts.offset = opts.offset;
+            }
+            if (opts?.filter) {
+                listOpts.filter = opts.filter;
+            }
+            const list = await db.listObjects(col, Object.keys(listOpts).length > 0 ? listOpts : undefined);
             objectsByCollection.set(col, list.map((o) => o.id));
         }
         catch {
@@ -287,13 +304,50 @@ async function fetchResources() {
     objectsByCollection.clear();
     for (const col of collections) {
         try {
-            const list = await db.listObjects(col);
+            const opts = collectionOptions.get(col);
+            const listOpts = {};
+            if (opts?.sortBy) {
+                listOpts.sortBy = { field: opts.sortBy, direction: opts.sortDir ?? "asc" };
+            }
+            if (opts?.limit) {
+                listOpts.limit = opts.limit;
+            }
+            if (opts?.offset) {
+                listOpts.offset = opts.offset;
+            }
+            if (opts?.filter) {
+                listOpts.filter = opts.filter;
+            }
+            const list = await db.listObjects(col, Object.keys(listOpts).length > 0 ? listOpts : undefined);
             objectsByCollection.set(col, list.map((o) => o.id));
         }
         catch {
             objectsByCollection.set(col, []);
         }
     }
+    // Populate events per stream
+    eventsByStream.clear();
+    await Promise.all(streams.map(async (s) => {
+        try {
+            const evts = await db.events.list(s, { limit: 20 });
+            eventsByStream.set(s, evts);
+        }
+        catch {
+            eventsByStream.set(s, []);
+        }
+    }));
+    // Populate jobs per queue
+    jobsByQueue.clear();
+    await Promise.all(queues.map(async (q) => {
+        try {
+            const active = await db.queue(q).list();
+            const dead = await db.queue(q).dead();
+            jobsByQueue.set(q, { active, dead });
+        }
+        catch {
+            jobsByQueue.set(q, { active: [], dead: [] });
+        }
+    }));
     // Calculate Deltas for Operations Throughput Rates
     const prevObjects = objectsHistory.length > 0
         ? (objectsHistory[objectsHistory.length - 1] ?? totalObjects)
@@ -510,15 +564,40 @@ function buildTree() {
             });
         }
         for (const stream of streams) {
+            const sOpen = expandedSet.has(`stream:${stream}`);
             nodes.push({
                 id: `stream:${stream}`,
                 parentId: "cat:streams",
                 type: "stream",
-                label: `${pc.green("●")} ${pc.green(stream)}`,
+                label: `${sOpen ? pc.cyan("▾") : pc.dim("▸")} ${pc.green(stream)}`,
                 depth: 1,
-                expandable: false,
+                expandable: true,
                 ref: { name: stream },
             });
+            if (sOpen) {
+                const evts = eventsByStream.get(stream) ?? [];
+                if (evts.length === 0) {
+                    nodes.push({
+                        id: `empty:evt:${stream}`,
+                        parentId: `stream:${stream}`,
+                        type: "status",
+                        label: pc.dim("(no events)"),
+                        depth: 2,
+                        expandable: false,
+                    });
+                }
+                for (const evt of evts) {
+                    nodes.push({
+                        id: `evt:${stream}:${evt.id}`,
+                        parentId: `stream:${stream}`,
+                        type: "event",
+                        label: `${pc.dim("·")} ${pc.dim(evt.type || "unknown")}`,
+                        depth: 2,
+                        expandable: false,
+                        ref: { stream: stream, eventId: evt.id, eventData: evt },
+                    });
+                }
+            }
         }
     }
     // Queues
@@ -541,15 +620,87 @@ function buildTree() {
             });
         }
         for (const q of queues) {
+            const qOpen = expandedSet.has(`queue:${q}`);
             nodes.push({
                 id: `queue:${q}`,
                 parentId: "cat:queues",
                 type: "queue",
-                label: `${pc.magenta("◇")} ${pc.magenta(q)}`,
+                label: `${qOpen ? pc.cyan("▾") : pc.dim("▸")} ${pc.magenta(q)}`,
                 depth: 1,
-                expandable: false,
+                expandable: true,
                 ref: { name: q },
             });
+            if (qOpen) {
+                const jobData = jobsByQueue.get(q);
+                const activeJobs = jobData?.active ?? [];
+                const deadJobs = jobData?.dead ?? [];
+                // Active jobs subcategory
+                const activeOpen = expandedSet.has(`queue:${q}:active`);
+                nodes.push({
+                    id: `queue:${q}:active`,
+                    parentId: `queue:${q}`,
+                    type: "category",
+                    label: `${activeOpen ? pc.cyan("▾") : pc.dim("▸")} ${pc.bold("Active")}  ${pc.dim(`(${activeJobs.length})`)}`,
+                    depth: 2,
+                    expandable: true,
+                });
+                if (activeOpen) {
+                    if (activeJobs.length === 0) {
+                        nodes.push({
+                            id: `empty:active:${q}`,
+                            parentId: `queue:${q}:active`,
+                            type: "status",
+                            label: pc.dim("(no active jobs)"),
+                            depth: 3,
+                            expandable: false,
+                        });
+                    }
+                    for (const job of activeJobs) {
+                        nodes.push({
+                            id: `job:${q}:active:${job.id}`,
+                            parentId: `queue:${q}:active`,
+                            type: "job",
+                            label: `${pc.cyan("●")} ${pc.dim(job.id.slice(0, 12))}`,
+                            depth: 3,
+                            expandable: false,
+                            ref: { queue: q, jobId: job.id, status: "active", jobData: job },
+                        });
+                    }
+                }
+                // Dead jobs subcategory
+                const deadOpen = expandedSet.has(`queue:${q}:dead`);
+                nodes.push({
+                    id: `queue:${q}:dead`,
+                    parentId: `queue:${q}`,
+                    type: "category",
+                    label: `${deadOpen ? pc.cyan("▾") : pc.dim("▸")} ${pc.bold("Dead")}  ${pc.dim(`(${deadJobs.length})`)}`,
+                    depth: 2,
+                    expandable: true,
+                });
+                if (deadOpen) {
+                    if (deadJobs.length === 0) {
+                        nodes.push({
+                            id: `empty:dead:${q}`,
+                            parentId: `queue:${q}:dead`,
+                            type: "status",
+                            label: pc.dim("(no dead jobs)"),
+                            depth: 3,
+                            expandable: false,
+                        });
+                    }
+                    for (const job of deadJobs) {
+                        nodes.push({
+                            id: `job:${q}:dead:${job.id}`,
+                            parentId: `queue:${q}:dead`,
+                            type: "job",
+                            label: `${pc.red("○")} ${pc.dim(job.id.slice(0, 12))}`,
+                            depth: 3,
+                            expandable: false,
+                            ref: { queue: q, jobId: job.id, status: "dead", jobData: job },
+                        });
+                    }
+                }
+            }
         }
     }
     // Links
@@ -636,6 +787,27 @@ async function loadContent(node) {
             const ref = node.ref;
             const objs = objectsByCollection.get(ref.name) ?? [];
             let res = `${pc.bold(ref.name)} ${pc.dim(`(${objs.length} objects)`)}\n\n`;
+            // Schema info
+            try {
+                const schemas = await db.schema(ref.name);
+                if (schemas.length > 0) {
+                    const fields = schemas[0]?.fields ?? [];
+                    if (fields.length > 0) {
+                        res += `${pc.bold("Fields")}\n`;
+                        for (const f of fields) {
+                            const icon = f.nullable ? pc.dim("⊙") : pc.cyan("◎");
+                            const sample = f.sampleValues.length > 0
+                                ? pc.dim(` e.g. ${String(f.sampleValues[0]).slice(0, 20)}`)
+                                : "";
+                            res += ` ${icon} ${f.name}: ${f.type}${sample}\n`;
+                        }
+                        res += "\n";
+                    }
+                }
+            }
+            catch {
+                // Schema not available for this store
+            }
             if (objs.length === 0) {
                 res += pc.dim("No objects in this collection.");
             }
@@ -647,43 +819,59 @@ async function loadContent(node) {
         }
         else if (node.type === "stream" && node.ref) {
             const ref = node.ref;
-            const events = await db.events.list(ref.name);
-            let res = `${pc.bold(ref.name)} ${pc.dim(`(${events.length} events)`)}\n\n`;
-            if (events.length === 0) {
-                res += pc.dim("No events in this stream.");
+            const evts = eventsByStream.get(ref.name) ?? [];
+            let res = `${pc.bold(ref.name)} ${pc.dim(`(${evts.length} events shown)`)}\n\n`;
+            res += pc.dim("Expand to browse individual events, or press [c] to append.\n");
+            content = res;
+        }
+        else if (node.type === "event" && node.ref) {
+            const ref = node.ref;
+            const evt = ref.eventData;
+            let res = `${pc.bold(evt.type || "unknown")} ${pc.dim(evt.id)}\n`;
+            res += ` ${pc.dim("Stream:")} ${pc.green(ref.stream)}\n`;
+            res += ` ${pc.dim("Created:")} ${pc.dim(evt.createdAt || "—")}\n\n`;
+            const display = { ...evt };
+            for (const k of ["id", "stream", "sequence", "createdAt", "idempotencyKey"]) {
+                delete display[k];
+            }
+            if (Object.keys(display).length > 0) {
+                res += highlightJson(display);
             }
             else {
-                const lines = events.map((e) => {
-                    const ts = e.createdAt ? pc.dim(String(e.createdAt)) : "";
-                    const type = pc.magenta(e.type || "unknown");
-                    return ` ${ts} ${type}`;
-                });
-                res += lines.join("\n");
+                res += pc.dim("No payload.");
             }
             content = res;
         }
         else if (node.type === "queue" && node.ref) {
             const ref = node.ref;
-            const queue = db.queue(ref.name);
-            const [active, dead] = await Promise.all([queue.list(), queue.dead()]);
+            const jobData = jobsByQueue.get(ref.name);
+            const active = jobData?.active ?? [];
+            const dead = jobData?.dead ?? [];
             let res = `${pc.bold(ref.name)}\n\n`;
             res += `${pc.cyan("Active")} ${pc.dim(`(${active.length})`)}\n`;
-            if (active.length === 0) {
-                res += pc.dim(" No jobs\n");
+            res += `${pc.red("Dead")} ${pc.dim(`(${dead.length})`)}\n\n`;
+            res += pc.dim("Expand Active or Dead to browse jobs, [c] to push new job.");
+            content = res;
+        }
+        else if (node.type === "job" && node.ref) {
+            const ref = node.ref;
+            const job = ref.jobData;
+            let res = `${pc.bold(job.id)}  ${pc.yellow(job.status || ref.status)}\n`;
+            res += ` ${pc.dim("Queue:")} ${pc.magenta(ref.queue)}\n`;
+            res += ` ${pc.dim("Attempts:")} ${job.attempts}/${job.maxAttempts}\n`;
+            res += ` ${pc.dim("Created:")} ${pc.dim(job.createdAt || "—")}\n`;
+            if (job.lastError) {
+                res += ` ${pc.dim("Error:")} ${pc.red(job.lastError)}\n`;
+            }
+            res += "\n";
+            if (job.payload && Object.keys(job.payload).length > 0) {
+                res += highlightJson(job.payload);
             }
             else {
-                for (const j of active) {
-                    res += ` ${pc.cyan("●")} ${j.id} ${pc.yellow(j.status)} ${pc.dim(`${j.attempts}/${j.maxAttempts}`)}\n`;
-                }
+                res += pc.dim("No payload.");
             }
-            res += `${pc.red("Dead")} ${pc.dim(`(${dead.length})`)}\n`;
-            if (dead.length === 0) {
-                res += pc.dim(" No dead jobs\n");
-            }
-            else {
-                for (const j of dead) {
-                    res += ` ${pc.red("○")} ${j.id} ${pc.dim(`${j.attempts}/${j.maxAttempts}`)}\n`;
-                }
+            if (ref.status === "dead") {
+                res += `\n\n${pc.dim("[e] Retry (ack)  [d] Nack (remove from dead letter)")}`;
             }
             content = res;
         }
@@ -903,7 +1091,7 @@ function draw() {
         help = ` ${pc.dim("↑↓")} nav  ${pc.dim("enter")} connect  ${pc.dim("q")} quit `;
     }
     else {
-        help = ` ${pc.dim("↑↓")} nav  ${pc.dim("←→")} toggle  ${pc.dim("c")} create  ${pc.dim("e")} edit  ${pc.dim("d")} delete  ${pc.dim("/")} search  ${pc.dim("n")} neighbors  ${pc.dim("i")} info  ${pc.dim("r")} refresh  ${pc.dim("s")} switch  ${pc.dim("l")} logout  ${pc.dim("q")} quit `;
+        help = ` ${pc.dim("↑↓")} nav  ${pc.dim("←→")} toggle  ${pc.dim("c")} create  ${pc.dim("e")} edit  ${pc.dim("d")} delete  ${pc.dim("/")} search  ${pc.dim("n")} neighbors  ${pc.dim("N")} nlq  ${pc.dim("a")} agg  ${pc.dim("t")} ts  ${pc.dim("o")} options  ${pc.dim("b")} batch  ${pc.dim("i")} info  ${pc.dim("r")} refresh  ${pc.dim("s")} switch  ${pc.dim("l")} logout  ${pc.dim("q")} quit `;
     }
     buf += `${pc.dim("─".repeat(W))}\n`;
     buf += padToWidth(help, W);
@@ -1220,6 +1408,41 @@ async function handleEdit(selected) {
             }
         });
     }
+    else if (selected.type === "job" && selected.ref) {
+        const ref = selected.ref;
+        if (ref.status === "dead") {
+            openForm(`Retry Dead Job: ${ref.jobId.slice(0, 12)}`, [
+                {
+                    id: "action",
+                    label: "Action",
+                    value: "ack",
+                    options: ["ack", "nack"],
+                },
+                {
+                    id: "error",
+                    label: "Error message (for nack)",
+                    placeholder: "Optional error",
+                },
+            ], async (vals) => {
+                const action = vals.action || "";
+                if (action === "ack") {
+                    await db.queue(ref.queue).ack(ref.jobId);
+                }
+                else if (action === "nack") {
+                    await db.queue(ref.queue).nack(ref.jobId, { error: vals.error || "Rejected" });
+                }
+                else {
+                    throw new Error("Action must be 'ack' or 'nack'.");
+                }
+            });
+        }
+        else {
+            // Active job — nack to fail it back to ready
+            openForm(`Nack Job: ${ref.jobId.slice(0, 12)}`, [{ id: "error", label: "Error message", placeholder: "Optional" }], async (vals) => {
+                await db.queue(ref.queue).nack(ref.jobId, { error: vals.error || "Nacked" });
+            });
+        }
+    }
     else {
         openForm("Edit Not Supported", [{ id: "msg", label: "Error", value: "Editing is only available for Objects and Queues." }], async () => { });
     }
@@ -1284,6 +1507,33 @@ async function handleDelete(selected) {
             }
         });
     }
+    else if (selected.type === "job" && selected.ref) {
+        const ref = selected.ref;
+        if (ref.status === "dead") {
+            openForm(`Remove Dead Job: ${ref.jobId.slice(0, 12)}`, [
+                {
+                    id: "action",
+                    label: "Action",
+                    value: "nack",
+                    options: ["ack", "nack"],
+                },
+                { id: "confirm", label: 'Type "yes" to confirm', placeholder: "yes" },
+            ], async (vals) => {
+                if ((vals.confirm || "").toLowerCase() !== "yes") {
+                    throw new Error("Canceled");
+                }
+                if (vals.action === "ack") {
+                    await db.queue(ref.queue).ack(ref.jobId);
+                }
+                else {
+                    await db.queue(ref.queue).nack(ref.jobId, { error: "Removed from dead letter" });
+                }
+            });
+        }
+        else {
+            openForm("Delete Not For Active Jobs", [{ id: "msg", label: "Info", value: "Use [e] to nack an active job back to ready state." }], async () => { });
+        }
+    }
     else {
         openForm("Delete Not Supported", [
             {
@@ -1461,6 +1711,316 @@ async function handleNeighbors(selected) {
         draw();
     });
 }
+async function handleAggregate(selected) {
+    const defaultCol = selected?.type === "collection"
+        ? (selected.ref?.name ?? "")
+        : selected?.type === "object"
+            ? (selected.ref?.collection ?? "")
+            : "";
+    openForm("Aggregate", [
+        {
+            id: "function",
+            label: "Function",
+            value: "count",
+            options: ["count", "sum", "avg", "min", "max"],
+        },
+        {
+            id: "collection",
+            label: "Collection",
+            value: defaultCol,
+            options: collections,
+            allowCustom: true,
+        },
+        { id: "field", label: "Field (for sum/avg/min/max)", placeholder: "field name" },
+        { id: "groupBy", label: "Group By (optional field)", placeholder: "field name" },
+        { id: "filter", label: "Filter (optional JSON)", placeholder: '{"status":"active"}' },
+    ], async (vals) => {
+        const func = vals.function || "count";
+        const collection = (vals.collection || "").trim();
+        if (!collection) {
+            throw new Error("Collection is required.");
+        }
+        const field = (vals.field || "").trim() || undefined;
+        const groupBy = (vals.groupBy || "").trim() || undefined;
+        const filter = vals.filter?.trim() ? JSON.parse(vals.filter.trim()) : undefined;
+        const options = { groupBy, filter };
+        const a = db.aggregate;
+        const result = func === "count"
+            ? await a.count(collection, options)
+            : func === "sum"
+                ? await a.sum(collection, field, options)
+                : func === "avg"
+                    ? await a.avg(collection, field, options)
+                    : func === "min"
+                        ? await a.min(collection, field, options)
+                        : await a.max(collection, field, options);
+        const lines = [
+            ` ${pc.bold("Aggregate")}  ${pc.cyan(func)} ${pc.dim(`on ${collection}`)}`,
+            "",
+            ` ${pc.dim("Total:")} ${pc.bold(String(result.total))}`,
+            "",
+        ];
+        if (result.groups && result.groups.length > 0) {
+            lines.push(` ${pc.bold("Groups")}`);
+            const maxVal = Math.max(...result.groups.map((g) => g.value));
+            for (const g of result.groups) {
+                const barLen = Math.max(1, Math.round((g.value / maxVal) * 20));
+                const bar = pc.cyan("█".repeat(barLen));
+                lines.push(` ${g.key}: ${bar} ${pc.dim(String(g.value))}`);
+            }
+        }
+        viewerLines = lines;
+        loadedItemId = "aggregate_result";
+        draw();
+    });
+}
+async function handleTimeseries(selected) {
+    const defaultCol = selected?.type === "collection"
+        ? (selected.ref?.name ?? "")
+        : selected?.type === "object"
+            ? (selected.ref?.collection ?? "")
+            : "";
+    openForm("Time Series", [
+        {
+            id: "function",
+            label: "Function",
+            value: "count",
+            options: ["count", "sum", "avg", "min", "max"],
+        },
+        {
+            id: "collection",
+            label: "Collection",
+            value: defaultCol,
+            options: collections,
+            allowCustom: true,
+        },
+        { id: "field", label: "Field (optional)", placeholder: "field name" },
+        {
+            id: "bucket",
+            label: "Bucket",
+            value: "day",
+            options: ["hour", "day", "week", "month"],
+        },
+        { id: "from", label: "From (ISO date, optional)", placeholder: "2024-01-01" },
+        { id: "to", label: "To (ISO date, optional)", placeholder: "2024-12-31" },
+        { id: "filter", label: "Filter (optional JSON)", placeholder: '{"status":"active"}' },
+    ], async (vals) => {
+        const func = vals.function || "count";
+        const collection = (vals.collection || "").trim();
+        if (!collection) {
+            throw new Error("Collection is required.");
+        }
+        const field = (vals.field || "").trim() || undefined;
+        const bucket = (vals.bucket || "day");
+        const from = (vals.from || "").trim() || undefined;
+        const to = (vals.to || "").trim() || undefined;
+        const filter = vals.filter?.trim() ? JSON.parse(vals.filter.trim()) : undefined;
+        const result = await db.timeseries(collection, {
+            function: func,
+            field,
+            bucket,
+            from,
+            to,
+            filter,
+        });
+        const lines = [
+            ` ${pc.bold("Time Series")}  ${pc.cyan(func)} ${pc.dim(`on ${collection}, ${bucket}ly`)}`,
+            "",
+        ];
+        if (result.buckets.length === 0) {
+            lines.push(pc.dim("No data for the selected range."));
+        }
+        else {
+            const maxVal = Math.max(...result.buckets.map((b) => b.value));
+            for (const b of result.buckets) {
+                const barLen = Math.max(1, Math.round((b.value / maxVal) * 20));
+                const bar = pc.green("█".repeat(barLen));
+                lines.push(` ${b.label}: ${bar} ${pc.dim(String(b.value))}`);
+            }
+        }
+        viewerLines = lines;
+        loadedItemId = "timeseries_result";
+        draw();
+    });
+}
+async function handleNlq(selected) {
+    const defaultCol = selected?.type === "collection"
+        ? (selected.ref?.name ?? "")
+        : selected?.type === "object"
+            ? (selected.ref?.collection ?? "")
+            : "";
+    openForm("Natural Language Query", [
+        { id: "question", label: "Question", placeholder: "How many active users?" },
+        {
+            id: "collection",
+            label: "Collection (optional)",
+            value: defaultCol,
+            options: collections,
+            allowCustom: true,
+        },
+    ], async (vals) => {
+        const question = (vals.question || "").trim();
+        if (!question) {
+            throw new Error("Question is required.");
+        }
+        const collection = (vals.collection || "").trim() || undefined;
+        const result = await db.nlq.query(question, {
+            collection,
+        });
+        const intent = result.intent;
+        const lines = [
+            ` ${pc.bold("NLQ Result")}`,
+            ` ${pc.dim(`Question: ${question}`)}`,
+            "",
+            ` ${result.answer}`,
+            "",
+        ];
+        if (intent) {
+            lines.push(` ${pc.dim("Interpreted as:")} ${intent.action} ${pc.dim("on")} ${pc.cyan(intent.collection)}`);
+            if (intent.function) {
+                lines.push(` ${pc.dim("Function:")} ${intent.function}`);
+            }
+            if (intent.field) {
+                lines.push(` ${pc.dim("Field:")} ${intent.field}`);
+            }
+            if (intent.query) {
+                lines.push(` ${pc.dim("Query:")} ${intent.query}`);
+            }
+        }
+        if (result.data !== undefined && result.data !== null) {
+            lines.push("", highlightJson(result.data));
+        }
+        viewerLines = lines;
+        loadedItemId = "nlq_result";
+        draw();
+    });
+}
+async function handleCollectionOptions(selected) {
+    const colName = selected?.type === "collection"
+        ? (selected.ref?.name ?? "")
+        : selected?.type === "object"
+            ? (selected.ref?.collection ?? "")
+            : "";
+    if (!colName) {
+        viewerLines = [pc.yellow("Select a collection first, then press [o] to set listing options.")];
+        loadedItemId = "options_info";
+        draw();
+        return;
+    }
+    const current = collectionOptions.get(colName) ?? {};
+    openForm(`Listing Options: ${colName}`, [
+        {
+            id: "sortBy",
+            label: "Sort By",
+            value: current.sortBy ?? "",
+            options: ["", "id", "created_at", "updated_at", "version"],
+            allowCustom: true,
+        },
+        {
+            id: "sortDir",
+            label: "Sort Direction",
+            value: current.sortDir ?? "asc",
+            options: ["asc", "desc"],
+        },
+        { id: "limit", label: "Limit", value: String(current.limit ?? ""), placeholder: "50" },
+        { id: "offset", label: "Offset", value: String(current.offset ?? ""), placeholder: "0" },
+        {
+            id: "filter",
+            label: "Filter (JSON)",
+            value: current.filter ? JSON.stringify(current.filter) : "",
+            placeholder: '{"status":"active"}',
+        },
+    ], async (vals) => {
+        const opts = {};
+        if (vals.sortBy) {
+            opts.sortBy = vals.sortBy;
+            opts.sortDir = vals.sortDir || "asc";
+        }
+        if (vals.limit) {
+            opts.limit = parseInt(vals.limit, 10) || 50;
+        }
+        if (vals.offset) {
+            opts.offset = parseInt(vals.offset, 10) || 0;
+        }
+        if (vals.filter?.trim()) {
+            opts.filter = JSON.parse(vals.filter.trim());
+        }
+        if (Object.keys(opts).length > 0) {
+            collectionOptions.set(colName, opts);
+        }
+        else {
+            collectionOptions.delete(colName);
+        }
+        await fetchResources();
+        const tree = buildTree();
+        const idx = tree.findIndex((n) => n.id === `col:${colName}`);
+        if (idx !== -1) {
+            cursorIndex = idx;
+        }
+        const n = tree[cursorIndex];
+        if (n) {
+            scheduleLoad(n);
+        }
+    });
+}
+async function handleBatchOps(selected) {
+    const colName = selected?.type === "collection"
+        ? (selected.ref?.name ?? "")
+        : selected?.type === "object"
+            ? (selected.ref?.collection ?? "")
+            : "";
+    if (!colName) {
+        viewerLines = [pc.yellow("Select a collection first, then press [b] for batch operations.")];
+        loadedItemId = "batch_info";
+        draw();
+        return;
+    }
+    openForm(`Batch Ops: ${colName}`, [
+        {
+            id: "action",
+            label: "Action",
+            value: "put",
+            options: ["put", "delete"],
+        },
+        {
+            id: "input",
+            label: "JSON File Path or IDs (comma-sep for delete)",
+            placeholder: "/path/to/file.json or id1,id2,id3",
+        },
+    ], async (vals) => {
+        const action = vals.action || "";
+        const input = (vals.input || "").trim();
+        if (!input) {
+            throw new Error("Input is required.");
+        }
+        if (action === "put") {
+            const data = JSON.parse(await fs.promises.readFile(input, "utf-8"));
+            const objects = Array.isArray(data) ? data : (data.objects ?? [data]);
+            const result = await db.putBatch(colName, objects);
+            viewerLines = [
+                ` ${pc.bold("Batch Put Complete")}`,
+                ` ${pc.dim(`Collection: ${colName}`)}`,
+                ` ${pc.dim(`Objects: ${result.length}`)}`,
+            ];
+            loadedItemId = "batch_result";
+            draw();
+        }
+        else if (action === "delete") {
+            const ids = input
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+            const count = await db.deleteBatch(colName, ids);
+            viewerLines = [
+                ` ${pc.bold("Batch Delete Complete")}`,
+                ` ${pc.dim(`Collection: ${colName}`)}`,
+                ` ${pc.dim(`Deleted: ${count} objects`)}`,
+            ];
+            loadedItemId = "batch_result";
+            draw();
+        }
+    });
+}
 async function handleMaintenance() {
     // Cycle through maintenance operations with each press of 'm'
     const operations = ["health", "checkpoint", "backup"];
@@ -1756,9 +2316,24 @@ function setupKeypress() {
             else if (str === "i" || str === "I") {
                 await handleInfo();
             }
-            else if (str === "n" || str === "N") {
+            else if (str === "n") {
                 await handleNeighbors(tree[cursorIndex]);
             }
+            else if (str === "N") {
+                await handleNlq(tree[cursorIndex]);
+            }
+            else if (str === "a" || str === "A") {
+                await handleAggregate(tree[cursorIndex]);
+            }
+            else if (str === "t" || str === "T") {
+                await handleTimeseries(tree[cursorIndex]);
+            }
+            else if (str === "o" || str === "O") {
+                await handleCollectionOptions(tree[cursorIndex]);
+            }
+            else if (str === "b" || str === "B") {
+                await handleBatchOps(tree[cursorIndex]);
+            }
             else if (str === "m" || str === "M") {
                 await handleMaintenance();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thingd/cli",
-  "version": "0.54.0",
+  "version": "0.56.0",
   "description": "CLI, Interactive TUI Dashboard, and MCP server for thingd — a fast object-first data engine for applications and AI agents.",
   "type": "module",
   "homepage": "https://engine.thingd.cloud",
@@ -45,7 +45,7 @@
     "cli-table3": "^0.6.5",
     "picocolors": "^1.1.1",
     "zod": "^4.4.3",
-    "@thingd/sdk": "0.54.0"
+    "@thingd/sdk": "0.56.0"
   },
   "engines": {
     "node": ">=24.0.0"