@tixyel/cli 1.0.0

package/README.md

@@ -0,0 +1,31 @@
+# @tixyel/cli
+
+CLI tool for Tixyel widgets.
+
+## Installation
+
+```bash
+npm install -g @tixyel/cli
+```
+
+## Usage
+
+```bash
+tixyel --help
+```
+
+## Development
+
+```bash
+npm run dev
+```
+
+## Build
+
+```bash
+npm run build
+```
+
+## License
+
+Apache-2.0

package/dist/commands/base.d.ts

@@ -0,0 +1,24 @@
+import type { Command as CommanderCommand } from 'commander';
+/**
+ * Base class for all CLI commands
+ */
+export declare abstract class Command {
+    /**
+     * Command name (e.g., 'init', 'build', 'generate')
+     */
+    abstract name: string;
+    /**
+     * Command description
+     */
+    abstract description: string;
+    /**
+     * Register the command with commander
+     * Override to add custom arguments/options
+     */
+    register(command: CommanderCommand): void;
+    /**
+     * Execute the command
+     * Implement in subclasses
+     */
+    abstract execute(...args: unknown[]): Promise<void>;
+}

package/dist/commands/base.js

@@ -0,0 +1,15 @@
+/**
+ * Base class for all CLI commands
+ */
+export class Command {
+    /**
+     * Register the command with commander
+     * Override to add custom arguments/options
+     */
+    register(command) {
+        command
+            .command(this.name)
+            .description(this.description)
+            .action((...args) => this.execute(...args));
+    }
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,15 @@
+import type { Command as CommanderCommand } from 'commander';
+import { Command } from './base.js';
+/**
+ * Build command
+ */
+export declare class BuildCommand extends Command {
+    name: string;
+    description: string;
+    register(command: CommanderCommand): void;
+    execute(options?: {
+        depth?: string;
+        parallel?: boolean;
+        verbose?: boolean;
+    }): Promise<void>;
+}

package/dist/commands/build.js

@@ -0,0 +1,155 @@
+import inquirer from 'inquirer';
+import { findWidgets } from '../utils/find-widgets.js';
+import { bumpWidgetVersion } from '../utils/version.js';
+import { loadCliConfig } from '../utils/load-cli-config.js';
+import { validateWorkspaceInit } from '../utils/workspace.js';
+import { buildWidget as processBuild } from '../utils/build-processor.js';
+import { Command } from './base.js';
+/**
+ * Build command
+ */
+export class BuildCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.name = 'build';
+        this.description = 'Build widgets from the workspace';
+    }
+    register(command) {
+        command
+            .command(this.name)
+            .description(this.description)
+            .option('-d, --depth <number>', 'Maximum depth to search for widgets', '3')
+            .option('-p, --parallel', 'Build widgets in parallel')
+            .option('-v, --verbose', 'Show verbose output')
+            .action((...args) => this.execute(...args));
+    }
+    async execute(options = {}) {
+        try {
+            // Validate workspace is initialized
+            const workspaceRoot = await validateWorkspaceInit();
+            const rootPath = process.cwd();
+            // Load CLI config from workspace root
+            const cliConfig = await loadCliConfig(workspaceRoot);
+            const maxDepth = options.depth ? parseInt(options.depth, 10) : cliConfig.search.maxDepth;
+            console.log(`🔍 Searching for widgets (max depth: ${maxDepth})...\n`);
+            // Find all widgets
+            const widgets = await findWidgets(rootPath, maxDepth, cliConfig.search.ignore);
+            if (widgets.length === 0) {
+                console.log('❌ No widgets found with .tixyel configuration files.');
+                return;
+            }
+            console.log(`✅ Found ${widgets.length} widget(s)\n`);
+            // Create choices for selection
+            const choices = widgets.map((widget) => ({
+                name: `${widget.config.name} (${widget.relativePath})`,
+                value: widget.path,
+                checked: false,
+            }));
+            let selectedPaths = [];
+            if (choices.length === 1) {
+                selectedPaths = [choices[0].value];
+                console.log(`🔒 Only one widget found, auto-selected: ${choices[0].name}\n`);
+            }
+            else {
+                // Prompt for widget selection
+                const answers = await inquirer.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'selectedWidgets',
+                        message: 'Select widgets to build:',
+                        choices,
+                        pageSize: 10,
+                        loop: false,
+                    },
+                ]);
+                selectedPaths = answers.selectedWidgets;
+            }
+            if (selectedPaths.length === 0) {
+                console.log('\n⚠️  No widgets selected. Exiting...');
+                return;
+            }
+            // Prompt for version bump
+            const versionAnswers = await inquirer.prompt([
+                {
+                    type: 'select',
+                    name: 'versionBump',
+                    message: 'Version bump type:',
+                    choices: [
+                        { name: 'No version bump', value: 'none' },
+                        { name: 'Patch (x.x.1)', value: 'patch' },
+                        { name: 'Minor (x.1.0)', value: 'minor' },
+                        { name: 'Major (1.0.0)', value: 'major' },
+                    ],
+                    default: 'none',
+                    loop: false,
+                    pageSize: 4,
+                },
+            ]);
+            const versionBump = versionAnswers.versionBump;
+            // Resolve parallel setting (CLI option overrides config)
+            const useParallel = options.parallel ?? cliConfig.build.parallel;
+            const verbose = options.verbose ?? cliConfig.build.verbose;
+            console.log(`\n🚀 Building ${selectedPaths.length} widget(s)${useParallel ? ' (parallel)' : ''}...\n`);
+            // Build each selected widget
+            if (useParallel) {
+                // Parallel execution
+                await Promise.all(selectedPaths.map(async (widgetPath) => {
+                    const widget = widgets.find((w) => w.path === widgetPath);
+                    if (widget) {
+                        await buildWidget(widget.path, widget.config.name, versionBump !== 'none' ? versionBump : undefined, verbose, widget.config, cliConfig);
+                    }
+                }));
+            }
+            else {
+                // Sequential execution
+                for (const widgetPath of selectedPaths) {
+                    const widget = widgets.find((w) => w.path === widgetPath);
+                    if (widget) {
+                        await buildWidget(widget.path, widget.config.name, versionBump !== 'none' ? versionBump : undefined, verbose, widget.config, cliConfig);
+                    }
+                }
+            }
+            console.log('\n✨ Build complete!');
+        }
+        catch (error) {
+            console.error(`${error}`);
+            process.exit(1);
+        }
+    }
+}
+/**
+ * Builds a single widget
+ */
+async function buildWidget(widgetPath, widgetName, versionBump, verbose, config, cliConfig) {
+    console.log(`📦 Building ${widgetName}...`);
+    if (verbose) {
+        console.log(`   Path: ${widgetPath}`);
+    }
+    // Bump version if requested
+    if (versionBump) {
+        const newVersion = await bumpWidgetVersion(widgetPath, versionBump);
+        if (newVersion) {
+            console.log(`   📌 Version bumped to: ${newVersion}`);
+        }
+    }
+    // Process build if config and cliConfig provided
+    if (config && cliConfig) {
+        try {
+            await processBuild({
+                widgetPath,
+                config,
+                cliConfig,
+                verbose,
+            });
+        }
+        catch (error) {
+            console.error(`   ❌ Build failed: ${error}`);
+            throw error;
+        }
+    }
+    else {
+        console.error('   ❌ Missing configuration for build process.');
+        throw new Error('Missing configuration for build process.');
+    }
+    console.log(`✓ ${widgetName} built successfully\n`);
+}

