create-mcbepack 1.0.6 → 1.0.8

package/README.md

@@ -1,8 +1,6 @@
 # create-mcbepack
 
-Interactive scaffolder for Minecraft Bedrock Edition add-on projects.
-
-It creates the pack folders, manifests, optional Script API entry point, package scripts, and Minecraft development-path configuration expected by `@mcbepack/cli`.
+Interactive scaffolder for MCBEPACK projects.
 
 ## Usage
 
@@ -10,72 +8,15 @@ It creates the pack folders, manifests, optional Script API entry point, package
 bunx create-mcbepack
 ```
 
-The prompts ask for:
-
-- behavior pack and/or resource pack
-- project name, description, author, and minimum engine version
-- optional Script API support
-- TypeScript or JavaScript
-- stable, beta, or preview Script API release channel
-- Minecraft package modules to include
-
-## Generated Scripts
-
-Script API projects include:
-
-```json
-{
-  "scripts": {
-    "dev": "mcbepack dev",
-    "build:zip": "mcbepack build -o zip",
-    "build:mcpack": "mcbepack build -o mcpack",
-    "build:mcaddon": "mcbepack build -o mcaddon",
-    "update:stable": "mcbepack update -t stable",
-    "update:beta": "mcbepack update -t beta",
-    "update:preview": "mcbepack update -t preview"
-  }
-}
-```
-
-Non-script projects include the three build commands.
+It creates behavior/resource packs, manifests, package scripts, and optional Script API setup.
 
-## Generated Layout
-
-```text
-my-addon/
-|-- scripts/
-|   `-- index.ts
-|-- src/
-|   |-- behavior_pack/
-|   |   |-- manifest.json
-|   |   `-- pack_icon.png
-|   `-- resource_pack/
-|       |-- manifest.json
-|       `-- pack_icon.png
-|-- .env.local
-|-- .gitignore
-|-- package.json
-|-- README.md
-`-- tsconfig.json
-```
-
-Some files are only created when the selected options need them.
-
-## Local Development
-
-From the repository root:
+## Development
 
 ```bash
 bun install
 bun --cwd packages/create-mcbepack run build
 ```
 
-## Related Packages
-
-- [`@mcbepack/cli`](../@mcbepack/cli)
-- [`@mcbepack/api`](../@mcbepack/api)
-- [`@mcbepack/common`](../@mcbepack/common)
-
 ## License
 
-GPL-3.0. See [LICENSE](./LICENSE).
+GPL-3.0

package/dist/config/constant.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Extension } from "./enum.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const SCRIPTS_BASE = [
+    { name: "export:zip", cmd: "mcbepack export zip", desc: "Export .zip" },
+    { name: "export:mcpack", cmd: "mcbepack export mcpack", desc: "Export .mcpack" },
+    { name: "export:mcaddon", cmd: "mcbepack export mcaddon", desc: "Export .mcaddon" },
+];
+export const SCRIPTS_SCRIPT_API = [
+    { name: "dev", cmd: "mcbepack dev", desc: "Dev server" },
+    { name: "build", cmd: "mcbepack build", desc: "Build" },
+    { name: "update:stable", cmd: "mcbepack update stable", desc: "Update stable" },
+    { name: "update:beta", cmd: "mcbepack update beta", desc: "Update beta" },
+    { name: "update:preview", cmd: "mcbepack update preview", desc: "Update preview" },
+];
+export const DIRECTORIES = {
+    template: path.join(__dirname, "..", "..", "templates"),
+    [Extension.Behavior]: path.join("src", "behavior_pack"),
+    [Extension.Resource]: path.join("src", "resource_pack"),
+};

package/dist/config/enum.js

@@ -0,0 +1,24 @@
+export var Extension;
+(function (Extension) {
+    Extension["Behavior"] = "behavior";
+    Extension["Resource"] = "resource";
+})(Extension || (Extension = {}));
+export var ScriptLanguage;
+(function (ScriptLanguage) {
+    ScriptLanguage["TypeScript"] = "typescript";
+    ScriptLanguage["JavaScript"] = "javascript";
+})(ScriptLanguage || (ScriptLanguage = {}));
+export var Release;
+(function (Release) {
+    Release["Stable"] = "stable";
+    Release["Beta"] = "beta";
+    Release["Preview"] = "preview";
+})(Release || (Release = {}));
+export var PackageManager;
+(function (PackageManager) {
+    PackageManager["Npm"] = "npm";
+    PackageManager["Yarn"] = "yarn";
+    PackageManager["Pnpm"] = "pnpm";
+    PackageManager["Bun"] = "bun";
+    PackageManager["Deno"] = "deno";
+})(PackageManager || (PackageManager = {}));

