@orxataguy/tyr 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/core/Kernel.ts

@@ -104,14 +104,14 @@ export class Kernel {
             const shell = this.container.get().shell;
             const gitDir = path.join(this.userRoot, '.git');
             if (!fs.existsSync(gitDir)) {
-                console.log('~/.tyr no está vinculado a ningún repositorio git.');
-                console.log('Ejecuta: tyr --config --repo <url>  para vincularlo.');
+                console.log('~/.tyr is not linked to any git repository.');
+                console.log('Run: tyr --config --repo <url>  to link it.');
                 return;
             }
-            console.log('Actualizando ~/.tyr desde el repositorio...');
+            console.log('Updating ~/.tyr from repository...');
             shell.cd(this.userRoot);
             await shell.exec('git pull');
-            console.log('Actualización completada.');
+            console.log('Update complete.');
             return;
         }
 
@@ -120,13 +120,14 @@ export class Kernel {
             const pkgPath = path.resolve(this.frameworkRoot, 'package.json');
             const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
             const shell = this.container.get().shell;
-            console.log(`Actualizando ${pkg.name}...`);
+            console.log(`Updating ${pkg.name}...`);
             await shell.exec(`npm update -g ${pkg.name}`);
-            console.log('Actualización completada. Ejecuta tyr --version para confirmar.');
+            console.log(`Current version:`)
+            await shell.exec(`tyr --version`)
             return;
         }
 
