@gobi-ai/cli 0.7.3 → 0.9.0

package/.claude-plugin/marketplace.json

@@ -4,20 +4,24 @@
     "name": "gobi-ai"
   },
   "description": "Claude Code plugin for the Gobi collaborative knowledge platform CLI",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "plugins": [
     {
       "name": "gobi",
-      "description": "Manage the Gobi collaborative knowledge platform from the command line. Search and ask brains, publish brain documents, create threads, manage sessions.",
-      "version": "0.7.3",
+      "description": "Manage the Gobi collaborative knowledge platform from the command line. Search and ask brains, publish brain documents, create threads, manage sessions, generate images and videos.",
+      "version": "0.8.0",
       "author": {
         "name": "gobi-ai"
       },
       "homepage": "https://github.com/gobi-ai/gobi-cli",
       "source": "./",
       "skills": [
-        "./skills/gobi",
-        "./skills/gobi-dev-homepage"
+        "./skills/gobi-core",
+        "./skills/gobi-space",
+        "./skills/gobi-brain",
+        "./skills/gobi-media",
+        "./skills/gobi-sense",
+        "./skills/gobi-homepage"
       ],
       "commands": "./commands"
     }

package/.claude-plugin/plugin.json

@@ -1,14 +1,18 @@
 {
   "name": "gobi",
   "description": "Manage the Gobi collaborative knowledge platform from the command line",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "author": {
     "name": "gobi-ai"
   },
   "homepage": "https://github.com/gobi-ai/gobi-cli",
   "skills": [
-    "./skills/gobi",
-    "./skills/gobi-dev-homepage"
+    "./skills/gobi-core",
+    "./skills/gobi-space",
+    "./skills/gobi-brain",
+    "./skills/gobi-media",
+    "./skills/gobi-sense",
+    "./skills/gobi-homepage"
   ],
   "commands": "./commands"
 }

package/dist/commands/media.js

@@ -0,0 +1,379 @@
+import { apiGet, apiPost } from "../client.js";
+import { BASE_URL, POLL_MAX_DURATION_MS } from "../constants.js";
+import { getValidToken } from "../auth/manager.js";
+import { ApiError } from "../errors.js";
+import { isJsonMode, jsonOut, unwrapResp } from "./utils.js";
+// ── Polling helper ──
+async function pollStatus(path, terminalStates, intervalMs = 3000) {
+    const start = Date.now();
+    while (Date.now() - start < POLL_MAX_DURATION_MS) {
+        const resp = (await apiGet(path));
+        const data = unwrapResp(resp);
+        const status = data.status || "";
+        if (terminalStates.includes(status))
+            return data;
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error(`Polling timed out after ${POLL_MAX_DURATION_MS / 1000}s`);
+}
+export function registerMediaCommand(program) {
+    const media = program
+        .command("media")
+        .description("Media generation commands (videos, images).");
+    // ════════════════════════════════════════════════════════════════════
+    //  Upload
+    // ════════════════════════════════════════════════════════════════════
+    media
+        .command("upload-init")
+        .description("Get a presigned upload URL for a media file.")
+        .requiredOption("--file-name <fileName>", "Name of the file to upload")
+        .requiredOption("--content-type <contentType>", "MIME type (e.g. image/png, video/mp4)")
+        .option("--file-size <fileSize>", "File size in bytes")
+        .action(async (opts) => {
+        const body = {
+            fileName: opts.fileName,
+            contentType: opts.contentType,
+        };
+        if (opts.fileSize)
+            body.fileSize = parseInt(opts.fileSize, 10);
+        const resp = (await apiPost("/media-gen/media/initialize", body));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Upload initialized!\n` +
+            `  Media ID:   ${data.mediaId}\n` +
+            `  Upload URL: ${data.uploadUrl}\n\n` +
+            `PUT your file to the upload URL, then run:\n` +
+            `  gobi media upload-finalize --media-id ${data.mediaId}`);
+    });
+    media
+        .command("upload-finalize")
+        .description("Confirm that a media upload is complete.")
+        .requiredOption("--media-id <mediaId>", "Media ID from upload-init")
+        .action(async (opts) => {
+        const resp = (await apiPost("/media-gen/media/finalize", {
+            mediaId: opts.mediaId,
+        }));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Upload finalized for media ${opts.mediaId}.`);
+    });
+    // ════════════════════════════════════════════════════════════════════
+    //  Avatars & Voices
+    // ════════════════════════════════════════════════════════════════════
+    media
+        .command("avatars")
+        .description("List available avatars.")
+        .action(async () => {
+        const resp = (await apiGet("/media-gen/avatars"));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        if (!Array.isArray(data) || data.length === 0) {
+            console.log("No avatars available.");
+            return;
+        }
+        console.log("Available avatars:");
+        for (const a of data) {
+            console.log(`  - ${a.id || a.avatarId}: ${a.name || "(unnamed)"}`);
+        }
+    });
+    media
+        .command("voices")
+        .description("List available voices.")
+        .action(async () => {
+        const resp = (await apiGet("/media-gen/voices"));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        if (!Array.isArray(data) || data.length === 0) {
+            console.log("No voices available.");
+            return;
+        }
+        console.log("Available voices:");
+        for (const v of data) {
+            console.log(`  - ${v.id || v.voiceId}: ${v.name || "(unnamed)"}`);
+        }
+    });
+    // ════════════════════════════════════════════════════════════════════
+    //  Videos
+    // ════════════════════════════════════════════════════════════════════
+    media
+        .command("video-create")
+        .description("Create an avatar video generation job.")
+        .requiredOption("--name <name>", "Name for the video")
+        .requiredOption("--avatar-id <avatarId>", "Avatar to use")
+        .requiredOption("--voice-id <voiceId>", "Voice to use")
+        .requiredOption("--script <script>", "Script for the avatar to read")
+        .option("--background-media-id <backgroundMediaId>", "Background media ID (from upload)")
+        .option("--wait", "Poll until generation completes")
+        .action(async (opts) => {
+        const body = {
+            name: opts.name,
+            avatarId: opts.avatarId,
+            voiceId: opts.voiceId,
+            script: opts.script,
+        };
+        if (opts.backgroundMediaId)
+            body.backgroundMediaId = opts.backgroundMediaId;
+        const resp = (await apiPost("/media-gen/videos", body));
+        let data = unwrapResp(resp);
+        const videoId = data.id || data.videoId;
+        if (opts.wait && videoId) {
+            console.log(`Video ${videoId} queued — polling for completion…`);
+            data = await pollStatus(`/media-gen/videos/${videoId}/status`, ["inference_complete", "inference_failed"]);
+        }
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        const status = data.status || "queued";
+        console.log(`Video created!\n` +
+            `  ID:     ${videoId}\n` +
+            `  Status: ${status}`);
+        if (status === "inference_complete") {
+            console.log(`  Download: gobi media video-download ${videoId}`);
+        }
+    });
+    media
+        .command("video-list")
+        .description("List all videos.")
+        .action(async () => {
+        const resp = (await apiGet("/media-gen/videos"));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        if (!Array.isArray(data) || data.length === 0) {
+            console.log("No videos found.");
+            return;
+        }
+        console.log("Videos:");
+        for (const v of data) {
+            console.log(`  - [${v.id}] status: ${v.status || "unknown"}, created: ${v.createdAt || "?"}`);
+        }
+    });
+    media
+        .command("video-get <id>")
+        .description("Get video metadata.")
+        .action(async (id) => {
+        const resp = (await apiGet(`/media-gen/videos/${id}`));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Video ${id}:`);
+        for (const [k, v] of Object.entries(data)) {
+            console.log(`  ${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`);
+        }
+    });
+    media
+        .command("video-status <id>")
+        .description("Poll video generation status.")
+        .option("--wait", "Poll until a terminal state is reached")
+        .action(async (id, opts) => {
+        if (opts.wait) {
+            const data = await pollStatus(`/media-gen/videos/${id}/status`, ["inference_complete", "inference_failed"]);
+            if (isJsonMode(media)) {
+                jsonOut(data);
+                return;
+            }
+            console.log(`Video ${id} — status: ${data.status}`);
+            return;
+        }
+        const resp = (await apiGet(`/media-gen/videos/${id}/status`));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Video ${id} — status: ${data.status || "unknown"}`);
+    });
+    media
+        .command("video-download <id>")
+        .description("Get the download URL for a completed video.")
+        .action(async (id) => {
+        const token = await getValidToken();
+        const url = `${BASE_URL}/media-gen/videos/${id}/download`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${token}` },
+            redirect: "manual",
+        });
+        // If the server redirects, extract the Location header
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location") || "";
+            if (isJsonMode(media)) {
+                jsonOut({ downloadUrl: location });
+                return;
+            }
+            console.log(`Download URL for video ${id}:\n  ${location}`);
+            return;
+        }
+        if (!res.ok) {
+            const text = (await res.text()) || "(no body)";
+            throw new ApiError(res.status, `/media-gen/videos/${id}/download`, text);
+        }
+        // If it returns JSON instead of a redirect
+        const resp = (await res.json());
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Download URL for video ${id}:\n  ${data.url || data.downloadUrl || JSON.stringify(data)}`);
+    });
+    // ════════════════════════════════════════════════════════════════════
+    //  Images
+    // ════════════════════════════════════════════════════════════════════
+    media
+        .command("image-generate")
+        .description("Generate an image from a text prompt. Types: image (default), thumbnail (YouTube-optimized), asset (logo/product). Aspect ratios: 1:1, 16:9, 9:16, 4:3, 3:4")
+        .requiredOption("--prompt <prompt>", "Text prompt for image generation")
+        .requiredOption("--name <name>", "Name for the generated image")
+        .option("--type <type>", "Generation type: image (default), thumbnail (YouTube-optimized), asset (logo/product)")
+        .option("--aspect-ratio <aspectRatio>", "Aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4)")
+        .option("--negative-prompt <negativePrompt>", "Negative prompt")
+        .option("--seed <seed>", "Random seed for reproducibility")
+        .option("--reference-media-id <referenceMediaId>", "Reference image media ID")
+        .option("--wait", "Poll until generation completes")
+        .action(async (opts) => {
+        const body = {
+            prompt: opts.prompt,
+            name: opts.name,
+        };
+        if (opts.type)
+            body.type = opts.type;
+        if (opts.aspectRatio)
+            body.aspectRatio = opts.aspectRatio;
+        if (opts.negativePrompt)
+            body.negativePrompt = opts.negativePrompt;
+        if (opts.seed)
+            body.seed = parseInt(opts.seed, 10);
+        if (opts.referenceMediaId)
+            body.referenceMediaId = opts.referenceMediaId;
+        const resp = (await apiPost("/media-gen/images/generate", body));
+        let data = unwrapResp(resp);
+        const jobId = data.jobId || data.id;
+        if (opts.wait && jobId) {
+            console.log(`Image job ${jobId} queued — polling for completion…`);
+            data = await pollStatus(`/media-gen/images/${jobId}`, [
+                "completed",
+                "failed",
+                "inference_complete",
+                "inference_failed",
+            ]);
+        }
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Image generation started!\n` +
+            `  Job ID: ${jobId}\n` +
+            `  Status: ${data.status || "queued"}\n` +
+            `  Check:  gobi media image-status ${jobId}`);
+    });
+    media
+        .command("image-edit")
+        .description("Edit an existing image with a prompt (image-to-image).")
+        .requiredOption("--media-id <mediaId>", "Source image media ID")
+        .requiredOption("--prompt <prompt>", "Edit instruction")
+        .requiredOption("--name <name>", "Name for the edited image")
+        .option("--wait", "Poll until generation completes")
+        .action(async (opts) => {
+        const resp = (await apiPost("/media-gen/images/edit", {
+            mediaId: opts.mediaId,
+            prompt: opts.prompt,
+            name: opts.name,
+        }));
+        let data = unwrapResp(resp);
+        const jobId = data.jobId || data.id;
+        if (opts.wait && jobId) {
+            console.log(`Image edit job ${jobId} — polling for completion…`);
+            data = await pollStatus(`/media-gen/images/${jobId}`, [
+                "completed",
+                "failed",
+                "inference_complete",
+                "inference_failed",
+            ]);
+        }
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Image edit started!\n` +
+            `  Job ID: ${jobId}\n` +
+            `  Status: ${data.status || "queued"}`);
+    });
+    media
+        .command("image-inpaint")
+        .description("Inpaint an image region using a mask.")
+        .requiredOption("--media-id <mediaId>", "Source image media ID")
+        .requiredOption("--mask-media-id <maskMediaId>", "Mask image media ID")
+        .requiredOption("--prompt <prompt>", "Inpainting prompt")
+        .requiredOption("--name <name>", "Name for the inpainted image")
+        .option("--wait", "Poll until generation completes")
+        .action(async (opts) => {
+        const resp = (await apiPost("/media-gen/images/inpaint", {
+            mediaId: opts.mediaId,
+            maskMediaId: opts.maskMediaId,
+            prompt: opts.prompt,
+            name: opts.name,
+        }));
+        let data = unwrapResp(resp);
+        const jobId = data.jobId || data.id;
+        if (opts.wait && jobId) {
+            console.log(`Inpaint job ${jobId} — polling for completion…`);
+            data = await pollStatus(`/media-gen/images/${jobId}`, [
+                "completed",
+                "failed",
+                "inference_complete",
+                "inference_failed",
+            ]);
+        }
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Inpainting started!\n` +
+            `  Job ID: ${jobId}\n` +
+            `  Status: ${data.status || "queued"}`);
+    });
+    media
+        .command("image-status <jobId>")
+        .description("Check image generation job status.")
+        .option("--wait", "Poll until a terminal state is reached")
+        .action(async (jobId, opts) => {
+        if (opts.wait) {
+            const data = await pollStatus(`/media-gen/images/${jobId}`, [
+                "completed",
+                "failed",
+                "inference_complete",
+                "inference_failed",
+            ]);
+            if (isJsonMode(media)) {
+                jsonOut(data);
+                return;
+            }
+            console.log(`Image job ${jobId} — status: ${data.status}`);
+            return;
+        }
+        const resp = (await apiGet(`/media-gen/images/${jobId}`));
+        const data = unwrapResp(resp);
+        if (isJsonMode(media)) {
+            jsonOut(data);
+            return;
+        }
+        console.log(`Image job ${jobId} — status: ${data.status || "unknown"}`);
+    });
+}

package/dist/main.js

@@ -10,6 +10,7 @@ import { registerSessionsCommand } from "./commands/sessions.js";
 import { registerSenseCommand } from "./commands/sense.js";
 import { registerSyncCommand } from "./commands/sync.js";
 import { registerUpdateCommand } from "./commands/update.js";
+import { registerMediaCommand } from "./commands/media.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 const SKIP_BANNER_COMMANDS = new Set(["auth", "init", "update"]);
@@ -36,6 +37,7 @@ export async function cli() {
     registerSenseCommand(program);
     registerSyncCommand(program);
     registerUpdateCommand(program);
+    registerMediaCommand(program);
     // Propagate helpWidth to all subcommands
     const helpWidth = process.stdout.columns || 200;
     for (const cmd of program.commands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "test": "node --test dist/*.test.js dist/**/*.test.js",
-    "generate-skill-docs": "npm run build && npx tsx skills/gobi/scripts/generate-docs.ts",
+    "generate-skill-docs": "npm run build && npx tsx scripts/generate-skill-docs.ts",
     "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },

package/skills/gobi-brain/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: gobi-brain
+description: >-
+  Gobi brain commands for knowledge management: search public brains by text
+  and semantic similarity, ask brains questions, publish/unpublish BRAIN.md,
+  and manage brain updates (list/post/edit/delete). Use when the user wants
+  to search knowledge, ask a brain, publish their brain document, or manage
+  brain updates.
+allowed-tools: Bash(gobi:*)
+metadata:
+  author: gobi-ai
+  version: "0.8.0"
+---
+
+# gobi-brain
+
+Gobi brain commands for knowledge management (v0.8.0).
+
+Requires gobi-cli installed and authenticated. See gobi-core skill for setup.
+
+## Gobi Brain — Knowledge Management
+
+`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md. Public brains are accessible at `https://gobispace.com/@{vaultSlug}`.
+
+## Space Slug Override
+
+For `gobi brain list-updates`, you can filter by space with a subcommand option:
+
+```bash
+gobi brain list-updates --space-slug <slug>
+```
+
+Note: `--space-slug` is not available on other `brain` subcommands.
+
+## Important: JSON Mode
+
+For programmatic/agent usage, always pass `--json` as a **global** option (before the subcommand):
+
+```bash
+gobi --json brain search --query "machine learning"
+```
+
+## Available Commands
+
+- `gobi brain search` — Search public brains by text and semantic similarity.
+- `gobi brain ask` — Ask a brain a question. Creates a targeted session (1:1 conversation).
+- `gobi brain publish` — Upload BRAIN.md to the vault root on webdrive. Triggers post-processing (brain sync, metadata update, Discord notification).
+- `gobi brain unpublish` — Delete BRAIN.md from the vault on webdrive.
+- `gobi brain list-updates` — List recent brain updates. Without --space-slug, lists all updates for you. With --space-slug, lists updates for that space. Use --mine to show only updates by you.
+- `gobi brain post-update` — Post a brain update for a vault.
+- `gobi brain edit-update` — Edit a published brain update. You must be the author.
+- `gobi brain delete-update` — Delete a published brain update. You must be the author.
+
+## Reference Documentation
+
+- [gobi brain](references/brain.md)

package/skills/{gobi/SKILL.template.md → gobi-core/SKILL.md}

@@ -1,21 +1,20 @@
 ---
-name: gobi-cli
+name: gobi-core
 description: >-
-  Manage the Gobi collaborative knowledge platform from the command line.
-  Gobi space is the user's main channel for social interactions and engaging with
-  the outside world — checking what's happening, reading and writing threads,
-  and collaborating with others.
-  Use when the user wants to interact with Gobi spaces, vaults, brains, threads,
-  sessions, or brain updates.
+  Core Gobi CLI: authentication (login/logout/status), vault initialization
+  (gobi init), space selection (gobi space warp/list), file sync (gobi sync),
+  CLI updates (gobi update), and session management (list/get/reply to
+  conversations). Use when the user needs to set up Gobi, authenticate,
+  sync files, manage sessions, or update the CLI.
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "{{VERSION}}"
+  version: "0.8.0"
 ---
 
-# gobi-cli
+# gobi-core
 
-A CLI client for the Gobi collaborative knowledge platform (v{{VERSION}}).
+Core CLI commands for the Gobi collaborative knowledge platform (v0.8.0).
 
 ## Prerequisites
 
@@ -89,74 +88,39 @@ gobi auth status
 
 **Important for agents**: Before running any `space` command, check if `.gobi/settings.yaml` exists in the current directory with both `vaultSlug` and `selectedSpaceSlug`. If the vault is missing, guide the user through `gobi init`. If only the space is missing, guide the user through `gobi space warp`. These commands require user input (interactive prompts), so the agent cannot run them silently.
 
-## Gobi Space — Community Channel
-
-`gobi space` is the main interface for interacting with the user's Gobi community. When the user asks about what's happening, what others are discussing, or wants to engage with their community — use `gobi space` commands. Think of it as the user's community feed and communication hub.
-
-- When the user wants to explore or catch up on what's happening in their space, invoke `/gobi:space-explore`.
-- When the user wants to share or post learnings from the current session, invoke `/gobi:space-share`.
-
-## Gobi Brain — Knowledge Management
-
-`gobi brain` commands manage your vault's brain: search across all spaces, ask brains questions, and publish/unpublish your BRAIN.md. Public brains are accessible at `https://gobispace.com/@{vaultSlug}`.
-
-## Gobi Session — Conversations
-
-`gobi session` commands manage your conversations: list, read, and reply to sessions.
-
 ## Important: JSON Mode
 
 For programmatic/agent usage, always pass `--json` as a **global** option (before the subcommand) to get structured JSON output:
 
-```bash
-gobi --json space list-threads
-```
-
-or
-
 ```bash
 gobi --json session list
 ```
 
 JSON responses have the shape `{ "success": true, "data": ... }` on success or `{ "success": false, "error": "..." }` on failure.
 
-## Space Slug Override
-
-`gobi space` commands use the space from `.gobi/settings.yaml`. Override it with a parent-level flag:
-
-```bash
-gobi space --space-slug <slug> list-threads
-```
-
-For `gobi brain list-updates`, you can filter by space with a subcommand option:
-
-```bash
-gobi brain list-updates --space-slug <slug>
-```
-
-Note: `--space-slug` is not available on other `brain` subcommands or on `session` commands.
-
 ## Available Commands
 
-{{COMMANDS}}
+- `gobi auth` — Authentication commands.
+  - `gobi auth login` — Log in to Gobi. Opens a browser URL for Google OAuth, then polls until authentication is complete.
+  - `gobi auth status` — Check whether you are currently authenticated with Gobi.
+  - `gobi auth logout` — Log out of Gobi and remove stored credentials.
+- `gobi init` — Log in (if needed) and select or create the vault for the current directory.
+- `gobi space list` — List spaces you are a member of.
+- `gobi space warp` — Select the active space. Pass a slug to warp directly, or omit for interactive selection.
+- `gobi session` — Session commands (get, list, reply).
+  - `gobi session get` — Get a session and its messages (paginated).
+  - `gobi session list` — List all sessions you are part of, sorted by most recent activity.
+  - `gobi session reply` — Send a human reply to a session you are a member of.
+- `gobi sync` — Sync local vault files with Gobi Webdrive.
+- `gobi update` — Update gobi-cli to the latest version.
 
 ## Reference Documentation
 
-{{REFERENCE_TOC}}
-
-## Discovering Options
-
-Run `--help` on any command for details:
-
-```bash
-gobi --help
-gobi auth --help
-gobi space --help
-gobi brain --help
-gobi session --help
-gobi sense --help
-gobi sync --help
-```
+- [gobi auth](references/auth.md)
+- [gobi init](references/init.md)
+- [gobi session](references/session.md)
+- [gobi sync](references/sync.md)
+- [gobi update](references/update.md)
 
 ## Configuration Files