package/dist/generator/manifest.js

@@ -0,0 +1,84 @@
+import pkg from "../../package.json" with { type: "json" };
+import { Extension } from "../config/enum.js";
+import { json } from "../utils.js";
+const pluginPackages = new Set();
+export const ver = () => [1, 0, 0];
+export function buildBaseManifest(context) {
+    return {
+        format_version: 2,
+        header: {
+            name: context.name,
+            description: context.description,
+            uuid: "",
+            version: ver(),
+            min_engine_version: context.minEngineVersion,
+        },
+        metadata: {
+            authors: context.author.split(",").map((s) => s.trim()).filter(Boolean),
+            generated_with: {
+                "create-mcbepack": pkg.version
+            },
+        },
+    };
+}
+export function buildBehaviorManifest(context) {
+    const base = buildBaseManifest(context);
+    const scriptDeps = context.script?.enabled
+        ? context.script.dependencies
+            .filter((d) => !pluginPackages.has(d.packageName))
+            .map((d) => ({ module_name: d.packageName, version: d.version }))
+        : [];
+    const resourceDep = context.script?.enabled && context.extensions.includes(Extension.Resource)
+        ? [
+            {
+                uuid: context.uuids.resource,
+                version: ver()
+            }
+        ]
+        : [];
+    return json({
+        ...base,
+        header: {
+            ...base.header,
+            uuid: context.uuids.behavior
+        },
+        ...(context.script?.enabled ? { capabilities: ["script_eval"] } : {}),
+        modules: context.script?.enabled
+            ? [
+                {
+                    type: "script",
+                    language: "javascript",
+                    entry: "scripts/index.js",
+                    uuid: context.uuids.scriptModule,
+                    version: ver(),
+                }
+            ]
+            : [],
+        dependencies: [...scriptDeps, ...resourceDep],
+    });
+}
+export function buildResourceManifest(context) {
+    const base = buildBaseManifest(context);
+    return json({
+        ...base,
+        header: {
+            ...base.header,
+            uuid: context.uuids.resource
+        },
+        modules: [
+            {
+                type: "resources",
+                uuid: context.uuids.resourceModule,
+                version: ver()
+            }
+        ],
+        dependencies: context.extensions.includes(Extension.Behavior)
+            ? [
+                {
+                    uuid: context.uuids.behavior,
+                    version: ver()
+                }
+            ]
+            : [],
+    });
+}

package/dist/generator/package.js

@@ -0,0 +1,23 @@
+import { SCRIPTS_BASE, SCRIPTS_SCRIPT_API } from "../config/constant.js";
+import { ScriptLanguage } from "../config/enum.js";
+import { json } from "../utils.js";
+export function buildPackageJson(context) {
+    const scripts = context.script?.enabled
+        ? [...SCRIPTS_SCRIPT_API, ...SCRIPTS_BASE]
+        : [...SCRIPTS_BASE];
+    const devDeps = { "@mcbepack/cli": "latest" };
+    if (context.script?.enabled) {
+        devDeps["@mcbepack/api"] = "latest";
+        if (context.script.language === ScriptLanguage.TypeScript) {
+            devDeps["typescript"] = "latest";
+        }
+        for (const dep of context.script.dependencies) {
+            devDeps[dep.packageName] = dep.fullVersion;
+        }
+    }
+    return json({
+        name: context.name,
+        scripts: Object.fromEntries(scripts.map((s) => [s.name, s.cmd])),
+        devDependencies: devDeps,
+    });
+}

package/dist/generator/readme.js

@@ -0,0 +1,20 @@
+import { SCRIPTS_BASE, SCRIPTS_SCRIPT_API } from "../config/constant.js";
+export function buildReadme(context) {
+    const pm = context.packageManager;
+    const scripts = context.script?.enabled
+        ? [...SCRIPTS_SCRIPT_API, ...SCRIPTS_BASE]
+        : [...SCRIPTS_BASE];
+    const cmds = scripts.map((s) => `${pm} run ${s.name.padEnd(16)} # ${s.desc}`).join("\n");
+    return `# ${context.name}
+
+${context.description}
+
+> Generated with \`create-mcbepack\`
+
+## Commands
+
+\`\`\`bash
+${cmds}
+\`\`\`
+`;
+}

