@wji.ai/cli 0.1.0 → 0.2.0

package/README.md

@@ -165,7 +165,9 @@ wji canvas gen <node> --yes --wait                  # spends credits
 ```
 
 Changes appear live in the open canvas. Pass `--canvas <id>` to work on a
-canvas that is not linked (`wji canvas list`).
+canvas that is not linked (`wji canvas list`); `wji canvas create <name>` adds
+an empty canvas, `wji canvas add image --asset <id>` shows an existing asset
+and `wji canvas add dataset --dataset <id>` places a dataset card.
 
 ## Skills
 
@@ -240,3 +242,10 @@ cp -r "$(npm root -g)/@wji.ai/cli/skill/wji" ~/.claude/skills/wji
 
 From a source checkout: `cp -r skill/wji ~/.claude/skills/wji`. Re-copy after
 upgrading the CLI so the skill matches the commands.
+
+`skill/short-drama/` is a second skill built on top of it: an AI short-drama
+pipeline (outline → characters → scenes/props → script → storyboard) whose
+stages are checked by `skill/short-drama/scripts/short-drama.mjs validate`,
+with the data stored as workspace datasets and the work laid out on canvases.
+Install it the same way (`cp -r skill/short-drama ~/.claude/skills/short-drama`)
+next to `wji`; `node skill/short-drama/scripts/selftest.mjs` runs its self-test.

package/dist/commands/canvas.js

@@ -23,7 +23,8 @@ const NODE_PREFIX = 'canvas/node/';
 const EDGE_MIMETYPE = 'canvas/edge';
 const CANVAS_MIMETYPE = 'workspace-v2/canvas';
 const CANVASES_MIMETYPE = 'workspace-v2/canvases';
-const CREATABLE_KINDS = ['text', 'title', 'comment', 'image', 'video', 'audio'];
+const DATASET_MIMETYPE = 'workspace/dataset';
+const CREATABLE_KINDS = ['text', 'title', 'comment', 'image', 'video', 'audio', 'dataset'];
 const MEDIA_KINDS = new Set(['image', 'video', 'audio']);
 const TEXT_KINDS = new Set(['text', 'title', 'comment']);
 /** Default names the canvas UI shows localized. */
@@ -34,6 +35,12 @@ const DEFAULT_NAMES = {
     image: '图片',
     video: '视频',
     audio: '音频',
+    dataset: '数据集',
+};
+/** What the web writes into a brand-new canvas folder (CanvasAppFileSystem.createCanvas). */
+const INITIAL_CANVAS_CONTENT = {
+    data: { viewport: { x: 0, y: 0, zoom: 1 }, backgroundMode: 'dots' },
+    metadata: {},
 };
 /** The canvas lays media out on a 250px short side; text nodes are wider. */
 const MEDIA_BASE = 250;
@@ -105,6 +112,19 @@ async function loadCanvas(client, canvasId) {
         assets,
     };
 }
+/** The `canvases` folder of every InfiniteCanvas app in a workspace. */
+async function canvasesFolders(client, wsId) {
+    const ws = await client.get(`/workspace/list/${wsId}`);
+    const apps = (ws.apps || []).filter((a) => a.app === 'InfiniteCanvas' || a.type === 'INFINITE_CANVAS');
+    const out = [];
+    for (const app of apps) {
+        const tree = await client.get(`/workspace/list/${wsId}/fs/${app.id}`);
+        const folder = (tree?.children || []).find((n) => n.mimetype === CANVASES_MIMETYPE);
+        if (folder)
+            out.push({ appId: String(app.id), folderId: String(folder.id) });
+    }
+    return out;
+}
 function requireNode(canvas, id) {
     const node = canvas.byId.get(id);
     if (!node)
@@ -144,6 +164,9 @@ function describe(canvas, node) {
         assetId: node.file,
         url: asset?.url || undefined,
         assetType: asset?.type,
+        dataset: node.kind === 'dataset' && node.content.datasetId
+            ? { id: String(node.content.datasetId), name: node.content.datasetName, type: node.content.datasetType, folder: node.content.datasetParentName }
+            : undefined,
         status: generate?.historyId ? (pending ? 'generating' : asset?.error ? 'failed' : asset?.url ? 'done' : 'pending') : undefined,
         error: asset?.error?.message || asset?.error || undefined,
         generate,
@@ -152,12 +175,16 @@ function describe(canvas, node) {
     };
 }
 // ── models ──────────────────────────────────────────────────────────────────
+/** An audio node is fed by either an `audio` or a `tts` model — the backend tags voice models `tts`. */
+const KIND_FEATURES = { audio: ['audio', 'tts'] };
 async function findModel(client, kind, name, workspaceId) {
-    const rows = await fetchModels(client, { features: [kind], workspace: workspaceId });
+    const features = KIND_FEATURES[kind] ?? [kind];
+    const rows = (await Promise.all(features.map((f) => fetchModels(client, { features: [f], workspace: workspaceId })))).flat();
     const usable = rows.filter((m) => m.enabled !== false);
     const model = usable.find((m) => m.nickname === name) ?? usable.find((m) => m.name === name);
     if (!model) {
-        throw new Error(`No ${kind} model "${name}". See \`wji models list --feature ${kind}\`.`);
+        const hint = features.map((f) => `--feature ${f}`).join(' / ');
+        throw new Error(`No ${kind} model "${name}". See \`wji models list ${hint}\`.`);
     }
     return model;
 }
