fwinit 1.3.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/package.json

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