@asaro/git-cli 1.0.0

package/README.md

@@ -0,0 +1,189 @@
+# Git CLI (@asaro/git-cli)
+
+Git CLI interactivo en español para gestionar repositorios Git y GitHub desde la terminal.
+
+## Características
+
+- 📋 Estado del repositorio, historial de commits
+- ✅ Commit, Push, Pull
+- 🌿 Gestión de ramas
+- 🔀 Merge y Rebase
+- 📦 Stash
+- 🆕 Repositorios (clone, init, remotos)
+- 🌐 Integración con GitHub
+  - Autenticación segura
+  - Crear y gestionar repositorios
+  - GitHub Actions
+- 🔐 Token encriptado guardado localmente
+
+## Instalación
+
+### Requisitos previos
+
+- Node.js (v18 o superior)
+- npm (v9 o superior)
+- Git instalado y configurado
+
+### Métodos de instalación
+
+#### 1. Instalación global desde npm (la forma más fácil!)
+
+Si el paquete está publicado en npm:
+
+```bash
+# Instálalo globalmente en tu PC
+npm install -g @itzasaro/git-cli
+
+# Ahora puedes usar el comando 'git-cli' desde cualquier lugar!
+git-cli
+```
+
+#### 2. Instalación desde el repositorio
+
+Si quieres instalarlo directamente desde el código fuente:
+
+```bash
+# Clona el repositorio
+git clone https://github.com/iTzAsaro/GitCLI.git
+cd gitcli
+
+# Instala dependencias y compila
+npm install
+npm run build
+
+# Instálalo globalmente
+npm install -g .
+
+# Ahora puedes usar el comando 'git-cli' desde cualquier lugar!
+git-cli
+```
+
+#### 3. Usar desde la carpeta del proyecto
+
+Si prefieres no instalarlo globalmente:
+
+```bash
+npm install
+npm run build
+npm start
+```
+
+---
+
+## Publicar tu paquete en npm
+
+Si quieres que otras personas puedan instalarlo con `npm install -g gitcli`, sigue estos pasos:
+
+### Paso 1: Crear una cuenta en npm
+
+1. Ve a [https://www.npmjs.com/signup](https://www.npmjs.com/signup)
+2. Crea tu cuenta y verifica tu email
+
+### Paso 2: Iniciar sesión en npm desde la terminal
+
+```bash
+npm login
+```
+
+Ingresa tu username, password y email de npm.
+
+### Paso 3: Actualizar datos del paquete
+
+Edita `package.json` y cambia:
+- `name`: Asegúrate de que el nombre esté disponible en npm
+- `author`: Tu nombre y email
+- `repository`: La URL de tu repo en GitHub
+- `homepage` y `bugs`: URLs de tu repo
+
+### Paso 4: Publicar!
+
+Como es un paquete con scope (`@iTzAsaro/`), necesitas publicar con acceso público:
+
+```bash
+npm publish --access public
+```
+
+¡Listo! Ahora cualquier persona puede instalar tu paquete con:
+
+```bash
+npm install -g @itzasaro/git-cli
+```
+
+### Para publicar una nueva versión
+
+Siempre que quieras publicar una actualización:
+
+1. Actualiza la versión en `package.json` (usa [Semantic Versioning](https://semver.org/))
+2. Ejecuta:
+   ```bash
+   npm publish --access public
+   ```
+
+---
+
+## Uso
+
+Ejecuta el comando y sigue las instrucciones en la terminal:
+
+```bash
+git-cli
+```
+
+## Configuración de GitHub
+
+1. Abre GitCLI
+2. Ve a **"🌐 Gestión GitHub"**
+3. Selecciona **"Autenticación (Login/Logout)"**
+4. Ingresa tu Personal Access Token de GitHub
+5. ¡Listo para usar todas las funcionalidades de GitHub!
+
+### Cómo crear un Personal Access Token:
+
+1. Ve a https://github.com/settings/tokens/new
+2. Selecciona los scopes:
+   - `repo` (para repositorios)
+   - `workflow` (para GitHub Actions)
+   - `delete_repo` (para borrar repositorios, opcional)
+3. Genera y copia el token
+
+## Funcionalidades
+
+### Menú principal
+
+- **📋 Estado del repositorio** - Ver el estado actual del repo
+- **📜 Ver historial (log)** - Ver commits y cambios
+- **✅ Commit** - Hacer commit de cambios
+- **↑ Push** - Subir cambios a remoto
+- **↓ Pull** - Bajar cambios de remoto
+- **🌿 Ramas** - Gestionar ramas
+- **🔀 Merge / Rebase** - Fusionar cambios
+- **📦 Stash** - Guardar cambios temporalmente
+- **🆕 Repositorio** - Clonar, init o gestionar remotos
+- **🌐 Gestión GitHub** - Gestionar GitHub
+- **🚪 Salir** - Cerrar la aplicación
+
+## Actualización
+
+Si instalaste globalmente y quieres actualizar:
+
+```bash
+cd gitcli
+git pull
+npm install
+npm run build
+npm install -g .
+```
+
+## Desinstalación
+
+```bash
+npm uninstall -g @itzasaro/git-cli
+```
+
+## Archivos de configuración
+
+- El token de GitHub se guarda encriptado en `~/.gitcli/`
+
+## Licencia
+
+ISC

package/dist/adapters/git/SimpleGitAdapter.js

@@ -0,0 +1,126 @@
+import { simpleGit } from 'simple-git';
+export class SimpleGitAdapter {
+    git;
+    constructor(cwd) {
+        this.git = simpleGit(cwd || process.cwd());
+    }
+    async isRepository() {
+        try {
+            await this.git.revparse(['--git-dir']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getStatus() {
+        return this.git.status();
+    }
+    getLog(maxCount = 10) {
+        return this.git.log({ maxCount });
+    }
+    getBranches() {
+        return this.git.branch(['-a']);
+    }
+    getRemotes() {
+        return this.git.getRemotes(true);
+    }
+    async add(files) {
+        await this.git.add(files);
+    }
+    async commit(message) {
+        await this.git.commit(message);
+    }
+    async push(remote, branch, options) {
+        if (options && options.length > 0) {
+            await this.git.push(options);
+        }
+        else if (remote && branch) {
+            await this.git.push(remote, branch);
+        }
+        else {
+            await this.git.push();
+        }
+    }
+    async pull(remote, branch, options) {
+        if (remote && branch) {
+            await this.git.pull(remote, branch, options);
+        }
+        else {
+            await this.git.pull(options);
+        }
+    }
+    async checkout(branch) {
+        await this.git.checkout(branch);
+    }
+    async checkoutLocalBranch(branch) {
+        await this.git.checkoutLocalBranch(branch);
+    }
+    async createBranch(branch) {
+        await this.git.branch([branch]);
+    }
+    async deleteBranch(branch, force = false) {
+        await this.git.deleteLocalBranch(branch, force);
+    }
+    async renameBranch(oldName, newName) {
+        await this.git.branch(['-m', oldName, newName]);
+    }
+    async merge(branch, options) {
+        if (options) {
+            await this.git.merge([branch, ...options]);
+        }
+        else {
+            await this.git.merge([branch]);
+        }
+    }
+    async rebase(branch) {
+        await this.git.rebase([branch]);
+    }
+    async abortMerge() {
+        await this.git.merge(['--abort']);
+    }
+    async abortRebase() {
+        await this.git.rebase(['--abort']);
+    }
+    async stashPush(message, includeUntracked = false) {
+        const args = ['push'];
+        if (message)
+            args.push('-m', message);
+        if (includeUntracked)
+            args.push('--include-untracked');
+        await this.git.stash(args);
+    }
+    stashList() {
+        return this.git.stashList();
+    }
+    async stashApply(stashId) {
+        await this.git.stash(['apply', stashId]);
+    }
+    async stashPop(stashId) {
+        await this.git.stash(['pop', stashId]);
+    }
+    async stashDrop(stashId) {
+        await this.git.stash(['drop', stashId]);
+    }
+    async stashClear() {
+        await this.git.stash(['clear']);
+    }
+    async clone(url, destination, options) {
+        await this.git.clone(url, destination, options);
+    }
+    async init(destination, initialBranch = 'main') {
+        if (destination) {
+            const git = simpleGit(destination);
+            await git.init({ '--initial-branch': initialBranch });
+        }
+        else {
+            await this.git.init({ '--initial-branch': initialBranch });
+        }
+    }
+    async addRemote(name, url) {
+        await this.git.addRemote(name, url);
+    }
+    getGitInstance() {
+        return this.git;
+    }
+}

package/dist/adapters/github/GitHubAPIAdapter.js

@@ -0,0 +1,243 @@
+import { Octokit } from 'octokit';
+import { GitHubAuthError, GitHubRateLimitError, GitHubPermissionError, GitHubNotFoundError, GitHubError, } from '../../core/errors/GitHubError.js';
+export class GitHubAPIAdapter {
+    octokit = null;
+    async authenticate(token) {
+        this.octokit = new Octokit({ auth: token });
+    }
+    async validateToken() {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        await this.octokit.rest.users.getAuthenticated();
+        return true;
+    }
+    async getCurrentUser() {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        const { data } = await this.octokit.rest.users.getAuthenticated();
+        return { login: data.login, name: data.name };
+    }
+    async listRepos(filters) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        const { data } = await this.octokit.rest.repos.listForAuthenticatedUser({
+            visibility: filters?.visibility === 'all' ? undefined : filters?.visibility,
+            sort: 'updated',
+            per_page: 100,
+        });
+        let repos = data.map((repo) => ({
+            id: repo.id,
+            name: repo.name,
+            fullName: repo.full_name,
+            description: repo.description,
+            visibility: repo.visibility,
+            htmlUrl: repo.html_url,
+            cloneUrl: repo.clone_url,
+            sshUrl: repo.ssh_url,
+            stars: repo.stargazers_count,
+            language: repo.language,
+            updatedAt: repo.updated_at,
+            archived: repo.archived,
+        }));
+        // Apply client-side filters
+        if (filters?.language) {
+            repos = repos.filter((r) => r.language?.toLowerCase() === filters.language.toLowerCase());
+        }
+        if (filters?.since) {
+            const sinceDate = new Date(filters.since);
+            repos = repos.filter((r) => r.updatedAt && new Date(r.updatedAt) >= sinceDate);
+        }
+        return repos;
+    }
+    async getRepo(owner, repo) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            const { data } = await this.octokit.rest.repos.get({ owner, repo });
+            return {
+                id: data.id,
+                name: data.name,
+                fullName: data.full_name,
+                description: data.description,
+                visibility: data.visibility,
+                htmlUrl: data.html_url,
+                cloneUrl: data.clone_url,
+                sshUrl: data.ssh_url,
+                stars: data.stargazers_count,
+                language: data.language,
+                updatedAt: data.updated_at,
+                archived: data.archived,
+            };
+        }
+        catch (err) {
+            this.handleError(err, 'Repositorio');
+        }
+    }
+    async createRepo(options) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            const { data } = await this.octokit.rest.repos.createForAuthenticatedUser({
+                name: options.name,
+                description: options.description,
+                private: options.visibility === 'private',
+                auto_init: options.autoInit,
+                gitignore_template: options.gitignoreTemplate,
+                license_template: options.licenseTemplate,
+            });
+            return {
+                id: data.id,
+                name: data.name,
+                fullName: data.full_name,
+                description: data.description,
+                visibility: data.visibility,
+                htmlUrl: data.html_url,
+                cloneUrl: data.clone_url,
+                sshUrl: data.ssh_url,
+                stars: data.stargazers_count,
+                language: data.language,
+                updatedAt: data.updated_at,
+                archived: data.archived,
+            };
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    async archiveRepo(owner, repo) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.repos.update({ owner, repo, archived: true });
+        }
+        catch (err) {
+            this.handleError(err, 'Repositorio');
+        }
+    }
+    async unarchiveRepo(owner, repo) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.repos.update({ owner, repo, archived: false });
+        }
+        catch (err) {
+            this.handleError(err, 'Repositorio');
+        }
+    }
+    async deleteRepo(owner, repo) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.repos.delete({ owner, repo });
+        }
+        catch (err) {
+            this.handleError(err, 'Repositorio');
+        }
+    }
+    async listWorkflows(owner, repo) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            const { data } = await this.octokit.rest.actions.listRepoWorkflows({ owner, repo });
+            return data.workflows.map((w) => ({
+                id: w.id,
+                name: w.name,
+                path: w.path,
+                state: w.state,
+                createdAt: w.created_at,
+                updatedAt: w.updated_at,
+                htmlUrl: w.html_url,
+            }));
+        }
+        catch (err) {
+            this.handleError(err, 'Workflows');
+        }
+    }
+    async listWorkflowRuns(owner, repo, filters) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            const params = { owner, repo, per_page: 50 };
+            if (filters?.status)
+                params.status = filters.status;
+            if (filters?.branch)
+                params.branch = filters.branch;
+            if (filters?.since)
+                params.created = `>=${filters.since}`;
+            const { data } = await this.octokit.rest.actions.listWorkflowRunsForRepo(params);
+            return data.workflow_runs.map((r) => ({
+                id: r.id,
+                name: r.name,
+                status: r.status,
+                conclusion: r.conclusion,
+                headBranch: r.head_branch,
+                headSha: r.head_sha,
+                createdAt: r.created_at,
+                updatedAt: r.updated_at,
+                htmlUrl: r.html_url,
+                actor: r.actor ? { login: r.actor.login } : null,
+            }));
+        }
+        catch (err) {
+            this.handleError(err, 'Runs de workflow');
+        }
+    }
+    async enableWorkflow(owner, repo, workflowId) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.actions.enableWorkflow({ owner, repo, workflow_id: workflowId });
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    async disableWorkflow(owner, repo, workflowId) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.actions.disableWorkflow({ owner, repo, workflow_id: workflowId });
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    async triggerWorkflowDispatch(owner, repo, workflowId, ref, inputs) {
+        if (!this.octokit)
+            throw new GitHubAuthError('No hay token configurado');
+        try {
+            await this.octokit.rest.actions.createWorkflowDispatch({
+                owner,
+                repo,
+                workflow_id: workflowId,
+                ref,
+                inputs,
+            });
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    handleError(err, resourceName) {
+        if (err instanceof Error) {
+            // Check if it's an Octokit error
+            const octokitErr = err;
+            if (octokitErr.status) {
+                switch (octokitErr.status) {
+                    case 401:
+                    case 403:
+                        if (octokitErr.message?.includes('rate limit')) {
+                            const resetTime = octokitErr.response?.headers?.['x-ratelimit-reset'];
+                            throw new GitHubRateLimitError(resetTime ? parseInt(resetTime) : undefined);
+                        }
+                        throw new GitHubPermissionError();
+                    case 404:
+                        throw new GitHubNotFoundError(resourceName);
+                    default:
+                        throw new GitHubError(`Error de GitHub (${octokitErr.status}): ${octokitErr.message}`);
+                }
+            }
+        }
+        throw new GitHubError(err.message || 'Error desconocido de GitHub');
+    }
+}

package/dist/adapters/storage/FileSecureStorageAdapter.js

@@ -0,0 +1,67 @@
+import CryptoJS from 'crypto-js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+export class FileSecureStorageAdapter {
+    storageDir;
+    secretKey;
+    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 {
+            await fs.access(this.storageDir);
+        }
+        catch {
+            await fs.mkdir(this.storageDir, { recursive: true });
+        }
+    }
+    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 filePath = this.getFilePath(key);
+        await fs.writeFile(filePath, encrypted, 'utf8');
+    }
+    async load(key) {
+        const filePath = this.getFilePath(key);
+        try {
+            const encrypted = await fs.readFile(filePath, 'utf8');
+            const bytes = CryptoJS.AES.decrypt(encrypted, this.secretKey);
+            return bytes.toString(CryptoJS.enc.Utf8);
+        }
+        catch {
+            return null;
+        }
+    }
+    async delete(key) {
+        const filePath = this.getFilePath(key);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch {
+            // Ignore if file doesn't exist
+        }
+    }
+    async exists(key) {
+        const filePath = this.getFilePath(key);
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}