fwinit 1.1.2 → 1.3.0

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,6 +276,17 @@ async function askProjectName() {
   ]);
   return name.trim();
 }
+async function askLayerLayout(layer) {
+  const { layout } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "layout",
+      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
+    }
+  ]);
+  return layout;
+}
 
 // src/utils.ts
 import { existsSync } from "fs";
@@ -311,20 +349,38 @@ function resolveCommand(cmd, pm) {
       return cmd;
   }
 }
-function printSuccess(projectName, templateName, pm, postInit) {
+function printSuccess(projectName, templateName, pm, postInit, codeDir) {
   const installCmd = postInit?.install ? resolveCommand(postInit.install, pm) : `${pm} install`;
   const devCmd = postInit?.dev ? resolveCommand(postInit.dev, pm) : `${pm} run dev`;
+  const target = codeDir ? `${projectName}/${codeDir}` : projectName;
   console.log(`
 \x1B[32m\u2714\x1B[0m Template descargado
-\x1B[32m\u2714\x1B[0m Proyecto creado en ./${projectName}
+\x1B[32m\u2714\x1B[0m Proyecto creado en ./${target}
 
 \x1B[1mPr\xF3ximos pasos:\x1B[0m
 
-  \x1B[36mcd ${projectName}\x1B[0m
+  \x1B[36mcd ${target}\x1B[0m
   \x1B[36m${installCmd}\x1B[0m
   \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)) {
@@ -334,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]);
   }
@@ -353,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"'));
         }
@@ -367,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");
@@ -375,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();
@@ -412,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").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 } = program.opts();
+      const { pm: pmArg, backend, backendTemplate, frontendTemplate } = program.opts();
       if (pmArg && !PACKAGE_MANAGERS.includes(pmArg)) {
         console.error(
           chalk.red(
@@ -438,30 +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();
       }
-      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)) {
@@ -474,42 +698,41 @@ 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);
-      spinner.text = "Creando proyecto...";
-      await copyTemplate(
-        templatePath,
-        getProjectPath(projectName)
-      );
-      await substituteTemplate(
-        getProjectPath(projectName),
-        projectName,
-        template.folder
-      );
-      await installOpenCodeFiles(
-        repoRoot,
-        getProjectPath(projectName)
-      );
-      if (template.runtime === "bun" && pm && pm !== "bun") {
-        await adaptToNodeRuntime(getProjectPath(projectName));
-      }
-      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(getProjectPath(projectName), "template.json"),
-            "utf-8"
-          )
+      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
         );
-        postInit = tj.postInit;
-      } catch {
+        if (useLayerLayout) {
+          console.log(
+            chalk.dim(
+              `  Estructura: ${layer}/ (c\xF3digo) \xB7 .opencode/ y specs/ (al mismo nivel)
+`
+            )
+          );
+        }
       }
-      printSuccess(projectName, template.name, pm ?? "npm", postInit);
     } catch (error) {
       console.error(
         chalk.red(

package/package.json

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