@axeth/create-cli 1.0.0

package/index.ts

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

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@axeth/create-cli",
+  "version": "1.0.0",
+  "bin": {
+    "axeth-cli": "index.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "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

@@ -0,0 +1,206 @@
+import * as prompt from "@clack/prompts";
+import color from "colors";
+import type { TemplateGenerators } from "./TemplateGenerators.js";
+
+class AxethCLI {
+    private promptGroups: Record<string, Record<string, (opts?: any) => any>> = {};
+    private promptDefaults: Record<string, Record<string, any>> = {};
+    private template: TemplateGenerators;
+
+    private readonly axethAPI = `@axeth/api`;
+    private readonly axethCore = `@axeth/core`;
+
+    constructor(template: TemplateGenerators) {
+        console.clear();
+        this.template = template;
+        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;
+    }
+
+    private async init() {
+        const version = await this.version();
+        const addonInfo = await this.addonInfoPrompt(version, () => {
+            process.exit(0);
+        });
+        const config = await this.configPrompt();
+        const spinner = prompt.spinner({ indicator: "dots" });
+        spinner.start("Generating template files...");
+        await this.template.generate({
+            "project_name": (addonInfo.addonName as string).replace(/\s+/g, "-").toLowerCase(),
+            "axethApiVersion": config.axethApiVersion,
+            "pack_name": addonInfo.addonName,
+            "pack_description": addonInfo.description,
+            "author_name": `[${(addonInfo.authors as string).split(",").map((name: string) => `"${name.trim()}"`)}]`,
+            "version": `[${addonInfo.version.split(".").map((num: string) => `${parseInt(num, 10)}`)}]`,
+            "seed": `${Math.floor(Math.random() * 1000000)}`,
+            "axethApiName": this.axethAPI,
+            "axethCoreName": this.axethCore,
+            "axethCoreVersion": config.axethCoreVersion,
+        }, 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) => {
+                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) {
+        return await new Promise<{ [x: string]: any }>((resolve) => {
+            this.registerIntro(
+                "\n    _            _   \n   /_\\  __ _____| |_ \n  / _ \\ \\ \\ / -_)  _|\n /_/ \\_\\/\\_\\_\\___|\\__|\n                     ",
+                "Axeth CLI",
+                version,
+            );
+            this.registerPrompt("addonInfo", "addonName", "Add-on Name", "text", { placeholder: "My-Addon" });
+            this.registerPrompt("addonInfo", "description", "Description", "text", { placeholder: "This addon create for Minecraft Bedrock (Axeth)" });
+            this.registerPrompt("addonInfo", "version", "Version", "text", { placeholder: "1.0.0" });
+            this.registerPrompt("addonInfo", "authors", "Authors", "text", { placeholder: "YourName,Axeth" });
+            this.runPrompts("addonInfo", onCancel).then((responses) => {
+                resolve(responses);
+            })
+        })
+    }
+
+    private async configPrompt() {
+        return new Promise<{ [x: string]: any }>(async (resolve) => {
+            const spinner = prompt.spinner({ indicator: "dots" });
+            spinner.start("Fetching latest Axeth API version...");
+            const versions = await this.getAxethApiVersion();
+            console.log(versions);
+            spinner.stop(`Fetched @axeth/api ${versions.length} versions.`);
+            this.registerPrompt("config", "axethApiVersion", "Select Axeth API version", "select", {
+                options: versions.slice(0, 10).map((ver) => ({ label: ver, value: ver })),
+                initial: versions[0],
+            });
+            const axethCoreVersion = await this.getAxethCoreVersion();
+            await this.runPrompts("config", () => { process.exit(0); }).then((response) => {
+                resolve({
+                    axethApiVersion: response.axethApiVersion,
+                    axethCoreVersion: axethCoreVersion,
+                });
+            });
+        })
+    }
+
+    private registerPrompt(groupId: string, key: string, message: string, type: "text" | "password" | "confirm" | "select" | "multiselect" = "text", options: any = {}) {
+        if (!this.promptGroups[groupId]) this.promptGroups[groupId] = {};
+        this.promptDefaults[groupId] = this.promptDefaults[groupId] || {};
+        switch (type) {
+            case "text":
+                this.promptGroups[groupId][key] = () => prompt.text({ message, ...options });
+                this.promptDefaults[groupId][key] = options.placeholder || undefined;
+                break;
+            case "password":
+                this.promptGroups[groupId][key] = () => prompt.password({ message, ...options });
+                this.promptDefaults[groupId][key] = options.placeholder || undefined;
+                break;
+            case "confirm":
+                this.promptGroups[groupId][key] = () => prompt.confirm({ message, ...options });
+                this.promptDefaults[groupId][key] = options.initial || undefined;
+                break;
+            case "select":
+                this.promptGroups[groupId][key] = () => prompt.select({ message, ...options });
+                this.promptDefaults[groupId][key] = options.initial || undefined;
+                break;
+            case "multiselect":
+                this.promptGroups[groupId][key] = () => prompt.multiselect({ message, ...options });
+                this.promptDefaults[groupId][key] = options.initial || undefined;
+                break;
+            default:
+                throw new Error(`Unknown prompt type: ${type}`);
+        }
+    }
+
+    private async getAxethCoreVersion() {
+        const moduleData: any = await fetch(`https://registry.npmjs.org/${this.axethCore}`)
+            .then(res => res.json());
+        
+        const versions = Object.keys(moduleData.versions);
+        return versions.reverse()[0];
+    }
+
+    private async getAxethApiVersion() {
+        const moduleData: any = await fetch(`https://registry.npmjs.org/${this.axethAPI}`)
+            .then(res => res.json());
+
+        const versions = Object.keys(moduleData.versions);
+        return versions.reverse();
+    }
+
+    async runPrompts(groupId: string, onCancel?: () => void) {
+        if (!this.promptGroups[groupId] || Object.keys(this.promptGroups[groupId]).length === 0) {
+            throw new Error(`No prompts to run for group: ${groupId}`);
+        }
+
+        const responses: { [x: string]: any } = {};
+        for (const key of Object.keys(this.promptGroups[groupId])) {
+            const response = await this.promptGroups[groupId][key]!();
+            if (String(response).includes("clack:cancel")) {
+                prompt.cancel("Operation cancelled.");
+                if (onCancel) onCancel();
+                return {};
+            }
+            if (response === undefined) {
+                if (this.promptDefaults[groupId] && this.promptDefaults[groupId][key] !== undefined) {
+                    responses[key] = this.promptDefaults[groupId][key];
+                } else {
+                    responses[key] = undefined;
+                }
+            } else {
+                responses[key] = response;
+            }
+        }
+        return responses;
+    }
+
+    private registerIntro(logo: string, title: string, version: string) {
+        prompt.intro(color.cyan(logo) + `\n   ${title} - v${version}\n`);
+    }
+}
+
+export { AxethCLI };

package/src/class/TemplateGenerators.ts

@@ -0,0 +1,65 @@
+import path from "path"
+import fs from 'fs-extra';
+
+class TemplateGenerators {
+    private fileList = new Map<string, string>();
+
+    constructor() {
+    }
+
+    public registerFile(path: string, content: string) {
+        this.fileList.set(path, content);
+    }
+
+    public getFiles() {
+        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 })) {
+                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;
+            }
+        }
+    }
+}
+
+export { TemplateGenerators };

