@darkj/create-db 1.0.0

package/README.md

@@ -0,0 +1,70 @@
+# create-db
+
+CLI to scaffold PostgreSQL database projects with a modular, maintainable structure.
+
+Generates a project with two independent layers:
+- **`schema/`** — current design: table definitions organized by domain
+- **`migrations/`** — history: incremental changes applied to existing databases
+
+## Usage
+
+```bash
+npx create-db
+```
+
+Prompts for a project name and whether you'll use Claude Code, then scaffolds the project and installs dependencies.
+
+## What gets generated
+
+```
+my-project-db/
+├── init.sql              ← DROP ALL + reload schema (for fresh DBs)
+├── package.json          ← npm run build / migrate / rollback
+├── tsconfig.json
+├── .env.example          ← copy to .env and fill credentials
+├── scripts/
+│   ├── build.ts          ← merges schema/ into db-output.sql
+│   ├── migrate.ts        ← applies pending migrations to an existing DB
+│   └── rollback.ts       ← reverts last N applied migrations
+├── schema/
+│   └── init.sql          ← define your tables here
+├── migrations/           ← one folder per change (up.sql + down.sql)
+└── backups/              ← pg_dump outputs go here (gitignored)
+```
+
+## Available commands in the generated project
+
+```bash
+npm run build           # merge schema/ into db-output.sql (no DB needed)
+npm run migrate         # apply pending migrations to an existing DB
+npm run rollback        # revert last migration
+npm run rollback 3      # revert last 3 migrations
+```
+
+## Two workflows
+
+**Fresh database (dev, CI, new environment)**
+```bash
+psql -U user -d mydb -f init.sql
+```
+
+**Existing database with data**
+```bash
+npm run migrate
+```
+
+## Requirements
+
+- Node.js >= 18
+- PostgreSQL
+
+## Getting started
+
+```bash
+npx create-db
+
+cd my-project-db
+cp .env.example .env      # fill in DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASSWORD
+npm run build             # test with no DB needed
+psql -U user -d mydb -f init.sql   # initialize a fresh DB
+```

