@asaro/git-cli 1.0.0

package/dist/commit.js

@@ -0,0 +1,98 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { checkbox, input, select, confirm } from "@inquirer/prompts";
+// ── Commit guiado (add + commit) ─────────────────────────────────────────────
+export async function hacerCommit() {
+    if (!(await verificarRepo()))
+        return;
+    const spin = spinner("Leyendo estado del repositorio...");
+    const status = await git.status();
+    spin.stop();
+    // Armar lista de archivos disponibles para stagear
+    const disponibles = [
+        ...status.modified.map(f => ({ name: c.aviso(`  ~ ${f}`) + c.tenue("  (modificado)"), value: f })),
+        ...status.not_added.map(f => ({ name: c.tenue(`  ? ${f}`) + c.tenue("  (nuevo)"), value: f })),
+        ...status.deleted.map(f => ({ name: c.error(`  - ${f}`) + c.tenue("  (eliminado)"), value: f })),
+    ];
+    // Si ya hay staged, ofrecer usarlos o agregar más
+    let archivosParaStage = [];
+    if (status.staged.length > 0) {
+        console.log();
+        console.log(c.info("  Ya tienes archivos preparados (staged):"));
+        status.staged.forEach(f => console.log(c.exito(`    + ${f}`)));
+        console.log();
+        const usarExistentes = await confirm({
+            message: "¿Usar los archivos ya preparados sin agregar más?",
+            default: true,
+        });
+        if (!usarExistentes && disponibles.length > 0) {
+            archivosParaStage = await checkbox({
+                message: "Selecciona archivos adicionales para incluir:",
+                choices: disponibles,
+            });
+        }
+    }
+    else {
+        if (disponibles.length === 0) {
+            console.log(c.aviso("\n  No hay cambios para hacer commit.\n"));
+            return;
+        }
+        // Opción de agregar todo o seleccionar
+        const modo = await select({
+            message: "¿Qué archivos incluir en el commit?",
+            choices: [
+                { name: "Todos los cambios  (git add .)", value: "todos" },
+                { name: "Seleccionar manualmente", value: "manual" },
+            ],
+        });
+        if (modo === "todos") {
+            archivosParaStage = ["."];
+        }
+        else {
+            archivosParaStage = await checkbox({
+                message: "Selecciona los archivos (espacio para marcar):",
+                choices: disponibles,
+                validate: (val) => val.length > 0 || "Debes seleccionar al menos uno.",
+            });
+        }
+        const spinAdd = spinner("Agregando archivos...");
+        await git.add(archivosParaStage);
+        spinAdd.stop();
+        console.log(c.exito("  ✓ Archivos agregados al stage"));
+    }
+    // Mensaje de commit
+    console.log();
+    separador();
+    const tipo = await select({
+        message: "Tipo de commit:",
+        choices: [
+            { name: "feat     · Nueva funcionalidad", value: "feat" },
+            { name: "fix      · Corrección de bug", value: "fix" },
+            { name: "docs     · Documentación", value: "docs" },
+            { name: "style    · Estilos / formato", value: "style" },
+            { name: "refactor · Refactorización", value: "refactor" },
+            { name: "test     · Tests", value: "test" },
+            { name: "chore    · Tareas de mantenimiento", value: "chore" },
+            { name: "build    · Sistema de build", value: "build" },
+            { name: "ci       · CI/CD", value: "ci" },
+            { name: "Ninguno  · Mensaje libre", value: "" },
+        ],
+    });
+    const descripcion = await input({
+        message: "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();
+    // Confirmar
+    separador();
+    console.log(c.titulo(`  Commit: `) + c.info(`"${mensaje}"`));
+    separador();
+    const confirmar = await confirm({ message: "¿Confirmar commit?", default: true });
+    if (!confirmar) {
+        console.log(c.aviso("  Commit cancelado.\n"));
+        return;
+    }
+    const spinCommit = spinner("Realizando commit...");
+    await git.commit(mensaje);
+    spinCommit.stop();
+    console.log(c.exito(`\n  ✓ Commit realizado: "${mensaje}"\n`));
+}

package/dist/core/errors/GitError.js

@@ -0,0 +1,19 @@
+export class GitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitError';
+        Object.setPrototypeOf(this, GitError.prototype);
+    }
+}
+export class NotARepositoryError extends GitError {
+    constructor() {
+        super('Este directorio no es un repositorio Git');
+        this.name = 'NotARepositoryError';
+    }
+}
+export class NoChangesError extends GitError {
+    constructor() {
+        super('No hay cambios para realizar');
+        this.name = 'NoChangesError';
+    }
+}

