@asaro/git-cli 1.0.0 → 1.0.2

package/README.md

@@ -26,13 +26,27 @@ Git CLI interactivo en español para gestionar repositorios Git y GitHub desde l
 
 ### Métodos de instalación
 
-#### 1. Instalación global desde npm (la forma más fácil!)
+#### 1. Instalación global directa desde GitHub (¡Recomendada!)
 
-Si el paquete está publicado en npm:
+Puedes instalar la herramienta directamente desde el repositorio en tu PC corriendo:
+
+```bash
+npm install -g iTzAsaro/GitCLI
+```
+
+Y luego utilízalo en cualquier lugar con:
+
+```bash
+git-cli
+```
+
+#### 2. Instalación global desde npm
+
+Si el paquete está publicado en el registro de npm:
 
 ```bash
 # Instálalo globalmente en tu PC
-npm install -g @itzasaro/git-cli
+npm install -g @asaro/git-cli
 
 # Ahora puedes usar el comando 'git-cli' desde cualquier lugar!
 git-cli
@@ -97,7 +111,7 @@ Edita `package.json` y cambia:
 
 ### Paso 4: Publicar!
 
-Como es un paquete con scope (`@iTzAsaro/`), necesitas publicar con acceso público:
+Como es un paquete con scope (`@asaro/`), necesitas publicar con acceso público:
 
 ```bash
 npm publish --access public
@@ -106,7 +120,7 @@ npm publish --access public
 ¡Listo! Ahora cualquier persona puede instalar tu paquete con:
 
 ```bash
-npm install -g @itzasaro/git-cli
+npm install -g @asaro/git-cli
 ```
 
 ### Para publicar una nueva versión
@@ -177,7 +191,7 @@ npm install -g .
 ## Desinstalación
 
 ```bash
-npm uninstall -g @itzasaro/git-cli
+npm uninstall -g @asaro/git-cli
 ```
 
 ## Archivos de configuración

package/dist/adapters/git/SimpleGitAdapter.js

@@ -120,7 +120,25 @@ export class SimpleGitAdapter {
     async addRemote(name, url) {
         await this.git.addRemote(name, url);
     }
+    async removeRemote(name) {
+        await this.git.removeRemote(name);
+    }
+    async renameRemote(oldName, newName) {
+        await this.git.remote(['rename', oldName, newName]);
+    }
+    async setRemoteUrl(name, url) {
+        await this.git.remote(['set-url', name, url]);
+    }
     getGitInstance() {
         return this.git;
     }
+    async diff(options) {
+        return this.git.diff(options);
+    }
+    async show(options) {
+        if (options) {
+            return this.git.show(options);
+        }
+        return this.git.show();
+    }
 }

package/dist/adapters/github/GitHubAPIAdapter.js

