@wji.ai/cli 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,113 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { DEFAULT_ENDPOINT, configPath, getProfile, readConfig, updateProfile, writeConfig, } from '../core/config.js';
+import { confirm } from '../core/prompt.js';
+import { color, detail, info, render, success, table } from '../core/output.js';
+const REDACTED_KEYS = new Set(['accessToken', 'refreshToken', 'apiKey']);
+function redact(profile) {
+    const out = {};
+    for (const [k, v] of Object.entries(profile)) {
+        out[k] = REDACTED_KEYS.has(k) && typeof v === 'string' ? `${v.slice(0, 8)}…` : v;
+    }
+    return out;
+}
+export function configCommand(globals) {
+    const config = new Command('config').description('Manage CLI profiles and defaults');
+    config
+        .command('show', { isDefault: true })
+        .description('Show the active profile (secrets redacted)')
+        .action(() => {
+        const g = globals();
+        const { name, profile } = getProfile(g.profile);
+        const view = redact(profile);
+        // The endpoint is resolved at request time from flag > env > profile >
+        // built-in default, so show what will actually be used, not just what is
+        // stored — an unset profile would otherwise print nothing here.
+        const client = new WjiClient(g);
+        const effective = client.endpoint + (profile.endpoint ? '' : ` ${color.dim('(default)')}`);
+        render({ profile: name, path: configPath(), endpoint: client.endpoint, ...view }, () => {
+            detail([
+                ['profile', name],
+                ['file', configPath()],
+                ['endpoint', effective],
+                ...Object.entries(view).filter(([k]) => k !== 'endpoint'),
+                ['org', client.orgId || 'personal'],
+            ]);
+        });
+    });
+    config
+        .command('set <key> <value>')
+        .description('Set a profile field (endpoint, orgId, workspace, locale, apiKey)')
+        .action((key, value) => {
+        const allowed = ['endpoint', 'orgId', 'workspace', 'locale', 'apiKey', 'email', 'name'];
+        if (!allowed.includes(key)) {
+            throw new Error(`Unknown key "${key}". Allowed: ${allowed.join(', ')}`);
+        }
+        updateProfile(globals().profile, { [key]: value === 'null' ? null : value });
+        success(`${key} = ${value}`);
+    });
+    config
+        .command('unset <key>')
+        .description('Remove a profile field')
+        .action((key) => {
+        updateProfile(globals().profile, { [key]: undefined });
+        success(`Cleared ${key}`);
+    });
+    config
+        .command('profiles')
+        .description('List all profiles')
+        .action(() => {
+        const file = readConfig();
+        // Spread first: a profile's own `name` field is the account display name,
+        // which must not shadow the profile key.
+        const rows = Object.entries(file.profiles).map(([key, p]) => ({ ...p, key }));
+        render({ current: file.current, profiles: rows.map((r) => redact(r)) }, () => table(rows, [
+            { header: '', value: (r) => (r.key === file.current ? color.green('*') : ' ') },
+            { header: 'profile', value: (r) => r.key },
+            { header: 'endpoint', value: (r) => r.endpoint || `${DEFAULT_ENDPOINT} (default)` },
+            { header: 'account', value: (r) => r.email },
+            { header: 'org', value: (r) => r.orgId || 'personal' },
+        ]));
+    });
+    config
+        .command('use <profile>')
+        .description('Switch the active profile (creates it when new)')
+        .action((name) => {
+        const file = readConfig();
+        if (!file.profiles[name])
+            file.profiles[name] = {};
+        file.current = name;
+        writeConfig(file);
+        success(`Using profile ${name}`);
+    });
+    config
+        .command('rm <profile>')
+        .description('Delete a profile')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (name, opts) => {
+        const file = readConfig();
+        if (!file.profiles[name])
+            throw new Error(`No such profile: ${name}`);
+        const p = file.profiles[name];
+        // A profile is often the only copy of an sk_ secret — say so before it goes.
+        const holds = [p.apiKey && 'API key', p.refreshToken && 'login'].filter(Boolean).join(' and ');
+        const prompt = `Delete profile "${name}"${holds ? ` and the ${holds} stored in it` : ''}?`;
+        if (!(await confirm(prompt, opts.yes)))
+            return info('Aborted');
+        delete file.profiles[name];
+        if (file.current === name)
+            file.current = Object.keys(file.profiles)[0] || 'default';
+        if (!file.profiles[file.current])
+            file.profiles[file.current] = {};
+        writeConfig(file);
+        success(`Deleted profile ${name}`);
+        info(color.dim(`Active profile is now ${file.current}`));
+    });
+    config
+        .command('path')
+        .description('Print the config file path')
+        .action(() => {
+        process.stdout.write(configPath() + '\n');
+    });
+    return config;
+}

package/dist/commands/fsnode.js

