@asaro/git-cli 1.0.0

package/dist/integracion.js

@@ -0,0 +1,152 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { select, confirm } from "@inquirer/prompts";
+// ── Menú Merge / Rebase ───────────────────────────────────────────────────────
+export async function menuMergeRebase() {
+    if (!(await verificarRepo()))
+        return;
+    const accion = await select({
+        message: "Integración — ¿qué deseas hacer?",
+        choices: [
+            { name: "Merge (fusionar rama en la actual)", value: "merge" },
+            { name: "Rebase (reescribir historial sobre base)", value: "rebase" },
+            { name: "Abortar merge en curso", value: "abortMerge" },
+            { name: "Abortar rebase en curso", value: "abortRebase" },
+            { name: "← Volver al menú principal", value: "volver" },
+        ],
+    });
+    switch (accion) {
+        case "merge": return hacerMerge();
+        case "rebase": return hacerRebase();
+        case "abortMerge": return abortarMerge();
+        case "abortRebase": return abortarRebase();
+        case "volver": return;
+    }
+}
+// ── Merge ─────────────────────────────────────────────────────────────────────
+async function hacerMerge() {
+    const spin = spinner("Cargando ramas...");
+    const ramas = await git.branchLocal();
+    spin.stop();
+    const actual = ramas.current;
+    const opciones = ramas.all
+        .filter(r => r !== actual)
+        .map(r => ({ name: r, value: r }));
+    if (opciones.length === 0) {
+        console.log(c.aviso("\n  No hay otras ramas para fusionar.\n"));
+        return;
+    }
+    const origen = await select({
+        message: `Fusionar en "${c.rama(actual)}" ← ¿desde qué rama?`,
+        choices: opciones,
+    });
+    const modo = await select({
+        message: "Modo de merge:",
+        choices: [
+            { name: "Normal (crea commit de merge)", value: "normal" },
+            { name: "No fast-forward (fuerza merge commit siempre)", value: "noff" },
+            { name: "Squash (aplana todos los commits en uno)", value: "squash" },
+        ],
+    });
+    separador();
+    console.log(`  ${c.rama(origen)}  →  ${c.rama(actual)}`);
+    separador();
+    const confirmar = await confirm({ message: "¿Confirmar merge?", default: true });
+    if (!confirmar) {
+        console.log(c.aviso("  Merge cancelado.\n"));
+        return;
+    }
+    const spinMerge = spinner(`Fusionando ${origen} en ${actual}...`);
+    try {
+        switch (modo) {
+            case "noff":
+                await git.merge([origen, "--no-ff"]);
+                break;
+            case "squash":
+                await git.merge([origen, "--squash"]);
+                spinMerge.stop();
+                console.log(c.exito(`\n  ✓ Squash merge listo. Debes hacer commit manual.\n`));
+                return;
+            default:
+                await git.merge([origen]);
+        }
+        spinMerge.stop();
+        console.log(c.exito(`\n  ✓ Merge completado: ${origen} → ${actual}\n`));
+    }
+    catch (err) {
+        spinMerge.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error en merge (posibles conflictos):\n  ${msg}\n`));
+        console.log(c.aviso("  Usa 'Abortar merge en curso' si deseas revertir.\n"));
+    }
+}
+// ── Rebase ────────────────────────────────────────────────────────────────────
+async function hacerRebase() {
+    const spin = spinner("Cargando ramas...");
+    const ramas = await git.branchLocal();
+    spin.stop();
+    const actual = ramas.current;
+    const opciones = ramas.all
+        .filter(r => r !== actual)
+        .map(r => ({ name: r, value: r }));
+    if (opciones.length === 0) {
+        console.log(c.aviso("\n  No hay otras ramas para hacer rebase.\n"));
+        return;
+    }
+    const base = await select({
+        message: `Rebasar "${c.rama(actual)}" sobre ¿qué rama?`,
+        choices: opciones,
+    });
+    console.log();
+    console.log(c.aviso("  ⚠ El rebase reescribe el historial de commits."));
+    console.log(c.aviso("    No lo uses en ramas compartidas/remotas."));
+    separador();
+    const confirmar = await confirm({ message: `¿Confirmar rebase sobre ${base}?`, default: false });
+    if (!confirmar) {
+        console.log(c.aviso("  Rebase cancelado.\n"));
+        return;
+    }
+    const spinRebase = spinner(`Aplicando rebase sobre ${base}...`);
+    try {
+        await git.rebase([base]);
+        spinRebase.stop();
+        console.log(c.exito(`\n  ✓ Rebase completado sobre ${c.rama(base)}\n`));
+    }
+    catch (err) {
+        spinRebase.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Conflictos durante rebase:\n  ${msg}\n`));
+        console.log(c.aviso("  Resuelve conflictos manualmente o usa 'Abortar rebase'.\n"));
+    }
+}
+// ── Abortar merge ─────────────────────────────────────────────────────────────
+async function abortarMerge() {
+    const confirmar = await confirm({ message: "¿Abortar el merge en curso?", default: false });
+    if (!confirmar)
+        return;
+    const spin = spinner("Abortando merge...");
+    try {
+        await git.merge(["--abort"]);
+        spin.stop();
+        console.log(c.exito("\n  ✓ Merge abortado. Estado restaurado.\n"));
+    }
+    catch (err) {
+        spin.stop();
+        console.log(c.error("\n  ✗ No hay merge en curso o falló el abort.\n"));
+    }
+}
+// ── Abortar rebase ─────────────────────────────────────────────────────────────
+async function abortarRebase() {
+    const confirmar = await confirm({ message: "¿Abortar el rebase en curso?", default: false });
+    if (!confirmar)
+        return;
+    const spin = spinner("Abortando rebase...");
+    try {
+        await git.rebase(["--abort"]);
+        spin.stop();
+        console.log(c.exito("\n  ✓ Rebase abortado. Estado restaurado.\n"));
+    }
+    catch (err) {
+        spin.stop();
+        console.log(c.error("\n  ✗ No hay rebase en curso o falló el abort.\n"));
+    }
+}

