fwinit 1.0.2 → 1.0.4

package/dist/index.js

@@ -11,31 +11,36 @@ var TEMPLATES = [
     name: "ASP.NET",
     alias: ["aspnet", "dotnet", "csharp"],
     description: "API REST con ASP.NET Core, Clean Architecture y C#",
-    folder: "ASPNET"
+    folder: "ASPNET",
+    runtime: "dotnet"
   },
   {
     name: "Express",
     alias: ["express"],
     description: "API REST con Express, Prisma, TypeScript y Bun",
-    folder: "EXPRESS"
+    folder: "EXPRESS",
+    runtime: "bun"
   },
   {
     name: "Fastify",
     alias: ["fastify"],
     description: "API REST con Fastify, Prisma, TypeScript y Bun",
-    folder: "FASTIFY"
+    folder: "FASTIFY",
+    runtime: "bun"
   },
   {
     name: "Node.js Vanilla",
     alias: ["nodejs", "vanilla", "node"],
     description: "API con Node.js puro, Prisma, TypeScript y tsx",
-    folder: "NODEJS-VANILLA"
+    folder: "NODEJS-VANILLA",
+    runtime: "node"
   },
   {
     name: "React Native",
     alias: ["react-native", "rn", "expo"],
     description: "App m\xF3vil con React Native, Expo y TypeScript",
-    folder: "REACT-NATIVE"
+    folder: "REACT-NATIVE",
+    runtime: "node"
   }
 ];
 function findTemplate(input) {
@@ -117,6 +122,23 @@ async function substituteNodejs(dir, projectName) {
     await writeFile(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
   } catch {
   }
+  const appJsonPath = join(dir, "app.json");
+  try {
+    const content = await readFile(appJsonPath, "utf-8");
+    const app = JSON.parse(content);
+    if (app.expo) {
+      app.expo.name = projectName;
+      app.expo.slug = projectName;
+      if (app.expo.scheme) {
+        app.expo.scheme = toScheme(projectName);
+      }
+      await writeFile(appJsonPath, JSON.stringify(app, null, 2) + "\n");
+    }
+  } catch {
+  }
+}
+function toScheme(str) {
+  return str.replace(/[-_\s]+/g, "").toLowerCase();
 }
 async function substituteAspNet(dir, projectName) {
   const pascalName = toPascalCase(projectName);
@@ -191,6 +213,22 @@ async function selectTemplate() {
   ]);
   return template;
 }
