@wji.ai/cli 0.7.0 → 0.7.1

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`));
-}

package/dist/commands/profile.js

@@ -1,129 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { askSecret, parseKeyValues, readValue } from '../core/prompt.js';
-import { color, detail, info, relativeTime, render, success, table, truncate } from '../core/output.js';
-export function profileCommand(globals) {
-    const profile = new Command('profile').description('Your account profile, wallet and login history');
-    profile
-        .command('show', { isDefault: true })
-        .description('Show your profile')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const me = await client.get('/user/me');
-        render(me, (u) => detail([
-            ['id', u.id],
-            ['name', u.name],
-            ['handle', u.handle],
-            ['email', u.email],
-            ['bio', u.bio],
-            ['website', u.website],
-            ['contactEmail', u.contactEmail],
-            ['phone', u.phone],
-            ['balance', u.balance],
-            ['vip', u.vip?.level],
-            ['avatar', u.avatar?.id || u.avatar],
-            ['banner', u.banner?.id || u.banner],
-            ['socialLinks', (u.socialLinks || []).map((s) => `${s.platform}:${s.url}`).join(', ')],
-            ['createdAt', u.createdAt],
-        ]));
-    });
-    profile
-        .command('update')
-        .description('Update your profile')
-        .option('-n, --name <name>', 'display name')
-        .option('--handle <handle>', '3-24 chars, letter first, lowercase/digits/underscore')
-        .option('--bio <text>', 'bio, max 500 chars (@file / - supported)')
-        .option('--email <email>', 'account email')
-        .option('--contact-email <email>', 'public contact email')
-        .option('--phone <phone>', 'contact phone')
-        .option('--website <url>', 'website')
-        .option('--avatar <assetId>', 'avatar asset id ("null" to clear)')
-        .option('--banner <assetId>', 'banner asset id ("null" to clear)')
-        .option('--set <key=value...>', 'arbitrary field')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const nullable = (v) => (v === 'null' ? null : v);
-        const updated = await client.patch('/user/me', {
-            name: opts.name,
-            handle: nullable(opts.handle),
-            bio: opts.bio ? await readValue(opts.bio) : undefined,
-            email: opts.email,
-            contactEmail: nullable(opts.contactEmail),
-            phone: nullable(opts.phone),
-            website: nullable(opts.website),
-            avatar: nullable(opts.avatar),
-            banner: nullable(opts.banner),
-            ...parseKeyValues(opts.set),
-        });
-        render(updated, () => success('Profile updated'));
-    });
-    profile
-        .command('password')
-        .description('Change your password')
-        .option('-p, --password <password>', 'new password (prompted when omitted)')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const password = opts.password || (await askSecret('New password: '));
-        if (password.length < 6)
-            throw new Error('Password must be at least 6 characters');
-        const result = await client.patch('/user/me/password', { password });
-        render(result, () => success('Password changed'));
-    });
-    profile
-        .command('logins')
-        .description('Show your last 10 successful logins')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const rows = await client.get('/user/loginHistory');
-        render(rows, (list) => table(list || [], [
-            { header: 'when', value: (l) => relativeTime(l.createdAt) },
-            { header: 'state', value: (l) => l.state },
-            { header: 'ip', value: (l) => l.ip },
-            { header: 'agent', value: (l) => truncate(l.userAgent, 40) },
-        ]));
-    });
-    profile
-        .command('wallet')
-        .description('Show your credit balance and recent ledger entries')
-        .option('--limit <n>', 'ledger entries to show', '10')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const me = await client.get('/user/me');
-        const ledgers = await client
-            .get('/wallet/ledgers/search', { limit: Number(opts.limit) })
-            .catch(() => null);
-        render({ balance: me.balance, vip: me.vip, ledgers }, () => {
-            detail([
-                ['balance', me.balance],
-                ['vip', me.vip?.level],
-            ]);
-            if (ledgers?.data?.length) {
-                info('');
-                table(ledgers.data, [
-                    { header: 'when', value: (l) => relativeTime(l.createdAt) },
-                    { header: 'amount', value: (l) => l.amount },
-                    { header: 'type', value: (l) => l.type },
-                    { header: 'note', value: (l) => truncate(l.description || l.remark, 40) },
-                ]);
-            }
-        });
-    });
-    profile
-        .command('search <keyword>')
-        .description('Find other users by name or handle (an exact email address also matches)')
-        .option('--limit <n>', 'max results (1-20)', '10')
-        .action(async (keyword, opts) => {
-        const client = new WjiClient(globals());
-        // Public search returns a bare array of {id, name, handle, avatar} — never email.
-        const result = await client.get('/user/search', { keyword, limit: Number(opts.limit) });
-        render(result, (users) => {
-            table(users || [], [
-                { header: 'id', value: (u) => u.id },
-                { header: 'name', value: (u) => u.name },
-                { header: 'handle', value: (u) => u.handle },
-            ]);
-            info(color.dim(`${users?.length ?? 0} found`));
-        });
-    });
-    return profile;
-}

package/dist/commands/skill.js

@@ -1,272 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, relative, resolve } from 'node:path';
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { confirm } from '../core/prompt.js';
-import { createZip } from '../core/zip.js';
-import { color, detail, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
-/**
- * Import limits enforced by wji-backend (src/ai/skill/zip.ts, shared.service.ts).
- * Checked locally so a push fails with a clear message instead of a 400 / 413.
- */
-const SKILL_ZIP_MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
-const SKILL_ZIP_MAX_ENTRIES = 200;
-const SKILL_ZIP_MAX_FILE_BYTES = 2 * 1024 * 1024;
-const SKILL_ZIP_MAX_TOTAL_BYTES = 20 * 1024 * 1024;
-const mb = (bytes) => `${bytes / (1024 * 1024)}MB`;
-function assertUploadSize(bytes, what) {
-    if (bytes > SKILL_ZIP_MAX_UPLOAD_BYTES) {
-        throw new Error(`${what} is ${(bytes / (1024 * 1024)).toFixed(1)}MB; the server accepts at most ${mb(SKILL_ZIP_MAX_UPLOAD_BYTES)}.`);
-    }
-}
-/** Recursively collect files under a dir as forward-slash relative paths. */
-async function collectFiles(root) {
-    const out = [];
-    async function walk(dir) {
-        for (const entry of await readdir(dir, { withFileTypes: true })) {
-            if (entry.name.startsWith('.'))
-                continue;
-            const full = join(dir, entry.name);
-            if (entry.isDirectory())
-                await walk(full);
-            else if (entry.isFile())
-                out.push(full);
-        }
-    }
-    await walk(root);
-    return out;
-}
-/** Read a skill folder into zip entries. The backend keeps only .md files. */
-async function zipSkillDir(dir) {
-    const root = resolve(dir);
-    if (!existsSync(root) || !statSync(root).isDirectory()) {
-        throw new Error(`Not a directory: ${dir}`);
-    }
-    const files = await collectFiles(root);
-    const rel = (f) => relative(root, f).split('\\').join('/');
-    const hasSkillMd = files.some((f) => {
-        const r = rel(f);
-        return r === 'SKILL.md' || r.endsWith('/SKILL.md');
-    });
-    if (!hasSkillMd) {
-        throw new Error(`No SKILL.md found in ${dir} — a skill must contain SKILL.md at its root.`);
-    }
-    const entries = [];
-    const kept = [];
-    const skipped = [];
-    for (const f of files) {
-        const path = rel(f);
-        if (path.toLowerCase().endsWith('.md')) {
-            entries.push({ path, content: await readFile(f) });
-            kept.push(path);
-        }
-        else {
-            skipped.push(path);
-        }
-    }
-    if (entries.length > SKILL_ZIP_MAX_ENTRIES) {
-        throw new Error(`${entries.length} markdown files; a skill holds at most ${SKILL_ZIP_MAX_ENTRIES}.`);
-    }
-    let total = 0;
-    for (const entry of entries) {
-        const bytes = Buffer.byteLength(entry.content);
-        if (bytes > SKILL_ZIP_MAX_FILE_BYTES) {
-            throw new Error(`${entry.path} is larger than ${mb(SKILL_ZIP_MAX_FILE_BYTES)}; the server rejects it.`);
-        }
-        total += bytes;
-    }
-    if (total > SKILL_ZIP_MAX_TOTAL_BYTES) {
-        throw new Error(`Markdown totals ${(total / (1024 * 1024)).toFixed(1)}MB; the server accepts at most ${mb(SKILL_ZIP_MAX_TOTAL_BYTES)}.`);
-    }
-    const zip = createZip(entries);
-    assertUploadSize(zip.length, 'The bundled zip');
-    return { zip, kept, skipped };
-}
-export function skillCommand(globals) {
-    const skill = new Command('skill').description('Manage agent skills (SKILL.md bundles)');
-    // ── system skills ────────────────────────────────────────────────────────
-    skill
-        .command('system')
-        .description('List built-in system skills you can attach to an agent')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const list = await client.get('/ai/skill/system');
-        render(list, (rows) => table(rows || [], [
-            { header: 'key', value: (s) => s.key },
-            { header: 'name', value: (s) => s.name },
-            { header: 'runtime', value: (s) => s.runtime },
-            { header: 'script', value: (s) => (s.script ? 'yes' : '') },
-            { header: 'description', value: (s) => truncate(s.description, 46) },
-        ]));
-    });
-    // ── user skills ──────────────────────────────────────────────────────────
-    skill
-        .command('list', { isDefault: true })
-        .description('List your skills')
-        .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('/ai/skill/search', {
-            page: Number(opts.page),
-            limit: Number(opts.limit),
-        });
-        render(result, (r) => {
-            table(r.data || [], [
-                { header: 'id', value: (s) => s.id },
-                { header: 'name', value: (s) => truncate(s.name, 28) },
-                { header: 'files', value: (s) => (s.files || []).length },
-                { header: 'visibility', value: (s) => s.visibility },
-                { header: 'description', value: (s) => truncate(s.description, 40) },
-            ]);
-            info(color.dim(`${r.pagination?.total ?? 0} total`));
-        });
-    });
-    skill
-        .command('get <id>')
-        .description('Show a skill and its files')
-        .action(async (id) => {
-        const client = new WjiClient(globals());
-        const s = await client.get(`/ai/skill/${id}`);
-        render(s, () => {
-            detail([
-                ['id', s.id],
-                ['name', s.name],
-                ['description', s.description],
-                ['visibility', s.visibility],
-                ['files', (s.files || []).length],
-            ]);
-            for (const f of s.files || []) {
-                info(`  ${color.cyan(f.path)} ${color.dim(`(${(f.content || '').length} chars)`)}`);
-            }
-        });
-    });
-    skill
-        .command('cat <id> [path]')
-        .description('Print the content of a skill file (defaults to SKILL.md)')
-        .action(async (id, path) => {
-        const client = new WjiClient(globals());
-        const s = await client.get(`/ai/skill/${id}`);
-        const files = s.files || [];
-        const target = (path && files.find((f) => f.path === path)) ||
-            files.find((f) => f.path === 'SKILL.md' || f.path.endsWith('/SKILL.md')) ||
-            files[0];
-        if (!target)
-            throw new Error('Skill has no files');
-        process.stdout.write(target.content + '\n');
-    });
-    skill
-        .command('import <zip>')
-        .description('Import a skill from a .zip whose root contains SKILL.md')
-        .action(async (zipPath) => {
-        const client = new WjiClient(globals());
-        if (!existsSync(zipPath))
-            throw new Error(`No such file: ${zipPath}`);
-        const buffer = await readFile(zipPath);
-        assertUploadSize(buffer.length, basename(zipPath));
-        const created = await client.uploadBuffer('/ai/skill/import', buffer, basename(zipPath));
-        render(created, (s) => success(`Imported skill ${s.name} (${s.id})`));
-    });
-    skill
-        .command('push <dir>')
-        .description('Bundle a local skill folder and import it (only .md files are stored)')
-        .action(async (dir) => {
-        const client = new WjiClient(globals());
-        const { zip, kept, skipped } = await zipSkillDir(dir);
-        if (skipped.length) {
-            warn(`Skipping ${skipped.length} non-markdown file(s): ${skipped.slice(0, 5).join(', ')}${skipped.length > 5 ? '…' : ''}`);
-        }
-        const created = await client.uploadBuffer('/ai/skill/import', zip, `${basename(resolve(dir))}.zip`);
-        if (isJsonMode())
-            return printJson(created);
-        success(`Imported skill ${created.name} (${created.id})`);
-        info(color.dim(`${kept.length} markdown file(s): ${kept.join(', ')}`));
-    });
-    skill
-        .command('pull <id> [dir]')
-        .description('Write a skill\'s files to disk (defaults to ./<skill-name>)')
-        .option('-f, --force', 'overwrite existing files')
-        .action(async (id, dir, opts) => {
-        const client = new WjiClient(globals());
-        const s = await client.get(`/ai/skill/${id}`);
-        const target = resolve(dir || slugify(s.name) || id);
-        const written = [];
-        for (const f of s.files || []) {
-            const dest = join(target, f.path);
-            if (existsSync(dest) && !opts.force) {
-                throw new Error(`${dest} exists — pass --force to overwrite`);
-            }
-            await mkdir(dirname(dest), { recursive: true });
-            await writeFile(dest, f.content);
-            written.push(relative(process.cwd(), dest));
-        }
-        render({ id, dir: target, files: written }, () => {
-            success(`Pulled ${written.length} file(s) to ${relative(process.cwd(), target) || '.'}`);
-            for (const w of written)
-                info(color.dim(`  ${w}`));
-        });
-    });
-    skill
-        .command('update <id>')
-        .description('Update a skill\'s metadata, or replace its files from a folder')
-        .option('-n, --name <name>', 'new name')
-        .option('-d, --description <text>', 'new description')
-        .option('--visibility <v>', 'private | unlist')
-        .option('--dir <dir>', 'replace files from this skill folder')
-        .option('-y, --yes', 'skip the confirmation before --dir replaces files')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const body = {
-            name: opts.name,
-            description: opts.description,
-            visibility: opts.visibility,
-        };
-        if (opts.dir) {
-            const root = resolve(opts.dir);
-            const files = await collectFiles(root);
-            const rel = (f) => relative(root, f).split('\\').join('/');
-            body.files = [];
-            for (const f of files) {
-                const path = rel(f);
-                if (path.toLowerCase().endsWith('.md')) {
-                    body.files.push({ path, content: await readFile(f, 'utf8') });
-                }
-            }
-            if (!body.files.some((f) => f.path === 'SKILL.md' || f.path.endsWith('/SKILL.md'))) {
-                throw new Error(`No SKILL.md in ${opts.dir}`);
-            }
-            // --dir swaps the whole file set; files missing from the folder are gone for good.
-            const current = await client.get(`/ai/skill/${id}`).catch(() => null);
-            const label = current?.name ? `"${current.name}" (${id})` : id;
-            const had = Array.isArray(current?.files) ? `its ${current.files.length} file(s)` : 'all of its files';
-            const prompt = `Replace ${had} of skill ${label} with ${body.files.length} file(s) from ${opts.dir}?`;
-            if (!(await confirm(prompt, opts.yes)))
-                return info('Aborted');
-        }
-        const updated = await client.put(`/ai/skill/${id}`, body);
-        render(updated, () => success(`Updated skill ${id}`));
-    });
-    skill
-        .command('rm <id>')
-        .description('Delete a skill')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const s = await client.get(`/ai/skill/${id}`).catch(() => ({ name: id }));
-        if (!(await confirm(`Delete skill "${s.name}" (${id})?`, opts.yes)))
-            return info('Aborted');
-        const result = await client.delete(`/ai/skill/${id}`);
-        render(result, () => success(`Deleted ${id}`));
-    });
-    return skill;
-}
-function slugify(name) {
-    if (!name)
-        return '';
-    return name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}