@@ -0,0 +1,252 @@
+import { Command } from 'commander';
+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';
+export function fsCommand(globals) {
+    const fs = new Command('fs')
+        .aliases(['fsnode'])
+        .description('Browse and edit the fsnode tree (ideas, datasets, files)');
+    fs.command('root [key]')
+        .description('Get a root node (defaults to your personal drive; pass a workspace id for its root)')
+        .option('-d, --depth <n>', 'expand this many levels')
+        .action(async (key, opts) => {
+        const client = new WjiClient(globals());
+        const path = key ? `/fsnode/root/${key}` : '/fsnode/root';
+        const node = await client.get(path, opts.depth ? { depth: Number(opts.depth) } : undefined);
+        render(node, (n) => (opts.depth ? printTree(n) : printNode(n)));
+    });
+    fs.command('ls <id>')
+        .description('List child nodes')
+        .option('--limit <n>', 'page size')
+        .option('--scope <scope>', 'server-side scope filter')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.get(`/fsnode/list/${id}/children`, {
+            limit: opts.limit ? Number(opts.limit) : undefined,
+            scope: opts.scope,
+        });
+        const rows = Array.isArray(result) ? result : result?.data || [];
+        render(result, () => table(rows, [
+            { header: 'id', value: (n) => n.id },
+            { header: 'type', value: (n) => (n.type === 'folder' ? color.blue('dir') : 'file') },
+            { header: 'name', value: (n) => truncate(n.name, 32) },
+            { header: 'nickname', value: (n) => truncate(n.nickname, 24) },
+            { header: 'mimetype', value: (n) => n.mimetype },
+            { header: 'updated', value: (n) => relativeTime(n.updatedAt) },
+        ]));
+    });
+    fs.command('tree <id>')
+        .description('Print the subtree')
+        .option('-d, --depth <n>', 'levels to expand')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const node = await client.get(`/fsnode/list/${id}/tree`, opts.depth ? { depth: Number(opts.depth) } : undefined);
+        render(node, (n) => printTree(n));
+    });
+    fs.command('get <id>')
+        .description('Show one node (comma-separate ids for a batch)')
+        .option('--scope <scope>', 'server-side scope filter')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const node = await client.get(`/fsnode/list/${id}`, { scope: opts.scope });
+        render(node, (n) => (Array.isArray(n) ? n.forEach(printNode) : printNode(n)));
+    });
+    fs.command('path <id>')
+        .description('Print the ancestor chain from root to this node')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const nodes = await client.get(`/fsnode/list/${id}/path`);
+        render(nodes, (rows) => {
+            process.stdout.write(rows.map((n) => n.nickname || n.name).join(' / ') + '\n');
+            info(color.dim(rows.map((n) => n.id).join(' / ')));
+        });
+    });
+    fs.command('mkdir <parent> <name>')
+        .description('Create a folder')
+        .option('--nickname <text>', 'display name')
+        .option('--content <json>', 'content JSON, @file or - for stdin')
+        .action(async (parent, name, opts) => {
+        const client = new WjiClient(globals());
+        const created = await client.post('/fsnode/create', {
+            parent,
+            name,
+            type: 'folder',
+            nickname: opts.nickname,
+            content: await readJson(opts.content),
+        });
+        render(created, (n) => success(`Created folder ${n.name} (${n.id})`));
+    });
+    fs.command('touch <parent> <name>')
+        .description('Create a file node')
+        .option('--mimetype <type>', 'e.g. workspace/dataset')
+        .option('--nickname <text>', 'display name')
+        .option('--asset <assetId>', 'attach an asset as the file')
+        .option('--content <json>', 'content JSON, @file or - for stdin')
+        .action(async (parent, name, opts) => {
+        const client = new WjiClient(globals());
+        const created = await client.post('/fsnode/create', {
+            parent,
+            name,
+            type: 'file',
+            mimetype: opts.mimetype,
+            nickname: opts.nickname,
+            file: opts.asset,
+            content: await readJson(opts.content),
+        });
+        render(created, (n) => success(`Created file ${n.name} (${n.id})`));
+    });
+    fs.command('set <id>')
+        .description('Update a node')
+        .option('-n, --name <name>', 'new name')
+        .option('--nickname <text>', 'new display name')
+        .option('--content <json>', 'replace content JSON (@file / - supported)')
+        .option('--tags <tag...>', 'replace tags')
+        .option('--images <assetId...>', 'replace the image asset list')
+        .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')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const body = {
+            name: opts.name,
+            nickname: opts.nickname,
+            content: await readJson(opts.content),
+            tags: opts.tags,
+            images: opts.images,
+            icon: opts.icon,
+            file: opts.asset === 'null' ? null : opts.asset,
+            sort: opts.sort != null ? Number(opts.sort) : undefined,
+            ...parseKeyValues(opts.set),
+        };
+        const updated = await client.patch(`/fsnode/list/${id}`, body);
+        render(updated, (n) => success(`Updated ${n?.id || id}`));
+    });
+    fs.command('describe <id> <text>')
+        .description('Set content.description (accepts @file or - for stdin)')
+        .action(async (id, text) => {
+        const client = new WjiClient(globals());
+        const node = await client.getFresh(`/fsnode/list/${id}`);
+        const description = await readValue(text);
+        const updated = await client.patch(`/fsnode/list/${id}`, {
+            content: { ...(node.content || {}), description },
+        });
+        render(updated, () => success(`Updated description of ${id}`));
+    });
+    fs.command('rm <id>')
+        .description('Delete a node and its subtree (soft delete)')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const node = await client.get(`/fsnode/list/${id}`).catch(() => ({ name: id }));
+        if (!(await confirm(`Delete "${node.name}" (${id}) and everything under it?`, opts.yes))) {
+            return info('Aborted');
+        }
+        const result = await client.delete(`/fsnode/list/${id}`);
+        render(result, () => success(`Deleted ${id}`));
+    });
+    fs.command('sort <parent> <ids...>')
+        .description('Reorder children of a folder')
+        .action(async (parent, ids) => {
+        const client = new WjiClient(globals());
+        const result = await client.patch(`/fsnode/list/${parent}/children/sort`, { ids });
+        render(result, () => success(`Reordered ${ids.length} children`));
+    });
+    fs.command('batch <json>')
+        .description('Batch update nodes: [{id, name?, content?, sort?, file?}] (@file / - supported)')
+        .action(async (json) => {
+        const client = new WjiClient(globals());
+        const items = await readJson(json);
+        const result = await client.patch('/fsnode/batch', {
+            items: Array.isArray(items) ? items : items.items,
+        });
+        render(result, () => success('Batch update applied'));
+    });
+    fs.command('used-space')
+        .description('Show storage used by your nodes')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        const usage = await client.get('/fsnode/drive/used-space');
+        render(usage, (u) => typeof u === 'object' ? detail(Object.entries(u)) : process.stdout.write(`${u}\n`));
+    });
+    return fs;
+}
+/** Dataset nodes are fsnodes with a `workspace/dataset` mimetype. */
+export function datasetCommand(globals) {
+    const dataset = new Command('dataset').description('Dataset nodes (ideas: character, location, prop, …)');
+    dataset
+        .command('new <parent> <name>')
+        .description('Create a dataset node under a folder')
+        .option('-t, --type <type>', 'outline | screenplay | character | location | prop | outfit | scene | shot | other', 'other')
+        .option('-d, --description <text>', 'description (@file / - supported)')
+        .option('--images <assetId...>', 'attach image assets')
+        .option('--nickname <text>', 'display name')
+        .action(async (parent, name, opts) => {
+        const client = new WjiClient(globals());
+        const created = await client.post('/fsnode/create', {
+            parent,
+            name,
+            type: 'file',
+            mimetype: 'workspace/dataset',
+            nickname: opts.nickname,
+            images: opts.images,
+            content: {
+                type: opts.type,
+                description: opts.description ? await readValue(opts.description) : undefined,
+            },
+        });
+        render(created, (n) => success(`Created dataset ${n.name} (${n.id})`));
+    });
+    dataset
+        .command('list <folderId>')
+        .description('List dataset nodes in a folder')
+        .action(async (folderId) => {
+        const client = new WjiClient(globals());
+        const result = await client.get(`/fsnode/list/${folderId}/children`);
+        const rows = (Array.isArray(result) ? result : result?.data || []).filter((n) => n.mimetype === 'workspace/dataset' || n.type === 'file');
+        render(rows, () => table(rows, [
+            { header: 'id', value: (n) => n.id },
+            { header: 'name', value: (n) => truncate(n.name, 28) },
+            { header: 'kind', value: (n) => n.content?.type },
+            { header: 'images', value: (n) => (n.images || []).length },
+            { header: 'description', value: (n) => truncate(n.content?.description, 40) },
+        ]));
+    });
+    dataset
+        .command('get <key>')
+        .description('Read a vector-store dataset record by key')
+        .action(async (key) => {
+        const client = new WjiClient(globals());
+        const result = await client.get(`/dataset/list/${key}`);
+        render(result, (d) => (d ? detail(Object.entries(d)) : info('Not found')));
+    });
+    dataset
+        .command('rm <key>')
+        .description('Delete a vector-store dataset record by key')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (key, opts) => {
+        if (!(await confirm(`Delete dataset record ${key}?`, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.delete(`/dataset/list/${key}`);
+        render(result, () => success(`Deleted ${key}`));
+    });
+    return dataset;
+}
+function printNode(n) {
+    detail([
+        ['id', n.id],
+        ['name', n.name],
+        ['nickname', n.nickname],
+        ['type', n.type],
+        ['mimetype', n.mimetype],
+        ['parent', n.parent?.id || n.parent],
+        ['workspace', n.workspace?.id || n.workspace],
+        ['tags', (n.tags || []).join(', ')],
+        ['images', (n.images || []).map((a) => a?.id || a).join(', ')],
+        ['file', n.file?.id || n.file],
+        ['content', n.content],
+        ['updatedAt', n.updatedAt],
+    ]);
+}