@asaro/git-cli 1.0.0 → 1.0.2

package/dist/commands/RepositoryCommand.js

@@ -1,6 +1,7 @@
 import { BaseCommand } from './BaseCommand.js';
 import path from 'path';
-import { simpleGit } from 'simple-git';
+import readline from 'readline';
+import chalk from 'chalk';
 export class RepositoryCommand extends BaseCommand {
     gitHubService;
     constructor(gitPort, uiPort, gitHubService) {
@@ -10,11 +11,10 @@ export class RepositoryCommand extends BaseCommand {
     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: '📥 Clonar un repositorio remoto', value: 'clonar' },
+                { name: '🆕 Inicializar un repositorio Git local', value: 'init' },
+                { name: '🚀 Publicar este proyecto local en GitHub', value: 'publicarGitHub' },
+                { name: '🌐 Gestionar enlaces remotos (remotes)', value: 'gestionarRemotos' },
                 { name: '← Volver al menú principal', value: 'volver' },
             ]);
             switch (accion) {
@@ -24,14 +24,11 @@ export class RepositoryCommand extends BaseCommand {
                 case 'init':
                     await this.inicializarRepo();
                     break;
-                case 'initGitHub':
-                    await this.inicializarYSubirAGitHub();
+                case 'publicarGitHub':
+                    await this.publicarRepositorioEnGitHub();
                     break;
-                case 'remotos':
-                    await this.verRemotos();
-                    break;
-                case 'agregarRemoto':
-                    await this.agregarRemoto();
+                case 'gestionarRemotos':
+                    await this.gestionarRemotosSubMenu();
                     break;
                 case 'volver':
                     return;
@@ -46,9 +43,48 @@ export class RepositoryCommand extends BaseCommand {
         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.',
-        });
+        let url = '';
+        const isAuth = await this.gitHubService.isAuthenticated();
+        if (isAuth) {
+            const modo = await this.uiPort.select('¿Cómo deseas seleccionar el repositorio a clonar?', [
+                { name: '🌐 Seleccionar de mis repositorios de GitHub', value: 'github' },
+                { name: '🔗 Ingresar URL manualmente (HTTPS o SSH)', value: 'manual' },
+            ]);
+            if (modo === 'github') {
+                const spin = this.uiPort.spinner('Cargando tus repositorios de GitHub...');
+                let repos = [];
+                try {
+                    repos = await this.gitHubService.listRepos();
+                }
+                catch (err) {
+                    this.uiPort.error(`  ✗ Error al cargar repositorios: ${err.message}`);
+                }
+                spin.stop();
+                if (repos.length === 0) {
+                    this.uiPort.warning('  No se encontraron repositorios en tu cuenta de GitHub.');
+                    const ingresarManual = await this.uiPort.confirm('¿Deseas ingresar la URL manualmente?', true);
+                    if (!ingresarManual)
+                        return;
+                }
+                else {
+                    const selectedRepo = await this.seleccionarRepoPaginado(repos);
+                    if (!selectedRepo) {
+                        this.uiPort.warning('  Clonación cancelada.');
+                        return;
+                    }
+                    const metodoClonacion = await this.uiPort.select('Método de clonación:', [
+                        { name: 'HTTPS', value: 'https' },
+                        { name: 'SSH', value: 'ssh' },
+                    ]);
+                    url = metodoClonacion === 'https' ? selectedRepo.cloneUrl : selectedRepo.sshUrl;
+                }
+            }
+        }
+        if (!url) {
+            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,
@@ -72,12 +108,11 @@ export class RepositoryCommand extends BaseCommand {
         }
         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);
+            await this.gitPort.clone(url, destino, opciones);
             spinClone.stop();
             this.uiPort.success(`\n  ✓ Repositorio clonado en: ${c.archivo(destinoAbsoluto)}\n`);
         }
@@ -87,6 +122,93 @@ export class RepositoryCommand extends BaseCommand {
             this.uiPort.error(`\n  ✗ Error al clonar:\n  ${msg}\n`);
         }
     }
