@asaro/git-cli 1.0.0

package/dist/commands/StatusCommand.js

@@ -0,0 +1,66 @@
+import { BaseCommand } from './BaseCommand.js';
+export class StatusCommand 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 spin = this.uiPort.spinner('Obteniendo estado del repositorio...');
+            const status = await this.gitPort.getStatus();
+            spin.stop();
+            const c = this.uiColors;
+            const rama = status.current ?? 'desconocida';
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  📋 Estado del repositorio'));
+            this.uiPort.separator();
+            this.uiPort.log(`  Rama actual: ${c.rama(rama)}`);
+            if (status.ahead > 0 && status.behind > 0) {
+                this.uiPort.log(c.aviso(`  ⚡ ${status.ahead} commit(s) adelante y ${status.behind} atrás del remoto`));
+            }
+            else if (status.ahead > 0) {
+                this.uiPort.log(c.aviso(`  ↑  ${status.ahead} commit(s) por subir`));
+            }
+            else if (status.behind > 0) {
+                this.uiPort.log(c.aviso(`  ↓  ${status.behind} commit(s) por bajar`));
+            }
+            else {
+                this.uiPort.log(c.exito('  ✓  Sincronizado con el remoto'));
+            }
+            this.uiPort.separator();
+            if (status.staged.length > 0) {
+                this.uiPort.log(c.exito('  Preparados para commit (staged):'));
+                status.staged.forEach((f) => this.uiPort.log(c.exito(`    + ${f}`)));
+            }
+            if (status.modified.length > 0) {
+                this.uiPort.log(c.aviso('  Modificados (sin stagear):'));
+                status.modified.forEach((f) => this.uiPort.log(c.aviso(`    ~ ${f}`)));
+            }
+            if (status.not_added.length > 0) {
+                this.uiPort.log(c.tenue('  Sin seguimiento (untracked):'));
+                status.not_added.forEach((f) => this.uiPort.log(c.tenue(`    ? ${f}`)));
+            }
+            if (status.deleted.length > 0) {
+                this.uiPort.log(c.error('  Eliminados:'));
+                status.deleted.forEach((f) => this.uiPort.log(c.error(`    - ${f}`)));
+            }
+            if (status.conflicted.length > 0) {
+                this.uiPort.log(c.error('  Con conflictos:'));
+                status.conflicted.forEach((f) => this.uiPort.log(c.error(`    ✗ ${f}`)));
+            }
+            const total = status.staged.length +
+                status.modified.length +
+                status.not_added.length +
+                status.deleted.length;
+            if (total === 0) {
+                this.uiPort.log(c.tenue('  Árbol de trabajo limpio.'));
+            }
+            this.uiPort.separator();
+            this.uiPort.log('');
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+}

package/dist/commands/github/BaseGitHubCommand.js

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../BaseCommand.js';
+export class BaseGitHubCommand extends BaseCommand {
+    gitHubService;
+    constructor(gitHubService, gitPort, uiPort) {
+        super(gitPort, uiPort);
+        this.gitHubService = gitHubService;
+    }
+    async ensureAuthenticated() {
+        const isAuth = await this.gitHubService.isAuthenticated();
+        if (!isAuth) {
+            this.uiPort.error('  ✗ No estás autenticado con GitHub');
+            this.uiPort.info('  Usa la opción de inicio de sesión primero');
+            return false;
+        }
+        return true;
+    }
+}

package/dist/commands/github/GitHubAuthCommand.js