-        // --help / -h: lista todos los comandos disponibles con su documentación
+        // --help / -h: lists all available commands with their documentation
         if (commandName === '--help' || commandName === '-h') {
             const helpContext = {
                 ...this.container.get(),

package/src/core/sys/config.ts

@@ -64,7 +64,7 @@ const PACKAGE_JSON_TEMPLATE = `{
   "version": "1.0.0",
   "type": "module",
   "private": true,
-  "description": "Comandos personalizados de Tyr (~/.tyr/)",
+  "description": "Custom Tyr commands (~/.tyr/)",
   "dependencies": {
     "@orxataguy/tyr": "latest"
   }
@@ -87,47 +87,47 @@ const TSCONFIG_TEMPLATE = `{
 `;
 
 const ENV_TEMPLATE = `# ~/.tyr/.env
-# Variables de entorno para Tyr. Este archivo nunca debe subirse a git.
+# Environment variables for Tyr. This file must never be committed to git.
 #
-# Base de datos SQL Server
+# SQL Server database
 MSSQL_USER=
 MSSQL_PASSWORD=
 MSSQL_SERVER=
 MSSQL_DATABASE=
-# Basde de datos de Mongo
+# MongoDB database
 MONGO_URI=
 MONGO_DATABASE=
 `;
 
 const SH_ALIASES_TEMPLATE = `# ~/.tyr/aliases
-# Añade aquí tus aliases personalizados.
-# Este archivo se carga automáticamente por tu shell.
+# Add your custom aliases here.
+# This file is loaded automatically by your shell.
 #
-# Ejemplos:
+# Examples:
 #   alias gs='git status'
 #   alias tyr-deploy='tyr deploy'
 `;
 
 const SH_PLUGINS_TEMPLATE = `# ~/.tyr/plugins
-# Añade aquí tus plugins de shell.
-# Compatible con zsh, bash y otros shells POSIX.
+# Add your shell plugins here.
+# Compatible with zsh, bash and other POSIX shells.
 #
-# Ejemplos (zsh):
+# Examples (zsh):
 #   source /usr/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
 `;
 
 const PS_ALIASES_TEMPLATE = `# ~/.tyr/aliases.ps1
-# Añade aquí tus aliases personalizados para PowerShell.
+# Add your custom aliases for PowerShell here.
 #
-# Ejemplos:
+# Examples:
 #   Set-Alias gs git-status
 #   function tyr-deploy { tyr deploy @args }
 `;
 
 const PS_PLUGINS_TEMPLATE = `# ~/.tyr/plugins.ps1
-# Añade aquí tus módulos y plugins de PowerShell.
+# Add your PowerShell modules and plugins here.
 #
-# Ejemplos:
+# Examples:
 #   Import-Module posh-git
 #   Import-Module PSReadLine
 `;
@@ -141,8 +141,8 @@ function makeTimestamp(): string {
 async function configureUnixShell(tyrFs: any, logger: any, homeDir: string, aliasesPath: string, pluginsPath: string): Promise<void> {
     const rcFile = detectShellRcFile(homeDir);
     if (!rcFile) {
-        logger.warn('No se pudo detectar el archivo de configuración del shell.');
-        logger.info(`Añade manualmente:\n  source "${aliasesPath}"\n  source "${pluginsPath}"`);
+        logger.warn('Could not detect shell configuration file.');
+        logger.info(`Add manually:\n  source "${aliasesPath}"\n  source "${pluginsPath}"`);
         return;
     }
     await tyrFs.ensureLine(rcFile, `source "${aliasesPath}"`);
@@ -156,14 +156,14 @@ async function configureWindowsShell(tyrFs: any, logger: any, aliasesPath: strin
         ? path.join(process.env.USERPROFILE, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1')
         : null;
     if (!psProfile) {
-        logger.warn('No se pudo detectar el perfil de PowerShell.');
-        logger.info(`Añade manualmente:\n  . "${aliasesPath}"\n  . "${pluginsPath}"`);
+        logger.warn('Could not detect PowerShell profile.');
+        logger.info(`Add manually:\n  . "${aliasesPath}"\n  . "${pluginsPath}"`);
         return;
     }
     await tyrFs.ensureLine(psProfile, `. "${aliasesPath}"`);
     await tyrFs.ensureLine(psProfile, `. "${pluginsPath}"`);
-    logger.success(`Perfil de PowerShell configurado: ${psProfile}`);
-    logger.info('Reinicia PowerShell para aplicar los cambios.');
+    logger.success(`PowerShell profile configured: ${psProfile}`);
+    logger.info('Restart PowerShell to apply the changes.');
 }
 
 export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrContext) {
@@ -178,8 +178,8 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
         const repoUrl = repoIndex !== -1 ? (args[repoIndex + 1] ?? null) : null;
 
         if (repoIndex !== -1 && (!repoUrl || repoUrl.startsWith('--'))) {
-            logger.error('Falta la URL del repositorio.');
-            logger.info('Uso: tyr --config --repo <url>');
+            logger.error('Repository URL is missing.');
+            logger.info('Usage: tyr --config --repo <url>');
             return;
         }
 
@@ -187,7 +187,7 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
         if (existsSync(userRoot)) {
             backupPath = `${userRoot}.bak.${makeTimestamp()}`;
             backupUserRoot(userRoot, backupPath);
-            logger.warn(`Configuración anterior respaldada en: ${backupPath}`);
+            logger.warn(`Previous configuration backed up at: ${backupPath}`);
         }
 
                let repoHasContent = false;
@@ -197,7 +197,7 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
                 try { removeDirRecursive(tempDir); } catch {}
             }
 
-            logger.info(`\nClonando repositorio: ${repoUrl}`);
+            logger.info(`\nCloning repository: ${repoUrl}`);
             try {
                 await shell.exec(`git clone "${repoUrl}" "${tempDir}"`);
             } catch (e) {
@@ -209,8 +209,8 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
 
             repoHasContent = existsSync(path.join(tempDir, 'map.yml'));
             logger.success(repoHasContent
-                ? 'Repositorio clonado con configuración existente.'
-                : 'Repositorio vacío — iniciando configuración por defecto...');
+                ? 'Repository cloned with existing configuration.'
+                : 'Empty repository — starting default configuration...');
 
             clearDirExceptLogs(userRoot);
             copyDirContents(tempDir, userRoot);
@@ -218,64 +218,64 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
         }
 
         if (!repoHasContent) {
-            logger.info('\nInicializando ~/.tyr...\n');
+            logger.info('\nInitializing ~/.tyr...\n');
 
             await tyrFs.createDir(path.join(userRoot, 'commands'));
-            logger.success(`Directorio creado: ${path.join(userRoot, 'commands')}`);
+            logger.success(`Directory created: ${path.join(userRoot, 'commands')}`);
 
             const aliasesPath = path.join(userRoot, `aliases${ext}`);
             if (!tyrFs.exists(aliasesPath)) {
                 await tyrFs.write(aliasesPath, isWindows ? PS_ALIASES_TEMPLATE : SH_ALIASES_TEMPLATE);
-                logger.success(`Archivo creado: ${aliasesPath}`);
+                logger.success(`File created: ${aliasesPath}`);
             }
 
             const pluginsPath = path.join(userRoot, `plugins${ext}`);
             if (!tyrFs.exists(pluginsPath)) {
                 await tyrFs.write(pluginsPath, isWindows ? PS_PLUGINS_TEMPLATE : SH_PLUGINS_TEMPLATE);
-                logger.success(`Archivo creado: ${pluginsPath}`);
+                logger.success(`File created: ${pluginsPath}`);
             }
 
             const mapPath = path.join(userRoot, 'map.yml');
             await tyrFs.write(mapPath, 'commands: {}\n');
-            logger.success(`Archivo creado: ${mapPath}`);
+            logger.success(`File created: ${mapPath}`);
 
             const envPath = path.join(userRoot, '.env');
             if (!tyrFs.exists(envPath)) {
                 await tyrFs.write(envPath, ENV_TEMPLATE);
-                logger.success(`Archivo creado: ${envPath}`);
+                logger.success(`File created: ${envPath}`);
             }
 
             const packageJsonPath = path.join(userRoot, 'package.json');
             if (!tyrFs.exists(packageJsonPath)) {
                 await tyrFs.write(packageJsonPath, PACKAGE_JSON_TEMPLATE);
-                logger.success(`Archivo creado: ${packageJsonPath}`);
+                logger.success(`File created: ${packageJsonPath}`);
             }
 
             const tsconfigPath = path.join(userRoot, 'tsconfig.json');
             if (!tyrFs.exists(tsconfigPath)) {
                 await tyrFs.write(tsconfigPath, TSCONFIG_TEMPLATE);
-                logger.success(`Archivo creado: ${tsconfigPath}`);
+                logger.success(`File created: ${tsconfigPath}`);
             }
 
-            logger.info('\nInstalando dependencias de tipos en ~/.tyr...');
+            logger.info('\nInstalling type dependencies in ~/.tyr...');
             shell.cd(userRoot);
             try {
                 await shell.exec('npm install');
-                logger.success('Dependencias instaladas correctamente.');
+                logger.success('Dependencies installed successfully.');
             } catch {
-                logger.warn('No se pudo ejecutar npm install en ~/.tyr. Hazlo manualmente.');
+                logger.warn('Could not run npm install in ~/.tyr. Run it manually.');
             }
 
             if (repoUrl) {
-                logger.info('\nSubiendo configuración inicial al repositorio...');
+                logger.info('\nPushing initial configuration to repository...');
                 shell.cd(userRoot);
                 try {
                     await shell.exec('git add .');
                     await shell.exec('git commit -m "Initial tyr configuration"');
                     await shell.exec('git push -u origin HEAD');
-                    logger.success('Configuración subida al repositorio.');
+                    logger.success('Configuration pushed to repository.');
                 } catch (e) {
-                    logger.warn('No se pudo hacer push automático. Hazlo manualmente desde ~/.tyr');
+                    logger.warn('Could not push automatically. Do it manually from ~/.tyr');
                 }
             }
         }
@@ -299,13 +299,13 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
         }
 
         if (needsInstall) {
-            logger.info('\nInstalando dependencias de tipos en ~/.tyr...');
+            logger.info('\nInstalling type dependencies in ~/.tyr...');
             shell.cd(userRoot);
             try {
                 await shell.exec('npm install');
-                logger.success('Dependencias instaladas.');
+                logger.success('Dependencies installed.');
             } catch {
-                logger.warn('No se pudo ejecutar npm install en ~/.tyr. Hazlo manualmente.');
+                logger.warn('Could not run npm install in ~/.tyr. Run it manually.');
             }
         }
 
@@ -321,11 +321,11 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
             }
         }
 
-        logger.success('\nTyr configurado correctamente.');
-        logger.info(`Directorio de configuración: ${userRoot}`);
-        if (repoUrl) logger.info(`Repositorio vinculado: ${repoUrl}`);
-        logger.info('\nPróximos pasos:');
-        logger.info('  tyr gen <nombre> <archivo>   Crear un nuevo comando');
-        logger.info('  tyr doc                      Ver documentación de la API');
+        logger.success('\nTyr configured successfully.');
+        logger.info(`Configuration directory: ${userRoot}`);
+        if (repoUrl) logger.info(`Linked repository: ${repoUrl}`);
+        logger.info('\nNext steps:');
+        logger.info('  tyr gen <name> <file>   Create a new command');
+        logger.info('  tyr doc                 View API documentation');
     };
 }

package/src/core/sys/doc.ts

@@ -17,14 +17,14 @@ interface DocStructure {
 
 export default function doc({ logger, frameworkRoot, run }: TyrContext) {
     return async (args: string[]) => {
-        logger.info("📚 Generando documentación del sistema (TS Mode)...");
+        logger.info("📚 Generating system documentation (TS Mode)...");
 
         const libPath = path.resolve(frameworkRoot, 'src/lib');
 
         const parseJSDoc = (filename: string, content: string): DocStructure => {
             const fileDoc: DocStructure = {
                 name: filename,
-                description: "Sin descripción.",
+                description: "No description.",
                 methods: []
             };
 
@@ -81,7 +81,7 @@ export default function doc({ logger, frameworkRoot, run }: TyrContext) {
                         description = descMatch[1].trim();
                     } else {
                         const textLines = cleanComment.split('\n').filter(l => !l.startsWith('@'));
-                        description = textLines.join(' ').trim() || "Sin descripción";
+                        description = textLines.join(' ').trim() || "No description";
                     }
 
                     let example = null;
@@ -104,14 +104,14 @@ export default function doc({ logger, frameworkRoot, run }: TyrContext) {
         };
 
         if (!fs.existsSync(libPath)) {
-            logger.error(`No se encuentra la carpeta de librerías: ${libPath}`);
+            logger.error(`Library folder not found: ${libPath}`);
             return;
         }
 
         const files = fs.readdirSync(libPath).filter(f => f.endsWith('.ts'));
 
         if (files.length === 0) {
-            logger.warn("No se encontraron archivos .ts en /src/lib para documentar.");
+            logger.warn("No .ts files found in /src/lib to document.");
         }
 
         const fileDocs = files.map(file => {
@@ -120,44 +120,44 @@ export default function doc({ logger, frameworkRoot, run }: TyrContext) {
 
         const systemDocs: DocStructure = {
             name: 'TyrContext (Kernel)',
-            description: 'Utilidades globales inyectadas en cada comando. Accesibles destructurando el contexto.',
+            description: 'Global utilities injected into every command. Accessible by destructuring the context.',
             methods: [
                 {
                     name: 'run',
-                    description: 'Ejecuta otro comando del sistema programáticamente (Composición de comandos). Útil para que un comando invoque a otros.',
+                    description: 'Programmatically runs another system command (command composition). Useful for a command to invoke others.',
                     example: `
-// Llama al comando 'test' pasándole argumentos adicionales
+// Calls the 'test' command passing extra arguments
 const secret = "123";
 args.push(secret);
 await run('test', args);`.trim()
                 },
                 {
                     name: 'task',
-                    description: 'Helper que envuelve una operación crítica. Si falla, el framework captura el error, añade contexto y lo muestra limpio en consola. Elimina la necesidad de try/catch manuales.',
+                    description: 'Helper that wraps a critical operation. If it fails, the framework captures the error, adds context, and displays it cleanly in the console. Removes the need for manual try/catch.',
                     example: `
-// Ejemplo: Tarea asíncrona que retorna un valor
-const buildId = await task('Compilando proyecto', async () => {
+// Example: async task that returns a value
+const buildId = await task('Building project', async () => {
     return await shell.exec('npm run build');
 });
 
-// Si falla, el log dirá: "Falló la tarea: Compilando proyecto"`.trim()
+// If it fails, the log will say: "Task failed: Building project"`.trim()
                 },
                 {
                     name: 'fail',
-                    description: 'Detiene la ejecución del comando inmediatamente lanzando un error controlado. Permite añadir una "sugerencia" para ayudar al usuario a solucionarlo.',
+                    description: 'Stops command execution immediately by throwing a controlled error. Allows adding a "suggestion" to help the user resolve the issue.',
                     example: `
-// Úsalo para validaciones lógicas
+// Use it for logic validations
 if (!fs.existsSync('./package.json')) {
     fail(
-        'No se encuentra el archivo package de npm', 
-        'Ejecuta "npm init -y" para generar uno.'
+        'npm package file not found',
+        'Run "npm init -y" to generate one.'
     );
 }`.trim()
                 },
                 {
                     name: 'logger',
-                    description: 'Sistema de logs estandarizado con colores y formatos.',
-                    example: `logger.info('Iniciando...');\nlogger.success('Creado');\nlogger.warn('Cuidado');`
+                    description: 'Standardised logging system with colours and formats.',
+                    example: `logger.info('Starting...');\nlogger.success('Created');\nlogger.warn('Warning');`
                 }
             ]
         };
@@ -192,7 +192,7 @@ if (!fs.existsSync('./package.json')) {
         </head>
         <body>
             <nav>
-                <h3 style="color: #888; text-transform: uppercase; font-size: 0.8rem;">Módulos TS</h3>
+                <h3 style="color: #888; text-transform: uppercase; font-size: 0.8rem;">TS Modules</h3>
                 ${docs.map(d => `<a href="#${d.name}">📦 ${d.name.replace('.ts', '')}</a>`).join('')}
             </nav>
             <main>
@@ -223,17 +223,17 @@ if (!fs.existsSync('./package.json')) {
                         const { name, prompt } = JSON.parse(body);
                         if (!name || !prompt) {
                             res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ success: false, message: 'Faltan campos obligatorios.' }));
+                            res.end(JSON.stringify({ success: false, message: 'Missing required fields.' }));
                             return;
                         }
 
                         await run('ai', [name, prompt]);
 
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ success: true, message: `Comando '${name}' generado correctamente en ~/.tyr/commands/${name}.tyr.ts` }));
+                        res.end(JSON.stringify({ success: true, message: `Command '${name}' generated successfully at ~/.tyr/commands/${name}.tyr.ts` }));
                     } catch (e: any) {
                         res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ success: false, message: e.message || 'Error al generar el comando.' }));
