@textui/cli 0.1.0

package/dist/registry.js

@@ -0,0 +1,226 @@
+import { createHash } from 'node:crypto';
+import { readFile, writeFile, mkdir, readdir, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve, relative } from 'node:path';
+export const DEFAULT_CONFIG = {
+    componentsDir: 'src/ui',
+    templatesDir: 'src/screens',
+    alias: '@textui/core',
+    theme: 'dark',
+    shell: 'plain',
+    typescript: true,
+};
+export const CONFIG_FILES = ['textui.config.json', 'textui.config.ts'];
+export const RECEIPT_FILE = '.textui/components.json';
+export function hashContent(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex').slice(0, 16);
+}
+export async function findProjectRoot(from = process.cwd()) {
+    let dir = resolve(from);
+    for (;;) {
+        for (const name of CONFIG_FILES) {
+            if (existsSync(join(dir, name)))
+                return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export async function readConfig(root) {
+    const jsonPath = join(root, 'textui.config.json');
+    if (existsSync(jsonPath)) {
+        const raw = await readFile(jsonPath, 'utf8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    // A `.ts` config is read for its literal object rather than executed: the
+    // CLI must work before the project's dependencies are installed.
+    const tsPath = join(root, 'textui.config.ts');
+    if (existsSync(tsPath)) {
+        const raw = await readFile(tsPath, 'utf8');
+        const match = /defineConfig\(\s*({[\s\S]*?})\s*\)/.exec(raw);
+        if (match) {
+            try {
+                return { ...DEFAULT_CONFIG, ...JSON.parse(toJson(match[1])) };
+            }
+            catch {
+                // Fall through to defaults; a config we cannot read is not fatal.
+            }
+        }
+    }
+    return { ...DEFAULT_CONFIG };
+}
+/** A permissive JS-object-literal to JSON conversion. Good enough for a config. */
+function toJson(source) {
+    return source
+        .replace(/\/\/.*$/gm, '')
+        .replace(/([{,]\s*)([A-Za-z_$][\w$]*)\s*:/g, '$1"$2":')
+        .replace(/'/g, '"')
+        .replace(/,(\s*[}\]])/g, '$1');
+}
+export async function writeConfig(root, config) {
+    const path = join(root, 'textui.config.json');
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return path;
+}
+export async function readReceipt(root) {
+    const path = join(root, RECEIPT_FILE);
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeReceipt(root, receipt) {
+    const path = join(root, RECEIPT_FILE);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+}
+/** Where the shipped registry lives, relative to this package. */
+export function builtinRegistryDir() {
+    // dist/registry.js -> packages/cli/dist -> repo root/components
+    const here = dirname(new URL(import.meta.url).pathname);
+    const candidates = [
+        resolve(here, '../../../components'),
+        resolve(here, '../../components'),
+        resolve(process.cwd(), 'components'),
+    ];
+    return candidates.find((dir) => existsSync(join(dir, 'registry.json'))) ?? candidates[0];
+}
+export async function loadRegistry(source) {
+    const dir = source ?? builtinRegistryDir();
+    const path = join(dir, 'registry.json');
+    if (!existsSync(path)) {
+        throw new Error(`no registry.json at ${dir}`);
+    }
+    const manifest = JSON.parse(await readFile(path, 'utf8'));
+    return { manifest, dir };
+}
+export function findComponent(manifest, name) {
+    return manifest.components.find((c) => c.name === name);
+}
+/** A component plus everything it depends on, dependencies first. */
+export function resolveDependencies(manifest, names) {
+    const out = [];
+    const seen = new Set();
+    const visit = (name, trail) => {
+        if (seen.has(name))
+            return;
+        if (trail.includes(name)) {
+            throw new Error(`circular dependency: ${[...trail, name].join(' -> ')}`);
+        }
+        const component = findComponent(manifest, name);
+        if (!component) {
+            const known = manifest.components.map((c) => c.name).join(', ');
+            throw new Error(`unknown component "${name}". Available: ${known}`);
+        }
+        for (const dep of component.dependencies ?? [])
+            visit(dep, [...trail, name]);
+        seen.add(name);
+        out.push(component);
+    };
+    for (const name of names)
+        visit(name, []);
+    return out;
+}
+export async function copyComponent(component, options) {
+    const written = [];
+    const skipped = [];
+    const recorded = [];
+    const previous = options.receipt[component.name];
+    for (const file of component.files) {
+        const sourcePath = join(options.registryDir, file.path);
+        const targetRelative = file.target ?? join(options.config.componentsDir, basename(file.path));
+        const targetPath = join(options.root, targetRelative);
+        const source = await readFile(sourcePath, 'utf8');
+        const transformed = source.replace(/from '@textui\/core'/g, `from '${options.config.alias}'`);
+        const hash = hashContent(transformed);
+        if (existsSync(targetPath) && !options.force) {
+            const current = await readFile(targetPath, 'utf8');
+            const currentHash = hashContent(current);
+            const installedHash = previous?.files.find((f) => f.path === targetRelative)?.hash;
+            if (currentHash === hash) {
+                // Already up to date; nothing to do and nothing to warn about.
+                recorded.push({ path: targetRelative, hash });
+                continue;
+            }
+            // Only refuse when the local copy differs from what we installed - an
+            // untouched file is safe to update, an edited one is the user's work.
+            skipped.push({
+                path: targetRelative,
+                reason: installedHash && installedHash !== currentHash ? 'modified' : 'exists',
+            });
+            recorded.push({ path: targetRelative, hash: currentHash });
+            continue;
+        }
+        if (!options.dryRun) {
+            await mkdir(dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, transformed, 'utf8');
+        }
+        written.push(targetRelative);
+        recorded.push({ path: targetRelative, hash });
+    }
+    if (!options.dryRun) {
+        options.receipt[component.name] = {
+            registry: options.registryName ?? 'textui',
+            version: component.version,
+            files: recorded,
+            installedAt: new Date().toISOString(),
+        };
+    }
+    return { component: component.name, written, skipped };
+}
+function basename(path) {
+    return path.split('/').pop() ?? path;
+}
+/** What has drifted from upstream, and in which direction. */
+export async function diffInstalled(root, registryDir, manifest, receipt, config) {
+    const out = [];
+    for (const [name, entry] of Object.entries(receipt)) {
+        const component = findComponent(manifest, name);
+        if (!component)
+            continue;
+        for (const file of entry.files) {
+            const target = join(root, file.path);
+            if (!existsSync(target)) {
+                out.push({ component: name, file: file.path, state: 'missing' });
+                continue;
+            }
+            const current = hashContent(await readFile(target, 'utf8'));
+            const definition = component.files.find((f) => (f.target ?? join(config.componentsDir, basename(f.path))) === file.path);
+            const upstreamPath = definition ? join(registryDir, definition.path) : null;
+            const upstream = upstreamPath && existsSync(upstreamPath)
+                ? hashContent((await readFile(upstreamPath, 'utf8')).replace(/from '@textui\/core'/g, `from '${config.alias}'`))
+                : null;
+            if (current !== file.hash) {
+                out.push({ component: name, file: file.path, state: 'modified' });
+            }
+            else if (upstream && upstream !== current) {
+                out.push({ component: name, file: file.path, state: 'outdated' });
+            }
+            else {
+                out.push({ component: name, file: file.path, state: 'unchanged' });
+            }
+        }
+    }
+    return out;
+}
+export async function listSourceFiles(dir) {
+    const out = [];
+    const walk = async (current) => {
+        for (const entry of await readdir(current, { withFileTypes: true })) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory())
+                await walk(full);
+            else
+                out.push(relative(dir, full));
+        }
+    };
+    if (existsSync(dir) && (await stat(dir)).isDirectory())
+        await walk(dir);
+    return out;
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@textui/cli",
+  "version": "0.1.0",
+  "description": "TextUI developer CLI - init, add, create, doctor - and primitives for building your own",
+  "keywords": [
+    "terminal",
+    "tui",
+    "cli",
+    "scaffold",
+    "generator",
+    "init",
+    "component-registry"
+  ],
+  "homepage": "https://softov.github.io/textui/",
+  "bugs": {
+    "url": "https://github.com/softov/textui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softov/textui.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Softov <softov@brbyte.com>",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "textui": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./app": {
+      "types": "./dist/app.d.ts",
+      "import": "./dist/app.js"
+    }
+  },
+  "dependencies": {
+    "@textui/core": "^0.1.0",
+    "@textui/widgets": "^0.1.0",
+    "@textui/terminal": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run"
+  }
+}