fwinit 1.2.0 → 1.3.1

package/README.md

@@ -1,6 +1,6 @@
 # fwinit
 
-CLI para crear proyectos desde templates. Instalás una vez y scaffoldás proyectos con un comando.
+CLI para crear proyectos desde templates. Instalás una vez y scaffoldás proyectos con un comando: un solo template, o un proyecto full stack completo (backend + frontend + base de datos).
 
 ## Instalación
 
@@ -17,51 +17,112 @@ bun add -g fwinit
 
 ## Uso
 
-### Modo directo
-
 ```bash
+# Menú interactivo: elegís entre full stack, solo backend o solo frontend
+fwinit
+
+# Crear un solo template (backend o frontend)
 fwinit fastify mi-api
 fwinit aspnet mi-app
 fwinit react-native mi-mobile
+
+# Crear un proyecto completo: backend + frontend (+ db incluida)
+fwinit fullstack mi-proyecto
+
+# Elegir los templates sin preguntas (modo scripting/CI)
+fwinit fullstack mi-proyecto -b fastify -f react-native -p pnpm
+
+# Ver templates disponibles (agrupados por capa)
+fwinit list
+
+# Ayuda
+fwinit --help
 ```
 
 ### Modo interactivo
 
-```bash
-fwinit
+`fwinit` sin argumentos abre el menú principal:
+
+```
+? ¿Qué querés crear?
+> Full stack (backend + frontend)
+  Solo backend (API)
+  Solo frontend (app)
 ```
 
-Te pregunta qué template usar y el nombre del proyecto.
+- **Full stack**: te pregunta primero el backend y después el frontend, y arma el monorepo completo.
+- **Solo backend / Solo frontend**: te pregunta el template de la capa, el nombre, el layout y el package manager.
 
-### Ver templates disponibles
+### Proyecto full stack
 
 ```bash
-fwinit list
+fwinit fullstack mi-proyecto
 ```
 
-### Help
+Pregunta qué backend querés (ASP.NET, Express, Fastify, Node.js Vanilla) y qué frontend (React Native). Genera:
+
+```
+mi-proyecto/
+├── backend/          # API (template elegido — trae su DB: Prisma o EF)
+├── frontend/         # App (template frontend elegido)
+├── .gitignore        # .atl/ · odd · .opencode/
+├── .opencode/        # Skills de opencode (create-specs incluida)
+├── README.md         # Cómo correr backend y frontend
+└── specs/            # La creás con /create-specs
+```
+
+La base de datos no se configura aparte: viene incluida en el template backend (Prisma en los templates JS/TS, EF Core en ASP.NET).
+
+### Layout de capa (monorepo liviano)
+
+Al crear un solo template, el CLI pregunta si querés empaquetar el código en una carpeta de capa (default: sí):
 
 ```bash