+                        res.end(JSON.stringify({ success: false, message: e.message || 'Error generating command.' }));
                     }
                 });
                 return;
@@ -244,8 +244,8 @@ if (!fs.existsSync('./package.json')) {
         });
 
         server.listen(PORT, () => {
-            logger.success(`Documentación TS lista en: http://localhost:${PORT}`);
-            logger.info("Presiona Ctrl+C para detener.");
+            logger.success(`TS documentation ready at: http://localhost:${PORT}`);
+            logger.info("Press Ctrl+C to stop.");
         });
     };
 };

package/src/core/sys/gen.ts

@@ -11,12 +11,12 @@ const template = `import type { TyrContext } from '@orxataguy/tyr';
 
 export default ({ run, task, fail, logger, shell, fs }: TyrContext) => {
     return async (args: string[]) => {
-        logger.info("Ejecutando comando: %s");
+        logger.info("Running command: %s");
 
-        // Tu lógica aquí...
-        // Ejecuta "tyr doc" para ver la documentación de managers disponibles
+        // Your logic here...
+        // Run "tyr doc" to see the documentation for available managers
 
-        logger.success("¡Comando %s finalizado!");
+        logger.success("Command %s finished!");
     };
 };
 
@@ -29,18 +29,18 @@ export default function gen({ logger, fs, userRoot }: TyrContext) {
         const fileName = args[1];
 
         if (!commandName || !fileName) {
-            logger.error('Uso incorrecto.');
-            logger.info('Sintaxis: tyr gen [nombre-comando] [nombre-archivo]');
+            logger.error('Incorrect usage.');
+            logger.info('Syntax: tyr gen [command-name] [file-name]');
             return;
         }
 
-        logger.info(`Creando nuevo comando: '${commandName}' -> '${fileName}.tyr.ts'`);
+        logger.info(`Creating new command: '${commandName}' -> '${fileName}.tyr.ts'`);
 
         const commandsDir = path.join(userRoot, 'commands');
         const filePath = path.join(commandsDir, `${fileName}.tyr.ts`);
 
         if (fs.exists(filePath)) {
-            logger.error(`El archivo ${fileName}.tyr.ts ya existe. Abortando.`);
+            logger.error(`File ${fileName}.tyr.ts already exists. Aborting.`);
             return;
         }
 
@@ -56,7 +56,7 @@ export default function gen({ logger, fs, userRoot }: TyrContext) {
             if (!config.commands) config.commands = {};
 
             if (config.commands[commandName]) {
-                logger.warn(`El comando '${commandName}' ya existía. Actualizando ruta...`);
+                logger.warn(`Command '${commandName}' already existed. Updating path...`);
             }
 
             // Store path relative to userRoot so it remains portable
@@ -65,10 +65,10 @@ export default function gen({ logger, fs, userRoot }: TyrContext) {
             const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
             await fs.write(mapPath, newYaml);
 
-            logger.success(`Comando '${commandName}' creado en ${filePath}`);
-            logger.success(`Registrado en ${mapPath}`);
+            logger.success(`Command '${commandName}' created at ${filePath}`);
+            logger.success(`Registered in ${mapPath}`);
         } catch (e) {
-            logger.error('Error al actualizar la configuración.');
+            logger.error('Error updating configuration.');
             console.error(e);
         }
     };

package/src/core/sys/help.ts

@@ -9,8 +9,8 @@ interface CommandDoc {
 }
 
 /**
- * Extrae el primer bloque JSDoc de un archivo .tyr.ts y lo parsea
- * en descripción y ejemplos de uso.
+ * Extracts the first JSDoc block from a .tyr.ts file and parses it
+ * into a description and usage examples.
  */
 function parseCommandDoc(filePath: string): CommandDoc {
     const fileName = path.basename(filePath, '.tyr.ts');
@@ -21,12 +21,12 @@ function parseCommandDoc(filePath: string): CommandDoc {
         return { name: fileName, description: '', usage: '' };
     }
 
-    // Limpiar cada línea: eliminar el * inicial y espacios
+    // Clean each line: remove leading * and spaces
     const lines = match[1]
         .split('\n')
         .map(line => line.replace(/^\s*\*\s?/, '').trimEnd());
 
-    // Separar en descripción y bloque "Uso:"
+    // Split into description and "Usage:" block
     const usoIndex = lines.findIndex(l => /^uso:/i.test(l.trim()));
 
     let description = '';
@@ -70,19 +70,19 @@ export default function help({ userRoot }: TyrContext) {
         const separator = `${gray}  ${'─'.repeat(50)}${reset}`;
 
         console.log('');
-        console.log(`  ${bold}${cyan}tyr${reset}  ${white}Comandos disponibles${reset}`);
+        console.log(`  ${bold}${cyan}tyr${reset}  ${white}Available commands${reset}`);
         console.log(separator);
         console.log('');
 
-        // Flags y comandos built-in del framework
+        // Framework flags and built-in commands
         const builtins = [
-            { name: '--help',    description: 'Muestra este listado de comandos.',          usage: 'tyr --help' },
-            { name: '--version', description: 'Muestra la versión instalada de tyr.',       usage: 'tyr --version' },
-            { name: '--config',  description: 'Configura tyr por primera vez.',             usage: 'tyr --config' },
-            { name: '--update',  description: 'Actualiza ~/.tyr desde el repositorio git.', usage: 'tyr --update' },
-            { name: '--upgrade', description: 'Actualiza el paquete npm de tyr.',           usage: 'tyr --upgrade' },
-            { name: 'gen',       description: 'Genera un nuevo comando a partir de una descripción con IA.', usage: 'tyr gen <nombre> "<descripción>"' },
-            { name: 'doc',       description: 'Levanta la documentación del framework en el navegador.', usage: 'tyr doc' },
+            { name: '--help',    description: 'Shows this command listing.',                  usage: 'tyr --help' },
+            { name: '--version', description: 'Shows the installed version of tyr.',          usage: 'tyr --version' },
+            { name: '--config',  description: 'Configures tyr for the first time.',           usage: 'tyr --config' },
+            { name: '--update',  description: 'Updates ~/.tyr from the git repository.',      usage: 'tyr --update' },
+            { name: '--upgrade', description: 'Upgrades the tyr npm package.',                usage: 'tyr --upgrade' },
+            { name: 'gen',       description: 'Generates a new command from a description using AI.', usage: 'tyr gen <name> "<description>"' },
+            { name: 'doc',       description: 'Opens the framework documentation in the browser.', usage: 'tyr doc' },
         ];
 
         console.log(`  ${bold}${yellow}Framework${reset}`);
@@ -94,10 +94,10 @@ export default function help({ userRoot }: TyrContext) {
             console.log('');
         }
 
-        // Comandos de usuario en ~/.tyr/commands/
+        // User commands in ~/.tyr/commands/
         if (!fs.existsSync(commandsDir)) {
             console.log(separator);
-            console.log(`  ${yellow}No se encontró la carpeta de comandos: ${commandsDir}${reset}`);
+            console.log(`  ${yellow}Commands folder not found: ${commandsDir}${reset}`);
             console.log('');
             return;
         }
@@ -108,14 +108,14 @@ export default function help({ userRoot }: TyrContext) {
 
         if (files.length === 0) {
             console.log(separator);
-            console.log(`  ${dim}No hay comandos en ${commandsDir}${reset}`);
+            console.log(`  ${dim}No commands in ${commandsDir}${reset}`);
             console.log('');
             return;
         }
 
         console.log(separator);
         console.log('');
-        console.log(`  ${bold}${yellow}Comandos de usuario${reset}  ${gray}(~/.tyr/commands/)${reset}`);
+        console.log(`  ${bold}${yellow}User commands${reset}  ${gray}(~/.tyr/commands/)${reset}`);
         console.log('');
 
         for (const file of files) {
@@ -128,12 +128,12 @@ export default function help({ userRoot }: TyrContext) {
                     console.log(`  ${dim}${line}${reset}`);
                 }
             } else {
-                console.log(`  ${gray}Sin descripción${reset}`);
+                console.log(`  ${gray}No description${reset}`);
             }
 
             if (doc.usage) {
                 console.log('');
-                console.log(`  ${gray}  Uso:${reset}`);
+                console.log(`  ${gray}  Usage:${reset}`);
                 for (const line of doc.usage.split('\n')) {
                     console.log(`  ${cyan}    ${line}${reset}`);
                 }
@@ -143,7 +143,7 @@ export default function help({ userRoot }: TyrContext) {
         }
 
         console.log(separator);
-        console.log(`  ${dim}Genera un comando nuevo con ${cyan}tyr gen <nombre> "<qué debe hacer>"${reset}`);
+        console.log(`  ${dim}Generate a new command with ${cyan}tyr gen <name> "<what it should do>"${reset}`);
         console.log('');
     };
 }

package/src/core/sys/rem.ts

@@ -12,25 +12,25 @@ export default function rem({ logger, fs, userRoot }: TyrContext) {
         const commandName = args[0];
 
         if (!commandName) {
-            logger.error('Falta el nombre del comando a eliminar.');
+            logger.error('Missing command name to remove.');
             return;
         }
 
-        logger.info(`Iniciando eliminación del comando: '${commandName}'`);
+        logger.info(`Starting removal of command: '${commandName}'`);
 
         const mapPath = path.join(userRoot, 'map.yml');
 
         try {
             const currentConfigRaw = await fs.read(mapPath);
             if (!currentConfigRaw) {
-                logger.error(`No se encontró ${mapPath}. Ejecuta 'tyr --config' primero.`);
+                logger.error(`${mapPath} not found. Run 'tyr --config' first.`);
                 return;
             }
 
             const config = yaml.load(currentConfigRaw) as TyrConfig;
 
             if (!config.commands?.[commandName]) {
-                logger.error(`El comando '${commandName}' no existe en ~/.tyr/map.yml.`);
+                logger.error(`Command '${commandName}' does not exist in ~/.tyr/map.yml.`);
                 return;
             }
 
@@ -44,7 +44,7 @@ export default function rem({ logger, fs, userRoot }: TyrContext) {
                 for (const [alias, target] of Object.entries(config.aliases)) {
                     if (target === commandName) {
                         delete config.aliases[alias];
-                        logger.info(`Alias '${alias}' eliminado.`);
+                        logger.info(`Alias '${alias}' removed.`);
                     }
                 }
             }
@@ -52,9 +52,9 @@ export default function rem({ logger, fs, userRoot }: TyrContext) {
             const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
             await fs.write(mapPath, newYaml);
 
-            logger.success(`Comando '${commandName}' eliminado.`);
+            logger.success(`Command '${commandName}' removed.`);
         } catch (e) {
-            logger.error('Error crítico durante la eliminación.');
+            logger.error('Critical error during removal.');
             console.error(e);
         }
     };

package/src/lib/GitManager.ts

@@ -74,16 +74,16 @@ export class GitManager {
      * await git.cloneTo('git@github.com:org/repo.git', '/path/to/dest');
      */
     public async cloneTo(repoUrl: string, destDir: string): Promise<void> {
-        this.logger.info(`Clonando ${repoUrl}...`);
-        const loader = this.shell.showLoader('Clonando repositorio...');
+        this.logger.info(`Cloning ${repoUrl}...`);
+        const loader = this.shell.showLoader('Cloning repository...');
         try {
             await this.shell.exec(`git clone "${repoUrl}" "${destDir}"`);
             await this.shell.exec(`git -C "${destDir}" config --add core.filemode false`);
             loader.stop();
-            this.logger.success('Clonación completada.');
+            this.logger.success('Cloning complete.');
         } catch (e) {
             loader.stop();
-            throw new TyrError(`No se pudo clonar el repositorio: ${repoUrl}`, e, 'Comprueba que el repositorio existe y que tienes permisos para clonarlo.');
+            throw new TyrError(`Could not clone repository: ${repoUrl}`, e, 'Check that the repository exists and that you have permission to clone it.');
         }
     }
 
@@ -118,9 +118,9 @@ export class GitManager {
             await this.shell.exec(
                 `cd "${dir}" && rm -rf .git && git init -b master && git remote add origin "${remoteUrl}" && git config --add core.filemode false && echo 'node_modules' >> .gitignore`
             );
-            this.logger.success(`Repositorio Git inicializado en ${dir}`);
+            this.logger.success(`Git repository initialized at ${dir}`);
         } catch (e) {
-            throw new TyrError(`No se pudo inicializar el repositorio en ${dir}`, e);
+            throw new TyrError(`Could not initialize git repository at ${dir}`, e);
         }
     }
 }

package/src/lib/JiraManager.ts

@@ -74,18 +74,18 @@ export class JiraManager {
                         name: `${i.key} - ${i.summary} [${i.status}]`,
                         value: i.key,
                     })),
-                    { name: 'Sin ticket (introducir rama manualmente)', value: '__manual__' },
-                    { name: 'Omitir (no crear rama)', value: '__skip__' },
+                    { name: 'No ticket (enter branch manually)', value: '__manual__' },
+                    { name: 'Skip (do not create branch)', value: '__skip__' },
                 ];
 
-                const selected = await this.shell.select(choices, 'Selecciona un ticket de Jira:');
+                const selected = await this.shell.select(choices, 'Select a Jira ticket:');
 
                 if (selected === '__skip__') return null;
                 if (selected === '__manual__') return this.askForBranch();
 
                 return selected;
             } catch {
-                this.logger.warn('No se ha podido conectar con Jira. Introducción manual de rama.');
+                this.logger.warn('Could not connect to Jira. Manual branch entry.');
             }
         }
 
@@ -93,7 +93,7 @@ export class JiraManager {
     }
 
     private async askForBranch(): Promise<string | null> {
-        const raw = await this.shell.input('Introduce el nombre de la nueva rama (vacío para omitir):');
+        const raw = await this.shell.input('Enter the new branch name (empty to skip):');
         if (!raw.trim()) return null;
         // Normalise: take the last segment separated by '/'
         return raw.trim().split('/').pop()?.toUpperCase() ?? raw.trim();

package/src/lib/MongoManager.ts

@@ -2,7 +2,7 @@ import { MongoClient, Db, Document, Filter, UpdateFilter, InsertOneResult, Inser
 
 /**
  * @class MongoManager
- * @description Conector con MongoDB que gestiona el ciclo de vida de la conexión y expone un CRUD genérico.
+ * @description MongoDB connector that manages the connection lifecycle and exposes a generic CRUD interface.
  */
 export class MongoManager {
   private client!: MongoClient;
@@ -32,10 +32,10 @@ export class MongoManager {
 
   /**
    * @method insertOne
-   * @description Inserta un documento en la colección indicada.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Document} document - Documento a insertar.
-   * @returns {Promise<InsertOneResult>} Resultado de la inserción.
+   * @description Inserts a document into the specified collection.
+   * @param {string} collection - Collection name.
+   * @param {Document} document - Document to insert.
+   * @returns {Promise<InsertOneResult>} Insertion result.
    * @example
    * const result = await mongo.insertOne('users', { name: 'Ana', age: 30 });
    */
@@ -48,10 +48,10 @@ export class MongoManager {
 
   /**
    * @method insertMany
-   * @description Inserta múltiples documentos en la colección indicada.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Document[]} documents - Array de documentos a insertar.
-   * @returns {Promise<InsertManyResult>} Resultado de la inserción.
+   * @description Inserts multiple documents into the specified collection.
+   * @param {string} collection - Collection name.
+   * @param {Document[]} documents - Array of documents to insert.
+   * @returns {Promise<InsertManyResult>} Insertion result.
    * @example
    * const result = await mongo.insertMany('users', [{ name: 'Ana' }, { name: 'Luis' }]);
    */
@@ -64,11 +64,11 @@ export class MongoManager {
 
   /**
    * @method findOne
-   * @description Busca el primer documento que coincida con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro de búsqueda.
-   * @param {FindOptions} [options] - Opciones adicionales (proyección, etc.).
-   * @returns {Promise<WithId<T> | null>} El documento encontrado o null.
+   * @description Finds the first document matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Search filter.
+   * @param {FindOptions} [options] - Additional options (projection, etc.).
+   * @returns {Promise<WithId<T> | null>} The matching document or null.
    * @example
    * const user = await mongo.findOne('users', { name: 'Ana' });
    */
@@ -81,11 +81,11 @@ export class MongoManager {
 
   /**
    * @method find
-   * @description Busca todos los documentos que coincidan con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro de búsqueda. Usa {} para traer todos los documentos.
-   * @param {FindOptions} [options] - Opciones adicionales (proyección, límite, etc.).
-   * @returns {Promise<WithId<T>[]>} Array de documentos encontrados.
+   * @description Finds all documents matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Search filter. Use {} to return all documents.
+   * @param {FindOptions} [options] - Additional options (projection, limit, etc.).
+   * @returns {Promise<WithId<T>[]>} Array of matching documents.
    * @example
    * const users = await mongo.find('users', { age: { $gte: 18 } });
    */
@@ -98,11 +98,11 @@ export class MongoManager {
 
   /**
    * @method updateOne
-   * @description Actualiza el primer documento que coincida con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro para identificar el documento.
-   * @param {UpdateFilter<Document>} update - Operación de actualización (ej: { $set: { field: value } }).
-   * @returns {Promise<UpdateResult>} Resultado de la actualización.
+   * @description Updates the first document matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Filter to identify the document.
+   * @param {UpdateFilter<Document>} update - Update operation (e.g. { $set: { field: value } }).
+   * @returns {Promise<UpdateResult>} Update result.
    * @example
    * const result = await mongo.updateOne('users', { name: 'Ana' }, { $set: { age: 31 } });
    */
@@ -115,11 +115,11 @@ export class MongoManager {
 
   /**
    * @method updateMany
-   * @description Actualiza todos los documentos que coincidan con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro para identificar los documentos.
-   * @param {UpdateFilter<Document>} update - Operación de actualización.
-   * @returns {Promise<UpdateResult>} Resultado de la actualización.
+   * @description Updates all documents matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Filter to identify the documents.
+   * @param {UpdateFilter<Document>} update - Update operation.
+   * @returns {Promise<UpdateResult>} Update result.
    * @example
    * const result = await mongo.updateMany('users', { active: false }, { $set: { active: true } });
    */
@@ -132,10 +132,10 @@ export class MongoManager {
 
   /**
    * @method deleteOne
-   * @description Elimina el primer documento que coincida con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro para identificar el documento.
-   * @returns {Promise<DeleteResult>} Resultado de la eliminación.
+   * @description Deletes the first document matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Filter to identify the document.
+   * @returns {Promise<DeleteResult>} Deletion result.
    * @example
    * const result = await mongo.deleteOne('users', { name: 'Ana' });
    */
@@ -148,10 +148,10 @@ export class MongoManager {
 
   /**
    * @method deleteMany
-   * @description Elimina todos los documentos que coincidan con el filtro.
-   * @param {string} collection - Nombre de la colección.
-   * @param {Filter<Document>} filter - Filtro para identificar los documentos.
-   * @returns {Promise<DeleteResult>} Resultado de la eliminación.
+   * @description Deletes all documents matching the filter.
+   * @param {string} collection - Collection name.
+   * @param {Filter<Document>} filter - Filter to identify the documents.
+   * @returns {Promise<DeleteResult>} Deletion result.
    * @example
    * const result = await mongo.deleteMany('users', { active: false });
    */
@@ -165,7 +165,7 @@ export class MongoManager {
 
 /**
  * @object MongoManagerTests
- * @description Parámetros de pruebas para validar la funcionalidad de MongoManager.
+ * @description Test parameters to validate MongoManager functionality.
  */
 export const MongoManagerTests = {
   // insertOne: { collection: 'test', document: { name: 'test_doc', value: 1 } },

package/src/lib/SQLManager.ts

@@ -3,7 +3,7 @@ import sql, { config as SQLConfig } from 'mssql';
 
 /**
  * @class SQLManager
- * @description Conector con la base de datos SQL Server.
+ * @description SQL Server database connector.
  */
 export class SQLManager {
   private pool!: sql.ConnectionPool;
@@ -33,12 +33,12 @@ export class SQLManager {
 
   /**
    * @method select
-   * @description Ejecuta un comando SELECT en SQL Server y devuelve el resultado como JSON.
-   * @param {string} query - El comando SELECT completo.
-   * @returns {Promise<any[]>} Los registros del resultado.
+   * @description Executes a SELECT command on SQL Server and returns the result as JSON.
+   * @param {string} query - The full SELECT command.
+   * @returns {Promise<any[]>} The result records.
    * @example
    * await dbManager.init();
-   * const data = await dbManager.select('SELECT * FROM tabla');
+   * const data = await dbManager.select('SELECT * FROM table');
    */
   public async select(query: string): Promise<any[]> {
     await this.init();
@@ -51,9 +51,9 @@ export class SQLManager {
 
   /**
    * @method searchBrokerOnDB
-   * @description Busca broker por hostname usando la query encoded.
-   * @param {string | URL} url - URL o string para extraer hostname.
-   * @returns {Promise<string>} Nombre del broker.
+   * @description Looks up a broker by hostname using the encoded query.
+   * @param {string | URL} url - URL or string to extract the hostname from.
+   * @returns {Promise<string>} Broker name.
    * @example
    * const broker = await db.searchBrokerOnDB('https://www.foo.com');
    */
@@ -88,7 +88,7 @@ export class SQLManager {
     await this.close();
 
     if (!result.recordset[0] || !result.recordset[0].BROKER) {
-      throw new Error(`No se encontró broker para ${urlObj}`);
+      throw new Error(`No broker found for ${urlObj}`);
     }
 
     return result.recordset[0].BROKER as string;
@@ -104,7 +104,7 @@ export class SQLManager {
 
 /**
  * @object SQLManagerTests
- * @description Parámetros de pruebas para validar la funcionalidad de SQLManager.
+ * @description Test parameters to validate SQLManager functionality.
  */
 export const SQLManagerTests = {
     // init: {},

package/src/lib/SetupManager.ts

@@ -203,18 +203,18 @@ export class SetupManager {
 
         if (await this.binExists('docker-compose')) return 'docker-compose';
 
-        this.logger.warn('docker-compose no encontrado. Intentando instalar...');
+        this.logger.warn('docker-compose not found. Attempting to install...');
 
         const rawArch = await this.shell.exec('uname -m').catch(() => 'x86_64');
         const osName  = await this.shell.exec("uname -s | tr '[:upper:]' '[:lower:]'").catch(() => 'linux');
         const bin     = '/usr/local/bin/docker-compose';
         const url     = `https://github.com/docker/compose/releases/latest/download/docker-compose-${osName.trim()}-${rawArch.trim()}`;
 