package/dist/ramas.js

@@ -0,0 +1,178 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { select, input, confirm } from "@inquirer/prompts";
+// ── Menú de ramas ─────────────────────────────────────────────────────────────
+export async function menuRamas() {
+    if (!(await verificarRepo()))
+        return;
+    const accion = await select({
+        message: "Ramas — ¿qué deseas hacer?",
+        choices: [
+            { name: "Listar todas las ramas", value: "listar" },
+            { name: "Cambiar de rama (checkout)", value: "cambiar" },
+            { name: "Crear nueva rama", value: "crear" },
+            { name: "Crear y cambiar a nueva rama", value: "crearCambiar" },
+            { name: "Eliminar rama", value: "eliminar" },
+            { name: "Renombrar rama actual", value: "renombrar" },
+            { name: "← Volver al menú principal", value: "volver" },
+        ],
+    });
+    switch (accion) {
+        case "listar": return listarRamas();
+        case "cambiar": return cambiarRama();
+        case "crear": return crearRama(false);
+        case "crearCambiar": return crearRama(true);
+        case "eliminar": return eliminarRama();
+        case "renombrar": return renombrarRama();
+        case "volver": return;
+    }
+}
+// ── Listar ramas ──────────────────────────────────────────────────────────────
+async function listarRamas() {
+    const spin = spinner("Cargando ramas...");
+    const ramas = await git.branch(["-a"]);
+    spin.stop();
+    console.log();
+    console.log(c.titulo("  🌿 Ramas del repositorio"));
+    separador();
+    ramas.all.forEach(rama => {
+        const esActual = rama === ramas.current;
+        const esRemota = rama.startsWith("remotes/");
+        const nombre = rama.replace("remotes/", "");
+        if (esActual) {
+            console.log(c.exito(`  ◉ ${nombre}`) + c.tenue("  ← actual"));
+        }
+        else if (esRemota) {
+            console.log(c.tenue(`  ○ ${nombre}`) + c.info("  (remota)"));
+        }
+        else {
+            console.log(c.titulo(`  ○ ${nombre}`));
+        }
+    });
+    separador();
+    console.log();
+}
+// ── Cambiar de rama ───────────────────────────────────────────────────────────
+async function cambiarRama() {
+    const spin = spinner("Cargando ramas locales...");
+    const ramas = await git.branchLocal();
+    spin.stop();
+    const opciones = ramas.all
+        .filter(r => r !== ramas.current)
+        .map(r => ({ name: r, value: r }));
+    if (opciones.length === 0) {
+        console.log(c.aviso("\n  No hay otras ramas locales disponibles.\n"));
+        return;
+    }
+    const destino = await select({
+        message: "Selecciona la rama de destino:",
+        choices: opciones,
+    });
+    const spinSwitch = spinner(`Cambiando a ${destino}...`);
+    try {
+        await git.checkout(destino);
+        spinSwitch.stop();
+        console.log(c.exito(`\n  ✓ Ahora estás en: ${c.rama(destino)}\n`));
+    }
+    catch (err) {
+        spinSwitch.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error al cambiar de rama:\n  ${msg}\n`));
+    }
+}
+// ── Crear rama (con opción de checkout inmediato) ─────────────────────────────
+async function crearRama(cambiarAlCrear) {
+    const nombre = await input({
+        message: "Nombre de la nueva rama:",
+        validate: (v) => {
+            if (!v.trim())
+                return "El nombre no puede estar vacío.";
+            if (/\s/.test(v))
+                return "El nombre no puede tener espacios.";
+            return true;
+        },
+    });
+    const spinCrear = spinner(`Creando rama ${nombre}...`);
+    try {
+        if (cambiarAlCrear) {
+            await git.checkoutLocalBranch(nombre);
+            spinCrear.stop();
+            console.log(c.exito(`\n  ✓ Rama creada y activa: ${c.rama(nombre)}\n`));
+        }
+        else {
+            await git.branch([nombre]);
+            spinCrear.stop();
+            console.log(c.exito(`\n  ✓ Rama creada: ${c.rama(nombre)}\n`));
+        }
+    }
+    catch (err) {
+        spinCrear.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error al crear rama:\n  ${msg}\n`));
+    }
+}
+// ── Eliminar rama ─────────────────────────────────────────────────────────────
+async function eliminarRama() {
+    const spin = spinner("Cargando ramas locales...");
+    const ramas = await git.branchLocal();
+    spin.stop();
+    const opciones = ramas.all
+        .filter(r => r !== ramas.current)
+        .map(r => ({ name: r, value: r }));
+    if (opciones.length === 0) {
+        console.log(c.aviso("\n  No hay ramas locales para eliminar (no puedes eliminar la actual).\n"));
+        return;
+    }
+    const objetivo = await select({
+        message: "¿Qué rama deseas eliminar?",
+        choices: opciones,
+    });
+    const forzar = await confirm({
+        message: `¿Forzar eliminación de "${objetivo}"? (--force)`,
+        default: false,
+    });
+    const confirmar = await confirm({
+        message: c.error(`¿Seguro que deseas eliminar "${objetivo}"?`),
+        default: false,
+    });
+    if (!confirmar) {
+        console.log(c.aviso("  Operación cancelada.\n"));
+        return;
+    }
+    const spinDel = spinner(`Eliminando rama ${objetivo}...`);
+    try {
+        await git.deleteLocalBranch(objetivo, forzar);
+        spinDel.stop();
+        console.log(c.exito(`\n  ✓ Rama eliminada: ${objetivo}\n`));
+    }
+    catch (err) {
+        spinDel.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error:\n  ${msg}\n`));
+    }
+}
+// ── Renombrar rama actual ─────────────────────────────────────────────────────
+async function renombrarRama() {
+    const actual = (await git.branchLocal()).current;
+    console.log(c.info(`\n  Rama actual: ${c.rama(actual)}`));
+    const nuevoNombre = await input({
+        message: "Nuevo nombre:",
+        validate: (v) => {
+            if (!v.trim())
+                return "El nombre no puede estar vacío.";
+            if (/\s/.test(v))
+                return "Sin espacios.";
+            return true;
+        },
+    });
+    const spinRen = spinner("Renombrando...");
+    try {
+        await git.branch(["-m", actual, nuevoNombre]);
+        spinRen.stop();
+        console.log(c.exito(`\n  ✓ Renombrada: ${actual} → ${c.rama(nuevoNombre)}\n`));
+    }
+    catch (err) {
+        spinRen.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error:\n  ${msg}\n`));
+    }
+}