package/dist/core/errors/GitHubError.js

@@ -0,0 +1,36 @@
+export class GitHubError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubError';
+        Object.setPrototypeOf(this, GitHubError.prototype);
+    }
+}
+export class GitHubAuthError extends GitHubError {
+    constructor(message = 'Token de GitHub inválido o expirado') {
+        super(message);
+        this.name = 'GitHubAuthError';
+    }
+}
+export class GitHubRateLimitError extends GitHubError {
+    constructor(resetTime) {
+        let message = 'Límite de tasa de GitHub excedido';
+        if (resetTime) {
+            const resetDate = new Date(resetTime * 1000);
+            message += `. Se restablecerá en ${resetDate.toLocaleString('es-CL')}`;
+        }
+        super(message);
+        this.name = 'GitHubRateLimitError';
+    }
+}
+export class GitHubPermissionError extends GitHubError {
+    constructor(message = 'No tienes permisos para realizar esta operación') {
+        super(message);
+        this.name = 'GitHubPermissionError';
+    }
+}
+export class GitHubNotFoundError extends GitHubError {
+    constructor(resource = 'Recurso') {
+        super(`${resource} no encontrado`);
+        this.name = 'GitHubNotFoundError';
+    }
+}

package/dist/core/ports/GitHubPort.js

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

package/dist/core/ports/GitPort.js

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

package/dist/core/ports/SecureStoragePort.js

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

package/dist/core/ports/UIPort.js

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

package/dist/core/services/GitHubService.js

@@ -0,0 +1,95 @@
+import { GitHubAuthError } from '../errors/GitHubError.js';
+const TOKEN_KEY = 'github_pat';
+export class GitHubService {
+    gitHubPort;
+    storage;
+    currentUser = null;
+    constructor(gitHubPort, storage) {
+        this.gitHubPort = gitHubPort;
+        this.storage = storage;
+    }
+    async isAuthenticated() {
+        const tokenExists = await this.storage.exists(TOKEN_KEY);
+        if (!tokenExists)
+            return false;
+        try {
+            await this.loadAndAuthenticate();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async login(token) {
+        await this.gitHubPort.authenticate(token);
+        await this.gitHubPort.validateToken();
+        await this.storage.save(TOKEN_KEY, token);
+        this.currentUser = await this.gitHubPort.getCurrentUser();
+    }
+    async logout() {
+        await this.storage.delete(TOKEN_KEY);
+        this.currentUser = null;
+    }
+    async getCurrentUser() {
+        if (!this.currentUser) {
+            await this.loadAndAuthenticate();
+        }
+        return this.currentUser;
+    }
+    async loadAndAuthenticate() {
+        const token = await this.storage.load(TOKEN_KEY);
+        if (!token)
+            throw new GitHubAuthError('No hay token guardado');
+        this.gitHubPort.authenticate(token);
+        this.currentUser = await this.gitHubPort.getCurrentUser();
+    }
+    async listRepos(filters) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.listRepos(filters);
+    }
+    async getRepo(owner, repo) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.getRepo(owner, repo);
+    }
+    async createRepo(options) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.createRepo(options);
+    }
+    async archiveRepo(owner, repo) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.archiveRepo(owner, repo);
+    }
+    async unarchiveRepo(owner, repo) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.unarchiveRepo(owner, repo);
+    }
+    async deleteRepo(owner, repo) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.deleteRepo(owner, repo);
+    }
+    async listWorkflows(owner, repo) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.listWorkflows(owner, repo);
+    }
+    async listWorkflowRuns(owner, repo, filters) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.listWorkflowRuns(owner, repo, filters);
+    }
+    async enableWorkflow(owner, repo, workflowId) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.enableWorkflow(owner, repo, workflowId);
+    }
+    async disableWorkflow(owner, repo, workflowId) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.disableWorkflow(owner, repo, workflowId);
+    }
+    async triggerWorkflowDispatch(owner, repo, workflowId, ref, inputs) {
+        await this.ensureAuthenticated();
+        return this.gitHubPort.triggerWorkflowDispatch(owner, repo, workflowId, ref, inputs);
+    }
+    async ensureAuthenticated() {
+        if (!this.currentUser) {
+            await this.loadAndAuthenticate();
+        }
+    }
+}

package/dist/core/services/GitService.js