-        this.logger.info('Descargando docker-compose desde GitHub...');
+        this.logger.info('Downloading docker-compose from GitHub...');
         try {
             await this.shell.exec(`curl -fsSL "${url}" -o "${bin}" && chmod +x "${bin}"`);
             if (await this.shell.exec('docker-compose version 2>/dev/null').then(() => true).catch(() => false)) {
-                this.logger.success('docker-compose instalado correctamente.');
+                this.logger.success('docker-compose installed successfully.');
                 return 'docker-compose';
             }
         } catch { /* fall through to pip */ }
@@ -226,14 +226,14 @@ export class SetupManager {
                     `${pip.trim()} install --quiet docker-compose --break-system-packages 2>/dev/null || ${pip.trim()} install --quiet docker-compose`
                 );
                 if (await this.binExists('docker-compose')) {
-                    this.logger.success('docker-compose instalado via pip.');
+                    this.logger.success('docker-compose installed via pip.');
                     return 'docker-compose';
                 }
             } catch { /* fall through */ }
         }
 
-        this.logger.warn('No se pudo instalar docker-compose automaticamente.');
-        this.logger.warn('Instalalo manualmente: https://docs.docker.com/compose/install/');
+        this.logger.warn('Could not install docker-compose automatically.');
+        this.logger.warn('Install it manually: https://docs.docker.com/compose/install/');
         return null;
     }
 
