fwinit 1.3.0 → 1.3.2

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

@@ -6,7 +6,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { readFileSync } from "fs";
 import { mkdir as mkdir2, cp as cp2, access, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join2, basename } from "path";
 
 // src/templates.ts
 var TEMPLATES = [
@@ -243,6 +243,17 @@ async function selectTemplateFromLayer(layer) {
   ]);
   return template;
 }
+async function askGitInit() {
+  const { initGit } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "initGit",
+      message: "\xBFInicializar un repositorio git?",
+      default: true
+    }
+  ]);
+  return initGit;
+}
 async function selectPackageManager() {
   const { pm } = await inquirer.prompt([
     {
@@ -431,10 +442,9 @@ async function adaptToNodeRuntime(projectPath) {
   } catch {
   }
 }
-async function writeRootFiles(info) {
+async function writeRootGitignore(projectPath) {
   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);
@@ -444,6 +454,28 @@ async function writeRootFiles(info) {
       "# AI dev state\n.atl/\nodd\n.opencode/\n"
     );
   }
+}
+async function gitInit(projectPath) {
+  const { execFile } = await import("child_process");
+  try {
+    await new Promise((resolve2, reject) => {
+      execFile(
+        "git",
+        ["init"],
+        { cwd: projectPath },
+        (err) => err ? reject(err) : resolve2()
+      );
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeRootFiles(info) {
+  const { writeFile: writeFile2 } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const projectPath = resolve(process.cwd(), info.projectName);
+  await writeRootGitignore(projectPath);
   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`;
@@ -526,9 +558,9 @@ async function readTemplatePostInit(dir) {
     return void 0;
   }
 }
-async function createFullStackProject(projectName, backendTpl, frontendTpl, pm) {
+async function createFullStackProject(projectPath, backendTpl, frontendTpl, pm) {
   const { tempDir, repoRoot } = await downloadAndExtractRepo();
-  const projectPath = getProjectPath(projectName);
+  const projectName = basename(projectPath);
   const backendPath = join2(projectPath, "backend");
   const frontendPath = join2(projectPath, "frontend");
   await copyTemplate(
@@ -595,10 +627,10 @@ program.command("list").description("Mostrar templates disponibles").action(() =
     console.log();
   }
 });
-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(
+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)").option("--git", "Inicializar un repositorio git (saltea la pregunta)").option("--no-git", "No inicializar git (saltea la pregunta)").action(
   async (templateArg, projectNameArg) => {
     try {
-      const { pm: pmArg, backend, backendTemplate, frontendTemplate } = program.opts();
+      const { pm: pmArg, backend, backendTemplate, frontendTemplate, git } = program.opts();
       if (pmArg && !PACKAGE_MANAGERS.includes(pmArg)) {
         console.error(
           chalk.red(
@@ -688,6 +720,7 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
       if (!pm && needsPm) {
         pm = await selectPackageManager();
       }
+      const wantsGit = git === void 0 ? await askGitInit() : git;
       if (projectExists(projectName)) {
         console.error(
           chalk.red(
@@ -697,21 +730,29 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
         );
         process.exit(1);
       }
+      const projectPath = getProjectPath(projectName);
       const spinner = ora(
         isFullStack ? "Descargando templates..." : `Descargando template ${template.name}...`
       ).start();
       if (isFullStack) {
         spinner.text = "Creando proyecto...";
-        await createFullStackProject(projectName, backendTpl, frontendTpl, pm ?? "npm");
+        await createFullStackProject(
+          projectPath,
+          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 (useLayerLayout) {
+          await writeRootGitignore(projectPath);
+        }
         if (template.runtime === "bun" && pm && pm !== "bun") {
           await adaptToNodeRuntime(codePath);
         }
@@ -733,6 +774,20 @@ program.argument("[template]", "Template a usar (o 'fullstack' para backend + fr
           );
         }
       }
+      if (wantsGit) {
+        const ok = await gitInit(projectPath);
+        if (ok) {
+          console.log(
+            chalk.dim("  Git: repositorio inicializado\n")
+          );
+        } else {
+          console.log(
+            chalk.yellow(
+              "  \u26A0 No se pudo inicializar git (\xBFest\xE1 instalado?)\n"
+            )
+          );
+        }
+      }
     } catch (error) {
       console.error(
         chalk.red(

package/package.json

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