package/dist/commands/generate-new.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate command handler
+ *
+ * Usage:
+ * - `tixyel generate` -> creates widget in current directory (01 - Widget)
+ * - `tixyel generate widgets` -> creates widgets/01 - Widget/
+ * - `tixyel generate widgets myname` -> creates widgets/myname/
+ * - `tixyel generate widgets/` -> creates widget at widgets/
+ * - All parameters except path are optional and can be provided via prompts
+ */
+export declare function generateCommand(targetPath?: string, widgetName?: string, description?: string, tags?: string): Promise<void>;

package/dist/commands/generate-new.js

@@ -0,0 +1,146 @@
+import { resolve, basename, join } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import inquirer from 'inquirer';
+import { loadCliConfig } from '../utils/load-cli-config.js';
+/**
+ * Determines if a path should be treated as a parent directory or target directory
+ * Paths ending with / are treated as target directories
+ */
+function isTargetDirectory(path) {
+    return path.endsWith('/') || path.endsWith('\\');
+}
+/**
+ * Gets the next widget number in a parent directory
+ */
+async function getNextWidgetNumber(parentPath) {
+    try {
+        if (!existsSync(parentPath)) {
+            return '01';
+        }
+        // Check for existing widget folders
+        const { readdirSync } = await import('fs');
+        const entries = readdirSync(parentPath);
+        const widgetNumbers = entries
+            .filter((name) => /^\d+\s*-\s*/.test(name))
+            .map((name) => parseInt(name.split('-')[0], 10))
+            .filter((num) => !isNaN(num));
+        const maxNum = widgetNumbers.length > 0 ? Math.max(...widgetNumbers) : 0;
+        return String(maxNum + 1).padStart(2, '0');
+    }
+    catch {
+        return '01';
+    }
+}
+/**
+ * Generate command handler
+ *
+ * Usage:
+ * - `tixyel generate` -> creates widget in current directory (01 - Widget)
+ * - `tixyel generate widgets` -> creates widgets/01 - Widget/
+ * - `tixyel generate widgets myname` -> creates widgets/myname/
+ * - `tixyel generate widgets/` -> creates widget at widgets/
+ * - All parameters except path are optional and can be provided via prompts
+ */
+export async function generateCommand(targetPath, widgetName, description, tags) {
+    const rootPath = process.cwd();
+    // Load CLI config
+    const cliConfig = await loadCliConfig(rootPath);
+    // Default to current directory if no path provided
+    const resolvedPath = targetPath ? resolve(rootPath, targetPath.replace(/[/\\]$/, '')) : rootPath;
+    const isTarget = targetPath ? isTargetDirectory(targetPath) : false;
+    console.log('🎨 Generating widget...\n');
+    if (isTarget) {
+        // Path ends with / -> use as target directory
+        const folderName = basename(resolvedPath);
+        await createWidget(resolvedPath, folderName, description, tags, cliConfig);
+    }
+    else {
+        // Path without / -> use as parent directory
+        let finalWidgetName = widgetName;
+        if (!finalWidgetName) {
+            // Get next number and ask for name
+            const nextNum = await getNextWidgetNumber(resolvedPath);
+            const defaultName = `${nextNum} - Widget`;
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Widget name:',
+                    default: defaultName,
+                },
+            ]);
+            finalWidgetName = answers.name;
+        }
+        const widgetPath = join(resolvedPath, finalWidgetName);
+        await createWidget(widgetPath, finalWidgetName, description, tags, cliConfig);
+    }
+    console.log('\n✨ Generation complete!');
+}
+/**
+ * Prompts for optional widget metadata
+ */
+async function promptMetadata(widgetName, initialDescription, initialTags) {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Widget description:',
+            default: initialDescription || '',
+        },
+        {
+            type: 'input',
+            name: 'tags',
+            message: 'Widget tags (comma-separated):',
+            default: initialTags || '',
+        },
+    ]);
+    const tagsArray = answers.tags
+        ? answers.tags
+            .split(',')
+            .map((tag) => tag.trim())
+            .filter((tag) => tag.length > 0)
+        : [];
+    return {
+        description: answers.description,
+        tags: tagsArray,
+    };
+}
+/**
+ * Creates a widget with .tixyel configuration file
+ */
+async function createWidget(widgetPath, widgetName, description, tagsStr, cliConfig) {
+    try {
+        console.log(`📁 Creating widget: ${widgetName}`);
+        console.log(`   Path: ${widgetPath}`);
+        // Create directory
+        await mkdir(widgetPath, { recursive: true });
+        // Prompt for metadata if not provided
+        const metadata = await promptMetadata(widgetName, description, tagsStr);
+        // Create .tixyel configuration
+        const tixyelConfig = {
+            name: widgetName,
+            description: metadata.description,
+            metadata: {
+                author: cliConfig?.generationDefaults.author || 'Tixyel',
+                tags: metadata.tags,
+                platform: cliConfig?.generationDefaults.platform || 'streamelements',
+            },
+        };
+        const configPath = join(widgetPath, '.tixyel');
+        await writeFile(configPath, JSON.stringify(tixyelConfig, null, 2), 'utf-8');
+        console.log(`✓ Created ${widgetName} successfully`);
+        console.log(`   - Name: ${widgetName}`);
+        if (metadata.description) {
+            console.log(`   - Description: ${metadata.description}`);
+        }
+        if (metadata.tags.length > 0) {
+            console.log(`   - Tags: ${metadata.tags.join(', ')}`);
+        }
+        console.log(`   - .tixyel configuration created`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to create widget: ${error}`);
+        throw error;
+    }
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,11 @@
+import type { Command as CommanderCommand } from 'commander';
+import { Command } from './base.js';
+/**
+ * Generate command
+ */
+export declare class GenerateCommand extends Command {
+    name: string;
+    description: string;
+    register(command: CommanderCommand): void;
+    execute(targetPath?: string, widgetName?: string, description?: string, tags?: string): Promise<void>;
+}

package/dist/commands/generate.js

@@ -0,0 +1,198 @@
+import { resolve, basename, join } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import inquirer from 'inquirer';
+import { loadCliConfig } from '../utils/load-cli-config.js';
+import { validateWorkspaceInit, getConfigPathFromWidget } from '../utils/workspace.js';
+import { Command } from './base.js';
+/**
+ * Generate command
+ */
+export class GenerateCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.name = 'generate';
+        this.description = 'Generate a new widget (path defaults to current directory)';
+    }
+    register(command) {
+        command
+            .command(`${this.name} [path] [name] [description] [tags]`)
+            .description(this.description)
+            .action((...args) => this.execute(...args));
+    }
+    async execute(targetPath, widgetName, description, tags) {
+        try {
+            // Validate workspace is initialized
+            const workspaceRoot = await validateWorkspaceInit();
+            const rootPath = process.cwd();
+            // Load CLI config from workspace root
+            const cliConfig = await loadCliConfig(workspaceRoot);
+            // Default to current directory if no path provided
+            const resolvedPath = targetPath ? resolve(rootPath, targetPath.replace(/[/\\]$/, '')) : rootPath;
+            const isTarget = targetPath ? isTargetDirectory(targetPath) : false;
+            console.log('🎨 Generating widget...\n');
+            if (isTarget) {
+                // Path ends with / -> use as target directory
+                const folderName = basename(resolvedPath);
+                await createWidget(resolvedPath, folderName, description, tags, cliConfig, workspaceRoot);
+            }
+            else {
+                // Path without / -> use as parent directory
+                let finalWidgetName = widgetName;
+                if (!finalWidgetName) {
+                    // Get next number and ask for name
+                    const nextNum = await getNextWidgetNumber(resolvedPath);
+                    const defaultName = `${nextNum} - Widget`;
+                    const answers = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'name',
+                            message: 'Widget name:',
+                            default: defaultName,
+                        },
+                    ]);
+                    finalWidgetName = answers.name;
+                }
+                const widgetPath = join(resolvedPath, finalWidgetName);
+                await createWidget(widgetPath, finalWidgetName, description, tags, cliConfig, workspaceRoot);
+            }
+            console.log('\n✨ Generation complete!');
+        }
+        catch (error) {
+            console.error(`${error}`);
+            process.exit(1);
+        }
+    }
+}
+/**
+ * Determines if a path should be treated as a parent directory or target directory
+ * Paths ending with / are treated as target directories
+ */
+function isTargetDirectory(path) {
+    return path.endsWith('/') || path.endsWith('\\');
+}
+/**
+ * Gets the next widget number in a parent directory
+ */
+async function getNextWidgetNumber(parentPath) {
+    try {
+        if (!existsSync(parentPath)) {
+            return '01';
+        }
+        // Check for existing widget folders
+        const { readdirSync } = await import('fs');
+        const entries = readdirSync(parentPath);
+        const widgetNumbers = entries
+            .filter((name) => /^\d+\s*-\s*/.test(name))
+            .map((name) => parseInt(name.split('-')[0], 10))
+            .filter((num) => !isNaN(num));
+        const maxNum = widgetNumbers.length > 0 ? Math.max(...widgetNumbers) : 0;
+        return String(maxNum + 1).padStart(2, '0');
+    }
+    catch {
+        return '01';
+    }
+}
+/**
+ * Prompts for optional widget metadata
+ */
+async function promptMetadata(widgetName, initialDescription, initialTags) {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Widget description:',
+            default: initialDescription || '',
+        },
+        {
+            type: 'input',
+            name: 'tags',
+            message: 'Widget tags (comma-separated):',
+            default: initialTags || '',
+        },
+    ]);
+    const tagsArray = answers.tags
+        ? answers.tags
+            .split(',')
+            .map((tag) => tag.trim())
+            .filter((tag) => tag.length > 0)
+        : [];
+    return {
+        description: answers.description,
+        tags: tagsArray,
+    };
+}
+/**
+ * Creates a widget with .tixyel configuration file
+ */
+async function createWidget(widgetPath, widgetName, description, tagsStr, cliConfig, workspaceRoot) {
+    try {
+        console.log(`📁 Creating widget: ${widgetName}`);
+        console.log(`   Path: ${widgetPath}`);
+        // Create directory
+        await mkdir(widgetPath, { recursive: true });
+        // Calculate config path if workspace root is provided
+        const configPath = workspaceRoot ? getConfigPathFromWidget(widgetPath, workspaceRoot) : undefined;
+        // Prompt for metadata if not provided
+        const metadata = await promptMetadata(widgetName, description, tagsStr);
+        // Create .tixyel configuration
+        const tixyelConfig = {
+            name: widgetName,
+            description: metadata.description,
+        };
+        if (configPath) {
+            tixyelConfig.configPath = configPath;
+        }
+        tixyelConfig.metadata = {
+            author: cliConfig?.generationDefaults.author || 'Tixyel',
+            tags: metadata.tags,
+            platform: cliConfig?.generationDefaults.platform || 'streamelements',
+        };
+        const configFilePath = join(widgetPath, '.tixyel');
+        await writeFile(configFilePath, JSON.stringify(tixyelConfig, null, 2), 'utf-8');
+        // Create scaffold files from config
+        const scaffold = cliConfig?.generationDefaults.scaffold || [];
+        let createdFiles = 0;
+        let createdFolders = 0;
+        async function processScaffoldItem(item, basePath) {
+            const fullPath = join(basePath, item.name);
+            if (item.type === 'folder') {
+                await mkdir(fullPath, { recursive: true });
+                createdFolders++;
+                // Process folder contents if any
+                if (item.content && Array.isArray(item.content)) {
+                    for (const child of item.content) {
+                        await processScaffoldItem(child, fullPath);
+                    }
+                }
+            }
+            else if (item.type === 'file') {
+                // Write file
+                await writeFile(fullPath, item.content || '', 'utf-8');
+                createdFiles++;
+            }
+        }
+        for (const item of scaffold) {
+            await processScaffoldItem(item, widgetPath);
+        }
+        console.log(`✓ Created ${widgetName} successfully`);
+        console.log(`   - Name: ${widgetName}`);
+        if (metadata.description) {
+            console.log(`   - Description: ${metadata.description}`);
+        }
+        if (metadata.tags.length > 0) {
+            console.log(`   - Tags: ${metadata.tags.join(', ')}`);
+        }
+        if (configPath) {
+            console.log(`   - Config path: ${configPath}`);
+        }
+        console.log(`   - .tixyel configuration created`);
+        if (createdFiles > 0 || createdFolders > 0) {
+            console.log(`   - Scaffold: ${createdFiles} file(s), ${createdFolders} folder(s)`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to create widget: ${error}`);
+        throw error;
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,9 @@
+import { Command } from './base.js';
+/**
+ * Init command - initializes a workspace
+ */
+export declare class InitCommand extends Command {
+    name: string;
+    description: string;
+    execute(): Promise<void>;
+}