@@ -249,7 +249,7 @@ export class SetupManager {
             .then(() => true).catch(() => false);
         if (ok) return;
 
-        this.logger.info('Instalando docker buildx plugin...');
+        this.logger.info('Installing docker buildx plugin...');
         const rawArch   = await this.shell.exec('uname -m').catch(() => 'x86_64');
         const arch      = rawArch.trim().replace('x86_64', 'amd64').replace('aarch64', 'arm64');
         const osName    = await this.shell.exec("uname -s | tr '[:upper:]' '[:lower:]'").catch(() => 'linux');
@@ -261,16 +261,16 @@ export class SetupManager {
         ).catch(() => '');
 
         if (!urlRaw.trim()) {
-            this.logger.warn('No se pudo obtener la URL de docker buildx. El build puede mostrar advertencias.');
+            this.logger.warn('Could not fetch the docker buildx URL. The build may show warnings.');
             return;
         }
         try {
             await this.shell.exec(
                 `mkdir -p "${pluginDir}" && wget -qO "${pluginDir}/docker-buildx" "${urlRaw.trim()}" && chmod +x "${pluginDir}/docker-buildx"`
             );
-            this.logger.success('docker buildx instalado.');
+            this.logger.success('docker buildx installed.');
         } catch {
-            this.logger.warn('No se pudo instalar docker buildx. El build puede mostrar advertencias.');
+            this.logger.warn('Could not install docker buildx. The build may show warnings.');
         }
     }
 