package/dist/index.js

@@ -1,56 +1,70 @@
 #!/usr/bin/env node
-import fs from "node:fs";
+import { execFileSync } from "node:child_process";
 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.")} bun install`);
-            console.log(`  ${pc.cyan("3.")} Start developing your project\n`);
-        }
-        console.log(pc.dim("Available commands:"));
-        if (config.script?.enabled) {
-            console.log(pc.dim("   - bun run dev             - Start development server"));
-            console.log(pc.dim("   - bun run update:stable   - Update Script API packages"));
+import chalk from "chalk";
+import { logger } from "@mcbepack/common";
+import { DIRECTORIES } from "./config/constant.js";
+import { Extension, ScriptLanguage } from "./config/enum.js";
+import { buildBehaviorManifest, buildResourceManifest } from "./generator/manifest.js";
+import { buildPackageJson } from "./generator/package.js";
+import { buildReadme } from "./generator/readme.js";
+import { confirmPrompt, createContext } from "./prompts.js";
+import { FileGenerator } from "./utils.js";
+try {
+    const context = await createContext();
+    const projectRoot = path.join(process.cwd(), context.name);
+    const confirmed = await confirmPrompt(`Do you want to continue with the following configuration?`);
+    if (!confirmed) {
+        logger.warn("Project creation cancelled.");
+        process.exit(0);
+    }
+    const generator = new FileGenerator(projectRoot);
+    generator.create(path.join(projectRoot, "README.md"), buildReadme(context));
+    generator.create(path.join(projectRoot, "package.json"), buildPackageJson(context));
+    if (context.extensions.includes(Extension.Behavior)) {
+        generator.create(path.join(projectRoot, DIRECTORIES.behavior, "manifest.json"), buildBehaviorManifest(context));
+        generator.copy(path.join(projectRoot, DIRECTORIES.behavior, "pack_icon.png"), path.join(DIRECTORIES.template, "pack_icon.png"));
+    }
+    if (context.extensions.includes(Extension.Resource)) {
+        generator.create(path.join(projectRoot, DIRECTORIES.resource, "manifest.json"), buildResourceManifest(context));
+        generator.copy(path.join(projectRoot, DIRECTORIES.resource, "pack_icon.png"), path.join(DIRECTORIES.template, "pack_icon.png"));
+    }
+    if (context.script?.enabled) {
+        const lang = context.script.language;
+        generator.create(path.join(projectRoot, "scripts", lang === ScriptLanguage.TypeScript ? "index.ts" : "index.js"), "export {};\n");
+        generator.copy(path.join(projectRoot, ".env.local"), path.join(DIRECTORIES.template, ".env.local.txt"));
+        generator.copy(path.join(projectRoot, ".gitignore"), path.join(DIRECTORIES.template, ".gitignore.txt"));
+        if (lang === ScriptLanguage.TypeScript) {
+            generator.copy(path.join(projectRoot, "tsconfig.json"), path.join(DIRECTORIES.template, "tsconfig.json"));
         }
-        console.log(pc.dim("   - bun run build:zip       - Build a .zip archive"));
-        console.log(pc.dim("   - bun run build:mcpack    - Build .mcpack archive(s)"));
-        console.log(pc.dim("   - bun run build:mcaddon   - Build a .mcaddon archive"));
     }
-    catch (error) {
-        console.error(pc.red("\nError occurred:"), error);
-        process.exit(1);
+    generator.generate();
+    execFileSync(context.packageManager, ["install"], { cwd: projectRoot, stdio: "inherit" });
+    logger.done(`Created project ${context.name}`);
+    logger.field("Path", chalk.dim(projectRoot));
+    logger.section("Next steps");
+    logger.item(`${chalk.cyan("1.")} cd ${context.name}`);
+    if (context.script?.enabled) {
+        logger.item(`${chalk.cyan("2.")} ${context.packageManager} dev`);
+    }
+    else {
+        logger.item(`${chalk.cyan("2.")} Start developing your project`);
+    }
+    logger.section("Available commands");
+    if (context.script?.enabled) {
+        logger.info(`${context.packageManager} run dev             - Start development server`);
+        logger.info(`${context.packageManager} run build           - Build project files`);
     }
+    logger.info(`${context.packageManager} run export:zip      - Export a .zip archive`);
+    logger.info(`${context.packageManager} run export:mcpack   - Export .mcpack archive(s)`);
+    logger.info(`${context.packageManager} run export:mcaddon  - Export a .mcaddon archive`);
+    if (context.script?.enabled) {
+        logger.info(`${context.packageManager} run update:stable   - Update Script API (stable) packages`);
+        logger.info(`${context.packageManager} run update:beta     - Update Script API (beta) packages`);
+        logger.info(`${context.packageManager} run update:preview  - Update Script API (preview) packages`);
+    }
+}
+catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
 }
-main();

package/dist/prompts.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import enquirer from "enquirer";
+import { getDependency, MINECRAFT_PACKAGES } from "@mcbepack/common";
+import { Extension, Release, ScriptLanguage } from "./config/enum.js";
+import { detectPackageManager } from "./utils.js";
+export async function createContext() {
+    const { extensions } = await enquirer.prompt({
+        type: "multiselect",
+        name: "extensions",
+        message: "What types of development do you need?",
+        choices: Object.values(Extension),
+        validate: (v) => v.length > 0 || "At least one extension type is required",
+    });
+    const info = await enquirer.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "What is the name of your project?"
+        },
+        {
+            type: "input",
+            name: "description",
+            message: "What is the description of your project?"
+        },
+        {
+            type: "input",
+            name: "author",
+            message: "What is the author's name? Use commas to separate multiple authors.",
+        },
+        {
+            type: "input",
+            name: "minEngineVersion",
+            message: "What is the minimum engine version required?",
+            initial: "1.26.0",
+            validate: (v) => /^\d+\.\d+\.\d+$/.test(v) || "Minimum engine version must be in the format x.x.x",
+        }
+    ]);
+    const context = {
+        ...info,
+        extensions,
+        packageManager: await detectPackageManager(),
+        uuids: {
+            behavior: randomUUID(),
+            resource: randomUUID(),
+            scriptModule: randomUUID(),
+            resourceModule: randomUUID(),
+        },
+    };
+    if (extensions.includes(Extension.Behavior)) {
+        const { useScript } = await enquirer.prompt({
+            type: "confirm",
+            name: "useScript",
+            message: "Do you want to add Script API to the behavior pack?",
+            initial: true,
+        });
+        if (useScript) {
+            const scriptConfig = await enquirer.prompt([
+                {
+                    type: "select",
+                    name: "language",
+                    message: "Which language do you want to use?",
+                    choices: Object.values(ScriptLanguage),
+                },
+                {
+                    type: "select",
+                    name: "release",
+                    message: "What release channel would you like to use?",
+                    choices: Object.values(Release),
+                },
+                {
+                    type: "multiselect",
+                    name: "packages",
+                    message: "Which packages would you like to add?",
+                    choices: [...MINECRAFT_PACKAGES.modules, ...MINECRAFT_PACKAGES.plugins],
+                    validate: (v) => v.length > 0 || "At least one package is required",
+                },
+            ]);
+            const dependencies = await Promise.all(scriptConfig.packages.map((pkg) => getDependency(pkg, scriptConfig.release)));
+            context.script = { enabled: true, ...scriptConfig, dependencies };
+        }
+    }
+    return context;
+}
+export async function confirmPrompt(message, initial = true) {
+    const { ok } = await enquirer.prompt({
+        type: "confirm",
+        name: "ok",
+        message,
+        initial,
+    });
+    return ok;
+}

