@textui/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Softov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @textui/cli
+
+`textui` - set a project up, copy components into it, and find out what the
+terminal in front of you can actually do.
+
+```bash
+npx @textui/cli init
+```
+
+## Components are copied, not imported
+
+`@textui/widgets` is a dependency you install. The registry behind `textui add`
+is the opposite: it writes the source into your project and you own it from
+there, edits included.
+
+```bash
+textui add service-table     # writes src/ui/service-table.tsx
+textui create dashboard      # writes a whole screen
+textui diff                  # what you have edited since it was copied
+```
+
+`diff` matters because owning the source means upstream fixes do not reach you.
+It tells you which files have drifted, so an update is a decision rather than a
+surprise.
+
+## Commands
+
+| | |
+|---|---|
+| `init` | Set up TextUI in this project |
+| `add` | Copy components into your project |
+| `create` | Scaffold a template into your project |
+| `list` | Registry components, templates and themes |
+| `theme` | List themes, or preview one |
+| `registry` | Manage component registries |
+| `diff` | Which copied components have drifted from upstream |
+| `doctor` | What this terminal can do, and what the project looks like |
+
+`doctor` is the one to run first when something renders wrong: it reports the
+unicode level, colour depth, mouse and keyboard protocol actually detected,
+which is usually the answer.
+
+## Building your own
+
+`createCli()` is exported, and `@textui/cli/app` is the primitives under it -
+commands, options, help and prompts. Deliberately small: the point is that an
+application built on TextUI can combine plain commands with interactive screens
+without a second framework and a second idea of what an argument is.
+
+## Runtime
+
+Depends on `@textui/core` and `@textui/terminal`. Uses `node:fs`, `node:path`
+and `node:crypto` - it is the one library package here that touches a disk.
+Node 22+ and Bun.
+
+## Documentation
+
+<https://softov.github.io/textui/>

package/dist/app.d.ts

@@ -0,0 +1,114 @@
+import type { TerminalInput, TerminalOutput } from '@textui/terminal';
+/**
+ * CLI application primitives.
+ *
+ * Deliberately small: commands, options, help, and prompts. The point is not
+ * to replace a full CLI ecosystem - it is that an application built on TextUI
+ * should be able to combine plain commands with interactive screens without
+ * reaching for a second framework and a second idea of what an argument is.
+ */
+export type OptionType = 'string' | 'number' | 'boolean';
+export interface OptionSpec {
+    name: string;
+    type?: OptionType;
+    /** Single-letter alias: `-w`. */
+    short?: string;
+    description?: string;
+    default?: unknown;
+    required?: boolean;
+    /** Accept the flag more than once, collecting values. */
+    multiple?: boolean;
+    choices?: string[];
+}
+export interface ArgumentSpec {
+    name: string;
+    description?: string;
+    required?: boolean;
+    /** Swallow the rest of the command line. */
+    variadic?: boolean;
+}
+export interface ParsedArgs {
+    options: Record<string, unknown>;
+    positionals: string[];
+    /** Everything after a bare `--`. */
+    rest: string[];
+}
+export interface CliCommand {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    arguments?: ArgumentSpec[];
+    options?: OptionSpec[];
+    /** Subcommands. A command with children may still have a handler. */
+    commands?: CliCommand[];
+    examples?: string[];
+    hidden?: boolean;
+    run?(args: ParsedArgs, cli: Cli): Promise<number | void> | number | void;
+}
+export interface CliOptions {
+    name: string;
+    version?: string;
+    description?: string;
+    commands: CliCommand[];
+    /** Options accepted before the command name. */
+    globalOptions?: OptionSpec[];
+    /** Where output goes. Swappable so tests can capture it. */
+    write?(text: string): void;
+    writeError?(text: string): void;
+}
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare class Cli {
+    private options;
+    readonly name: string;
+    readonly version: string;
+    constructor(options: CliOptions);
+    write(text: string): void;
+    writeError(text: string): void;
+    /** Run and return an exit code. Never throws for a user-facing problem. */
+    run(argv: string[]): Promise<number>;
+    private dispatch;
+    help(path?: CliCommand[]): string;
+}
+/**
+ * Parse a command line.
+ *
+ * Supports `--flag`, `--no-flag`, `--key value`, `--key=value`, `-k value`,
+ * bundled short flags `-abc`, and `--` to stop parsing. Unknown options are an
+ * error rather than a positional, because a typo silently becoming a filename
+ * is how a CLI deletes the wrong thing.
+ */
+export declare function parseArgs(argv: string[], specs: OptionSpec[]): ParsedArgs;
+export interface PromptOptions {
+    message: string;
+    default?: string;
+    /** Hide what is typed. */
+    mask?: boolean;
+    validate?(value: string): string | null;
+    input?: TerminalInput;
+    output?: TerminalOutput;
+}
+/**
+ * A line prompt for non-interactive stretches of a CLI.
+ *
+ * This is deliberately not a TUI: mixing a full-screen renderer into a prompt
+ * means a resize or a stray escape sequence can eat the answer. When the input
+ * is not a terminal it returns the default rather than hanging, which is what
+ * makes a CLI usable from a script.
+ */
+export declare function promptLine(options: PromptOptions): Promise<string>;
+export declare function promptConfirm(message: string, options?: {
+    default?: boolean;
+    input?: TerminalInput;
+    output?: TerminalOutput;
+}): Promise<boolean>;
+export declare function promptSelect(message: string, choices: {
+    value: string;
+    label: string;
+}[], options?: {
+    input?: TerminalInput;
+    output?: TerminalOutput;
+}): Promise<string>;
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"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"}