@@ -292,13 +292,13 @@ export class SetupManager {
         const invokePrefix = hasExisting ? 'make -f Makefile.dev' : 'make';
 
         if (this.fs.exists(makefilePath)) {
-            this.logger.info(`${makefileName} ya existe. No se sobreescribe.`);
+            this.logger.info(`${makefileName} already exists. Skipping.`);
             return;
         }
 
         const TAB = '\t';
         const content = [
-            `# ${makefileName} generado por setup-dev`,
+            `# ${makefileName} generated by setup-dev`,
             '',
             'up:',      TAB + 'docker-compose up -d',                '',
             'build:',   TAB + 'docker-compose up -d --build',        '',
@@ -309,12 +309,12 @@ export class SetupManager {
         ].join('\n');
 
         await this.fs.write(makefilePath, content);
-        this.logger.success(`${makefileName} generado en: ${makefilePath}`);
-        this.logger.info(`  ${invokePrefix} up      -> arrancar contenedores`);
-        this.logger.info(`  ${invokePrefix} build   -> rebuild y arrancar`);
-        this.logger.info(`  ${invokePrefix} stop    -> parar y eliminar (sin orphans)`);
-        this.logger.info(`  ${invokePrefix} logs    -> ver logs en tiempo real`);
-        this.logger.info(`  ${invokePrefix} ps      -> estado de los contenedores`);
+        this.logger.success(`${makefileName} generated at: ${makefilePath}`);
+        this.logger.info(`  ${invokePrefix} up      -> start containers`);
+        this.logger.info(`  ${invokePrefix} build   -> rebuild and start`);
+        this.logger.info(`  ${invokePrefix} stop    -> stop and remove (no orphans)`);
+        this.logger.info(`  ${invokePrefix} logs    -> watch logs in real time`);
+        this.logger.info(`  ${invokePrefix} ps      -> container status`);
     }
 }
 