@@ -3,7 +3,15 @@ import { GitHubAuthError, GitHubRateLimitError, GitHubPermissionError, GitHubNot
 export class GitHubAPIAdapter {
     octokit = null;
     async authenticate(token) {
-        this.octokit = new Octokit({ auth: token });
+        this.octokit = new Octokit({
+            auth: token,
+            log: {
+                debug: () => { },
+                info: () => { },
+                warn: () => { },
+                error: () => { },
+            },
+        });
     }
     async validateToken() {
         if (!this.octokit)

package/dist/adapters/storage/FileSecureStorageAdapter.js

@@ -1,20 +1,14 @@
 import CryptoJS from 'crypto-js';
+import crypto from 'crypto';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 export class FileSecureStorageAdapter {
     storageDir;
-    secretKey;
+    secretKey = null;
     constructor() {
         // Use a directory in user's home for storage
         this.storageDir = path.join(os.homedir(), '.gitcli');
-        // Use machine-specific info as part of secret (not perfect but better than plaintext)
-        this.secretKey = this.getMachineSecret();
-        this.ensureStorageDir();
-    }
-    getMachineSecret() {
-        // Combine hostname and user info for a basic machine-specific secret
-        return `${os.hostname()}-${os.userInfo().uid}-gitcli-secret-key-v1`;
     }
     async ensureStorageDir() {
         try {
@@ -24,21 +18,48 @@ export class FileSecureStorageAdapter {
             await fs.mkdir(this.storageDir, { recursive: true });
         }
     }
+    async getSecretKey() {
+        if (this.secretKey) {
+            return this.secretKey;
+        }
+        await this.ensureStorageDir();
+        const keyPath = path.join(this.storageDir, 'key.bin');
+        try {
+            const storedKey = await fs.readFile(keyPath, 'utf8');
+            this.secretKey = storedKey.trim();
+        }
+        catch {
+            // Key doesn't exist, generate a secure random 256-bit (32 bytes) key in hex
+            const randomKey = crypto.randomBytes(32).toString('hex');
+            await fs.writeFile(keyPath, randomKey, 'utf8');
+            try {
+                // Set permissions to 0o600 (owner read/write) for security on UNIX-like OS
+                await fs.chmod(keyPath, 0o600);
+            }
+            catch {
+                // Chmod might fail on Windows, ignore it
+            }
+            this.secretKey = randomKey;
+        }
+        return this.secretKey;
+    }
     getFilePath(key) {
         // Sanitize key for filename
         const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
         return path.join(this.storageDir, `${safeKey}.enc`);
     }
     async save(key, value) {
-        const encrypted = CryptoJS.AES.encrypt(value, this.secretKey).toString();
+        const secretKey = await this.getSecretKey();
+        const encrypted = CryptoJS.AES.encrypt(value, secretKey).toString();
         const filePath = this.getFilePath(key);
         await fs.writeFile(filePath, encrypted, 'utf8');
     }
     async load(key) {
         const filePath = this.getFilePath(key);
         try {
+            const secretKey = await this.getSecretKey();
             const encrypted = await fs.readFile(filePath, 'utf8');
-            const bytes = CryptoJS.AES.decrypt(encrypted, this.secretKey);
+            const bytes = CryptoJS.AES.decrypt(encrypted, secretKey);
             return bytes.toString(CryptoJS.enc.Utf8);
         }
         catch {

package/dist/adapters/ui/ConsoleUIAdapter.js

@@ -1,4 +1,4 @@
-import { select, input, checkbox, confirm } from '@inquirer/prompts';
+import { select, input, checkbox, confirm, Separator } from '@inquirer/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 const c = {
@@ -59,13 +59,25 @@ export class ConsoleUIAdapter {
         this.separator();
     }
     select(message, choices) {
-        return select({ message, choices });
+        const mappedChoices = choices.map(choice => {
+            if (choice.disabled === true && (choice.name.includes('──') || String(choice.value).startsWith('sep'))) {
+                return new Separator(choice.name);
+            }
+            return choice;
+        });
+        return select({ message, choices: mappedChoices, pageSize: 25 });
     }
     input(message, options) {
         return input({ message, ...options });
     }
     checkbox(message, choices) {
-        return checkbox({ message, choices });
+        const mappedChoices = choices.map(choice => {
+            if (choice.disabled === true && (choice.name.includes('──') || String(choice.value).startsWith('sep'))) {
+                return new Separator(choice.name);
+            }
+            return choice;
+        });
+        return checkbox({ message, choices: mappedChoices, pageSize: 25 });
     }
     confirm(message, defaultVal = true) {
         return confirm({ message, default: defaultVal });

package/dist/{factories → commands}/CommandFactory.js

@@ -1,14 +1,15 @@
 import { GitHubService } from '../core/services/GitHubService.js';
-import { StatusCommand } from '../commands/StatusCommand.js';
-import { LogCommand } from '../commands/LogCommand.js';
-import { CommitCommand } from '../commands/CommitCommand.js';
-import { PushCommand } from '../commands/PushCommand.js';
-import { PullCommand } from '../commands/PullCommand.js';
-import { BranchesCommand } from '../commands/BranchesCommand.js';
-import { IntegrationCommand } from '../commands/IntegrationCommand.js';
-import { StashCommand } from '../commands/StashCommand.js';
-import { RepositoryCommand } from '../commands/RepositoryCommand.js';
-import { GitHubMenuCommand } from '../commands/github/GitHubMenuCommand.js';
+import { StatusCommand } from './StatusCommand.js';
+import { LogCommand } from './LogCommand.js';
+import { CommitCommand } from './CommitCommand.js';
+import { PushCommand } from './PushCommand.js';
+import { PullCommand } from './PullCommand.js';
+import { BranchesCommand } from './BranchesCommand.js';
+import { IntegrationCommand } from './IntegrationCommand.js';
+import { StashCommand } from './StashCommand.js';
+import { RepositoryCommand } from './RepositoryCommand.js';
+import { GitHubMenuCommand } from './github/GitHubMenuCommand.js';
+import { DiffCommand } from './DiffCommand.js';
 export class CommandFactory {
     gitPort;
     uiPort;
@@ -28,6 +29,8 @@ export class CommandFactory {
                 return new StatusCommand(this.gitPort, this.uiPort);
             case 'log':
                 return new LogCommand(this.gitPort, this.uiPort);
+            case 'diff':
+                return new DiffCommand(this.gitPort, this.uiPort);
             case 'commit':
                 return new CommitCommand(this.gitPort, this.uiPort);
             case 'push':

package/dist/commands/CommitCommand.js

@@ -49,24 +49,87 @@ export class CommitCommand extends BaseCommand {
             }
             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 tipo = await this.uiPort.select('¿Qué tipo de cambio realizaste?', [
+                { name: '🆕 Nueva característica o funcionalidad (feat)', value: 'feat' },
+                { name: '🐛 Corrección de un fallo o error (fix)', value: 'fix' },
+                { name: '📝 Documentación, guías o textos (docs)', value: 'docs' },
+                { name: '🎨 Diseño, apariencia, estilos o formato (style)', value: 'style' },
+                { name: '⚡ Refactorización o mejora de código existente (refactor)', value: 'refactor' },
+                { name: '🧪 Pruebas unitarias o tests (test)', value: 'test' },
+                { name: '⚙️ Tareas internas o mantenimiento (chore)', value: 'chore' },
+                { name: '📦 Dependencias o configuración del build (build)', value: 'build' },
+                { name: '🚀 Automatización o Integración Continua (ci)', value: 'ci' },
+                { name: '✏️ Ninguno (escribir un mensaje libre sin formato)', 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();
+            let mensaje = '';
+            if (!tipo) {
+                // Free message commit
+                const mensajeLibre = await this.uiPort.input('Escribe el mensaje para tu commit:', {
+                    validate: (v) => v.trim().length > 0 || 'El mensaje no puede estar vacío.',
+                });
+                mensaje = mensajeLibre.trim();
+            }
+            else {
+                // Conventional Commit Walkthrough
+                const ambitoInput = await this.uiPort.input('¿A qué parte del proyecto afecta principalmente? (opcional. Ej: interfaz, login, base-de-datos):');
+                const ambito = ambitoInput.trim();
+                const descripcion = await this.uiPort.input('Resumen corto de lo que hiciste (ej: corregir diseño de botón):', {
+                    validate: (v) => v.trim().length > 0 || 'La descripción no puede estar vacía.',
+                });
+                const mostrarOpcionesAvanzadas = await this.uiPort.confirm('¿Deseas agregar información avanzada? (como explicación larga o cambios importantes)', false);
+                let cuerpo = '';
+                let introduceBreaking = false;
+                let breakingDesc = '';
+                let cierraIssue = false;
+                let issueId = '';
+                if (mostrarOpcionesAvanzadas) {
+                    const agregarCuerpo = await this.uiPort.confirm('¿Deseas agregar una explicación más larga y detallada?', false);
+                    if (agregarCuerpo) {
+                        cuerpo = await this.uiPort.input('Escribe la explicación detallada del cambio:');
+                    }
+                    introduceBreaking = await this.uiPort.confirm('¿Este cambio rompe la compatibilidad con versiones anteriores? (Breaking Change)', false);
+                    if (introduceBreaking) {
+                        breakingDesc = await this.uiPort.input('Describe el cambio importante que rompe la compatibilidad (BREAKING CHANGE):', {
+                            validate: (v) => v.trim().length > 0 || 'Debes describir el cambio de ruptura.',
+                        });
+                    }
+                    cierraIssue = await this.uiPort.confirm('¿Este cambio cierra algún issue o tarea en GitHub?', false);
+                    if (cierraIssue) {
+                        issueId = await this.uiPort.input('Número o ID de la tarea/issue (ej: #123):', {
+                            validate: (v) => v.trim().length > 0 || 'Debes ingresar el número de issue.',
+                        });
+                    }
+                }
+                // Message Construction
+                let header = tipo;
+                if (ambito) {
+                    header += `(${ambito})`;
+                }
+                if (introduceBreaking) {
+                    header += '!';
+                }
+                header += `: ${descripcion.trim()}`;
+                mensaje = header;
+                if (cuerpo && cuerpo.trim()) {
+                    mensaje += `\n\n${cuerpo.trim()}`;
+                }
+                const footers = [];
+                if (introduceBreaking && breakingDesc.trim()) {
+                    footers.push(`BREAKING CHANGE: ${breakingDesc.trim()}`);
+                }
+                if (cierraIssue && issueId.trim()) {
+                    const formattedIssue = issueId.trim().startsWith('#') ? issueId.trim() : `#${issueId.trim()}`;
+                    footers.push(`Closes ${formattedIssue}`);
+                }
+                if (footers.length > 0) {
+                    mensaje += `\n\n${footers.join('\n')}`;
+                }
+            }
             this.uiPort.separator();
-            this.uiPort.log(c.titulo('  Commit: ') + c.info(`"${mensaje}"`));
+            this.uiPort.log(c.titulo('  Commit Propuesto:\n'));
+            mensaje.split('\n').forEach((line) => {
+                this.uiPort.log(`  ${c.info(line)}`);
+            });
             this.uiPort.separator();
             const confirmar = await this.uiPort.confirm('¿Confirmar commit?', true);
             if (!confirmar) {
@@ -76,7 +139,7 @@ export class CommitCommand extends BaseCommand {
             const spinCommit = this.uiPort.spinner('Realizando commit...');
             await this.gitPort.commit(mensaje);
             spinCommit.stop();
-            this.uiPort.success(`\n  ✓ Commit realizado: "${mensaje}"\n`);
+            this.uiPort.success(`\n  ✓ Commit realizado con éxito.\n`);
         }
         catch (err) {
             this.uiPort.error(`  ✗ Error: ${err.message}`);

package/dist/commands/DiffCommand.js

@@ -0,0 +1,60 @@
+import { BaseCommand } from './BaseCommand.js';
+export class DiffCommand 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 tipoDiff = await this.uiPort.select('¿Qué diferencias deseas ver?', [
+                { name: '📂  Cambios en el área de trabajo (sin stagear)', value: 'working' },
+                { name: '✅  Cambios preparados para commit (staged)', value: 'staged' },
+                { name: '🚪  Volver', value: 'volver' },
+            ]);
+            if (tipoDiff === 'volver') {
+                return;
+            }
+            const options = [];
+            if (tipoDiff === 'staged') {
+                options.push('--staged');
+            }
+            const spin = this.uiPort.spinner('Obteniendo diferencias...');
+            const diffText = await this.gitPort.diff(options);
+            spin.stop();
+            const c = this.uiColors;
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  🔍 Diferencias del repositorio'));
+            this.uiPort.separator();
+            if (!diffText || diffText.trim().length === 0) {
+                this.uiPort.log(c.tenue('  No se encontraron diferencias en esta sección.'));
+                this.uiPort.separator();
+                this.uiPort.log('');
+                return;
+            }
+            const lines = diffText.split('\n');
+            lines.forEach((line) => {
+                if (line.startsWith('+') && !line.startsWith('+++')) {
+                    this.uiPort.log(c.exito(line));
+                }
+                else if (line.startsWith('-') && !line.startsWith('---')) {
+                    this.uiPort.log(c.error(line));
+                }
+                else if (line.startsWith('@@')) {
+                    this.uiPort.log(c.info(line));
+                }
+                else if (line.startsWith('diff')) {
+                    this.uiPort.log(c.titulo(line));
+                }
+                else {
+                    this.uiPort.log(line);
+                }
+            });
+            this.uiPort.separator();
+            this.uiPort.log('');
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error al obtener diff: ${err.message}`);
+        }
+    }
+}

package/dist/commands/LogCommand.js

@@ -12,28 +12,98 @@ export class LogCommand extends BaseCommand {
                 { 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',
+            let verDetalle = true;
+            while (verDetalle) {
+                const spin = this.uiPort.spinner('Cargando historial...');
+                const log = await this.gitPort.getLog(cantidad);
+                spin.stop();
+                this.uiPort.clear();
+                this.uiPort.showBanner();
+                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.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('');
+                this.uiPort.separator();
+                this.uiPort.log('');
+                const opcion = await this.uiPort.select('¿Qué deseas hacer?', [
+                    { name: '🔍  Inspeccionar un commit (ver detalle y diff)', value: 'inspeccionar' },
+                    { name: '🌿  Checkout temporal a un commit', value: 'checkout' },
+                    { name: '🚪  Volver al menú principal', value: 'salir' },
+                ]);
+                if (opcion === 'salir') {
+                    verDetalle = false;
+                }
+                else if (opcion === 'inspeccionar') {
+                    const choices = log.all.map((commit) => ({
+                        name: `${commit.hash.slice(0, 7)} - ${commit.message.slice(0, 50)}`,
+                        value: commit.hash,
+                    }));
+                    choices.push({ name: '🚪 Volver', value: 'volver' });
+                    const commitHash = await this.uiPort.select('Selecciona un commit para ver su detalle:', choices);
+                    if (commitHash !== 'volver') {
+                        const spinShow = this.uiPort.spinner('Obteniendo detalles del commit...');
+                        const commitDetailText = await this.gitPort.show([commitHash]);
+                        spinShow.stop();
+                        this.uiPort.clear();
+                        this.uiPort.showBanner();
+                        this.uiPort.log(c.titulo(`  🔍 Detalles del Commit: ${commitHash.slice(0, 7)}`));
+                        this.uiPort.separator();
+                        const lines = commitDetailText.split('\n');
+                        lines.forEach((line) => {
+                            if (line.startsWith('+') && !line.startsWith('+++')) {
+                                this.uiPort.log(c.exito(line));
+                            }
+                            else if (line.startsWith('-') && !line.startsWith('---')) {
+                                this.uiPort.log(c.error(line));
+                            }
+                            else if (line.startsWith('@@')) {
+                                this.uiPort.log(c.info(line));
+                            }
+                            else if (line.startsWith('diff') || line.startsWith('commit ')) {
+                                this.uiPort.log(c.titulo(line));
+                            }
+                            else {
+                                this.uiPort.log(line);
+                            }
+                        });
+                        this.uiPort.separator();
+                        await this.uiPort.pause();
+                    }
+                }
+                else if (opcion === 'checkout') {
+                    const choices = log.all.map((commit) => ({
+                        name: `${commit.hash.slice(0, 7)} - ${commit.message.slice(0, 50)}`,
+                        value: commit.hash,
+                    }));
+                    choices.push({ name: '🚪 Volver', value: 'volver' });
+                    const commitHash = await this.uiPort.select('Selecciona el commit para checkout:', choices);
+                    if (commitHash !== 'volver') {
+                        this.uiPort.warning(`\n  ⚠️  Hacer checkout a un commit te dejará en estado 'Detached HEAD'.`);
+                        this.uiPort.warning(`  Para regresar, deberás hacer checkout a tu rama actual desde el menú de Ramas.\n`);
+                        const confirmar = await this.uiPort.confirm(`¿Quieres hacer checkout al commit ${commitHash.slice(0, 7)}?`, false);
+                        if (confirmar) {
+                            const spinCheck = this.uiPort.spinner(`Haciendo checkout a ${commitHash.slice(0, 7)}...`);
+                            await this.gitPort.checkout(commitHash);
+                            spinCheck.stop();
+                            this.uiPort.success(`\n  ✓ Ahora estás en el commit ${c.rama(commitHash.slice(0, 7))}.`);
+                            await this.uiPort.pause();
+                            verDetalle = false; // salir de la vista ya que el contexto (HEAD) cambió
+                        }
+                    }
+                }
+            }
         }
         catch (err) {
             this.uiPort.error(`  ✗ Error: ${err.message}`);

package/dist/commands/PushCommand.js

@@ -1,5 +1,4 @@
 import { BaseCommand } from './BaseCommand.js';
-import { simpleGit } from 'simple-git';
 import path from 'path';
 export class PushCommand extends BaseCommand {
     gitHubService;
@@ -176,14 +175,13 @@ export class PushCommand extends BaseCommand {
         // 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);
+            await this.gitPort.addRemote('origin', url);
             spinRemote.stop();
             this.uiPort.success(c.exito(`  ✓ Remoto origin agregado: ${url}`));
         }