@bf6mods/cli 1.0.0 → 1.0.2

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@bf6mods/cli",
-  version: "1.0.0",
+  version: "1.0.1",
   description: "CLI and library for bundling BF6 mods",
   license: "MIT",
   type: "module",
@@ -30,102 +30,522 @@ var package_default = {
   ],
   dependencies: {
     "@bf6mods/sdk": "1.0.1",
+    "@clack/prompts": "^0.11.0",
     chokidar: "^4.0.3",
     colors: "^1.4.0",
     commander: "^14.0.1",
-    inquirer: "^12.9.6",
     jiti: "^2.6.1",
-    knitwork: "^1.2.0"
+    knitwork: "^1.2.0",
+    rolldown: "^1.0.0-beta.43",
+    "stringify-object": "^6.0.0"
   },
   publishConfig: {
     access: "public"
   },
   devDependencies: {
+    "@types/stringify-object": "^4.0.5",
     "cross-env": "^10.1.0",
     tsx: "^4.20.6"
   }
 };
 
-// src/cli/init.ts
-import inquirer from "inquirer";
+// src/cli/build.ts
+import fs from "fs";
 import path from "path";
+import {
+  AttachmentType
+} from "@bf6mods/sdk";
+import { createJiti } from "jiti";
+import { rolldown } from "rolldown";
+
+// src/resources/prepare/types/config.ts
+var MapId = /* @__PURE__ */ ((MapId2) => {
+  MapId2["FireStorm"] = "MP_FireStorm-ModBuilderCustom0";
+  MapId2["SiegeOfCairo"] = "MP_Abbasid-ModBuilderCustom0";
+  MapId2["EmpireState"] = "MP_Aftermath-ModBuilderCustom0";
+  MapId2["IberianOffensive"] = "MP_Battery-ModBuilderCustom0";
+  MapId2["LiberationPeak"] = "MP_Capstone-ModBuilderCustom0";
+  MapId2["ManhattanBridge"] = "MP_Dumbo-ModBuilderCustom0";
+  MapId2["SaintsQuarter"] = "MP_Limestone-ModBuilderCustom0";
+  MapId2["NewSobekCity"] = "MP_Outskirts-ModBuilderCustom0";
+  MapId2["MirakValley"] = "MP_Tungsten-ModBuilderCustom0";
+  return MapId2;
+})(MapId || {});
+
+// src/cli/build.ts
+async function getBf6Config(rootDir) {
+  globalThis.defineBf6Config = (c) => c;
+  globalThis.MapId = MapId;
+  const jiti = createJiti(rootDir, { interopDefault: true });
+  const result = await jiti.import("./bf6.config", { default: true });
+  delete globalThis.defineBf6Config;
+  delete globalThis.MapId;
+  return result;
+}
+async function build() {
+  const workingDir = path.resolve(".");
+  const config = await getBf6Config(workingDir);
+  const outDir = path.resolve(workingDir, config.outDir);
+  if (fs.existsSync(outDir))
+    fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(outDir, { recursive: true });
+  const minifyJson = typeof config.minify === "boolean" ? config.minify : config.minify?.json ?? false;
+  let tsAttachment;
+  if (config.entrypoint) {
+    const entryAbs = path.resolve(workingDir, config.entrypoint);
+    const compiled = await buildEntrypoint(
+      entryAbs,
+      outDir,
+      !!config.outputArtifacts
+    );
+    tsAttachment = createTsAttachment(entryAbs, compiled);
+  }
+  const { attachments, mapRotation } = await collectAttachments(
+    config,
+    workingDir,
+    tsAttachment
+  );
+  await writeModJson(config, outDir, attachments, mapRotation, minifyJson);
+  console.log(`\u2714 Built mod: ${config.name}`);
+}
+async function buildEntrypoint(entry, outDir, emit) {
+  const bundle = await rolldown({
+    input: entry
+  });
+  const result = await bundle.generate({
+    format: "esm",
+    inlineDynamicImports: true
+  });
+  const code = result.output[0].code;
+  if (emit) {
+    await fs.promises.writeFile(path.resolve(outDir, "index.js"), code);
+  }
+  return code;
+}
+async function collectAttachments(config, workingDir, tsAttachment) {
+  const attachments = [];
+  const mapRotation = [];
+  if (tsAttachment) attachments.push(tsAttachment);
+  if (config.strings) {
+    const strPath = path.resolve(workingDir, config.strings);
+    if (!fs.existsSync(strPath)) throw new Error("Cannot find strings file");
+    const raw = await fs.promises.readFile(strPath, "utf8");
+    attachments.push(createStringsAttachment(strPath, raw));
+  }
+  if (config.scenes) {
+    let mapIdx = 0;
+    for (const [mapId, scene] of config.scenes) {
+      const scenePath = path.resolve(workingDir, scene);
+      if (!fs.existsSync(scenePath))
+        throw new Error(`Cannot find spatial data file: ${scene}`);
+      const raw = await fs.promises.readFile(scenePath, "utf8");
+      const spatial = createSpatialAttachment(scenePath, raw, mapIdx++);
+      attachments.push(spatial);
+      mapRotation.push({ id: mapId, spatialAttachment: spatial });
+    }
+  }
+  return { attachments, mapRotation };
+}
+async function writeModJson(config, outDir, attachments, mapRotation, minify) {
+  const baseGame = config.game;
+  const finalJson = {
+    name: config.name,
+    description: config.description,
+    gameMode: "ModBuilderCustom",
+    mutators: baseGame.mutators ?? {},
+    assetRestrictions: baseGame.assetRestrictions ?? {},
+    teamComposition: baseGame.teamComposition ?? [],
+    mapRotation,
+    attachments
+  };
+  const jsonOutput = minify ? JSON.stringify(finalJson) : JSON.stringify(finalJson, null, 2);
+  await fs.promises.writeFile(path.resolve(outDir, "mod.json"), jsonOutput);
+}
+function createTsAttachment(filePath, compiled) {
+  return {
+    id: crypto.randomUUID(),
+    version: "1.0",
+    filename: `${path.parse(filePath).name}.js`,
+    isProcessable: true,
+    processingStatus: 2,
+    attachmentType: AttachmentType.TypeScript,
+    attachmentData: { original: toBase64(compiled), compiled: "" },
+    errors: []
+  };
+}
+function createStringsAttachment(filePath, raw) {
+  return {
+    id: crypto.randomUUID(),
+    version: "1.0",
+    filename: path.basename(filePath),
+    isProcessable: true,
+    processingStatus: 2,
+    attachmentType: AttachmentType.Strings,
+    attachmentData: { original: toBase64(raw), compiled: "" },
+    errors: []
+  };
+}
+function createSpatialAttachment(filePath, raw, mapIdx) {
+  return {
+    id: crypto.randomUUID(),
+    version: "1.0",
+    filename: path.basename(filePath),
+    isProcessable: true,
+    processingStatus: 2,
+    attachmentType: AttachmentType.SpatialData,
+    attachmentData: { original: toBase64(raw), compiled: "" },
+    metadata: `mapIdx=${mapIdx}`,
+    errors: []
+  };
+}
+function toBase64(input) {
+  return Buffer.isBuffer(input) ? input.toString("base64") : Buffer.from(input, "utf8").toString("base64");
+}
+
+// src/cli/dev.ts
+import fs2 from "fs";
+import { glob } from "fs/promises";
+import path2 from "path";
+import chokidar from "chokidar";
+import colors from "colors";
+async function dev() {
+  const workingDir = path2.resolve(".");
+  let config = await getBf6Config(workingDir);
+  const outDir = path2.resolve(workingDir, config.outDir);
+  if (!fs2.existsSync(outDir)) fs2.mkdirSync(outDir, { recursive: true });
+  console.log(colors.cyan(`\u25B6 Starting dev for ${config.name}`));
+  let watcher;
+  async function rebuild(trigger) {
+    console.log(
+      colors.yellow(
+        `\u21BB Change detected in ${path2.basename(trigger)}, rebuilding...`
+      )
+    );
+    const start = performance.now();
+    try {
+      await build();
+      const end = performance.now();
+      const duration = ((end - start) / 1e3).toFixed(2);
+      console.log(colors.green(`\u2714 Updated mod.json (${duration}s)`));
+    } catch (err) {
+      console.error(colors.red(`\u2716 Rebuild failed: ${err.message}`));
+    }
+  }
+  async function collectWatchTargets() {
+    const targets = [];
+    if (config.entrypoint)
+      targets.push(path2.resolve(workingDir, config.entrypoint));
+    if (config.scenes) {
+      for (const [, scene] of config.scenes) {
+        targets.push(path2.resolve(workingDir, scene));
+      }
+    }
+    if (config.strings) targets.push(path2.resolve(workingDir, config.strings));
+    const srcDir = path2.resolve(workingDir, "src");
+    for await (const entry of glob(`${srcDir}/**/*`)) targets.push(entry);
+    for await (const entry of glob("bf6.config.*")) targets.push(entry);
+    return targets;
+  }
+  async function setupWatcher() {
+    if (watcher) {
+      await watcher.close();
+      console.log(colors.grey("\u267B Reloading watcher due to config change..."));
+    }
+    const watchTargets = await collectWatchTargets();
+    watcher = chokidar.watch(watchTargets, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: true,
+      ignored: [path2.resolve(outDir), `${path2.resolve(outDir)}/**`]
+    });
+    watcher.on("change", async (file) => {
+      if (file.includes("bf6.config.")) {
+        console.log(
+          colors.magenta(
+            "\u2699 Config changed \u2014 reloading and rebuilding watcher..."
+          )
+        );
+        try {
+          config = await getBf6Config(workingDir);
+          await setupWatcher();
+        } catch (err) {
+          console.error(
+            colors.red(`\u2716 Failed to reload config: ${err.message}`)
+          );
+        }
+        return;
+      }
+      await rebuild(file);
+    });
+    watcher.on("add", async (file) => await rebuild(file));
+    await rebuild("initial");
+  }
+  await setupWatcher();
+}
+
+// src/cli/import.ts
+import fs4 from "fs";
+import path4 from "path";
+import { AttachmentType as AttachmentType2 } from "@bf6mods/sdk";
+import stringifyObject from "stringify-object";
+
+// src/cli/init.ts
+import child_process from "child_process";
+import fs3 from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
-import fs from "fs";
+import * as prompts from "@clack/prompts";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-var templates = path.resolve(__dirname, "../resources/templates");
+var __dirname = path3.dirname(__filename);
+var templatesDir = path3.resolve(__dirname, "../resources/templates");
 function renameFilesRecursively(dir, modName) {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const oldPath = path.join(dir, entry.name);
+    const oldPath = path3.join(dir, entry.name);
     let newPath = oldPath;
     if (entry.name.includes("{name}")) {
       const newName = entry.name.replace("{name}", modName);
-      newPath = path.join(dir, newName);
-      fs.renameSync(oldPath, newPath);
+      newPath = path3.join(dir, newName);
+      fs3.renameSync(oldPath, newPath);
+    }
+    if (entry.name === "bf6.config.ts") {
+      let content = fs3.readFileSync(newPath, "utf-8");
+      content = content.replace(/{bf6ConfigName}/g, modName);
+      fs3.writeFileSync(newPath, content, "utf-8");
     }
     if (entry.name === "package.json") {
-      const pkg = JSON.parse(fs.readFileSync(newPath, "utf-8"));
+      const pkg = JSON.parse(fs3.readFileSync(newPath, "utf-8"));
       pkg.name = modName;
-      fs.writeFileSync(newPath, JSON.stringify(pkg, null, 2));
+      fs3.writeFileSync(newPath, JSON.stringify(pkg, null, 2));
     }
-    if (fs.statSync(newPath).isDirectory()) {
+    if (fs3.statSync(newPath).isDirectory()) {
       renameFilesRecursively(newPath, modName);
     }
   }
 }