package/src/lib/ShellManager.ts

@@ -123,7 +123,7 @@ export class ShellManager {
      * @param {boolean} defaultValue - Default answer if user presses Enter (default: false).
      * @returns {Promise<boolean>} True if the user confirmed.
      * @example
-     * const ok = await shell.confirm('¿Continuar?', false);
+     * const ok = await shell.confirm('Continue?', false);
      */
     public async confirm(question: string, defaultValue: boolean = false): Promise<boolean> {
         try {
@@ -135,7 +135,7 @@ export class ShellManager {
             }]);
             return result.value;
         } catch (e) {
-            throw new TyrError(`Error al mostrar la confirmación: ${question}`, e);
+            throw new TyrError(`Error showing confirmation: ${question}`, e);
         }
     }
 
@@ -146,7 +146,7 @@ export class ShellManager {
      * @param {string} question - The question to display.
      * @returns {Promise<string>} The selected value.
      * @example
-     * const branch = await shell.select([{ name: 'main', value: 'main' }], '¿Qué rama?');
+     * const branch = await shell.select([{ name: 'main', value: 'main' }], 'Which branch?');
      */
     public async select(choices: { name: string; value: string }[], question: string): Promise<string> {
         try {
@@ -158,7 +158,7 @@ export class ShellManager {
             }]);
             return result.value;
         } catch (e) {
-            throw new TyrError(`Error al mostrar la selección: ${question}`, e);
+            throw new TyrError(`Error showing selection: ${question}`, e);
         }
     }
 