@@ -0,0 +1,44 @@
+import { NotARepositoryError } from '../errors/GitError.js';
+export class GitService {
+    gitPort;
+    constructor(gitPort) {
+        this.gitPort = gitPort;
+    }
+    async ensureIsRepository() {
+        const isRepo = await this.gitPort.isRepository();
+        if (!isRepo) {
+            throw new NotARepositoryError();
+        }
+    }
+    async getStatus() {
+        await this.ensureIsRepository();
+        return this.gitPort.getStatus();
+    }
+    async getLog(maxCount = 10) {
+        await this.ensureIsRepository();
+        return this.gitPort.getLog(maxCount);
+    }
+    async getBranches() {
+        await this.ensureIsRepository();
+        return this.gitPort.getBranches();
+    }
+    async commitChanges(files, message) {
+        await this.ensureIsRepository();
+        if (files.length > 0) {
+            await this.gitPort.add(files);
+        }
+        await this.gitPort.commit(message);
+    }
+    async push(remote = 'origin', branch, options) {
+        await this.ensureIsRepository();
+        await this.gitPort.push(remote, branch, options);
+    }
+    async pull(remote = 'origin', branch, useRebase = false) {
+        await this.ensureIsRepository();
+        await this.gitPort.pull(remote, branch, useRebase ? { '--rebase': 'true' } : undefined);
+    }
+    async getStashList() {
+        await this.ensureIsRepository();
+        return this.gitPort.stashList();
+    }
+}

package/dist/estado.js

