kustom-mc 0.1.0

package/dist/commands/build.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const buildCommand: Command;

package/dist/commands/build.js

@@ -0,0 +1,447 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import * as esbuild from 'esbuild';
+import chokidar from 'chokidar';
+import { transformForRhino } from '../compiler/rhino-plugin.js';
+import { transformAsyncAwait } from '../compiler/async-transform.js';
+import { loadConfig, validateManifest, generateManifest } from '../config.js';
+import { prepare } from './prepare.js';
+export const buildCommand = new Command('build')
+    .description('Compile TypeScript scripts to Rhino-compatible JavaScript')
+    .option('-w, --watch', 'Watch for changes and rebuild')
+    .option('-d, --deploy', 'Copy compiled files to deploy target')
+    .option('--no-validate', 'Skip validation')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--clean', 'Clean output directory before building')
+    .action(async (options) => {
+    const config = loadConfig(process.cwd());
+    // Clean output directory if requested
+    if (options.clean) {
+        const outDir = config.outDir || 'dist';
+        const outPath = path.resolve(process.cwd(), outDir);
+        if (fs.existsSync(outPath)) {
+            fs.rmSync(outPath, { recursive: true });
+            console.log(`Cleaned output directory: ${outDir}`);
+        }
+    }
+    if (options.watch) {
+        await watchMode(config, options);
+    }
+    else {
+        await buildAll(config, options);
+    }
+});
+/**
+ * Get the output path for a source file based on config.outDir
+ */
+function getOutputPath(sourceFile, config) {
+    const outDir = config.outDir || 'dist';
+    const relativePath = sourceFile.replace(/\.ts$/, '.js');
+    return path.resolve(process.cwd(), outDir, relativePath);
+}
+/**
+ * Get the output directory from config
+ */
+function getOutDir(config) {
+    return path.resolve(process.cwd(), config.outDir || 'dist');
+}
+async function buildAll(config, options) {
+    // Validate manifest configuration
+    const manifestErrors = validateManifest(config);
+    if (manifestErrors.length > 0) {
+        console.error('Manifest validation errors:');
+        for (const error of manifestErrors) {
+            console.error(`  - ${error}`);
+        }
+        process.exit(1);
+    }
+    // Run prepare first to generate types
+    console.log('Preparing types...');
+    await prepare(process.cwd());
+    console.log('Building kustompack scripts...');
+    console.log(`  Pack ID: ${config.manifest?.id || 'unknown'}`);
+    const startTime = Date.now();
+    let successCount = 0;
+    let errorCount = 0;
+    // Find all TypeScript files
+    const patterns = config.include || ['scripts/**/*.ts'];
+    const excludePatterns = config.exclude || [];
+    const files = [];
+    for (const pattern of patterns) {
+        const matches = await glob(pattern, {
+            cwd: process.cwd(),
+            ignore: excludePatterns
+        });
+        files.push(...matches);
+    }
+    // Filter out lib files (they get inlined)
+    const libDirs = config.lib || ['scripts/lib'];
+    const scriptFiles = files.filter(file => {
+        return !libDirs.some(lib => file.startsWith(lib + '/') || file.startsWith(lib + '\\'));
+    });
+    if (scriptFiles.length === 0) {
+        console.log('No TypeScript files found to compile.');
+        return;
+    }
+    const outDir = getOutDir(config);
+    console.log(`Found ${scriptFiles.length} script(s) to compile...`);
+    console.log(`Output directory: ${outDir}`);
+    for (const file of scriptFiles) {
+        try {
+            await buildFile(file, config, options);
+            successCount++;
+            if (options.verbose) {
+                console.log(`  [OK] ${file}`);
+            }
+        }
+        catch (error) {
+            errorCount++;
+            console.error(`  [ERROR] ${file}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    // Generate manifest in output directory
+    const manifestPath = path.resolve(outDir, 'kustompack.json');
+    try {
+        const manifestContent = generateManifest(config);
+        fs.writeFileSync(manifestPath, manifestContent);
+        if (options.verbose) {
+            console.log(`  [OK] kustompack.json`);
+        }
+    }
+    catch (error) {
+        console.error(`  [ERROR] kustompack.json: ${error instanceof Error ? error.message : error}`);
+    }
+    const elapsed = Date.now() - startTime;
+    console.log(`\nBuild completed in ${elapsed}ms: ${successCount} succeeded, ${errorCount} failed`);
+    if (options.deploy && config.deploy?.target) {
+        await deployFiles(scriptFiles, config, options);
+    }
+}
+/**
+ * esbuild plugin to mark relative script imports and cross-pack imports as external.
+ * This prevents esbuild from bundling imported scripts, allowing
+ * our rhino-plugin to transform them to __kustom_import() or __kustom_cross_import() calls.
+ */
+function externalScriptImportsPlugin(config) {
+    const libDirs = config.lib || ['scripts/lib'];
+    const declaredDependencies = new Set((config.dependencies || []).map(dep => dep.split('@')[0]));
+    const crossPackImportsUsed = new Set();
+    return {
+        name: 'external-script-imports',
+        setup(build) {
+            // Mark cross-pack imports as external (packId:path format)
+            build.onResolve({ filter: /^[a-z0-9-]+:/ }, (args) => {
+                // Extract pack ID from the import path
+                const match = args.path.match(/^([a-z0-9-]+):/);
+                if (match) {
+                    const packId = match[1];
+                    crossPackImportsUsed.add(packId);
+                    // Warn if importing from undeclared dependency
+                    if (!declaredDependencies.has(packId)) {
+                        console.warn(`  Warning: Cross-pack import from "${packId}" but it's not declared in dependencies`);
+                    }
+                }
+                // Mark as external - will be transformed by rhino-plugin
+                return { path: args.path, external: true };
+            });
+            // Mark relative imports as external, except for lib files
+            build.onResolve({ filter: /^\.\.?\// }, (args) => {
+                // Check if this is a lib import (should be bundled)
+                const isLibImport = libDirs.some(lib => {
+                    const normalizedLib = lib.replace(/\\/g, '/');
+                    const normalizedPath = args.path.replace(/\\/g, '/');
+                    // Check if the resolved path would be in a lib directory
+                    const resolvedDir = path.dirname(args.importer).replace(/\\/g, '/');
+                    const fullPath = path.join(resolvedDir, normalizedPath).replace(/\\/g, '/');
+                    return fullPath.includes(`/${normalizedLib}/`) || fullPath.startsWith(`${normalizedLib}/`);
+                });
+                if (isLibImport) {
+                    // Let esbuild bundle lib files
+                    return null;
+                }
+                // Mark as external - will be transformed by rhino-plugin
+                return { path: args.path, external: true };
+            });
+            // Report cross-pack imports at end of build
+            build.onEnd(() => {
+                if (crossPackImportsUsed.size > 0) {
+                    console.log(`  Cross-pack imports: ${Array.from(crossPackImportsUsed).join(', ')}`);
+                }
+            });
+        }
+    };
+}
+async function buildFile(file, config, options) {
+    const inputPath = path.resolve(process.cwd(), file);
+    const outputPath = getOutputPath(file, config);
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Use esbuild to bundle and transform
+    const result = await esbuild.build({
+        entryPoints: [inputPath],
+        bundle: true,
+        write: false, // We'll write after transforming
+        format: 'esm',
+        target: 'es2020',
+        platform: 'neutral',
+        external: ['kustom-mc'],
+        loader: { '.ts': 'ts' },
+        plugins: [externalScriptImportsPlugin(config)],
+    });
+    if (result.errors.length > 0) {
+        throw new Error(result.errors.map(e => e.text).join('\n'));
+    }
+    const bundledCode = result.outputFiles[0].text;
+    // Transform async/await to generators (for Rhino compatibility)
+    const asyncTransformed = await transformAsyncAwait(bundledCode);
+    // Transform for Rhino compatibility
+    const rhinoCode = transformForRhino(asyncTransformed);
+    // Write output
+    fs.writeFileSync(outputPath, rhinoCode);
+    return outputPath;
+}
+async function watchMode(config, options) {
+    console.log('Starting watch mode...');
+    // Initial build (without deploy - we'll deploy separately)
+    await buildAll(config, { ...options, deploy: false });
+    // Initial deploy if requested (scripts + assets)
+    if (options.deploy && config.deploy?.target) {
+        const patterns = config.include || ['scripts/**/*.ts'];
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: process.cwd(),
+                ignore: config.exclude || []
+            });
+            files.push(...matches);
+        }
+        const libDirs = config.lib || ['scripts/lib'];
+        const scriptFiles = files.filter(file => {
+            return !libDirs.some(lib => file.startsWith(lib + '/') || file.startsWith(lib + '\\'));
+        });
+        await deployFiles(scriptFiles, config, options);
+    }
+    // Watch for changes
+    const patterns = config.include || ['scripts/**/*.ts'];
+    const libDirs = config.lib || ['scripts/lib'];
+    const watcher = chokidar.watch(patterns, {
+        cwd: process.cwd(),
+        ignoreInitial: true,
+        ignored: config.exclude
+    });
+    // Watch sounds folder for type regeneration and deployment
+    const soundsWatcher = chokidar.watch('sounds/**/*.ogg', {
+        cwd: process.cwd(),
+        ignoreInitial: true
+    });
+    soundsWatcher.on('add', async (file) => {
+        console.log(`\nSound added: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(process.cwd());
+        if (options.deploy && config.deploy?.target) {
+            await deploySingleAsset(file, config);
+            console.log(`  Deployed: ${file}`);
+        }
+    });
+    soundsWatcher.on('change', async (file) => {
+        console.log(`\nSound changed: ${file}`);
+        if (options.deploy && config.deploy?.target) {
+            await deploySingleAsset(file, config);
+            console.log(`  Deployed: ${file}`);
+        }
+    });
+    soundsWatcher.on('unlink', async (file) => {
+        console.log(`\nSound removed: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(process.cwd());
+    });
+    // Watch other asset folders (textures, models, gui)
+    const assetPatterns = [
+        'textures/**/*',
+        'models/**/*',
+        'gui/**/*',
+        'items/**/*',
+        'blocks/**/*'
+    ];
+    const assetsWatcher = chokidar.watch(assetPatterns, {
+        cwd: process.cwd(),
+        ignoreInitial: true
+    });
+    assetsWatcher.on('add', async (file) => {
+        if (options.deploy && config.deploy?.target) {
+            console.log(`\nAsset added: ${file}`);
+            await deploySingleAsset(file, config);
+            console.log(`  Deployed: ${file}`);
+        }
+    });
+    assetsWatcher.on('change', async (file) => {
+        if (options.deploy && config.deploy?.target) {
+            console.log(`\nAsset changed: ${file}`);
+            await deploySingleAsset(file, config);
+            console.log(`  Deployed: ${file}`);
+        }
+    });
+    const rebuild = async (changedFile) => {
+        const isLibFile = libDirs.some(lib => changedFile.startsWith(lib + '/') || changedFile.startsWith(lib + '\\'));
+        if (isLibFile) {
+            // Rebuild all files if a lib file changed
+            console.log(`\nLib file changed: ${changedFile}`);
+            console.log('Rebuilding all scripts...');
+            await buildAll(config, { ...options, deploy: options.deploy });
+        }
+        else {
+            // Rebuild just the changed file
+            console.log(`\nFile changed: ${changedFile}`);
+            try {
+                const outputPath = await buildFile(changedFile, config, options);
+                console.log(`  [OK] ${changedFile} -> ${path.relative(process.cwd(), outputPath)}`);
+                if (options.deploy && config.deploy?.target) {
+                    await deploySingleFile(changedFile, config);
+                }
+            }
+            catch (error) {
+                console.error(`  [ERROR] ${changedFile}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+    };
+    watcher.on('change', rebuild);
+    watcher.on('add', rebuild);
+    watcher.on('unlink', (file) => {
+        console.log(`\nFile deleted: ${file}`);
+        const outputPath = getOutputPath(file, config);
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
+            console.log(`  Deleted: ${path.relative(process.cwd(), outputPath)}`);
+        }
+    });
+    console.log('\nWatching for changes... (Ctrl+C to stop)');
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('\nStopping watch mode...');
+        watcher.close();
+        soundsWatcher.close();
+        assetsWatcher.close();
+        process.exit(0);
+    });
+}
+async function deployFiles(sourceFiles, config, options = {}) {
+    if (!config.deploy?.target)
+        return;
+    const targetDir = path.resolve(process.cwd(), config.deploy.target);
+    console.log(`\nDeploying to ${targetDir}...`);
+    // Ensure target directory exists
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Deploy manifest
+    const outDir = getOutDir(config);
+    const manifestSource = path.resolve(outDir, 'kustompack.json');
+    const manifestTarget = path.join(targetDir, 'kustompack.json');
+    if (fs.existsSync(manifestSource)) {
+        fs.copyFileSync(manifestSource, manifestTarget);
+        console.log(`  Deployed kustompack.json`);
+    }
+    // Deploy compiled scripts
+    let deployedScripts = 0;
+    for (const sourceFile of sourceFiles) {
+        await deploySingleFile(sourceFile, config);
+        deployedScripts++;
+    }
+    console.log(`  Deployed ${deployedScripts} script(s)`);
+    // Deploy asset folders (sounds, textures, models, gui, etc.)
+    const deployedAssets = await deployAssets(config, options);
+    if (deployedAssets > 0) {
+        console.log(`  Deployed ${deployedAssets} asset folder(s)`);
+    }
+}
+/**
+ * Deploy a single file from outDir to deploy target
+ */
+async function deploySingleFile(sourceFile, config) {
+    if (!config.deploy?.target)
+        return;
+    // Source is in outDir
+    const outputPath = getOutputPath(sourceFile, config);
+    // Target preserves relative path structure
+    const relativePath = sourceFile.replace(/\.ts$/, '.js');
+    const targetDir = path.resolve(process.cwd(), config.deploy.target);
+    const targetPath = path.join(targetDir, relativePath);
+    // Ensure target subdirectory exists
+    const targetSubDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetSubDir)) {
+        fs.mkdirSync(targetSubDir, { recursive: true });
+    }
+    // Copy file from outDir to deploy target
+    if (fs.existsSync(outputPath)) {
+        fs.copyFileSync(outputPath, targetPath);
+    }
+}
+/**
+ * Asset folders that should be deployed alongside scripts
+ */
+const ASSET_FOLDERS = ['sounds', 'textures', 'models', 'gui', 'items', 'blocks'];
+/**
+ * Copy a folder recursively
+ */
+function copyFolderRecursive(source, target) {
+    // Ensure target directory exists
+    if (!fs.existsSync(target)) {
+        fs.mkdirSync(target, { recursive: true });
+    }
+    const entries = fs.readdirSync(source, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(source, entry.name);
+        const targetPath = path.join(target, entry.name);
+        if (entry.isDirectory()) {
+            copyFolderRecursive(sourcePath, targetPath);
+        }
+        else {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+/**
+ * Deploy asset folders (sounds, textures, models, gui, etc.) to deploy target
+ */
+async function deployAssets(config, options) {
+    if (!config.deploy?.target)
+        return 0;
+    const targetDir = path.resolve(process.cwd(), config.deploy.target);
+    let deployedCount = 0;
+    for (const folder of ASSET_FOLDERS) {
+        const sourceDir = path.resolve(process.cwd(), folder);
+        if (fs.existsSync(sourceDir)) {
+            const targetSubDir = path.join(targetDir, folder);
+            copyFolderRecursive(sourceDir, targetSubDir);
+            deployedCount++;
+            if (options.verbose) {
+                console.log(`  Deployed ${folder}/`);
+            }
+        }
+    }
+    return deployedCount;
+}
+/**
+ * Deploy a single asset file to deploy target
+ */
+async function deploySingleAsset(assetFile, config) {
+    if (!config.deploy?.target)
+        return;
+    const sourcePath = path.resolve(process.cwd(), assetFile);
+    const targetDir = path.resolve(process.cwd(), config.deploy.target);
+    const targetPath = path.join(targetDir, assetFile);
+    // Ensure target subdirectory exists
+    const targetSubDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetSubDir)) {
+        fs.mkdirSync(targetSubDir, { recursive: true });
+    }
+    // Copy file
+    if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}

package/dist/commands/bundle.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const bundleCommand: Command;

package/dist/commands/bundle.js

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import archiver from 'archiver';
+import chalk from 'chalk';
+import { loadConfig, generateManifest, validateManifest } from '../config.js';
+export const bundleCommand = new Command('bundle')
+    .description('Create a distributable zip file with manifest')
+    .option('-o, --output <file>', 'Output file name')
+    .option('--include-source', 'Include TypeScript source files')
+    .option('--no-manifest', 'Skip manifest generation (use existing kustompack.json)')
+    .action(async (options) => {
+    const config = loadConfig(process.cwd());
+    // Validate manifest configuration
+    const errors = validateManifest(config);
+    if (errors.length > 0) {
+        console.error(chalk.red('Manifest validation failed:'));
+        for (const error of errors) {
+            console.error(chalk.red(`  - ${error}`));
+        }
+        process.exit(1);
+    }
+    const packId = config.manifest?.id || 'kustompack';
+    const outputFile = options.output || config.bundle?.output || `dist/${packId}.zip`;
+    const outputPath = path.resolve(process.cwd(), outputFile);
+    console.log(chalk.blue(`Creating bundle for pack: ${chalk.bold(packId)}`));
+    console.log(`  Version: ${config.manifest?.version || '1.0.0'}`);
+    console.log(`  Output: ${outputFile}`);
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Generate manifest if enabled
+    let manifestContent = null;
+    if (options.manifest !== false) {
+        try {
+            manifestContent = generateManifest(config);
+            console.log(chalk.green('  Generated kustompack.json'));
+        }
+        catch (error) {
+            console.error(chalk.red(`Failed to generate manifest: ${error}`));
+            process.exit(1);
+        }
+    }
+    // Create zip archive
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    let fileCount = 0;
+    output.on('close', () => {
+        const sizeKB = (archive.pointer() / 1024).toFixed(2);
+        console.log(chalk.green(`\nBundle created successfully!`));
+        console.log(`  File: ${outputFile}`);
+        console.log(`  Size: ${sizeKB} KB`);
+        console.log(`  Files: ${fileCount}`);
+    });
+    archive.on('warning', (err) => {
+        if (err.code === 'ENOENT') {
+            console.warn(chalk.yellow('Warning:'), err.message);
+        }
+        else {
+            throw err;
+        }
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    archive.pipe(output);
+    // Add manifest first
+    if (manifestContent) {
+        archive.append(manifestContent, { name: 'kustompack.json' });
+        fileCount++;
+    }
+    else {
+        // Check for existing manifest
+        const existingManifest = path.resolve(process.cwd(), 'kustompack.json');
+        if (fs.existsSync(existingManifest)) {
+            archive.file(existingManifest, { name: 'kustompack.json' });
+            fileCount++;
+        }
+        else {
+            console.warn(chalk.yellow('Warning: No kustompack.json found. Pack may not load correctly.'));
+        }
+    }
+    // Add files based on bundle config
+    const includePatterns = config.bundle?.include || [
+        '**/*.js',
+        'textures/**/*',
+        'gui/**/*',
+        'models/**/*',
+        'sounds/**/*'
+    ];
+    const addedFiles = new Set();
+    for (const pattern of includePatterns) {
+        const files = await glob(pattern, {
+            cwd: process.cwd(),
+            nodir: true,
+            ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
+        });
+        for (const file of files) {
+            if (addedFiles.has(file))
+                continue;
+            const filePath = path.resolve(process.cwd(), file);
+            if (fs.existsSync(filePath)) {
+                archive.file(filePath, { name: file });
+                addedFiles.add(file);
+                fileCount++;
+            }
+        }
+    }
+    // Optionally include source files
+    if (options.includeSource) {
+        const sourcePatterns = config.include || ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'];
+        for (const pattern of sourcePatterns) {
+            const files = await glob(pattern, {
+                cwd: process.cwd(),
+                nodir: true,
+                ignore: config.exclude
+            });
+            for (const file of files) {
+                if (addedFiles.has(file))
+                    continue;
+                const filePath = path.resolve(process.cwd(), file);
+                if (fs.existsSync(filePath)) {
+                    archive.file(filePath, { name: file });
+                    addedFiles.add(file);
+                    fileCount++;
+                }
+            }
+        }
+    }
+    await archive.finalize();
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;