@textui/cli 0.1.0

package/dist/commands.js

@@ -0,0 +1,428 @@
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { detectCapabilities, describeEnvironment } from '@textui/terminal';
+import { BUILTIN_THEMES, renderToString } from '@textui/core';
+import { CATALOG } from '@textui/widgets';
+import { CliError, promptConfirm } from './app.js';
+import { DEFAULT_CONFIG, copyComponent, diffInstalled, findProjectRoot, loadRegistry, readConfig, readReceipt, resolveDependencies, writeConfig, writeReceipt, } from './registry.js';
+/**
+ * The developer CLI.
+ *
+ * Every command that writes to a project says what it is going to write before
+ * it writes it, and refuses to overwrite a file the user has edited. That
+ * refusal is the whole reason the receipt file exists.
+ */
+async function requireProject() {
+    const root = await findProjectRoot();
+    if (!root) {
+        throw new CliError('no textui.config.json found. Run `textui init` first.');
+    }
+    return { root, config: await readConfig(root) };
+}
+export const initCommand = {
+    name: 'init',
+    description: 'Set up TextUI in this project',
+    options: [
+        { name: 'components', type: 'string', description: 'Where components are copied', default: DEFAULT_CONFIG.componentsDir },
+        { name: 'templates', type: 'string', description: 'Where screens are copied', default: DEFAULT_CONFIG.templatesDir },
+        { name: 'theme', type: 'string', description: 'Default theme', default: 'dark', choices: BUILTIN_THEMES.map((t) => t.id) },
+        { name: 'shell', type: 'string', description: 'Default shell', default: 'plain', choices: ['plain', 'console', 'paper', 'workbench'] },
+        { name: 'yes', short: 'y', type: 'boolean', description: 'Accept the defaults' },
+    ],
+    examples: ['textui init', 'textui init --shell workbench --theme workbench'],
+    async run(args, cli) {
+        const root = process.cwd();
+        const existing = await findProjectRoot(root);
+        if (existing === root) {
+            throw new CliError('this project is already initialised');
+        }
+        const config = {
+            ...DEFAULT_CONFIG,
+            componentsDir: String(args.options.components),
+            templatesDir: String(args.options.templates),
+            theme: String(args.options.theme),
+            shell: String(args.options.shell),
+        };
+        cli.write('This will create:\n');
+        cli.write(`  textui.config.json\n`);
+        cli.write(`  ${config.componentsDir}/\n`);
+        cli.write(`  ${config.templatesDir}/\n\n`);
+        if (!args.options.yes && !(await promptConfirm('Continue?', { default: true }))) {
+            cli.write('Nothing was written.\n');
+            return 1;
+        }
+        const path = await writeConfig(root, config);
+        await mkdir(join(root, config.componentsDir), { recursive: true });
+        await mkdir(join(root, config.templatesDir), { recursive: true });
+        cli.write(`\nWrote ${path}\n`);
+        cli.write('\nNext:\n');
+        cli.write('  textui list          see what is available\n');
+        cli.write('  textui add table     copy a component into your project\n');
+        cli.write('  textui create dashboard\n');
+        return 0;
+    },
+};
+export const listCommand = {
+    name: 'list',
+    aliases: ['ls'],
+    description: 'List registry components, templates and themes',
+    options: [
+        { name: 'category', type: 'string', description: 'Filter by category' },
+        { name: 'catalog', type: 'boolean', description: 'List the built-in component catalog instead' },
+        { name: 'json', type: 'boolean', description: 'Machine-readable output' },
+    ],
+    async run(args, cli) {
+        if (args.options.catalog) {
+            const category = args.options.category;
+            const items = CATALOG
+                .filter((c) => !category || c.category === category)
+                .map((c) => ({ name: c.component, category: c.category ?? '-', description: c.description ?? '' }));
+            if (args.options.json) {
+                cli.write(`${JSON.stringify(items, null, 2)}\n`);
+                return 0;
+            }
+            cli.write(table(['COMPONENT', 'CATEGORY', 'DESCRIPTION'], items.map((i) => [i.name, i.category, i.description])));
+            return 0;
+        }
+        const { manifest } = await loadRegistry();
+        if (args.options.json) {
+            cli.write(`${JSON.stringify(manifest, null, 2)}\n`);
+            return 0;
+        }
+        cli.write(`${manifest.name} ${manifest.version}\n\n`);
+        cli.write('Components:\n');
+        cli.write(table(['NAME', 'CATEGORY', 'DEPENDS ON', 'DESCRIPTION'], manifest.components.map((c) => [
+            c.name, c.category ?? '-', (c.dependencies ?? []).join(', ') || '-', c.description ?? '',
+        ])));
+        cli.write('\nTemplates:\n');
+        cli.write(table(['NAME', 'DESCRIPTION'], (manifest.templates ?? []).map((t) => [t.name, t.description ?? ''])));
+        cli.write('\nThemes:\n');
+        cli.write(table(['NAME', 'APPEARANCE'], (manifest.themes ?? []).map((t) => [t.name, t.appearance])));
+        return 0;
+    },
+};
+export const addCommand = {
+    name: 'add',
+    description: 'Copy components into your project',
+    arguments: [{ name: 'components', required: true, variadic: true, description: 'Component names' }],
+    options: [
+        { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite files you have edited' },
+        { name: 'dry-run', type: 'boolean', description: 'Show what would happen' },
+        { name: 'registry', type: 'string', description: 'Registry path or name' },
+        { name: 'yes', short: 'y', type: 'boolean', description: 'Do not ask' },
+    ],
+    examples: ['textui add service-table', 'textui add status-dot metric-card --dry-run'],
+    async run(args, cli) {
+        const { root, config } = await requireProject();
+        const registrySource = resolveRegistrySource(config, args.options.registry);
+        const { manifest, dir } = await loadRegistry(registrySource);
+        const requested = args.positionals;
+        const components = resolveDependencies(manifest, requested);
+        const receipt = await readReceipt(root);
+        const implied = components.filter((c) => !requested.includes(c.name));
+        if (implied.length > 0) {
+            cli.write(`Also adding, as dependencies: ${implied.map((c) => c.name).join(', ')}\n`);
+        }
+        cli.write('\nWill write:\n');
+        for (const component of components) {
+            for (const file of component.files) {
+                const target = file.target ?? join(config.componentsDir, file.path.split('/').pop());
+                cli.write(`  ${target}${existsSync(join(root, target)) ? '  (exists)' : ''}\n`);
+            }
+        }
+        cli.write('\n');
+        if (!args.options['dry-run'] && !args.options.yes) {
+            if (!(await promptConfirm('Continue?', { default: true }))) {
+                cli.write('Nothing was written.\n');
+                return 1;
+            }
+        }
+        let refused = 0;
+        for (const component of components) {
+            const result = await copyComponent(component, {
+                root,
+                registryDir: dir,
+                registryName: manifest.name,
+                config,
+                receipt,
+                force: Boolean(args.options.force),
+                dryRun: Boolean(args.options['dry-run']),
+            });
+            for (const path of result.written)
+                cli.write(`  + ${path}\n`);
+            for (const skip of result.skipped) {
+                refused++;
+                cli.write(skip.reason === 'modified'
+                    ? `  ! ${skip.path} - you have edited this; left alone (use --force to replace)\n`
+                    : `  = ${skip.path} - already present; left alone\n`);
+            }
+        }
+        if (!args.options['dry-run'])
+            await writeReceipt(root, receipt);
+        if (args.options['dry-run'])
+            cli.write('\nDry run: nothing was written.\n');
+        return refused > 0 ? 1 : 0;
+    },
+};
+export const createCommand = {
+    name: 'create',
+    description: 'Scaffold a template into your project',
+    arguments: [{ name: 'template', required: true, description: 'Template name' }],
+    options: [
+        { name: 'name', type: 'string', description: 'File name to write' },
+        { name: 'yes', short: 'y', type: 'boolean', description: 'Do not ask' },
+    ],
+    examples: ['textui create dashboard', 'textui create logs --name log-screen'],
+    async run(args, cli) {
+        const { root, config } = await requireProject();
+        const { manifest, dir } = await loadRegistry();
+        const name = args.positionals[0];
+        const template = (manifest.templates ?? []).find((t) => t.name === name);
+        if (!template) {
+            const known = (manifest.templates ?? []).map((t) => t.name).join(', ');
+            throw new CliError(`unknown template "${name}". Available: ${known}`);
+        }
+        // A template is composed from public components, so pull in what it needs.
+        if (template.components.length > 0) {
+            const components = resolveDependencies(manifest, template.components);
+            const receipt = await readReceipt(root);
+            for (const component of components) {
+                const result = await copyComponent(component, {
+                    root, registryDir: dir, registryName: manifest.name, config, receipt,
+                });
+                for (const path of result.written)
+                    cli.write(`  + ${path}\n`);
+            }
+            await writeReceipt(root, receipt);
+        }
+        for (const file of template.files) {
+            const source = join(dir, file);
+            if (!existsSync(source)) {
+                cli.write(`  ! ${file} is listed in the registry but missing from it\n`);
+                continue;
+            }
+            const base = args.options.name ?? file.split('/').pop().replace(/\.tsx?$/, '');
+            const target = join(root, config.templatesDir, `${base}.tsx`);
+            if (existsSync(target) && !args.options.yes) {
+                if (!(await promptConfirm(`${config.templatesDir}/${base}.tsx exists. Overwrite?`, { default: false }))) {
+                    cli.write(`  = skipped ${base}.tsx\n`);
+                    continue;
+                }
+            }
+            const content = (await readFile(source, 'utf8'))
+                .replace(/from '@textui\/core'/g, `from '${config.alias}'`);
+            await mkdir(join(root, config.templatesDir), { recursive: true });
+            await writeFile(target, content, 'utf8');
+            cli.write(`  + ${config.templatesDir}/${base}.tsx\n`);
+        }
+        cli.write(`\nCreated "${name}".\n`);
+        return 0;
+    },
+};
+export const themeCommand = {
+    name: 'theme',
+    description: 'List themes, or preview one',
+    arguments: [{ name: 'theme', description: 'Theme to preview' }],
+    options: [
+        { name: 'set', type: 'string', description: 'Set the project default' },
+        { name: 'width', short: 'w', type: 'number', description: 'Preview width', default: 60 },
+    ],
+    examples: ['textui theme', 'textui theme workbench', 'textui theme --set paper'],
+    async run(args, cli) {
+        if (args.options.set) {
+            const { root, config } = await requireProject();
+            const id = String(args.options.set);
+            if (!BUILTIN_THEMES.some((t) => t.id === id)) {
+                throw new CliError(`unknown theme "${id}"`);
+            }
+            await writeConfig(root, { ...config, theme: id });
+            cli.write(`Default theme is now "${id}".\n`);
+            return 0;
+        }
+        const name = args.positionals[0];
+        if (!name) {
+            cli.write(table(['THEME', 'APPEARANCE', 'BORDER', 'DENSITY'], BUILTIN_THEMES.map((t) => [t.id, t.appearance, t.border ?? '-', t.density ?? 'normal'])));
+            cli.write('\nPreview one with `textui theme <name>`.\n');
+            return 0;
+        }
+        if (!BUILTIN_THEMES.some((t) => t.id === name)) {
+            throw new CliError(`unknown theme "${name}"`);
+        }
+        cli.write(`${renderToString(themePreview(), {
+            theme: name,
+            width: Number(args.options.width),
+            // The preview is written as data, so its components come by name.
+            components: CATALOG,
+        })}\n`);
+        return 0;
+    },
+};
+function themePreview() {
+    return {
+        component: 'box',
+        direction: 'column',
+        gap: 1,
+        padding: 1,
+        children: [
+            { component: 'Heading', content: 'Theme preview' },
+            {
+                component: 'box',
+                direction: 'row',
+                gap: 2,
+                children: [
+                    { component: 'StatusDot', status: 'up', label: 'up' },
+                    { component: 'StatusDot', status: 'degraded', label: 'degraded' },
+                    { component: 'StatusDot', status: 'down', label: 'down' },
+                ],
+            },
+            { component: 'Progress', value: 0.62, label: 'progress', barWidth: 24 },
+            { component: 'Sparkline', values: [1, 4, 2, 8, 5, 9, 3, 7], chartWidth: 24 },
+            {
+                component: 'Panel',
+                title: 'Panel',
+                children: { component: 'text', content: 'Body text inside a panel.' },
+            },
+            {
+                component: 'box',
+                direction: 'row',
+                gap: 1,
+                children: [
+                    { component: 'Badge', label: 'default' },
+                    { component: 'Badge', label: 'success', tone: 'success' },
+                    { component: 'Badge', label: 'danger', tone: 'danger' },
+                ],
+            },
+        ],
+    };
+}
+export const registryCommand = {
+    name: 'registry',
+    description: 'Manage component registries',
+    commands: [
+        {
+            name: 'add',
+            description: 'Register another registry by name',
+            arguments: [
+                { name: 'name', required: true },
+                { name: 'source', required: true, description: 'Path to a directory containing registry.json' },
+            ],
+            async run(args, cli) {
+                const { root, config } = await requireProject();
+                const [name, source] = args.positionals;
+                await loadRegistry(source);
+                await writeConfig(root, {
+                    ...config,
+                    registries: { ...config.registries, [name]: source },
+                });
+                cli.write(`Registry "${name}" added.\n`);
+                return 0;
+            },
+        },
+        {
+            name: 'list',
+            description: 'Show registered registries',
+            async run(_args, cli) {
+                const { config } = await requireProject();
+                const entries = Object.entries(config.registries ?? {});
+                cli.write(table(['NAME', 'SOURCE'], [['textui', '(built in)'], ...entries]));
+                return 0;
+            },
+        },
+    ],
+};
+export const diffCommand = {
+    name: 'diff',
+    description: 'Show which copied components have drifted from upstream',
+    async run(_args, cli) {
+        const { root, config } = await requireProject();
+        const { manifest, dir } = await loadRegistry();
+        const receipt = await readReceipt(root);
+        const report = await diffInstalled(root, dir, manifest, receipt, config);
+        if (report.length === 0) {
+            cli.write('Nothing installed from the registry yet.\n');
+            return 0;
+        }
+        const symbols = { unchanged: '=', modified: 'M', outdated: 'U', missing: '!' };
+        cli.write(table(['', 'COMPONENT', 'FILE', 'STATE'], report.map((r) => [symbols[r.state], r.component, r.file, r.state])));
+        cli.write('\nM = you edited it   U = upstream changed   ! = file is gone\n');
+        return report.some((r) => r.state === 'missing') ? 1 : 0;
+    },
+};
+export const doctorCommand = {
+    name: 'doctor',
+    description: 'Report what this terminal can do, and what the project looks like',
+    options: [{ name: 'json', type: 'boolean', description: 'Machine-readable output' }],
+    async run(args, cli) {
+        const env = describeEnvironment({
+            env: process.env,
+            isTTY: Boolean(process.stdout.isTTY),
+            columns: process.stdout.columns,
+            rows: process.stdout.rows,
+        });
+        const caps = detectCapabilities({
+            env: process.env,
+            isTTY: Boolean(process.stdout.isTTY),
+            columns: process.stdout.columns,
+            rows: process.stdout.rows,
+        });
+        const root = await findProjectRoot();
+        const project = root ? await readConfig(root) : null;
+        if (args.options.json) {
+            cli.write(`${JSON.stringify({ env, capabilities: caps, project, root }, null, 2)}\n`);
+            return 0;
+        }
+        cli.write('Environment\n');
+        cli.write(table(['KEY', 'VALUE'], Object.entries(env)));
+        cli.write('\nCapabilities\n');
+        cli.write(table(['CAPABILITY', 'VALUE'], Object.entries(caps).map(([k, v]) => [k, String(v)])));
+        cli.write('\nProject\n');
+        if (!project) {
+            cli.write('  no textui.config.json found - run `textui init`\n');
+        }
+        else {
+            cli.write(table(['KEY', 'VALUE'], [
+                ['root', root],
+                ['components', project.componentsDir],
+                ['templates', project.templatesDir],
+                ['theme', project.theme ?? 'dark'],
+                ['shell', project.shell ?? 'plain'],
+            ]));
+        }
+        const warnings = [];
+        if (caps.colorDepth === 0)
+            warnings.push('No colour: output will rely on glyphs alone (this is supported).');
+        if (caps.unicode === 'ascii')
+            warnings.push('No Unicode: borders and glyphs degrade to ASCII.');
+        if (!process.stdout.isTTY)
+            warnings.push('Not a terminal: interactive apps will not start, static rendering still works.');
+        if (warnings.length > 0) {
+            cli.write('\nNotes\n');
+            for (const warning of warnings)
+                cli.write(`  - ${warning}\n`);
+        }
+        return 0;
+    },
+};
+function resolveRegistrySource(config, requested) {
+    if (!requested)
+        return undefined;
+    return config.registries?.[requested] ?? requested;
+}
+/** A plain aligned table. The CLI's own output has no dependency on the TUI. */
+function table(headers, rows) {
+    const all = [headers, ...rows];
+    const widths = headers.map((_, i) => Math.max(...all.map((r) => (r[i] ?? '').length)));
+    const line = (cells) => `  ${cells.map((c, i) => (c ?? '').padEnd(widths[i])).join('  ')}`.trimEnd();
+    return [line(headers), ...rows.map(line)].join('\n') + '\n';
+}
+export const COMMANDS = [
+    initCommand,
+    addCommand,
+    createCommand,
+    listCommand,
+    themeCommand,
+    registryCommand,
+    diffCommand,
+    doctorCommand,
+];

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './app.js';
+export * from './registry.js';
+export * from './commands.js';
+export { createCli } from './cli.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './app.js';
+export * from './registry.js';
+export * from './commands.js';
+export { createCli } from './cli.js';

package/dist/registry.d.ts

@@ -0,0 +1,81 @@
+import type { RegistryComponentManifest, RegistryManifest } from '@textui/core';
+/**
+ * The registry, and copying out of it.
+ *
+ * The model is shadcn's: a component's source is copied into the project so
+ * the person who has to maintain it owns it. What makes that survivable is the
+ * receipt written alongside - origin, version and a content hash - so the CLI
+ * can later tell "you have not touched this" from "you changed it", and never
+ * overwrite the second kind without being asked.
+ */
+export interface ProjectConfig {
+    $schema?: string;
+    /** Where components are copied. */
+    componentsDir: string;
+    /** Where templates are copied. */
+    templatesDir: string;
+    /** Import alias the copied source should use for the runtime. */
+    alias: string;
+    theme?: string;
+    shell?: string;
+    /** Extra registries, by name. Values are paths or URLs. */
+    registries?: Record<string, string>;
+    typescript?: boolean;
+}
+export declare const DEFAULT_CONFIG: ProjectConfig;
+export declare const CONFIG_FILES: string[];
+export declare const RECEIPT_FILE = ".textui/components.json";
+export interface Receipt {
+    /** Component name to what was installed. */
+    [name: string]: {
+        registry: string;
+        version: string;
+        files: {
+            path: string;
+            hash: string;
+        }[];
+        installedAt: string;
+    };
+}
+export declare function hashContent(content: string): string;
+export declare function findProjectRoot(from?: string): Promise<string | null>;
+export declare function readConfig(root: string): Promise<ProjectConfig>;
+export declare function writeConfig(root: string, config: ProjectConfig): Promise<string>;
+export declare function readReceipt(root: string): Promise<Receipt>;
+export declare function writeReceipt(root: string, receipt: Receipt): Promise<void>;
+/** Where the shipped registry lives, relative to this package. */
+export declare function builtinRegistryDir(): string;
+export declare function loadRegistry(source?: string): Promise<{
+    manifest: RegistryManifest;
+    dir: string;
+}>;
+export declare function findComponent(manifest: RegistryManifest, name: string): RegistryComponentManifest | undefined;
+/** A component plus everything it depends on, dependencies first. */
+export declare function resolveDependencies(manifest: RegistryManifest, names: string[]): RegistryComponentManifest[];
+export interface CopyResult {
+    component: string;
+    written: string[];
+    skipped: {
+        path: string;
+        reason: 'modified' | 'exists';
+    }[];
+}
+export interface CopyOptions {
+    root: string;
+    registryDir: string;
+    registryName?: string;
+    config: ProjectConfig;
+    receipt: Receipt;
+    force?: boolean;
+    dryRun?: boolean;
+}
+export declare function copyComponent(component: RegistryComponentManifest, options: CopyOptions): Promise<CopyResult>;
+export interface DriftReport {
+    component: string;
+    file: string;
+    state: 'unchanged' | 'modified' | 'outdated' | 'missing';
+}
+/** What has drifted from upstream, and in which direction. */
+export declare function diffInstalled(root: string, registryDir: string, manifest: RegistryManifest, receipt: Receipt, config: ProjectConfig): Promise<DriftReport[]>;
+export declare function listSourceFiles(dir: string): Promise<string[]>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

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