@darkj/create-db 1.0.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jaimehuaycho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,7 @@
-# create-db
+# @darkj/create-db
+
+[![CI](https://github.com/jaimehuaycho/create-db/actions/workflows/ci.yml/badge.svg)](https://github.com/jaimehuaycho/create-db/actions/workflows/ci.yml)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 
 CLI to scaffold PostgreSQL database projects with a modular, maintainable structure.
 
@@ -9,16 +12,18 @@ Generates a project with two independent layers:
 ## Usage
 
 ```bash
-npx create-db
+npx @darkj/create-db
 ```
 
-Prompts for a project name and whether you'll use Claude Code, then scaffolds the project and installs dependencies.
+Prompts for a project name, whether you'll use Claude Code, and the language for user-facing docs
+(English or Spanish), then scaffolds the project and installs dependencies.
 
 ## What gets generated
 
 ```
 my-project-db/
 ├── init.sql              ← DROP ALL + reload schema (for fresh DBs)
+├── README.md             ← in the language you picked
 ├── package.json          ← npm run build / migrate / rollback
 ├── tsconfig.json
 ├── .env.example          ← copy to .env and fill credentials
@@ -32,6 +37,9 @@ my-project-db/
 └── backups/              ← pg_dump outputs go here (gitignored)
 ```
 
+Only `README.md` and each table's `DICTIONARY.md` follow the language you pick — everything else,
+including the `.claude/` folder, is always in English.
+
 ## Available commands in the generated project
 
 ```bash
@@ -41,6 +49,9 @@ npm run rollback        # revert last migration
 npm run rollback 3      # revert last 3 migrations
 ```
 
+Each run of `migrate`/`rollback` is wrapped in a single transaction — if any migration in the
+batch fails, everything applied earlier in that same run is rolled back too.
+
 ## Two workflows
 
 **Fresh database (dev, CI, new environment)**
@@ -55,16 +66,24 @@ npm run migrate
 
 ## Requirements
 
-- Node.js >= 18
+- Node.js >= 20
 - PostgreSQL
 
 ## Getting started
 
 ```bash
-npx create-db
+npx @darkj/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
 ```
+
+## Development
+
+```bash
+npm install
+npm run build   # tsc
+npm test        # vitest — template copying, placeholder substitution
+```

package/dist/builders/readme.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReadme = buildReadme;
+// The generated project's top-level README — the one thing (along with each table's
+// DICTIONARY.md) that follows the language picked at scaffold time. Everything else
+// the CLI generates, including .claude/, stays in English regardless of this choice.
+function buildReadme(projectName, language) {
+    return language === 'es' ? buildSpanish(projectName) : buildEnglish(projectName);
+}
+function buildEnglish(projectName) {
+    return `# ${projectName}
+
+PostgreSQL database project generated with [create-db](https://www.npmjs.com/package/@darkj/create-db).
+
+## Structure
+
+- \`schema/\` — current design: table definitions organized by domain
+- \`migrations/\` — history: incremental changes applied to existing databases
+
+## Commands
+
+| Command | Does | Needs a DB |
+|---|---|---|
+| \`npm run build\` | Merges \`schema/\` into \`db-output.sql\` | No |
+| \`npm run migrate\` | Applies pending migrations | Yes |
+| \`npm run rollback [N]\` | Reverts the last N migrations (default 1) | Yes |
+
+## Two workflows
+
+**Fresh database (dev, CI, new environment)**
+\`\`\`bash
+psql -U user -d dbname -f init.sql
+\`\`\`
+
+**Existing database with data**
+\`\`\`bash
+npm run migrate
+\`\`\`
+
+## Getting started
+
+\`\`\`bash
+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 dbname -f init.sql   # initialize a fresh DB
+\`\`\`
+`;
+}
+function buildSpanish(projectName) {
+    return `# ${projectName}
+
+Proyecto de base de datos PostgreSQL generado con [create-db](https://www.npmjs.com/package/@darkj/create-db).
+
+## Estructura
+
+- \`schema/\` — diseño actual: definición de tablas organizadas por dominio
+- \`migrations/\` — historia: cambios incrementales aplicados a bases de datos existentes
+
+## Comandos
+
+| Comando | Hace | Necesita DB |
+|---|---|---|
+| \`npm run build\` | Fusiona \`schema/\` en \`db-output.sql\` | No |
+| \`npm run migrate\` | Aplica las migraciones pendientes | Sí |
+| \`npm run rollback [N]\` | Revierte las últimas N migraciones (default 1) | Sí |
+
+## Dos flujos
+
+**Base de datos vacía (dev, CI, entorno nuevo)**
+\`\`\`bash
+psql -U user -d dbname -f init.sql
+\`\`\`
+
+**Base de datos existente con datos**
+\`\`\`bash
+npm run migrate
+\`\`\`
+
+## Cómo empezar
+
+\`\`\`bash
+cp .env.example .env      # completar DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASSWORD
+npm run build              # probar sin necesidad de DB
+psql -U user -d dbname -f init.sql   # inicializar una DB nueva
+\`\`\`
+`;
+}

package/dist/generator.js

@@ -33,11 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDir = copyDir;
 exports.generateProject = generateProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const readme_1 = require("./builders/readme");
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+const LANGUAGE_LABELS = {
+    en: 'English',
+    es: 'Spanish',
+};
 function copyDir(src, dest, vars = {}, skip = []) {
     fs.mkdirSync(dest, { recursive: true });
     for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
@@ -58,15 +64,22 @@ function copyDir(src, dest, vars = {}, skip = []) {
         }
     }
 }
-async function generateProject({ projectName, targetDir, withClaude }) {
+async function generateProject({ projectName, targetDir, withClaude, language }) {
     if (fs.existsSync(targetDir)) {
         throw new Error(`Directory "${projectName}" already exists.`);
     }
     // 1. Copy template files (skip .claude if not needed)
+    // DOC_LANGUAGE_LABEL only affects .claude/CLAUDE.md — it tells Claude which language to
+    // write user-facing docs (README.md, table DICTIONARY.md) in. The .claude/ prose itself
+    // always stays in English, regardless of this choice.
     const skip = withClaude ? [] : ['.claude'];
-    copyDir(path.join(TEMPLATES_DIR, 'base'), targetDir, { PROJECT_NAME: projectName }, skip);
+    const vars = { PROJECT_NAME: projectName, DOC_LANGUAGE_LABEL: LANGUAGE_LABELS[language] };
+    copyDir(path.join(TEMPLATES_DIR, 'base'), targetDir, vars, skip);
     console.log(`  ✓ Template files copied${withClaude ? ' (with .claude)' : ''}`);
-    // 2. Generate package.json with the project name and scripts (no pinned versions)
+    // 2. Generate the project README in the chosen language
+    fs.writeFileSync(path.join(targetDir, 'README.md'), (0, readme_1.buildReadme)(projectName, language));
+    console.log(`  ✓ README.md generated (${LANGUAGE_LABELS[language]})`);
+    // 3. Generate package.json with the project name and scripts (no pinned versions)
     const pkg = {
         name: projectName,
         version: '1.0.0',
@@ -78,7 +91,7 @@ async function generateProject({ projectName, targetDir, withClaude }) {
     };
     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)
+    // 4. 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' });

package/dist/index.js

@@ -57,12 +57,29 @@ async function main() {
         p.cancel('Cancelled.');
         process.exit(0);
     }
+    const language = await p.select({
+        message: 'Language for README.md and table dictionaries',
+        options: [
+            { value: 'en', label: 'English' },
+            { value: 'es', label: 'Español' },
+        ],
+        initialValue: 'en',
+    });
+    if (p.isCancel(language)) {
+        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 });
+        await (0, generator_1.generateProject)({
+            projectName: name,
+            targetDir,
+            withClaude: useClaude,
+            language: language,
+        });
     }
     catch (err) {
         p.log.error(String(err));

package/package.json

@@ -1,32 +1,55 @@
 {
   "name": "@darkj/create-db",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "CLI to scaffold PostgreSQL database projects with a modular, maintainable structure",
-  "bin": {
-    "create-db": "./dist/index.js"
+  "author": "jaimehuaycho",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaimehuaycho/create-db.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jaimehuaycho/create-db/issues"
+  },
+  "homepage": "https://github.com/jaimehuaycho/create-db#readme",
+  "engines": {
+    "node": ">=20"
   },
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build":   "tsc",
-    "prepare": "npm run build",
-    "dev":     "ts-node src/index.ts",
-    "start":   "node dist/index.js"
+  "bin": {
+    "create-db": "./dist/index.js"
   },
-  "engines": {
-    "node": ">=18"
+  "scripts": {
+    "build":          "tsc",
+    "prepare":        "npm run build",
+    "dev":            "ts-node src/index.ts",
+    "start":          "node dist/index.js",
+    "test":           "vitest run",
+    "test:watch":     "vitest",
+    "prepublishOnly": "npm run build"
   },
   "files": [
     "dist",
     "templates"
   ],
+  "keywords": [
+    "postgresql",
+    "postgres",
+    "scaffold",
+    "cli",
+    "generator",
+    "sql",
+    "migrations"
+  ],
   "dependencies": {
     "@clack/prompts": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.5",
     "ts-node":     "^10.9.2",
-    "typescript":  "^5.3.3"
+    "typescript":  "^5.3.3",
+    "vitest":      "^4.1.11"
   }
 }

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

@@ -1,83 +1,92 @@
 # {{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.
+PostgreSQL database — generated with `create-db`.
+My role here is to assist with the design, organization, analysis, and evolution of this database.
 
 ---
 
-## Cómo funciona
+## Documentation language
 
-### Dos capas independientes
+User-facing docs — `README.md` and each table's `DICTIONARY.md` — are written in **{{DOC_LANGUAGE_LABEL}}**.
+Everything else (this file, `.claude/rules/`, `.claude/commands/`, code comments) stays in English,
+regardless of that choice.
+
+---
+
+## How it works
+
+### Two independent layers
 
 ```
-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
+schema/       → current design: which tables exist and how they're defined
+migrations/   → history: what changed, in what order, already applied to real databases
 ```
 
-Editar `schema/` no afecta una DB existente. Para cambiar una DB con datos, siempre hay que crear una migración.
+Editing `schema/` does not affect an existing database. To change a database that has data,
+a migration must always be created.
 
-### Dos flujos
+### Two workflows
 
-| Situación | Comando |
+| Situation | Command |
 |---|---|
-| DB vacía (dev, CI, nuevo entorno) | `psql -U user -d dbname -f init.sql` |
-| DB existente con datos reales | `npm run migrate` |
+| Empty DB (dev, CI, new environment) | `psql -U user -d dbname -f init.sql` |
+| Existing DB with real data | `npm run migrate` |
 
 ### Scripts
 
-| Comando | Hace | Necesita DB |
+| Command | Does | Needs a 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í |
+| `npm run build` | Merges all of `schema/` into `db-output.sql`, following the `\i` recursively | No |
+| `init.sql` | Drops everything + loads `schema/` from scratch | Yes |
+| `npm run migrate` | Applies only the `migrations/` not yet registered in `migrations` | Yes |
+| `npm run rollback [N]` | Reverts the last N migrations by running their `down.sql` (default: 1) | Yes |
 
-### Estructura del schema
+### Schema structure
 
 ```
 schema/
-├── init.sql                  ← orden global (dependencias primero)
-├── tabla-standalone/         ← tabla transversal a varios dominios
+├── init.sql                  ← global order (dependencies first)
+├── standalone-table/         ← table shared across several domains
 │   ├── create.sql
 │   ├── data.sql
 │   ├── init.sql
 │   └── DICTIONARY.md
-└── nombre-grupo/             ← dominio lógico (auth, orders, catalog…)
-    ├── init.sql              ← orden dentro del grupo
-    └── tabla/
+└── group-name/                ← logical domain (auth, orders, catalog…)
+    ├── init.sql               ← order within the group
+    └── table/
         ├── create.sql
         ├── data.sql
-        ├── triggers.sql      ← solo si aplica
+        ├── triggers.sql       ← only if it applies
         ├── init.sql
         └── DICTIONARY.md
 ```
 
-El orden de dependencias es **siempre manual**. Quien referencia va después del referenciado.
+Dependency order is **always manual**. Whatever references another table goes after the referenced one.
 
 ---
 
-## Comandos disponibles
+## Available commands
 
-- `/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
+- `/analyze` — quick analysis of the current DB (structure, relationships, catalogs, triggers)
+- `/new-migration` — interactive guide to correctly create a migration
+- `/new-dictionary` — generates a table's `DICTIONARY.md` from its `create.sql`
+- `/build` — runs `npm run build` and explains the generated `db-output.sql`
+- `/backup` — creates a DB dump with the correct name and location
 
 ---
 
 ## Backups
 
-Los dumps van en `backups/` con formato: `YYYYMMDD_HHMMSS_descripcion.sql`
+Dumps go in `backups/` with the format: `YYYYMMDD_HHMMSS_description.sql`
 
 ```bash
-pg_dump -U user -d dbname -F p -f backups/$(date +%Y%m%d_%H%M%S)_descripcion.sql
+pg_dump -U user -d dbname -F p -f backups/$(date +%Y%m%d_%H%M%S)_description.sql
 ```
 
-Los archivos `.sql` dentro de `backups/` están en `.gitignore` — no se suben al repo.
+The `.sql` files inside `backups/` are in `.gitignore` — they are not pushed to the repo.
 
 ---
 
-## Learnings de este proyecto
+## Learnings from this project
 
-<!-- Aquí se van agregando decisiones, patrones y convenciones específicas de esta DB -->
+<!-- Decisions, patterns, and conventions specific to this DB get added here -->

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

@@ -1,18 +1,18 @@
-Analiza la base de datos de este proyecto siguiendo estos pasos en orden:
+Analyze this project's database following these steps in order:
 
-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
+1. Read `schema/init.sql` to see the global order: which groups and standalone tables exist
+2. For each group, read its `init.sql` to see the tables it contains and their dependency order
+3. For each table, read its `create.sql` to see column structure, types, constraints, and FKs
+4. Read each `data.sql` to identify which data is catalog/initial configuration
+5. Read each `triggers.sql` where it exists to understand automatic logic in the DB
+6. Read `migrations/` in order to see the history of changes since the baseline
 
-Con todo eso, produce un reporte estructurado que incluya:
+With all that, produce a structured report that includes:
 
-- **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.)
+- **Summary**: what this database does, in one sentence
+- **Groups and tables**: hierarchical list of groups → tables with a description of each
+- **Key relationships**: the most important FKs and what they represent
+- **Catalog data**: which tables have initial data and what it contains
+- **Logic in the DB**: existing triggers and what they do
+- **Change history**: which migrations exist and what changed in each
+- **Observations**: anything noteworthy (design, dependencies, missing data, etc.)

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

@@ -1,19 +1,19 @@
-Creá un backup de la base de datos en el directorio `backups/`.
+Create a database backup in the `backups/` directory.
 
-Primero leé `.env` para obtener las credenciales (DB_HOST, DB_PORT, DB_USER, DB_NAME).
+First read `.env` to get the credentials (DB_HOST, DB_PORT, DB_USER, DB_NAME).
 
-Preguntame una descripción breve del backup (ej: "before_migration_005", "pre_launch", "post_seed").
+Ask for a short description of the backup (e.g. "before_migration_005", "pre_launch", "post_seed").
 
-Luego mostrá el comando exacto a correr:
+Then show the exact command to run:
 
 ```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
+  -f backups/$(date +%Y%m%d_%H%M%S)_{description}.sql
 ```
 
-El formato del nombre es: `YYYYMMDD_HHMMSS_descripcion.sql`
+The name format is: `YYYYMMDD_HHMMSS_description.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`).
+Remember that the `.sql` files inside `backups/` are in `.gitignore` — they are not pushed to the repo.
+The `backups/` directory itself is tracked (thanks to the `.gitkeep`).
 
-Después de correr el comando, verificá que el archivo existe y mostrá su tamaño.
+After running the command, verify the file exists and show its size.

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

@@ -1,17 +1,17 @@
-Ejecutá el script de build desde la raíz del proyecto:
+Run the build script from the project root:
 
 ```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
+Then read the generated `db-output.sql` file and report:
+- How many tables/groups were included
+- The final load order (useful for spotting dependency errors)
+- Whether there's any `[WARN] Not found` warning in the script's output
 
-Si el usuario quiere usar el output para inicializar una DB:
+If the user wants to use the output to initialize a 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.
+Remember that `db-output.sql` is in `.gitignore` — it's a generated file, not pushed to the repo.

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

@@ -1,44 +1,47 @@
-Genera el archivo DICTIONARY.md para una tabla de este proyecto.
+Generate the DICTIONARY.md file for a table in this project.
 
-Si el usuario no especificó qué tabla, preguntá cuál.
+If the user didn't specify which table, ask which one.
 
-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
+Then:
+1. Read that table's `create.sql` to get columns, types, constraints, and FKs
+2. Read `data.sql` to understand what initial data it holds (useful for business rules)
+3. If `triggers.sql` exists, read it to document it under Technical notes
 
-Generá el `DICTIONARY.md` siguiendo exactamente esta plantilla:
+Write the DICTIONARY.md content in the language noted under "Documentation language" in
+`.claude/CLAUDE.md` — these instructions stay in English, but the generated file follows that setting.
+
+Generate the `DICTIONARY.md` following exactly this template:
 
 ---
 
-# {nombre_tabla}
+# {table_name}
 
-{Descripción en 1-2 líneas: qué representa esta tabla en el dominio del negocio.}
+{1-2 line description: what this table represents in the business domain.}
 
-## Columnas
+## Columns
 
-| Columna | Tipo | Nulo | Default | Descripción |
-|---------|------|------|---------|-------------|
-| {col}   | {tipo} | NO/SÍ | {default o —} | {descripción en lenguaje de negocio} |
+| Column | Type | Nullable | Default | Description |
+|--------|------|----------|---------|-------------|
+| {col}  | {type} | YES/NO | {default or —} | {description in business language} |
 
-## Relaciones
+## Relationships
 
-| Columna | Referencia | Descripción |
-|---------|------------|-------------|
-| {fk_col} | {tabla.col} | {qué representa esta relación en el negocio} |
+| Column | Reference | Description |
+|--------|-----------|--------------|
+| {fk_col} | {table.col} | {what this relationship means in the business} |
 
-## Reglas de negocio
+## Business rules
 
-- {regla o restricción relevante para el negocio}
+- {rule or constraint relevant to the business}
 
-## Notas técnicas
+## Technical notes
 
-- {constraints, triggers, índices relevantes que no son obvios del create.sql}
+- {constraints, triggers, indexes relevant that aren't obvious from 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
+Rules when generating:
+- Descriptions always in business language, not technical
+- If a section doesn't apply (no FKs, no special rules), omit it entirely
+- The row order in Columns must follow the same order as in create.sql
+- Save it to: schema/{group-if-applicable}/{table}/DICTIONARY.md