@wji.ai/cli 0.6.1 → 0.7.1

package/dist/commands/npc.js

@@ -1,413 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { Command } from 'commander';
-import { isObjectId, WjiClient } from '../core/client.js';
-import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
-import { color, detail, info, isJsonMode, printJson, render, relativeTime, success, table, truncate, warn } from '../core/output.js';
-import { NPC_JOB_TYPES, NPC_STATUSES, NPC_VISIBILITIES, RESIDENTS, npcLabel, parseJob, parsePositions, resolveNpc, updateJobs, } from '../core/npc.js';
-const TRANSFERS = '/npc-city/transfers';
-export function npcCommand(globals) {
-    const npc = new Command('npc')
-        .aliases(['npc-city'])
-        .description('Manage your NPC City residents (NPCs): profile, jobs, soul, character doc, transfers');
-    // ── residents ──────────────────────────────────────────────────────────
-    npc
-        .command('list', { isDefault: true })
-        .description('Your NPCs (org NPCs with --org); --public for the public directory')
-        .option('--public', 'list the public directory instead of yours')
-        .option('-k, --keyword <text>', 'search text')
-        .option('--status <status>', NPC_STATUSES.join(' | '))
-        .option('--visibility <v>', NPC_VISIBILITIES.join(' | '))
-        .option('--page <n>', 'page number', '1')
-        .option('--limit <n>', 'page size', '20')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get(opts.public ? RESIDENTS : `${RESIDENTS}/mine`, {
-            keyword: opts.keyword,
-            status: opts.status,
-            visibility: opts.visibility,
-            page: Number(opts.page),
-            limit: Number(opts.limit),
-        });
-        render(result, (r) => {
-            table(r?.data || [], [
-                { header: 'id', value: (n) => n.id },
-                { header: 'name', value: (n) => truncate(n.name, 20) },
-                { header: 'handle', value: (n) => n.handle },
-                { header: 'role', value: (n) => truncate(n.role, 16) },
-                { header: 'genre', value: (n) => truncate(n.genre, 16) },
-                { header: 'status', value: (n) => n.status },
-                { header: 'vis', value: (n) => n.visibility },
-                { header: 'jobs', value: (n) => (n.jobs || []).length },
-                { header: 'updated', value: (n) => relativeTime(n.updatedAt) },
-            ]);
-            pageFooter(r);
-        });
-    });
-    npc
-        .command('get <npc>')
-        .description('Show an NPC and its jobs (id, @handle or name)')
-        .action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        render(r, () => printNpc(r));
-    });
-    residentOptions(npc
-        .command('create <name>')
-        .description('Create an NPC (private until you publish it). Needs NPC City spawn permission.')
-        .requiredOption('--role <role>', 'role, e.g. Singer')
-        .requiredOption('--genre <genre>', 'genre, e.g. City pop')).action(async (name, opts) => {
-        const client = new WjiClient(globals());
-        const body = await residentBody(client, opts);
-        if (body.handle)
-            await assertHandle(client, body.handle);
-        const created = await client.post(RESIDENTS, { name, ...body });
-        render(created, (r) => success(`Created ${npcLabel(r)} — ${r.id} (${r.visibility})`));
-    });
-    residentOptions(npc
-        .command('set <npc>')
-        .description('Update NPC fields; only the flags you pass change')
-        .option('-n, --name <name>', 'rename')
-        .option('--role <role>', 'role')
-        .option('--genre <genre>', 'genre')).action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const current = await resolveNpc(client, token);
-        const body = await residentBody(client, opts, current);
-        if (opts.name)
-            body.name = opts.name;
-        if (!Object.keys(body).length)
-            throw new Error('Nothing to change — pass at least one field flag');
-        if (body.handle)
-            await assertHandle(client, body.handle, current.id);
-        const updated = await client.patch(`${RESIDENTS}/${current.id}`, body);
-        render(updated, (r) => success(`Updated ${npcLabel(r)}: ${Object.keys(body).join(', ')}`));
-    });
-    for (const [cmd, visibility] of [['publish', 'public'], ['unpublish', 'private']]) {
-        npc
-            .command(`${cmd} <npc>`)
-            .description(`Make an NPC ${visibility}`)
-            .action(async (token) => {
-            const client = new WjiClient(globals());
-            const r = await resolveNpc(client, token);
-            const updated = await client.patch(`${RESIDENTS}/${r.id}`, { visibility });
-            render(updated, (u) => success(`${npcLabel(u)} is now ${u.visibility}`));
-        });
-    }
-    npc
-        .command('rm <npc>')
-        .description('Delete an NPC')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        if (!(await confirm(`Delete NPC ${npcLabel(r)} (${r.id})?`, opts.yes)))
-            return info('Aborted');
-        const result = await client.delete(`${RESIDENTS}/${r.id}`);
-        render(result, () => success(`Deleted ${npcLabel(r)}`));
-    });
-    npc
-        .command('handle <handle>')
-        .description('Check whether a @handle is free')
-        .option('--exclude <npc>', "ignore this NPC's own handle")
-        .action(async (handle, opts) => {
-        const client = new WjiClient(globals());
-        const excludeId = opts.exclude ? (await resolveNpc(client, opts.exclude)).id : undefined;
-        const result = await client.get(`${RESIDENTS}/handle-available`, { handle, excludeId });
-        render(result, (r) => r.available ? success(`${r.handle} is available`) : warn(`${r.handle} is not available (${r.reason})`));
-    });
-    // ── jobs (work history) ────────────────────────────────────────────────
-    const job = npc.command('job').aliases(['jobs']).description("An NPC's work history: concerts, releases, ads…");
-    job
-        .command('list <npc>', { isDefault: true })
-        .description('Numbered work history')
-        .action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        render(r.jobs || [], (jobs) => printJobs(jobs));
-    });
-    jobOptions(job
-        .command('add <npc>')
-        .description('Add a job')
-        .requiredOption('-t, --type <type>', NPC_JOB_TYPES.join(' | '))
-        .requiredOption('--title <text>', 'title')
-        .requiredOption('--date <YYYY-MM-DD>', 'date')).action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const entry = parseJob(opts);
-        const updated = await updateJobs(client, r.id, (jobs) => [...jobs, entry]);
-        render(updated.jobs, () => success(`Added "${entry.title}" to ${npcLabel(r)} (#${updated.jobs.length})`));
-    });
-    jobOptions(job
-        .command('set <npc> <n>')
-        .description('Change job #n (see `npc job list`)')
-        .option('-t, --type <type>', NPC_JOB_TYPES.join(' | '))
-        .option('--title <text>', 'title')
-        .option('--date <YYYY-MM-DD>', 'date')).action(async (token, n, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const updated = await updateJobs(client, r.id, (jobs) => {
-            const [i] = parsePositions([n], jobs.length);
-            jobs[i] = parseJob(opts, jobs[i]);
-            return jobs;
-        });
-        render(updated.jobs, () => success(`Updated job #${n} of ${npcLabel(r)}`));
-    });
-    job
-        .command('rm <npc> <n...>')
-        .description('Remove jobs by number')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, ns, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const positions = parsePositions(ns, (r.jobs || []).length);
-        const titles = positions.map((i) => `#${i + 1} ${r.jobs[i].title}`).join(', ');
-        if (!(await confirm(`Remove ${titles} from ${npcLabel(r)}?`, opts.yes)))
-            return info('Aborted');
-        // Re-check against a fresh read so a concurrent edit can't shift the numbers.
-        const updated = await updateJobs(client, r.id, (jobs) => {
-            if (JSON.stringify(jobs) !== JSON.stringify(r.jobs)) {
-                throw new Error('The job list changed since it was read — list it again and retry');
-            }
-            return jobs.filter((_, i) => !positions.includes(i));
-        });
-        render(updated.jobs, () => success(`Removed ${positions.length} job(s); ${updated.jobs.length} left`));
-    });
-    // ── soul ───────────────────────────────────────────────────────────────
-    const soul = npc.command('soul').description("An NPC's soul config (persona, protocols, voice, assets)");
-    soul
-        .command('get <npc>', { isDefault: true })
-        .description('Print the soul config as JSON')
-        .action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        printJson(await client.getFresh(`${RESIDENTS}/${r.id}/soul`));
-    });
-    soul
-        .command('set <npc> <json>')
-        .description('Merge top-level soul keys (inline JSON, @file or -); nested objects are replaced whole')
-        .action(async (token, json) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const soulConfig = await readJson(json);
-        if (!soulConfig || typeof soulConfig !== 'object' || Array.isArray(soulConfig)) {
-            throw new Error('Soul config must be a JSON object');
-        }
-        const updated = await client.patch(`${RESIDENTS}/${r.id}/soul`, { soulConfig });
-        render(updated, () => success(`Updated soul of ${npcLabel(r)}: ${Object.keys(soulConfig).join(', ')}`));
-    });
-    // ── character document ────────────────────────────────────────────────
-    const doc = npc.command('doc').description('Export / apply the character document (profile + soul in one file)');
-    doc
-        .command('export <npc>')
-        .description('Print or save the character document')
-        .option('--format <format>', 'md | json', 'md')
-        .option('-o, --out <file>', 'write to a file instead of stdout')
-        .action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const result = await client.getFresh(`${RESIDENTS}/${r.id}/document`, { format: opts.format });
-        if (opts.out) {
-            await writeFile(opts.out, result.text);
-            return render({ file: opts.out, format: result.format }, () => success(`Wrote ${opts.out}`));
-        }
-        render(result, () => process.stdout.write(result.text.endsWith('\n') ? result.text : `${result.text}\n`));
-    });
-    doc
-        .command('apply <npc> <text>')
-        .description('Preview the changes a document makes (@file or -), confirm, then apply')
-        .option('--dry-run', 'only show the changes')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, source, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const text = await readValue(source);
-        const base = `${RESIDENTS}/${r.id}/document`;
-        const preview = await client.post(`${base}/preview`, { text });
-        const changes = preview.changes || [];
-        if (opts.dryRun || !changes.length) {
-            return render(preview, () => {
-                printChanges(changes, preview.warnings);
-                if (!changes.length)
-                    info('Nothing to apply');
-            });
-        }
-        if (!isJsonMode())
-            printChanges(changes, preview.warnings);
-        if (!(await confirm(`Apply ${changes.length} change(s) to ${npcLabel(r)}?`, opts.yes)))
-            return info('Aborted');
-        const applied = await client.post(base, { text });
-        render(applied, (a) => {
-            for (const w of a.warnings || [])
-                warn(w);
-            success(`Applied ${(a.applied || []).length} change(s) to ${npcLabel(r)}`);
-        });
-    });
-    // ── transfers ─────────────────────────────────────────────────────────
-    const transfer = npc
-        .command('transfer')
-        .description('Hand an NPC to another user; they accept within 7 days');
-    transfer
-        .command('send <npc>')
-        .description('Offer an NPC to another user')
-        .requiredOption('--to <user>', 'recipient email or user id')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        if (!(await confirm(`Offer ${npcLabel(r)} to ${opts.to}? You lose it once they accept.`, opts.yes))) {
-            return info('Aborted');
-        }
-        const target = isObjectId(opts.to) ? { toUserId: opts.to } : { email: opts.to };
-        const result = await client.post(`${RESIDENTS}/${r.id}/transfer`, target);
-        render(result, (t) => success(`Transfer ${t.id} to ${t.toOwner?.name || opts.to} pending until ${t.expiresAt}`));
-    });
-    transfer
-        .command('list', { isDefault: true })
-        .description('Pending transfers, incoming and outgoing')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const [incoming, outgoing] = await Promise.all([
-            client.getFresh(`${TRANSFERS}/incoming`),
-            client.getFresh(`${TRANSFERS}/outgoing`),
-        ]);
-        const rows = [
-            ...(incoming || []).map((t) => ({ ...t, direction: 'in' })),
-            ...(outgoing || []).map((t) => ({ ...t, direction: 'out' })),
-        ];
-        render(rows, () => table(rows, [
-            { header: 'id', value: (t) => t.id },
-            { header: 'dir', value: (t) => t.direction },
-            { header: 'npc', value: (t) => (t.resident ? npcLabel(t.resident) : null) },
-            { header: 'from', value: (t) => t.fromOwner?.name },
-            { header: 'to', value: (t) => t.toOwner?.name },
-            { header: 'expires', value: (t) => relativeTime(t.expiresAt) },
-        ]));
-    });
-    for (const action of ['accept', 'reject', 'cancel']) {
-        transfer
-            .command(`${action} <transferId>`)
-            .description(action === 'cancel' ? 'Withdraw a transfer you sent' : `${action[0].toUpperCase()}${action.slice(1)} a transfer sent to you`)
-            .action(async (id) => {
-            const client = new WjiClient(globals());
-            const result = await client.post(`${TRANSFERS}/${id}/${action}`);
-            render(result, (t) => success(`Transfer ${id}: ${t.status}${t.resident ? ` (${npcLabel(t.resident)})` : ''}`));
-        });
-    }
-    return npc;
-}
-// ── helpers ──────────────────────────────────────────────────────────────
-function residentOptions(cmd) {
-    return cmd
-        .option('--handle <handle>', '@handle (a-z 0-9 . _ -, 2–32)')
-        .option('--tagline <text>', 'one-line tagline')
-        .option('--bio <text>', 'bio (@file / - supported)')
-        .option('--image <url|assetId>', 'avatar image')
-        .option('--hero-image <url|assetId>', 'hero image')
-        .option('--color <hex>', 'accent color')
-        .option('--status <status>', NPC_STATUSES.join(' | '))
-        .option('--visibility <v>', NPC_VISIBILITIES.join(' | '))
-        .option('--social <key=url...>', 'ig / yt / tw / web')
-        .option('--tag <key=value...>', 'card tags: rating, type, role, gender, tier, language…')
-        .option('--set <key=value...>', 'any other field, e.g. liveEnabled=true');
-}
-function jobOptions(cmd) {
-    return cmd
-        .option('--detail <text>', 'what happened')
-        .option('--location <text>', 'where')
-        .option('--url <url>', 'link');
-}
-/** The resident fields a create / set carries, from flags. `current` merges socials / tags. */
-async function residentBody(client, opts, current) {
-    const body = {};
-    if (opts.role)
-        body.role = opts.role;
-    if (opts.genre)
-        body.genre = opts.genre;
-    if (opts.handle)
-        body.handle = opts.handle;
-    if (opts.tagline !== undefined)
-        body.tagline = opts.tagline;
-    if (opts.bio !== undefined)
-        body.bio = await readValue(opts.bio);
-    if (opts.image)
-        body.image = await imageUrl(client, opts.image);
-    if (opts.heroImage)
-        body.heroImage = await imageUrl(client, opts.heroImage);
-    if (opts.color)
-        body.color = opts.color;
-    if (opts.status)
-        body.status = oneOf(opts.status, NPC_STATUSES, '--status');
-    if (opts.visibility)
-        body.visibility = oneOf(opts.visibility, NPC_VISIBILITIES, '--visibility');
-    if (opts.social)
-        body.socials = { ...(current?.socials || {}), ...parseKeyValues(opts.social) };
-    if (opts.tag)
-        body.tags = { ...(current?.tags || {}), ...parseKeyValues(opts.tag) };
-    Object.assign(body, parseKeyValues(opts.set));
-    return body;
-}
-/** Residents store image URLs; an asset id is swapped for its ready URL. */
-async function imageUrl(client, value) {
-    if (!isObjectId(value))
-        return value;
-    const [asset] = await client.checkAssetStatus([value]);
-    if (!asset?.url)
-        throw new Error(`Asset ${value} has no URL yet (missing, not yours, or still pending)`);
-    return asset.url;
-}
-async function assertHandle(client, handle, excludeId) {
-    const r = await client.get(`${RESIDENTS}/handle-available`, { handle, excludeId });
-    if (!r.available)
-        throw new Error(`Handle ${r.handle || handle} is not available (${r.reason})`);
-}
-function oneOf(value, allowed, flag) {
-    if (!allowed.includes(value))
-        throw new Error(`${flag} must be one of ${allowed.join(', ')}`);
-    return value;
-}
-function pageFooter(r) {
-    const p = r?.pagination;
-    if (!p)
-        return;
-    info(color.dim(`${p.total} total · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
-}
-function printNpc(r) {
-    detail([
-        ['id', r.id],
-        ['name', r.name],
-        ['handle', r.handle],
-        ['role', r.role],
-        ['genre', r.genre],
-        ['status', r.status],
-        ['visibility', r.visibility],
-        ['tagline', r.tagline],
-        ['bio', truncate(r.bio, 120)],
-        ['image', r.image],
-        ['owner', r.owner?.name || r.owner],
-        ['organization', r.organization?.name || r.organization],
-        ['tags', r.tags && Object.keys(r.tags).length ? r.tags : null],
-        ['socials', r.socials && Object.keys(r.socials).length ? r.socials : null],
-        ['live', r.liveEnabled ? (r.livePublic ? 'enabled, public' : 'enabled') : null],
-        ['updated', relativeTime(r.updatedAt)],
-    ]);
-    process.stdout.write('\n');
-    printJobs(r.jobs || []);
-}
-function printJobs(jobs) {
-    table(jobs.map((j, i) => ({ ...j, n: i + 1 })), [
-        { header: '#', value: (j) => j.n },
-        { header: 'date', value: (j) => j.date },
-        { header: 'type', value: (j) => j.type },
-        { header: 'title', value: (j) => truncate(j.title, 32) },
-        { header: 'detail', value: (j) => truncate(j.detail, 32) },
-        { header: 'location', value: (j) => truncate(j.location, 20) },
-    ]);
-}
-function printChanges(changes, warnings = []) {
-    for (const w of warnings)
-        warn(w);
-    table(changes, [
-        { header: 'path', value: (c) => c.path },
-        { header: 'from', value: (c) => truncate(JSON.stringify(c.from ?? null), 40) },
-        { header: 'to', value: (c) => truncate(JSON.stringify(c.to ?? null), 40) },
-    ]);
-}

package/dist/commands/org.js

@@ -1,85 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { updateProfile } from '../core/config.js';
-import { color, detail, info, render, success, table } from '../core/output.js';
-/**
- * Organization context is a request header (X-Org-Id), not a login. Selecting
- * one here just stores it in the profile; every later call carries it.
- */
-export function orgCommand(globals) {
-    const org = new Command('org').description('Switch organization context (X-Org-Id)');
-    org
-        .command('list', { isDefault: true })
-        .description('List organizations you belong to')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const memberships = await client.get('/organization/mine');
-        render(memberships, (rows) => table(rows || [], [
-            {
-                header: '',
-                value: (m) => m.organization?.id === client.orgId ? color.green('*') : ' ',
-            },
-            { header: 'id', value: (m) => m.organization?.id },
-            { header: 'name', value: (m) => m.organization?.name },
-            { header: 'role', value: (m) => m.role },
-            { header: 'status', value: (m) => m.status },
-            { header: 'org status', value: (m) => m.organization?.status },
-        ]));
-    });
-    org
-        .command('use <orgId>')
-        .description('Make this organization the default context')
-        .action(async (orgId) => {
-        updateProfile(globals().profile, { orgId });
-        success(`Org context set to ${orgId}`);
-        info(color.dim('Use `wji org personal` to go back to your personal context.'));
-    });
-    org
-        .command('personal')
-        .description('Clear the organization context')
-        .action(() => {
-        updateProfile(globals().profile, { orgId: null });
-        success('Switched to personal context');
-    });
-    org
-        .command('current')
-        .description('Show the member record for the active org context')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        if (!client.orgId)
-            return info('Personal context (no organization)');
-        const me = await client.get('/organization/me');
-        render(me, (m) => detail([
-            ['org', m.organization?.name],
-            ['orgId', m.organization?.id],
-            ['role', m.role],
-            ['status', m.status],
-            ['monthlyLimit', m.monthlyLimit],
-            ['permanentLimit', m.permanentLimit],
-        ]));
-    });
-    org
-        .command('members')
-        .description('List members of the active org context')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const members = await client.get('/organization/members');
-        render(members, (rows) => table(rows || [], [
-            { header: 'id', value: (m) => m.id },
-            { header: 'user', value: (m) => m.user?.id },
-            { header: 'name', value: (m) => m.user?.name },
-            { header: 'email', value: (m) => m.user?.email },
-            { header: 'role', value: (m) => m.role },
-            { header: 'status', value: (m) => m.status },
-        ]));
-    });
-    org
-        .command('create <name>')
-        .description('Create an organization')
-        .action(async (name) => {
-        const client = new WjiClient(globals());
-        const created = await client.post('/organization/create', { name });
-        render(created, (o) => success(`Created organization ${o.name} (${o.id})`));
-    });
-    return org;
-}

package/dist/commands/preset.js

@@ -1,176 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { confirm, parseKeyValues, readValue } from '../core/prompt.js';
-import { color, detail, info, render, success, table, truncate } from '../core/output.js';
-const CATEGORIES = ['character', 'storyboard', 'multi_angle', 'composition', 'utility'];
-const SORTS = ['weight', 'popular', 'latest', 'updated'];
-export function presetCommand(globals) {
-    const preset = new Command('preset')
-        .aliases(['prompt'])
-        .description('Manage prompt presets');
-    const listOptions = (cmd) => cmd
-        .option('-k, --keyword <text>', 'search text')
-        .option('-t, --tag <tags>', 'comma-separated tags, all must match')
-        .option('-s, --sort <sort>', SORTS.join(' | '))
-        .option('--page <n>', 'page number', '1')
-        .option('--limit <n>', 'page size', '20');
-    const query = (client, opts, workspace) => ({
-        keyword: opts.keyword,
-        tag: opts.tag,
-        sortBy: opts.sort,
-        workspaceId: workspace,
-        page: Number(opts.page),
-        limit: Number(opts.limit),
-    });
-    listOptions(preset
-        .command('list', { isDefault: true })
-        .description('Presets you can use here (yours + public + workspace)')
-        .option('-w, --workspace <id>', 'include workspace presets')).action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get('/prompt-preset/search/usable', query(client, opts, client.workspace(opts.workspace)));
-        render(result, (r) => printPresets(r));
-    });
-    listOptions(preset.command('mine').description('Presets you created')).action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get('/prompt-preset/search/my', query(client, opts));
-        render(result, (r) => printPresets(r));
-    });
-    listOptions(preset.command('public').description('Public preset library')).action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get('/prompt-preset/search/public', query(client, opts));
-        render(result, (r) => printPresets(r));
-    });
-    listOptions(preset
-        .command('workspace [id]')
-        .description('Presets belonging to a workspace')).action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get('/prompt-preset/search/workspace', query(client, opts, client.requireWorkspace(id)));
-        render(result, (r) => printPresets(r));
-    });
-    preset
-        .command('get <id>')
-        .description('Show a preset with its full prompt')
-        .action(async (id) => {
-        const client = new WjiClient(globals());
-        const p = await client.get(`/prompt-preset/list/${id}`);
-        render(p, () => detail([
-            ['id', p.id],
-            ['name', p.name],
-            ['description', p.description],
-            ['category', p.category],
-            ['visibility', p.visibility],
-            ['tags', (p.tags || []).join(', ')],
-            ['workspace', p.workspace?.id || p.workspace],
-            ['forkedFrom', p.forkedFrom?.id || p.forkedFrom],
-            ['forkCount', p.forkCount],
-            ['prompt', p.prompt],
-        ]));
-    });
-    preset
-        .command('create <name>')
-        .description('Create a preset')
-        .requiredOption('-p, --prompt <text>', 'prompt body (@file / - supported)')
-        .option('-d, --description <text>', 'description')
-        .option('-c, --category <category>', CATEGORIES.join(' | '), 'utility')
-        .option('-t, --tag <tag...>', 'tags')
-        .option('--visibility <v>', 'private | public', 'private')
-        .option('-w, --workspace <id>', 'attach to a workspace')
-        .option('--set <key=value...>', 'arbitrary field')
-        .action(async (name, opts) => {
-        const client = new WjiClient(globals());
-        const created = await client.post('/prompt-preset/create', {
-            name,
-            prompt: await readValue(opts.prompt),
-            description: opts.description,
-            category: opts.category,
-            tags: opts.tag,
-            visibility: opts.visibility,
-            workspaceId: client.workspace(opts.workspace),
-            ...parseKeyValues(opts.set),
-        });
-        render(created, (p) => success(`Created preset ${p.name} (${p.id})`));
-    });
-    preset
-        .command('update <id>')
-        .description('Update a preset')
-        .option('-n, --name <name>', 'new name')
-        .option('-p, --prompt <text>', 'new prompt body (@file / - supported)')
-        .option('-d, --description <text>', 'new description')
-        .option('-c, --category <category>', CATEGORIES.join(' | '))
-        .option('-t, --tag <tag...>', 'replace tags')
-        .option('--visibility <v>', 'private | public')
-        .option('--set <key=value...>', 'arbitrary field')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        // The endpoint rebuilds every field from the body, so an omitted field
-        // arrives as undefined and is rejected. Merge onto the current preset to
-        // keep `update` partial from the caller's point of view.
-        const current = await client.getFresh(`/prompt-preset/list/${id}`);
-        const updated = await client.put(`/prompt-preset/list/${id}`, {
-            name: opts.name ?? current.name,
-            prompt: opts.prompt ? await readValue(opts.prompt) : current.prompt,
-            description: opts.description ?? current.description,
-            category: opts.category ?? current.category,
-            tags: opts.tag ?? current.tags,
-            visibility: opts.visibility ?? current.visibility,
-            ...parseKeyValues(opts.set),
-        });
-        render(updated, () => success(`Updated ${id}`));
-    });
-    preset
-        .command('rm <id>')
-        .description('Delete a preset')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        if (!(await confirm(`Delete preset ${id}?`, opts.yes)))
-            return info('Aborted');
-        const client = new WjiClient(globals());
-        const result = await client.delete(`/prompt-preset/list/${id}`);
-        render(result, () => success(`Deleted ${id}`));
-    });
-    preset
-        .command('fork <id>')
-        .description('Fork a preset into your own library')
-        .action(async (id) => {
-        const client = new WjiClient(globals());
-        const forked = await client.post(`/prompt-preset/fork/${id}`);
-        render(forked, (p) => success(`Forked to ${p.id}`));
-    });
-    preset
-        .command('copy <id> [workspaceId]')
-        .description('Copy a preset into a workspace')
-        .action(async (id, workspaceId) => {
-        const client = new WjiClient(globals());
-        const copied = await client.post(`/prompt-preset/copy-to-workspace/${id}`, {
-            workspaceId: client.requireWorkspace(workspaceId),
-        });
-        render(copied, (p) => success(`Copied to workspace as ${p.id}`));
-    });
-    preset
-        .command('tags')
-        .description('List preset tags in a scope')
-        .option('-s, --scope <scope>', 'my | public | workspace', 'public')
-        .option('-w, --workspace <id>', 'workspace when scope=workspace')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const tags = await client.get('/prompt-preset/tags', {
-            scope: opts.scope,
-            workspaceId: opts.scope === 'workspace' ? client.requireWorkspace(opts.workspace) : undefined,
-        });
-        render(tags, (rows) => rows.forEach((t) => process.stdout.write(`${t?.tag ?? t}\n`)));
-    });
-    return preset;
-}
-function printPresets(result) {
-    const rows = result?.data || result || [];
-    table(rows, [
-        { header: 'id', value: (p) => p.id },
-        { header: 'name', value: (p) => truncate(p.name, 28) },
-        { header: 'category', value: (p) => p.category },
-        { header: 'vis', value: (p) => p.visibility },
-        { header: 'tags', value: (p) => (p.tags || []).join(',') },
-        { header: 'prompt', value: (p) => truncate(p.prompt, 40) },
-    ]);
-    if (result?.pagination)
-        info(color.dim(`${result.pagination.total} total`));
-}