+async function selectPackageManager() {
+  const { pm } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "pm",
+      message: "\xBFQu\xE9 package manager quer\xE9s usar?",
+      choices: [
+        { name: "pnpm (recomendado)", value: "pnpm" },
+        { name: "npm", value: "npm" },
+        { name: "bun", value: "bun" }
+      ],
+      default: "pnpm"
+    }
+  ]);
+  return pm;
+}
 async function askProjectName() {
   const { name } = await inquirer.prompt([
     {
@@ -212,15 +250,67 @@ async function askProjectName() {
 // src/utils.ts
 import { existsSync } from "fs";
 import { resolve } from "path";
+var PM_RUNNER = {
+  npm: "npm",
+  pnpm: "pnpm",
+  bun: "bun"
+};
+var PM_EXEC = {
+  npm: "npx",
+  pnpm: "pnpm exec",
+  bun: "bunx"
+};
+var BUN_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "install",
+  "add",
+  "remove",
+  "update",
+  "upgrade",
+  "run",
+  "x",
+  "link",
+  "unlink",
+  "init",
+  "create",
+  "pm",
+  "outdated",
+  "why",
+  "publish",
+  "prune",
+  "rebuild"
+]);
 function getProjectPath(name) {
   return resolve(process.cwd(), name);
 }
 function projectExists(name) {
   return existsSync(getProjectPath(name));
 }
-function printSuccess(projectName, templateName, postInit) {
-  const installCmd = postInit?.install || "npm install";
-  const devCmd = postInit?.dev || "npm run dev";
+function resolveCommand(cmd, pm) {
+  const tokens = cmd.trim().split(/\s+/);
+  const [runner, ...rest] = tokens;
+  switch (runner) {
+    case "pnpm":
+      return [PM_RUNNER[pm], ...rest].join(" ");
+    case "npm":
+      return [PM_RUNNER[pm], ...rest].join(" ");
+    case "bun": {
+      if (pm === "bun") return cmd;
+      const sub = rest[0];
+      if (sub && !BUN_SUBCOMMANDS.has(sub)) {
+        return [PM_RUNNER[pm], "run", ...rest].join(" ");
+      }
+      return [PM_RUNNER[pm], ...rest].join(" ");
+    }
+    case "npx":
+    case "bunx":
+      return [PM_EXEC[pm], ...rest].join(" ");
+    default:
+      return cmd;
+  }
+}
+function printSuccess(projectName, templateName, pm, postInit) {
+  const installCmd = postInit?.install ? resolveCommand(postInit.install, pm) : `${pm} install`;
+  const devCmd = postInit?.dev ? resolveCommand(postInit.dev, pm) : `${pm} run dev`;
   console.log(`
 \x1B[32m\u2714\x1B[0m Template descargado
 \x1B[32m\u2714\x1B[0m Proyecto creado en ./${projectName}
@@ -232,9 +322,60 @@ function printSuccess(projectName, templateName, postInit) {
   \x1B[36m${devCmd}\x1B[0m
 `);
 }
+function adaptScriptToNode(script) {
+  let s = script.trim();
+  if (/^bun test\b/.test(s)) {
+    s = s.replace(/^bun test\b/, "vitest run");
+  }
+  s = s.replace(/^bun --hot /, "tsx watch ").replace(/^bunx /, "").replace(/^bun /, "tsx ");
+  return s;
+}
+async function adaptToNodeRuntime(projectPath) {
+  const { readFile: readFile2, writeFile: writeFile2, readdir: readdir2 } = await import("fs/promises");
+  const { join: join2 } = await import("path");
+  const pkgPath = join2(projectPath, "package.json");
+  const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+  for (const key of Object.keys(pkg.scripts ?? {})) {
+    pkg.scripts[key] = adaptScriptToNode(pkg.scripts[key]);
+  }
+  pkg.devDependencies ??= {};
+  pkg.devDependencies.tsx = "^4.0.0";
+  pkg.devDependencies.vitest = "^3.0.0";
+  delete pkg.devDependencies["bun-types"];
+  await writeFile2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  async function walk(dir) {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules") await walk(full);
+      } else if (entry.name.endsWith(".test.ts")) {
+        const content = await readFile2(full, "utf-8");
+        if (content.includes("bun:test")) {
+          await writeFile2(full, content.replaceAll('from "bun:test"', 'from "vitest"'));
+        }
+      }
+    }
+  }
+  const srcDir = join2(projectPath, "src");
+  try {
+    await walk(srcDir);
+  } catch {
+  }
+  const tsconfigPath = join2(projectPath, "tsconfig.json");
+  try {
+    const tsconfig = JSON.parse(await readFile2(tsconfigPath, "utf-8"));
+    if (tsconfig.compilerOptions?.types?.includes("bun-types")) {
+      delete tsconfig.compilerOptions.types;
+      await writeFile2(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+    }
+  } catch {
+  }
+}
 
 // src/index.ts
 var program = new Command();
+var PACKAGE_MANAGERS = ["npm", "pnpm", "bun"];
 program.name("fwinit").description("CLI para crear proyectos desde templates").version("1.0.0");
 program.command("list").description("Mostrar templates disponibles").action(() => {
   console.log(
@@ -247,11 +388,23 @@ program.command("list").description("Mostrar templates disponibles").action(() =
   });
   console.log();
 });
-program.argument("[template]", "Template a usar").argument("[project-name]", "Nombre del proyecto").action(
+program.argument("[template]", "Template a usar").argument("[project-name]", "Nombre del proyecto").option("-p, --pm <package-manager>", "Package manager a usar: npm, pnpm o bun").action(
   async (templateArg, projectNameArg) => {
     try {
+      const { pm: pmArg } = program.opts();
+      if (pmArg && !PACKAGE_MANAGERS.includes(pmArg)) {
+        console.error(
+          chalk.red(
+            `
+\u2716 Package manager "${pmArg}" inv\xE1lido. Us\xE1: npm, pnpm o bun.
+`
+          )
+        );
+        process.exit(1);
+      }
       let template = templateArg ? findTemplate(templateArg) : void 0;
       let projectName = projectNameArg;
+      let pm = pmArg;
       if (templateArg && !template) {
         console.error(
           chalk.red(
@@ -272,6 +425,9 @@ program.argument("[template]", "Template a usar").argument("[project-name]", "No
       if (!projectName) {
         projectName = await askProjectName();
       }
+      if (!pm && template.runtime !== "dotnet") {
+        pm = await selectPackageManager();
+      }
       if (projectExists(projectName)) {
         console.error(
           chalk.red(
@@ -295,6 +451,9 @@ program.argument("[template]", "Template a usar").argument("[project-name]", "No
         projectName,
         template.folder
       );
+      if (template.runtime === "bun" && pm && pm !== "bun") {
+        await adaptToNodeRuntime(getProjectPath(projectName));
+      }
       await cleanup(tempDir);
       spinner.succeed("Template descargado");
       let postInit;
@@ -310,7 +469,7 @@ program.argument("[template]", "Template a usar").argument("[project-name]", "No
         postInit = tj.postInit;
       } catch {
       }
-      printSuccess(projectName, template.name, postInit);
+      printSuccess(projectName, template.name, pm ?? "npm", postInit);
     } catch (error) {
       console.error(
         chalk.red(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fwinit",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI para crear proyectos desde templates",
   "type": "module",
   "bin": {