package/src/templates/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.3.0",
+  "configurations": [
+    {
+      "type": "minecraft-js",
+      "request": "attach",
+      "name": "Debug with Minecraft",
+      "mode": "listen",
+      "localRoot": "${workspaceFolder}/packs/scripts",
+      "sourceMapRoot": "${workspaceFolder}/data/dist/BP/scripts",
+      "port": 19144
+   }
+  ]
+}

package/src/templates/data/filters/ManifestBuilds/index.ts

@@ -0,0 +1,114 @@
+import { ConfigManagers, Filters } from "@axeth/core";
+import type { Manifest } from "./types/Manifest.ts";
+import chalk from "chalk";
+import * as fs from "fs";
+
+class ManifestBuilds extends Filters {
+  private bpManifest = `${this.basePath}/BP/manifest.json`;
+  private rpManifest = `${this.basePath}/RP/manifest.json`;
+  private bpDirectory = `${this.basePath}/BP`;
+  private rpDirectory = `${this.basePath}/RP`;
+  private config = new ConfigManagers().getConfig();
+
+  override async apply(): Promise<void> {
+    await null;
+    this.msg(`Looking for manifests...`);
+    const BPManifest = this.readManifest(this.bpManifest);
+    const RPManifest = this.readManifest(this.rpManifest);
+
+    if (!BPManifest || !RPManifest) {
+      this.msg(chalk.red(`No manifest.json found in BP or RP directories.`));
+      return;
+    } else {
+      const config = await this.config;
+      const BPUUIDs = this.uuidGen(config.meta.seed, 2);
+      const RPUUIDs = this.uuidGen(config.meta.seed + 1000, 2);
+
+      BPManifest.header.name = config.meta.name + `@${config.meta.version.join(".")} BP`;
+      RPManifest.header.name = config.meta.name + `@${config.meta.version.join(".")} RP`;
+      BPManifest.header.description = config.meta.description || BPManifest.header.description;
+      RPManifest.header.description = config.meta.description || RPManifest.header.description;
+      BPManifest.format_version = config.format_version;
+      RPManifest.format_version = config.format_version;
+      //UUID
+      BPManifest.header.uuid = BPUUIDs[0] || "";
+      //Script Module
+      BPManifest.modules.find((x) => x.language === "javascript")!.uuid = BPUUIDs[1] || "";
+      //UUID
+      RPManifest.header.uuid = RPUUIDs[0] || "";
+      //Resource Module
+      RPManifest.modules.find((x) => x.type === "resources")!.uuid = RPUUIDs[1] || "";
+
+      //Dependencies
+      const bpDep = BPManifest.dependencies?.find((dep) => dep.uuid);
+      if (bpDep) {
+        bpDep.uuid = RPManifest.header.uuid;
+      }
+      const rpDep = RPManifest.dependencies?.find((dep) => dep.uuid);
+      if (rpDep) {
+        rpDep.uuid = BPManifest.header.uuid;
+      }
+
+
+      this.fileManagers.writeFile(
+        this.bpManifest,
+        JSON.stringify(BPManifest, null, 2),
+      );
+      this.fileManagers.writeFile(
+        this.rpManifest,
+        JSON.stringify(RPManifest, null, 2),
+      );
+
+      this.msg(`Updated manifest ${chalk.green("successfully")}.`);
+
+      //Copy pack icons if exist
+      this.fileManagers.removeFile(this.bpDirectory + "/pack_icon.png");
+      this.fileManagers.removeFile(this.rpDirectory + "/pack_icon.png");
+
+      this.fileManagers.copyFile(
+        config.meta.icon,
+        this.bpDirectory + "/pack_icon.png",
+      );
+      this.fileManagers.copyFile(
+        config.meta.icon,
+        this.rpDirectory + "/pack_icon.png",
+      )
+    }
+  }
+
+  private uuidGen(seed: number, count: number): string[] {
+    const uuids: string[] = [];
+
+    // simple deterministic seeded PRNG (mulberry32-like)
+    const rnd = (function (a: number) {
+      return function () {
+        a |= 0;
+        a = (a + 0x6D2B79F5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+      };
+    })(seed);
+
+    for (let i = 0; i < count; i++) {
+      const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = Math.floor(rnd() * 16);
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+      });
+      uuids.push(uuid);
+    }
+    return uuids;
+  }
+
+  public readManifest(path: string): Manifest | null {
+    try {
+      return JSON.parse(
+        fs.readFileSync(path, "utf-8"),
+      ) as Manifest;
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { ManifestBuilds };

package/src/templates/data/filters/ManifestBuilds/types/Manifest.ts

@@ -0,0 +1,49 @@
+export interface Manifest {
+    format_version: number;
+    header: ManifestHeader;
+    modules: ManifestModule[];
+    dependencies?: ManifestDependency[];
+    subpacks?: Subpack[];
+    capabilities?: string[];
+}
+
+export type Version = [number, number, number];
+export type UUID = string;
+
+export interface ManifestHeader {
+    name: string;
+    description: string;
+    uuid: UUID;
+    version: Version;
+    min_engine_version: Version;
+    lock_template?: boolean;
+}
+
+export interface ManifestModule {
+    uuid: UUID;
+    version: Version;
+    type: ModuleType;
+    description?: string;
+    language?: string;
+}
+
+export type ModuleType =
+    | 'resources' // Resource Pack content
+    | 'data'      // Behavior Pack content (Scripts, Loot Tables, etc.)
+    | 'skin_pack' // Skin Pack content
+    | 'interface' // UI content
+    | 'world_template'
+    | 'script'    // Client-side scripting
+    | 'resource'  // Legacy name for 'resources'
+    | 'client_data' // Client-side behavior (e.g., animations, render controllers)
+    | 'world_dependencies';
+
+export interface ManifestDependency {
+    uuid: UUID;
+    version: Version;
+}
+
+export interface Subpack {
+    folder_name: string;
+    name: string;
+}

package/src/templates/data/filters/TSBuilds/index.ts

@@ -0,0 +1,102 @@
+import { Filters } from "@axeth/core";
+import type { Manifest } from "./types/Manifest.ts";
+import * as esbuild from "esbuild";
+import { parseArgs } from "./utils/parseArgs.ts";
+import chalk from "chalk";
+import { spawn } from "bun";
+import * as fs from "fs";
+
+const [settings] = parseArgs(Bun.argv.slice(2));
+
+
+class TSBuilds extends Filters {
+  private typescript = "ts";
+  private bpPath = `${this.basePath}/BP`;
+
+  override async apply(): Promise<void> {
+    const manifest = this.readManifest(this.bpPath);
+    if (!manifest) return;
+    const entryPath = manifest.modules.find((x) => x.entry)?.entry;
+    if (!entryPath) return;
+
+    const scriptPath = "./packs" + "/" + entryPath.replace(".js", `.${this.typescript}`);
+
+    // Run linter before building (surface output to console)
+    this.msg(`Running linter: ${chalk.yellow("bunx eslint ./packs")}`);
+    const lintProcess = spawn(["bunx", "eslint", "./packs"], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+
+    const exitCode = await lintProcess.exited;
+
+    if (exitCode !== 0) {
+      this.msg(`${chalk.red("✗")} Linting failed. Fix errors before building.`);
+      return;
+    }
+
+    this.msg(`${chalk.green("✓")} Linting passed`);
+
+    // Build KisuLib.js first (contains @axeth/api)
+    this.msg(`Building library: ${chalk.blue("KisuLib.js")}`);
+    await esbuild.build({
+      bundle: true,
+      entryPoints: ["@axeth/api"],
+      external: [
+        "@minecraft/server",
+        "@minecraft/server-ui",
+      ],
+      format: "esm",
+      outfile: this.bpPath + "/scripts/KisuLib.js",
+      minify: true,
+      keepNames: false,
+      sourcemap: true,
+      ...settings,
+    }).then(() => {
+      this.msg(`Successfully built library: ${chalk.green("BP/scripts/KisuLib.js")}`);
+    });
+
+    // Build main script (excludes @axeth/api)
+    this.msg(`Building script: ${chalk.green(scriptPath)}`);
+    await esbuild.build({
+      plugins: [
+        {
+          name: "alias-kisu-api",
+          setup(build) {
+            build.onResolve({ filter: /^@kisu\/api$/ }, () => {
+              return { path: "./KisuLib.js", external: true };
+            });
+          },
+        },
+      ],
+      bundle: true,
+      entryPoints: [
+        scriptPath,
+      ],
+      external: [
+        "@minecraft/server",
+        "@minecraft/server-ui",
+      ],
+      format: "esm",
+      outfile: this.bpPath + "/" + entryPath,
+      sourcemap: true,
+      ...settings,
+    }).then(() => {
+      this.msg(`Successfully built script: ${chalk.green("BP/" + entryPath)}`);
+    });
+
+    // this.fileManagers.removeDirectory(this.basePath + "/" + "scripts");
+  }
+
+  public readManifest(bpPath: string): Manifest | null {
+    try {
+      return JSON.parse(
+        fs.readFileSync(`${bpPath}/manifest.json`, "utf-8"),
+      ) as Manifest;
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { TSBuilds };

package/src/templates/data/filters/TSBuilds/types/Manifest.ts

@@ -0,0 +1,13 @@
+export interface Manifest {
+  format_version: number;
+  modules: [
+    {
+      description: string;
+      language: string;
+      type: string;
+      uuid: string;
+      version: [number, number, number];
+      entry: string;
+    },
+  ];
+}

package/src/templates/data/filters/TSBuilds/utils/parseArgs.ts

@@ -0,0 +1,8 @@
+export function parseArgs(args: string[]): [Record<string, unknown>, ...string[]] {
+  try {
+    const settings = JSON.parse(args[0] || "{}");
+    return [settings, ...args.slice(1)];
+  } catch {
+    return [{}, ...args];
+  }
+}

package/src/templates/eslint.config.ts

@@ -0,0 +1,16 @@
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+
+export default defineConfig(
+    eslint.configs.recommended,
+    tseslint.configs.recommended,
+    {
+        rules: {
+            "no-unused-vars": "off",
+            "@typescript-eslint/no-unused-vars": ["error", {
+                argsIgnorePattern: "^_"
+            }]
+        }
+    }
+);

package/src/templates/index.ts

@@ -0,0 +1,3 @@
+import { AxethCore } from "@axeth/core";
+
+new AxethCore();

package/src/templates/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "{{project_name}}",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "chokidar-cli": "^3.0.0",
+    "jiti": "^2.6.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "lint": "bunx eslint",
+    "dev": "bun run index.ts --dev",
+    "build": "bun run ./index.ts --build",
+    "packs": "bun run ./index.ts --packs",
+    "clean": "bun run ./index.ts --clean"
+  },
+  "dependencies": {
+    "{{axethApiName}}": "^{{axethApiVersion}}",
+    "{{axethCoreName}}": "^{{axethCoreVersion}}",
+    "chalk": "^5.6.2",
+    "esbuild": "^0.27.2",
+    "eslint": "^9.39.2",
+    "jszip": "^3.10.1",
+    "typescript-eslint": "^8.50.1"
+  }
+}

package/src/templates/packs/BP/manifest.json

@@ -0,0 +1,56 @@
+{
+  "format_version": 2,
+  "header": {
+    "name": "{{pack_name}}",
+    "description": "{{pack_description}}",
+    "uuid": "<uuid>",
+    "version": [
+      1,
+      0,
+      0
+    ],
+    "min_engine_version": [
+      1,
+      21,
+      60
+    ]
+  },
+  "modules": [
+    {
+      "description": "Behavior Pack",
+      "language": "javascript",
+      "type": "script",
+      "uuid": "<uuid>",
+      "version": [
+        1,
+        0,
+        0
+      ],
+      "entry": "scripts/index.js"
+    }
+  ],
+  "dependencies": [
+    {
+      "module_name": "@minecraft/server",
+      "version": "{{minecraftServerVersion}}"
+    },
+    {
+      "module_name": "@minecraft/server-ui",
+      "version": "{{minecraftServerUIVersion}}"
+    },
+    {
+      "uuid": "<uuid>",
+      "version": [
+        1,
+        0,
+        0
+      ]
+    }
+  ],
+  "metadata": {
+    "product_type": "addon",
+    "authors": [
+      "KisuX3"
+    ]
+  }
+}

package/src/templates/packs/RP/manifest.json

@@ -0,0 +1,40 @@
+{
+  "format_version": 2,
+  "header": {
+    "name": "{{pack_name}}",
+    "description": "{{pack_description}}",
+    "uuid": "<uuid>",
+    "version": [
+      1,
+      0,
+      0
+    ],
+    "min_engine_version": [
+      1,
+      21,
+      60
+    ]
+  },
+  "modules": [
+    {
+      "description": "Resource Pack",
+      "type": "resources",
+      "uuid": "<uuid>",
+      "version": [
+        1,
+        0,
+        0
+      ]
+    }
+  ],
+  "dependencies": [
+    {
+      "uuid": "<uuid>",
+      "version": [
+        1,
+        0,
+        0
+      ]
+    }
+  ]
+}

package/src/templates/packs/config.json

@@ -0,0 +1,23 @@
+{
+    "format_version": 2,
+    "meta": {
+        "name": "{{pack_name}}",
+        "icon": "./packs/pack_icon.png",
+        "version": {{version}},
+        "description": "{{pack_description}}",
+        "seed": {{seed}},
+        "authors": {{author_name}}
+    },
+    "filters": [
+        {
+            "name": "TSBuilds",
+            "config": {}   
+        },
+        {
+            "name": "ManifestBuilds",
+            "config": {}
+        }
+    ],
+    "env": {
+    }
+}

package/src/templates/packs/scripts/index.ts

@@ -0,0 +1,10 @@
+import { SystemBase } from "@axeth/api";
+import { SamplePlugin } from "./plugins/SamplePlugin/index.ts";
+
+class KisuAPI extends SystemBase {
+    public override onLoad(): void {
+        this.pluginManagers.registerPlugin(SamplePlugin)
+    }
+};
+
+new KisuAPI();

package/src/templates/packs/scripts/plugins/SamplePlugin/index.ts

@@ -0,0 +1,9 @@
+import { PluginBase } from "@axeth/api";
+
+class SamplePlugin extends PluginBase {
+    public override onLoad(): void {
+      this.logger.info("SamplePlugin has been loaded!");
+    }
+}
+
+export { SamplePlugin };

package/src/templates/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitAny": true,
+    "noPropertyAccessFromIndexSignature": false,
+
+    "paths": {
+      "@axeth/api": ["./lib/@axeth/api/index.ts"],
+      "@minecraft/server": ["./node_modules/@minecraft/server"],
+      "@minecraft/server-ui": ["./node_modules/@minecraft/server-ui"],
+      "@minecraft/math": ["./node_modules/@minecraft/math"]
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}