@wafflebase/cli 0.6.0 → 0.6.1

package/dist/bin.js

@@ -263,6 +263,22 @@ var HttpClient = class {
       deck
     );
   }
+  // Notes content — same endpoint as docs/slides; the backend dispatches
+  // on the persisted document type, picking the note writer for `'note'`.
+  // A note's content is a single markdown string (`{ content }`).
+  getNoteContent(docId) {
+    return this.request(
+      "GET",
+      `/documents/${docId}/content`
+    );
+  }
+  putNoteContent(docId, note) {
+    return this.request(
+      "PUT",
+      `/documents/${docId}/content`,
+      note
+    );
+  }
   // Tabs
   listTabs(docId) {
     return this.request("GET", `/documents/${docId}/tabs`);
@@ -316,7 +332,7 @@ var HttpClient = class {
 };
 
 // package.json
-var version = "0.6.0";
+var version = "0.6.1";
 
 // src/commands/root.ts
 function getGlobalOpts(cmd) {
@@ -99302,6 +99318,366 @@ function registerSlidesImportCommand(slides) {
   });
 }
 
+// src/commands/notes.ts
+import { extname as extname8 } from "path";
+
+// src/notes/import.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { basename as basename3, extname as extname7 } from "path";
+import { createInterface as createInterface3 } from "readline";
+var defaultNotesImportIO = {
+  stdout: (line) => {
+    process.stdout.write(line);
+    if (!line.endsWith("\n")) process.stdout.write("\n");
+  },
+  stderr: (line) => {
+    console.error(line);
+  },
+  readText: async (path) => {
+    if (path === "-") {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (c) => chunks.push(c));
+        process.stdin.on(
+          "end",
+          () => resolve(Buffer.concat(chunks).toString("utf-8"))
+        );
+        process.stdin.on("error", reject);
+      });
+    }
+    return readFileSync6(path, "utf-8");
+  },
+  confirm: (prompt) => {
+    return new Promise((resolve) => {
+      const rl3 = createInterface3({
+        input: process.stdin,
+        output: process.stderr
+      });
+      rl3.question(prompt, (answer) => {
+        rl3.close();
+        const a = answer.trim().toLowerCase();
+        resolve(a === "y" || a === "yes");
+      });
+    });
+  },
+  isTTY: process.stdin.isTTY ?? false
+};
+async function runNotesImport(args, client, io2 = defaultNotesImportIO) {
+  const { file, replace, yes = false, quiet = false, dryRun = false } = args;
+  const inferredTitle = args.title ?? defaultTitleFor3(file);
+  if (replace) {
+    if (!yes) {
+      if (!io2.isTTY) {
+        io2.stderr(
+          JSON.stringify(
+            {
+              error: {
+                code: "CONFIRMATION_REQ",
+                message: `Pass --yes to confirm replacing note "${replace}".`
+              }
+            },
+            null,
+            2
+          )
+        );
+        return { exitCode: 1 };
+      }
+      const ok3 = await io2.confirm(
+        `This will replace content of ${replace}. Continue? [y/N] `
+      );
+      if (!ok3) {
+        if (!quiet) io2.stderr("Aborted.");
+        return { exitCode: 0 };
+      }
+    }
+    const content2 = await io2.readText(file);
+    if (dryRun) {
+      io2.stdout(
+        JSON.stringify(
+          {
+            method: "PUT",
+            path: `/documents/${replace}/content`,
+            body: { content: content2 }
+          },
+          null,
+          2
+        )
+      );
+      return { exitCode: 0 };
+    }
+    const res = await client.putNoteContent(replace, { content: content2 });
+    if (!res.ok) {
+      io2.stderr(
+        JSON.stringify(res.data ?? { error: { code: "HTTP_ERROR" } }, null, 2)
+      );
+      return { exitCode: 1 };
+    }
+    io2.stdout(JSON.stringify({ id: replace, replaced: true }, null, 2));
+    return { exitCode: 0 };
+  }
+  const content = await io2.readText(file);
+  if (dryRun) {
+    io2.stdout(
+      JSON.stringify(
+        {
+          method: "POST",
+          path: "/documents",
+          body: { title: inferredTitle, type: "note" },
+          followUp: { method: "PUT", path: "/documents/<new-id>/content" }
+        },
+        null,
+        2
+      )
+    );
+    return { exitCode: 0 };
+  }
+  const created = await client.createDocument(inferredTitle, "note");
+  if (!created.ok) {
+    io2.stderr(
+      JSON.stringify(created.data ?? { error: { code: "HTTP_ERROR" } }, null, 2)
+    );
+    return { exitCode: 1 };
+  }
+  const newId = created.data?.id;
+  if (!newId) {
+    io2.stderr(
+      JSON.stringify(
+        {
+          error: {
+            code: "INVALID_RESPONSE",
+            message: "Server did not return an id"
+          }
+        },
+        null,
+        2
+      )
+    );
+    return { exitCode: 1 };
+  }
+  const put = await client.putNoteContent(newId, { content });
+  if (!put.ok) {
+    io2.stderr(
+      JSON.stringify(put.data ?? { error: { code: "HTTP_ERROR" } }, null, 2)
+    );
+    return { exitCode: 1 };
+  }
+  io2.stdout(JSON.stringify({ id: newId, title: inferredTitle }, null, 2));
+  return { exitCode: 0 };
+}
+function defaultTitleFor3(file) {
+  if (file === "-") return "Untitled";
+  return basename3(file, extname7(file)) || "Untitled";
+}
+
+// src/notes/content.ts
+import { writeFileSync as writeFileSync6, existsSync as existsSync5 } from "fs";
+var VALID_NOTES_CONTENT_FORMATS = ["json", "md", "text"];
+function parseNotesContentFormat(value) {
+  if (!VALID_NOTES_CONTENT_FORMATS.includes(value)) {
+    throw new Error(
+      `Invalid --format "${value}". Use one of: ${VALID_NOTES_CONTENT_FORMATS.join(", ")}.`
+    );
+  }
+  return value;
+}
+var defaultNotesContentIO = {
+  stdout: (text) => {
+    process.stdout.write(text);
+    if (!text.endsWith("\n")) process.stdout.write("\n");
+  },
+  stderr: (line) => {
+    console.error(line);
+  },
+  writeFile: (path, text, force) => {
+    if (existsSync5(path) && !force) {
+      throw new Error(
+        `Refusing to overwrite "${path}". Pass --force to allow overwrite.`
+      );
+    }
+    writeFileSync6(path, text.endsWith("\n") ? text : text + "\n", "utf-8");
+  }
+};
+function runNotesContent(args, io2 = defaultNotesContentIO) {
+  const { note, format: format2, out, force = false, quiet = false } = args;
+  const safeNote = note ?? { content: "" };
+  const text = format2 === "json" ? JSON.stringify(safeNote, null, 2) : safeNote.content ?? "";
+  if (!out || out === "-") {
+    io2.stdout(text);
+    return;
+  }
+  io2.writeFile(out, text, force);
+  if (!quiet) io2.stderr(`Wrote to ${out}`);
+}
+
+// src/commands/notes.ts
+function registerNotesCommand(program2) {
+  const notes = program2.command("notes").alias("note").description("Manage markdown notes");
+  notes.command("list").description("List notes in workspace").action(async function() {
+    const opts = getGlobalOpts(this);
+    try {
+      const res = await getClient(opts).listDocuments();
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      let data = res.data;
+      if (Array.isArray(data)) {
+        data = data.filter(
+          (d) => d.type === "note"
+        );
+      }
+      output(data, opts.format, opts.quiet);
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("create <title>").description("Create a new note").action(async function(title) {
+    const opts = getGlobalOpts(this);
+    try {
+      if (opts.dryRun) {
+        printDryRun(getConfig(opts), "POST", "/documents", {
+          title,
+          type: "note"
+        });
+        return;
+      }
+      const res = await getClient(opts).createDocument(title, "note");
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      output(res.data, opts.format, opts.quiet);
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("get <doc-id>").description("Show note metadata").action(async function(docId) {
+    const opts = getGlobalOpts(this);
+    try {
+      const res = await getClient(opts).getDocument(docId);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      output(res.data, opts.format, opts.quiet);
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("rename <doc-id> <title>").description("Rename a note").action(async function(docId, title) {
+    const opts = getGlobalOpts(this);
+    if (opts.dryRun) {
+      printDryRun(getConfig(opts), "PATCH", `/documents/${docId}`, { title });
+      return;
+    }
+    try {
+      const res = await getClient(opts).updateDocument(docId, title);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      output(res.data, opts.format, opts.quiet);
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("delete <doc-id>").description("Delete a note").action(async function(docId) {
+    const opts = getGlobalOpts(this);
+    if (opts.dryRun) {
+      printDryRun(getConfig(opts), "DELETE", `/documents/${docId}`);
+      return;
+    }
+    try {
+      const res = await getClient(opts).deleteDocument(docId);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      output(res.data, opts.format, opts.quiet);
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("content <doc-id>").description("Read note content as JSON or Markdown").option("--out <file>", "Output file (- for stdout)").option("--force", "Overwrite existing output file", false).action(async function(docId) {
+    const opts = getGlobalOpts(this);
+    const local = this.opts();
+    try {
+      const format2 = parseNotesContentFormat(opts.format);
+      if (opts.dryRun) {
+        printDryRun(getConfig(opts), "GET", `/documents/${docId}/content`);
+        return;
+      }
+      const res = await getClient(opts).getNoteContent(docId);
+      if (!res.ok) {
+        const body = res.data;
+        if (body?.error) {
+          console.error(JSON.stringify(body, null, 2));
+          process.exitCode = 1;
+          return;
+        }
+        throw new Error(`HTTP ${res.status}`);
+      }
+      runNotesContent({
+        note: res.data,
+        format: format2,
+        out: local.out,
+        force: local.force,
+        quiet: opts.quiet
+      });
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  notes.command("export <doc-id> <file>").description("Export a note to Markdown").option("--force", "Overwrite existing output file", false).action(async function(docId, file) {
+    const opts = getGlobalOpts(this);
+    const local = this.opts();
+    try {
+      const formatSource = this.getOptionValueSourceWithGlobals("format");
+      const fmt = formatSource === "cli" ? opts.format : void 0;
+      if (fmt && fmt !== "md" && fmt !== "markdown") {
+        throw new Error(`Invalid --format "${fmt}". Only "md" is supported.`);
+      }
+      const ext = extname8(file).toLowerCase();
+      if (!fmt && file !== "-" && ext !== ".md" && ext !== ".markdown") {
+        throw new Error(
+          `Cannot infer format from "${file}". Use a .md extension or --format md.`
+        );
+      }
+      if (opts.dryRun) {
+        printDryRun(getConfig(opts), "GET", `/documents/${docId}/content`);
+        return;
+      }
+      const res = await getClient(opts).getNoteContent(docId);
+      if (!res.ok) {
+        const body = res.data;
+        if (body?.error) {
+          console.error(JSON.stringify(body, null, 2));
+          process.exitCode = 1;
+          return;
+        }
+        throw new Error(`HTTP ${res.status}`);
+      }
+      runNotesContent({
+        note: res.data,
+        format: "md",
+        out: file,
+        force: local.force,
+        quiet: opts.quiet
+      });
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+  registerNotesImportCommand(notes);
+}
+function registerNotesImportCommand(notes) {
+  notes.command("import <file>").description("Import a Markdown file as a new (or replacement) note").option("--title <title>", "Note title (default: file basename)").option("--replace <doc-id>", "Replace content of an existing note").option("--yes", "Skip --replace confirmation prompt", false).action(async function(file) {
+    const opts = getGlobalOpts(this);
+    const local = this.opts();
+    try {
+      const result = await runNotesImport(
+        {
+          file,
+          title: local.title,
+          replace: local.replace,
+          yes: local.yes,
+          quiet: opts.quiet,
+          dryRun: opts.dryRun
+        },
+        getClient(opts)
+      );
+      if (result.exitCode !== 0) process.exitCode = result.exitCode;
+    } catch (e) {
+      outputError(e, opts.quiet);
+    }
+  });
+}
+
 // src/commands/api-keys.ts
 function registerApiKeysCommand(program2) {
   const apiKey = program2.command("api-keys").alias("api-key").description("Manage API keys");
@@ -99577,6 +99953,101 @@ var registry = [
     response: { type: "binary", description: "PPTX bytes" },
     aliases: ["slide.export", "deck.export", "decks.export"]
   },
+  // Notes (markdown) namespace
+  {
+    name: "notes.list",
+    description: "List notes in workspace",
+    safety: "read-only",
+    parameters: {},
+    response: { type: "array", items: { id: "string", title: "string", type: "string", createdAt: "string" } },
+    aliases: ["note.list"]
+  },
+  {
+    name: "notes.create",
+    description: "Create a new note",
+    safety: "write",
+    parameters: {
+      title: { type: "string", required: true, description: "Note title" }
+    },
+    response: { id: "string", title: "string", type: "string" },
+    aliases: ["note.create"]
+  },
+  {
+    name: "notes.get",
+    description: "Show note metadata",
+    safety: "read-only",
+    parameters: {
+      "doc-id": { type: "string", required: true, description: "Document ID" }
+    },
+    response: { id: "string", title: "string", type: "string", createdAt: "string" },
+    aliases: ["note.get"]
+  },
+  {
+    name: "notes.rename",
+    description: "Rename a note",
+    safety: "write",
+    parameters: {
+      "doc-id": { type: "string", required: true, description: "Document ID" },
+      title: { type: "string", required: true, description: "New title" }
+    },
+    response: { id: "string", title: "string" },
+    aliases: ["note.rename"]
+  },
+  {
+    name: "notes.delete",
+    description: "Delete a note",
+    safety: "destructive",
+    parameters: {
+      "doc-id": { type: "string", required: true, description: "Document ID" }
+    },
+    response: { id: "string" },
+    aliases: ["note.delete"]
+  },
+  {
+    name: "notes.content",
+    description: "Read note content as JSON or Markdown",
+    safety: "read-only",
+    parameters: {
+      "doc-id": { type: "string", required: true, description: "Document ID" },
+      "--format": { type: "string", required: false, description: "Output format (json|md|text)", default: "json" },
+      "--out": { type: "string", required: false, description: "Output file (- for stdout)" },
+      "--force": { type: "boolean", required: false, description: "Overwrite existing output file", default: "false" }
+    },
+    response: { type: "object", description: "Note JSON ({content}) or raw Markdown per --format" },
+    aliases: ["note.content"]
+  },
+  {
+    name: "notes.import",
+    description: "Import a Markdown file as a new (or replacement) note",
+    // Default safety is `write` (create new note); `--replace` flips it to
+    // destructive, mirroring `docs.import` / `slides.import`.
+    safety: "write",
+    parameters: {
+      file: { type: "string", required: true, description: "Source .md path or - for stdin" },
+      "--title": { type: "string", required: false, description: "Note title (default: file basename)" },
+      "--replace": { type: "string", required: false, description: "Existing note ID to replace" },
+      "--yes": { type: "boolean", required: false, description: "Skip --replace confirmation", default: "false" }
+    },
+    response: { id: "string", title: "string", replaced: "boolean" },
+    variants: [
+      { when: "default", safety: "write", creates: "new note" },
+      { when: "--replace given", safety: "destructive", modifies: "existing note content" }
+    ],
+    aliases: ["note.import"]
+  },
+  {
+    name: "notes.export",
+    description: "Export a note to Markdown",
+    safety: "read-only",
+    parameters: {
+      "doc-id": { type: "string", required: true, description: "Document ID" },
+      file: { type: "string", required: true, description: "Output path or - for stdout" },
+      "--format": { type: "string", required: false, description: "Output format (md); default from extension" },
+      "--force": { type: "boolean", required: false, description: "Overwrite existing output file", default: "false" }
+    },
+    response: { type: "string", description: "Markdown text" },
+    aliases: ["note.export"]
+  },
   // Sheets namespace — canonical names live under sheets.*
   {
     name: "sheets.tabs.list",
@@ -99738,7 +100209,7 @@ function registerSchemaCommand(program2) {
 
 // src/commands/login.ts
 import { createServer } from "http";
-import { createInterface as createInterface3 } from "readline";
+import { createInterface as createInterface4 } from "readline";
 function registerLoginCommand(program2) {
   program2.command("login").description("Log in via GitHub OAuth in the browser").action(async function() {
     const parentOpts = this.optsWithGlobals();
@@ -99832,7 +100303,7 @@ function registerLoginCommand(program2) {
   });
 }
 function ask(prompt) {
-  const rl3 = createInterface3({ input: process.stdin, output: process.stderr });
+  const rl3 = createInterface4({ input: process.stdin, output: process.stderr });
   return new Promise((resolve) => {
     rl3.question(prompt, (answer) => {
       rl3.close();
@@ -100032,6 +100503,7 @@ registerCtxCommand(program);
 registerDocsCommand(program);
 registerSheetsCommand(program);
 registerSlidesCommand(program);
+registerNotesCommand(program);
 registerApiKeysCommand(program);
 registerSchemaCommand(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wafflebase/cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "CLI for Wafflebase spreadsheet API",
   "license": "Apache-2.0",
   "type": "module",
@@ -31,8 +31,8 @@
     "tsx": "^4.19.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.8",
-    "@wafflebase/slides": "0.6.0",
-    "@wafflebase/docs": "0.6.0"
+    "@wafflebase/docs": "0.6.1",
+    "@wafflebase/slides": "0.6.1"
   },
   "scripts": {
     "build": "tsup",