@axeth/create-cli 1.0.4 → 2.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[?9001h[?1004h[?25l$tsc
+]0;C:\WINDOWS\system32\cmd.exe[?25h[?9001l[?1004l

package/README.md

@@ -1,34 +1,20 @@
-# @axeth/cli
+# @axeth/core
 
-The official CLI for the **Axeth** ecosystem — a toolkit for building, managing, and scaffolding Minecraft Bedrock Edition projects.
+The core engine of the **Axeth** ecosystem.
 
-`@axeth/cli` acts as the command-line interface that connects `@axeth/core` and `@axeth/api` together into a single developer experience.
-
----
-
-## ✨ Features
-
-- Project scaffolding and initialization
-- Minecraft Bedrock addon & tool workflows
-- Version-aware environment handling
-- Extensible command system
-- Works with `bun 🐰 `
+`@axeth/core` provides the foundational logic used by Axeth tools, including
+project initialization, configuration handling, environment resolution,
+and internal workflows for Minecraft Bedrock Edition tooling.
 
+> ⚠️ This package is primarily intended for internal use by Axeth tools.
+> Advanced users may use it directly at their own discretion.
 
 ---
-## 🚀 Usage
-```
-bun create @axeth/cli
-```
 
----
-## 🧩 Ecosystem
-
-- @axeth/core — core logic & project engine
-
-- @axeth/api — shared APIs & versioned Minecraft interfaces
-
----
+## ✨ Responsibilities
 
-## License
-MIT © PUKAN223
+- Project & template resolution
+- Configuration loading and validation
+- Minecraft Bedrock version targeting
+- Environment & workspace management
+- Shared utilities and internal pipelines

package/index.ts

@@ -1,7 +1,5 @@
 #!/usr/bin/env bun
 
 import { AxethCLI } from "./src/class/AxethCLI";
-import { TemplateGenerators } from "./src/class/TemplateGenerators";
 
-const templateGenerator = new TemplateGenerators();
-new AxethCLI(templateGenerator);
+new AxethCLI();

package/package.json

@@ -1,20 +1,38 @@
 {
   "name": "@axeth/create-cli",
-  "version": "1.0.4",
+  "version": "2.0.1",
+  "module": "index.ts",
+  "type": "module",
   "bin": {
     "axeth-cli": "index.ts"
   },
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "axeth",
+    "axeth-cli",
+    "minecraft",
+    "minecraft-bedrock",
+    "bedrock"
+  ],
   "license": "MIT",
+  "author": {
+    "name": "KisuX3"
+  },
   "devDependencies": {
     "@types/bun": "latest"
   },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "@types/fs-extra": "^11.0.4",
     "colors": "^1.4.0",
     "fs-extra": "^11.3.3"
   }
-}
+}

package/src/class/AxethCLI.ts

@@ -1,8 +1,9 @@
 import * as prompt from "@clack/prompts";
 import color from "colors";
-import type { TemplateGenerators } from "./TemplateGenerators.js";
+import { TemplateGenerators } from "./TemplateGenerators.js";
 import fs from "fs-extra";
 import path from "path";
+import { spawn } from "child_process";
 
 class AxethCLI {
     private promptGroups: Record<string, Record<string, (opts?: any) => any>> = {};
@@ -12,15 +13,13 @@ class AxethCLI {
     private readonly axethAPI = `@axeth/api`;
     private readonly axethCore = `@axeth/core`;
 
-    constructor(template: TemplateGenerators) {
+    constructor() {
         console.clear();
-        this.template = template;
+        this.template = new TemplateGenerators();
         this.init();
     }
 
-    // Get current module version from package.json
     private async version() {
-        // __dirname is not available in ESM, so use import.meta.url
         const url = new URL("../../package.json", import.meta.url);
         const pkgData = await Bun.file(url).json();
         return pkgData.version;
@@ -32,10 +31,66 @@ class AxethCLI {
             process.exit(0);
         });
         const config = await this.configPrompt();
-        const spinner = prompt.spinner({ indicator: "dots" });
-        spinner.start("Generating template files...");
         const minecraftServerVersion = await this.getMinecraftServerVersion();
         const minecraftServerUIVersion = await this.getMinecraftServerUIVersion();
+        const spinner = prompt.spinner({ indicator: "dots" });
+
+        await this.generateTemplate(addonInfo, config, minecraftServerVersion, minecraftServerUIVersion, spinner);
+        // await this.installDependencies()
+        // const projectDir = (addonInfo.addonName as string).replace(/\s+/g, "-").toLowerCase();
+        // const cwd = require('path').resolve(process.cwd(), projectDir);
+
+        // spinner.start("Installing dependencies...");
+        // try {
+        //     await new Promise<void>((resolve, reject) => {
+        //         //add dependency installation @minecraft/server{minecraftServerVersion} and @minecraft/server-ui@{minecraftServerUIVersion}
+        //         //edit package.json to add these dependencies
+        //         const packageJsonPath = path.join(cwd, 'package.json');
+        //         const packageJson = fs.readJsonSync(packageJsonPath);
+        //         packageJson.dependencies = packageJson.dependencies || {};
+        //         packageJson.dependencies['@minecraft/server'] = `^${minecraftServerVersion}`;
+        //         packageJson.dependencies['@minecraft/server-ui'] = `^${minecraftServerUIVersion}`;
+        //         fs.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+                
+        //         const child = spawn('bun', ['install'], { cwd, shell: true });
+        //         let errorOutput = '';
+        //         child.stderr && child.stderr.on('data', (data: Buffer) => {
+        //             errorOutput += data.toString();
+        //         });
+        //         child.on('close', async (code: number) => {
+        //             if (code === 0) {
+        //                 spinner.stop("Dependencies installed.");
+        //                 resolve();
+        //                 // Prompt to open VS Code
+        //                 const openVSCode = await prompt.confirm({
+        //                     message: "Open project in VS Code now?"
+        //                 });
+        //                 if (openVSCode) {
+        //                     const childCode = spawn('code', ['.'], { cwd, shell: true, stdio: 'ignore', detached: true });
+        //                     childCode.unref();
+        //                 }
+        //             } else {
+        //                 spinner.stop("Dependency installation failed.");
+        //                 prompt.log.error(`bun install failed with code ${code}`);
+        //                 if (errorOutput) {
+        //                     prompt.log.error(errorOutput.trim());
+        //                 }
+        //                 reject(new Error(`bun install failed with code ${code}`));
+        //             }
+        //         });
+        //         child.on('error', (err: Error) => {
+        //             spinner.stop("Dependency installation failed.");
+        //             prompt.log.error(`bun install process error: ${err.message}`);
+        //             reject(err);
+        //         });
+        //     });
+        // } catch (err) {
+        //     // spinner already stopped in error handler above
+        //     prompt.log.error(`Failed to install dependencies: ${err}`);
+        // }
+    }
+
+    private async generateTemplate(addonInfo: { [x: string]: any }, config: { [x: string]: any }, minecraftServerVersion: string, minecraftServerUIVersion: string, spinner: any) {
         await this.template.generate({
             "project_name": (addonInfo.addonName as string).replace(/\s+/g, "-").toLowerCase(),
             "axethApiVersion": config.axethApiVersion,
@@ -50,58 +105,6 @@ class AxethCLI {
             "minecraftServerUIVersion": minecraftServerUIVersion,
             "minecraftServerVersion": minecraftServerVersion
         }, spinner);
-        spinner.stop("Template files generated.");
-        const projectDir = (addonInfo.addonName as string).replace(/\s+/g, "-").toLowerCase();
-        const cwd = require('path').resolve(process.cwd(), projectDir);
-        const { spawn } = require('child_process');
-        spinner.start("Installing dependencies...");
-        try {
-            await new Promise<void>((resolve, reject) => {
-                //add dependency installation @minecraft/server{minecraftServerVersion} and @minecraft/server-ui@{minecraftServerUIVersion}
-                //edit package.json to add these dependencies
-                const packageJsonPath = path.join(cwd, 'package.json');
-                const packageJson = fs.readJsonSync(packageJsonPath);
-                packageJson.dependencies = packageJson.dependencies || {};
-                packageJson.dependencies['@minecraft/server'] = `^${minecraftServerVersion}`;
-                packageJson.dependencies['@minecraft/server-ui'] = `^${minecraftServerUIVersion}`;
-                fs.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
-                
-                const child = spawn('bun', ['install'], { cwd, shell: true });
-                let errorOutput = '';
-                child.stderr && child.stderr.on('data', (data: Buffer) => {
-                    errorOutput += data.toString();
-                });
-                child.on('close', async (code: number) => {
-                    if (code === 0) {
-                        spinner.stop("Dependencies installed.");
-                        resolve();
-                        // Prompt to open VS Code
-                        const openVSCode = await prompt.confirm({
-                            message: "Open project in VS Code now?"
-                        });
-                        if (openVSCode) {
-                            const childCode = spawn('code', ['.'], { cwd, shell: true, stdio: 'ignore', detached: true });
-                            childCode.unref();
-                        }
-                    } else {
-                        spinner.stop("Dependency installation failed.");
-                        prompt.log.error(`bun install failed with code ${code}`);
-                        if (errorOutput) {
-                            prompt.log.error(errorOutput.trim());
-                        }
-                        reject(new Error(`bun install failed with code ${code}`));
-                    }
-                });
-                child.on('error', (err: Error) => {
-                    spinner.stop("Dependency installation failed.");
-                    prompt.log.error(`bun install process error: ${err.message}`);
-                    reject(err);
-                });
-            });
-        } catch (err) {
-            // spinner already stopped in error handler above
-            prompt.log.error(`Failed to install dependencies: ${err}`);
-        }
     }
 
     private async addonInfoPrompt(version: string, onCancel?: () => void) {

package/src/class/TemplateGenerators.ts

@@ -1,8 +1,15 @@
 import path from "path"
 import fs from 'fs-extra';
+import { exec } from "child_process";
 
 class TemplateGenerators {
     private fileList = new Map<string, string>();
+    private dependencies: string[] = [
+        "@axeth/api",
+        "@axeth/core",
+        "@minecraft/server",
+        "@minecraft/server-ui"
+    ];
 
     constructor() {
     }
@@ -15,50 +22,53 @@ class TemplateGenerators {
         return this.fileList;
     }
 
-    public async generate(config:{ [key: string]: any }, spinner: any): Promise<void> {
-        const templateDir = path.resolve(__dirname, "../templates");
-        const targetDir = config["pack_name"] ? path.resolve(process.cwd(), config["pack_name"]) : process.cwd();
-
-        const readTemplateFiles = async (dir: string) => {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    await readTemplateFiles(fullPath);
-                } else if (entry.isFile()) {
-                    if (!this.fileList.has(fullPath)) {
-                        const content = await fs.readFile(fullPath, "utf8");
-                        //if folder is .git ignore it
-                        if (fullPath.includes(`${path.sep}.git${path.sep}`)) {
-                            continue;
-                        }
-                        this.registerFile(fullPath, content);
-                    }
-                }
-            }
-        };
-
-        await readTemplateFiles(templateDir);
-
-        for (const [filePath, fileContent] of this.fileList) {
-            let updatedContent = fileContent;
-            for (const [key, value] of Object.entries({ ...config })) {
+    public async generate(config: { [key: string]: any }, spinner: any): Promise<void> {
+        spinner.start("Preparing template pack files...");
+        const templateData: { [key: string]: string } = await fs.readJson(path.join(__dirname, '../data/templates.json'));
+        for (const [filePath, fileContent] of Object.entries(templateData)) {
+            let populatedContent = fileContent;
+            for (const [key, value] of Object.entries(config)) {
                 const placeholder = `{{${key}}}`;
-                updatedContent = updatedContent.split(placeholder).join(value);
-            }
-            const absFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(templateDir, filePath);
-            const relativePath = path.relative(templateDir, absFilePath);
-            const targetPath = path.join(targetDir, relativePath);
-            try {
-                await fs.ensureDir(path.dirname(targetPath));
-                spinner.message(`Creating file: ${targetPath}`);
-                await fs.writeFile(targetPath, updatedContent, "utf8");
-                await fs.utimes(targetPath, new Date(), new Date());
-                await new Promise((res) => setTimeout(res, 50));
-            } catch (err) {
-                throw err;
+                populatedContent = populatedContent.split(placeholder).join(value);
+                this.registerFile(filePath, populatedContent);
+                await new Promise((resolve) => setTimeout(resolve, 10)); // Slight delay to ensure responsiveness
             }
         }
+        spinner.stop("Prepared template pack files.");
+        spinner.start("Creating template pack files...");
+
+        for (const filePath of this.fileList.keys()) {
+            const fullPath = path.join(process.cwd(), config['pack_name'], filePath);
+            const shortPath = filePath
+                .split('/')
+                .slice(-5)
+                .join('/');
+            spinner.message(`Creating file: ${shortPath}`);
+            await Bun.file(fullPath).write(this.fileList.get(filePath) || '');
+            await new Promise((resolve) => setTimeout(resolve, 50)); // Slight delay to ensure file system stability
+        }
+        spinner.stop("Template pack files generated.");
+        spinner.start("Installing dependencies...");
+        await this.installDependencies(config['pack_name'], this.dependencies);
+        spinner.stop("Dependencies installed.");
+    }
+
+    private async runCommand(command: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            exec(command, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+
+    private async installDependencies(projectName: string, dependencies?: string[]): Promise<void> {
+        //cd to the generated pack directory
+        const installCommand = `cd ${path.join(process.cwd(), projectName || '')} && bun add ${dependencies ? dependencies.join(' ') : this.dependencies.join(' ')}`;
+        return await this.runCommand(installCommand);
     }
 }