@erdoai/cli 0.54.0 → 0.55.0

package/README.md

@@ -87,6 +87,21 @@ erdo --org 2200-brickell datasets query 2200-brickell.page-events \
   "which pages get the most views, and how many convert?"
 ```
 
+**A file dataset keeps the versions it overwrote.** Its contents are stored, and
+each write that replaces them keeps the version it replaced, so an import that
+landed bad rows over good ones has not destroyed them. List the versions, then
+read one back with `fetch` — the same SQL you would run against the live table.
+
+```bash
+erdo datasets revisions acme.leads               # live version first, then superseded
+erdo datasets fetch acme.leads --revision <id> \
+  --sql "SELECT * FROM data"                     # query those older contents
+```
+
+The history is read-only: nothing here rolls a dataset back. Restoring means
+fetching the rows out of the old revision and writing them in again through the
+normal write path.
+
 ```bash
 erdo datasets list                     # slug, type, status, class, name
 erdo datasets upload ./leads.csv       # create a dataset from a file

package/dist/index.js

@@ -713,6 +713,9 @@ var ErdoClient = class {
   // named saved filters. filter_names are additive on top of the dataset's default
   // filters — they narrow the result, never bypass a default. An unknown name is
   // rejected server-side with the available names.
+  //
+  // revision_id runs the same read against a superseded storage revision instead
+  // of the dataset's live contents — the ids come from listDatasetRevisions.
   fetchDatasetContents(slug, opts) {
     return this.request(
       "POST",
@@ -720,10 +723,21 @@ var ErdoClient = class {
       {
         sql_query: opts.sql_query,
         limit: opts.limit,
-        filter_names: opts.filter_names
+        filter_names: opts.filter_names,
+        revision_id: opts.revision_id
       }
     );
   }
+  // A file dataset's storage is versioned: every write that replaces its contents
+  // keeps the version it replaced, and this lists them — the live (primary) one
+  // first, then superseded ones newest first. superseded_at is the moment a newer
+  // version took over, and is null both on the live revision and on a stored file
+  // that was never live (an upload merged into an existing table); file_type may be
+  // absent when the stored file's type was never recorded. Read one back by passing
+  // its id as revision_id to fetchDatasetContents.
+  listDatasetRevisions(slug) {
+    return this.request("GET", `/v1/datasets/${encodeURIComponent(slug)}/revisions`);
+  }
   uploadDatasetFile(body) {
     return this.request("POST", "/v1/datasets-upload", body);
   }
@@ -2471,6 +2485,12 @@ agentCmd.command("threads").description("List your threads").action(async () =>
     fail(e);
   }
 });
+function contentBlockLabel(c) {
+  const type = c.ui_content_type || c.content_type;
+  const payload = c.content;
+  const toolName = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.name === "string" ? payload.name : void 0;
+  return toolName ? `${type}: ${toolName}` : type;
+}
 agentCmd.command("messages <threadId>").description("Show a thread's messages (role + text)").option("-v, --verbose", "print full content for non-text entries (tool calls, results, etc.) instead of a placeholder").action(async (threadId, opts) => {
   try {
     const { messages } = await new ErdoClient().getThreadMessages(threadId);
@@ -2485,10 +2505,10 @@ agentCmd.command("messages <threadId>").description("Show a thread's messages (r
         if (c.content_type === "text") {
           console.log(c.content);
         } else if (opts.verbose) {
-          console.log(`\x1B[2m[${c.content_type}]\x1B[0m`);
+          console.log(`\x1B[2m[${contentBlockLabel(c)}]\x1B[0m`);
           console.log(typeof c.content === "string" ? c.content : JSON.stringify(c.content, null, 2));
         } else {
-          console.log(`\x1B[2m[${c.content_type}]\x1B[0m`);
+          console.log(`\x1B[2m[${contentBlockLabel(c)}]\x1B[0m`);
         }
       }
     }
@@ -3458,14 +3478,57 @@ datasetsCmd.command("fetch <slug>").description(
   "opt into a saved filter by name (repeatable); additive on top of the dataset's default filters (see: erdo datasets filter list <slug>)",
   (v, acc) => acc.concat(v),
   []
-).action(async (slug, opts) => {
+).option(
+  "--revision <id>",
+  "read a superseded storage revision instead of the live table \u2014 the same SQL runs against the contents this id names, so a version that was overwritten is still queryable (see: erdo datasets revisions <slug> for the ids)"
+).action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().fetchDatasetContents(slug, {
+          sql_query: opts.sql,
+          limit: opts.limit,
+          filter_names: opts.filter.length ? opts.filter : void 0,
+          revision_id: opts.revision
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+datasetsCmd.command("revisions <slug>").description(
+  "List the stored versions of a file dataset's contents. Every write that replaces a file dataset keeps the version it replaced, so an import that overwrote good rows with bad ones has not lost them: this lists the live version first and the superseded ones newest first, and each row's id is what `datasets fetch <slug> --revision <id>` reads \u2014 the same SQL, run against those older contents. History is read-only and nothing here rolls a dataset back; restoring means fetching the rows out of the old revision and writing them in again through the normal write path."
+).option("--json", "print the raw JSON result instead of a table").action(async (slug, opts) => {
   try {
-    print(
-      await new ErdoClient().fetchDatasetContents(slug, {
-        sql_query: opts.sql,
-        limit: opts.limit,
-        filter_names: opts.filter.length ? opts.filter : void 0
-      })
+    const res = await new ErdoClient().listDatasetRevisions(slug);
+    if (opts.json) {
+      print(res);
+      return;
+    }
+    const revisions = res.revisions ?? [];
+    if (revisions.length === 0) {
+      console.log(
+        `${res.dataset_slug} has no stored revisions \u2014 versions are kept for file datasets, whose contents Erdo stores and replaces on each write. A database or warehouse dataset is queried live at its source and keeps no history here.`
+      );
+      return;
+    }
+    printAlignedTable(
+      ["id", "created", "superseded", "live", "name", "type"],
+      revisions.map((r) => [
+        r.id,
+        r.created_at,
+        r.superseded_at ?? "",
+        r.is_primary ? "yes" : "",
+        r.display_name,
+        // file_type is the specific answer (csv, xlsx) and item_type the general
+        // one; the more specific wins when it was recorded.
+        r.file_type || r.item_type
+      ])
+    );
+    console.log(
+      `
+Read one with: erdo datasets fetch ${res.dataset_slug} --revision <id> --sql "SELECT * FROM data"`
     );
   } catch (e) {
     fail(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erdoai/cli",
-  "version": "0.54.0",
+  "version": "0.55.0",
   "description": "Erdo CLI — drive datasets, pages, and evals from the terminal or CI",
   "type": "module",
   "bin": {