@@ -0,0 +1,48 @@
+import { BaseGitHubCommand } from './BaseGitHubCommand.js';
+export class GitHubAuthCommand extends BaseGitHubCommand {
+    async execute() {
+        try {
+            const isAuth = await this.gitHubService.isAuthenticated();
+            const c = this.uiColors;
+            if (isAuth) {
+                const user = await this.gitHubService.getCurrentUser();
+                this.uiPort.log('');
+                this.uiPort.log(c.info(`  Autenticado como: ${user.name || user.login}`));
+                const action = await this.uiPort.select('¿Qué deseas hacer?', [
+                    { name: 'Cerrar sesión', value: 'logout' },
+                    { name: 'Volver', value: 'back' },
+                ]);
+                if (action === 'logout') {
+                    await this.gitHubService.logout();
+                    this.uiPort.success('  ✓ Sesión cerrada correctamente');
+                }
+                return;
+            }
+            // Not authenticated - show login flow
+            this.uiPort.log('');
+            this.uiPort.log(c.titulo('  🔐 Inicio de sesión GitHub'));
+            this.uiPort.separator();
+            this.uiPort.log(c.info('  Necesitas un Personal Access Token (PAT) de GitHub'));
+            this.uiPort.log(c.tenue('  Permisos necesarios: repo, workflow, delete_repo'));
+            this.uiPort.log(c.tenue('  Genera uno aquí: https://github.com/settings/tokens/new'));
+            this.uiPort.separator();
+            const token = await this.uiPort.input('Ingresa tu PAT de GitHub:', {
+                validate: (val) => val.trim().length > 0 || 'El token no puede estar vacío',
+            });
+            const spin = this.uiPort.spinner('Validando token...');
+            try {
+                await this.gitHubService.login(token.trim());
+                spin.stop();
+                const user = await this.gitHubService.getCurrentUser();
+                this.uiPort.success(`  ✓ Autenticado correctamente como ${user.name || user.login}`);
+            }
+            catch (err) {
+                spin.stop();
+                throw err;
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ ${err.message}`);
+        }
+    }
+}

package/dist/commands/github/GitHubMenuCommand.js

@@ -0,0 +1,57 @@
+import { BaseGitHubCommand } from './BaseGitHubCommand.js';
+import { GitHubAuthCommand } from './GitHubAuthCommand.js';
+import { GitHubReposCommand } from './GitHubReposCommand.js';
+import { GitHubWorkflowsCommand } from './GitHubWorkflowsCommand.js';
+export class GitHubMenuCommand extends BaseGitHubCommand {
+    authCommand;
+    reposCommand;
+    workflowsCommand;
+    constructor(gitHubService, gitPort, uiPort) {
+        super(gitHubService, gitPort, uiPort);
+        this.authCommand = new GitHubAuthCommand(gitHubService, gitPort, uiPort);
+        this.reposCommand = new GitHubReposCommand(gitHubService, gitPort, uiPort);
+        this.workflowsCommand = new GitHubWorkflowsCommand(gitHubService, gitPort, uiPort);
+    }
+    async execute() {
+        try {
+            const c = this.uiColors;
+            let continuar = true;
+            while (continuar) {
+                const isAuth = await this.gitHubService.isAuthenticated();
+                this.uiPort.log('');
+                this.uiPort.log(c.titulo('  🌐 Menú GitHub'));
+                this.uiPort.separator();
+                if (isAuth) {
+                    const user = await this.gitHubService.getCurrentUser();
+                    this.uiPort.log(c.exito(`  ✅ Autenticado como: ${user.name || user.login}`));
+                }
+                else {
+                    this.uiPort.log(c.aviso('  ⚠️ No autenticado'));
+                }
+                const action = await this.uiPort.select('¿Qué deseas hacer?', [
+                    { name: 'Autenticación (Login/Logout)', value: 'auth' },
+                    { name: 'Gestión de repositorios', value: 'repos' },
+                    { name: 'Gestión de GitHub Actions', value: 'workflows' },
+                    { name: 'Volver al menú principal', value: 'back' },
+                ]);
+                switch (action) {
+                    case 'auth':
+                        await this.authCommand.execute();
+                        break;
+                    case 'repos':
+                        await this.reposCommand.execute();
+                        break;
+                    case 'workflows':
+                        await this.workflowsCommand.execute();
+                        break;
+                    case 'back':
+                        continuar = false;
+                        break;
+                }
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ ${err.message}`);
+        }
+    }
+}

package/dist/commands/github/GitHubReposCommand.js

