@asaro/git-cli 1.0.0

package/dist/adapters/ui/ConsoleUIAdapter.js

@@ -0,0 +1,91 @@
+import { select, input, checkbox, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+const c = {
+    titulo: (t) => chalk.bold.hex('#cad3f5')(t),
+    exito: (t) => chalk.hex('#a6da95')(t),
+    error: (t) => chalk.hex('#ed8796')(t),
+    aviso: (t) => chalk.hex('#eed49f')(t),
+    info: (t) => chalk.hex('#8aadf4')(t),
+    tenue: (t) => chalk.hex('#6e738d')(t),
+    rama: (t) => chalk.bold.hex('#f5bde6')(t),
+    hash: (t) => chalk.hex('#f5a97f')(t),
+    archivo: (t) => chalk.hex('#91d7e3')(t),
+};
+export class ConsoleUIAdapter {
+    clear() {
+        console.clear();
+    }
+    log(message) {
+        console.log(message);
+    }
+    info(message) {
+        console.log(c.info(message));
+    }
+    success(message) {
+        console.log(c.exito(message));
+    }
+    warning(message) {
+        console.log(c.aviso(message));
+    }
+    error(message) {
+        console.log(c.error(message));
+    }
+    separator() {
+        console.log(c.tenue('─'.repeat(52)));
+    }
+    showBanner() {
+        console.log();
+        console.log(c.titulo('  ██████╗ ██╗████████╗ ██████╗██╗     ██╗'));
+        console.log(c.titulo('  ██╔════╝ ██║╚══██╔══╝██╔════╝██║     ██║'));
+        console.log(c.titulo('  ██║  ███╗██║   ██║   ██║     ██║     ██║'));
+        console.log(c.titulo('  ██║   ██║██║   ██║   ██║     ██║     ██║'));
+        console.log(c.titulo('  ╚██████╔╝██║   ██║   ╚██████╗███████╗██║'));
+        console.log(c.titulo('   ╚═════╝ ╚═╝   ╚═╝    ╚═════╝╚══════╝╚═╝'));
+        console.log(c.tenue('  Git CLI interactivo · Alex · v2.0.0 (Arquitectura Limpia)'));
+        console.log();
+    }
+    showContextInfo(rama, ahead, behind, cambios) {
+        const indicadorRama = c.rama(`  🌿 ${rama}`);
+        const indicadorSync = ahead > 0
+            ? c.aviso(` ↑${ahead}`)
+            : behind > 0
+                ? c.aviso(` ↓${behind}`)
+                : c.exito(' ✓');
+        const indicadorCambios = cambios > 0
+            ? c.aviso(`  ✎ ${cambios} cambio(s) sin commit`)
+            : c.tenue('  árbol limpio');
+        console.log(indicadorRama + indicadorSync + indicadorCambios);
+        this.separator();
+    }
+    select(message, choices) {
+        return select({ message, choices });
+    }
+    input(message, options) {
+        return input({ message, ...options });
+    }
+    checkbox(message, choices) {
+        return checkbox({ message, choices });
+    }
+    confirm(message, defaultVal = true) {
+        return confirm({ message, default: defaultVal });
+    }
+    spinner(text) {
+        return ora({ text: c.info(text), spinner: 'dots' }).start();
+    }
+    pause() {
+        return new Promise((resolve) => {
+            process.stdout.write(c.tenue('  Presiona Enter para continuar...'));
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            process.stdin.once('data', () => {
+                process.stdin.pause();
+                resolve();
+            });
+        });
+    }
+    // Helper methods for color formatting
+    get colors() {
+        return c;
+    }
+}

package/dist/commands/BaseCommand.js

@@ -0,0 +1,11 @@
+export class BaseCommand {
+    gitPort;
+    uiPort;
+    constructor(gitPort, uiPort) {
+        this.gitPort = gitPort;
+        this.uiPort = uiPort;
+    }
+    get uiColors() {
+        return this.uiPort.colors;
+    }
+}

package/dist/commands/BranchesCommand.js

@@ -0,0 +1,152 @@
+import { BaseCommand } from './BaseCommand.js';
+export class BranchesCommand extends BaseCommand {
+    async execute() {
+        try {
+            const isRepo = await this.gitPort.isRepository();
+            if (!isRepo) {
+                this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+                return;
+            }
+            const accion = await this.uiPort.select('Ramas — ¿qué deseas hacer?', [
+                { name: 'Listar todas las ramas', value: 'listar' },
+                { name: 'Cambiar de rama (checkout)', value: 'cambiar' },
+                { name: 'Crear nueva rama', value: 'crear' },
+                { name: 'Crear y cambiar a nueva rama', value: 'crearCambiar' },
+                { name: 'Eliminar rama', value: 'eliminar' },
+                { name: 'Renombrar rama actual', value: 'renombrar' },
+                { name: '← Volver al menú principal', value: 'volver' },
+            ]);
+            switch (accion) {
+                case 'listar':
+                    await this.listarRamas();
+                    break;
+                case 'cambiar':
+                    await this.cambiarRama();
+                    break;
+                case 'crear':
+                    await this.crearRama(false);
+                    break;
+                case 'crearCambiar':
+                    await this.crearRama(true);
+                    break;
+                case 'eliminar':
+                    await this.eliminarRama();
+                    break;
+                case 'renombrar':
+                    await this.renombrarRama();
+                    break;
+                case 'volver':
+                    return;
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async listarRamas() {
+        const spin = this.uiPort.spinner('Cargando ramas...');
+        const ramas = await this.gitPort.getBranches();
+        spin.stop();
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🌿 Ramas del repositorio'));
+        this.uiPort.separator();
+        ramas.all.forEach((rama) => {
+            const esActual = rama === ramas.current;
+            const esRemota = rama.startsWith('remotes/');
+            const nombre = rama.replace('remotes/', '');
+            if (esActual) {
+                this.uiPort.log(c.exito(`  ◉ ${nombre}`) + c.tenue('  ← actual'));
+            }
+            else if (esRemota) {
+                this.uiPort.log(c.tenue(`  ○ ${nombre}`) + c.info('  (remota)'));
+            }
+            else {
+                this.uiPort.log(c.titulo(`  ○ ${nombre}`));
+            }
+        });
+        this.uiPort.separator();
+        this.uiPort.log('');
+    }
+    async cambiarRama() {
+        const spin = this.uiPort.spinner('Cargando ramas locales...');
+        const ramas = await this.gitPort.getBranches();
+        spin.stop();
+        const opciones = ramas.all
+            .filter((r) => r !== ramas.current && !r.startsWith('remotes/'))
+            .map((r) => ({ name: r, value: r }));
+        if (opciones.length === 0) {
+            this.uiPort.warning('\n  No hay otras ramas locales disponibles.\n');
+            return;
+        }
+        const destino = await this.uiPort.select('Selecciona la rama de destino:', opciones);
+        const spinSwitch = this.uiPort.spinner(`Cambiando a ${destino}...`);
+        await this.gitPort.checkout(destino);
+        spinSwitch.stop();
+        const c = this.uiColors;
+        this.uiPort.success(`\n  ✓ Ahora estás en: ${c.rama(destino)}\n`);
+    }
+    async crearRama(cambiarAlCrear) {
+        const nombre = await this.uiPort.input('Nombre de la nueva rama:', {
+            validate: (v) => {
+                if (!v.trim())
+                    return 'El nombre no puede estar vacío.';
+                if (/\s/.test(v))
+                    return 'El nombre no puede tener espacios.';
+                return true;
+            },
+        });
+        const spinCrear = this.uiPort.spinner(`Creando rama ${nombre}...`);
+        if (cambiarAlCrear) {
+            await this.gitPort.checkoutLocalBranch(nombre);
+        }
+        else {
+            await this.gitPort.createBranch(nombre);
+        }
+        spinCrear.stop();
+        const c = this.uiColors;
+        this.uiPort.success(`\n  ✓ Rama ${cambiarAlCrear ? 'creada y activa' : 'creada'}: ${c.rama(nombre)}\n`);
+    }
+    async eliminarRama() {
+        const spin = this.uiPort.spinner('Cargando ramas locales...');
+        const ramas = await this.gitPort.getBranches();
+        spin.stop();
+        const opciones = ramas.all
+            .filter((r) => r !== ramas.current && !r.startsWith('remotes/'))
+            .map((r) => ({ name: r, value: r }));
+        if (opciones.length === 0) {
+            this.uiPort.warning('\n  No hay ramas locales para eliminar (no puedes eliminar la actual).\n');
+            return;
+        }
+        const objetivo = await this.uiPort.select('¿Qué rama deseas eliminar?', opciones);
+        const forzar = await this.uiPort.confirm(`¿Forzar eliminación de "${objetivo}"? (--force)`, false);
+        const confirmar = await this.uiPort.confirm(this.uiColors.error(`¿Seguro que deseas eliminar "${objetivo}"?`), false);
+        if (!confirmar) {
+            this.uiPort.warning('  Operación cancelada.\n');
+            return;
+        }
+        const spinDel = this.uiPort.spinner(`Eliminando rama ${objetivo}...`);
+        await this.gitPort.deleteBranch(objetivo, forzar);
+        spinDel.stop();
+        this.uiPort.success(`\n  ✓ Rama eliminada: ${objetivo}\n`);
+    }
+    async renombrarRama() {
+        const ramas = await this.gitPort.getBranches();
+        const actual = ramas.current;
+        const c = this.uiColors;
+        this.uiPort.log(c.info(`\n  Rama actual: ${c.rama(actual)}`));
+        const nuevoNombre = await this.uiPort.input('Nuevo nombre:', {
+            validate: (v) => {
+                if (!v.trim())
+                    return 'El nombre no puede estar vacío.';
+                if (/\s/.test(v))
+                    return 'Sin espacios.';
+                return true;
+            },
+        });
+        const spinRen = this.uiPort.spinner('Renombrando...');
+        await this.gitPort.renameBranch(actual, nuevoNombre);
+        spinRen.stop();
+        this.uiPort.success(`\n  ✓ Renombrada: ${actual} → ${c.rama(nuevoNombre)}\n`);
+    }
+}

package/dist/commands/Command.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/CommitCommand.js

@@ -0,0 +1,85 @@
+import { BaseCommand } from './BaseCommand.js';
+export class CommitCommand extends BaseCommand {
+    async execute() {
+        try {
+            const isRepo = await this.gitPort.isRepository();
+            if (!isRepo) {
+                this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+                return;
+            }
+            const spin = this.uiPort.spinner('Leyendo estado del repositorio...');
+            const status = await this.gitPort.getStatus();
+            spin.stop();
+            const c = this.uiColors;
+            const disponibles = [
+                ...status.modified.map((f) => ({ name: c.aviso(`  ~ ${f}`) + c.tenue('  (modificado)'), value: f })),
+                ...status.not_added.map((f) => ({ name: c.tenue(`  ? ${f}`) + c.tenue('  (nuevo)'), value: f })),
+                ...status.deleted.map((f) => ({ name: c.error(`  - ${f}`) + c.tenue('  (eliminado)'), value: f })),
+            ];
+            let archivosParaStage = [];
+            if (status.staged.length > 0) {
+                this.uiPort.log('');
+                this.uiPort.log(c.info('  Ya tienes archivos preparados (staged):'));
+                status.staged.forEach((f) => this.uiPort.log(c.exito(`    + ${f}`)));
+                this.uiPort.log('');
+                const usarExistentes = await this.uiPort.confirm('¿Usar los archivos ya preparados sin agregar más?', true);
+                if (!usarExistentes && disponibles.length > 0) {
+                    archivosParaStage = await this.uiPort.checkbox('Selecciona archivos adicionales para incluir:', disponibles);
+                }
+            }
+            else {
+                if (disponibles.length === 0) {
+                    this.uiPort.warning('  No hay cambios para hacer commit.\n');
+                    return;
+                }
+                const modo = await this.uiPort.select('¿Qué archivos incluir en el commit?', [
+                    { name: 'Todos los cambios  (git add .)', value: 'todos' },
+                    { name: 'Seleccionar manualmente', value: 'manual' },
+                ]);
+                if (modo === 'todos') {
+                    archivosParaStage = ['.'];
+                }
+                else {
+                    archivosParaStage = await this.uiPort.checkbox('Selecciona los archivos (espacio para marcar):', disponibles);
+                }
+                const spinAdd = this.uiPort.spinner('Agregando archivos...');
+                await this.gitPort.add(archivosParaStage);
+                spinAdd.stop();
+                this.uiPort.success('  ✓ Archivos agregados al stage');
+            }
+            this.uiPort.log('');
+            this.uiPort.separator();
+            const tipo = await this.uiPort.select('Tipo de commit:', [
+                { name: 'feat     · Nueva funcionalidad', value: 'feat' },
+                { name: 'fix      · Corrección de bug', value: 'fix' },
+                { name: 'docs     · Documentación', value: 'docs' },
+                { name: 'style    · Estilos / formato', value: 'style' },
+                { name: 'refactor · Refactorización', value: 'refactor' },
+                { name: 'test     · Tests', value: 'test' },
+                { name: 'chore    · Tareas de mantenimiento', value: 'chore' },
+                { name: 'build    · Sistema de build', value: 'build' },
+                { name: 'ci       · CI/CD', value: 'ci' },
+                { name: 'Ninguno  · Mensaje libre', value: '' },
+            ]);
+            const descripcion = await this.uiPort.input('Descripción del commit:', {
+                validate: (v) => v.trim().length > 0 || 'El mensaje no puede estar vacío.',
+            });
+            const mensaje = tipo ? `${tipo}: ${descripcion.trim()}` : descripcion.trim();
+            this.uiPort.separator();
+            this.uiPort.log(c.titulo('  Commit: ') + c.info(`"${mensaje}"`));
+            this.uiPort.separator();
+            const confirmar = await this.uiPort.confirm('¿Confirmar commit?', true);
+            if (!confirmar) {
+                this.uiPort.warning('  Commit cancelado.\n');
+                return;
+            }
+            const spinCommit = this.uiPort.spinner('Realizando commit...');
+            await this.gitPort.commit(mensaje);
+            spinCommit.stop();
+            this.uiPort.success(`\n  ✓ Commit realizado: "${mensaje}"\n`);
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+}

package/dist/commands/IntegrationCommand.js

@@ -0,0 +1,151 @@
+import { BaseCommand } from './BaseCommand.js';
+export class IntegrationCommand extends BaseCommand {
+    async execute() {
+        try {
+            const isRepo = await this.gitPort.isRepository();
+            if (!isRepo) {
+                this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+                return;
+            }
+            const accion = await this.uiPort.select('Integración — ¿qué deseas hacer?', [
+                { name: 'Merge (fusionar rama en la actual)', value: 'merge' },
+                { name: 'Rebase (reescribir historial sobre base)', value: 'rebase' },
+                { name: 'Abortar merge en curso', value: 'abortMerge' },
+                { name: 'Abortar rebase en curso', value: 'abortRebase' },
+                { name: '← Volver al menú principal', value: 'volver' },
+            ]);
+            switch (accion) {
+                case 'merge':
+                    await this.hacerMerge();
+                    break;
+                case 'rebase':
+                    await this.hacerRebase();
+                    break;
+                case 'abortMerge':
+                    await this.abortarMerge();
+                    break;
+                case 'abortRebase':
+                    await this.abortarRebase();
+                    break;
+                case 'volver':
+                    return;
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async hacerMerge() {
+        const spin = this.uiPort.spinner('Cargando ramas...');
+        const ramas = await this.gitPort.getBranches();
+        spin.stop();
+        const actual = ramas.current;
+        const opciones = ramas.all
+            .filter(r => r !== actual && !r.startsWith('remotes/'))
+            .map(r => ({ name: r, value: r }));
+        if (opciones.length === 0) {
+            this.uiPort.warning('\n  No hay otras ramas para fusionar.\n');
+            return;
+        }
+        const origen = await this.uiPort.select(`Fusionar en "${this.uiColors.rama(actual)}" ← ¿desde qué rama?`, opciones);
+        const modo = await this.uiPort.select('Modo de merge:', [
+            { name: 'Normal (crea commit de merge)', value: 'normal' },
+            { name: 'No fast-forward (fuerza merge commit siempre)', value: 'noff' },
+            { name: 'Squash (aplana todos los commits en uno)', value: 'squash' },
+        ]);
+        this.uiPort.separator();
+        this.uiPort.log(`  ${this.uiColors.rama(origen)}  →  ${this.uiColors.rama(actual)}`);
+        this.uiPort.separator();
+        const confirmar = await this.uiPort.confirm('¿Confirmar merge?', true);
+        if (!confirmar) {
+            this.uiPort.warning('  Merge cancelado.\n');
+            return;
+        }
+        const spinMerge = this.uiPort.spinner(`Fusionando ${origen} en ${actual}...`);
+        try {
+            switch (modo) {
+                case 'noff':
+                    await this.gitPort.merge(origen, ['--no-ff']);
+                    break;
+                case 'squash':
+                    await this.gitPort.merge(origen, ['--squash']);
+                    spinMerge.stop();
+                    this.uiPort.success('\n  ✓ Squash merge listo. Debes hacer commit manual.\n');
+                    return;
+                default:
+                    await this.gitPort.merge(origen);
+            }
+            spinMerge.stop();
+            this.uiPort.success(`\n  ✓ Merge completado: ${origen} → ${actual}\n`);
+        }
+        catch (err) {
+            spinMerge.stop();
+            this.uiPort.error(`\n  ✗ Error en merge (posibles conflictos):\n  ${err.message}\n`);
+            this.uiPort.warning('  Usa "Abortar merge en curso" si deseas revertir.\n');
+        }
+    }
+    async hacerRebase() {
+        const spin = this.uiPort.spinner('Cargando ramas...');
+        const ramas = await this.gitPort.getBranches();
+        spin.stop();
+        const actual = ramas.current;
+        const opciones = ramas.all
+            .filter(r => r !== actual && !r.startsWith('remotes/'))
+            .map(r => ({ name: r, value: r }));
+        if (opciones.length === 0) {
+            this.uiPort.warning('\n  No hay otras ramas para hacer rebase.\n');
+            return;
+        }
+        const base = await this.uiPort.select(`Rebasar "${this.uiColors.rama(actual)}" sobre ¿qué rama?`, opciones);
+        this.uiPort.log('');
+        this.uiPort.warning('  ⚠ El rebase reescribe el historial de commits.');
+        this.uiPort.warning('    No lo uses en ramas compartidas/remotas.');
+        this.uiPort.separator();
+        const confirmar = await this.uiPort.confirm(`¿Confirmar rebase sobre ${base}?`, false);
+        if (!confirmar) {
+            this.uiPort.warning('  Rebase cancelado.\n');
+            return;
+        }
+        const spinRebase = this.uiPort.spinner(`Aplicando rebase sobre ${base}...`);
+        try {
+            await this.gitPort.rebase(base);
+            spinRebase.stop();
+            this.uiPort.success(`\n  ✓ Rebase completado sobre ${this.uiColors.rama(base)}\n`);
+        }
+        catch (err) {
+            spinRebase.stop();
+            this.uiPort.error(`\n  ✗ Conflictos durante rebase:\n  ${err.message}\n`);
+            this.uiPort.warning('  Resuelve conflictos manualmente o usa "Abortar rebase".\n');
+        }
+    }
+    async abortarMerge() {
+        const confirmar = await this.uiPort.confirm('¿Abortar el merge en curso?', false);
+        if (!confirmar)
+            return;
+        const spin = this.uiPort.spinner('Abortando merge...');
+        try {
+            await this.gitPort.abortMerge();
+            spin.stop();
+            this.uiPort.success('\n  ✓ Merge abortado. Estado restaurado.\n');
+        }
+        catch (err) {
+            spin.stop();
+            this.uiPort.error('\n  ✗ No hay merge en curso o falló el abort.\n');
+        }
+    }
+    async abortarRebase() {
+        const confirmar = await this.uiPort.confirm('¿Abortar el rebase en curso?', false);
+        if (!confirmar)
+            return;
+        const spin = this.uiPort.spinner('Abortando rebase...');
+        try {
+            await this.gitPort.abortRebase();
+            spin.stop();
+            this.uiPort.success('\n  ✓ Rebase abortado. Estado restaurado.\n');
+        }
+        catch (err) {
+            spin.stop();
+            this.uiPort.error('\n  ✗ No hay rebase en curso o falló el abort.\n');
+        }
+    }
+}

package/dist/commands/LogCommand.js

@@ -0,0 +1,42 @@
+import { BaseCommand } from './BaseCommand.js';
+export class LogCommand extends BaseCommand {
+    async execute() {
+        try {
+            const isRepo = await this.gitPort.isRepository();
+            if (!isRepo) {
+                this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+                return;
+            }
+            const cantidad = await this.uiPort.select('¿Cuántos commits mostrar?', [
+                { name: 'Últimos 10', value: 10 },
+                { name: 'Últimos 20', value: 20 },
+                { name: 'Últimos 50', value: 50 },
+            ]);
+            const spin = this.uiPort.spinner('Cargando historial...');
+            const log = await this.gitPort.getLog(cantidad);
+            spin.stop();
+            const c = this.uiColors;
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo(`  📜 Últimos ${cantidad} commits`));
+            this.uiPort.separator();
+            log.all.forEach((commit, i) => {
+                const esUltimo = i === 0;
+                const prefijo = esUltimo ? '◉' : '○';
+                const fecha = new Date(commit.date).toLocaleDateString('es-CL', {
+                    day: '2-digit',
+                    month: 'short',
+                    year: 'numeric',
+                });
+                this.uiPort.log(`  ${c.hash(prefijo)} ${c.hash(commit.hash.slice(0, 7))}` +
+                    `  ${c.tenue(fecha)}  ` +
+                    `${c.titulo(commit.message.slice(0, 45))}` +
+                    `  ${c.tenue(commit.author_name)}`);
+            });
+            this.uiPort.separator();
+            this.uiPort.log('');
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+}

package/dist/commands/PullCommand.js

@@ -0,0 +1,55 @@
+import { BaseCommand } from './BaseCommand.js';
+export class PullCommand extends BaseCommand {
+    async execute() {
+        try {
+            const isRepo = await this.gitPort.isRepository();
+            if (!isRepo) {
+                this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+                return;
+            }
+            const spin = this.uiPort.spinner('Verificando estado...');
+            const status = await this.gitPort.getStatus();
+            const remotos = await this.gitPort.getRemotes();
+            spin.stop();
+            if (remotos.length === 0) {
+                this.uiPort.error('\n  ✗ No hay remotos configurados.\n');
+                return;
+            }
+            const c = this.uiColors;
+            const rama = status.current ?? 'main';
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  ↓  Bajar cambios (pull)'));
+            this.uiPort.separator();
+            this.uiPort.log(`  Rama actual: ${c.rama(rama)}`);
+            if (status.behind > 0) {
+                this.uiPort.log(c.aviso(`  ${status.behind} commit(s) disponibles en el remoto`));
+            }
+            this.uiPort.separator();
+            let remoto = 'origin';
+            if (remotos.length > 1) {
+                remoto = await this.uiPort.select('¿Desde qué remoto hacer pull?', remotos.map((r) => ({ name: r.name, value: r.name })));
+            }
+            const estrategia = await this.uiPort.select('Estrategia de integración:', [
+                { name: 'Merge  (por defecto)', value: 'merge' },
+                { name: 'Rebase (historial más limpio)', value: 'rebase' },
+            ]);
+            const confirmar = await this.uiPort.confirm(`¿Confirmar pull desde ${remoto}/${rama}?`, true);
+            if (!confirmar) {
+                this.uiPort.warning('  Pull cancelado.\n');
+                return;
+            }
+            const spinPull = this.uiPort.spinner('Bajando cambios...');
+            if (estrategia === 'rebase') {
+                await this.gitPort.pull(remoto, rama, { '--rebase': 'true' });
+            }
+            else {
+                await this.gitPort.pull(remoto, rama);
+            }
+            spinPull.stop();
+            this.uiPort.success(`\n  ✓ Pull exitoso desde ${remoto}/${rama}\n`);
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+}