package/dist/utils.js

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import path from "node:path";
+import { detect } from "package-manager-detector/detect";
+import { PackageManager } from "./config/enum.js";
+export function json(v) {
+    return `${JSON.stringify(v, null, 2)}\n`;
+}
+export async function detectPackageManager() {
+    const detected = await detect();
+    const name = detected?.name;
+    return Object.values(PackageManager).includes(name)
+        ? name
+        : PackageManager.Bun;
+}
+export class FileGenerator {
+    projectRoot;
+    files = [];
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    create(destinationDir, content) {
+        this.files.push({ action: "create", destinationDir, content });
+    }
+    copy(destinationDir, originDir) {
+        this.files.push({ action: "copy", destinationDir, originDir });
+    }
+    generate() {
+        if (fs.existsSync(this.projectRoot)) {
+            throw new Error(`Directory already exists: ${path.basename(this.projectRoot)}`);
+        }
+        fs.mkdirSync(this.projectRoot);
+        const created = new Set([this.projectRoot]);
+        for (const file of this.files) {
+            const dir = path.dirname(file.destinationDir);
+            if (!created.has(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+                created.add(dir);
+            }
+            if (file.action === "copy") {
+                fs.copyFileSync(file.originDir, file.destinationDir);
+            }
+            else {
+                fs.writeFileSync(file.destinationDir, file.content);
+            }
+        }
+    }
+}

package/package.json

@@ -1,17 +1,8 @@
 {
   "name": "create-mcbepack",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "main": "dist/index.js",
-  "dependencies": {
-    "@mcbepack/common": "^1.0.1",
-    "enquirer": "^2.4.1",
-    "node-fetch": "^3.3.2",
-    "nodemon": "^3.1.11",
-    "picocolors": "^1.1.1"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
+  "type": "module",
   "bin": {
     "create-mcbepack": "./dist/index.js"
   },
@@ -19,5 +10,13 @@
     "dev": "tsc --watch",
     "build": "tsc"
   },
-  "type": "module"
+  "dependencies": {
+    "@mcbepack/common": "^1.0.2",
+    "enquirer": "^2.4.1",
+    "nodemon": "^3.1.11",
+    "package-manager-detector": "^1.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^5"
+  }
 }

package/templates/tsconfig.json

@@ -1,8 +1,8 @@
 {
     "compilerOptions": {
-        "target": "ESNext",
+        "target": "esnext",
         "moduleResolution": "bundler",
-        "module": "ESNext",
+        "module": "esnext",
         "resolvePackageJsonImports": true,
         "sourceMap": false
     },

package/dist/prompt.js

@@ -1,92 +0,0 @@
-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/dist/types.js

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

package/dist/utils/collect-info.js

@@ -1,54 +0,0 @@
-import { randomUUID } from "node:crypto";
-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: randomUUID(),
-        resource: randomUUID(),
-        scriptModule: randomUUID(),
-    };
-    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/dist/utils/create-files.js

@@ -1,77 +0,0 @@
-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("[OK]")} ${path.relative(process.cwd(), file.path)}`);
-        }
-        catch (error) {
-            console.error(`  ${pc.red("[ERR]")} ${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/dist/utils/generate-files.js

@@ -1,191 +0,0 @@
-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.txt"),
-            });
-            files.push({
-                path: path.join(projectRoot, ".gitignore"),
-                content: "",
-                type: "copy",
-                source: path.join(templatesDir, ".gitignore.txt"),
-            });
-            const packageJson = {
-                name: config.name,
-                scripts: {
-                    dev: "mcbepack dev",
-                    "build:zip": "mcbepack build -o zip",
-                    "build:mcpack": "mcbepack build -o mcpack",
-                    "build:mcaddon": "mcbepack build -o mcaddon",
-                    "update:stable": "mcbepack update -t stable",
-                    "update:beta": "mcbepack update -t beta",
-                    "update:preview": "mcbepack update -t preview",
-                },
-                devDependencies: {
-                    "@mcbepack/cli": "latest",
-                    "@mcbepack/api": "latest",
-                    ...(config.script.language === "typescript" ? { "typescript": "latest" } : {}),
-                    ...Object.fromEntries(config.script.dependencies.map(dep => [dep.packageName, dep.fullVersion]))
-                }
-            };
-            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: crypto.randomUUID(),
-                    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:mcaddon": "mcbepack build -o mcaddon",
-                },
-                devDependencies: {
-                    "@mcbepack/cli": "latest"
-                }
-            }, null, 2),
-            type: "file",
-        });
-    }
-    return files;
-}

package/templates/README.md

@@ -1,54 +0,0 @@
-# MCBEPACK Project
-
-This add-on was created with `create-mcbepack`.
-
-## Start
-
-Install dependencies:
-
-```bash
-bun install
-```
-
-Run the development watcher:
-
-```bash
-bun run dev
-```
-
-The dev command compiles Script API code from `scripts/` when present and syncs files from `src/behavior_pack` and `src/resource_pack` into Minecraft's development folders.
-
-## Build
-
-```bash
-bun run build:zip
-bun run build:mcpack
-bun run build:mcaddon
-```
-
-Build outputs are written to `dist/`.
-
-## Configure Minecraft Paths
-
-Edit `.env.local` if your Minecraft Bedrock installation uses a different location:
-
-```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"
-```
-
-## Project Structure
-
-```text
-.
-|-- scripts/
-|-- src/
-|   |-- behavior_pack/
-|   `-- resource_pack/
-|-- .env.local
-|-- package.json
-`-- tsconfig.json
-```
-
-Some folders only exist when they were selected during project creation.