@@ -0,0 +1,210 @@
+import { BaseGitHubCommand } from './BaseGitHubCommand.js';
+import { simpleGit } from 'simple-git';
+import path from 'path';
+export class GitHubReposCommand extends BaseGitHubCommand {
+    async execute() {
+        if (!(await this.ensureAuthenticated()))
+            return;
+        try {
+            const c = this.uiColors;
+            let continuar = true;
+            while (continuar) {
+                this.uiPort.log('');
+                this.uiPort.log(c.titulo('  📦 Gestión de repositorios GitHub'));
+                this.uiPort.separator();
+                const action = await this.uiPort.select('¿Qué deseas hacer?', [
+                    { name: 'Listar mis repositorios', value: 'list' },
+                    { name: 'Crear nuevo repositorio', value: 'create' },
+                    { name: 'Archivar/Desarchivar repositorio', value: 'archive' },
+                    { name: 'Clonar repositorio', value: 'clone' },
+                    { name: 'Volver', value: 'back' },
+                ]);
+                switch (action) {
+                    case 'list':
+                        await this.listRepos();
+                        break;
+                    case 'create':
+                        await this.createRepo();
+                        break;
+                    case 'archive':
+                        await this.archiveRepo();
+                        break;
+                    case 'clone':
+                        await this.cloneRepo();
+                        break;
+                    case 'back':
+                        continuar = false;
+                        break;
+                }
+                if (continuar && action !== 'back') {
+                    await this.uiPort.pause();
+                }
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ ${err.message}`);
+        }
+    }
+    async listRepos() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        // Ask for filters
+        const useFilters = await this.uiPort.confirm('¿Deseas aplicar filtros?', false);
+        let filters = {};
+        if (useFilters) {
+            const visibility = await this.uiPort.select('Visibilidad:', [
+                { name: 'Todos', value: 'all' },
+                { name: 'Públicos', value: 'public' },
+                { name: 'Privados', value: 'private' },
+            ]);
+            if (visibility !== 'all')
+                filters.visibility = visibility;
+            const language = await this.uiPort.input('Filtrar por lenguaje (deja vacío para no filtrar):');
+            if (language.trim())
+                filters.language = language.trim();
+            const sinceDays = await this.uiPort.input('Mostrar repos actualizados en los últimos X días (deja vacío):');
+            if (sinceDays.trim()) {
+                const days = parseInt(sinceDays.trim());
+                if (!isNaN(days)) {
+                    const date = new Date();
+                    date.setDate(date.getDate() - days);
+                    filters.since = date.toISOString();
+                }
+            }
+        }
+        const spin = this.uiPort.spinner('Cargando repositorios...');
+        const repos = await this.gitHubService.listRepos(Object.keys(filters).length > 0 ? filters : undefined);
+        spin.stop();
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo(`  📋 ${repos.length} repositorios encontrados`));
+        this.uiPort.separator();
+        repos.forEach((repo, index) => {
+            const archivedBadge = repo.archived ? c.tenue(' [ARCHIVADO]') : '';
+            this.uiPort.log(`  ${c.info(`${index + 1}.`)} ${c.titulo(repo.fullName)}${archivedBadge}`);
+            if (repo.description) {
+                this.uiPort.log(c.tenue(`     ${repo.description}`));
+            }
+            this.uiPort.log(c.tenue(`     ⭐ ${repo.stars} | ${repo.language || 'N/A'} | Última actualización: ${repo.updatedAt ? new Date(repo.updatedAt).toLocaleDateString('es-CL') : 'N/A'}`));
+            this.uiPort.log('');
+        });
+    }
+    async createRepo() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo('  ➕ Crear nuevo repositorio'));
+        this.uiPort.separator();
+        const name = await this.uiPort.input('Nombre del repositorio:', {
+            validate: (val) => val.trim().length > 0 || 'El nombre es obligatorio',
+        });
+        const description = await this.uiPort.input('Descripción (opcional):');
+        const visibility = await this.uiPort.select('Visibilidad:', [
+            { name: 'Público', value: 'public' },
+            { name: 'Privado', value: 'private' },
+        ]);
+        const autoInit = await this.uiPort.confirm('¿Inicializar con README?', true);
+        let gitignoreTemplate;
+        if (autoInit) {
+            const gitignore = await this.uiPort.input('Plantilla .gitignore (ej: Node, Python, dejar vacío para ninguna):');
+            if (gitignore.trim())
+                gitignoreTemplate = gitignore.trim();
+        }
+        let licenseTemplate;
+        if (autoInit) {
+            const license = await this.uiPort.input('Licencia (ej: mit, apache-2.0, dejar vacío para ninguna):');
+            if (license.trim())
+                licenseTemplate = license.trim();
+        }
+        const confirm = await this.uiPort.confirm(`¿Crear repositorio ${name}?`, true);
+        if (!confirm) {
+            this.uiPort.warning('  Operación cancelada');
+            return;
+        }
+        const spin = this.uiPort.spinner('Creando repositorio...');
+        const repo = await this.gitHubService.createRepo({
+            name: name.trim(),
+            description: description.trim() || undefined,
+            visibility,
+            autoInit,
+            gitignoreTemplate,
+            licenseTemplate,
+        });
+        spin.stop();
+        this.uiPort.success(`  ✓ Repositorio creado exitosamente!`);
+        this.uiPort.log(`  🔗 URL: ${c.info(repo.htmlUrl)}`);
+        this.uiPort.log(`  📥 HTTPS: ${c.info(repo.cloneUrl)}`);
+        this.uiPort.log(`  📥 SSH: ${c.info(repo.sshUrl)}`);
+    }
+    async archiveRepo() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        const spin = this.uiPort.spinner('Cargando repositorios...');
+        const repos = await this.gitHubService.listRepos();
+        spin.stop();
+        if (repos.length === 0) {
+            this.uiPort.warning('  No tienes repositorios');
+            return;
+        }
+        const repoChoices = repos.map((r) => ({
+            name: `${r.fullName} ${r.archived ? c.tenue('[ARCHIVADO]') : ''}`,
+            value: r.fullName,
+        }));
+        const selectedRepo = await this.uiPort.select('Selecciona un repositorio:', repoChoices);
+        const [owner, repoName] = selectedRepo.split('/');
+        const repo = repos.find((r) => r.fullName === selectedRepo);
+        const action = await this.uiPort.select('¿Qué deseas hacer?', [
+            { name: repo.archived ? 'Desarchivar repositorio' : 'Archivar repositorio', value: repo.archived ? 'unarchive' : 'archive' },
+            { name: 'Volver', value: 'back' },
+        ]);
+        if (action === 'back')
+            return;
+        const confirmMsg = action === 'archive'
+            ? `¿Seguro que quieres ARCHIVAR ${repo.fullName}?`
+            : `¿Seguro que quieres DESARCHIVAR ${repo.fullName}?`;
+        const confirm = await this.uiPort.confirm(confirmMsg, false);
+        if (!confirm) {
+            this.uiPort.warning('  Operación cancelada');
+            return;
+        }
+        const spin2 = this.uiPort.spinner(action === 'archive' ? 'Archivando repositorio...' : 'Desarchivando repositorio...');
+        if (action === 'archive') {
+            await this.gitHubService.archiveRepo(owner, repoName);
+        }
+        else {
+            await this.gitHubService.unarchiveRepo(owner, repoName);
+        }
+        spin2.stop();
+        this.uiPort.success(`  ✓ Repositorio ${action === 'archive' ? 'archivado' : 'desarchivado'} correctamente`);
+    }
+    async cloneRepo() {
+        const c = this.uiColors;
+        this.uiPort.log('');
+        const spin = this.uiPort.spinner('Cargando repositorios...');
+        const repos = await this.gitHubService.listRepos();
+        spin.stop();
+        if (repos.length === 0) {
+            this.uiPort.warning('  No tienes repositorios');
+            return;
+        }
+        const repoChoices = repos.map((r) => ({ name: r.fullName, value: r }));
+        const selectedRepo = await this.uiPort.select('Selecciona un repositorio:', repoChoices);
+        const cloneMethod = await this.uiPort.select('Método de clonación:', [
+            { name: 'HTTPS', value: 'https' },
+            { name: 'SSH', value: 'ssh' },
+        ]);
+        const cloneUrl = cloneMethod === 'https' ? selectedRepo.cloneUrl : selectedRepo.sshUrl;
+        const defaultDest = selectedRepo.name;
+        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());
+            spinClone.stop();
+            const destPath = path.join(process.cwd(), dest.trim());
+            this.uiPort.success(`  ✓ Repositorio clonado en: ${c.info(destPath)}`);
+        }
+        catch (err) {
+            spinClone.stop();
+            throw err;
+        }
+    }
+}

package/dist/commands/github/GitHubWorkflowsCommand.js

@@ -0,0 +1,243 @@
+import { BaseGitHubCommand } from './BaseGitHubCommand.js';
+export class GitHubWorkflowsCommand extends BaseGitHubCommand {
+    async execute() {
+        if (!(await this.ensureAuthenticated()))
+            return;
+        try {
+            const c = this.uiColors;
+            let continuar = true;
+            while (continuar) {
+                this.uiPort.log('');
+                this.uiPort.log(c.titulo('  ⚙️ Gestión de GitHub Actions'));
+                this.uiPort.separator();
+                const action = await this.uiPort.select('¿Qué deseas hacer?', [
+                    { name: 'Ver workflows de un repositorio', value: 'list' },
+                    { name: 'Ver runs de un workflow', value: 'runs' },
+                    { name: 'Habilitar/Deshabilitar workflow', value: 'toggle' },
+                    { name: 'Disparar workflow manualmente', value: 'dispatch' },
+                    { name: 'Volver', value: 'back' },
+                ]);
+                switch (action) {
+                    case 'list':
+                        await this.listWorkflows();
+                        break;
+                    case 'runs':
+                        await this.listWorkflowRuns();
+                        break;
+                    case 'toggle':
+                        await this.toggleWorkflow();
+                        break;
+                    case 'dispatch':
+                        await this.dispatchWorkflow();
+                        break;
+                    case 'back':
+                        continuar = false;
+                        break;
+                }
+                if (continuar && action !== 'back') {
+                    await this.uiPort.pause();
+                }
+            }
+        }
+        catch (err) {
+            this.uiPort.error(`  ✗ ${err.message}`);
+        }
+    }
+    async selectRepo() {
+        const spin = this.uiPort.spinner('Cargando repositorios...');
+        const repos = await this.gitHubService.listRepos();
+        spin.stop();
+        if (repos.length === 0) {
+            this.uiPort.warning('  No tienes repositorios');
+            return null;
+        }
+        const repoChoices = repos.map((r) => ({ name: r.fullName, value: r.fullName }));
+        const selectedRepo = await this.uiPort.select('Selecciona un repositorio:', repoChoices);
+        const [owner, repo] = selectedRepo.split('/');
+        return { owner, repo };
+    }
+    async listWorkflows() {
+        const c = this.uiColors;
+        const repo = await this.selectRepo();
+        if (!repo)
+            return;
+        const spin = this.uiPort.spinner('Cargando workflows...');
+        const workflows = await this.gitHubService.listWorkflows(repo.owner, repo.repo);
+        spin.stop();
+        if (workflows.length === 0) {
+            this.uiPort.warning('  Este repositorio no tiene workflows');
+            return;
+        }
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo(`  📋 ${workflows.length} workflows encontrados`));
+        this.uiPort.separator();
+        workflows.forEach((workflow, index) => {
+            const stateBadge = this.getStateBadge(workflow.state);
+            this.uiPort.log(`  ${c.info(`${index + 1}.`)} ${c.titulo(workflow.name)} ${stateBadge}`);
+            this.uiPort.log(c.tenue(`     Archivo: ${workflow.path}`));
+            this.uiPort.log(c.tenue(`     Última actualización: ${new Date(workflow.updatedAt).toLocaleDateString('es-CL')}`));
+            this.uiPort.log(c.tenue(`     🔗 URL: ${workflow.htmlUrl}`));
+            this.uiPort.log('');
+        });
+    }
+    async listWorkflowRuns() {
+        const repo = await this.selectRepo();
+        if (!repo)
+            return;
+        const c = this.uiColors;
+        const spin = this.uiPort.spinner('Cargando workflows...');
+        const workflows = await this.gitHubService.listWorkflows(repo.owner, repo.repo);
+        spin.stop();
+        if (workflows.length === 0) {
+            this.uiPort.warning('  Este repositorio no tiene workflows');
+            return;
+        }
+        const workflowChoices = workflows.map((w) => ({ name: w.name, value: w }));
+        const selectedWorkflow = await this.uiPort.select('Selecciona un workflow:', workflowChoices);
+        const useFilters = await this.uiPort.confirm('¿Deseas aplicar filtros?', false);
+        let filters = {};
+        if (useFilters) {
+            const status = await this.uiPort.select('Estado:', [
+                { name: 'Todos', value: '' },
+                { name: 'Éxito', value: 'success' },
+                { name: 'Fallido', value: 'failure' },
+                { name: 'En progreso', value: 'in_progress' },
+                { name: 'Cancelado', value: 'cancelled' },
+            ]);
+            if (status)
+                filters.status = status;
+            const branch = await this.uiPort.input('Rama (deja vacío):');
+            if (branch.trim())
+                filters.branch = branch.trim();
+        }
+        const spinRuns = this.uiPort.spinner('Cargando runs...');
+        const runs = await this.gitHubService.listWorkflowRuns(repo.owner, repo.repo, Object.keys(filters).length > 0 ? filters : undefined);
+        spinRuns.stop();
+        if (runs.length === 0) {
+            this.uiPort.warning('  No hay runs para este workflow');
+            return;
+        }
+        this.uiPort.log('');
+        this.uiPort.log(c.titulo(`  📋 ${runs.length} runs encontrados`));
+        this.uiPort.separator();
+        runs.forEach((run, index) => {
+            const conclusionBadge = this.getConclusionBadge(run.status, run.conclusion);
+            this.uiPort.log(`  ${c.info(`${index + 1}.`)} ${c.titulo(run.name || 'Unnamed workflow')} ${conclusionBadge}`);
+            this.uiPort.log(c.tenue(`     Rama: ${run.headBranch || 'N/A'} | SHA: ${run.headSha.substring(0, 7)}`));
+            if (run.actor) {
+                this.uiPort.log(c.tenue(`     Autor: ${run.actor.login}`));
+            }
+            this.uiPort.log(c.tenue(`     Creado: ${new Date(run.createdAt).toLocaleDateString('es-CL')}`));
+            this.uiPort.log(c.tenue(`     🔗 URL: ${run.htmlUrl}`));
+            this.uiPort.log('');
+        });
+    }
+    async toggleWorkflow() {
+        const repo = await this.selectRepo();
+        if (!repo)
+            return;
+        const spin = this.uiPort.spinner('Cargando workflows...');
+        const workflows = await this.gitHubService.listWorkflows(repo.owner, repo.repo);
+        spin.stop();
+        if (workflows.length === 0) {
+            this.uiPort.warning('  Este repositorio no tiene workflows');
+            return;
+        }
+        const workflowChoices = workflows.map((w) => ({
+            name: `${w.name} ${this.getStateBadge(w.state)}`,
+            value: w,
+        }));
+        const selectedWorkflow = await this.uiPort.select('Selecciona un workflow:', workflowChoices);
+        const isEnabled = selectedWorkflow.state === 'active';
+        const action = await this.uiPort.select('¿Qué deseas hacer?', [
+            { name: isEnabled ? 'Deshabilitar workflow' : 'Habilitar workflow', value: isEnabled ? 'disable' : 'enable' },
+            { name: 'Volver', value: 'back' },
+        ]);
+        if (action === 'back')
+            return;
+        const confirmMsg = action === 'enable'
+            ? `¿Seguro que quieres HABILITAR ${selectedWorkflow.name}?`
+            : `¿Seguro que quieres DESHABILITAR ${selectedWorkflow.name}?`;
+        const confirm = await this.uiPort.confirm(confirmMsg, false);
+        if (!confirm) {
+            this.uiPort.warning('  Operación cancelada');
+            return;
+        }
+        const spin2 = this.uiPort.spinner(action === 'enable' ? 'Habilitando workflow...' : 'Deshabilitando workflow...');
+        if (action === 'enable') {
+            await this.gitHubService.enableWorkflow(repo.owner, repo.repo, selectedWorkflow.id);
+        }
+        else {
+            await this.gitHubService.disableWorkflow(repo.owner, repo.repo, selectedWorkflow.id);
+        }
+        spin2.stop();
+        this.uiPort.success(`  ✓ Workflow ${action === 'enable' ? 'habilitado' : 'deshabilitado'} correctamente`);
+    }
+    async dispatchWorkflow() {
+        const repo = await this.selectRepo();
+        if (!repo)
+            return;
+        const spin = this.uiPort.spinner('Cargando workflows...');
+        const workflows = await this.gitHubService.listWorkflows(repo.owner, repo.repo);
+        spin.stop();
+        if (workflows.length === 0) {
+            this.uiPort.warning('  Este repositorio no tiene workflows');
+            return;
+        }
+        const workflowChoices = workflows.map((w) => ({ name: w.name, value: w }));
+        const selectedWorkflow = await this.uiPort.select('Selecciona un workflow:', workflowChoices);
+        const ref = await this.uiPort.input('Rama o tag para ejecutar:', { default: 'main' });
+        const useInputs = await this.uiPort.confirm('¿Deseas agregar inputs?', false);
+        let inputs = {};
+        if (useInputs) {
+            while (true) {
+                const key = await this.uiPort.input('Nombre del input (deja vacío para terminar):');
+                if (!key.trim())
+                    break;
+                const value = await this.uiPort.input(`Valor para ${key}:`);
+                inputs[key.trim()] = value;
+            }
+        }
+        const confirm = await this.uiPort.confirm(`¿Disparar ${selectedWorkflow.name} en ${ref}?`, true);
+        if (!confirm) {
+            this.uiPort.warning('  Operación cancelada');
+            return;
+        }
+        const spin2 = this.uiPort.spinner('Disparando workflow...');
+        await this.gitHubService.triggerWorkflowDispatch(repo.owner, repo.repo, selectedWorkflow.id, ref, Object.keys(inputs).length > 0 ? inputs : undefined);
+        spin2.stop();
+        this.uiPort.success('  ✓ Workflow disparado correctamente');
+    }
+    getStateBadge(state) {
+        const c = this.uiColors;
+        switch (state) {
+            case 'active':
+                return c.exito('[ACTIVO]');
+            case 'disabled_manually':
+                return c.error('[DESHABILITADO]');
+            case 'disabled_inactivity':
+                return c.aviso('[INACTIVO]');
+            default:
+                return c.tenue(`[${state.toUpperCase()}]`);
+        }
+    }
+    getConclusionBadge(status, conclusion) {
+        const c = this.uiColors;
+        if (status === 'in_progress')
+            return c.titulo('[EN PROGRESO]');
+        if (status === 'queued')
+            return c.tenue('[EN COLA]');
+        switch (conclusion) {
+            case 'success':
+                return c.exito('[ÉXITO]');
+            case 'failure':
+                return c.error('[FALLO]');
+            case 'cancelled':
+                return c.aviso('[CANCELADO]');
+            case 'skipped':
+                return c.tenue('[SALTADO]');
+            default:
+                return c.tenue(`[${(conclusion || status).toUpperCase()}]`);
+        }
+    }
+}