-fwinit --help
+# backend/ + .opencode/ + specs/ al mismo nivel
+fwinit express mi-api
+# raíz limpia (todo el código en mi-api/)
+fwinit express mi-api --no-backend
+# forzar el layout de capa sin preguntas
+fwinit express mi-api --backend
 ```
 
+Igual para frontend: `fwinit react-native mi-app` pregunta por `frontend/`.
+
+## Flags
+
+| Flag | Descripción |
+|------|-------------|
+| `-p, --pm <manager>` | Package manager: `npm`, `pnpm` o `bun` (saltea la pregunta) |
+| `--backend` | Empaquetar el código en `backend/` (solo modo single, saltea la pregunta) |
+| `--no-backend` | Dejar el código en la raíz del proyecto (saltea la pregunta) |
+| `-b, --backend-template <tpl>` | Backend a usar en fullstack (saltea la pregunta) |
+| `-f, --frontend-template <tpl>` | Frontend a usar en fullstack (saltea la pregunta) |
+
 ## Templates disponibles
 
-| Template | Descripción | Runtime |
-|----------|-------------|---------|
-| `aspnet` | API REST con ASP.NET Core, Clean Architecture y C# | dotnet |
-| `express` | API REST con Express, Prisma, TypeScript y Bun | bun |
-| `fastify` | API REST con Fastify, Prisma, TypeScript y Bun | bun |
-| `nodejs` | API con Node.js puro, Prisma, TypeScript y tsx | node |
-| `react-native` | App móvil con React Native, Expo y TypeScript | node |
+| Template | Capa | Descripción | Runtime |
+|----------|------|-------------|---------|
+| `aspnet` | backend | API REST con ASP.NET Core, Clean Architecture y C# | dotnet |
+| `express` | backend | API REST con Express, Prisma, TypeScript y Bun | bun |
+| `fastify` | backend | API REST con Fastify, Prisma, TypeScript y Bun | bun |
+| `nodejs` | backend | API con Node.js puro, Prisma, TypeScript y tsx | node |
+| `react-native` | frontend | App móvil con React Native, Expo y TypeScript | node |
+
+La capa es metadata de cada template (`layer` en `templates/<TEMPLATE>/template.json`): para sumar un frontend nuevo (Astro, Next.js...), alcanza con agregar la carpeta del template y su `layer`. Los templates se clasifican por capa en la metadata, no por estructura de carpetas.
+
+El runtime `bun` de un template se porta automáticamente a `node` (npm/pnpm) si elegís npm o pnpm: scripts con `tsx`, tests con `vitest` y sin `bun-types`.
 
 ## Qué hace
 
-1. Descarga el ZIP del repositorio de templates desde GitHub
-2. Extrae el template seleccionado
-3. Lo copia al directorio del proyecto
-4. Limpia los lock files (cada proyecto instala los suyos)
-5. Te muestra los próximos pasos (install y dev)
+1. Descarga el ZIP del repositorio de templates desde GitHub (una sola vez, también en fullstack)
+2. Extrae y copia el template (o los dos, `backend/` + `frontend/`) al proyecto
+3. Sustituye el nombre del proyecto (package.json, app.json de Expo, proyectos ASP.NET con "Example")
+4. Si corresponde, porta el template de runtime bun a node (npm/pnpm)
+5. Instala `.opencode/` con la skill `create-specs` y el comando `/create-specs`
+6. Limpia los lock files (cada proyecto instala los suyos)
+7. Te muestra los próximos pasos (install y dev de cada carpeta)
+
+En modo fullstack, además crea `.gitignore` y `README.md` en la raíz del monorepo.
 
 ## Desarrollo
 
@@ -93,6 +154,7 @@ bun run typecheck
 ```bash
 node dist/index.js list
 node dist/index.js fastify mi-api
