@asaro/git-cli 1.0.0

package/dist/commands/PushCommand.js

@@ -0,0 +1,227 @@
+import { BaseCommand } from './BaseCommand.js';
+import { simpleGit } from 'simple-git';
+import path from 'path';
+export class PushCommand extends BaseCommand {
+    gitHubService;
+    constructor(gitPort, uiPort, gitHubService) {
+        super(gitPort, uiPort);
+        this.gitHubService = gitHubService;
+    }
+    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();
+            let remotos = await this.gitPort.getRemotes();
+            spin.stop();
+            if (remotos.length === 0) {
+                // No hay remotos: preguntar al usuario
+                const accion = await this.uiPort.select('No hay remotos configurados. ¿Qué deseas hacer?', [
+                    { name: 'Crear nuevo repositorio en GitHub', value: 'nuevo' },
+                    { name: 'Elegir repositorio existente de GitHub', value: 'existente' },
+                    { name: 'Agregar remoto manualmente', value: 'manual' },
+                    { name: 'Volver', value: 'volver' },
+                ]);
+                if (accion === 'volver') {
+                    return;
+                }
+                else if (accion === 'manual') {
+                    // Llamar a la función de agregar remoto
+                    await this.agregarRemotoManual();
+                }
+                else {
+                    // Verificar autenticación primero
+                    const isAuth = await this.gitHubService.isAuthenticated();
+                    if (!isAuth) {
+                        this.uiPort.error('  ✗ No estás autenticado con GitHub.');
+                        this.uiPort.info('  Ve al menú "🌐 Gestión GitHub" primero para iniciar sesión.');
+                        return;
+                    }
+                    if (accion === 'nuevo') {
+                        await this.crearYConfigurarRepoGitHub();
+                    }
+                    else {
+                        await this.elegirYConfigurarRepoExistente();
+                    }
+                }
+                // Volver a obtener remotos después de configurar
+                remotos = await this.gitPort.getRemotes();
+                if (remotos.length === 0) {
+                    // Si sigue sin haber remotos, no continuar
+                    return;
+                }
+            }
+            const c = this.uiColors;
+            const rama = status.current ?? 'main';
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  ↑  Subir cambios (push)'));
+            this.uiPort.separator();
+            this.uiPort.log(`  Rama actual: ${c.rama(rama)}`);
+            if (status.ahead > 0) {
+                this.uiPort.log(c.aviso(`  ${status.ahead} commit(s) pendientes de subir`));
+            }
+            else {
+                this.uiPort.log(c.tenue('  No hay commits nuevos para subir.'));
+            }
+            this.uiPort.separator();
+            let remoto = 'origin';
+            if (remotos.length > 1) {
+                remoto = await this.uiPort.select('¿A qué remoto hacer push?', remotos.map((r) => ({ name: r.name, value: r.name })));
+            }
+            const modo = await this.uiPort.select('Modo de push:', [
+                { name: `Subir rama actual  (${rama})`, value: 'normal' },
+                { name: 'Subir y crear rama en remoto  (--set-upstream)', value: 'upstream' },
+                { name: 'Forzar push  (--force-with-lease)', value: 'force' },
+                { name: 'Subir todos los tags', value: 'tags' },
+            ]);
+            const confirmar = await this.uiPort.confirm(`¿Confirmar push a ${remoto}/${rama}?`, true);
+            if (!confirmar) {
+                this.uiPort.warning('  Push cancelado.\n');
+                return;
+            }
+            const spinPush = this.uiPort.spinner('Subiendo cambios...');
+            switch (modo) {
+                case 'upstream':
+                    await this.gitPort.push(remoto, rama, [remoto, rama, '--set-upstream']);
+                    break;
+                case 'force':
+                    await this.gitPort.push(remoto, rama, [remoto, rama, '--force-with-lease']);
+                    break;
+                case 'tags':
+                    await this.gitPort.push(remoto, rama, [remoto, '--tags']);
+                    break;
+                default:
+                    await this.gitPort.push(remoto, rama);
+            }
+            spinPush.stop();
+            this.uiPort.success(`\n  ✓ Push exitoso → ${remoto}/${rama}\n`);
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async agregarRemotoManual() {
+        const nombre = await this.uiPort.input('Nombre del remoto:', {
+            default: 'origin',
+            validate: (v) => v.trim().length > 0 || 'Nombre requerido.',
+        });
+        const url = await this.uiPort.input('URL del remoto:', {
+            validate: (v) => v.trim().length > 0 || 'URL requerida.',
+        });
+        const spin = this.uiPort.spinner('Agregando remoto...');
+        try {
+            await this.gitPort.addRemote(nombre, url);
+            spin.stop();
+            this.uiPort.success(`  ✓ Remoto "${nombre}" agregado.`);
+        }
+        catch (err) {
+            spin.stop();
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async crearYConfigurarRepoGitHub() {
+        const c = this.uiColors;
+        const nombreCarpeta = path.basename(process.cwd());
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🚀 Crear repo en GitHub'));
+        this.uiPort.separator();
+        // Usar el nombre de la carpeta actual por defecto
+        const nombreRepo = await this.uiPort.input('Nombre del repositorio:', {
+            default: nombreCarpeta,
+            validate: (v) => v.trim().length > 0 || 'El nombre no puede estar vacío.',
+        });
+        const descripcion = await this.uiPort.input('Descripción (opcional):', {
+            default: '',
+        });
+        const visibilidad = await this.uiPort.select('Visibilidad:', [
+            { name: 'Público', value: 'public' },
+            { name: 'Privado', value: 'private' },
+        ]);
+        const cwd = process.cwd();
+        this.uiPort.separator();
+        this.uiPort.log(c.titulo('  Resumen:'));
+        this.uiPort.log(c.info(`  Carpeta:     ${cwd}`));
+        this.uiPort.log(c.info(`  Repo:        ${nombreRepo}`));
+        this.uiPort.log(c.info(`  Visibilidad: ${visibilidad}`));
+        if (descripcion.trim())
+            this.uiPort.log(c.tenue(`  Descripción: ${descripcion}`));
+        this.uiPort.separator();
+        const confirmar = await this.uiPort.confirm('¿Confirmar y continuar?', true);
+        if (!confirmar) {
+            this.uiPort.warning('  Operación cancelada.');
+            return;
+        }
+        // Paso 1: Crear repo en GitHub (sin autoInit para no conflictuar con local)
+        const spinGH = this.uiPort.spinner('Creando repositorio en GitHub...');
+        let repoCreado;
+        try {
+            repoCreado = await this.gitHubService.createRepo({
+                name: nombreRepo.trim(),
+                description: descripcion.trim() || undefined,
+                visibility: visibilidad,
+                autoInit: false,
+            });
+            spinGH.stop();
+            this.uiPort.success(c.exito(`  ✓ Repo creado en GitHub: ${repoCreado.htmlUrl}`));
+        }
+        catch (err) {
+            spinGH.stop();
+            this.uiPort.error(`  ✗ Error al crear repo: ${err.message}`);
+            return;
+        }
+        // Paso 2: Agregar remoto
+        const spinRemote = this.uiPort.spinner('Configurando remoto...');
+        try {
+            const git = simpleGit(cwd);
+            // Elegir método: HTTPS o SSH
+            const metodo = await this.uiPort.select('Método de conexión:', [
+                { name: 'HTTPS', value: 'https' },
+                { name: 'SSH', value: 'ssh' },
+            ]);
+            const url = metodo === 'https' ? repoCreado.cloneUrl : repoCreado.sshUrl;
+            await git.addRemote('origin', url);
+            spinRemote.stop();
+            this.uiPort.success(c.exito(`  ✓ Remoto origin agregado: ${url}`));
+        }
+        catch (err) {
+            spinRemote.stop();
+            this.uiPort.error(`  ✗ Error al configurar remoto: ${err.message}`);
+            this.uiPort.warning('  El repositorio sigue existiendo en GitHub.');
+        }
+    }
+    async elegirYConfigurarRepoExistente() {
+        const c = this.uiColors;
+        const spin = this.uiPort.spinner('Cargando repositorios...');
+        const repos = await this.gitHubService.listRepos();
+        spin.stop();
+        if (repos.length === 0) {
+            this.uiPort.warning('  No tienes repositorios en GitHub.');
+            return;
+        }
+        this.uiPort.log('');
+        const repoSeleccionado = await this.uiPort.select('Selecciona un repositorio:', repos.map(r => ({
+            name: `${r.fullName}${r.archived ? ' (archivado)' : ''}`,
+            value: r
+        })));
+        // Elegir método: HTTPS o SSH
+        const metodo = await this.uiPort.select('Método de conexión:', [
+            { name: 'HTTPS', value: 'https' },
+            { name: 'SSH', value: 'ssh' },
+        ]);
+        const url = metodo === 'https' ? repoSeleccionado.cloneUrl : repoSeleccionado.sshUrl;
+        const spinRemote = this.uiPort.spinner('Configurando remoto...');
+        try {
+            await this.gitPort.addRemote('origin', url);
+            spinRemote.stop();
+            this.uiPort.success(c.exito(`  ✓ Remoto origin agregado: ${url}`));
+        }
+        catch (err) {
+            spinRemote.stop();
+            this.uiPort.error(`  ✗ Error al configurar remoto: ${err.message}`);
+        }
+    }
+}

package/dist/commands/RepositoryCommand.js

@@ -0,0 +1,268 @@
+import { BaseCommand } from './BaseCommand.js';
+import path from 'path';
+import { simpleGit } from 'simple-git';
+export class RepositoryCommand extends BaseCommand {
+    gitHubService;
+    constructor(gitPort, uiPort, gitHubService) {
+        super(gitPort, uiPort);
+        this.gitHubService = gitHubService;
+    }
+    async execute() {
+        try {
+            const accion = await this.uiPort.select('Repositorio — ¿qué deseas hacer?', [
+                { name: 'Clonar repositorio remoto', value: 'clonar' },
+                { name: 'Inicializar nuevo repositorio', value: 'init' },
+                { name: 'Crear y subir a GitHub', value: 'initGitHub' },
+                { name: 'Ver remotos configurados', value: 'remotos' },
+                { name: 'Agregar remoto', value: 'agregarRemoto' },
+                { name: '← Volver al menú principal', value: 'volver' },
+            ]);
+            switch (accion) {
+                case 'clonar':
+                    await this.clonarRepo();
+                    break;
+                case 'init':
+                    await this.inicializarRepo();
+                    break;
+                case 'initGitHub':
+                    await this.inicializarYSubirAGitHub();
+                    break;
+                case 'remotos':
+                    await this.verRemotos();
+                    break;
+                case 'agregarRemoto':
+                    await this.agregarRemoto();
+                    break;
+                case 'volver':
+                    return;
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async clonarRepo() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  📥 Clonar repositorio'));
+        this.uiPort.separator();
+        const url = await this.uiPort.input('URL del repositorio (HTTPS o SSH):', {
+            validate: (v) => v.trim().length > 0 || 'La URL no puede estar vacía.',
+        });
+        const nombreSugerido = url.split('/').pop()?.replace('.git', '') || 'repo';
+        const destino = await this.uiPort.input('Carpeta de destino:', {
+            default: nombreSugerido,
+            validate: (v) => v.trim().length > 0 || 'El nombre no puede estar vacío.',
+        });
+        const rama = await this.uiPort.input('Rama a clonar (dejar vacío para rama por defecto):', {
+            default: '',
+        });
+        const cwd = process.cwd();
+        const destinoAbsoluto = path.join(cwd, destino);
+        this.uiPort.separator();
+        this.uiPort.log(`  URL:     ${c.info(url)}`);
+        this.uiPort.log(`  Carpeta: ${c.archivo(destinoAbsoluto)}`);
+        if (rama.trim())
+            this.uiPort.log(`  Rama:    ${c.rama(rama.trim())}`);
+        this.uiPort.separator();
+        const confirmar = await this.uiPort.confirm('¿Confirmar clonación?', true);
+        if (!confirmar) {
+            this.uiPort.warning('  Clonación cancelada.\n');
+            return;
+        }
+        const spinClone = this.uiPort.spinner('Clonando repositorio...');
+        try {
+            const git = simpleGit(cwd);
+            const opciones = [];
+            if (rama.trim()) {
+                opciones.push('-b', rama.trim());
+            }
+            await git.clone(url, destino, opciones);
+            spinClone.stop();
+            this.uiPort.success(`\n  ✓ Repositorio clonado en: ${c.archivo(destinoAbsoluto)}\n`);
+        }
+        catch (err) {
+            spinClone.stop();
+            const msg = err.message;
+            this.uiPort.error(`\n  ✗ Error al clonar:\n  ${msg}\n`);
+        }
+    }
+    async inicializarRepo() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🆕 Inicializar repositorio'));
+        this.uiPort.separator();
+        const esActual = await this.uiPort.select('¿Dónde inicializar?', [
+            { name: `Directorio actual (${process.cwd()})`, value: 'actual' },
+            { name: 'Nueva carpeta', value: 'nueva' },
+        ]);
+        let destino = process.cwd();
+        if (esActual === 'nueva') {
+            const nombreCarpeta = await this.uiPort.input('Nombre de la nueva carpeta:', {
+                validate: (v) => v.trim().length > 0 || 'El nombre no puede estar vacío.',
+            });
+            destino = path.join(process.cwd(), nombreCarpeta);
+        }
+        const ramaInicial = await this.uiPort.input('Nombre de la rama inicial:', {
+            default: 'main',
+        });
+        const confirmar = await this.uiPort.confirm(`¿Inicializar repo en: ${c.archivo(destino)}?`, true);
+        if (!confirmar)
+            return;
+        const spinInit = this.uiPort.spinner('Inicializando...');
+        try {
+            const git = simpleGit(destino);
+            await git.init({ '--initial-branch': ramaInicial.trim() || 'main' });
+            spinInit.stop();
+            this.uiPort.success(`\n  ✓ Repositorio inicializado en: ${c.archivo(destino)}\n`);
+        }
+        catch (err) {
+            spinInit.stop();
+            const msg = err.message;
+            this.uiPort.error(`\n  ✗ Error al inicializar:\n  ${msg}\n`);
+        }
+    }
+    async verRemotos() {
+        const isRepo = await this.gitPort.isRepository();
+        if (!isRepo) {
+            this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+            return;
+        }
+        const spin = this.uiPort.spinner('Cargando remotos...');
+        const remotos = await this.gitPort.getRemotes();
+        spin.stop();
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🌐 Remotos configurados'));
+        this.uiPort.separator();
+        if (remotos.length === 0) {
+            this.uiPort.log(c.tenue('  No hay remotos configurados.'));
+        }
+        else {
+            remotos.forEach((r) => {
+                this.uiPort.log(`  ${c.info(r.name.padEnd(10))} ${c.tenue(r.refs?.fetch || '')}`);
+            });
+        }
+        this.uiPort.separator();
+        this.uiPort.log('');
+    }
+    async agregarRemoto() {
+        const isRepo = await this.gitPort.isRepository();
+        if (!isRepo) {
+            this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
+            return;
+        }
+        const nombre = await this.uiPort.input('Nombre del remoto:', {
+            default: 'origin',
+            validate: (v) => v.trim().length > 0 || 'Nombre requerido.',
+        });
+        const url = await this.uiPort.input('URL del remoto:', {
+            validate: (v) => v.trim().length > 0 || 'URL requerida.',
+        });
+        const spinRem = this.uiPort.spinner('Agregando remoto...');
+        try {
+            await this.gitPort.addRemote(nombre, url);
+            spinRem.stop();
+            this.uiPort.success(`\n  ✓ Remoto "${nombre}" agregado → ${url}\n`);
+        }
+        catch (err) {
+            spinRem.stop();
+            const msg = err.message;
+            this.uiPort.error(`\n  ✗ Error:\n  ${msg}\n`);
+        }
+    }
+    async inicializarYSubirAGitHub() {
+        // Primero, verificar que el usuario esté autenticado
+        const isAuth = await this.gitHubService.isAuthenticated();
+        if (!isAuth) {
+            this.uiPort.error('  ✗ No estás autenticado con GitHub.');
+            this.uiPort.info('  Ve al menú "🌐 Gestión GitHub" primero para iniciar sesión.');
+            return;
+        }
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🚀 Crear repo y subir a GitHub'));
+        this.uiPort.separator();
+        // Paso 1: Obtener datos del repositorio
+        const nombreCarpeta = await this.uiPort.input('Nombre de la carpeta y del repositorio:', {
+            validate: (v) => v.trim().length > 0 || 'El nombre no puede estar vacío.',
+        });
+        const descripcion = await this.uiPort.input('Descripción del repositorio (opcional):', {
+            default: '',
+        });
+        const visibilidad = await this.uiPort.select('Visibilidad:', [
+            { name: 'Público', value: 'public' },
+            { name: 'Privado', value: 'private' },
+        ]);
+        const autoInit = await this.uiPort.confirm('¿Agregar README.md inicial?', true);
+        const gitignore = autoInit ? await this.uiPort.input('Plantilla .gitignore (ej: Node, dejar vacío para ninguna):', { default: '' }) : undefined;
+        const licencia = autoInit ? await this.uiPort.input('Licencia (ej: mit, dejar vacío para ninguna):', { default: '' }) : undefined;
+        const ramaInicial = await this.uiPort.input('Nombre de la rama inicial:', {
+            default: 'main',
+        });
+        // Calcular destino
+        const destino = path.join(process.cwd(), nombreCarpeta.trim());
+        this.uiPort.separator();
+        this.uiPort.log(c.titulo('  Resumen:'));
+        this.uiPort.log(c.info(`  Carpeta:     ${destino}`));
+        this.uiPort.log(c.info(`  Visibilidad: ${visibilidad}`));
+        if (descripcion.trim())
+            this.uiPort.log(c.tenue(`  Descripción: ${descripcion}`));
+        this.uiPort.separator();
+        const confirmar = await this.uiPort.confirm('¿Confirmar y continuar?', true);
+        if (!confirmar) {
+            this.uiPort.warning('  Operación cancelada.');
+            return;
+        }
+        // Paso 2: Crear repo en GitHub
+        const spinGH = this.uiPort.spinner('Creando repositorio en GitHub...');
+        let repoCreado;
+        try {
+            repoCreado = await this.gitHubService.createRepo({
+                name: nombreCarpeta.trim(),
+                description: descripcion.trim() || undefined,
+                visibility: visibilidad,
+                autoInit: autoInit,
+                gitignoreTemplate: gitignore?.trim(),
+                licenseTemplate: licencia?.trim(),
+            });
+            spinGH.stop();
+            this.uiPort.success(c.exito(`  ✓ Repo creado en GitHub: ${repoCreado.htmlUrl}`));
+        }
+        catch (err) {
+            spinGH.stop();
+            this.uiPort.error(`  ✗ Error al crear repo en GitHub: ${err.message}`);
+            return;
+        }
+        // Paso 3: Clonar o inicializar localmente y subir
+        const spinLocal = this.uiPort.spinner('Configurando repositorio local...');
+        try {
+            const git = simpleGit();
+            // Clonar el repo que acabamos de crear
+            await git.clone(repoCreado.cloneUrl, nombreCarpeta.trim());
+            // Ir a la carpeta
+            const gitRepo = simpleGit(destino);
+            // Verificar que existan archivos (si usamos autoInit)
+            if (autoInit) {
+                // Ya tiene contenido, solo confirmar
+                spinLocal.stop();
+                this.uiPort.success(c.exito(`  ✓ Listo! Repositorio en: ${destino}`));
+                this.uiPort.log(c.tenue(`  URL HTTPS: ${repoCreado.cloneUrl}`));
+                this.uiPort.log(c.tenue(`  URL SSH:   ${repoCreado.sshUrl}`));
+            }
+            else {
+                // Si no usamos autoInit, agregar algún contenido inicial
+                spinLocal.stop();
+                this.uiPort.info('  Repo creado sin contenido inicial. Puedes agregar archivos y hacer push manualmente.');
+                this.uiPort.log(c.tenue(`  URL HTTPS: ${repoCreado.cloneUrl}`));
+                this.uiPort.log(c.tenue(`  URL SSH:   ${repoCreado.sshUrl}`));
+            }
+            this.uiPort.log('');
+        }
+        catch (err) {
+            spinLocal.stop();
+            this.uiPort.error(`  ✗ Error al configurar localmente: ${err.message}`);
+            this.uiPort.warning('  El repositorio sigue existiendo en GitHub.');
+        }
+    }
+}

package/dist/commands/StashCommand.js

@@ -0,0 +1,140 @@
+import { BaseCommand } from './BaseCommand.js';
+export class StashCommand 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('Stash — ¿qué deseas hacer?', [
+                { name: 'Guardar cambios en stash', value: 'guardar' },
+                { name: 'Ver lista de stashes', value: 'listar' },
+                { name: 'Aplicar stash (mantener en lista)', value: 'aplicar' },
+                { name: 'Restaurar y eliminar stash (pop)', value: 'pop' },
+                { name: 'Eliminar un stash', value: 'eliminar' },
+                { name: 'Limpiar todos los stashes', value: 'limpiar' },
+                { name: '← Volver al menú principal', value: 'volver' },
+            ]);
+            switch (accion) {
+                case 'guardar':
+                    await this.guardarStash();
+                    break;
+                case 'listar':
+                    await this.listarStashes();
+                    break;
+                case 'aplicar':
+                    await this.operarStash('apply');
+                    break;
+                case 'pop':
+                    await this.operarStash('pop');
+                    break;
+                case 'eliminar':
+                    await this.eliminarStash();
+                    break;
+                case 'limpiar':
+                    await this.limpiarStashes();
+                    break;
+                case 'volver':
+                    return;
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    async guardarStash() {
+        const spin = this.uiPort.spinner('Verificando cambios...');
+        const status = await this.gitPort.getStatus();
+        spin.stop();
+        const hayModificados = status.modified.length + status.staged.length + status.not_added.length;
+        if (hayModificados === 0) {
+            this.uiPort.warning('\n  No hay cambios para guardar en stash.\n');
+            return;
+        }
+        const mensaje = await this.uiPort.input('Mensaje del stash (opcional):');
+        const incluirNoSeguidos = await this.uiPort.confirm('¿Incluir archivos sin seguimiento (untracked)?', false);
+        const spinStash = this.uiPort.spinner('Guardando en stash...');
+        await this.gitPort.stashPush(mensaje.trim() || undefined, incluirNoSeguidos);
+        spinStash.stop();
+        this.uiPort.success('\n  ✓ Cambios guardados en stash. Árbol limpio.\n');
+    }
+    async listarStashes() {
+        const spin = this.uiPort.spinner('Cargando stashes...');
+        const lista = await this.gitPort.stashList();
+        spin.stop();
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  📦 Stashes guardados'));
+        this.uiPort.separator();
+        if (lista.all.length === 0) {
+            this.uiPort.log(c.tenue('  No hay stashes guardados.'));
+        }
+        else {
+            lista.all.forEach((s, i) => {
+                const fecha = new Date(s.date).toLocaleDateString('es-CL', {
+                    day: '2-digit',
+                    month: 'short',
+                    year: 'numeric',
+                });
+                this.uiPort.log(`  ${c.hash(`stash@{${i}}`)}  ${c.tenue(fecha)}  ${c.titulo(s.message)}`);
+            });
+        }
+        this.uiPort.separator();
+        this.uiPort.log('');
+    }
+    async operarStash(modo) {
+        const spin = this.uiPort.spinner('Cargando stashes...');
+        const lista = await this.gitPort.stashList();
+        spin.stop();
+        if (lista.all.length === 0) {
+            this.uiPort.warning('\n  No hay stashes disponibles.\n');
+            return;
+        }
+        const opciones = lista.all.map((s, i) => ({
+            name: `stash@{${i}}  ${s.message}`,
+            value: `stash@{${i}}`,
+        }));
+        const seleccionado = await this.uiPort.select(modo === 'pop' ? '¿Qué stash restaurar y eliminar (pop)?' : '¿Qué stash aplicar?', opciones);
+        const label = modo === 'pop' ? 'Restaurando y eliminando' : 'Aplicando';
+        const spinOp = this.uiPort.spinner(`${label} ${seleccionado}...`);
+        if (modo === 'pop') {
+            await this.gitPort.stashPop(seleccionado);
+        }
+        else {
+            await this.gitPort.stashApply(seleccionado);
+        }
+        spinOp.stop();
+        this.uiPort.success(`\n  ✓ ${seleccionado} ${modo === 'pop' ? 'restaurado y eliminado' : 'aplicado'}.\n`);
+    }
+    async eliminarStash() {
+        const spin = this.uiPort.spinner('Cargando stashes...');
+        const lista = await this.gitPort.stashList();
+        spin.stop();
+        if (lista.all.length === 0) {
+            this.uiPort.warning('\n  No hay stashes disponibles.\n');
+            return;
+        }
+        const opciones = lista.all.map((s, i) => ({
+            name: `stash@{${i}}  ${s.message}`,
+            value: `stash@{${i}}`,
+        }));
+        const seleccionado = await this.uiPort.select('¿Qué stash deseas eliminar?', opciones);
+        const confirmar = await this.uiPort.confirm(`¿Eliminar ${seleccionado}?`, false);
+        if (!confirmar)
+            return;
+        const spinDel = this.uiPort.spinner('Eliminando...');
+        await this.gitPort.stashDrop(seleccionado);
+        spinDel.stop();
+        this.uiPort.success(`\n  ✓ ${seleccionado} eliminado.\n`);
+    }
+    async limpiarStashes() {
+        const confirmar = await this.uiPort.confirm(this.uiColors.error('¿Eliminar TODOS los stashes? Esta acción es irreversible.'), false);
+        if (!confirmar)
+            return;
+        const spin = this.uiPort.spinner('Limpiando stashes...');
+        await this.gitPort.stashClear();
+        spin.stop();
+        this.uiPort.success('\n  ✓ Todos los stashes eliminados.\n');
+    }
+}