@@ -169,7 +169,7 @@ export class ShellManager {
      * @param {string} question - The question to display.
      * @returns {Promise<string[]>} The selected values.
      * @example
-     * const widgets = await shell.checkbox(choices, '¿Qué widgets incluir?');
+     * const widgets = await shell.checkbox(choices, 'Which widgets to include?');
      */
     public async checkbox(choices: { name: string; value: string }[], question: string): Promise<string[]> {
         try {
@@ -181,7 +181,7 @@ export class ShellManager {
             }]);
             return result.value;
         } catch (e) {
-            throw new TyrError(`Error al mostrar las opciones: ${question}`, e);
+            throw new TyrError(`Error showing options: ${question}`, e);
         }
     }
 }
@@ -195,7 +195,7 @@ export const ShellManagerTests = {
     cd: { path: '/tmp' },
     input: { question: 'Enter a test value:' },
     showLoader: { message: 'Loading test...' },
-    confirm: { question: '¿Continuar?', defaultValue: false },
-    select: { choices: [{ name: 'Opción A', value: 'a' }, { name: 'Opción B', value: 'b' }], question: '¿Cuál eliges?' },
-    checkbox: { choices: [{ name: 'Item 1', value: '1' }, { name: 'Item 2', value: '2' }], question: '¿Cuáles quieres?' },
+    confirm: { question: 'Continue?', defaultValue: false },
+    select: { choices: [{ name: 'Option A', value: 'a' }, { name: 'Option B', value: 'b' }], question: 'Which one?' },
+    checkbox: { choices: [{ name: 'Item 1', value: '1' }, { name: 'Item 2', value: '2' }], question: 'Which ones?' },
 };

package/src/lib/WorkspaceManager.ts

@@ -25,29 +25,29 @@ export class WorkspaceManager {
      * If it does, asks the user if they want to replace it (deleting it first).
      * Returns true if the caller should proceed with creating the workspace.
      * @param {string} dirPath - Absolute path to the workspace directory.
-     * @param {string} type - Human-readable type name shown in messages (e.g. 'integración', 'web').
+     * @param {string} type - Human-readable type name shown in messages (e.g. 'integration', 'web').
      * @returns {Promise<boolean>} True if the workspace can be created/overwritten.
      * @example
-     * const proceed = await workspace.checkExisting('/path/to/repo', 'integración');
+     * const proceed = await workspace.checkExisting('/path/to/repo', 'integration');
      * if (!proceed) return;
      */
-    public async checkExisting(dirPath: string, type: string = 'directorio'): Promise<boolean> {
+    public async checkExisting(dirPath: string, type: string = 'directory'): Promise<boolean> {
         if (!this.fs.exists(dirPath)) return true;
 
-        this.logger.warn(`Este ${type} ya existe: ${dirPath}`);
-        const replace = await this.shell.confirm('¿Quieres reemplazarlo?', false);
+        this.logger.warn(`This ${type} already exists: ${dirPath}`);
+        const replace = await this.shell.confirm('Do you want to replace it?', false);
 
         if (!replace) {
-            this.logger.info('Operación cancelada.');
+            this.logger.info('Operation cancelled.');
             return false;
         }
 
         try {
             await this.shell.exec(`rm -rf "${dirPath}"`);
-            this.logger.info('Directorio existente eliminado.');
+            this.logger.info('Existing directory removed.');
             return true;
         } catch (e) {
-            throw new TyrError(`No se pudo eliminar el directorio existente: ${dirPath}`, e);
+            throw new TyrError(`Could not remove existing directory: ${dirPath}`, e);
         }
     }
 
@@ -65,9 +65,9 @@ export class WorkspaceManager {
         if (branch) {
             try {
                 await this.shell.exec(`git -C "${dir}" checkout -b ${branch}`);
-                this.logger.success(`Rama '${branch}' creada.`);
+                this.logger.success(`Branch '${branch}' created.`);
             } catch (e) {
-                this.logger.warn(`No se pudo crear la rama '${branch}'. Puede que ya exista.`);
+                this.logger.warn(`Could not create branch '${branch}'. It may already exist.`);
             }
         }
 
@@ -75,13 +75,13 @@ export class WorkspaceManager {
             try {
                 await this.shell.exec(`code "${dir}"`);
             } catch {
-                this.logger.warn('No se pudo abrir VSCode. Asegúrate de tener el comando "code" instalado.');
+                this.logger.warn('Could not open VSCode. Make sure the "code" command is installed.');
             }
         }
     }
 }
 
 export const WorkspaceManagerTests = {
-    checkExisting: { dirPath: '/tmp/tyr-workspace-test', type: 'integración' },
+    checkExisting: { dirPath: '/tmp/tyr-workspace-test', type: 'integration' },
     tagWorkspace: { dir: '/tmp/tyr-workspace-test', branch: null, openCode: false },
 };