soja-cli 1.4.0

package/dist/cli/commands/chat.js

@@ -0,0 +1,133 @@
+import { ValidationError } from '../../domain/errors.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { formatStamp } from '../../utils/time.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { withSession } from '../runtime.js';
+import { parseCommand, requireArg } from './args.js';
+import { runInterface } from './tui.js';
+/** `soja chat …` (remote mode): the chat from scripts and hooks, or the interface on a channel. */
+export async function chatCommand(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'send':
+            return send(rest);
+        case 'log':
+            return log(rest);
+        case 'channels':
+        case 'ls':
+            return channels();
+        case 'new':
+        case 'create':
+            return create(rest);
+        case 'topic':
+            return topic(rest);
+        case 'archive':
+        case 'unarchive':
+            return archive(sub === 'archive', rest);
+        case undefined:
+            return runInterface({ route: { name: 'chat' } });
+        default:
+            if (sub.startsWith('#') || !sub.startsWith('-'))
+                return runInterface({ route: { name: 'chat', channel: sub } });
+            throw new ValidationError(`Unknown chat command “${sub}”.`, { hint: 'Try: send, log, channels, new, topic, archive, unarchive, or `soja chat #channel`.' });
+    }
+}
+function chatOf(services) {
+    if (!services.chat) {
+        throw new ValidationError('The chat needs a team: SOJA is in local mode.', { hint: '`soja login --server <url>` to work with a SOJA server.' });
+    }
+    return services.chat;
+}
+async function send(args) {
+    const { positionals } = parseCommand(args, {});
+    const usage = 'soja chat send #channel "message"  (use - to read the message from stdin)';
+    const channel = requireArg(positionals[0], 'channel', usage);
+    let text = positionals.slice(1).join(' ');
+    if (text === '-')
+        text = await readStdin();
+    requireArg(text.trim() || undefined, 'message', usage);
+    await withSession(async (services, session) => {
+        const message = await chatOf(services).send(session, channel, text);
+        const target = await chatOf(services).channel(session, message.channelId);
+        success(`Sent to ${bold(`#${target.name}`)}`);
+    });
+}
+async function log(args) {
+    const { values, positionals } = parseCommand(args, { n: { type: 'string', short: 'n' } });
+    const count = values.n === undefined ? 20 : Number(values.n);
+    if (!Number.isInteger(count) || count < 1)
+        throw new ValidationError('-n takes a positive number.');
+    await withSession(async (services, session) => {
+        const chat = chatOf(services);
+        const channel = await chat.channel(session, positionals[0] ?? 'general');
+        const messages = await chat.messages(session, channel.id, count);
+        print(`${bold(`#${channel.name}`)}${channel.topic ? dim(`  ${channel.topic}`) : ''}`);
+        if (messages.length === 0)
+            print(dim('  No messages yet.'));
+        const now = new Date();
+        for (const message of messages)
+            printMessage(message, now);
+    });
+}
+function printMessage(message, now) {
+    const who = message.author ? `@${message.author.username}` : 'someone';
+    const stamp = dim(formatStamp(message.createdAt, now).padEnd(7));
+    if (message.replyTo) {
+        const quoted = message.replyTo.deleted ? 'deleted message' : (message.replyTo.body.split('\n')[0] ?? '');
+        print(`${' '.repeat(8)}${dim(`${symbols.reply} ${message.replyTo.author ? `@${message.replyTo.author.username}: ` : ''}${quoted.slice(0, 60)}`)}`);
+    }
+    const [first = '', ...more] = message.deletedAt ? ['message deleted'] : message.body.split('\n');
+    const body = message.deletedAt ? dim(first) : message.mentionsMe ? color('yellow', first) : first;
+    const flags = `${message.pending ? dim(` ${symbols.pending}`) : ''}${message.editedAt && !message.deletedAt ? dim(' (edited)') : ''}`;
+    print(`${stamp} ${bold(who)} ${body}${flags}`);
+    for (const line of more)
+        print(`${' '.repeat(8)}${line}`);
+}
+async function channels() {
+    await withSession(async (services, session) => {
+        const list = await chatOf(services).channels(session);
+        for (const channel of list) {
+            const badges = [
+                channel.unread ? color('green', `${channel.unread} unread`) : '',
+                channel.mentions ? color('yellow', `@${channel.mentions}`) : '',
+                channel.archivedAt ? dim('archived') : '',
+            ].filter(Boolean);
+            print(`  ${`#${channel.name}`.padEnd(24)}${badges.join('  ')}${channel.topic ? `  ${dim(channel.topic)}` : ''}`);
+        }
+    });
+}
+async function create(args) {
+    const { values, positionals } = parseCommand(args, { topic: { type: 'string' } });
+    const name = requireArg(positionals[0], 'channel name', 'soja chat new <name> [--topic "…"]');
+    await withSession(async (services, session) => {
+        const channel = await chatOf(services).createChannel(session, name, values.topic ?? null);
+        success(`Created ${bold(`#${channel.name}`)}`);
+    });
+}
+async function topic(args) {
+    const { positionals } = parseCommand(args, {});
+    const channel = requireArg(positionals[0], 'channel', 'soja chat topic <channel> "text"  (empty text clears it)');
+    const text = positionals.slice(1).join(' ').trim();
+    await withSession(async (services, session) => {
+        const chat = chatOf(services);
+        const target = await chat.channel(session, channel);
+        const updated = await chat.updateChannel(session, target.id, { topic: text || null });
+        success(`${bold(`#${updated.name}`)} ${updated.topic ? dim(updated.topic) : dim('no topic')}`);
+    });
+}
+async function archive(archived, args) {
+    const { positionals } = parseCommand(args, {});
+    const channel = requireArg(positionals[0], 'channel', `soja chat ${archived ? 'archive' : 'unarchive'} <channel>`);
+    await withSession(async (services, session) => {
+        const chat = chatOf(services);
+        const target = await chat.channel(session, channel);
+        const updated = await chat.updateChannel(session, target.id, { archived });
+        success(`${bold(`#${updated.name}`)} ${archived ? 'archived: it keeps its history and takes no new messages' : 'restored'}`);
+    });
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/cli/commands/dev.js

@@ -0,0 +1,59 @@
+import { existsSync, rmSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { resolvePaths } from '../../config/paths.js';
+import { ValidationError } from '../../domain/errors.js';
+import { seedDemoData } from '../../dev/seed.js';
+import { bold, dim, print, success } from '../output.js';
+import { withServices } from '../runtime.js';
+import { parseCommand } from './args.js';
+/** Developer tooling behind `npm run db:*`. Not part of the everyday CLI. */
+export async function devCommand(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'migrate':
+            // Opening the database applies pending migrations.
+            await withServices(async () => undefined);
+            success(`Database is up to date ${dim(resolvePaths().databaseFile)}`);
+            return;
+        case 'seed':
+            await withServices(async (services) => {
+                if (services.environment.mode === 'remote') {
+                    throw new ValidationError('Demo data is only for local mode.', { hint: 'Run `soja mode local` first.' });
+                }
+                const result = await seedDemoData(services);
+                success(`Seeded ${bold(result.session.workspace.name)}: ${result.projects} projects, ${result.tasks} tasks`);
+                print(dim(`  You are @${result.session.user.username}. Run \`npm run dev\` to look around.`));
+            });
+            return;
+        case 'reset':
+            return reset(rest);
+        default:
+            throw new ValidationError(`Unknown dev command “${sub ?? ''}”.`, { hint: 'Try: migrate, seed, reset.' });
+    }
+}
+async function reset(args) {
+    const { values } = parseCommand(args, { yes: { type: 'boolean', short: 'y' } });
+    const paths = resolvePaths();
+    const targets = [paths.databaseFile, `${paths.databaseFile}-wal`, `${paths.databaseFile}-shm`, paths.configFile].filter((file) => existsSync(file));
+    if (targets.length === 0) {
+        print(dim('Nothing to reset.'));
+        return;
+    }
+    print(bold('This permanently deletes:'));
+    for (const file of targets)
+        print(`  ${file}`);
+    if (!values.yes) {
+        if (!process.stdin.isTTY)
+            throw new ValidationError('Refusing to reset without confirmation.', { hint: 'Pass --yes.' });
+        const readline = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await readline.question('Type "reset" to continue: ');
+        readline.close();
+        if (answer.trim() !== 'reset') {
+            print(dim('Cancelled. Nothing was deleted.'));
+            return;
+        }
+    }
+    for (const file of targets)
+        rmSync(file, { force: true });
+    success('Reset. The next `soja` starts from first-run setup.');
+}

package/dist/cli/commands/folders.js

@@ -0,0 +1,59 @@
+import { ValidationError } from '../../domain/errors.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { tildify } from '../../utils/text.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { withServices, withSession } from '../runtime.js';
+import { parseCommand, requireArg } from './args.js';
+/** `soja folders`: parent folders that contain your repositories. */
+export async function foldersCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub === undefined || sub === 'list' || sub === 'ls')
+        return list();
+    if (sub === 'add')
+        return add(rest);
+    if (sub === 'remove' || sub === 'rm')
+        return remove(rest);
+    throw new ValidationError(`Unknown folders command “${sub}”.`, { hint: 'Try: list, add <path>, remove <path>.' });
+}
+/** Parent folders and their subfolders, like `ls -1`, marking repositories and linked projects. */
+async function list() {
+    await withSession(async (services, session) => {
+        const parents = services.folders.browse();
+        if (parents.length === 0) {
+            print(dim('No parent folders yet. Add one with `soja folders add ~/workspace/products`.'));
+            return;
+        }
+        const linked = new Map((await services.projects.list(session)).flatMap((project) => project.repositoryPath ? [[project.repositoryPath, project.key]] : []));
+        for (const [index, parent] of parents.entries()) {
+            if (index > 0)
+                print();
+            print(`${bold(tildify(parent.path))}${parent.available ? '' : dim('  (not found)')}`);
+            for (const child of parent.children) {
+                const key = linked.get(child.path);
+                const mark = child.isGitRepository ? color('green', symbols.active) : dim(symbols.dot);
+                print(`  ${mark} ${child.isGitRepository ? child.name : dim(child.name)}${key ? dim(`  ${symbols.arrow} ${key}`) : ''}`);
+            }
+            if (parent.available && parent.children.length === 0)
+                print(dim('  (empty)'));
+        }
+        print();
+        print(dim(`${color('green', symbols.active)} Git repository   ${symbols.arrow} linked project`));
+    });
+}
+async function add(args) {
+    const { positionals } = parseCommand(args, {});
+    const path = requireArg(positionals.join(' '), 'folder', 'soja folders add ~/workspace/products');
+    await withServices(async (services) => {
+        const folders = services.folders.add(path);
+        success(`Parent folder added ${dim(`(${folders.length} total)`)}`);
+        print(dim('  See its subfolders with `soja folders list`.'));
+    });
+}
+async function remove(args) {
+    const { positionals } = parseCommand(args, {});
+    const path = requireArg(positionals.join(' '), 'folder', 'soja folders remove ~/workspace/products');
+    await withServices(async (services) => {
+        services.folders.remove(path);
+        success('Parent folder removed. Nothing was deleted from disk.');
+    });
+}

package/dist/cli/commands/git-ops.js

@@ -0,0 +1,200 @@
+import { pullRequestWarnings } from '../../application/services/index.js';
+import { ValidationError } from '../../domain/errors.js';
+import { GitError } from '../../git/types.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { bold, color, dim, paint, print, success } from '../output.js';
+import { confirm } from '../prompt.js';
+import { withSession } from '../runtime.js';
+import { parseCommand, requireArg } from './args.js';
+/**
+ * Runs `work` while mirroring the Git console to stderr, so the commands and
+ * their output show up live in the terminal. GitErrors get their suggestions.
+ */
+async function withGit(work) {
+    return withSession(async (services, session) => {
+        let shown = services.gitConsole.lastId;
+        const stop = services.gitConsole.subscribe(() => {
+            for (const line of services.gitConsole.since(shown)) {
+                const text = line.kind === 'command' ? paint('bold', line.text, process.stderr) : paint('dim', `  ${line.text}`, process.stderr);
+                if (line.kind !== 'success' && line.kind !== 'error')
+                    process.stderr.write(`${text}\n`);
+                shown = line.id;
+            }
+        });
+        try {
+            return await work(services, session);
+        }
+        catch (error) {
+            if (error instanceof GitError && error.suggestions.length > 1) {
+                // printError shows the first suggestion as the hint; list the rest too.
+                for (const suggestion of error.suggestions.slice(1))
+                    process.stderr.write(`${paint('dim', `  ${symbols.arrow} ${suggestion}`, process.stderr)}\n`);
+            }
+            throw error;
+        }
+        finally {
+            stop();
+        }
+    });
+}
+const interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+/** `soja commit <id> -m <message> [files…] [--all]` */
+export async function commitCommand(args) {
+    const { values, positionals } = parseCommand(args, {
+        message: { type: 'string', short: 'm' },
+        all: { type: 'boolean', short: 'a' },
+    });
+    const ref = requireArg(positionals[0], 'task ID', 'soja commit SOJA-12 -m "Fix webhook" [files…|--all]');
+    const message = requireArg(values.message, 'commit message', 'soja commit SOJA-12 -m "Fix webhook" --all');
+    await withGit(async (services, session) => {
+        let paths = positionals.slice(1);
+        if (paths.length === 0) {
+            const { files } = await services.git.workingState(session, ref, process.cwd());
+            if (!values.all) {
+                throw new ValidationError('Choose the files to commit, or pass --all.', {
+                    hint: files.length ? `Changed: ${files.map((file) => file.path).join(', ')}` : 'There are no changes.',
+                });
+            }
+            paths = files.map((file) => file.path);
+        }
+        const result = await services.git.commit(session, ref, { cwd: process.cwd(), message, paths });
+        success(`Committed ${color('yellow', result.hash.slice(0, 7))} ${result.subject} ${dim(`(${result.files} file${result.files === 1 ? '' : 's'})`)}`);
+    });
+}
+/** `soja merge <id> [--delete] [--done] [--yes]` */
+export async function mergeCommand(args) {
+    const { values, positionals } = parseCommand(args, {
+        delete: { type: 'boolean', short: 'd' },
+        done: { type: 'boolean' },
+        yes: { type: 'boolean', short: 'y' },
+    });
+    const ref = requireArg(positionals[0], 'task ID', 'soja merge SOJA-12 [--delete] [--done]');
+    await withGit(async (services, session) => {
+        const cwd = process.cwd();
+        const plan = await services.git.mergePlan(session, ref, cwd);
+        if (!(await confirm(`Merge ${bold(plan.branch)} into ${bold(plan.into)}?`, values.yes)))
+            return print(dim('Cancelled.'));
+        const result = await services.git.merge(session, ref, { cwd });
+        success(`Merged ${result.branch} into ${result.into} ${dim(result.hash.slice(0, 7))}`);
+        if (values.delete) {
+            const deleted = await services.git.deleteBranch(session, ref, { cwd });
+            success(`Deleted ${deleted.branch}`);
+        }
+        if (values.done) {
+            const task = await services.tasks.complete(session, ref);
+            success(`${task.ref} ${symbols.arrow} Done`);
+        }
+    });
+}
+/** `soja branch delete <id> [--force] [--yes]` */
+export async function branchCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub !== 'delete' && sub !== 'rm') {
+        throw new ValidationError(`Unknown branch command “${sub ?? ''}”.`, { hint: 'Try: soja branch delete SOJA-12' });
+    }
+    const { values, positionals } = parseCommand(rest, {
+        force: { type: 'boolean', short: 'f' },
+        yes: { type: 'boolean', short: 'y' },
+    });
+    const ref = requireArg(positionals[0], 'task ID', 'soja branch delete SOJA-12 [--force]');
+    await withGit(async (services, session) => {
+        const task = await services.tasks.get(session, ref);
+        if (!task.branch)
+            throw new GitError(`${task.ref} has no branch.`);
+        const question = values.force
+            ? `Delete ${bold(task.branch)} even if it is NOT merged? Its unmerged commits will be lost.`
+            : `Delete ${bold(task.branch)}?`;
+        if (!(await confirm(question, values.yes)))
+            return print(dim('Cancelled.'));
+        const result = await services.git.deleteBranch(session, ref, { cwd: process.cwd(), force: values.force ?? false });
+        success(`Deleted ${result.branch}${result.switchedTo ? dim(` (switched to ${result.switchedTo})`) : ''}${result.merged ? '' : dim(' (was not merged)')}`);
+    }).catch((error) => {
+        if (error instanceof GitError && error.code === 'not_merged') {
+            throw new GitError(error.message, { code: error.code, suggestions: ['Merge it first (`soja merge`), or pass --force to delete it anyway.'] });
+        }
+        throw error;
+    });
+}
+/** `soja push <id>` */
+export async function pushCommand(args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', 'soja push SOJA-12');
+    await withGit(async (services, session) => {
+        // Attached to the terminal, Git can ask for credentials itself.
+        const result = await services.git.push(session, ref, { cwd: process.cwd(), interactive: interactive() });
+        success(`Pushed ${result.branch} to origin`);
+    });
+}
+/** `soja pr <id> [--yes]` */
+export async function pullRequestCommand(args) {
+    const [sub, ...rest] = args;
+    if (sub === 'status')
+        return pullRequestStatus(rest);
+    if (sub === 'merge')
+        return mergePullRequest(rest);
+    const { values, positionals } = parseCommand(args, { yes: { type: 'boolean', short: 'y' } });
+    const ref = requireArg(positionals[0], 'task ID', 'soja pr SOJA-12');
+    await withGit(async (services, session) => {
+        const task = await services.tasks.get(session, ref);
+        if (!(await confirm(`Push ${bold(task.branch ?? task.ref)} and open a pull request?`, values.yes)))
+            return print(dim('Cancelled.'));
+        const result = await services.git.openPullRequest(session, ref, { cwd: process.cwd(), interactive: interactive() });
+        success(`Pull request ${result.branch} ${symbols.arrow} ${result.base}`);
+        print(`  ${result.url}`);
+    });
+}
+/** `soja pr status <id>`: the task's pull request as GitHub sees it (through gh). */
+async function pullRequestStatus(args) {
+    const { positionals } = parseCommand(args, {});
+    const ref = requireArg(positionals[0], 'task ID', 'soja pr status SOJA-12');
+    await withGit(async (services, session) => {
+        const state = await services.git.pullRequest(session, ref, process.cwd());
+        if (state.status === 'unavailable')
+            throw new GitError(state.reason, state.hint ? { hint: state.hint } : {});
+        if (state.status === 'none')
+            return print(dim(state.reason));
+        const { pr } = state;
+        const stateText = pr.state === 'merged' ? color('magenta', 'merged') : pr.state === 'open' ? color('cyan', pr.draft ? 'draft' : 'open') : dim('closed');
+        print(`${bold(`#${pr.number}`)} ${stateText} ${dim(`${pr.head} ${symbols.arrow} ${pr.base}`)}  ${pr.title}`);
+        print(`  ${pr.url}`);
+        if (pr.state !== 'open')
+            return;
+        const review = pr.review === 'approved' ? color('green', 'approved') : pr.review === 'changes_requested' ? color('red', 'changes requested') : dim(pr.review ? 'review required' : 'no review rules');
+        print(`  review  ${review}`);
+        const { checks } = pr;
+        const checkText = checks.total === 0
+            ? dim('none')
+            : checks.failed > 0
+                ? color('red', `${symbols.cross} ${checks.failed} failing: ${checks.failing.join(', ')}`)
+                : checks.pending > 0
+                    ? color('yellow', `${symbols.running} ${checks.passed}/${checks.total} passed, ${checks.pending} running`)
+                    : color('green', `${symbols.check} ${checks.passed}/${checks.total} passed`);
+        print(`  checks  ${checkText}`);
+        if (pr.mergeable === 'conflicting')
+            print(`  ${color('red', 'conflicts with the base')}`);
+        // Learn what the team should see too (merged elsewhere, new CI failure).
+        await services.git.followPullRequests(session, process.cwd(), { only: ref });
+    });
+}
+/** `soja pr merge <id> [--delete-branch] [-y]`: merges the PR on GitHub and closes the task. */
+async function mergePullRequest(args) {
+    const { values, positionals } = parseCommand(args, { yes: { type: 'boolean', short: 'y' }, 'delete-branch': { type: 'boolean', short: 'd' } });
+    const ref = requireArg(positionals[0], 'task ID', 'soja pr merge SOJA-12 [--delete-branch]');
+    await withGit(async (services, session) => {
+        const state = await services.git.pullRequest(session, ref, process.cwd());
+        if (state.status === 'unavailable')
+            throw new GitError(state.reason, state.hint ? { hint: state.hint } : {});
+        if (state.status === 'none')
+            throw new GitError(`${ref}: ${state.reason}`, { hint: `Open one with \`soja pr ${ref}\`.` });
+        const { pr } = state;
+        const warnings = pullRequestWarnings(pr);
+        if (warnings.length)
+            print(color('yellow', `! ${warnings.join(', ')}`));
+        const deleteBranch = values['delete-branch'] ?? false;
+        const question = `Merge PR ${bold(`#${pr.number}`)} (${pr.head} ${symbols.arrow} ${pr.base}) on GitHub${deleteBranch ? ' and delete the branch' : ''}?`;
+        if (!(await confirm(question, values.yes)))
+            return print(dim('Cancelled.'));
+        const result = await services.git.mergePullRequest(session, ref, { cwd: process.cwd(), deleteBranch });
+        success(`Merged PR #${result.pr.number} into ${result.pr.base}. ${result.task.ref} is Done.`);
+    });
+}

package/dist/cli/commands/import.js

@@ -0,0 +1,48 @@
+import { ValidationError } from '../../domain/errors.js';
+import { symbols } from '../../ui/theme/theme.js';
+import { bold, color, dim, print, success } from '../output.js';
+import { confirm } from '../prompt.js';
+import { withSession } from '../runtime.js';
+import { parseCommand } from './args.js';
+/** `soja import-local [--from <slug>] [--yes]`: brings local-mode history into the server workspace. */
+export async function importLocalCommand(args) {
+    const { values } = parseCommand(args, { from: { type: 'string' }, yes: { type: 'boolean', short: 'y' } });
+    await withSession(async (services, session) => {
+        const importer = services.importer;
+        if (!importer) {
+            throw new ValidationError('Importing sends your local data to a SOJA server, and SOJA is in local mode.', {
+                hint: 'Sign in first: `soja login --server <url>`.',
+            });
+        }
+        const options = values.from ? { from: values.from } : {};
+        const preview = await importer.preview(session, options);
+        print(`${bold('Import')} ${preview.from.name} ${dim(`(local)`)} ${symbols.arrow} ${bold(session.workspace.name)} ${dim(services.environment.mode === 'remote' ? `on ${new URL(services.environment.server).host}` : '')}`);
+        print(`  ${preview.projects} projects ${symbols.dot} ${preview.tasks} tasks ${symbols.dot} ${preview.comments} comments ${symbols.dot} ${preview.activity} timeline events`);
+        print(dim(`  Developers matched by username: ${preview.developers.map((name) => `@${name}`).join(', ') || 'none'}`));
+        print(dim('  Your local data is only read; it stays as it is.'));
+        if (preview.tasks === 0 && preview.projects === 0)
+            return print(dim('Nothing to import.'));
+        if (preview.alreadyImported)
+            print(color('yellow', '! Already imported from this machine: importing again changes nothing.'));
+        if (!(await confirm('Import now?', values.yes)))
+            return print(dim('Cancelled.'));
+        const outcome = await importer.run(session, options);
+        if (preview.alreadyImported)
+            return success('Already imported earlier: nothing changed.');
+        success(`Imported ${outcome.tasks} tasks, ${outcome.projects} new projects, ${outcome.comments} comments and ${outcome.activity} timeline events`);
+        const renumbered = Object.entries(outcome.renumbered);
+        if (renumbered.length) {
+            print(dim(`  Numbers changed because ${session.workspace.name} already had tasks:`));
+            for (const [from, to] of renumbered.slice(0, 20))
+                print(`  SOJA-${from} ${symbols.arrow} ${bold(`SOJA-${to}`)}`);
+            if (renumbered.length > 20)
+                print(dim(`  ${symbols.ellipsis} and ${renumbered.length - 20} more`));
+        }
+        if (outcome.unmatchedUsers.length) {
+            print(color('yellow', `! Not members of ${session.workspace.name}: ${outcome.unmatchedUsers.map((name) => `@${name}`).join(', ')}`));
+            print(dim('  Their tasks and comments are attributed to you, and their assignments were left empty. Add them with `soja workspace add <username>`.'));
+        }
+        if (outcome.linkedFolders)
+            print(dim(`  ${outcome.linkedFolders} project folder link${outcome.linkedFolders === 1 ? '' : 's'} kept on this machine.`));
+    });
+}

package/dist/cli/commands/info.js

@@ -0,0 +1,82 @@
+import { createUpdater } from '../../bootstrap.js';
+import { APP_AUTHOR, APP_DESCRIPTION, APP_NAME, APP_SLOGAN, APP_VERSION } from '../../ui/branding/brand.js';
+import { bold, color, dim, print } from '../output.js';
+export async function printVersion() {
+    print(`${bold(APP_NAME)} ${color('green', `v${APP_VERSION}`)}`);
+    print(APP_DESCRIPTION);
+    print(dim(APP_AUTHOR));
+    const update = await createUpdater().cachedCheck();
+    if (update?.available)
+        print(color('yellow', `v${update.latest} is available: soja update`));
+}
+const COMMANDS = [
+    ['task list', 'Your open tasks (--all, --status <s>, --project <key>)'],
+    ['task create <title>', 'New task (--project, --type, --priority, --assignee, --requester)'],
+    ['task show <id>', 'Details, activity and comments'],
+    ['task start <id>', 'Assign to yourself and move to In Progress (no Git)'],
+    ['task done <id>', 'Mark as Done'],
+    ['task reopen <id>', 'Move a closed task back to Todo'],
+    ['task comment <id> [text|-]', 'Comment; without text opens $EDITOR, - reads stdin'],
+    ['task describe <id> [text|-]', 'Replace the description; without text edits it in $EDITOR'],
+    ['task archive|restore <id>', 'Hide a task from lists, or bring it back (list --archived)'],
+    ['task delete <id> [--yes]', 'Delete a task for good (owners; type the ID to confirm)'],
+    ['project list', 'Projects with open work'],
+    ['project create <name>', 'New project (--key, --repo-path, --repo-url)'],
+    ['project edit <key>', 'Change name (--name), --description or --url'],
+    ['project link <key> [path|name]', 'Link a project to a local Git repository (default: here)'],
+    ['project unlink <key>', 'Forget the linked repository'],
+    ['start <id>', 'Task start + create/switch its Git branch (--from <ref>, --link)'],
+    ['commit <id> -m <msg> [files|--all]', 'Commit on the task branch; adds (SOJA-12) to the message'],
+    ['merge <id> [--delete] [--done]', 'Merge the task branch into its base (asks first)'],
+    ['branch delete <id> [--force]', 'Delete the task branch (asks first)'],
+    ['push <id>', 'Push the task branch to origin'],
+    ['pr <id>', 'Push and open a pull request with the GitHub CLI (asks first)'],
+    ['pr status <id>', 'The task PR on GitHub: state, review and checks'],
+    ['pr merge <id> [--delete-branch]', 'Merge the PR on GitHub and mark the task Done (asks first)'],
+    ['login --server <url>', 'Sign in with GitHub; new accounts request Online access'],
+    ['access status|request', 'Check or submit your SOJA Online access request'],
+    ['access approvals', 'Review pending requests (CEO only)'],
+    ['access approve|reject <id>', 'Decide an access request (CEO only)'],
+    ['logout', 'Sign out and go back to local mode'],
+    ['account delete [--yes]', 'Delete the Online account and anonymize shared authorship'],
+    ['mode [local|remote]', 'Show or switch where SOJA keeps data'],
+    ['whoami', 'Current user, workspace and mode'],
+    ['import-local [--from <slug>]', 'Bring local-mode projects, tasks and history to the team server (owners)'],
+    ['sync [--dismiss]', 'Sync now (remote mode); shows conflicts and rejected changes'],
+    ['chat [#channel]', 'Open the team chat (remote mode)'],
+    ['chat send #channel <text|->', 'Send a message; - reads it from stdin (scripts, hooks)'],
+    ['chat log [#channel] [-n 20]', 'Latest messages of a channel'],
+    ['chat channels', 'Channels with unread messages and mentions'],
+    ['chat new <name> [--topic]', 'Create a channel'],
+    ['chat topic <channel> <text>', 'Set a channel topic (empty clears it)'],
+    ['chat archive|unarchive <channel>', 'Archive a channel or bring it back (owners)'],
+    ['update [--check]', 'Install the newest SOJA release from npm'],
+    ['backup [list | restore <name>]', 'Copy the database now, list copies (one a day is automatic), or restore one'],
+    ['folders [list]', 'Parent folders and their subfolders, like ls -1'],
+    ['folders add|remove <path>', 'Register or forget a folder that contains repositories'],
+    ['workspace list', 'Your workspaces'],
+    ['workspace create <name>', 'New workspace (you are the owner)'],
+    ['workspace add <username>', 'Add a developer to the active workspace'],
+    ['use <workspace>', 'Switch the active workspace'],
+];
+export function printHelp() {
+    print(`${bold(APP_NAME)}${color('green', '▁')}  ${dim(`v${APP_VERSION}`)}`);
+    print(APP_DESCRIPTION);
+    print();
+    print(dim(APP_SLOGAN));
+    print();
+    print(bold('Usage'));
+    print(`  soja                   ${dim('Open the interface')}`);
+    print(`  soja <command> [options]`);
+    print();
+    print(bold('Commands'));
+    const width = Math.max(...COMMANDS.map(([command]) => command.length)) + 3;
+    for (const [command, description] of COMMANDS)
+        print(`  ${command.padEnd(width)}${dim(description)}`);
+    print();
+    print(bold('Options'));
+    print(`  -h, --help${' '.repeat(width - 10)}${dim('Show this help')}`);
+    print(`  -v, --version${' '.repeat(width - 13)}${dim('Show the version')}`);
+    print();
+    print(dim(`Task IDs look like SOJA-12. Debug output: SOJA_DEBUG=1 soja …`));
+}