-async function init() {
-  inquirer.prompt([
-    {
-      type: "input",
-      name: "mod_name",
-      message: "What's your mod's name",
-      validate: ((value) => {
-        if (value.trim() === "") return "Please provide a value";
-        return true;
-      })
-    },
-    {
-      type: "list",
-      name: "template",
-      message: "Which template should be used",
-      choices: ["Basic", "AcePursuit", "BombSquad", "Exfil", "Vertigo"]
-    }
-  ]).then((answers) => {
-    const template = path.resolve(templates, answers.template);
-    const newProject = path.resolve(".", answers.mod_name);
-    console.log("template:", template);
-    console.log("newProject:", newProject);
-    fs.cpSync(path.resolve(templates, "All"), newProject, { recursive: true });
-    fs.cpSync(template, newProject, { recursive: true });
-    renameFilesRecursively(newProject, answers.mod_name);
-  }).catch((error) => {
-    if (error.isTtyError) {
-      console.error("TTY Error:", error);
-    } else {
-      console.error("Error occurred:", error);
+var templates = [
+  "Basic",
+  "AcePursuit",
+  "BombSquad",
+  "Exfil",
+  "Vertigo"
+];
+async function startProject(destination, template, name) {
+  if (["AcePursuit", "BombSquad", "Exfil", "Vertigo"].includes(template)) {
+    const importPath = path3.resolve(templatesDir, `${template}.json`);
+    await importFile(importPath, destination, name);
+  } else if (template === "None") {
+  } else {
+    const templateDir = path3.resolve(templatesDir, template);
+    fs3.cpSync(templateDir, destination, { recursive: true });
+  }
+  fs3.cpSync(path3.resolve(templatesDir, "All"), destination, {
+    recursive: true
+  });
+  if (name) renameFilesRecursively(destination, name);
+}
+function installDependencies(projectDir) {
+  try {
+    child_process.execSync(`npm install`, {
+      stdio: "inherit",
+      cwd: projectDir
+    });
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+var cancel2 = () => prompts.cancel("Operation cancelled");
+function isEmpty(path6) {
+  const files = fs3.readdirSync(path6);
+  return files.length === 0 || files.length === 1 && files[0] === ".git";
+}
+function emptyDir(dir) {
+  if (!fs3.existsSync(dir)) {
+    return;
+  }
+  for (const file of fs3.readdirSync(dir)) {
+    if (file === ".git") {
+      continue;
+    }
+    fs3.rmSync(path3.resolve(dir, file), { recursive: true, force: true });
+  }
+}
+async function init(argTargetDir) {
+  prompts.intro("Initialize Bf6 Mod");
+  const path6 = argTargetDir ? argTargetDir : await prompts.text({
+    message: "Where should we create your project?",
+    placeholder: "./ace-pursuit",
+    validate: (value) => {
+      if (!value) return "Please enter a path.";
+      if (value[0] !== ".") return "Please enter a relative path.";
     }
   });
+  if (prompts.isCancel(path6)) return cancel2();
+  let name = await prompts.text({
+    message: "What is the name of your mod?",
+    placeholder: "Ace Pursuit",
+    validate: (value) => {
+      if (!value.trim()) return "Please enter a name.";
+    }
+  });
+  if (prompts.isCancel(name)) return cancel2();
+  name = name.trim();
+  if (fs3.existsSync(path6) && !isEmpty(path6)) {
+    let overwrite;
+    const res = await prompts.select({
+      message: (path6 === "." ? "Current directory" : `Target directory "${path6}"`) + ` is not empty. Please choose how to proceed:`,
+      options: [
+        {
+          label: "Cancel operation",
+          value: "no"
+        },
+        {
+          label: "Remove existing files and continue",
+          value: "yes"
+        },
+        {
+          label: "Ignore files and continue",
+          value: "ignore"
+        }
+      ]
+    });
+    if (prompts.isCancel(res)) return cancel2();
+    overwrite = res;
+    switch (overwrite) {
+      case "yes":
+        emptyDir(path6);
+        break;
+      case "no":
+        cancel2();
+        return;
+    }
+  }
+  const template = await prompts.select({
+    message: "Select a template:",
+    options: templates.map((template2) => {
+      return {
+        label: template2,
+        value: template2
+      };
+    })
+  });
+  if (prompts.isCancel(template)) return cancel2();
+  await startProject(path6, template, name);
+  const s = prompts.spinner();
+  s.start("Installing via npm");
+  const installed = installDependencies(path6);
+  if (installed) s.stop("Installed via npm");
+  else s.stop("Failed to install via npm", 1);
+  const nextSteps = `cd ${path6}
+npm run build`;
+  prompts.note(nextSteps, "Next steps.");
 }
 
-// src/cli/build.ts
-import { createJiti } from "jiti";
-import path2 from "path";
-var getBf6Config = async (rootDir) => {
-  const jiti = createJiti(rootDir, { interopDefault: true });
-  const result = await jiti.import("./bf6.config", { default: true });
-  return result;
-};
-async function build() {
-  const workingDir = path2.resolve(".");
-  getBf6Config(workingDir);
+// src/cli/import.ts
+async function writeFileSafe(filePath, data) {
+  const dir = path4.dirname(filePath);
+  await fs4.promises.mkdir(dir, { recursive: true });
+  await fs4.promises.writeFile(filePath, data);
+}
+function getMapKeyByValue(value) {
+  return Object.keys(MapId).find(
+    (k) => MapId[k] === value
+  );
+}
+async function importFile(input, output, name) {
+  const workingDir = path4.resolve(".");
+  const entrypoint = path4.resolve(workingDir, input);
+  const outDir = path4.resolve(workingDir, output);
+  if (!fs4.existsSync(entrypoint)) throw new Error("Cannot find strings file");
+  const config = JSON.parse(
+    await fs4.promises.readFile(entrypoint, { encoding: "utf8" })
+  );
+  if (!fs4.existsSync(outDir))
+    await fs4.promises.mkdir(outDir, { recursive: true });
+  await startProject(outDir, "None", name ?? config.name);
+  let typescriptFile;
+  let stringsFile;
+  const scenes = [];
+  const promises = [];
+  if (config.attachments) {
+    for (const attachment of config.attachments) {
+      if (attachment.attachmentType === AttachmentType2.TypeScript)
+        typescriptFile = attachment.filename;
+      if (attachment.attachmentType === AttachmentType2.Strings)
+        stringsFile = attachment.filename;
+      if (attachment.attachmentType === AttachmentType2.SpatialData) {
+        continue;
+      }
+      promises.push(
+        writeFileSafe(
+          path4.resolve(outDir, "src", attachment.filename),
+          atob(attachment.attachmentData.original)
+        )
+      );
+    }
+  }
+  if (config.mapRotation?.length) {
+    for (const map of config.mapRotation) {
+      promises.push(
+        writeFileSafe(
+          path4.resolve(outDir, "src", "scenes", map.spatialAttachment.filename),
+          atob(map.spatialAttachment.attachmentData.original)
+        )
+      );
+      scenes.push([map.id, `src/scenes/${map.spatialAttachment.filename}`]);
+    }
+  }
+  const bf6Config = {
+    name: name ?? config.name,
+    description: config.description,
+    outDir: "dist",
+    entrypoint: typescriptFile ? `src/${typescriptFile}` : void 0,
+    scenes: scenes ? scenes.map(([id, path6]) => [
+      `MapId.${getMapKeyByValue(id) ?? id}`,
+      path6
+    ]) : void 0,
+    strings: stringsFile ? `src/${stringsFile}` : void 0,
+    game: {
+      mutators: config.mutators,
+      assetRestrictions: config.assetRestrictions,
+      gameMode: config.gameMode,
+      teamComposition: config.teamComposition
+    }
+  };
+  const bf6ConfigContent = `export default defineBf6Config(${stringifyWithRaw(
+    bf6Config
+  )});
+`;
+  promises.push(
+    writeFileSafe(path4.resolve(outDir, "bf6.config.ts"), bf6ConfigContent)
+  );
+  await Promise.all(promises);
+}
+function stringifyWithRaw(value, options = {}) {
+  return stringifyObject(value, {
+    indent: "    ",
+    // 4 spaces
+    singleQuotes: true,
+    transform: (_obj, _prop, originalResult) => {
+      if (/^['"]MapId\.[A-Za-z0-9_]+['"]$/.test(originalResult)) {
+        return originalResult.slice(1, -1);
+      }
+      return originalResult;
+    },
+    ...options
+  });
 }
 
 // src/cli/prepare.ts
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs2 from "fs";
-import { genExport } from "knitwork";
+import colors3 from "colors";
+import { genExport, genInlineTypeImport } from "knitwork";
+
+// src/cli/utils.ts
+import colors2 from "colors";
 
 // ../../node_modules/ansi-regex/index.js
 function ansiRegex({ onlyFirst = false } = {}) {
@@ -146,42 +566,80 @@ function stripAnsi(string) {
 }
 
 // src/cli/utils.ts
-import colors from "colors";
 var printToConsole = (message) => {
   const now = /* @__PURE__ */ new Date();
-  const formattedTime = colors.grey(now.toLocaleTimeString());
+  const formattedTime = colors2.grey(now.toLocaleTimeString());
   const terminalWidth = process.stdout.columns || 80;
   const timeLength = stripAnsi(formattedTime).length;
   const messageLength = stripAnsi(message).length;
-  console.log(`${message}${" ".repeat(terminalWidth - (messageLength + timeLength))}${formattedTime}`);
+  const available = terminalWidth - (messageLength + timeLength);
+  const spacing = available > 1 ? " ".repeat(available) : " ";
+  console.log(`${message}${spacing}${formattedTime}`);
 };
 
 // src/cli/prepare.ts
 async function prepare() {
   try {
     const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = path3.dirname(__filename2);
-    const workingDir = path3.resolve(".");
-    const buildDir = path3.resolve(".bf6");
-    const resources = path3.resolve(__dirname2, "../../resources/prepare");
-    fs2.cpSync(path3.resolve(resources, "tsconfig.json"), path3.resolve(buildDir, "tsconfig.json"));
-    fs2.cpSync(path3.resolve(resources, "bf6.d.ts"), path3.resolve(buildDir, "bf6.d.ts"));
-    fs2.cpSync(path3.resolve(resources, "types", "config.ts"), path3.resolve(buildDir, "types", "config.ts"));
-    const ConfigFileExports = genExport("./types/config", ["defineBf6Config"]);
-    fs2.writeFileSync(path3.resolve(buildDir, "imports.d.ts"), `${ConfigFileExports}
-`);
-    printToConsole(`${"\u2714".green} Types generated in .bf6`);
+    const __dirname2 = path5.dirname(__filename2);
+    const _workingDir = path5.resolve(".");
+    const buildDir = path5.resolve(".bf6");
+    const resources = path5.resolve(__dirname2, "../resources/prepare");
+    fs5.cpSync(
+      path5.resolve(resources, "tsconfig.json"),
+      path5.resolve(buildDir, "tsconfig.json")
+    );
+    fs5.cpSync(
+      path5.resolve(resources, "bf6.d.ts"),
+      path5.resolve(buildDir, "bf6.d.ts")
+    );
+    fs5.cpSync(
+      path5.resolve(resources, "types", "config.ts"),
+      path5.resolve(buildDir, "types", "config.ts")
+    );
+    const ConfigFileExports = genExport("./types/config.ts", [
+      "defineBf6Config"
+    ]);
+    fs5.writeFileSync(
+      path5.resolve(buildDir, "imports.d.ts"),
+      `${ConfigFileExports}
+`
+    );
+    const augmentations = {
+      defineBf6Config: genInlineTypeImport(
+        "./types/config.ts",
+        `defineBf6Config`
+      ),
+      MapId: genInlineTypeImport("./types/config.ts", `MapId`)
+    };
+    const args = genNamespaceAugmentation("global", augmentations);
+    fs5.writeFileSync(
+      path5.resolve(buildDir, "globals.d.ts"),
+      `export {}
+
+${args}
+`
+    );
+    printToConsole(`${colors3.green("\u2714")} Types generated in .bf6`);
   } catch (error) {
     console.error(error);
-    printToConsole(`${"\u2717".red} Types failed to generate in .bf6`);
+    printToConsole(`${colors3.red("\u2717")} Types failed to generate in .bf6`);
   }
 }
+var genNamespaceAugmentation = (name, contents) => {
+  if (!contents || Object.keys(contents).length === 0)
+    return `declare ${name} {}`;
+  const decls = Object.entries(contents).map(([k, v]) => `	const ${k}: ${v};`).join("\n");
+  return `declare ${name} {
+${decls}
+}`;
+};
 
 // src/cli/index.ts
 var program = new Command();
 program.name(Object.keys(package_default.bin)[0]).description(package_default.description).version(package_default.version);
-program.command("init").description("Create a new bf6 mod").action(async () => {
-  await init();
+program.command("init").argument("[directory]").description("Create a new bf6 mod").action(async (directory) => {
+  await init(directory);
 });
 program.command("build").description("build the bf6 mod").action(async () => {
   await build();
@@ -189,6 +647,13 @@ program.command("build").description("build the bf6 mod").action(async () => {
 program.command("prepare").description("prepare the types for bf6 mod").action(async () => {
   await prepare();
 });
+program.command("dev").description("watch the changes in src, and recompile as needed").action(async () => {
+  await dev();
+});
+program.command("import").argument("<input>").argument("<output>").description("decompiles the json config of a mod into a new project").action(async (input, output) => {
+  await importFile(input, output);
+  installDependencies(output);
+});
 program.exitOverride((_err) => {
   if (process.env.EXIT_CODE === "none") process.exit(0);
 });