@tixyel/cli 1.0.0 → 2.0.0

package/dist/dev.d.ts

@@ -0,0 +1,2 @@
+import { WidgetInfo } from './widget';
+export declare function devServer(widget: WidgetInfo, port?: number): Promise<void>;

package/dist/dev.js

@@ -0,0 +1 @@
+export async function devServer(widget, port = 3666) { }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export type { TixyelCliConfig, ScaffoldItem, ScaffoldFile, ScaffoldFolder } from './types/tixyel-cli-config.js';
+export * from './workspace.js';

package/dist/index.js

@@ -1,39 +1,194 @@
 #!/usr/bin/env node
-import { Command as CommanderCommand } from 'commander';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { readdirSync } from 'fs';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const program = new CommanderCommand();
-program.name('tixyel').description('CLI tool for Tixyel widgets').version('1.0.0');
-/**
- * Auto-discover and load command classes from the commands directory
- */
-async function loadCommands() {
-    const commandsDir = join(__dirname, 'commands');
-    const files = readdirSync(commandsDir).filter((file) => file.endsWith('.js') && file !== 'base.js');
-    for (const file of files) {
-        try {
-            const modulePath = join(commandsDir, file);
-            const module = await import(`file://${modulePath}`);
-            // Look for class exports
-            for (const key in module) {
-                const exported = module[key];
-                // Check if it's a class that extends Command
-                if (typeof exported === 'function' && exported.prototype && exported.prototype.register) {
-                    const CommandClass = exported;
-                    const instance = new CommandClass();
-                    instance.register(program);
-                    break;
-                }
+import { build, createWidget, findWidgets, getNextWidgetNumber } from './widget.js';
+import { loadWorkspace, validateWorkspace } from './workspace.js';
+import { workspace_config } from './templates/workspace.js';
+import { Command as Commander } from 'commander';
+import { basename, join, resolve } from 'path';
+import { writeFile } from 'fs/promises';
+import { createRequire } from 'module';
+import inquirer from 'inquirer';
+const program = new Commander();
+program
+    .name('tixyel')
+    .description('CLI tool for streamelements widgets')
+    .version((() => {
+    try {
+        const require = createRequire(import.meta.url);
+        const { version } = require('../package.json');
+        return version ?? 'dev';
+    }
+    catch {
+        return process.env.TIXYEL_VERSION ?? 'dev';
+    }
+})());
+program
+    .command('init')
+    .aliases(['initialize', 'i', 'setup', 'start'])
+    .description('Initialize a new widget workspace.')
+    .action(async () => {
+    const root = process.cwd();
+    const config = resolve(root, 'tixyel.config.ts');
+    console.log('🚀 Initializing new workspace...');
+    console.log(`📁 Workspace root: ${root}`);
+    const content = workspace_config;
+    try {
+        await writeFile(config, content, 'utf-8');
+        console.log(`✅ Created tixyel.config.ts`);
+        console.log('   Edit it to customize your workspace settings.');
+        console.log('\n🎉 All set! Start building your widgets!');
+        console.log('   - Use "tixyel generate" to create new widgets.');
+        console.log('   - Use "tixyel build" to build your widgets for publish.');
+    }
+    catch (error) {
+        throw error;
+    }
+});
+program
+    .command('generate [path] [name] [description] [tags]')
+    .aliases(['new', 'g', 'create', 'widget'])
+    .description('Generate a new widget.')
+    .action(async (path, name, description, tags) => {
+    try {
+        // Validate if the workspace is initialized
+        const validWorkspacePath = await validateWorkspace();
+        const rootPath = process.cwd();
+        // Load the workspace config
+        const workspaceConfig = await loadWorkspace(validWorkspacePath);
+        // Default to current dir if the path wasn't provided
+        const resolvedPath = path ? resolve(rootPath, path.replace(/[/\\]$/, '')) : rootPath;
+        const isTarget = path ? path.endsWith('/') || path.endsWith('\\') : false;
+        console.log('🎨 Generating widget...\n');
+        if (isTarget) {
+            // Path ends with / -> use as target directory
+            const folderName = basename(resolvedPath);
+            await createWidget(resolvedPath, {
+                name: folderName,
+                description,
+                tags: tags ? tags.split(',').map((t) => t.trim()) : undefined,
+            }, workspaceConfig, validWorkspacePath);
+        }
+        else {
+            // Path without / -> use as parent directory
+            let finalWidgetName = name;
+            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, {
+                name: finalWidgetName,
+                description,
+                tags: tags ? tags.split(',').map((t) => t.trim()) : undefined,
+            }, workspaceConfig, validWorkspacePath);
+        }
+        console.log('\n✨ Generation complete!');
+    }
+    catch (error) {
+        throw error;
+    }
+});
+program
+    .command('build')
+    .aliases(['b', 'compact', 'compile'])
+    .description('Build widgets in the workspace. Supports interactive selection and version bumping.')
+    .option('-d --depth <number>', 'Maximum search depth for widgets', '3')
+    .option('-p --parallel', 'Build widgets in parallel')
+    .option('-v --verbose', 'Show verbose output')
+    .action(async (options = {}) => {
+    try {
+        // Validate if the workspace is initialized
+        const validWorkspacePath = await validateWorkspace();
+        const rootPath = process.cwd();
+        // Load the workspace config
+        const workspaceConfig = await loadWorkspace(validWorkspacePath);
+        const maxDepth = options.depth ? parseInt(options.depth, 10) : workspaceConfig.search?.maxDepth || 3;
+        console.log(`🔍 Searching for widgets (max depth: ${maxDepth})...\n`);
+        // Find all widgets on the workspace
+        const widgets = await findWidgets(rootPath, maxDepth, workspaceConfig.search?.ignore || []);
+        const choices = widgets.map((widget) => ({
+            name: `${widget.config.name} (${widget.relativePath})`,
+            value: widget.path,
+            checked: false,
+        }));
+        let selectedPaths = [];
+        if (widgets.length === 0) {
+            console.log('❌ No widgets found with .tixyel configuration files.');
+            return;
         }
-        catch (error) {
-            console.error(`Failed to load command from ${file}:`, error);
+        else if (widgets.length === 1) {
+            selectedPaths = [choices[0].value];
+            console.log(`🔒 Only one widget found, auto-selected: ${choices[0].name}\n`);
         }
+        else {
+            console.log(`✅ Found ${widgets.length} widget(s)\n`);
+            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('❌ No widgets selected for build. Exiting.');
+            return;
+        }
+        const versionAnswers = await inquirer.prompt([
+            {
+                type: 'select',
+                name: 'versionBump',
+                message: 'Select version bump type:',
+                choices: [
+                    { name: 'No version bump', value: 'none' },
+                    { name: 'Patch (x.x.1)', value: 'patch' },
+                    { name: 'Minor (x.1.x)', value: 'minor' },
+                    { name: 'Major (1.x.x)', value: 'major' },
+                ],
+                default: 'none',
+                loop: false,
+                pageSize: 4,
+            },
+        ]);
+        const versionBump = versionAnswers.versionBump;
+        // Resolve parallel option (CLI option overrides config)
+        const buildInParallel = options.parallel ?? workspaceConfig.build?.parallel ?? false;
+        const verboseOutput = options.verbose ?? workspaceConfig.build?.verbose ?? false;
+        console.log(`\n⚙️ Building ${selectedPaths.length} widget(s)${buildInParallel ? ' in parallel' : ''}...\n`);
+        if (buildInParallel) {
+            await Promise.all(selectedPaths.map(async (path) => {
+                const widget = widgets.find((w) => w.path === path);
+                if (widget) {
+                    await build(widget, versionBump, verboseOutput, workspaceConfig);
+                }
+            }));
+        }
+        else {
+            for (const widgetPath of selectedPaths) {
+                const widget = widgets.find((w) => w.path === widgetPath);
+                if (widget) {
+                    await build(widget, versionBump, verboseOutput, workspaceConfig);
+                }
+            }
+        }
+        console.log('\n🎉 Build process complete!');
+    }
+    catch (error) {
+        throw error;
     }
-}
-// Load commands and parse
-await loadCommands();
+});
 program.parse();
+export * from './workspace.js';

package/dist/templates/config.d.ts

@@ -0,0 +1 @@
+export declare const workspace_config = "\nimport type { TixyelCliConfig } from '@tixyel/cli';\n\n/**\n * Tixyel workspace configuration\n */\nconst config: TixyelCliConfig = {\n  \n};\n\nexport default config;\n";

package/dist/templates/config.js

@@ -0,0 +1,12 @@
+export const workspace_config = `
+import type { TixyelCliConfig } from '@tixyel/cli';
+
+/**
+ * Tixyel workspace configuration
+ */
+const config: TixyelCliConfig = {
+  
+};
+
+export default config;
+`;

package/dist/templates/workspace.d.ts

@@ -0,0 +1 @@
+export declare const workspace_config: string;

package/dist/templates/workspace.js

@@ -0,0 +1,111 @@
+export const workspace_config = `
+import { defineWorkspaceConfig } from '@tixyel/cli';
+
+export default defineWorkspaceConfig({
+  search: {
+    maxDepth: 3,
+    ignore: ['node_modules', 'dist', 'build', '.git'],
+  },
+
+  metadata: {
+    author: 'Your Name',
+    clientId: 'your-client-id',
+  },
+
+  scaffold: [
+    {
+      name: 'development',
+      type: 'folder',
+      content: [
+        {
+          name: 'index.html',
+          type: 'file',
+          content: \`\`,
+        },
+        {
+          name: 'style.css',
+          type: 'file',
+          content: \`\`,
+        },
+        {
+          name: 'script.js',
+          type: 'file',
+          content: \`\`,
+        },
+        {
+          name: 'fields.json',
+          type: 'file',
+          content: '{}',
+        },
+        {
+          name: 'data.json',
+          type: 'file',
+          content: '{}',
+        },
+      ],
+    },
+    {
+      name: 'finished',
+      type: 'folder',
+    },
+    {
+      name: 'widgetIO',
+      type: 'folder',
+    },
+  ],
+
+  build: {
+    parallel: true,
+    verbose: false,
+
+    find: {
+      html: ['index.html'],
+      script: ['script.js'],
+      css: ['style.css'],
+      fields: ['fields.json', 'fields.jsonc'],
+    },
+    result: {
+      'HTML.html': 'html',
+      'SCRIPT.js': 'script',
+      'CSS.css': 'css',
+      'FIELDS.json': 'fields',
+    },
+    widgetIO: {
+      'html.txt': 'html',
+      'js.txt': 'script',
+      'css.txt': 'css',
+      'fields.txt': 'fields',
+    },
+
+    obfuscation: {
+      javascript: {
+        compact: true,
+        log: false,
+        debugProtection: false,
+        selfDefending: false,
+        deadCodeInjection: false,
+        controlFlowFlattening: false,
+        stringArray: false,
+        simplify: false,
+        identifierNamesGenerator: 'mangled',
+      },
+      css: {
+        removeNesting: true,
+        autoprefixer: {
+          overrideBrowserslist: ['Chrome 127'],
+        },
+        cssnano: {
+          preset: 'default',
+        },
+      },
+      html: {
+        removeComments: true,
+        collapseWhitespace: true,
+        minifyCSS: true,
+        minifyJS: true,
+        removeAttributeQuotes: false,
+      },
+    },
+  },
+});
+`.trim();

package/dist/types/workspace.d.ts

@@ -0,0 +1,47 @@
+import type autoprefixer from 'autoprefixer';
+import type cssnanoPlugin from 'cssnano';
+import type { ObfuscatorOptions } from 'javascript-obfuscator';
+import type { Options as HtmlMinifierOptions } from 'html-minifier-terser';
+export type ScaffoldItem = ScaffoldFile | ScaffoldFolder;
+export interface ScaffoldFile {
+    name: string;
+    type: 'file';
+    content: string;
+}
+export interface ScaffoldFolder {
+    name: string;
+    type: 'folder';
+    content?: ScaffoldItem[];
+}
+export interface WorkspaceConfig<Find extends BuildFindMap = BuildFindMap> {
+    search?: {
+        maxDepth?: number;
+        ignore?: string[];
+    };
+    metadata?: {
+        author?: string;
+        clientId?: string;
+        [key: string]: unknown;
+    };
+    scaffold?: ScaffoldItem[];
+    build?: {
+        parallel?: boolean;
+        verbose?: boolean;
+        find?: Find;
+        result?: BuildResultMap<Find>;
+        widgetIO?: BuildResultMap<Find>;
+        obfuscation?: {
+            javascript?: ObfuscatorOptions;
+            css?: {
+                removeNesting?: boolean;
+                autoprefixer?: autoprefixer.Options;
+                cssnano?: cssnanoPlugin.Options;
+            };
+            html?: HtmlMinifierOptions;
+        };
+    };
+}
+type BuildFindMap = Record<string, string[]>;
+type BuildResultMap<Find extends BuildFindMap> = Record<string, keyof Find>;
+export declare function defineWorkspaceConfig<const Find extends BuildFindMap>(config: WorkspaceConfig<Find>): WorkspaceConfig<Find>;
+export {};

package/dist/types/workspace.js

@@ -0,0 +1,4 @@
+// Helper to preserve literal keys for autocomplete in find/result
+export function defineWorkspaceConfig(config) {
+    return config;
+}

package/dist/widget.d.ts

@@ -0,0 +1,31 @@
+import { WorkspaceConfig } from './workspace';
+export interface DotTixyel {
+    name: string;
+    description: string;
+    version: string;
+    config?: string;
+    metadata: WorkspaceConfig['metadata'];
+    dirs: WorkspaceConfig['dirs'];
+}
+export declare function createWidget(path: string, metadata: WorkspaceConfig['metadata'], config: WorkspaceConfig, root: string): Promise<void>;
+export declare function getNextWidgetNumber(parentPath: string): Promise<string>;
+export declare function validateDotTixyel(config: DotTixyel): boolean;
+export type WidgetInfo = {
+    /**
+     * Absolute path to the widget directory
+     */
+    path: string;
+    /**
+     * Relative path from the root directory
+     */
+    relativePath: string;
+    /**
+     * Parsed .tixyel configuration
+     */
+    config: DotTixyel;
+};
+export declare function readDotTixyel(path: string): Promise<DotTixyel | null>;
+export declare function findWidgets(root: string, depth: number, ignore: string[]): Promise<WidgetInfo[]>;
+export declare function build(widget: WidgetInfo, versionBump: 'none' | 'patch' | 'minor' | 'major', verbose: boolean | undefined, workspaceConfig: WorkspaceConfig): Promise<void>;
+export declare function processBuild(widget: WidgetInfo, workspaceConfig: WorkspaceConfig, verbose?: boolean): Promise<void>;
+export declare function bumpVersion(widgetPath: string, bumpType?: 'major' | 'minor' | 'patch'): Promise<string | null>;