package/dist/remoto.js

@@ -0,0 +1,129 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { select, confirm } from "@inquirer/prompts";
+// ── Push ─────────────────────────────────────────────────────────────────────
+export async function hacerPush() {
+    if (!(await verificarRepo()))
+        return;
+    const spin = spinner("Verificando estado...");
+    const status = await git.status();
+    const remotos = await git.getRemotes(true);
+    spin.stop();
+    if (remotos.length === 0) {
+        console.log(c.error("\n  ✗ No hay remotos configurados en este repositorio.\n"));
+        return;
+    }
+    const rama = status.current ?? "main";
+    console.log();
+    console.log(c.titulo("  ↑  Subir cambios (push)"));
+    separador();
+    console.log(`  Rama actual: ${c.rama(rama)}`);
+    if (status.ahead > 0) {
+        console.log(c.aviso(`  ${status.ahead} commit(s) pendientes de subir`));
+    }
+    else {
+        console.log(c.tenue("  No hay commits nuevos para subir."));
+    }
+    separador();
+    // Seleccionar remoto si hay más de uno
+    let remoto = "origin";
+    if (remotos.length > 1) {
+        remoto = await select({
+            message: "¿A qué remoto hacer push?",
+            choices: remotos.map(r => ({ name: r.name, value: r.name })),
+        });
+    }
+    const modo = await select({
+        message: "Modo de push:",
+        choices: [
+            { name: `Subir rama actual  (${rama})`, value: "normal" },
+            { name: "Subir y crear rama en remoto  (--set-upstream)", value: "upstream" },
+            { name: "Forzar push  (--force-with-lease)", value: "force" },
+            { name: "Subir todos los tags", value: "tags" },
+        ],
+    });
+    const confirmar = await confirm({ message: `¿Confirmar push a ${remoto}/${rama}?`, default: true });
+    if (!confirmar) {
+        console.log(c.aviso("  Push cancelado.\n"));
+        return;
+    }
+    const spinPush = spinner("Subiendo cambios...");
+    try {
+        switch (modo) {
+            case "upstream":
+                await git.push([remoto, rama, "--set-upstream"]);
+                break;
+            case "force":
+                await git.push([remoto, rama, "--force-with-lease"]);
+                break;
+            case "tags":
+                await git.push([remoto, "--tags"]);
+                break;
+            default:
+                await git.push(remoto, rama);
+        }
+        spinPush.stop();
+        console.log(c.exito(`\n  ✓ Push exitoso → ${remoto}/${rama}\n`));
+    }
+    catch (err) {
+        spinPush.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error en push:\n  ${msg}\n`));
+    }
+}
+// ── Pull ─────────────────────────────────────────────────────────────────────
+export async function hacerPull() {
+    if (!(await verificarRepo()))
+        return;
+    const spin = spinner("Verificando estado...");
+    const status = await git.status();
+    const remotos = await git.getRemotes(true);
+    spin.stop();
+    if (remotos.length === 0) {
+        console.log(c.error("\n  ✗ No hay remotos configurados.\n"));
+        return;
+    }
+    const rama = status.current ?? "main";
+    console.log();
+    console.log(c.titulo("  ↓  Bajar cambios (pull)"));
+    separador();
+    console.log(`  Rama actual: ${c.rama(rama)}`);
+    if (status.behind > 0) {
+        console.log(c.aviso(`  ${status.behind} commit(s) disponibles en el remoto`));
+    }
+    separador();
+    let remoto = "origin";
+    if (remotos.length > 1) {
+        remoto = await select({
+            message: "¿Desde qué remoto hacer pull?",
+            choices: remotos.map(r => ({ name: r.name, value: r.name })),
+        });
+    }
+    const estrategia = await select({
+        message: "Estrategia de integración:",
+        choices: [
+            { name: "Merge  (por defecto)", value: "merge" },
+            { name: "Rebase (historial más limpio)", value: "rebase" },
+        ],
+    });
+    const confirmar = await confirm({ message: `¿Confirmar pull desde ${remoto}/${rama}?`, default: true });
+    if (!confirmar) {
+        console.log(c.aviso("  Pull cancelado.\n"));
+        return;
+    }
+    const spinPull = spinner("Bajando cambios...");
+    try {
+        if (estrategia === "rebase") {
+            await git.pull(remoto, rama, { "--rebase": "true" });
+        }
+        else {
+            await git.pull(remoto, rama);
+        }
+        spinPull.stop();
+        console.log(c.exito(`\n  ✓ Pull exitoso desde ${remoto}/${rama}\n`));
+    }
+    catch (err) {
+        spinPull.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error en pull:\n  ${msg}\n`));
+    }
+}