package/dist/app.js

@@ -0,0 +1,372 @@
+import { stringWidth } from '@textui/core';
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'CliError';
+    }
+}
+const HELP_OPTION = { name: 'help', short: 'h', type: 'boolean', description: 'Show this help' };
+const VERSION_OPTION = { name: 'version', short: 'v', type: 'boolean', description: 'Print the version' };
+export class Cli {
+    options;
+    name;
+    version;
+    constructor(options) {
+        this.options = options;
+        this.name = options.name;
+        this.version = options.version ?? '0.0.0';
+    }
+    write(text) {
+        (this.options.write ?? ((t) => process.stdout.write(t)))(text);
+    }
+    writeError(text) {
+        (this.options.writeError ?? ((t) => process.stderr.write(t)))(text);
+    }
+    /** Run and return an exit code. Never throws for a user-facing problem. */
+    async run(argv) {
+        try {
+            return await this.dispatch(argv);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                this.writeError(`${this.name}: ${err.message}\n`);
+                return err.exitCode;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            this.writeError(`${this.name}: ${message}\n`);
+            return 1;
+        }
+    }
+    async dispatch(argv) {
+        const path = [];
+        let commands = this.options.commands;
+        let index = 0;
+        while (index < argv.length) {
+            const token = argv[index];
+            if (token.startsWith('-'))
+                break;
+            const found = commands.find((c) => c.name === token || (c.aliases ?? []).includes(token));
+            if (!found)
+                break;
+            path.push(found);
+            commands = found.commands ?? [];
+            index++;
+        }
+        const command = path[path.length - 1];
+        const rest = argv.slice(index);
+        // Help and version are answered before anything is validated, because a
+        // user asking for help has by definition not got the arguments right yet.
+        if (rest.includes('--help') || rest.includes('-h')) {
+            this.write(this.help(path));
+            return 0;
+        }
+        if (path.length === 0 && (rest.includes('--version') || rest.includes('-v'))) {
+            this.write(`${this.version}\n`);
+            return 0;
+        }
+        if (!command) {
+            this.write(this.help([]));
+            return argv.length === 0 ? 0 : 1;
+        }
+        if (!command.run) {
+            this.write(this.help(path));
+            return 1;
+        }
+        const specs = [
+            ...(this.options.globalOptions ?? []),
+            ...(command.options ?? []),
+            HELP_OPTION,
+        ];
+        const parsed = parseArgs(rest, specs);
+        validate(command, parsed);
+        const code = await command.run(parsed, this);
+        return typeof code === 'number' ? code : 0;
+    }
+    help(path = []) {
+        const command = path[path.length - 1];
+        const lines = [];
+        if (!command) {
+            lines.push(this.options.description ?? `${this.name} ${this.version}`);
+            lines.push('');
+            lines.push(`Usage: ${this.name} <command> [options]`);
+            lines.push('');
+            lines.push('Commands:');
+            lines.push(...describeCommands(this.options.commands));
+            if (this.options.globalOptions?.length) {
+                lines.push('');
+                lines.push('Options:');
+                lines.push(...describeOptions([...this.options.globalOptions, HELP_OPTION, VERSION_OPTION]));
+            }
+            lines.push('');
+            lines.push(`Run \`${this.name} <command> --help\` for details.`);
+            return lines.join('\n') + '\n';
+        }
+        const names = path.map((c) => c.name).join(' ');
+        const args = (command.arguments ?? [])
+            .map((a) => (a.required ? `<${a.name}${a.variadic ? '...' : ''}>` : `[${a.name}${a.variadic ? '...' : ''}]`))
+            .join(' ');
+        if (command.description) {
+            lines.push(command.description);
+            lines.push('');
+        }
+        lines.push(`Usage: ${this.name} ${names}${args ? ` ${args}` : ''} [options]`);
+        if (command.arguments?.length) {
+            lines.push('');
+            lines.push('Arguments:');
+            const width = Math.max(...command.arguments.map((a) => stringWidth(a.name)));
+            for (const arg of command.arguments) {
+                lines.push(`  ${arg.name.padEnd(width)}  ${arg.description ?? ''}`.trimEnd());
+            }
+        }
+        if (command.commands?.length) {
+            lines.push('');
+            lines.push('Commands:');
+            lines.push(...describeCommands(command.commands));
+        }
+        const options = [...(command.options ?? []), HELP_OPTION];
+        lines.push('');
+        lines.push('Options:');
+        lines.push(...describeOptions(options));
+        if (command.examples?.length) {
+            lines.push('');
+            lines.push('Examples:');
+            for (const example of command.examples)
+                lines.push(`  ${example}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+}
+function describeCommands(commands) {
+    const visible = commands.filter((c) => !c.hidden);
+    if (visible.length === 0)
+        return ['  (none)'];
+    const width = Math.max(...visible.map((c) => stringWidth(c.name)));
+    return visible.map((c) => `  ${c.name.padEnd(width)}  ${c.description ?? ''}`.trimEnd());
+}
+function describeOptions(options) {
+    const labels = options.map((o) => {
+        const short = o.short ? `-${o.short}, ` : '    ';
+        const value = o.type === 'boolean' || o.type === undefined ? '' : ` <${o.type}>`;
+        return `${short}--${o.name}${value}`;
+    });
+    const width = Math.max(...labels.map(stringWidth));
+    return options.map((o, i) => {
+        const extra = [];
+        if (o.choices)
+            extra.push(`(${o.choices.join(' | ')})`);
+        if (o.default !== undefined)
+            extra.push(`[default: ${String(o.default)}]`);
+        const suffix = extra.length ? ` ${extra.join(' ')}` : '';
+        return `  ${labels[i].padEnd(width)}  ${o.description ?? ''}${suffix}`.trimEnd();
+    });
+}
+/**
+ * Parse a command line.
+ *
+ * Supports `--flag`, `--no-flag`, `--key value`, `--key=value`, `-k value`,
+ * bundled short flags `-abc`, and `--` to stop parsing. Unknown options are an
+ * error rather than a positional, because a typo silently becoming a filename
+ * is how a CLI deletes the wrong thing.
+ */
+export function parseArgs(argv, specs) {
+    const byName = new Map(specs.map((s) => [s.name, s]));
+    const byShort = new Map(specs.filter((s) => s.short).map((s) => [s.short, s]));
+    const options = {};
+    const positionals = [];
+    const rest = [];
+    for (const spec of specs) {
+        if (spec.default !== undefined)
+            options[spec.name] = spec.default;
+        else if (spec.type === 'boolean')
+            options[spec.name] = false;
+    }
+    const assign = (spec, raw) => {
+        const value = coerce(spec, raw);
+        if (spec.choices && typeof value === 'string' && !spec.choices.includes(value)) {
+            throw new CliError(`--${spec.name} must be one of: ${spec.choices.join(', ')} (got "${value}")`);
+        }
+        if (spec.multiple) {
+            const list = Array.isArray(options[spec.name]) ? options[spec.name] : [];
+            options[spec.name] = [...list, value];
+            return;
+        }
+        options[spec.name] = value;
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const token = argv[i];
+        if (token === '--') {
+            rest.push(...argv.slice(i + 1));
+            break;
+        }
+        if (token.startsWith('--')) {
+            const body = token.slice(2);
+            const eq = body.indexOf('=');
+            const name = eq === -1 ? body : body.slice(0, eq);
+            const inline = eq === -1 ? undefined : body.slice(eq + 1);
+            if (name.startsWith('no-') && byName.has(name.slice(3))) {
+                assign(byName.get(name.slice(3)), false);
+                i++;
+                continue;
+            }
+            const spec = byName.get(name);
+            if (!spec)
+                throw new CliError(`unknown option --${name}`);
+            if (spec.type === 'boolean' || spec.type === undefined) {
+                assign(spec, inline === undefined ? true : inline !== 'false');
+                i++;
+                continue;
+            }
+            const value = inline ?? argv[i + 1];
+            if (value === undefined)
+                throw new CliError(`--${name} needs a value`);
+            assign(spec, value);
+            i += inline === undefined ? 2 : 1;
+            continue;
+        }
+        if (token.startsWith('-') && token.length > 1) {
+            const letters = [...token.slice(1)];
+            for (let j = 0; j < letters.length; j++) {
+                const letter = letters[j];
+                const spec = byShort.get(letter);
+                if (!spec)
+                    throw new CliError(`unknown option -${letter}`);
+                if (spec.type === 'boolean' || spec.type === undefined) {
+                    assign(spec, true);
+                    continue;
+                }
+                // A value-taking short flag consumes the rest of the bundle, or the
+                // next argument: `-w80` and `-w 80` both work.
+                const inline = letters.slice(j + 1).join('');
+                const value = inline !== '' ? inline : argv[++i];
+                if (value === undefined)
+                    throw new CliError(`-${letter} needs a value`);
+                assign(spec, value);
+                break;
+            }
+            i++;
+            continue;
+        }
+        positionals.push(token);
+        i++;
+    }
+    return { options, positionals, rest };
+}
+function coerce(spec, raw) {
+    if (typeof raw === 'boolean')
+        return raw;
+    if (spec.type === 'number') {
+        const n = Number(raw);
+        if (Number.isNaN(n))
+            throw new CliError(`--${spec.name} must be a number (got "${raw}")`);
+        return n;
+    }
+    if (spec.type === 'boolean')
+        return raw !== 'false';
+    return raw;
+}
+function validate(command, parsed) {
+    for (const spec of command.options ?? []) {
+        if (spec.required && parsed.options[spec.name] === undefined) {
+            throw new CliError(`--${spec.name} is required`);
+        }
+    }
+    const required = (command.arguments ?? []).filter((a) => a.required);
+    if (parsed.positionals.length < required.length) {
+        const missing = required.slice(parsed.positionals.length).map((a) => a.name);
+        throw new CliError(`missing argument: ${missing.join(', ')}`);
+    }
+}
+/**
+ * A line prompt for non-interactive stretches of a CLI.
+ *
+ * This is deliberately not a TUI: mixing a full-screen renderer into a prompt
+ * means a resize or a stray escape sequence can eat the answer. When the input
+ * is not a terminal it returns the default rather than hanging, which is what
+ * makes a CLI usable from a script.
+ */
+export async function promptLine(options) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const suffix = options.default ? ` (${options.default})` : '';
+    if (!input.isTTY)
+        return options.default ?? '';
+    for (;;) {
+        output.write(`${options.message}${suffix}: `);
+        const answer = await readLine(input, options.mask ? output : undefined);
+        const value = answer.trim() === '' ? options.default ?? '' : answer.trim();
+        const problem = options.validate?.(value);
+        if (!problem) {
+            if (options.mask)
+                output.write('\n');
+            return value;
+        }
+        output.write(`  ${problem}\n`);
+    }
+}
+export async function promptConfirm(message, options = {}) {
+    const fallback = options.default ?? false;
+    const answer = await promptLine({
+        message: `${message} ${fallback ? '[Y/n]' : '[y/N]'}`,
+        default: fallback ? 'y' : 'n',
+        input: options.input,
+        output: options.output,
+    });
+    return /^y(es)?$/i.test(answer);
+}
+export async function promptSelect(message, choices, options = {}) {
+    const output = options.output ?? process.stdout;
+    output.write(`${message}\n`);
+    choices.forEach((choice, i) => output.write(`  ${i + 1}) ${choice.label}\n`));
+    const answer = await promptLine({
+        message: `Choose 1-${choices.length}`,
+        default: '1',
+        input: options.input,
+        output,
+        validate: (value) => {
+            const n = Number(value);
+            return Number.isInteger(n) && n >= 1 && n <= choices.length ? null : 'Out of range';
+        },
+    });
+    return choices[Number(answer) - 1].value;
+}
+const CTRL_C = String.fromCharCode(3);
+const BACKSPACE = String.fromCharCode(8);
+const DEL = String.fromCharCode(127);
+function readLine(input, maskTo) {
+    return new Promise((resolve) => {
+        let buffer = '';
+        const wasRaw = input.isRaw;
+        const finish = () => {
+            input.off('data', onData);
+            if (maskTo && wasRaw === false && input.setRawMode)
+                input.setRawMode(false);
+            input.pause();
+            resolve(buffer);
+        };
+        const onData = (chunk) => {
+            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+            for (const char of text) {
+                if (char === '\n' || char === '\r')
+                    return finish();
+                // ctrl+c during a prompt has to exit, not be typed into the answer.
+                if (char === CTRL_C)
+                    process.exit(130);
+                if (char === DEL || char === BACKSPACE) {
+                    buffer = buffer.slice(0, -1);
+                    continue;
+                }
+                buffer += char;
+                if (maskTo)
+                    maskTo.write('*');
+            }
+        };
+        if (maskTo && input.setRawMode)
+            input.setRawMode(true);
+        input.setEncoding('utf8');
+        input.resume();
+        input.on('data', onData);
+    });
+}

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { createCli } from './cli.js';
+const code = await createCli().run(process.argv.slice(2));
+process.exit(code);

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+import { Cli } from './app.js';
+export declare const VERSION = "0.1.0";
+export declare function createCli(options?: {
+    write?(t: string): void;
+    writeError?(t: string): void;
+}): Cli;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAG/B,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,wBAAgB,SAAS,CAAC,OAAO,GAAE;IAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAAG,GAAG,CAYtG"}

package/dist/cli.js

@@ -0,0 +1,16 @@
+import { Cli } from './app.js';
+import { COMMANDS } from './commands.js';
+export const VERSION = '0.1.0';
+export function createCli(options = {}) {
+    return new Cli({
+        name: 'textui',
+        version: VERSION,
+        description: 'TextUI - build terminal interfaces you own.',
+        commands: COMMANDS,
+        globalOptions: [
+            { name: 'cwd', type: 'string', description: 'Run as if from this directory' },
+        ],
+        write: options.write,
+        writeError: options.writeError,
+    });
+}

package/dist/commands.d.ts

@@ -0,0 +1,11 @@
+import type { CliCommand } from './app.js';
+export declare const initCommand: CliCommand;
+export declare const listCommand: CliCommand;
+export declare const addCommand: CliCommand;
+export declare const createCommand: CliCommand;
+export declare const themeCommand: CliCommand;
+export declare const registryCommand: CliCommand;
+export declare const diffCommand: CliCommand;
+export declare const doctorCommand: CliCommand;
+export declare const COMMANDS: CliCommand[];
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAwB3C,eAAO,MAAM,WAAW,EAAE,UA+CzB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,UAwDzB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAqExB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,UA2D3B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,UA2C1B,CAAC;AAyCF,eAAO,MAAM,eAAe,EAAE,UAqC7B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,UAsBzB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,UA2D3B,CAAC;AAiBF,eAAO,MAAM,QAAQ,EAAE,UAAU,EAShC,CAAC"}