create-mcbepack 1.0.0

package/README.md

@@ -0,0 +1,197 @@
+# create-mcbepack
+
+Interactive CLI tool for scaffolding MCBEPACK projects
+
+[![npm version](https://badge.fury.io/js/create-mcbepack.svg)](https://www.npmjs.com/package/create-mcbepack)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
+## Overview
+
+`create-mcbepack` is an interactive command-line tool that facilitates rapid scaffolding of Minecraft Bedrock Edition addon projects with best practices and modern development tooling.
+
+## Features
+
+- **Interactive Project Setup** - Guided prompts for project configuration
+- **Multiple Pack Types** - Support for Behavior Packs and Resource Packs
+- **Script API Integration** - Optional Script API setup with package selection
+- **Language Choice** - TypeScript or JavaScript support
+- **Release Channel Selection** - Choose between stable, beta, or preview releases
+- **Auto-generated Configuration** - Automatic manifest, package.json, and tsconfig generation
+- **Project Templates** - Pre-configured templates with best practices
+
+## Usage
+
+### Quick Start
+
+```bash
+bunx create-mcbepack
+```
+
+### Interactive Prompts
+
+The CLI will guide you through the following steps:
+
+1. **Pack Type Selection**
+   - Choose between Behavior Pack and/or Resource Pack
+
+2. **Project Information**
+   - Project name
+   - Description
+   - Author name(s)
+   - Minimum engine version
+
+3. **Script API Configuration** (if Behavior Pack is selected)
+   - Enable/disable Script API
+   - Select programming language (TypeScript/JavaScript)
+   - Choose game release channel (stable/beta/preview)
+   - Select Script API packages to include:
+     - `@minecraft/server`
+     - `@minecraft/server-ui`
+     - `@minecraft/server-net`
+     - `@minecraft/server-admin`
+     - `@minecraft/server-gametest`
+     - `@minecraft/vanilla-data`
+     - `@minecraft/math`
+
+4. **Project Preview**
+   - Review generated file structure
+   - Confirm project creation
+
+### Example
+
+```bash
+$ bunx create-mcbepack
+
+Create MCBEPack
+
+? Select a extension type?
+  ◉ Behavior Pack
+  ◉ Resource Pack
+
+? What is the name of the project? my-awesome-addon
+? What is the description of the project? An amazing Minecraft addon
+? What is the author's name? YourName
+? What is the minimum engine version required? 1.21.0
+
+? Do you want to add a script api to behavior? Yes
+? Which language do you want to use? typescript
+? What game type would you like to use? stable
+? Which packages would you like to add?
+  ◉ @minecraft/server
+  ◉ @minecraft/server-ui
+
+Success! Created project my-awesome-addon
+   at: /path/to/my-awesome-addon
+
+Next steps:
+
+  1. cd my-awesome-addon
+  2. bun install
+  3. bun run dev
+
+Available commands:
+   • bun run dev    - Start development server
+   • bun run build:zip  - Build project
+   • bun run build:mcpack  - Build project
+   • bun run build:addon  - Build project
+```
+
+## Generated Project Structure
+
+```
+my-awesome-addon/
+├── scripts/              # TypeScript/JavaScript source files (if Script API enabled)
+│   └── index.ts
+├── .env.local           # Minecraft path configuration
+├── .gitignore
+├── package.json
+├── tsconfig.json        # TypeScript configuration (if TypeScript selected)
+├── pack_icon.png
+└── README.md
+```
+
+## Configuration Files
+
+### package.json
+
+Automatically generated with:
+
+- Project metadata
+- Script API dependencies (if enabled)
+- Development scripts
+- Peer dependencies (`@mcbepack/cli`, `@mcbepack/api`)
+
+### tsconfig.json
+
+Pre-configured TypeScript settings optimized for Minecraft addon development:
+
+- ESNext target
+- Bundler module resolution
+- Source maps disabled for production
+
+### .env.local
+
+Minecraft installation paths configuration:
+
+```env
+BASE_PATH="C:\Users\YourName\AppData\Roaming\Minecraft Bedrock\Users\Shared\games\com.mojang"
+RESOURCE_PATH="development_resource_packs"
+BEHAVIOR_PATH="development_behavior_packs"
+```
+
+## Development
+
+### Building from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/bugphxne/create-mcbepack.git
+cd mcbepack/packages/create-mcbepack
+
+# Install dependencies
+bun install
+
+# Build
+bun run build
+
+# Test locally
+bun run test
+```
+
+### Project Structure
+
+```
+create-mcbepack/
+├── src/
+│   ├── index.ts          # Main CLI entry point
+│   ├── prompt.ts         # Interactive prompts
+│   ├── types.ts          # TypeScript type definitions
+│   └── utils/
+│       ├── collect-info.ts    # Project information collection
+│       ├── create-files.ts    # File generation
+│       └── generate-files.ts  # File list generation
+├── templates/            # Project templates
+│   ├── README.md
+│   ├── tsconfig.json
+│   ├── .env.local
+│   ├── .gitignore
+│   └── pack_icon.png
+└── bin/                  # Compiled output
+```
+
+## Related Packages
+
+- [`@mcbepack/cli`](../cli) - Development and build tooling
+- [`@mcbepack/api`](../api) - Utility APIs for Script API
+- [`@mcbepack/common`](../common) - Shared utilities
+
+## License
+
+GPL-3.0 - see [LICENSE](./LICENSE) for details
+
+## Resources
+
+- [GitHub Repository](https://github.com/bugphxne/create-mcbepack)
+- [npm Package](https://www.npmjs.com/package/create-mcbepack)
+- [Documentation](https://docs.mbext.online/mcbepack)
+- [Issue Tracker](https://github.com/bugphxne/create-mcbepack/issues)

package/out/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+import { collectProjectInfo } from "./utils/collect-info";
+import { generateFileList } from "./utils/generate-files";
+import { createFiles, previewFiles } from "./utils/create-files";
+import prompt from "./prompt";
+async function main() {
+    try {
+        console.log(pc.bold(pc.cyan("\nCreate MCBEPack\n")));
+        const config = await collectProjectInfo();
+        const files = generateFileList(config);
+        previewFiles(files, config.name);
+        console.log();
+        const { confirmed } = await prompt.confirm({
+            message: "Do you want to create this project?",
+            default: true,
+        });
+        if (!confirmed) {
+            console.log(pc.yellow("\nProject creation cancelled"));
+            process.exit(0);
+        }
+        const projectRoot = path.join(process.cwd(), config.name);
+        if (fs.existsSync(projectRoot)) {
+            console.log(pc.red(`\nDirectory ${config.name} already exists`));
+            process.exit(1);
+        }
+        createFiles(files);
+        console.log(`\n${pc.green("Success!")} Created project ${pc.cyan(config.name)}`);
+        console.log(pc.dim(`   at: ${projectRoot}\n`));
+        console.log(pc.bold("Next steps:\n"));
+        console.log(`  ${pc.cyan("1.")} cd ${config.name}`);
+        if (config.script?.enabled) {
+            console.log(`  ${pc.cyan("2.")} bun install`);
+            console.log(`  ${pc.cyan("3.")} bun run dev\n`);
+        }
+        else {
+            console.log(`  ${pc.cyan("2.")} Start developing your project\n`);
+        }
+        if (config.script?.enabled) {
+            console.log(pc.dim("Available commands:"));
+            console.log(pc.dim("   • bun run dev    - Start development server"));
+            console.log(pc.dim("   • bun run build:zip  - Build project"));
+            console.log(pc.dim("   • bun run build:mcpack  - Build project"));
+            console.log(pc.dim("   • bun run build:addon  - Build project"));
+        }
+        else {
+            console.log(pc.dim("Available commands:"));
+            console.log(pc.dim("   • bun run build:zip  - Build project"));
+            console.log(pc.dim("   • bun run build:mcpack  - Build project"));
+            console.log(pc.dim("   • bun run build:addon  - Build project"));
+        }
+    }
+    catch (error) {
+        console.error(pc.red("\nError occurred:"), error);
+        process.exit(1);
+    }
+}
+main();

package/out/prompt.js

@@ -0,0 +1,92 @@
+import enquirer from 'enquirer';
+import { constants } from '@mcbepack/common';
+const extension = async () => {
+    const response = await enquirer.prompt({
+        type: 'multiselect',
+        name: 'extensions',
+        message: 'Select a extension type?',
+        choices: [
+            { name: 'behavior', message: 'Behavior Pack' },
+            { name: 'resource', message: 'Resource Pack' },
+        ]
+    });
+    return response;
+};
+const api = async () => {
+    const response = await enquirer.prompt({
+        type: "confirm",
+        name: "api",
+        message: "Do you want to add a script api to behavior?",
+        initial: true
+    });
+    return response;
+};
+const info = async () => {
+    const response = await enquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'What is the name of the project?',
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'What is the description of the project?',
+        },
+        {
+            type: 'input',
+            name: 'author',
+            message: 'What is the author\'s name? Use commas to separate multiple authors(,).',
+        },
+        {
+            type: 'input',
+            name: 'minimumEngineVersion',
+            message: 'What is the minimum engine version required?',
+            validate: input => {
+                if (input.length === 0)
+                    return 'Minimum engine version is required';
+                const version = input.split('.');
+                const response = 'Minimum engine version must be in the format x.x.x';
+                return version.every((v) => !isNaN(parseInt(v))) || response;
+            }
+        }
+    ]);
+    return response;
+};
+const script = async () => {
+    const response = await enquirer.prompt([
+        {
+            type: 'select',
+            name: 'language',
+            message: 'Which language do you want to use?',
+            choices: ['typescript', 'javascript']
+        },
+        {
+            type: 'select',
+            name: 'release',
+            message: 'What game type would you like to use?',
+            choices: ['stable', 'beta', 'preview'],
+        },
+        {
+            type: 'multiselect',
+            name: 'packages',
+            message: 'Which packages would you like to add?',
+            choices: [
+                ...constants.packages.modules,
+                ...constants.packages.plugins
+            ],
+            validate: input => input.length > 0 || 'At least one package is required'
+        }
+    ]);
+    return response;
+};
+const confirm = async (options) => {
+    const response = await enquirer.prompt({
+        type: "confirm",
+        name: "confirmed",
+        message: options.message,
+        initial: options.default ?? true
+    });
+    return response;
+};
+export default { extension, api, info, script, confirm };

package/out/types.js

@@ -0,0 +1 @@
+export {};

package/out/utils/collect-info.js

@@ -0,0 +1,54 @@
+import { v4 as uuidv4 } from "uuid";
+import pc from "picocolors";
+import { getDependency } from "@mcbepack/common";
+import prompt from "../prompt";
+export async function collectProjectInfo() {
+    console.log(pc.bold("Please provide project information\n"));
+    const { extensions } = await prompt.extension();
+    const { name, description, author, minimumEngineVersion } = await prompt.info();
+    const uuids = {
+        behavior: uuidv4(),
+        resource: uuidv4(),
+        scriptModule: uuidv4(),
+    };
+    const config = {
+        name,
+        description,
+        author,
+        minimumEngineVersion,
+        extensions,
+        uuids,
+    };
+    if (extensions.includes("behavior")) {
+        const { api } = await prompt.api();
+        if (api) {
+            const { language, release, packages } = await prompt.script();
+            console.log(pc.dim("\nFetching dependencies..."));
+            const dependencies = await Promise.all(packages.map(async (packageName) => {
+                const dep = await getDependency(packageName, release);
+                return {
+                    packageName: dep.packageName,
+                    version: dep.version,
+                    fullVersion: dep.fullVersion,
+                };
+            }));
+            config.script = {
+                enabled: true,
+                language,
+                release,
+                packages,
+                dependencies,
+            };
+        }
+        else {
+            config.script = {
+                enabled: false,
+                language: "javascript",
+                release: "",
+                packages: [],
+                dependencies: [],
+            };
+        }
+    }
+    return config;
+}

package/out/utils/create-files.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+export function createFiles(files) {
+    console.log(`\nCreating ${files.length} files...\n`);
+    for (const file of files) {
+        try {
+            const dir = path.dirname(file.path);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            if (file.type === "copy" && file.source) {
+                fs.copyFileSync(file.source, file.path);
+            }
+            else {
+                fs.writeFileSync(file.path, file.content);
+            }
+            console.log(`  ${pc.green("✓")} ${path.relative(process.cwd(), file.path)}`);
+        }
+        catch (error) {
+            console.error(`  ${pc.red("✗")} ${path.relative(process.cwd(), file.path)}`);
+            throw error;
+        }
+    }
+}
+export function previewFiles(files, projectName) {
+    console.log(`\nFiles to be created in ${pc.cyan(projectName)}:\n`);
+    const projectRoot = path.join(process.cwd(), projectName);
+    const tree = buildFileTree(files, projectRoot);
+    printTree(tree);
+}
+function buildFileTree(files, projectRoot) {
+    const root = {
+        name: path.basename(projectRoot),
+        type: "directory",
+        children: new Map(),
+    };
+    for (const file of files) {
+        const relativePath = path.relative(projectRoot, file.path);
+        const parts = relativePath.split(path.sep);
+        let current = root;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            if (!current.children) {
+                current.children = new Map();
+            }
+            if (!current.children.has(part)) {
+                current.children.set(part, {
+                    name: part,
+                    type: isLast ? "file" : "directory",
+                    children: isLast ? undefined : new Map(),
+                });
+            }
+            current = current.children.get(part);
+        }
+    }
+    return root;
+}
+function printTree(node, prefix = "", isLast = true) {
+    const connector = isLast ? "└── " : "├── ";
+    if (prefix === "") {
+        console.log(`  ${pc.cyan(node.name)}/`);
+    }
+    else {
+        const displayName = node.type === "directory" ? `${pc.cyan(node.name)}/` : node.name;
+        console.log(`  ${prefix}${connector}${displayName}`);
+    }
+    if (node.children) {
+        const children = Array.from(node.children.values());
+        children.forEach((child, index) => {
+            const isLastChild = index === children.length - 1;
+            const newPrefix = prefix + (isLast ? "    " : "│   ");
+            printTree(child, newPrefix, isLastChild);
+        });
+    }
+}

package/out/utils/generate-files.js

@@ -0,0 +1,191 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { constants } from "@mcbepack/common";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function generateFileList(config) {
+    const files = [];
+    const projectRoot = path.join(process.cwd(), config.name);
+    const templatesDir = path.join(__dirname, "..", "..", "templates");
+    const baseManifest = {
+        format_version: 2,
+        header: {
+            name: config.name,
+            description: config.description,
+            uuid: "",
+            version: [1, 0, 0],
+            min_engine_version: config.minimumEngineVersion.split('.').map(Number),
+        },
+        metadata: {
+            authors: config.author.split(',').map(a => a.trim()),
+            generated_with: {
+                "create-mcbepack": [1, 0, 0],
+            },
+        },
+    };
+    files.push({
+        path: path.join(projectRoot, "README.md"),
+        content: "",
+        type: "copy",
+        source: path.join(templatesDir, "README.md"),
+    });
+    if (config.extensions.includes("behavior")) {
+        const bpRoot = path.join(projectRoot, "src", "behavior_pack");
+        files.push({
+            path: path.join(bpRoot, "pack_icon.png"),
+            content: "",
+            type: "copy",
+            source: path.join(templatesDir, "pack_icon.png"),
+        });
+        const bpManifest = {
+            ...baseManifest,
+            header: {
+                ...baseManifest.header,
+                uuid: config.uuids.behavior,
+            },
+            capabilities: ['script_eval'],
+            modules: [],
+            dependencies: [],
+        };
+        if (config.script?.enabled) {
+            bpManifest.modules = [
+                {
+                    type: "script",
+                    language: "javascript",
+                    entry: "scripts/index.js",
+                    uuid: config.uuids.scriptModule,
+                    version: [1, 0, 0],
+                },
+            ];
+            bpManifest.dependencies = [
+                ...config.script.dependencies
+                    .filter(dep => !constants.packages.plugins.includes(dep.packageName))
+                    .map(dep => ({
+                    module_name: dep.packageName,
+                    version: dep.version,
+                })),
+            ];
+            if (config.extensions.includes("resource")) {
+                bpManifest.dependencies.push({
+                    uuid: config.uuids.resource,
+                    version: [1, 0, 0],
+                });
+            }
+            files.push({
+                path: path.join(projectRoot, ".env.local"),
+                content: "",
+                type: "copy",
+                source: path.join(templatesDir, ".env.local"),
+            });
+            files.push({
+                path: path.join(projectRoot, ".gitignore"),
+                content: "",
+                type: "copy",
+                source: path.join(templatesDir, ".gitignore"),
+            });
+            const packageJson = {
+                name: config.name,
+                scripts: {
+                    dev: "mcbepack dev",
+                    "build:zip": "mcbepack build -o zip",
+                    "build:mcpack": "mcbepack build -o mcpack",
+                    "build:addon": "mcbepack build -o addon",
+                    "update:stable": "mcbepack update -o stable",
+                    "update:beta": "mcbepack update -o beta",
+                    "update:preview": "mcbepack update -o preview",
+                },
+                devDependencies: Object.fromEntries(config.script.dependencies.map(dep => [dep.packageName, dep.fullVersion])),
+                peerDependencies: {
+                    "@mcbepack/cli": "latest",
+                    "@mcbepack/api": "latest",
+                    ...(config.script.language === "typescript" ? { "typescript": "latest" } : {})
+                }
+            };
+            files.push({
+                path: path.join(projectRoot, "package.json"),
+                content: JSON.stringify(packageJson, null, 2),
+                type: "file",
+            });
+            const scriptsDir = path.join(projectRoot, "scripts");
+            if (config.script.language === "typescript") {
+                files.push({
+                    path: path.join(scriptsDir, "index.ts"),
+                    content: "console.log('Hello World!');",
+                    type: "file",
+                });
+                files.push({
+                    path: path.join(projectRoot, "tsconfig.json"),
+                    content: "",
+                    type: "copy",
+                    source: path.join(templatesDir, "tsconfig.json"),
+                });
+            }
+            else {
+                files.push({
+                    path: path.join(scriptsDir, "index.js"),
+                    content: "console.log('Hello World!');",
+                    type: "file",
+                });
+            }
+        }
+        files.push({
+            path: path.join(bpRoot, "manifest.json"),
+            content: JSON.stringify(bpManifest, null, 2),
+            type: "file",
+        });
+    }
+    if (config.extensions.includes("resource")) {
+        const rpRoot = path.join(projectRoot, "src", "resource_pack");
+        files.push({
+            path: path.join(rpRoot, "pack_icon.png"),
+            content: "",
+            type: "copy",
+            source: path.join(templatesDir, "pack_icon.png"),
+        });
+        const rpManifest = {
+            ...baseManifest,
+            header: {
+                ...baseManifest.header,
+                uuid: config.uuids.resource,
+            },
+            modules: [
+                {
+                    type: "resources",
+                    uuid: config.uuids.resource,
+                    version: [1, 0, 0],
+                },
+            ],
+            dependencies: [],
+        };
+        if (config.extensions.includes("behavior")) {
+            rpManifest.dependencies = [
+                {
+                    uuid: config.uuids.behavior,
+                    version: [1, 0, 0],
+                }
+            ];
+        }
+        files.push({
+            path: path.join(rpRoot, "manifest.json"),
+            content: JSON.stringify(rpManifest, null, 2),
+            type: "file",
+        });
+    }
+    if (!config.script?.enabled) {
+        files.push({
+            path: path.join(projectRoot, "package.json"),
+            content: JSON.stringify({
+                scripts: {
+                    "build:zip": "mcbepack build -o zip",
+                    "build:mcpack": "mcbepack build -o mcpack",
+                    "build:addon": "mcbepack build -o addon",
+                },
+                peerDependencies: {
+                    "@mcbepack/cli": "latest"
+                }
+            }, null, 2),
+            type: "file",
+        });
+    }
+    return files;
+}