@@ -0,0 +1,97 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { select } from "@inquirer/prompts";
+// ── Status detallado ─────────────────────────────────────────────────────────
+export async function mostrarStatus() {
+    if (!(await verificarRepo()))
+        return;
+    const spin = spinner("Obteniendo estado del repositorio...");
+    const status = await git.status();
+    spin.stop();
+    const rama = status.current ?? "desconocida";
+    console.log();
+    console.log(c.titulo("  📋 Estado del repositorio"));
+    separador();
+    console.log(`  Rama actual: ${c.rama(rama)}`);
+    // Indicador de sincronía con remoto
+    if (status.ahead > 0 && status.behind > 0) {
+        console.log(c.aviso(`  ⚡ ${status.ahead} commit(s) adelante y ${status.behind} atrás del remoto`));
+    }
+    else if (status.ahead > 0) {
+        console.log(c.aviso(`  ↑  ${status.ahead} commit(s) por subir`));
+    }
+    else if (status.behind > 0) {
+        console.log(c.aviso(`  ↓  ${status.behind} commit(s) por bajar`));
+    }
+    else {
+        console.log(c.exito("  ✓  Sincronizado con el remoto"));
+    }
+    separador();
+    // Archivos staged
+    if (status.staged.length > 0) {
+        console.log(c.exito("  Preparados para commit (staged):"));
+        status.staged.forEach(f => console.log(c.exito(`    + ${f}`)));
+    }
+    // Modificados sin stagear
+    if (status.modified.length > 0) {
+        console.log(c.aviso("  Modificados (sin stagear):"));
+        status.modified.forEach(f => console.log(c.aviso(`    ~ ${f}`)));
+    }
+    // Sin seguimiento
+    if (status.not_added.length > 0) {
+        console.log(c.tenue("  Sin seguimiento (untracked):"));
+        status.not_added.forEach(f => console.log(c.tenue(`    ? ${f}`)));
+    }
+    // Eliminados
+    if (status.deleted.length > 0) {
+        console.log(c.error("  Eliminados:"));
+        status.deleted.forEach(f => console.log(c.error(`    - ${f}`)));
+    }
+    // Conflictos
+    if (status.conflicted.length > 0) {
+        console.log(c.error("  Con conflictos:"));
+        status.conflicted.forEach(f => console.log(c.error(`    ✗ ${f}`)));
+    }
+    const total = status.staged.length +
+        status.modified.length +
+        status.not_added.length +
+        status.deleted.length;
+    if (total === 0) {
+        console.log(c.tenue("  Árbol de trabajo limpio."));
+    }
+    separador();
+    console.log();
+}
+// ── Log visual ───────────────────────────────────────────────────────────────
+export async function mostrarLog() {
+    if (!(await verificarRepo()))
+        return;
+    const cantidad = await select({
+        message: "¿Cuántos commits mostrar?",
+        choices: [
+            { name: "Últimos 10", value: 10 },
+            { name: "Últimos 20", value: 20 },
+            { name: "Últimos 50", value: 50 },
+        ],
+    });
+    const spin = spinner("Cargando historial...");
+    const log = await git.log({ maxCount: cantidad });
+    spin.stop();
+    console.log();
+    console.log(c.titulo(`  📜 Últimos ${cantidad} commits`));
+    separador();
+    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",
+        });
+        console.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)}`);
+    });
+    separador();
+    console.log();
+}

package/dist/factories/CommandFactory.js

@@ -0,0 +1,51 @@
+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';
+export class CommandFactory {
+    gitPort;
+    uiPort;
+    gitHubPort;
+    storage;
+    gitHubService;
+    constructor(gitPort, uiPort, gitHubPort, storage) {
+        this.gitPort = gitPort;
+        this.uiPort = uiPort;
+        this.gitHubPort = gitHubPort;
+        this.storage = storage;
+        this.gitHubService = new GitHubService(gitHubPort, storage);
+    }
+    createCommand(type) {
+        switch (type) {
+            case 'status':
+                return new StatusCommand(this.gitPort, this.uiPort);
+            case 'log':
+                return new LogCommand(this.gitPort, this.uiPort);
+            case 'commit':
+                return new CommitCommand(this.gitPort, this.uiPort);
+            case 'push':
+                return new PushCommand(this.gitPort, this.uiPort, this.gitHubService);
+            case 'pull':
+                return new PullCommand(this.gitPort, this.uiPort);
+            case 'branches':
+                return new BranchesCommand(this.gitPort, this.uiPort);
+            case 'merge':
+                return new IntegrationCommand(this.gitPort, this.uiPort);
+            case 'stash':
+                return new StashCommand(this.gitPort, this.uiPort);
+            case 'repo':
+                return new RepositoryCommand(this.gitPort, this.uiPort, this.gitHubService);
+            case 'github':
+                return new GitHubMenuCommand(this.gitHubService, this.gitPort, this.uiPort);
+            default:
+                throw new Error(`Unknown command type: ${type}`);
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+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';
+async function main() {
+    const gitPort = new SimpleGitAdapter();
+    const uiPort = new ConsoleUIAdapter();
+    const gitHubPort = new GitHubAPIAdapter();
+    const storage = new FileSecureStorageAdapter();
+    const commandFactory = new CommandFactory(gitPort, uiPort, gitHubPort, storage);
+    let continuar = true;
+    while (continuar) {
+        try {
+            uiPort.clear();
+            uiPort.showBanner();
+            await showContextInfo(gitPort, uiPort);
+            const opcion = await uiPort.select('¿Qué deseas hacer?', [
+                { name: '📋  Estado del repositorio', value: 'status' },
+                { name: '📜  Ver historial (log)', value: 'log' },
+                { name: '─────────────────────────────', value: 'sep1', disabled: true },
+                { name: '✅  Commit  (add + commit)', value: 'commit' },
+                { name: '↑   Push  (subir cambios)', value: 'push' },
+                { name: '↓   Pull  (bajar cambios)', value: 'pull' },
+                { name: '─────────────────────────────', value: 'sep2', disabled: true },
+                { name: '🌿  Ramas  (crear/cambiar/eliminar)', value: 'branches' },
+                { name: '🔀  Merge / Rebase', value: 'merge' },
+                { name: '📦  Stash  (guardar/restaurar)', value: 'stash' },
+                { name: '─────────────────────────────', value: 'sep3', disabled: true },
+                { name: '🆕  Repositorio  (clone/init/remoto)', value: 'repo' },
+                { name: '─────────────────────────────', value: 'sep4', disabled: true },
+                { name: '🌐  Gestión GitHub', value: 'github' },
+                { name: '─────────────────────────────', value: 'sep5', disabled: true },
+                { name: '🚪  Salir', value: 'salir' },
+            ]);
+            if (opcion === 'salir') {
+                uiPort.log(uiPort.colors.tenue('\n  Hasta pronto.\n'));
+                continuar = false;
+            }
+            else {
+                const command = commandFactory.createCommand(opcion);
+                await command.execute();
+                await uiPort.pause();
+            }
+        }
+        catch (err) {
+            if (err instanceof Error &&
+                (err.message.includes('User force closed') || err.name === 'ExitPromptError')) {
+                uiPort.log(uiPort.colors.tenue('\n\n  Hasta pronto.\n'));
+                process.exit(0);
+            }
+            throw err;
+        }
+    }
+}
+async function showContextInfo(gitPort, uiPort) {
+    try {
+        const status = await gitPort.getStatus();
+        const rama = status.current ?? '?';
+        const sucios = status.modified.length +
+            status.staged.length +
+            status.not_added.length +
+            status.deleted.length;
+        uiPort.showContextInfo(rama, status.ahead, status.behind, sucios);
+    }
+    catch {
+        uiPort.separator();
+    }
+}
+main().catch(console.error);