+    async seleccionarRepoPaginado(repos) {
+        const itemsPerPage = 10;
+        let currentPage = 0;
+        const totalPages = Math.ceil(repos.length / itemsPerPage);
+        let selectedIndexInPage = 0;
+        const isRaw = process.stdin.isRaw;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        const c = this.uiColors;
+        return new Promise((resolve) => {
+            const render = () => {
+                this.uiPort.clear();
+                this.uiPort.showBanner();
+                this.uiPort.log(c.titulo(`  🌐 Seleccionar Repositorio (Página ${currentPage + 1} de ${totalPages})`));
+                this.uiPort.log(c.tenue('  [←/→] Cambiar página  |  [↑/↓] Mover cursor  |  [Enter] Seleccionar  |  [Esc] Cancelar'));
+                this.uiPort.separator();
+                const start = currentPage * itemsPerPage;
+                const end = Math.min(start + itemsPerPage, repos.length);
+                const pageItems = repos.slice(start, end);
+                if (selectedIndexInPage >= pageItems.length) {
+                    selectedIndexInPage = pageItems.length - 1;
+                }
+                pageItems.forEach((r, idx) => {
+                    const esSeleccionado = idx === selectedIndexInPage;
+                    const indicador = esSeleccionado ? ' ❯ ' : '   ';
+                    const infoText = `${r.fullName} (${r.visibility})`;
+                    if (esSeleccionado) {
+                        this.uiPort.log(chalk.bgHex('#313244').hex('#a6da95').bold(` ${indicador}${infoText.padEnd(55)}`));
+                    }
+                    else {
+                        this.uiPort.log(` ${indicador}${infoText}`);
+                    }
+                });
+                this.uiPort.separator();
+                const paginador = Array.from({ length: totalPages }).map((_, idx) => {
+                    return idx === currentPage ? c.exito('●') : c.tenue('○');
+                }).join(' ');
+                this.uiPort.log(`  Páginas:  ${paginador}`);
+                this.uiPort.separator();
+            };
+            const handleKeypress = (str, key) => {
+                if (!key)
+                    return;
+                const start = currentPage * itemsPerPage;
+                const end = Math.min(start + itemsPerPage, repos.length);
+                const pageItems = repos.slice(start, end);
+                if (key.name === 'up') {
+                    selectedIndexInPage = (selectedIndexInPage - 1 + pageItems.length) % pageItems.length;
+                    render();
+                }
+                else if (key.name === 'down') {
+                    selectedIndexInPage = (selectedIndexInPage + 1) % pageItems.length;
+                    render();
+                }
+                else if (key.name === 'left') {
+                    if (currentPage > 0) {
+                        currentPage--;
+                        selectedIndexInPage = 0;
+                        render();
+                    }
+                }
+                else if (key.name === 'right') {
+                    if (currentPage < totalPages - 1) {
+                        currentPage++;
+                        selectedIndexInPage = 0;
+                        render();
+                    }
+                }
+                else if (key.name === 'return') {
+                    cleanup();
+                    resolve(pageItems[selectedIndexInPage]);
+                }
+                else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                    cleanup();
+                    resolve(null);
+                }
+            };
+            const cleanup = () => {
+                process.stdin.removeListener('keypress', handleKeypress);
+                process.stdin.setRawMode(isRaw);
+                process.stdin.pause();
+            };
+            process.stdin.on('keypress', handleKeypress);
+            render();
+        });
+    }
     async inicializarRepo() {
         const c = this.uiColors;
         this.uiPort.log('');
@@ -111,8 +233,7 @@ export class RepositoryCommand extends BaseCommand {
             return;
         const spinInit = this.uiPort.spinner('Inicializando...');
         try {
-            const git = simpleGit(destino);
-            await git.init({ '--initial-branch': ramaInicial.trim() || 'main' });
+            await this.gitPort.init(destino, ramaInicial.trim() || 'main');
             spinInit.stop();
             this.uiPort.success(`\n  ✓ Repositorio inicializado en: ${c.archivo(destino)}\n`);
         }
@@ -122,12 +243,162 @@ export class RepositoryCommand extends BaseCommand {
             this.uiPort.error(`\n  ✗ Error al inicializar:\n  ${msg}\n`);
         }
     }
-    async verRemotos() {
+    async publicarRepositorioEnGitHub() {
+        const isAuth = await this.gitHubService.isAuthenticated();
+        if (!isAuth) {
+            this.uiPort.error('  ✗ No estás autenticado con GitHub.');
+            this.uiPort.info('  Por favor, ve al menú "🌐 Gestión GitHub" y selecciona "Autenticación" para iniciar sesión.');
+            return;
+        }
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  🚀 Publicar repositorio actual en GitHub'));
+        this.uiPort.separator();
+        let isRepo = await this.gitPort.isRepository();
+        if (!isRepo) {
+            this.uiPort.warning('  El directorio actual no es un repositorio Git local.');
+            const initConfirm = await this.uiPort.confirm('¿Deseas inicializar un repositorio Git en esta carpeta ahora?', true);
+            if (!initConfirm) {
+                this.uiPort.warning('  Operación cancelada.');
+                return;
+            }
+            const spinInit = this.uiPort.spinner('Inicializando repositorio local...');
+            try {
+                await this.gitPort.init(process.cwd(), 'main');
+                spinInit.stop();
+                this.uiPort.success('  ✓ Repositorio Git local inicializado (rama principal: main).');
+                isRepo = true;
+            }
+            catch (err) {
+                spinInit.stop();
+                this.uiPort.error(`  ✗ Error al inicializar: ${err.message}`);
+                return;
+            }
+        }
+        try {
+            const remotos = await this.gitPort.getRemotes();
+            const originExiste = remotos.some((r) => r.name === 'origin');
+            if (originExiste) {
+                this.uiPort.warning('  ⚠️ Ya tienes un remoto configurado con el nombre "origin".');
+                this.uiPort.info('  Si deseas cambiarlo, ve a la sección de "Gestionar enlaces remotos".');
+                return;
+            }
+        }
+        catch (err) {
+            // Ignorar e intentar continuar
+        }
+        const defaultName = path.basename(process.cwd());
+        const nombre = await this.uiPort.input('Nombre del repositorio en GitHub:', {
+            default: defaultName,
+            validate: (v) => v.trim().length > 0 || 'El nombre es obligatorio.',
+        });
+        const descripcion = await this.uiPort.input('Descripción (opcional):');
+        const visibilidad = await this.uiPort.select('Visibilidad:', [
+            { name: 'Público', value: 'public' },
+            { name: 'Privado', value: 'private' },
+        ]);
+        const confirmar = await this.uiPort.confirm(`¿Quieres crear el repositorio "${nombre}" (${visibilidad}) en GitHub y subir el código actual?`, true);
+        if (!confirmar) {
+            this.uiPort.warning('  Operación cancelada.');
+            return;
+        }
+        const spinGH = this.uiPort.spinner('Creando repositorio en GitHub...');
+        let repoCreado;
+        try {
+            repoCreado = await this.gitHubService.createRepo({
+                name: nombre.trim(),
+                description: descripcion.trim() || undefined,
+                visibility: visibilidad,
+                autoInit: false,
+            });
+            spinGH.stop();
+            this.uiPort.success(`  ✓ Repositorio creado en GitHub: ${repoCreado.htmlUrl}`);
+        }
+        catch (err) {
+            spinGH.stop();
+            this.uiPort.error(`  ✗ Error al crear repositorio en GitHub: ${err.message}`);
+            return;
+        }
+        const spinConfig = this.uiPort.spinner('Vinculando repositorio remoto...');
+        try {
+            await this.gitPort.addRemote('origin', repoCreado.sshUrl || repoCreado.cloneUrl);
+            spinConfig.stop();
+            this.uiPort.success(`  ✓ Remoto "origin" vinculado con éxito.`);
+        }
+        catch (err) {
+            spinConfig.stop();
+            this.uiPort.error(`  ✗ Error al vincular el remoto: ${err.message}`);
+            this.uiPort.info(`  Puedes agregarlo manualmente con la URL: ${repoCreado.cloneUrl}`);
+            return;
+        }
+        const status = await this.gitPort.getStatus();
+        const ramaActual = status.current || 'main';
+        const realizarPush = await this.uiPort.confirm(`¿Deseas subir la rama actual "${ramaActual}" a GitHub ahora mismo? (push)`, true);
+        if (realizarPush) {
+            const spinPush = this.uiPort.spinner(`Subiendo rama "${ramaActual}" a GitHub (origin)...`);
+            try {
+                await this.gitPort.push('origin', ramaActual, ['-u', 'origin', ramaActual]);
+                spinPush.stop();
+                this.uiPort.success(`\n  ✓ ¡Todo listo! Tu código se ha subido a GitHub.`);
+                this.uiPort.log(`  🔗 Puedes verlo en: ${c.info(repoCreado.htmlUrl)}\n`);
+            }
+            catch (err) {
+                spinPush.stop();
+                this.uiPort.error(`\n  ✗ Error al subir el código: ${err.message}`);
+                this.uiPort.info('  Asegúrate de tener commits hechos antes de subir cambios.');
+                this.uiPort.info(`  Puedes intentar subirlo manualmente ejecutando: git push -u origin ${ramaActual}\n`);
+            }
+        }
+        else {
+            this.uiPort.info(`\n  Perfecto. Puedes subir tu código en cualquier momento usando la opción de "Push" desde el menú principal.\n`);
+        }
+    }
+    async gestionarRemotosSubMenu() {
         const isRepo = await this.gitPort.isRepository();
         if (!isRepo) {
             this.uiPort.error('  ✗ Este directorio no es un repositorio Git.');
             return;
         }
+        const c = this.uiColors;
+        let continuar = true;
+        while (continuar) {
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  🌐 Gestión de Enlaces Remotos (Remotes)'));
+            this.uiPort.separator();
+            const accion = await this.uiPort.select('¿Qué deseas hacer con los remotos?', [
+                { name: '📋  Ver remotos configurados', value: 'ver' },
+                { name: '➕  Agregar un nuevo remoto', value: 'agregar' },
+                { name: '✏️  Cambiar URL de un remoto', value: 'url' },
+                { name: '🏷️  Renombrar un remoto', value: 'renombrar' },
+                { name: '❌  Eliminar un remoto', value: 'eliminar' },
+                { name: '←  Volver', value: 'volver' },
+            ]);
+            switch (accion) {
+                case 'ver':
+                    await this.verRemotos();
+                    break;
+                case 'agregar':
+                    await this.agregarRemoto();
+                    break;
+                case 'url':
+                    await this.cambiarUrlRemoto();
+                    break;
+                case 'renombrar':
+                    await this.renombrarRemoto();
+                    break;
+                case 'eliminar':
+                    await this.eliminarRemoto();
+                    break;
+                case 'volver':
+                    continuar = false;
+                    break;
+            }
+            if (continuar && accion !== 'volver') {
+                await this.uiPort.pause();
+            }
+        }
+    }
+    async verRemotos() {
         const spin = this.uiPort.spinner('Cargando remotos...');
         const remotos = await this.gitPort.getRemotes();
         spin.stop();
@@ -147,11 +418,6 @@ export class RepositoryCommand extends BaseCommand {
         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.',
@@ -171,98 +437,76 @@ export class RepositoryCommand extends BaseCommand {
             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.');
+    async cambiarUrlRemoto() {
+        const remotes = await this.gitPort.getRemotes();
+        if (remotes.length === 0) {
+            this.uiPort.warning('  No hay remotos configurados.');
             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 choices = remotes.map((r) => ({ name: `${r.name} (${r.refs?.fetch || 'no-url'})`, value: r.name }));
+        const name = await this.uiPort.select('Selecciona el remoto a modificar:', choices);
+        const url = await this.uiPort.input('Ingresa la nueva URL para el remoto:', {
+            validate: (v) => v.trim().length > 0 || 'La URL es requerida.',
         });
-        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.');
+        const spin = this.uiPort.spinner('Actualizando URL del remoto...');
+        try {
+            await this.gitPort.setRemoteUrl(name, url.trim());
+            spin.stop();
+            this.uiPort.success(`\n  ✓ La URL del remoto "${name}" ha sido cambiada a: ${url.trim()}\n`);
+        }
+        catch (err) {
+            spin.stop();
+            this.uiPort.error(`\n  ✗ Error al cambiar URL: ${err.message}\n`);
+        }
+    }
+    async renombrarRemoto() {
+        const remotes = await this.gitPort.getRemotes();
+        if (remotes.length === 0) {
+            this.uiPort.warning('  No hay remotos configurados.');
             return;
         }
-        // Paso 2: Crear repo en GitHub
-        const spinGH = this.uiPort.spinner('Creando repositorio en GitHub...');
-        let repoCreado;
+        const choices = remotes.map((r) => ({ name: r.name, value: r.name }));
+        const oldName = await this.uiPort.select('Selecciona el remoto a renombrar:', choices);
+        const newName = await this.uiPort.input('Ingresa el nuevo nombre:', {
+            validate: (v) => {
+                if (!v.trim())
+                    return 'El nombre es requerido.';
+                if (/\s/.test(v))
+                    return 'El nombre no puede tener espacios.';
+                return true;
+            },
+        });
+        const spin = this.uiPort.spinner('Renombrando remoto...');
         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}`));
+            await this.gitPort.renameRemote(oldName, newName.trim());
+            spin.stop();
+            this.uiPort.success(`\n  ✓ Remoto renombrado con éxito: ${oldName} → ${newName.trim()}\n`);
         }
         catch (err) {
-            spinGH.stop();
-            this.uiPort.error(`  ✗ Error al crear repo en GitHub: ${err.message}`);
+            spin.stop();
+            this.uiPort.error(`\n  ✗ Error al renombrar remoto: ${err.message}\n`);
+        }
+    }
+    async eliminarRemoto() {
+        const remotes = await this.gitPort.getRemotes();
+        if (remotes.length === 0) {
+            this.uiPort.warning('  No hay remotos configurados.');
             return;
         }
-        // Paso 3: Clonar o inicializar localmente y subir
-        const spinLocal = this.uiPort.spinner('Configurando repositorio local...');
+        const choices = remotes.map((r) => ({ name: `${r.name} (${r.refs?.fetch || 'no-url'})`, value: r.name }));
+        const name = await this.uiPort.select('Selecciona el remoto a eliminar:', choices);
+        const confirmar = await this.uiPort.confirm(`¿Seguro que deseas eliminar el remoto "${name}"? Se perderá la vinculación remota.`, false);
+        if (!confirmar)
+            return;
+        const spin = this.uiPort.spinner('Eliminando remoto...');
         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('');
+            await this.gitPort.removeRemote(name);
+            spin.stop();
+            this.uiPort.success(`\n  ✓ Remoto "${name}" eliminado correctamente.\n`);
         }
         catch (err) {
-            spinLocal.stop();
-            this.uiPort.error(`  ✗ Error al configurar localmente: ${err.message}`);
-            this.uiPort.warning('  El repositorio sigue existiendo en GitHub.');
+            spin.stop();
+            this.uiPort.error(`\n  ✗ Error al eliminar remoto: ${err.message}\n`);
         }
     }
 }

package/dist/commands/github/GitHubReposCommand.js

@@ -1,5 +1,4 @@
 import { BaseGitHubCommand } from './BaseGitHubCommand.js';
-import { simpleGit } from 'simple-git';
 import path from 'path';
 export class GitHubReposCommand extends BaseGitHubCommand {
     async execute() {
@@ -196,8 +195,7 @@ export class GitHubReposCommand extends BaseGitHubCommand {
         const dest = await this.uiPort.input('Carpeta de destino:', { default: defaultDest });
         const spinClone = this.uiPort.spinner('Clonando repositorio...');
         try {
-            const git = simpleGit(process.cwd());
-            await git.clone(cloneUrl, dest.trim());
+            await this.gitPort.clone(cloneUrl, dest.trim());
             spinClone.stop();
             const destPath = path.join(process.cwd(), dest.trim());
             this.uiPort.success(`  ✓ Repositorio clonado en: ${c.info(destPath)}`);

package/dist/core/services/GitHubService.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GitHubService } from './GitHubService.js';
+describe('GitHubService', () => {
+    let mockGitHubPort;
+    let mockStorage;
+    let service;
+    class MockSecureStorage {
+        store = new Map();
+        async save(key, value) { this.store.set(key, value); }
+        async load(key) { return this.store.get(key) || null; }
+        async delete(key) { this.store.delete(key); }
+        async exists(key) { return this.store.has(key); }
+    }
+    class MockGitHubPort {
+        authenticatedToken = null;
+        validated = false;
+        currentUser = { login: 'testuser', name: 'Test User' };
+        async authenticate(token) { this.authenticatedToken = token; }
+        async validateToken() { this.validated = true; return true; }
+        async getCurrentUser() { return this.currentUser; }
+        // Stub implementations for the rest to satisfy interface
+        async listRepos() { return []; }
+        async getRepo() { return {}; }
+        async createRepo() { return {}; }
+        async archiveRepo() { }
+        async unarchiveRepo() { }
+        async deleteRepo() { }
+        async listWorkflows() { return []; }
+        async listWorkflowRuns() { return []; }
+        async enableWorkflow() { }
+        async disableWorkflow() { }
+        async triggerWorkflowDispatch() { }
+    }
+    beforeEach(() => {
+        mockGitHubPort = new MockGitHubPort();
+        mockStorage = new MockSecureStorage();
+        service = new GitHubService(mockGitHubPort, mockStorage);
+    });
+    it('debería retornar falso en isAuthenticated si no hay token guardado', async () => {
+        const isAuth = await service.isAuthenticated();
+        expect(isAuth).toBe(false);
+    });
+    it('debería retornar verdadero en isAuthenticated si hay un token válido guardado', async () => {
+        await mockStorage.save('github_pat', 'my-valid-token');
+        const isAuth = await service.isAuthenticated();
+        expect(isAuth).toBe(true);
+        expect(mockGitHubPort.authenticatedToken).toBe('my-valid-token');
+    });
+    it('debería iniciar sesión correctamente guardando el token y obteniendo el usuario', async () => {
+        await service.login('new-token');
+        expect(await mockStorage.load('github_pat')).toBe('new-token');
+        expect(mockGitHubPort.authenticatedToken).toBe('new-token');
+        const user = await service.getCurrentUser();
+        expect(user.login).toBe('testuser');
+    });
+    it('debería cerrar sesión eliminando el token guardado', async () => {
+        await mockStorage.save('github_pat', 'token-to-delete');
+        await service.logout();
+        expect(await mockStorage.exists('github_pat')).toBe(false);
+    });
+});

package/dist/index.js

@@ -3,10 +3,26 @@ import { SimpleGitAdapter } from './adapters/git/SimpleGitAdapter.js';
 import { ConsoleUIAdapter } from './adapters/ui/ConsoleUIAdapter.js';
 import { GitHubAPIAdapter } from './adapters/github/GitHubAPIAdapter.js';
 import { FileSecureStorageAdapter } from './adapters/storage/FileSecureStorageAdapter.js';
-import { CommandFactory } from './factories/CommandFactory.js';
+import { CommandFactory } from './commands/CommandFactory.js';
+import { execSync } from 'child_process';
+function checkGitInstalled() {
+    try {
+        execSync('git --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function main() {
-    const gitPort = new SimpleGitAdapter();
     const uiPort = new ConsoleUIAdapter();
+    if (!checkGitInstalled()) {
+        uiPort.error('\n  ✗ Error: Git no está instalado o no se encuentra en el PATH del sistema.');
+        uiPort.info('  Por favor instala Git y asegúrate de que esté configurado en tu variable de entorno PATH.');
+        uiPort.info('  Para más información visita: https://git-scm.com\n');
+        process.exit(1);
+    }
+    const gitPort = new SimpleGitAdapter();
     const gitHubPort = new GitHubAPIAdapter();
     const storage = new FileSecureStorageAdapter();
     const commandFactory = new CommandFactory(gitPort, uiPort, gitHubPort, storage);
@@ -19,6 +35,7 @@ async function main() {
             const opcion = await uiPort.select('¿Qué deseas hacer?', [
                 { name: '📋  Estado del repositorio', value: 'status' },
                 { name: '📜  Ver historial (log)', value: 'log' },
+                { name: '🔍  Ver diferencias (diff)', value: 'diff' },
                 { name: '─────────────────────────────', value: 'sep1', disabled: true },
                 { name: '✅  Commit  (add + commit)', value: 'commit' },
                 { name: '↑   Push  (subir cambios)', value: 'push' },