@@ -243,6 +270,8 @@ function applyModelDefaults(model, kind, generate, opts) {
 // ── writes ──────────────────────────────────────────────────────────────────
 /** Short side 250, like the canvas; text-ish nodes use a typical card size. */
 function estimateSize(canvas, node) {
+    if (node.kind === 'dataset')
+        return { width: 480, height: 220 };
     if (!MEDIA_KINDS.has(node.kind))
         return { width: 320, height: 200 };
     const ratioText = node.content.mode === 'generate' ? node.content.generate?.ratio : undefined;
@@ -335,6 +364,8 @@ async function patchNode(client, node, body) {
 function summary(n) {
     if (n.text !== undefined)
         return String(n.text).replace(/\s+/g, ' ');
+    if (n.dataset)
+        return [n.dataset.type, n.dataset.name, color.dim(n.dataset.id)].filter(Boolean).join(' ');
     if (n.mode === 'generate') {
         const g = n.generate || {};
         const state = n.status === 'done' ? color.green('done') : n.status === 'failed' ? color.red('failed') : n.status ? color.yellow(n.status) : '';
@@ -361,6 +392,7 @@ function printNode(n) {
         ['name', n.name],
         ['position', n.position && `${Math.round(n.position.x)},${Math.round(n.position.y)}`],
         ['text', n.text],
+        ['dataset', n.dataset && `${n.dataset.type || 'dataset'} "${n.dataset.name || ''}" ${color.dim(n.dataset.id)}${n.dataset.folder ? ` in ${n.dataset.folder}` : ''}`],
         ['asset', n.assetId],
         ['url', n.url],
         ['status', n.status],
@@ -603,17 +635,11 @@ export function canvasCommand(globals) {
         const c = client();
         const linked = opts.workspace ? null : await linkedState(c);
         const wsId = opts.workspace || linked?.workspaceId || c.requireWorkspace();
-        const ws = await c.get(`/workspace/list/${wsId}`);
-        const apps = (ws.apps || []).filter((a) => a.app === 'InfiniteCanvas' || a.type === 'INFINITE_CANVAS');
         const rows = [];
-        for (const app of apps) {
-            const tree = await c.get(`/workspace/list/${wsId}/fs/${app.id}`);
-            const folder = (tree?.children || []).find((n) => n.mimetype === CANVASES_MIMETYPE);
-            if (!folder)
-                continue;
-            const canvases = toList(await c.getFresh(`/fsnode/list/${folder.id}/children`, { limit: -1 }));
+        for (const { appId, folderId } of await canvasesFolders(c, wsId)) {
+            const canvases = toList(await c.getFresh(`/fsnode/list/${folderId}/children`, { limit: -1 }));
             for (const it of canvases.filter((n) => n.mimetype === CANVAS_MIMETYPE)) {
-                rows.push({ id: it.id, name: it.name, app: app.id, linked: it.id === linked?.canvasId, updatedAt: it.updatedAt });
+                rows.push({ id: it.id, name: it.name, app: appId, linked: it.id === linked?.canvasId, updatedAt: it.updatedAt });
             }
         }
         render(rows, () => table(rows, [
@@ -623,6 +649,36 @@ export function canvasCommand(globals) {
             { header: 'app', value: (r) => r.app },
         ]));
     });
+    canvas
+        .command('create <name>')
+        .description('Create an empty canvas in a workspace (its InfiniteCanvas app)')
+        .option('-w, --workspace <id>', 'workspace (defaults to the linked one, then the profile default)')
+        .option('--app <appId>', 'InfiniteCanvas app when the workspace has several')
+        .action(async (name, opts) => {
+        const c = client();
+        const linked = opts.workspace ? null : await linkedState(c);
+        const wsId = opts.workspace || linked?.workspaceId || c.requireWorkspace();
+        const folders = await canvasesFolders(c, wsId);
+        if (!folders.length)
+            throw new Error(`Workspace ${wsId} has no InfiniteCanvas app. Add one with \`wji ws app add canvas\`.`);
+        const target = opts.app ? folders.find((f) => f.appId === opts.app) : folders[0];
+        if (!target)
+            throw new Error(`No InfiniteCanvas app ${opts.app} in workspace ${wsId}`);
+        if (!opts.app && folders.length > 1)
+            warn(`Several InfiniteCanvas apps — using ${target.appId}; pass --app to choose`);
+        const raw = await c.post('/fsnode/create', {
+            name,
+            type: 'folder',
+            mimetype: CANVAS_MIMETYPE,
+            parent: target.folderId,
+            content: INITIAL_CANVAS_CONTENT,
+        });
+        const out = { id: raw.id, name: raw.name, app: target.appId, workspaceId: wsId };
+        render(out, () => {
+            success(`Created canvas "${out.name}" ${color.dim(out.id)}`);
+            info(color.dim(`Target it with --canvas ${out.id}, or open it in the browser and press link.`));
+        });
+    });
     canvas
         .command('nodes')
         .description('Nodes with references and a content summary (* = generate node)')
@@ -671,6 +727,7 @@ export function canvasCommand(globals) {
         .option('-t, --text <text>', 'text for text/title/comment (- reads stdin)')
         .option('--text-file <path>', 'read the text from a file')
         .option('--asset <assetId>', 'show an existing asset (display node)')
+        .option('--dataset <fsnodeId>', 'for `add dataset`: the workspace dataset node to show on the canvas')
         .option('--from <nodeIds...>', 'connect these nodes in as references, in order (@image1, @image2…)')
         .option('--at <x,y>', 'position; default is right of the --from nodes')).action(async (kind, opts) => {
         if (!CREATABLE_KINDS.includes(kind)) {
@@ -694,6 +751,28 @@ export function canvasCommand(globals) {
                 throw new Error(`${kind} nodes need --text`);
             content.text = text;
         }
+        else if (kind === 'dataset') {
+            // A dataset node is a card bound to a workspace dataset (CanvasAppFileSystem.createDatasetNodeFromDataset).
+            if (!opts.dataset)
+                throw new Error('dataset nodes need --dataset <fsnodeId>');
+            if (from.length)
+                throw new Error('dataset nodes take no references; connect them out to a generate node instead');
+            const ds = await c.getFresh(`/fsnode/list/${opts.dataset}`);
+            if (ds?.mimetype !== DATASET_MIMETYPE) {
+                throw new Error(`${opts.dataset} is not a dataset (mimetype ${ds?.mimetype || 'none'})`);
+            }
+            const parent = ds.parent ? await c.get(`/fsnode/list/${idOf(ds.parent)}`).catch(() => null) : null;
+            const dsName = ds.nickname || ds.name || DEFAULT_NAMES.dataset;
+            if (!opts.name)
+                body.name = dsName;
+            Object.assign(content, {
+                datasetId: String(ds.id),
+                datasetName: dsName,
+                datasetType: String(ds.content?.type || ''),
+                datasetParentName: parent ? parent.nickname || parent.name || '' : '',
+                description: String(ds.content?.description || ''),
+            });
+        }
         else {
             const { patch, explicit } = await generateOptions(opts);
             const wantsGenerate = Object.keys(patch).length > 0;

package/dist/commands/fsnode.js

@@ -3,6 +3,15 @@ import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
 import { color, detail, info, relativeTime, render, success, table, truncate } from '../core/output.js';
 import { printTree } from './workspace.js';
+/** Nested plain objects merge; arrays and scalars are replaced. */
+function deepMerge(base, patch) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        const isObject = (v) => v && typeof v === 'object' && !Array.isArray(v);
+        out[key] = isObject(value) && isObject(out[key]) ? deepMerge(out[key], value) : value;
+    }
+    return out;
+}
 export function fsCommand(globals) {
     const fs = new Command('fs')
         .aliases(['fsnode'])
@@ -106,7 +115,9 @@ export function fsCommand(globals) {
         .option('--icon <assetId>', 'set the icon asset')
         .option('--asset <assetId>', 'set the attached file asset (use "null" to clear)')
         .option('--sort <n>', 'sort order')
-        .option('--set <key=value...>', 'arbitrary field, dotted keys allowed')
+        .option('--set <key=value...>', 'arbitrary top-level field, dotted keys allowed (content.* would REPLACE content — use --merge)')
+        .option('--merge <key=value...>', 'set fields inside content, merged with the current content; values accept @file')
+        .option('--add-images <assetId...>', 'append to the image asset list instead of replacing it')
         .action(async (id, opts) => {
         const client = new WjiClient(globals());
         const body = {
@@ -120,6 +131,24 @@ export function fsCommand(globals) {
             sort: opts.sort != null ? Number(opts.sort) : undefined,
             ...parseKeyValues(opts.set),
         };
+        if (opts.merge?.length || opts.addImages?.length) {
+            // PATCH replaces `content` and `images` whole, so read first and merge.
+            const node = await client.getFresh(`/fsnode/list/${id}`);
+            if (opts.merge?.length) {
+                const pairs = [];
+                for (const pair of opts.merge) {
+                    const index = pair.indexOf('=');
+                    if (index === -1)
+                        throw new Error(`Expected key=value, got "${pair}"`);
+                    pairs.push(`${pair.slice(0, index)}=${await readValue(pair.slice(index + 1))}`);
+                }
+                body.content = deepMerge(body.content ?? node.content ?? {}, parseKeyValues(pairs));
+            }
+            if (opts.addImages?.length) {
+                const current = (opts.images ?? node.images ?? []).map((it) => (typeof it === 'string' ? it : it.id));
+                body.images = [...current, ...opts.addImages.filter((it) => !current.includes(it))];
+            }
+        }
         const updated = await client.patch(`/fsnode/list/${id}`, body);
         render(updated, (n) => success(`Updated ${n?.id || id}`));
     });

package/dist/commands/gen.js

@@ -2,7 +2,6 @@ import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
 import { color, detail, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
-const PENDING = 0;
 const READY = 1;
 const CANCELLED = -1;
 /** `--ref abc123`, `--ref abc123:hero`, `--ref abc123:hero:0.6` */
@@ -81,22 +80,9 @@ export function reportHistory(history, assets) {
     ]);
 }
 async function submit(client, kind, body, opts) {
-    const path = opts.history
-        ? `/ai/assets/history/${kind}/generations`
-        : `/ai/assets/${kind}/generations`;
-    const result = await client.post(path, body);
-    if (!opts.history) {
-        // Raw mode returns Asset[] directly; there is no history to poll.
-        return render(result, (assets) => {
-            if (!Array.isArray(assets))
-                return detail(Object.entries(assets || {}));
-            table(assets, [
-                { header: 'assetId', value: (a) => a.id },
-                { header: 'state', value: (a) => (a.status === PENDING ? 'pending' : 'ready') },
-                { header: 'url', value: (a) => a.url },
-            ]);
-        });
-    }
+    // Always the history endpoint: the raw one silently drops fsnode, scope,
+    // scopeId and tags, and returns no id to poll with.
+    const result = await client.post(`/ai/assets/history/${kind}/generations`, body);
     if (!opts.wait) {
         if (isJsonMode())
             return printJson(result);
@@ -121,14 +107,13 @@ function withCommonOptions(cmd) {
         .option('-p, --prompt <text>', 'prompt text (@file / - for stdin)')
         .option('-n, --n <count>', 'number of outputs', '1')
         .option('-w, --workspace <id>', 'workspace to bill and file the result under')
-        .option('--fsnode <id>', 'attach the result to an fsnode')
+        .option('--fsnode <id>', 'file the history entry under an fsnode (does not add the asset to its images)')
         .option('--scope <scope>', 'history scope, e.g. workspace | canvas')
         .option('--scope-id <id>', 'history scope id')
         .option('-r, --ratio <ratio>', 'aspect ratio, e.g. 16:9')
         .option('--tags <tag...>', 'tags for the history entry')
         .option('--values <json>', 'model-specific form values (@file / - supported)')
         .option('--set <key=value...>', 'model-specific form values as key=value')
-        .option('--no-history', 'call the raw endpoint and return assets instead of a history')
         .option('--wait', 'block until the task finishes')
         .option('--timeout <seconds>', 'wait timeout', '900')
         .option('--interval <seconds>', 'poll interval', '5');

package/dist/commands/workspace.js

@@ -16,6 +16,8 @@ const APPS = {
     batch: 'Batch',
     digitalhost: 'DigitalHost',
 };
+/** Apps every new workspace gets unless `-a` or `--no-apps` says otherwise — what the drama and canvas workflows need. */
+const DEFAULT_APPS = ['dataset', 'datasetimagegeneration', 'canvas'];
 const APP_TYPES = {
     Dataset: 'DATASET',
     DatasetImageGeneration: 'DATASET_IMAGE_GENERATION',
@@ -103,10 +105,12 @@ export function workspaceCommand(globals) {
         .option('-r, --aspect-ratio <ratio>', '16:9 | 9:16 | 21:9', '16:9')
         .option('-l, --language <lang>', 'dialogue language', 'auto')
         .option('-t, --type <type>', 'workspaceType')
-        .option('-a, --app <app...>', 'apps to create, e.g. dataset files canvas')
+        .option('-a, --app <app...>', `apps to create (default: ${DEFAULT_APPS.join(' ')})`)
+        .option('--no-apps', 'create an empty workspace with no apps')
         .action(async (name, opts) => {
         const client = new WjiClient(globals());
-        const apps = (opts.app || []).map((token) => {
+        const tokens = opts.app?.length ? opts.app : opts.apps ? DEFAULT_APPS : [];
+        const apps = tokens.map((token) => {
             const { app, type } = resolveApp(token);
             return { app, type, name: app };
         });

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { ApiError } from './core/client.js';
 import { color, setJsonMode } from './core/output.js';
@@ -15,7 +16,9 @@ import { profileCommand } from './commands/profile.js';
 import { presetCommand } from './commands/preset.js';
 import { skillCommand } from './commands/skill.js';
 import { canvasCommand } from './commands/canvas.js';
-const VERSION = '0.1.0';
+// Read from package.json so `wji --version` cannot drift from the published
+// version — the skill compares the two to detect a stale install.
+const VERSION = createRequire(import.meta.url)('../package.json').version;
 const program = new Command();
 program
     .name('wji')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wji.ai/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Command line interface for the WJI AI platform",
   "license": "UNLICENSED",
   "author": "WJI AI",