package/dist/repositorio.js

@@ -0,0 +1,159 @@
+import { git, c, separador, verificarRepo, spinner } from "./utils.js";
+import { select, input, confirm } from "@inquirer/prompts";
+import { simpleGit } from "simple-git";
+import path from "path";
+// ── Menú Clone / Init ─────────────────────────────────────────────────────────
+export async function menuOrigenRepo() {
+    const accion = await select({
+        message: "Repositorio — ¿qué deseas hacer?",
+        choices: [
+            { name: "Clonar repositorio remoto", value: "clonar" },
+            { name: "Inicializar nuevo repositorio", value: "init" },
+            { name: "Ver remotos configurados", value: "remotos" },
+            { name: "Agregar remoto", value: "agregarRemoto" },
+            { name: "← Volver al menú principal", value: "volver" },
+        ],
+    });
+    switch (accion) {
+        case "clonar": return clonarRepo();
+        case "init": return inicializarRepo();
+        case "remotos": return verRemotos();
+        case "agregarRemoto": return agregarRemoto();
+        case "volver": return;
+    }
+}
+// ── Clonar ────────────────────────────────────────────────────────────────────
+async function clonarRepo() {
+    console.log();
+    console.log(c.titulo("  📥 Clonar repositorio"));
+    separador();
+    const url = await input({
+        message: "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 input({
+        message: "Carpeta de destino:",
+        default: nombreSugerido,
+        validate: (v) => v.trim().length > 0 || "El nombre no puede estar vacío.",
+    });
+    const rama = await input({
+        message: "Rama a clonar (dejar vacío para rama por defecto):",
+        default: "",
+    });
+    const cwd = process.cwd();
+    const destinoAbsoluto = path.join(cwd, destino);
+    separador();
+    console.log(`  URL:     ${c.info(url)}`);
+    console.log(`  Carpeta: ${c.archivo(destinoAbsoluto)}`);
+    if (rama.trim())
+        console.log(`  Rama:    ${c.rama(rama.trim())}`);
+    separador();
+    const confirmar = await confirm({ message: "¿Confirmar clonación?", default: true });
+    if (!confirmar) {
+        console.log(c.aviso("  Clonación cancelada.\n"));
+        return;
+    }
+    const spinClone = spinner("Clonando repositorio...");
+    try {
+        const g = simpleGit(cwd);
+        const opciones = [];
+        if (rama.trim()) {
+            opciones.push("-b", rama.trim());
+        }
+        await g.clone(url, destino, opciones);
+        spinClone.stop();
+        console.log(c.exito(`\n  ✓ Repositorio clonado en: ${c.archivo(destinoAbsoluto)}\n`));
+    }
+    catch (err) {
+        spinClone.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error al clonar:\n  ${msg}\n`));
+    }
+}
+// ── Init ──────────────────────────────────────────────────────────────────────
+async function inicializarRepo() {
+    console.log();
+    console.log(c.titulo("  🆕 Inicializar repositorio"));
+    separador();
+    const esActual = await select({
+        message: "¿Dónde inicializar?",
+        choices: [
+            { name: `Directorio actual (${process.cwd()})`, value: "actual" },
+            { name: "Nueva carpeta", value: "nueva" },
+        ],
+    });
+    let destino = process.cwd();
+    if (esActual === "nueva") {
+        const nombreCarpeta = await input({
+            message: "Nombre de la nueva carpeta:",
+            validate: (v) => v.trim().length > 0 || "El nombre no puede estar vacío.",
+        });
+        destino = path.join(process.cwd(), nombreCarpeta);
+    }
+    const ramaInicial = await input({
+        message: "Nombre de la rama inicial:",
+        default: "main",
+    });
+    const confirmar = await confirm({ message: `¿Inicializar repo en: ${c.archivo(destino)}?`, default: true });
+    if (!confirmar)
+        return;
+    const spinInit = spinner("Inicializando...");
+    try {
+        const g = simpleGit(destino);
+        await g.init({ "--initial-branch": ramaInicial.trim() || "main" });
+        spinInit.stop();
+        console.log(c.exito(`\n  ✓ Repositorio inicializado en: ${c.archivo(destino)}\n`));
+    }
+    catch (err) {
+        spinInit.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error al inicializar:\n  ${msg}\n`));
+    }
+}
+// ── Ver remotos ───────────────────────────────────────────────────────────────
+async function verRemotos() {
+    if (!(await verificarRepo()))
+        return;
+    const spin = spinner("Cargando remotos...");
+    const remotos = await git.getRemotes(true);
+    spin.stop();
+    console.log();
+    console.log(c.titulo("  🌐 Remotos configurados"));
+    separador();
+    if (remotos.length === 0) {
+        console.log(c.tenue("  No hay remotos configurados."));
+    }
+    else {
+        remotos.forEach(r => {
+            console.log(`  ${c.info(r.name.padEnd(10))} ${c.tenue(r.refs.fetch ?? "")}`);
+        });
+    }
+    separador();
+    console.log();
+}
+// ── Agregar remoto ─────────────────────────────────────────────────────────────
+async function agregarRemoto() {
+    if (!(await verificarRepo()))
+        return;
+    const nombre = await input({
+        message: "Nombre del remoto:",
+        default: "origin",
+        validate: (v) => v.trim().length > 0 || "Nombre requerido.",
+    });
+    const url = await input({
+        message: "URL del remoto:",
+        validate: (v) => v.trim().length > 0 || "URL requerida.",
+    });
+    const spinRem = spinner("Agregando remoto...");
+    try {
+        await git.addRemote(nombre, url);
+        spinRem.stop();
+        console.log(c.exito(`\n  ✓ Remoto "${nombre}" agregado → ${url}\n`));
+    }
+    catch (err) {
+        spinRem.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(c.error(`\n  ✗ Error:\n  ${msg}\n`));
+    }
+}