package/dist/generator.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = generateProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+function copyDir(src, dest, vars = {}, skip = []) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (skip.includes(entry.name))
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, vars, skip);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, 'utf-8');
+            for (const [key, val] of Object.entries(vars)) {
+                content = content.replaceAll(`{{${key}}}`, val);
+            }
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.writeFileSync(destPath, content);
+        }
+    }
+}
+async function generateProject({ projectName, targetDir, withClaude }) {
+    if (fs.existsSync(targetDir)) {
+        throw new Error(`Directory "${projectName}" already exists.`);
+    }
+    // 1. Copy template files (skip .claude if not needed)
+    const skip = withClaude ? [] : ['.claude'];
+    copyDir(path.join(TEMPLATES_DIR, 'base'), targetDir, { PROJECT_NAME: projectName }, skip);
+    console.log(`  ✓ Template files copied${withClaude ? ' (with .claude)' : ''}`);
+    // 2. Generate package.json with the project name and scripts (no pinned versions)
+    const pkg = {
+        name: projectName,
+        version: '1.0.0',
+        scripts: {
+            build: 'tsx scripts/build.ts',
+            migrate: 'tsx scripts/migrate.ts',
+            rollback: 'tsx scripts/rollback.ts',
+        },
+    };
+    fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+    console.log('  ✓ package.json generated');
+    // 3. Install dependencies (latest versions at scaffold time)
+    console.log('  Installing dependencies...');
+    (0, child_process_1.execSync)('npm install pg', { cwd: targetDir, stdio: 'inherit' });
+    (0, child_process_1.execSync)('npm install -D tsx typescript @types/node @types/pg', { cwd: targetDir, stdio: 'inherit' });
+    console.log('  ✓ Dependencies installed');
+}

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const p = __importStar(require("@clack/prompts"));
+const path = __importStar(require("path"));
+const generator_1 = require("./generator");
+async function main() {
+    console.log();
+    p.intro('create-db');
+    const projectName = await p.text({
+        message: 'Project name',
+        placeholder: 'my-project-db',
+        validate: (v) => !v.trim() ? 'Project name is required.' : undefined,
+    });
+    if (p.isCancel(projectName)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const useClaude = await p.confirm({
+        message: 'Will you use Claude Code in this project?',
+        initialValue: true,
+    });
+    if (p.isCancel(useClaude)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const name = projectName;
+    const targetDir = path.join(process.cwd(), name);
+    p.log.step('Scaffolding database project...');
+    console.log();
+    try {
+        await (0, generator_1.generateProject)({ projectName: name, targetDir, withClaude: useClaude });
+    }
+    catch (err) {
+        p.log.error(String(err));
+        process.exit(1);
+    }
+    console.log();
+    p.outro(`Done! Next steps:\n\n` +
+        `  cd ${name}\n` +
+        `  cp .env.example .env\n` +
+        `  # Fill in your DB credentials\n` +
+        `  npm run build`);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@darkj/create-db",
+  "version": "1.0.0",
+  "description": "CLI to scaffold PostgreSQL database projects with a modular, maintainable structure",
+  "bin": {
+    "create-db": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build":   "tsc",
+    "prepare": "npm run build",
+    "dev":     "ts-node src/index.ts",
+    "start":   "node dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "ts-node":     "^10.9.2",
+    "typescript":  "^5.3.3"
+  }
+}

package/templates/base/.claude/CLAUDE.md

@@ -0,0 +1,83 @@
+# {{PROJECT_NAME}}
+
+Base de datos PostgreSQL — generada con `create-db`.
+Mi rol aquí es asistir en el diseño, organización, análisis y evolución de esta DB.
+
+---
+
+## Cómo funciona
+
+### Dos capas independientes
+
+```
+schema/       → diseño actual: qué tablas existen y cómo están definidas
+migrations/   → historia: qué cambió, en qué orden, ya aplicado a DBs reales
+```
+
+Editar `schema/` no afecta una DB existente. Para cambiar una DB con datos, siempre hay que crear una migración.
+
+### Dos flujos
+
+| Situación | Comando |
+|---|---|
+| DB vacía (dev, CI, nuevo entorno) | `psql -U user -d dbname -f init.sql` |
+| DB existente con datos reales | `npm run migrate` |
+
+### Scripts
+
+| Comando | Hace | Necesita DB |
+|---|---|---|
+| `npm run build` | Fusiona todo `schema/` en `db-output.sql` siguiendo los `\i` recursivamente | No |
+| `init.sql` | DROP de todo + carga `schema/` desde cero | Sí |
+| `npm run migrate` | Aplica solo las migraciones de `migrations/` aún no registradas en `_migrations` | Sí |
+| `npm run rollback [N]` | Revierte las últimas N migraciones ejecutando su `down.sql` (default: 1) | Sí |
+
+### Estructura del schema
+
+```
+schema/
+├── init.sql                  ← orden global (dependencias primero)
+├── tabla-standalone/         ← tabla transversal a varios dominios
+│   ├── create.sql
+│   ├── data.sql
+│   ├── init.sql
+│   └── DICTIONARY.md
+└── nombre-grupo/             ← dominio lógico (auth, orders, catalog…)
+    ├── init.sql              ← orden dentro del grupo
+    └── tabla/
+        ├── create.sql
+        ├── data.sql
+        ├── triggers.sql      ← solo si aplica
+        ├── init.sql
+        └── DICTIONARY.md
+```
+
+El orden de dependencias es **siempre manual**. Quien referencia va después del referenciado.
+
+---
+
+## Comandos disponibles
+
+- `/analyze` — análisis rápido de la DB actual (estructura, relaciones, catálogos, triggers)
+- `/new-migration` — guía interactiva para crear una migración correctamente
+- `/new-dictionary` — genera el `DICTIONARY.md` de una tabla a partir de su `create.sql`
+- `/build` — corre `npm run build` y explica el `db-output.sql` generado
+- `/backup` — crea un dump de la DB con nombre y ubicación correctos
+
+---
+
+## Backups
+
+Los dumps van en `backups/` con formato: `YYYYMMDD_HHMMSS_descripcion.sql`
+
+```bash
+pg_dump -U user -d dbname -F p -f backups/$(date +%Y%m%d_%H%M%S)_descripcion.sql
+```
+
+Los archivos `.sql` dentro de `backups/` están en `.gitignore` — no se suben al repo.
+
+---
+
+## Learnings de este proyecto
+
+<!-- Aquí se van agregando decisiones, patrones y convenciones específicas de esta DB -->

package/templates/base/.claude/commands/analyze.md

@@ -0,0 +1,18 @@
+Analiza la base de datos de este proyecto siguiendo estos pasos en orden:
+
+1. Lee `schema/init.sql` para ver el orden global: qué grupos y tablas standalone existen
+2. Por cada grupo, lee su `init.sql` para ver las tablas que contiene y su orden de dependencia
+3. Por cada tabla, lee su `create.sql` para ver estructura de columnas, tipos, constraints y FKs
+4. Lee cada `data.sql` para identificar qué datos son de catálogo/configuración inicial
+5. Lee cada `triggers.sql` donde exista para entender lógica automática en la DB
+6. Lee `migrations/` en orden para ver la historia de cambios desde el baseline
+
+Con todo eso, produce un reporte estructurado que incluya:
+
+- **Resumen**: qué hace esta base de datos, en una oración
+- **Grupos y tablas**: lista jerárquica de grupos → tablas con descripción de cada una
+- **Relaciones clave**: las FKs más importantes y qué representan
+- **Datos de catálogo**: qué tablas tienen datos iniciales y qué contienen
+- **Lógica en DB**: triggers existentes y qué hacen
+- **Historia de cambios**: qué migraciones hay y qué cambió en cada una
+- **Observaciones**: algo que llame la atención (diseño, dependencias, datos faltantes, etc.)

package/templates/base/.claude/commands/backup.md

@@ -0,0 +1,19 @@
+Creá un backup de la base de datos en el directorio `backups/`.
+
+Primero leé `.env` para obtener las credenciales (DB_HOST, DB_PORT, DB_USER, DB_NAME).
+
+Preguntame una descripción breve del backup (ej: "before_migration_005", "pre_launch", "post_seed").
+
+Luego mostrá el comando exacto a correr:
+
+```bash
+pg_dump -U {DB_USER} -h {DB_HOST} -p {DB_PORT} -d {DB_NAME} -F p \
+  -f backups/$(date +%Y%m%d_%H%M%S)_{descripcion}.sql
+```
+
+El formato del nombre es: `YYYYMMDD_HHMMSS_descripcion.sql`
+
+Recordá que los `.sql` dentro de `backups/` están en `.gitignore` — no se suben al repo.
+El directorio `backups/` sí está trackeado (gracias al `.gitkeep`).
+
+Después de correr el comando, verificá que el archivo existe y mostrá su tamaño.

package/templates/base/.claude/commands/build.md

@@ -0,0 +1,17 @@
+Ejecutá el script de build desde la raíz del proyecto:
+
+```bash
+npm run build
+```
+
+Luego leé el archivo `db-output.sql` generado y reportá:
+- Cuántas tablas/grupos fueron incluidos
+- El orden final de carga (útil para detectar errores de dependencia)
+- Si hay alguna advertencia de `[WARN] Not found` en la salida del script
+
+Si el usuario quiere usar el output para inicializar una DB:
+```bash
+psql -U user -d dbname -f db-output.sql
+```
+
+Recordá que `db-output.sql` está en `.gitignore` — es un archivo generado, no se sube al repo.

package/templates/base/.claude/commands/new-dictionary.md

@@ -0,0 +1,44 @@
+Genera el archivo DICTIONARY.md para una tabla de este proyecto.
+
+Si el usuario no especificó qué tabla, preguntá cuál.
+
+Luego:
+1. Leé el `create.sql` de esa tabla para obtener columnas, tipos, constraints y FKs
+2. Leé el `data.sql` para entender qué datos iniciales maneja (útil para las reglas de negocio)
+3. Si existe `triggers.sql`, leélo para documentarlo en Notas técnicas
+
+Generá el `DICTIONARY.md` siguiendo exactamente esta plantilla:
+
+---
+
+# {nombre_tabla}
+
+{Descripción en 1-2 líneas: qué representa esta tabla en el dominio del negocio.}
+
+## Columnas
+
+| Columna | Tipo | Nulo | Default | Descripción |
+|---------|------|------|---------|-------------|
+| {col}   | {tipo} | NO/SÍ | {default o —} | {descripción en lenguaje de negocio} |
+
+## Relaciones
+
+| Columna | Referencia | Descripción |
+|---------|------------|-------------|
+| {fk_col} | {tabla.col} | {qué representa esta relación en el negocio} |
+
+## Reglas de negocio
+
+- {regla o restricción relevante para el negocio}
+
+## Notas técnicas
+
+- {constraints, triggers, índices relevantes que no son obvios del create.sql}
+
+---
+
+Reglas al generar:
+- Descripciones siempre en lenguaje de negocio, no técnico
+- Si una sección no aplica (sin FKs, sin reglas especiales), omitirla completamente
+- El orden de filas en Columnas debe seguir el mismo orden que en el create.sql
+- Guardarlo en: schema/{grupo-si-aplica}/{tabla}/DICTIONARY.md

package/templates/base/.claude/commands/new-migration.md

@@ -0,0 +1,61 @@
+Creá una nueva migración para este proyecto siguiendo el formato de carpetas.
+
+## Paso 1 — Determinar el número siguiente
+
+Listá las carpetas en `migrations/` en orden alfabético.
+El próximo número es el último + 1, con ceros a la izquierda (ej: si existe `004_...`, el siguiente es `005`).
+
+## Paso 2 — Obtener información
+
+Si el usuario no la dio, preguntá:
+- ¿Qué cambio se quiere hacer?
+- ¿Hay contexto o razón detrás del cambio? (para decidir si crear README.md)
+
+Si el usuario pasó un script SQL directamente, usarlo como base para `up.sql` — ordenarlo y limpiarlo si hace falta.
+
+## Paso 3 — Crear la carpeta
+
+Nombre: `NNN_YYYYMMDD_HHMM_proposito_breve`
+- Fecha y hora actuales
+- Propósito en snake_case, breve (3-5 palabras máximo)
+
+```
+migrations/NNN_YYYYMMDD_HHMM_proposito_breve/
+├── up.sql
+├── down.sql
+└── README.md   ← solo si hay contexto claro
+```
+
+## Paso 4 — Escribir up.sql
+
+Aplicar el checklist:
+- ¿Columna NOT NULL nueva? → necesita DEFAULT o backfill previo
+- ¿Eliminás columna con datos? → primero migrar datos, luego DROP
+- ¿FK nueva? → la tabla referenciada ya debe existir
+- ¿Índice en tabla grande? → sugerir CONCURRENTLY
+
+## Paso 5 — Escribir down.sql
+
+SQL inverso al up.sql. Debe dejar la DB en el estado anterior exactamente.
+Siempre escribirlo, aunque el usuario no lo haya pedido.
+
+## Paso 6 — Crear README.md (solo si hay contexto)
+
+Si la migración fue planeada o el usuario explicó la razón:
+```markdown
+# proposito_breve
+
+{1-3 líneas del por qué, no del qué.}
+```
+
+Si el usuario pasó el script sin contexto: no crear README.md.
+
+## Paso 7 — Actualizar schema/
+
+Identificá qué archivos `create.sql` en `schema/` quedan desactualizados y actualizalos para reflejar el nuevo estado de las tablas afectadas.
+
+## Paso 8 — Mostrar el comando para aplicar
+
+```bash
+npm run migrate
+```

package/templates/base/.claude/rules/migrations.md

@@ -0,0 +1,111 @@
+---
+paths:
+  - "migrations/**"
+---
+
+# Reglas para trabajar en migrations/
+
+## Principio fundamental
+
+`migrations/` es **append-only** e **inmutable**. Solo se agregan carpetas nuevas al final.
+Nunca editar `up.sql` de una migración ya aplicada — si hay un error, crear una nueva migración que lo corrija.
+
+## Estructura de cada migración
+
+Cada migración es una **carpeta**, no un archivo suelto:
+
+```
+migrations/
+└── NNN_YYYYMMDD_HHMM_proposito_breve/
+    ├── up.sql      ← cambios a aplicar (obligatorio)
+    ├── down.sql    ← cómo revertirlos (obligatorio)
+    └── README.md   ← contexto y razón (solo si fue planeado o tiene contexto claro)
+```
+
+## Naming de la carpeta
+
+```
+NNN_YYYYMMDD_HHMM_proposito_breve
+```
+
+- `NNN` — número secuencial con ceros (`001`, `002`, `003`...)
+- `YYYYMMDD` — fecha de creación
+- `HHMM` — hora de creación
+- `proposito_breve` — descripción corta en `snake_case`
+
+Ejemplos:
+- `003_20260524_1430_add_phone_to_users`
+- `004_20260525_0900_create_index_orders_status`
+- `005_20260526_1100_rename_column_amount_to_total`
+- `006_20260527_1600_drop_deprecated_sessions`
+
+## up.sql — los cambios
+
+SQL que transforma la DB del estado anterior al nuevo. Es lo que `npm run migrate` ejecuta.
+
+## down.sql — el reverso
+
+SQL inverso al `up.sql`. Debe dejar la DB exactamente como estaba antes de aplicar esta migración.
+Siempre escribirlo aunque no se planee usarlo — es la documentación del efecto contrario.
+
+## README.md — contexto (opcional)
+
+Solo crearlo si la migración fue **planeada** o tiene **contexto conocido** (decisión de negocio, bug fix, refactor coordinado).
+Si el usuario pasa un script sin contexto, generar solo `up.sql` y `down.sql`, sin `README.md`.
+
+Formato del README.md:
+```markdown
+# proposito_breve
+
+{1-3 líneas explicando por qué se hace este cambio, no qué hace el SQL.}
+```
+
+## Checklist antes de escribir up.sql
+
+1. ¿El cambio afecta datos existentes? → incluir `UPDATE`/backfill antes del `ALTER`
+2. ¿Se agrega columna `NOT NULL`? → necesita `DEFAULT` o backfill previo
+3. ¿Se elimina columna con datos? → primero migrar los datos, luego `DROP`
+4. ¿Hay FK nueva? → la tabla referenciada ya debe existir
+5. ¿Se crea índice en tabla grande? → considerar `CREATE INDEX CONCURRENTLY`
+6. ¿El SQL es idempotente donde sea posible? → usar `IF NOT EXISTS`, `IF EXISTS`, `CREATE OR REPLACE`
+
+## Cómo aplica npm run migrate
+
+1. Conecta a la DB leyendo `.env`
+2. Crea tabla `_migrations` si no existe
+3. Lista las **carpetas** de `migrations/` en orden alfabético
+4. Ejecuta `up.sql` de las carpetas no registradas en `_migrations`
+5. Registra el **nombre de la carpeta** con timestamp al aplicarla
+6. Cada migración se ejecuta en una transacción — si falla, hace ROLLBACK y para
+
+## También actualizar schema/
+
+Al crear una migración, actualizar también el `create.sql` correspondiente en `schema/` para que refleje el estado actual. `schema/` es el diseño vigente; `migrations/` es cómo llegamos ahí.
+
+## Cómo revertir migraciones (npm run rollback)
+
+`rollback.ts` elimina el registro de `_migrations` y luego ejecuta el `down.sql` dentro de la misma transacción — en ese orden, para que si el `down.sql` dropa la tabla `_migrations`, la transacción igual cierre limpia.
+
+```bash
+# Revertir la última migración aplicada
+npm run rollback
+
+# Revertir las últimas N migraciones (en orden inverso)
+npm run rollback 3
+```
+
+Cómo funciona:
+1. Verifica que la tabla `_migrations` exista — si no, no hay nada que revertir
+2. Consulta `_migrations ORDER BY migration DESC` para obtener las últimas N
+3. Por cada una, en transacción: `DELETE FROM _migrations` → ejecuta `down.sql` → `COMMIT`
+4. Si `down.sql` falla, hace `ROLLBACK` y para
+
+**El `down.sql` debe existir.** Si no existe, el script para sin revertir nada.
+
+## Error común
+
+Si `npm run migrate` dice que ya está al día pero los cambios no aparecen:
+```sql
+DELETE FROM _migrations WHERE migration = 'NNN_YYYYMMDD_HHMM_nombre';
+```
+Luego volver a correr `npm run migrate`. O crear una nueva migración con el cambio faltante.

package/templates/base/.claude/rules/schema.md

@@ -0,0 +1,238 @@
+---
+paths:
+  - "schema/**"
+---
+
+# Reglas para trabajar en schema/
+
+## Regla fundamental de rutas en init.sql
+
+**Todas las rutas en todos los `init.sql` deben ser absolutas desde la raíz del proyecto.**
+
+psql resuelve los `\i` siempre desde su directorio de trabajo (CWD), no desde el directorio del archivo que se está leyendo. `build.py` también resuelve desde la raíz del proyecto (`ROOT_DIR`). Los dos se comportan igual — por eso todas las rutas deben ser desde la raíz.
+
+```sql
+-- CORRECTO — ruta desde la raíz
+\i schema/auth/roles/create.sql
+\i schema/auth/roles/data.sql
+
+-- INCORRECTO — ruta relativa al archivo
+\i create.sql
+\i ../roles/create.sql
+```
+
+El usuario siempre debe estar parado en la raíz del proyecto al usar psql:
+```
+\cd /ruta/al/proyecto
+\i init.sql
+```
+
+---
+
+## Cómo agregar una tabla standalone
+
+```bash
+mkdir schema/mi-tabla
+touch schema/mi-tabla/create.sql schema/mi-tabla/data.sql schema/mi-tabla/init.sql
+```
+
+- `create.sql` → `CREATE TABLE` con columnas, constraints y FKs
+- `data.sql` → INSERTs de datos iniciales (roles, estados, catálogos). Si no hay, dejarlo comentado — el archivo debe existir igual
+- `init.sql` → rutas completas desde la raíz del proyecto:
+
+```sql
+-- sin triggers
+\i schema/mi-tabla/create.sql
+\i schema/mi-tabla/data.sql
+
+-- con triggers
+\i schema/mi-tabla/create.sql
+\i schema/mi-tabla/data.sql
+\i schema/mi-tabla/triggers.sql
+```
+
+- Agregar `\i schema/mi-tabla/init.sql` a `schema/init.sql` en la posición correcta
+
+## Cómo agregar un grupo
+
+```bash
+mkdir schema/mi-grupo
+touch schema/mi-grupo/init.sql
+```
+
+El `init.sql` del grupo lista sus tablas con rutas completas desde la raíz: `\i schema/mi-grupo/mi-tabla/init.sql`. Agregar `\i schema/mi-grupo/init.sql` a `schema/init.sql`.
+
+## Cuándo crear un grupo vs standalone
+
+| Standalone | Grupo |
+|---|---|
+| Tabla transversal a varios dominios (`parameters`, `tags`, `files`) | 2+ tablas del mismo dominio funcional |
+| Una sola tabla en ese dominio | Tablas que solo tienen sentido juntas |
+
+## Lógica de agrupación por dominio
+
+Agrupar por **responsabilidad funcional**, no por conveniencia técnica.
+
+Grupos comunes:
+
+| Grupo | Tablas típicas |
+|---|---|
+| `auth` | `users`, `roles`, `permissions`, `sessions` |
+| `catalog` | `products`, `categories`, `brands` |
+| `orders` | `orders`, `order_items`, `order_statuses` |
+| `payments` | `payments`, `payment_methods`, `invoices` |
+| `notifications` | `notifications`, `notification_types` |
+
+Una tabla que tiene FK hacia tablas de **dos grupos distintos** probablemente va standalone, después de ambos grupos en `schema/init.sql`.
+
+## Formato estándar de CREATE TABLE
+
+Este es el formato propio del proyecto. Toda tabla nueva debe seguirlo sin excepción.
+
+### Orden de columnas (de arriba hacia abajo)
+
+```
+1. PK          → primera columna, siempre
+2. FKs         → en columnas simples, sin referenciar aún, después del PK
+3. Atributos   → campos propios de la tabla en orden lógico de importancia
+4. Timestamps  → created_at y updated_at al final, siempre TIMESTAMPTZ
+5. Constraints → PRIMARY KEY primero, luego cada FOREIGN KEY con REFERENCES
+```
+
+### Naming
+
+- **Tablas**: `snake_case`, **plural** — representan una colección de registros (`users`, `order_items`)
+- **PK**: nombre de la tabla en singular + `_id` → `user_id`, `order_id`, `role_id`
+  - Si el nombre es largo, usar una versión simplificada que mantenga el contexto
+- **FK columns**: mismo formato que el PK de la tabla que referencian → `role_id`, `created_by`
+- Índices: `idx_{tabla}_{columna}` (`idx_users_email`)
+- Triggers: `trg_{tabla}_{descripcion}`
+- Funciones de trigger: `fn_{tabla}_{descripcion}`
+- Constraints únicos: `uq_{tabla}_{columna}` (`uq_users_email`)
+
+### Ejemplo de referencia
+
+```sql
+CREATE TABLE users (
+    user_id             SERIAL,
+    role_id             INT             NOT NULL,                        -- rol asignado al usuario
+    created_by          INT,                                             -- usuario que lo creó (NULL solo para root)
+    full_name           VARCHAR(150)    NOT NULL,                        -- nombre completo del usuario
+    username            VARCHAR(50)     NOT NULL UNIQUE,                 -- nombre de usuario único
+    email               VARCHAR(150),                                    -- correo electrónico
+    password_hash       VARCHAR(255)    NOT NULL,                        -- contraseña almacenada con hash seguro
+    failed_attempts     SMALLINT        NOT NULL DEFAULT 0,              -- contador de intentos de login fallidos
+    active              BOOLEAN         NOT NULL DEFAULT TRUE,           -- cuenta activa/inactiva (no se elimina)
+    requires_pwd_change BOOLEAN         NOT NULL DEFAULT TRUE,           -- fuerza cambio de contraseña en primer ingreso
+    locked_until        TIMESTAMPTZ,                                     -- fecha y hora hasta cuando la cuenta está bloqueada
+    created_at          TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
+    updated_at          TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (user_id),
+    FOREIGN KEY (role_id)    REFERENCES roles(role_id),
+    FOREIGN KEY (created_by) REFERENCES users(user_id)
+);
+```
+
+### Reglas del formato
+
+- **PK se declara como columna simple** (`SERIAL`) sin `PRIMARY KEY` inline — la constraint va al final
+- **FKs se declaran como columnas simples** (`INT`, `INT NOT NULL`) sin `REFERENCES` inline — la constraint va al final
+- **Alineación visual**: columna, tipo, constraints y comentario alineados con espacios para legibilidad
+- **Comentarios inline** (`--`) en toda columna que no sea autoexplicativa por su nombre
+- **`NOT NULL` explícito** en toda columna que no admite nulos — nunca asumir por defecto
+- **Timestamps**: siempre `TIMESTAMPTZ` (con zona horaria), nunca `TIMESTAMP` a secas
+- **Orden de constraints al final**: primero `PRIMARY KEY`, luego `FOREIGN KEY` en el mismo orden que aparecen las columnas FK arriba
+
+### Tipos de datos
+
+| Dato | Tipo |
+|---|---|
+| PK autoincremental | `SERIAL` |
+| FK, referencia a otra tabla | `INT` |
+| Texto con longitud conocida | `VARCHAR(N)` |
+| Texto sin límite | `TEXT` |
+| Contador pequeño | `SMALLINT` |
+| Número entero general | `INT` |
+| Dinero / precisión decimal | `NUMERIC(10,2)` — nunca `FLOAT` |
+| Booleano | `BOOLEAN` — nunca `INT` ni `CHAR` |
+| Solo fecha | `DATE` |
+| Fecha + hora + zona | `TIMESTAMPTZ` — siempre esta, nunca `TIMESTAMP` a secas |
+| Enumeraciones | tabla de catálogo con FK — nunca `ENUM` de Postgres (difícil de migrar) |
+
+### Columnas de auditoría
+
+Toda tabla de datos (no catálogo puro) cierra con:
+```sql
+    created_at          TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
+    updated_at          TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
+```
+
+El `updated_at` se mantiene con un trigger en `triggers.sql`.
+Si aplica borrado lógico, agregar `deleted_at TIMESTAMPTZ` antes de `created_at`.
+
+### Integridad referencial
+
+Elegir `ON DELETE` conscientemente en cada FK:
+
+- `CASCADE` → el hijo no tiene sentido sin el padre (`order_items` → `orders`)
+- `SET NULL` → la relación es opcional (la columna FK debe admitir NULL)
+- Sin cláusula (default `RESTRICT`) → el borrado del padre se bloquea explícitamente
+
+### Índices
+
+- La PK ya crea índice automáticamente
+- Crear índices en columnas frecuentes en `WHERE`, `JOIN ON`, `ORDER BY`
+- Índice compuesto cuando las queries filtran por dos columnas juntas
+- No sobre-indexar: cada índice tiene costo en escritura
+
+### Triggers
+
+Solo crear `triggers.sql` si la tabla realmente lo necesita.
+Siempre usar `CREATE OR REPLACE FUNCTION` para que sea re-ejecutable.
+
+---
+
+## Diccionario de tabla (DICTIONARY.md)
+
+Cada carpeta de tabla debe tener un `DICTIONARY.md` junto a `create.sql`, `data.sql` e `init.sql`.
+
+**Cuándo generarlo**: al crear una tabla nueva o al recibir un `create.sql` existente.
+Si trabajo en una tabla que no tiene su `DICTIONARY.md`, preguntar si debo generarlo.
+
+### Plantilla
+
+```markdown
+# {nombre_tabla}
+
+{Descripción en 1-2 líneas: qué representa esta tabla en el dominio del negocio.}
+
+## Columnas
+
+| Columna | Tipo | Nulo | Default | Descripción |
+|---------|------|------|---------|-------------|
+| {col}   | {tipo} | NO/SÍ | {default o —} | {descripción en lenguaje de negocio} |
+
+## Relaciones
+
+| Columna | Referencia | Descripción |
+|---------|------------|-------------|
+| {fk_col} | {tabla.col} | {qué representa esta relación en el negocio} |
+
+## Reglas de negocio
+
+- {regla o restricción relevante para el negocio}
+- {caso especial o comportamiento esperado}
+
+## Notas técnicas
+
+- {constraints, triggers, índices relevantes que no son obvios del create.sql}
+```
+
+### Reglas del diccionario
+
+- La descripción del header explica **qué representa** la tabla, no cómo está implementada
+- Columnas: descripciones en **lenguaje de negocio**, no técnico ("Rol del usuario" no "FK a roles")
+- Relaciones: solo las FK; explicar el **significado de la relación**, no solo el dato técnico
+- Reglas de negocio: comportamiento esperado, casos borde, qué operaciones están prohibidas
+- Notas técnicas: solo lo que no es visible a simple vista en el `create.sql` (triggers, índices, constraints nombrados)
+- Si una sección no aplica (ej. tabla sin FK → sin sección Relaciones), omitirla completamente

package/templates/base/.env.example

@@ -0,0 +1,5 @@
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=your_database
+DB_USER=your_user
+DB_PASSWORD=your_password

package/templates/base/README.md

@@ -0,0 +1,117 @@
+# {{PROJECT_NAME}}
+
+Base de datos PostgreSQL — generada con [`@darkj/create-db`](https://www.npmjs.com/package/@darkj/create-db).
+
+---
+
+## Configuración inicial
+
+```bash
+npm install
+cp .env.example .env   # completar con las credenciales reales
+```
+
+`.env` nunca se sube al repo (está en `.gitignore`).
+
+---
+
+## Comandos
+
+| Comando | Hace | Necesita DB |
+|---|---|---|
+| `npm run build` | Fusiona todo `schema/` en `db-output.sql` | No |
+| `npm run migrate` | Aplica migraciones pendientes a una DB existente | Sí |
+| `npm run rollback` | Revierte la última migración | Sí |
+| `npm run rollback 3` | Revierte las últimas 3 migraciones | Sí |
+
+---
+
+## Dos flujos de trabajo
+
+**DB vacía** (desarrollo, CI, entorno nuevo):
+```bash
+psql -U user -d dbname -f init.sql
+```
+
+**DB existente con datos** (producción, staging):
+```bash
+npm run migrate
+```
+
+---
+
+## Estructura
+
+```
+{{PROJECT_NAME}}/
+├── init.sql              ← DROP ALL + recarga schema/ desde cero
+├── schema/               ← diseño actual: tablas organizadas por dominio
+│   └── init.sql          ← orden de carga (dependencias primero)
+├── migrations/           ← historial de cambios incrementales
+│   └── NNN_YYYYMMDD_HHMM_proposito/
+│       ├── up.sql        ← cambios a aplicar
+│       └── down.sql      ← cómo revertirlos
+├── scripts/              ← build.ts · migrate.ts · rollback.ts
+└── backups/              ← dumps de pg_dump (gitignored)
+```
+
+### Organización de schema/
+
+```
+schema/
+├── init.sql                  ← orden global
+├── tabla-standalone/         ← tabla transversal a varios dominios
+│   ├── create.sql
+│   ├── data.sql
+│   └── init.sql
+└── nombre-grupo/             ← dominio funcional (auth, orders, catalog…)
+    ├── init.sql
+    └── tabla/
+        ├── create.sql
+        ├── data.sql
+        ├── triggers.sql      ← solo si aplica
+        └── init.sql
+```
+
+> Todas las rutas dentro de los `init.sql` son absolutas desde la raíz del proyecto.
+> `psql` resuelve `\i` desde su directorio de trabajo, no desde el archivo.
+
+---
+
+## Agregar una tabla
+
+```bash
+mkdir schema/mi-tabla
+touch schema/mi-tabla/create.sql schema/mi-tabla/data.sql schema/mi-tabla/init.sql
+```
+
+`schema/mi-tabla/init.sql`:
+```sql
+\i schema/mi-tabla/create.sql
+\i schema/mi-tabla/data.sql
+```
+
+Agregar a `schema/init.sql`:
+```sql
+\i schema/mi-tabla/init.sql
+```
+
+---
+
+## Crear una migración
+
+```bash
+mkdir migrations/002_20260601_1000_descripcion
+# escribir up.sql y down.sql
+npm run migrate
+```
+
+> Nunca editar un `up.sql` ya aplicado. Para corregir errores, crear una nueva migración.
+
+---
+
+## Backup
+
+```bash
+pg_dump -U user -d dbname -F p -f backups/$(date +%Y%m%d_%H%M%S)_descripcion.sql
+```

package/templates/base/init.sql

@@ -0,0 +1,14 @@
+-- ==========================================================
+-- RESET COMPLETO — elimina todo y recarga desde schema/
+-- Usar solo en entornos vacíos o de desarrollo.
+-- ==========================================================
+
+DO $$ DECLARE
+    r RECORD;
+BEGIN
+    FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public') LOOP
+        EXECUTE 'DROP TABLE IF EXISTS public.' || quote_ident(r.tablename) || ' CASCADE';
+    END LOOP;
+END $$;
+
+\i schema/init.sql

package/templates/base/schema/init.sql

@@ -0,0 +1,10 @@
+-- ==========================================================
+-- SCHEMA LOAD ORDER
+-- Rutas siempre desde la raíz del proyecto. Dependencias primero.
+-- ==========================================================
+
+-- Tabla standalone (sin grupo):
+-- \i schema/mi-tabla/init.sql
+
+-- Grupo de tablas:
+-- \i schema/mi-grupo/init.sql

package/templates/base/scripts/build.ts

@@ -0,0 +1,62 @@
+import * as fs from "fs";
+import * as path from "path";
+
+const ROOT_DIR = process.cwd();
+const OUTPUT_FILE = "db-output.sql";
+const ROOT_INIT = "init.sql";
+const visited = new Set<string>();
+
+function readLines(filePath: string): string[] {
+  if (!fs.existsSync(filePath)) {
+    console.warn(`[WARN] Not found: ${filePath}`);
+    return [];
+  }
+  return fs.readFileSync(filePath, "utf-8").split("\n").map((l) => l.trimEnd());
+}
+
+function sectionLabel(initPath: string): string {
+  const rel = path.relative(ROOT_DIR, path.dirname(path.resolve(initPath)));
+  return rel.replace(/[\\/]/g, " > ") || ".";
+}
+
+function processInit(initPath: string): string[] {
+  const absPath = path.resolve(initPath);
+  if (visited.has(absPath)) return [];
+  visited.add(absPath);
+
+  const output: string[] = [];
+  for (const line of readLines(absPath)) {
+    const match = line.match(/^\s*\\i\s+(.+)/);
+    if (!match) {
+      output.push(line);
+      continue;
+    }
+    const ref = match[1].trim();
+    const refPath = path.join(ROOT_DIR, ref);
+
+    if (ref.endsWith("init.sql")) {
+      const lbl = sectionLabel(refPath);
+      const dashes = "-".repeat(Math.max(2, 54 - lbl.length));
+      output.push(`\n-- [${lbl}] ${dashes}`);
+      output.push(...processInit(refPath));
+      output.push(`-- [/${lbl}]\n`);
+    } else {
+      output.push(...readLines(refPath));
+    }
+  }
+  return output;
+}
+
+const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+const header = [
+  "-- " + "=".repeat(58),
+  `-- Generated: ${now}`,
+  "-- DO NOT EDIT — run: npm run build",
+  "-- " + "=".repeat(58),
+  "",
+];
+
+if (fs.existsSync(OUTPUT_FILE)) fs.unlinkSync(OUTPUT_FILE);
+const lines = processInit(ROOT_INIT);
+fs.writeFileSync(OUTPUT_FILE, [...header, ...lines].join("\n") + "\n", "utf-8");
+console.log(`Generated: ${OUTPUT_FILE}`);

package/templates/base/scripts/migrate.ts

@@ -0,0 +1,101 @@
+import * as fs from "fs";
+import * as path from "path";
+import { Client } from "pg";
+
+const ROOT_DIR = process.cwd();
+const MIGRATIONS_DIR = path.join(ROOT_DIR, "migrations");
+
+function loadEnv(): Record<string, string> {
+  const envPath = path.join(ROOT_DIR, ".env");
+  if (!fs.existsSync(envPath)) {
+    console.error(".env not found. Copy .env.example and fill in your credentials.");
+    process.exit(1);
+  }
+  const env: Record<string, string> = {};
+  for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+  }
+  return env;
+}
+
+async function ensureMigrationsTable(client: Client): Promise<void> {
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      migration   VARCHAR(255) PRIMARY KEY,
+      applied_at  TIMESTAMPTZ  NOT NULL DEFAULT NOW()
+    )
+  `);
+}
+
+async function appliedMigrations(client: Client): Promise<Set<string>> {
+  const result = await client.query<{ migration: string }>(
+    "SELECT migration FROM _migrations ORDER BY migration"
+  );
+  return new Set(result.rows.map((r) => r.migration));
+}
+
+function pendingMigrations(applied: Set<string>): string[] {
+  if (!fs.existsSync(MIGRATIONS_DIR)) return [];
+  return fs
+    .readdirSync(MIGRATIONS_DIR)
+    .filter((name) => {
+      const dir = path.join(MIGRATIONS_DIR, name);
+      return (
+        fs.statSync(dir).isDirectory() &&
+        !applied.has(name) &&
+        fs.existsSync(path.join(dir, "up.sql"))
+      );
+    })
+    .sort();
+}
+
+async function main(): Promise<void> {
+  const env = loadEnv();
+  const client = new Client({
+    host: env.DB_HOST ?? "localhost",
+    port: Number(env.DB_PORT ?? 5432),
+    database: env.DB_NAME,
+    user: env.DB_USER,
+    password: env.DB_PASSWORD,
+  });
+
+  await client.connect();
+  await ensureMigrationsTable(client);
+
+  const applied = await appliedMigrations(client);
+  const pending = pendingMigrations(applied);
+
+  if (pending.length === 0) {
+    console.log("Nothing to migrate.");
+    await client.end();
+    return;
+  }
+
+  for (const name of pending) {
+    const upPath = path.join(MIGRATIONS_DIR, name, "up.sql");
+    const sql = fs.readFileSync(upPath, "utf-8");
+    console.log(`Applying: ${name}`);
+    await client.query("BEGIN");
+    try {
+      await client.query(sql);
+      await client.query("INSERT INTO _migrations (migration) VALUES ($1)", [name]);
+      await client.query("COMMIT");
+      console.log(`  ✓ Done`);
+    } catch (err) {
+      await client.query("ROLLBACK");
+      console.error(`  ✗ Failed — rolled back`);
+      console.error(err);
+      await client.end();
+      process.exit(1);
+    }
+  }
+
+  console.log(`\nApplied ${pending.length} migration(s).`);
+  await client.end();
+}
+
+main();

package/templates/base/scripts/rollback.ts

@@ -0,0 +1,91 @@
+import * as fs from "fs";
+import * as path from "path";
+import { Client } from "pg";
+
+const ROOT_DIR = process.cwd();
+const MIGRATIONS_DIR = path.join(ROOT_DIR, "migrations");
+
+function loadEnv(): Record<string, string> {
+  const envPath = path.join(ROOT_DIR, ".env");
+  if (!fs.existsSync(envPath)) {
+    console.error(".env not found.");
+    process.exit(1);
+  }
+  const env: Record<string, string> = {};
+  for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+  }
+  return env;
+}
+
+async function main(): Promise<void> {
+  const steps = Number(process.argv[2] ?? 1);
+  if (!Number.isInteger(steps) || steps < 1) {
+    console.error("Usage: npm run rollback [N]  (N = number of migrations to revert, default 1)");
+    process.exit(1);
+  }
+
+  const env = loadEnv();
+  const client = new Client({
+    host: env.DB_HOST ?? "localhost",
+    port: Number(env.DB_PORT ?? 5432),
+    database: env.DB_NAME,
+    user: env.DB_USER,
+    password: env.DB_PASSWORD,
+  });
+
+  await client.connect();
+
+  const tableCheck = await client.query<{ exists: boolean }>(
+    "SELECT EXISTS (SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = '_migrations') AS exists"
+  );
+  if (!tableCheck.rows[0].exists) {
+    console.log("No applied migrations to revert.");
+    await client.end();
+    return;
+  }
+
+  const result = await client.query<{ migration: string }>(
+    "SELECT migration FROM _migrations ORDER BY migration DESC LIMIT $1",
+    [steps]
+  );
+
+  if (result.rows.length === 0) {
+    console.log("No applied migrations to revert.");
+    await client.end();
+    return;
+  }
+
+  for (const { migration } of result.rows) {
+    const downPath = path.join(MIGRATIONS_DIR, migration, "down.sql");
+    if (!fs.existsSync(downPath)) {
+      console.error(`No down.sql for migration: ${migration}`);
+      await client.end();
+      process.exit(1);
+    }
+    const sql = fs.readFileSync(downPath, "utf-8");
+    console.log(`Reverting: ${migration}`);
+    await client.query("BEGIN");
+    try {
+      await client.query("DELETE FROM _migrations WHERE migration = $1", [migration]);
+      await client.query(sql);
+      await client.query("COMMIT");
+      console.log(`  ✓ Reverted`);
+    } catch (err) {
+      await client.query("ROLLBACK");
+      console.error(`  ✗ Failed — rolled back`);
+      console.error(err);
+      await client.end();
+      process.exit(1);
+    }
+  }
+
+  console.log(`\nReverted ${result.rows.length} migration(s).`);
+  await client.end();
+}
+
+main();

package/templates/base/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "dist"
+  },
+  "include": ["scripts/**/*.ts"]
+}