@gobi-ai/cli 2.0.20 → 2.0.21

package/.claude-plugin/marketplace.json

@@ -4,12 +4,12 @@
     "name": "gobi-ai"
   },
   "description": "Claude Code plugin for the Gobi collaborative knowledge platform CLI",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "plugins": [
     {
       "name": "gobi",
       "description": "Manage the Gobi collaborative knowledge platform from the command line. Publish vault profiles, create posts and replies, manage saved notes and posts, manage sessions, generate images and videos.",
-      "version": "2.0.19",
+      "version": "2.0.21",
       "author": {
         "name": "gobi-ai"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gobi",
   "description": "Manage the Gobi collaborative knowledge platform from the command line",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "author": {
     "name": "gobi-ai"
   },

package/dist/commands/personal.js

@@ -0,0 +1,470 @@
+import { apiGet, apiPost, apiPatch, apiDelete } from "../client.js";
+import { fetchDraftSummary, isJsonMode, jsonOut, readStdin, resolveVaultSlug, unwrapResp, } from "./utils.js";
+import { extractWikiLinks, uploadAttachments, uploadPostAttachments, assertPostAttachmentMix, } from "../attachments.js";
+import { getValidToken } from "../auth/manager.js";
+function readContent(value) {
+    if (value === "-")
+        return readStdin();
+    return value;
+}
+function formatFeedLine(m) {
+    const isReply = m.parentPostId != null ||
+        m.type === "post-reply";
+    const id = `[${isReply ? "r" : "p"}:${m.id}]`;
+    const kind = isReply ? "reply" : "post ";
+    const author = m.author?.name ||
+        `User ${m.authorId ?? "?"}`;
+    let label;
+    if (isReply) {
+        const text = m.content || "";
+        label = text.length > 80 ? text.slice(0, 80) + "…" : text;
+        label = label.replace(/\s+/g, " ").trim();
+    }
+    else {
+        label = m.title || m.content || "";
+    }
+    return `${id} ${kind} ${author}  "${label}"  ${m.createdAt}`;
+}
+export function registerPersonalCommand(program) {
+    const personal = program
+        .command("personal")
+        .description("Personal-space commands (private posts and replies visible only to you). " +
+        "Mirrors the `global` subcommand shape — posts/replies live in the same data " +
+        "model, scoped via personalSpaceUserId so they never surface on the public feed.");
+    // ── Feed (unified) ──
+    personal
+        .command("feed")
+        .description("List your personal-space feed (posts and replies, newest first). Only you can see these rows.")
+        .option("--limit <number>", "Items per page", "20")
+        .option("--cursor <string>", "Pagination cursor from previous response")
+        .action(async (opts) => {
+        const params = {
+            limit: parseInt(opts.limit, 10),
+        };
+        if (opts.cursor)
+            params.cursor = opts.cursor;
+        const resp = (await apiGet(`/posts/personal-space`, params));
+        if (isJsonMode(personal)) {
+            jsonOut({
+                items: resp.data || [],
+                pagination: resp.pagination || {},
+            });
+            return;
+        }
+        const items = (resp.data || []);
+        const pagination = (resp.pagination || {});
+        if (!items.length) {
+            console.log("No items in your personal space yet.");
+            return;
+        }
+        const lines = items.map(formatFeedLine);
+        const footer = pagination.hasMore ? `\n  Next cursor: ${pagination.nextCursor}` : "";
+        console.log(`Personal-space feed (${items.length} items, newest first):\n` +
+            lines.join("\n") +
+            footer);
+    });
+    // ── List posts ──
+    //
+    // No server-side roots-only endpoint exists for the personal-space lane;
+    // we fetch the unified feed and filter client-side to `type === 'post'`.
+    // The `--limit` then applies to the raw feed page, not the post-only
+    // count — callers expecting N roots may need to paginate further.
+    personal
+        .command("list-posts")
+        .description("List root posts (no replies) in your personal space. Filters the personal feed client-side; pagination cursor advances through the underlying feed page.")
+        .option("--limit <number>", "Items per page (applied to the underlying feed page)", "20")
+        .option("--cursor <string>", "Pagination cursor from previous response")
+        .action(async (opts) => {
+        const params = {
+            limit: parseInt(opts.limit, 10),
+        };
+        if (opts.cursor)
+            params.cursor = opts.cursor;
+        const resp = (await apiGet(`/posts/personal-space`, params));
+        const allItems = (resp.data || []);
+        const items = allItems.filter((t) => t.type !== "post-reply" && t.parentPostId == null);
+        const pagination = (resp.pagination || {});
+        if (isJsonMode(personal)) {
+            jsonOut({ items, pagination });
+            return;
+        }
+        if (!items.length) {
+            console.log("No posts found in your personal space.");
+            return;
+        }
+        const lines = [];
+        for (const t of items) {
+            const vaultSlug = t.vault?.vaultSlug ||
+                t.authorVault?.vaultSlug ||
+                "—";
+            lines.push(`- [${t.id}] "${t.title ?? "(no title)"}" (vault: ${vaultSlug}, ${t.replyCount ?? 0} replies, ${t.createdAt})`);
+        }
+        const footer = pagination.hasMore ? `\n  Next cursor: ${pagination.nextCursor}` : "";
+        console.log(`Personal-space posts (${items.length} of ${allItems.length} feed items):\n` +
+            lines.join("\n") +
+            footer);
+    });
+    // ── Get post (with ancestors and replies) ──
+    //
+    // Same `/posts/:id` and `/posts/:id/ancestors` routes the global command
+    // uses — the server gates these by `viewerUserId`, so private rows
+    // resolve for the owner and 404 for everyone else. Personal-space posts
+    // and global posts share this endpoint without ambiguity.
+    personal
+        .command("get-post <postId>")
+        .description("Get a personal-space post with its ancestors and replies (paginated). Same endpoint as `gobi global get-post`; only the owner can resolve a private id.")
+        .option("--limit <number>", "Items per page", "20")
+        .option("--cursor <string>", "Pagination cursor from previous response")
+        .option("--full", "Show full reply content without truncation")
+        .action(async (postId, opts) => {
+        const params = {
+            limit: parseInt(opts.limit, 10),
+        };
+        if (opts.cursor)
+            params.cursor = opts.cursor;
+        const [postResp, ancestorsResp] = await Promise.all([
+            apiGet(`/posts/${postId}`, params),
+            apiGet(`/posts/${postId}/ancestors`),
+        ]);
+        const data = unwrapResp(postResp);
+        const pagination = (postResp.pagination || {});
+        const mentions = (postResp.mentions || {});
+        const ancestorsData = unwrapResp(ancestorsResp);
+        const ancestors = (ancestorsData.ancestors || []);
+        if (isJsonMode(personal)) {
+            jsonOut({ ...data, ancestors, pagination, mentions });
+            return;
+        }
+        const post = (data.update || data.post || data);
+        const replies = (data.replies || []);
+        const author = post.author?.name ||
+            `User ${post.authorId}`;
+        const vault = post.vault?.vaultSlug ||
+            post.authorVault?.vaultSlug ||
+            "—";
+        const ancestorLines = [];
+        if (ancestors.length) {
+            ancestors.forEach((a, i) => {
+                ancestorLines.push(`  ${i + 1}. ${formatFeedLine(a)}`);
+            });
+        }
+        const replyLines = [];
+        for (const r of replies) {
+            const rAuthor = r.author?.name ||
+                `User ${r.authorId}`;
+            const text = r.content || "";
+            const truncated = opts.full || text.length <= 200 ? text : text.slice(0, 200) + "…";
+            replyLines.push(`  - ${rAuthor}: ${truncated} (${r.createdAt})`);
+        }
+        const isReplyPost = post.parentPostId != null;
+        const heading = isReplyPost
+            ? `Reply [r:${post.id}] (private)`
+            : `Post: ${post.title || "(no title)"} (private)`;
+        const output = [
+            heading,
+            `By: ${author} (vault: ${vault}) on ${post.createdAt}`,
+            ...(ancestorLines.length
+                ? ["", `Ancestors (${ancestors.length} items, root first):`, ...ancestorLines]
+                : []),
+            "",
+            post.content || "",
+            "",
+            `Replies (${replies.length} items):`,
+            ...replyLines,
+            ...(pagination.hasMore
+                ? [`  Next cursor: ${pagination.nextCursor}`]
+                : []),
+        ].join("\n");
+        console.log(output);
+    });
+    // ── Create post ──
+    //
+    // Targets `POST /posts/personal-space`, the only endpoint that stamps
+    // `personalSpaceUserId` on the row. Body shape is identical to the
+    // global `POST /posts` create (same CreatePostDto). The server skips the
+    // `@gobi` mention dispatch and the notification fan-out for this lane —
+    // private posts have no audience.
+    personal
+        .command("create-post")
+        .description("Create a private post in your personal space. --vault-slug attributes it to a vault you own. Visible only to you.")
+        .option("--title <title>", "Title of the post")
+        .option("--content <content>", "Post content (markdown supported, use \"-\" for stdin)")
+        .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
+        .option("--vault-slug <vaultSlug>", "Attribute the post to this vault (sets authorVaultSlug). Defaults to your primary vault.")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before posting (also sets authorVaultSlug to that vault)")
+        .option("--draft-id <draftId>", "Use this draft as the source of title and content (mutually exclusive with --title/--content/--rich-text). On success, links the post back via draft.metadata. The draft's vaultSlug seeds --vault-slug when not given explicitly.")
+        .option("--attach <file>", "Local media file to attach. Repeatable. X-style mix rule: up to 4 photos OR 1 GIF OR 1 video. Size ceilings: 5MB photos / 15MB GIFs / 512MB video.", (value, prev = []) => [...prev, value], [])
+        .option("--repost-post-id <postId>", "Wrap an existing top-level post as the embedded card on this new private post. The referenced post must be visible to you (your own personal-space post, a global-feed post, or a post in a space you're a member of). Reposting someone else's personal-space post returns 404.")
+        .action(async (opts) => {
+        if (opts.draftId) {
+            if (opts.title || opts.content || opts.richText) {
+                throw new Error("--draft-id sources title and content from the draft; --title, --content, and --rich-text are not allowed alongside it.");
+            }
+        }
+        else {
+            if (!opts.content && !opts.richText) {
+                throw new Error("Provide either --content or --rich-text (or --draft-id).");
+            }
+            if (opts.content && opts.richText) {
+                throw new Error("--content and --rich-text are mutually exclusive.");
+            }
+        }
+        const draft = opts.draftId ? await fetchDraftSummary(opts.draftId) : null;
+        const effectiveTitle = draft ? draft.title : opts.title;
+        const effectiveContent = draft ? draft.content : opts.content;
+        const effectiveVaultSlugOpt = opts.vaultSlug ?? draft?.vaultSlug ?? undefined;
+        let authorVaultSlug;
+        if (effectiveVaultSlugOpt || opts.autoAttachments) {
+            authorVaultSlug = resolveVaultSlug({ vaultSlug: effectiveVaultSlugOpt });
+        }
+        const body = {};
+        if (effectiveTitle != null)
+            body.title = effectiveTitle;
+        if (effectiveContent != null) {
+            const content = draft ? effectiveContent : readContent(effectiveContent);
+            if (opts.autoAttachments && authorVaultSlug) {
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
+            }
+            body.content = content;
+        }
+        if (opts.richText != null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.richText);
+            }
+            catch {
+                throw new Error("Invalid --rich-text JSON.");
+            }
+            body.richText = parsed;
+        }
+        if (authorVaultSlug)
+            body.authorVaultSlug = authorVaultSlug;
+        if (opts.attach && opts.attach.length > 0) {
+            assertPostAttachmentMix(opts.attach);
+            body.attachments = await uploadPostAttachments(opts.attach);
+        }
+        if (opts.repostPostId != null) {
+            const n = Number(opts.repostPostId);
+            if (!Number.isFinite(n) || n <= 0 || !Number.isInteger(n)) {
+                throw new Error("--repost-post-id must be a positive integer.");
+            }
+            body.repostPostId = n;
+        }
+        const resp = (await apiPost(`/posts/personal-space`, body));
+        const post = unwrapResp(resp);
+        if (opts.draftId && post.id != null) {
+            try {
+                await apiPatch(`/app/drafts/${opts.draftId}/metadata`, {
+                    postId: typeof post.id === "number" ? post.id : Number(post.id),
+                    spaceSlug: null,
+                });
+            }
+            catch (e) {
+                console.error(`Warning: failed to link post to draft ${opts.draftId}: ${e.message}`);
+            }
+        }
+        if (isJsonMode(personal)) {
+            jsonOut(post);
+            return;
+        }
+        console.log(`Personal-space post created!\n` +
+            `  ID: ${post.id}\n` +
+            (post.title ? `  Title: ${post.title}\n` : "") +
+            `  Created: ${post.createdAt}\n` +
+            `  Visibility: private (only you can see this)` +
+            (opts.draftId ? `\n  Linked to draft: ${opts.draftId}` : ""));
+    });
+    // ── Edit post ──
+    //
+    // Same `PATCH /posts/:postId` route the global command uses — the server
+    // gates on `authorId === userId` and the read-path guard runs first, so
+    // a non-owner can't edit (or even discover) a private post.
+    personal
+        .command("edit-post <postId>")
+        .description("Edit a post you authored in your personal space.")
+        .option("--title <title>", "New title")
+        .option("--content <content>", "New content (markdown supported, use \"-\" for stdin)")
+        .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
+        .option("--vault-slug <vaultSlug>", "Attribute the post to this vault (sets authorVaultSlug).")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before editing (uses --vault-slug or .gobi vault)")
+        .action(async (postId, opts) => {
+        const wantsVaultChange = !!(opts.vaultSlug || opts.autoAttachments);
+        if (opts.title == null &&
+            opts.content == null &&
+            opts.richText == null &&
+            !wantsVaultChange) {
+            throw new Error("Provide at least --title, --content, --rich-text, or --vault-slug to update.");
+        }
+        if (opts.content && opts.richText) {
+            throw new Error("--content and --rich-text are mutually exclusive.");
+        }
+        let authorVaultSlug;
+        if (opts.vaultSlug || opts.autoAttachments) {
+            authorVaultSlug = resolveVaultSlug(opts);
+        }
+        const body = {};
+        if (opts.title != null)
+            body.title = opts.title;
+        if (opts.content != null) {
+            const content = readContent(opts.content);
+            if (opts.autoAttachments && authorVaultSlug) {
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
+            }
+            body.content = content;
+        }
+        if (opts.richText != null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.richText);
+            }
+            catch {
+                throw new Error("Invalid --rich-text JSON.");
+            }
+            body.richText = parsed;
+        }
+        if (authorVaultSlug !== undefined)
+            body.authorVaultSlug = authorVaultSlug;
+        const resp = (await apiPatch(`/posts/${postId}`, body));
+        const post = unwrapResp(resp);
+        if (isJsonMode(personal)) {
+            jsonOut(post);
+            return;
+        }
+        console.log(`Post edited!\n  ID: ${post.id}\n  Edited: ${post.editedAt ?? post.updatedAt}`);
+    });
+    // ── Delete post ──
+    personal
+        .command("delete-post <postId>")
+        .description("Delete a post you authored in your personal space.")
+        .action(async (postId) => {
+        await apiDelete(`/posts/${postId}`);
+        if (isJsonMode(personal)) {
+            jsonOut({ id: postId });
+            return;
+        }
+        console.log(`Post ${postId} deleted.`);
+    });
+    // ── Reply ──
+    //
+    // `POST /posts/:postId/replies` inherits scope from the parent on the
+    // server — reply to a personal-space parent → reply is scoped to that
+    // personal space. The same command works for global and personal; we
+    // expose it here for discoverability/symmetry with `gobi global`.
+    personal
+        .command("create-reply <postId>")
+        .description("Reply to a personal-space post. The reply inherits the parent's private scope automatically.")
+        .option("--content <content>", "Reply content (markdown supported, use \"-\" for stdin)")
+        .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
+        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug). Also used as upload destination for --auto-attachments.")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before posting (also attributes the reply to that vault)")
+        .option("--attach <file>", "Local media file to attach to this reply. Repeatable. X-style mix rule: up to 4 photos OR 1 GIF OR 1 video. Size ceilings: 5MB photos / 15MB GIFs / 512MB video.", (value, prev = []) => [...prev, value], [])
+        .action(async (postId, opts) => {
+        if (!opts.content && !opts.richText) {
+            throw new Error("Provide either --content or --rich-text.");
+        }
+        if (opts.content && opts.richText) {
+            throw new Error("--content and --rich-text are mutually exclusive.");
+        }
+        let authorVaultSlug;
+        if (opts.vaultSlug || opts.autoAttachments) {
+            authorVaultSlug = resolveVaultSlug(opts);
+        }
+        const body = {};
+        if (opts.content != null) {
+            const content = readContent(opts.content);
+            if (opts.autoAttachments && authorVaultSlug) {
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
+            }
+            body.content = content;
+        }
+        if (opts.richText != null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.richText);
+            }
+            catch {
+                throw new Error("Invalid --rich-text JSON.");
+            }
+            body.richText = parsed;
+        }
+        if (authorVaultSlug)
+            body.authorVaultSlug = authorVaultSlug;
+        if (opts.attach && opts.attach.length > 0) {
+            assertPostAttachmentMix(opts.attach);
+            body.attachments = await uploadPostAttachments(opts.attach);
+        }
+        const resp = (await apiPost(`/posts/${postId}/replies`, body));
+        const reply = unwrapResp(resp);
+        if (isJsonMode(personal)) {
+            jsonOut(reply);
+            return;
+        }
+        console.log(`Reply created!\n  ID: ${reply.id}\n  Created: ${reply.createdAt}`);
+    });
+    personal
+        .command("edit-reply <replyId>")
+        .description("Edit a reply you authored in your personal space.")
+        .option("--content <content>", "New reply content (markdown supported, use \"-\" for stdin)")
+        .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
+        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug). Also used as upload destination for --auto-attachments.")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before editing (also attributes the reply to that vault)")
+        .action(async (replyId, opts) => {
+        const wantsVaultChange = !!(opts.vaultSlug || opts.autoAttachments);
+        if (opts.content == null && opts.richText == null && !wantsVaultChange) {
+            throw new Error("Provide at least --content, --rich-text, or --vault-slug to update.");
+        }
+        if (opts.content && opts.richText) {
+            throw new Error("--content and --rich-text are mutually exclusive.");
+        }
+        let authorVaultSlug;
+        if (opts.vaultSlug || opts.autoAttachments) {
+            authorVaultSlug = resolveVaultSlug(opts);
+        }
+        const body = {};
+        if (opts.content != null) {
+            const content = readContent(opts.content);
+            if (opts.autoAttachments && authorVaultSlug) {
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
+            }
+            body.content = content;
+        }
+        if (opts.richText != null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.richText);
+            }
+            catch {
+                throw new Error("Invalid --rich-text JSON.");
+            }
+            body.richText = parsed;
+        }
+        if (authorVaultSlug !== undefined)
+            body.authorVaultSlug = authorVaultSlug;
+        const resp = (await apiPatch(`/posts/replies/${replyId}`, body));
+        const reply = unwrapResp(resp);
+        if (isJsonMode(personal)) {
+            jsonOut(reply);
+            return;
+        }
+        console.log(`Reply edited!\n  ID: ${reply.id}\n  Edited: ${reply.editedAt ?? reply.updatedAt}`);
+    });
+    personal
+        .command("delete-reply <replyId>")
+        .description("Delete a reply you authored in your personal space.")
+        .action(async (replyId) => {
+        await apiDelete(`/posts/replies/${replyId}`);
+        if (isJsonMode(personal)) {
+            jsonOut({ id: replyId });
+            return;
+        }
+        console.log(`Reply ${replyId} deleted.`);
+    });
+}

package/dist/main.js

@@ -6,6 +6,7 @@ import { registerAuthCommand } from "./commands/auth.js";
 import { commandRequiresSpace, commandRequiresVault, readSettings, } from "./commands/init.js";
 import { registerSpaceCommand } from "./commands/space.js";
 import { registerGlobalCommand } from "./commands/global.js";
+import { registerPersonalCommand } from "./commands/personal.js";
 import { registerVaultCommand } from "./commands/vault.js";
 import { registerSavedCommand } from "./commands/saved.js";
 import { registerSessionsCommand } from "./commands/sessions.js";
@@ -60,6 +61,7 @@ export async function cli() {
     registerAuthCommand(program);
     registerSpaceCommand(program);
     registerGlobalCommand(program);
+    registerPersonalCommand(program);
     registerVaultCommand(program);
     registerSavedCommand(program);
     registerSessionsCommand(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "2.0.20",
+  "version": "2.0.21",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",