+node dist/index.js fullstack mi-proyecto -b fastify -f react-native -p pnpm
 ```
 
 ### Link global para desarrollo

package/dist/index.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import ora from "ora";
 import chalk from "chalk";
 import { readFileSync } from "fs";
-import { mkdir as mkdir2, cp as cp2, access } from "fs/promises";
+import { mkdir as mkdir2, cp as cp2, access, readFile as readFile2 } from "fs/promises";
 import { join as join2 } from "path";
 
 // src/templates.ts
@@ -15,37 +15,45 @@ var TEMPLATES = [
     alias: ["aspnet", "dotnet", "csharp"],
     description: "API REST con ASP.NET Core, Clean Architecture y C#",
     folder: "ASPNET",
-    runtime: "dotnet"
+    runtime: "dotnet",
+    layer: "backend"
   },
   {
     name: "Express",
     alias: ["express"],
     description: "API REST con Express, Prisma, TypeScript y Bun",
     folder: "EXPRESS",
-    runtime: "bun"
+    runtime: "bun",
+    layer: "backend"
   },
   {
     name: "Fastify",
     alias: ["fastify"],
     description: "API REST con Fastify, Prisma, TypeScript y Bun",
     folder: "FASTIFY",
-    runtime: "bun"
+    runtime: "bun",
+    layer: "backend"
   },
   {
     name: "Node.js Vanilla",
     alias: ["nodejs", "vanilla", "node"],
     description: "API con Node.js puro, Prisma, TypeScript y tsx",
     folder: "NODEJS-VANILLA",
-    runtime: "node"
+    runtime: "node",
+    layer: "backend"
   },
   {
     name: "React Native",
     alias: ["react-native", "rn", "expo"],
     description: "App m\xF3vil con React Native, Expo y TypeScript",
     folder: "REACT-NATIVE",
-    runtime: "node"
+    runtime: "node",
+    layer: "frontend"
   }
 ];
+function getTemplatesByLayer(layer) {
+  return TEMPLATES.filter((t) => t.layer === layer);
+}
 function findTemplate(input) {
   const normalized = input.toLowerCase().trim();
   return TEMPLATES.find(
@@ -61,7 +69,7 @@ import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 var GITHUB_REPO = "orlandotellez/fwinit";
 var GITHUB_BRANCH = "main";
-async function downloadAndExtract(templateFolder) {
+async function downloadAndExtractRepo() {
   const url = `https://github.com/${GITHUB_REPO}/archive/refs/heads/${GITHUB_BRANCH}.zip`;
   const response = await fetch(url);
   if (!response.ok) {
@@ -76,6 +84,10 @@ async function downloadAndExtract(templateFolder) {
   await mkdir(tempDir, { recursive: true });
   zip.extractAllTo(tempDir, true);
   const repoRoot = join(tempDir, `fwinit-${GITHUB_BRANCH}`);
+  return { tempDir, repoRoot };
+}
+async function downloadAndExtract(templateFolder) {
+  const { tempDir, repoRoot } = await downloadAndExtractRepo();
   const templatePath = join(repoRoot, "templates", templateFolder);
   try {
     await readdir(templatePath);
@@ -202,13 +214,28 @@ function toPascalCase(str) {
 
 // src/prompts.ts
 import inquirer from "inquirer";
-async function selectTemplate() {
+async function selectScope() {
+  const { scope } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "\xBFQu\xE9 quer\xE9s crear?",
+      choices: [
+        { name: "Full stack (backend + frontend)", value: "fullstack" },
+        { name: "Solo backend (API)", value: "backend" },
+        { name: "Solo frontend (app)", value: "frontend" }
+      ]
+    }
+  ]);
+  return scope;
+}
+async function selectTemplateFromLayer(layer) {
   const { template } = await inquirer.prompt([
     {
       type: "list",
       name: "template",
-      message: "\xBFQu\xE9 proyecto quer\xE9s crear?",
-      choices: TEMPLATES.map((t) => ({
+      message: layer === "backend" ? "\xBFQu\xE9 backend quer\xE9s usar?" : "\xBFQu\xE9 frontend quer\xE9s usar?",
+      choices: getTemplatesByLayer(layer).map((t) => ({
         name: `${t.name} \u2014 ${t.description}`,
         value: t
       }))
@@ -249,12 +276,12 @@ async function askProjectName() {
   ]);
   return name.trim();
 }
-async function askBackendLayout() {
+async function askLayerLayout(layer) {
   const { layout } = await inquirer.prompt([
     {
       type: "confirm",
       name: "layout",
-      message: "\xBFEmpaquetar el c\xF3digo del template en una carpeta backend/?",
+      message: layer === "backend" ? "\xBFEmpaquetar el c\xF3digo del template en una carpeta backend/?" : "\xBFEmpaquetar el c\xF3digo del template en una carpeta frontend/?",
       default: true
     }
   ]);
@@ -337,6 +364,23 @@ function printSuccess(projectName, templateName, pm, postInit, codeDir) {
   \x1B[36m${devCmd}\x1B[0m
 `);
 }
+function printSuccessFullStack(projectName, layers, pm) {
+  const blocks = layers.map((l) => {
+    const installCmd = l.postInit?.install ? resolveCommand(l.postInit.install, pm) : `${pm} install`;
+    const devCmd = l.postInit?.dev ? resolveCommand(l.postInit.dev, pm) : `${pm} run dev`;
+    return `  \x1B[36mcd ${projectName}/${l.label}\x1B[0m
+  \x1B[36m${installCmd}\x1B[0m
+  \x1B[36m${devCmd}\x1B[0m`;
+  }).join("\n\n");
+  console.log(`
+\x1B[32m\u2714\x1B[0m Template descargado
+\x1B[32m\u2714\x1B[0m Proyecto creado en ./${projectName}
+
+\x1B[1mPr\xF3ximos pasos:\x1B[0m
+
+${blocks}
+`);
+}
 function adaptScriptToNode(script) {
   let s = script.trim();
   if (/^bun test\b/.test(s)) {
@@ -346,10 +390,10 @@ function adaptScriptToNode(script) {
   return s;
 }
 async function adaptToNodeRuntime(projectPath) {
-  const { readFile: readFile2, writeFile: writeFile2, readdir: readdir2 } = await import("fs/promises");
+  const { readFile: readFile3, writeFile: writeFile2, readdir: readdir2 } = await import("fs/promises");
   const { join: join3 } = await import("path");
   const pkgPath = join3(projectPath, "package.json");
-  const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+  const pkg = JSON.parse(await readFile3(pkgPath, "utf-8"));
   for (const key of Object.keys(pkg.scripts ?? {})) {
     pkg.scripts[key] = adaptScriptToNode(pkg.scripts[key]);
   }
@@ -365,7 +409,7 @@ async function adaptToNodeRuntime(projectPath) {
       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");
+        const content = await readFile3(full, "utf-8");
         if (content.includes("bun:test")) {
           await writeFile2(full, content.replaceAll('from "bun:test"', 'from "vitest"'));
         }
@@ -379,7 +423,7 @@ async function adaptToNodeRuntime(projectPath) {
   }
   const tsconfigPath = join3(projectPath, "tsconfig.json");
   try {
-    const tsconfig = JSON.parse(await readFile2(tsconfigPath, "utf-8"));
+    const tsconfig = JSON.parse(await readFile3(tsconfigPath, "utf-8"));
     if (tsconfig.compilerOptions?.types?.includes("bun-types")) {
       delete tsconfig.compilerOptions.types;
       await writeFile2(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
@@ -387,6 +431,54 @@ async function adaptToNodeRuntime(projectPath) {
   } catch {
   }
 }
+async function writeRootFiles(info) {
+  const { writeFile: writeFile2, access: access2 } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const projectPath = resolve(process.cwd(), info.projectName);
+  const gitignorePath = join3(projectPath, ".gitignore");
+  try {
+    await access2(gitignorePath);
+  } catch {
+    await writeFile2(
+      gitignorePath,
+      "# AI dev state\n.atl/\nodd\n.opencode/\n"
+    );
+  }
+  const installB = info.backend.postInit?.install ? resolveCommand(info.backend.postInit.install, info.pm) : `${info.pm} install`;
+  const devB = info.backend.postInit?.dev ? resolveCommand(info.backend.postInit.dev, info.pm) : `${info.pm} run dev`;
+  const installF = info.frontend.postInit?.install ? resolveCommand(info.frontend.postInit.install, info.pm) : `${info.pm} install`;
+  const devF = info.frontend.postInit?.dev ? resolveCommand(info.frontend.postInit.dev, info.pm) : `${info.pm} run dev`;
+  const readme = [
+    `# ${info.projectName}`,
+    "",
+    "Proyecto full stack generado con [fwinit](https://github.com/orlandotellez/fwinit).",
+    "",
+    "## Estructura",
+    "",
+    `- \`backend/\` \u2014 ${info.backend.description}`,
+    `- \`frontend/\` \u2014 ${info.frontend.description}`,
+    "- `.opencode/` \u2014 skills de opencode (us\xE1 `/create-specs` para generar las specs)",
+    "- `specs/` \u2014 especificaciones del proyecto",
+    "",
+    "## Backend",
+    "",
+    "```bash",
+    "cd backend",
+    installB,
+    devB,
+    "```",
+    "",
+    "## Frontend",
+    "",
+    "```bash",
+    "cd frontend",
+    installF,
+    devF,
+    "```",
+    ""
+  ].join("\n");
+  await writeFile2(join3(projectPath, "README.md"), readme);
+}
 
 // src/index.ts
 var program = new Command();
@@ -424,22 +516,89 @@ async function installOpenCodeFiles(repoRoot, projectPath) {
     join2(projectPath, ".opencode", "commands", "create-specs.md")
   );
 }
+async function readTemplatePostInit(dir) {
+  try {
+    const tj = JSON.parse(
+      await readFile2(join2(dir, "template.json"), "utf-8")
+    );
+    return tj.postInit;
+  } catch {
+    return void 0;
+  }
+}
+async function createFullStackProject(projectName, backendTpl, frontendTpl, pm) {
+  const { tempDir, repoRoot } = await downloadAndExtractRepo();
+  const projectPath = getProjectPath(projectName);
+  const backendPath = join2(projectPath, "backend");
+  const frontendPath = join2(projectPath, "frontend");
+  await copyTemplate(
+    join2(repoRoot, "templates", backendTpl.folder),
+    backendPath
+  );
+  await copyTemplate(
+    join2(repoRoot, "templates", frontendTpl.folder),
+    frontendPath
+  );
+  await substituteTemplate(backendPath, projectName, backendTpl.folder);
+  await substituteTemplate(frontendPath, projectName, frontendTpl.folder);
+  await installOpenCodeFiles(repoRoot, projectPath);
+  if (backendTpl.runtime === "bun" && pm !== "bun") {
+    await adaptToNodeRuntime(backendPath);
+  }
+  const backendPost = await readTemplatePostInit(backendPath);
+  const frontendPost = await readTemplatePostInit(frontendPath);
+  await writeRootFiles({
+    projectName,
+    backend: {
+      label: "backend",
+      description: backendTpl.description,
+      postInit: backendPost
+    },
+    frontend: {
+      label: "frontend",
+      description: frontendTpl.description,
+      postInit: frontendPost
+    },
+    pm
+  });
+  await cleanup(tempDir);
+  printSuccessFullStack(
+    projectName,
+    [
+      { label: "backend", postInit: backendPost },
+      { label: "frontend", postInit: frontendPost }
+    ],
+    pm
+  );
+  console.log(
+    chalk.dim(
+      "  Estructura: backend/ (API) \xB7 frontend/ (app) \xB7 .opencode/ y specs/ (al mismo nivel)\n"
+    )
+  );
+}
 program.name("fwinit").description("CLI para crear proyectos desde templates").version(getCliVersion());
 program.command("list").description("Mostrar templates disponibles").action(() => {
   console.log(
     chalk.bold("\nTemplates disponibles:\n")
   );
-  TEMPLATES.forEach((t) => {
-    console.log(
-      `  ${chalk.cyan(t.folder.toLowerCase())} \u2014 ${t.description}`
-    );
-  });
-  console.log();
+  for (const [label, layer] of [
+    ["Backend", "backend"],
+    ["Frontend", "frontend"]
+  ]) {
+    console.log(chalk.bold(`${label}:
+`));
+    getTemplatesByLayer(layer).forEach((t) => {
+      console.log(
+        `  ${chalk.cyan(t.folder.toLowerCase())} \u2014 ${t.description}`
+      );
+    });
+    console.log();
+  }
 });
-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").option("--backend", "Empaquetar el c\xF3digo en backend/ (saltea la pregunta)").option("--no-backend", "Dejar el c\xF3digo en la ra\xEDz del proyecto (saltea la pregunta)").action(
+program.argument("[template]", "Template a usar (o 'fullstack' para backend + frontend)").argument("[project-name]", "Nombre del proyecto").option("-p, --pm <package-manager>", "Package manager a usar: npm, pnpm o bun").option("--backend", "Empaquetar el c\xF3digo en backend/ (saltea la pregunta)").option("--no-backend", "Dejar el c\xF3digo en la ra\xEDz del proyecto (saltea la pregunta)").option("-b, --backend-template <tpl>", "Backend a usar en fullstack (saltea la pregunta)").option("-f, --frontend-template <tpl>", "Frontend a usar en fullstack (saltea la pregunta)").action(
   async (templateArg, projectNameArg) => {
     try {
-      const { pm: pmArg, backend } = program.opts();
+      const { pm: pmArg, backend, backendTemplate, frontendTemplate } = program.opts();
       if (pmArg && !PACKAGE_MANAGERS.includes(pmArg)) {
         console.error(
           chalk.red(
@@ -450,31 +609,83 @@ program.argument("[template]", "Template a usar").argument("[project-name]", "No
         );
         process.exit(1);
       }
-      let template = templateArg ? findTemplate(templateArg) : void 0;
       let projectName = projectNameArg;
       let pm = pmArg;
-      if (templateArg && !template) {
-        console.error(
-          chalk.red(
-            `
+      let isFullStack = false;
+      let template;
+      const rawArg = templateArg?.toLowerCase();
+      if (rawArg === void 0) {
+        const scope = await selectScope();
+        if (scope === "fullstack") {
+          isFullStack = true;
+        } else {
+          template = await selectTemplateFromLayer(scope);
+        }
+      } else if (rawArg === "fullstack") {
+        isFullStack = true;
+      } else {
+        template = findTemplate(rawArg);
+        if (!template) {
+          console.error(
+            chalk.red(
+              `
 \u2716 Template "${templateArg}" no encontrado.
 `
-          )
-        );
-        console.log("Templates disponibles:");
-        TEMPLATES.forEach(
-          (t) => console.log(`  - ${t.folder.toLowerCase()}`)
-        );
-        process.exit(1);
+            )
+          );
+          console.log("Templates disponibles:");
+          for (const [label, layer2] of [
+            ["Backend", "backend"],
+            ["Frontend", "frontend"]
+          ]) {
+            console.log(chalk.bold(`${label}:`));
+            getTemplatesByLayer(layer2).forEach(
+              (t) => console.log(`  - ${t.folder.toLowerCase()}`)
+            );
+          }
+          process.exit(1);
+        }
       }
-      if (!template) {
-        template = await selectTemplate();
+      let backendTpl;
+      let frontendTpl;
+      if (isFullStack) {
+        backendTpl = backendTemplate ? findTemplate(backendTemplate) : void 0;
+        frontendTpl = frontendTemplate ? findTemplate(frontendTemplate) : void 0;
+        if (backendTemplate && !backendTpl) {
+          console.error(
+            chalk.red(
+              `
+\u2716 Backend "${backendTemplate}" no encontrado.
+`
+            )
+          );
+          process.exit(1);
+        }
+        if (frontendTemplate && !frontendTpl) {
+          console.error(
+            chalk.red(
+              `
+\u2716 Frontend "${frontendTemplate}" no encontrado.
+`
+            )
+          );
+          process.exit(1);
+        }
+        if (!backendTpl) {
+          backendTpl = await selectTemplateFromLayer("backend");
+        }
+        if (!frontendTpl) {
+          frontendTpl = await selectTemplateFromLayer("frontend");
+        }
       }
       if (!projectName) {
         projectName = await askProjectName();
       }
-      const useBackendLayout = backend === void 0 ? await askBackendLayout() : backend;
-      if (!pm && template.runtime !== "dotnet") {
+      const layer = template?.layer;
+      const useLayerLayout = !template ? false : backend === void 0 ? await askLayerLayout(layer) : backend;
+      const runtimes = template ? [template.runtime] : [backendTpl.runtime, frontendTpl.runtime];
+      const needsPm = runtimes.some((r) => r !== "dotnet");
+      if (!pm && needsPm) {
         pm = await selectPackageManager();
       }
       if (projectExists(projectName)) {
@@ -487,56 +698,40 @@ program.argument("[template]", "Template a usar").argument("[project-name]", "No
         process.exit(1);
       }
       const spinner = ora(
-        `Descargando template ${template.name}...`
+        isFullStack ? "Descargando templates..." : `Descargando template ${template.name}...`
       ).start();
-      const { tempDir, templatePath, repoRoot } = await downloadAndExtract(template.folder);
-      const projectPath = getProjectPath(projectName);
-      const codePath = useBackendLayout ? join2(projectPath, "backend") : projectPath;
-      spinner.text = "Creando proyecto...";
-      await copyTemplate(
-        templatePath,
-        codePath
-      );
-      await substituteTemplate(
-        codePath,
-        projectName,
-        template.folder
-      );
-      await installOpenCodeFiles(
-        repoRoot,
-        projectPath
-      );
-      if (template.runtime === "bun" && pm && pm !== "bun") {
-        await adaptToNodeRuntime(codePath);
-      }
-      await cleanup(tempDir);
-      spinner.succeed("Template descargado");
-      let postInit;
-      try {
-        const { readFile: readFile2 } = await import("fs/promises");
-        const { join: join3 } = await import("path");
-        const tj = JSON.parse(
-          await readFile2(
-            join3(codePath, "template.json"),
-            "utf-8"
-          )
-        );
-        postInit = tj.postInit;
-      } catch {
-      }
-      printSuccess(
-        projectName,
-        template.name,
-        pm ?? "npm",
-        postInit,
-        useBackendLayout ? "backend" : void 0
-      );
-      if (useBackendLayout) {
-        console.log(
-          chalk.dim(
-            "  Estructura: backend/ (c\xF3digo) \xB7 .opencode/ y specs/ (al mismo nivel)\n"
-          )
+      if (isFullStack) {
+        spinner.text = "Creando proyecto...";
+        await createFullStackProject(projectName, backendTpl, frontendTpl, pm ?? "npm");
+        spinner.succeed("Template descargado");
+      } else {
+        const { tempDir, templatePath, repoRoot } = await downloadAndExtract(template.folder);
+        const projectPath = getProjectPath(projectName);
+        const codePath = useLayerLayout ? join2(projectPath, layer) : projectPath;
+        spinner.text = "Creando proyecto...";
+        await copyTemplate(templatePath, codePath);
+        await substituteTemplate(codePath, projectName, template.folder);
+        await installOpenCodeFiles(repoRoot, projectPath);
+        if (template.runtime === "bun" && pm && pm !== "bun") {
+          await adaptToNodeRuntime(codePath);
+        }
+        await cleanup(tempDir);
+        spinner.succeed("Template descargado");
+        printSuccess(
+          projectName,
+          template.name,
+          pm ?? "npm",
+          await readTemplatePostInit(codePath),
+          useLayerLayout ? layer : void 0
         );
+        if (useLayerLayout) {
+          console.log(
+            chalk.dim(
+              `  Estructura: ${layer}/ (c\xF3digo) \xB7 .opencode/ y specs/ (al mismo nivel)
+`
+            )
+          );
+        }
       }
     } catch (error) {
       console.error(

package/package.json

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