@vobs/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { existsSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import { checkViewProject } from '@vobs/compiler-dom';
+import { renderCliLogo } from './logo/cli-logo.js';
+import { createScaffold, isScaffoldTemplate, scaffoldSuccessText, } from './scaffold.js';
+export function runVobsCli(args, streams = { stdout: process.stdout, stderr: process.stderr }) {
+    const { args: commandArgs, shouldShowLogo } = readLogoOption(args);
+    if (shouldShowLogo) {
+        streams.stdout.write(`${renderCliLogo()}\n\n`);
+    }
+    const parsed = parseArgs(commandArgs);
+    if (parsed.command === 'help') {
+        streams.stdout.write(helpText());
+        return Promise.resolve(0);
+    }
+    if (parsed.command === 'new') {
+        return runNewCommand(parsed, streams);
+    }
+    const result = checkViewProject({
+        tsconfigPath: parsed.tsconfigPath,
+        ...(parsed.viewFiles === undefined ? {} : { viewFiles: parsed.viewFiles }),
+    });
+    const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'error');
+    const warnings = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'warning');
+    if (errors.length === 0) {
+        if (warnings.length > 0) {
+            streams.stderr.write(`vobs check warnings\n${formatDiagnostics(warnings)}\n`);
+        }
+        streams.stdout.write(`vobs check passed (${result.units.length} view unit(s)).\n`);
+        return Promise.resolve(0);
+    }
+    streams.stderr.write(`vobs check failed\n${formatDiagnostics(errors)}${warnings.length === 0 ? '' : `\nvobs check warnings\n${formatDiagnostics(warnings)}`}\n`);
+    return Promise.resolve(1);
+}
+function readLogoOption(args) {
+    return {
+        args: args.filter((arg) => arg !== '--no-logo'),
+        shouldShowLogo: !args.includes('--no-logo'),
+    };
+}
+function parseArgs(args) {
+    const [command, ...rest] = args;
+    if (command === undefined || command === '--help' || command === '-h')
+        return { command: 'help' };
+    if (command === 'new' || command === 'create')
+        return parseNewArgs(rest, command === 'create');
+    if (command !== 'check')
+        throw new Error(`Unknown command: ${command}`);
+    let tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    const viewFiles = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        if (arg === '--help' || arg === '-h')
+            return { command: 'help' };
+        if (arg === '--tsconfig' || arg === '-p') {
+            const value = rest[index + 1];
+            if (value === undefined)
+                throw new Error(`${arg} requires a path`);
+            tsconfigPath = path.resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === '--view') {
+            const value = rest[index + 1];
+            if (value === undefined)
+                throw new Error('--view requires a path');
+            viewFiles.push(path.resolve(value));
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option: ${arg ?? ''}`);
+    }
+    return {
+        command: 'check',
+        tsconfigPath,
+        viewFiles: viewFiles.length === 0 ? undefined : viewFiles,
+    };
+}
+function parseNewArgs(args, deprecatedAlias) {
+    let type;
+    let name;
+    let template;
+    let withDi;
+    let force = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--help' || arg === '-h')
+            return { command: 'help' };
+        if (arg === '--template' || arg === '-t') {
+            const value = args[index + 1];
+            if (value === undefined)
+                throw new Error(`${arg} requires a template`);
+            if (!isScaffoldTemplate(value))
+                throw new Error(`Unknown template: ${value}`);
+            template = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--with-di') {
+            withDi = true;
+            continue;
+        }
+        if (arg === '--force') {
+            force = true;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`Unknown option: ${arg}`);
+        if (type === undefined) {
+            type = arg;
+            continue;
+        }
+        if (name === undefined) {
+            name = arg;
+            continue;
+        }
+        throw new Error(`Unexpected argument: ${arg ?? ''}`);
+    }
+    const resolvedType = template === undefined ? type : type === template ? undefined : type;
+    const resolvedName = template === undefined ? name : (name ?? type);
+    return {
+        command: 'new',
+        type: resolvedType,
+        name: resolvedName,
+        options: {
+            ...(template === undefined ? {} : { template }),
+            ...(withDi === undefined ? {} : { withDi }),
+            ...(force ? { force } : {}),
+        },
+        deprecatedAlias,
+    };
+}
+async function runNewCommand(command, streams) {
+    if (command.deprecatedAlias) {
+        streams.stderr.write('Warning: "vobs create" is deprecated. Use "vobs new" instead.\n');
+    }
+    const completed = await completeNewCommand(command, streams);
+    if (completed.name !== undefined &&
+        completed.options.force === false &&
+        existsSync(path.resolve(process.cwd(), completed.name))) {
+        streams.stdout.write('Cancelled.\n');
+        return 0;
+    }
+    const result = createScaffold(completed.type, completed.name, completed.options);
+    streams.stdout.write(scaffoldSuccessText(result));
+    return 0;
+}
+async function completeNewCommand(command, streams) {
+    const needsPrompt = command.type === undefined || command.name === undefined;
+    if (!needsPrompt)
+        return command;
+    const prompt = streams.prompt ?? createNodePrompt();
+    try {
+        const type = command.options.template ?? command.type ?? (await askTemplate(prompt));
+        const name = command.name ?? (await askProjectName(prompt));
+        const withDi = command.options.withDi ??
+            (type === 'app' || type === 'lib'
+                ? await prompt.confirm('Include @vobs/di integration?', false)
+                : undefined);
+        const force = command.options.force === true
+            ? true
+            : existsSync(path.resolve(process.cwd(), name))
+                ? await prompt.confirm(`Directory "${name}" already exists. Overwrite?`, false)
+                : undefined;
+        return {
+            ...command,
+            type,
+            name,
+            options: {
+                ...command.options,
+                ...(withDi === undefined ? {} : { withDi }),
+                ...(force === undefined ? {} : { force }),
+            },
+        };
+    }
+    finally {
+        if (streams.prompt === undefined)
+            prompt.close?.();
+    }
+}
+async function askTemplate(prompt) {
+    while (true) {
+        const value = await prompt.text('Template (app, app-di, enterprise, lib, lib-di)', 'app');
+        if (isScaffoldTemplate(value))
+            return value;
+    }
+}
+async function askProjectName(prompt) {
+    while (true) {
+        const value = await prompt.text('Project name');
+        if (/^[a-z0-9][a-z0-9-]*$/u.test(value))
+            return value;
+    }
+}
+function createNodePrompt() {
+    const terminal = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        async text(question, initial) {
+            const suffix = initial === undefined ? ': ' : ` (${initial}): `;
+            const answer = (await terminal.question(`${question}${suffix}`)).trim();
+            return answer === '' && initial !== undefined ? initial : answer;
+        },
+        async confirm(question, initial = false) {
+            const suffix = initial ? ' (Y/n): ' : ' (y/N): ';
+            const answer = (await terminal.question(`${question}${suffix}`)).trim().toLowerCase();
+            if (answer === '')
+                return initial;
+            return answer === 'y' || answer === 'yes';
+        },
+        close() {
+            terminal.close();
+        },
+    };
+}
+function formatDiagnostics(diagnostics) {
+    return diagnostics.map(formatDiagnostic).join('\n');
+}
+function formatDiagnostic(diagnostic) {
+    const source = diagnostic.sourceId ?? 'project';
+    const position = diagnostic.start === undefined ? '' : `:${diagnostic.start.line}:${diagnostic.start.column}`;
+    return `${source}${position} ${diagnostic.severity.toUpperCase()} ${diagnostic.code}: ${diagnostic.message}`;
+}
+function helpText() {
+    return [
+        'Usage:',
+        '  vobs check [--tsconfig tsconfig.json] [--view view.html]',
+        '  vobs new [app|app-di|enterprise|lib|lib-di] [name] [--with-di] [--force]',
+        '',
+        'Check options:',
+        '  -p, --tsconfig <path>  TypeScript project file. Defaults to ./tsconfig.json.',
+        '  --view <path>          Require a specific HTML view to have exactly one owner.',
+        '',
+        'New options:',
+        '  -t, --template <name>   Template: app, app-di, enterprise, lib, lib-di.',
+        '  --with-di               Include DI integration for app/lib templates.',
+        '  --force                 Overwrite an existing project directory.',
+        '',
+        'Global options:',
+        '  --no-logo              Hide the startup logo.',
+        '  -h, --help            Show this help.',
+        '',
+        'Example:',
+        '  vobs new enterprise my-admin',
+        '',
+    ].join('\n');
+}
+try {
+    if (process.argv[1] !== undefined &&
+        realpathSync.native(fileURLToPath(import.meta.url)) ===
+            realpathSync.native(path.resolve(process.argv[1]))) {
+        process.exitCode = await runVobsCli(process.argv.slice(2));
+    }
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/logo/cli-logo.d.ts

@@ -0,0 +1,5 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+export declare function renderCliLogo(): string;

package/dist/logo/cli-logo.js

@@ -0,0 +1,16 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import chalk from 'chalk';
+const BRAND_COLOR = '#2DD4BF';
+const LOGO_MARK = ['╭──────╮', '│ vobs │', '╰──────╯'];
+const PRODUCT_NAME = 'vobs';
+export function renderCliLogo() {
+    const brand = chalk.hex(BRAND_COLOR);
+    return [
+        brand(LOGO_MARK[0]),
+        `${brand(LOGO_MARK[1])} ${brand.bold(PRODUCT_NAME)}`,
+        brand(LOGO_MARK[2]),
+    ].join('\n');
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,23 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+export type ScaffoldTemplate = 'app' | 'app-di' | 'enterprise' | 'lib' | 'lib-di';
+export interface ScaffoldOptions {
+    readonly template?: ScaffoldTemplate;
+    readonly withDi?: boolean;
+    readonly force?: boolean;
+}
+export interface ScaffoldResult {
+    readonly name: string;
+    readonly targetDir: string;
+    readonly template: ScaffoldTemplate;
+}
+export interface TemplateFile {
+    readonly path: string;
+    readonly content: string;
+}
+export declare function createScaffold(type: string | undefined, name: string | undefined, options?: ScaffoldOptions, cwd?: string): ScaffoldResult;
+export declare function resolveScaffoldTemplate(type: string | undefined, options?: ScaffoldOptions): ScaffoldTemplate;
+export declare function isScaffoldTemplate(value: string): value is ScaffoldTemplate;
+export declare function scaffoldSuccessText(result: ScaffoldResult): string;