{"meta":{"title":"Comandos de la CLI de solicitudes de incorporación de cambios apiladas","intro":"Busque todos los comandos, marcas y código de salida de la gh stack extensión en GitHub CLI.","product":"Solicitudes de incorporación de cambios","breadcrumbs":[{"href":"/es/pull-requests","title":"Solicitudes de incorporación de cambios"},{"href":"/es/pull-requests/reference","title":"Referencia"},{"href":"/es/pull-requests/reference/stacked-prs-cli-commands","title":"Comandos de la CLI de solicitudes de incorporación de cambios apiladas"}],"documentType":"article"},"body":"# Comandos de la CLI de solicitudes de incorporación de cambios apiladas\n\nBusque todos los comandos, marcas y código de salida de la gh stack extensión en GitHub CLI.\n\n> \\[!NOTE] Esta característica está en versión preliminar pública y está sujeta a cambios.\n\nLa `gh stack` extensión para GitHub CLI crea y administra pilas de solicitudes de incorporación de cambios del repositorio local. Para obtener una introducción a las pilas, consulte [Solicitudes de incorporación de cambios apiladas](/es/pull-requests/reference/stacked-pull-requests).\n\n## Installation\n\n```shell\ngh extension install github/gh-stack\n```\n\nLa extensión requiere GitHub CLI (`gh`) versión 2.0 o posterior.\n\n> \\[!NOTE]\n> La `gh stack` extensión usa la GitHub CLI autenticación. Si aún no se ha autenticado, ejecute `gh auth login`.\n\n## Resumen de comandos\n\n| Comando | Purpose |\n| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`gh stack init`](#gh-stack-init) | Inicialice una nueva pila en el repositorio actual. |\n| [`gh stack add`](#gh-stack-add) | Agregue una nueva rama en la parte superior de la pila actual. |\n| [`gh stack view`](#gh-stack-view) | Vea la pila actual. |\n| [`gh stack checkout`](#gh-stack-checkout) | Consulte una pila por número de pila, número de solicitud de incorporación de cambios, dirección URL de solicitud de incorporación de cambios o nombre de rama. |\n| [`gh stack modify`](#gh-stack-modify) | Reestructure interactivamente la pila actual. |\n| [`gh stack unstack`](#gh-stack-unstack) | Quite una pila del seguimiento local y desstackla en GitHub. |\n| [`gh stack submit`](#gh-stack-submit) | Inserte todas las ramas y, a continuación, cree o actualice las solicitudes de incorporación de cambios y la pila en GitHub. |\n| [`gh stack sync`](#gh-stack-sync) | Capture, vuelva a base, inserte y sincronice el estado de solicitud de incorporación de cambios en un solo comando. |\n| [`gh stack rebase`](#gh-stack-rebase) | Extraiga del control remoto y ejecute una base en cascada a través de la pila. |\n| [`gh stack push`](#gh-stack-push) | Inserte las ramas activas de la pila actual en el remoto. |\n| [`gh stack link`](#gh-stack-link) | Vincule las solicitudes de incorporación de cambios en una pila sin GitHub seguimiento local. |\n| [`gh stack merge`](#gh-stack-merge) | Combine una o varias solicitudes de incorporación de cambios apiladas a la vez. |\n| [`gh stack switch`](#gh-stack-switch) | Cambie interactivamente a otra rama de la pila. |\n| [`gh stack up`](#gh-stack-up) | Subir hacia la parte superior de la pila, lejos del tronco. |\n| [`gh stack down`](#gh-stack-down) | Baja hacia abajo hacia la parte inferior de la pila, hacia el tronco. |\n| [`gh stack top`](#gh-stack-top) | Vaya a la parte superior de la pila. |\n| [`gh stack bottom`](#gh-stack-bottom) | Vaya a la parte inferior de la pila. |\n| [`gh stack trunk`](#gh-stack-trunk) | Salta a la rama del tronco. |\n| [`gh stack alias`](#gh-stack-alias) | Cree un alias de comando corto para que pueda escribir menos. |\n| [`gh stack feedback`](#gh-stack-feedback) | Comparta comentarios sobre la `gh stack` extensión. |\n\n## Administración de la pila\n\n### `gh stack init`\n\nInicialice una nueva pila en el repositorio actual.\n\n```shell\ngh stack init [flags] [branches...]\n```\n\nInicializa una nueva pila localmente. En modo interactivo (sin argumentos), el comando solicita un nombre de rama y ofrece usar la rama actual como primera capa.\n\nAl proporcionar nombres de rama explícitos, las ramas existentes se adoptan automáticamente y se crean las ramas que faltan. El tronco tiene como valor predeterminado la rama predeterminada del repositorio, a menos que la invalide con `--base`.\n\nEl comando habilita `git rerere` automáticamente, de modo que las resoluciones de conflictos se recuerden entre rebases.\n\n| Flag | Description |\n| --------------------- | ----------------------------------------------------------------------------------------------- |\n| `-b, --base ` | Rama de tronco para la pila (el valor predeterminado es la rama predeterminada del repositorio) |\n\n**Ejemplos:**\n\n```shell\n# Interactive — prompts for branch names\ngh stack init\n\n# Non-interactive — specify first branch upfront\ngh stack init feature-auth\n\n# Use a different trunk branch\ngh stack init --base develop feature-auth\n\n# Adopt or create multiple branches at once\ngh stack init feature-auth feature-api feature-ui\n```\n\n### `gh stack add`\n\nAgregue una nueva rama en la parte superior de la pila actual.\n\n```shell\ngh stack add [flags] [branch]\n```\n\nCrea una nueva rama en el HEAD actual, la agrega a la parte superior de la pila y la desadifica. Debe ejecutar este comando mientras se encuentra en la rama superior de una pila. Si no proporciona un nombre de rama, el sistema solicita uno.\n\nOpcionalmente, puede almacenar provisionalmente los cambios y crear una confirmación como parte del `add` flujo. Cuando se proporciona `-m` sin un nombre de rama explícito, el nombre de la rama se genera automáticamente en formato de fecha y de slug, como `03-24-add_login`.\n\n| Flag | Description |\n| ------------------------ | ------------------------------------------------------------------------------------------------------- |\n| `-A, --all` | Almacenar provisionalmente todos los cambios, incluidos los archivos sin seguimiento. Se requiere `-m`. |\n| `-u, --update` | Solo se realizan cambios de fase en los archivos con seguimiento. Se requiere `-m`. |\n| `-m, --message ` | Cree una confirmación con este mensaje antes de crear la rama. |\n\n> \\[!NOTE]\n> `-A` y `-u` son mutuamente excluyentes.\n\n**Ejemplos:**\n\n```shell\n# Create a branch by name\ngh stack add api-routes\n\n# Prompt for a branch name interactively\ngh stack add\n\n# Stage all changes, commit, and auto-generate the branch name\ngh stack add -Am \"Add login endpoint\"\n\n# Stage only tracked files, commit, and auto-generate the branch name\ngh stack add -um \"Fix auth bug\"\n\n# Commit already-staged changes and auto-generate the branch name\ngh stack add -m \"Add user model\"\n\n# Stage all changes, commit, and use an explicit branch name\ngh stack add -Am \"Add tests\" test-layer\n\n# Stage only tracked files, commit, and use an explicit branch name\ngh stack add -um \"Update docs\" docs-layer\n```\n\n### `gh stack view`\n\nVea la pila actual.\n\n```shell\ngh stack view [flags]\n```\n\nMuestra todas las ramas de la pila, su ordenación, vínculos de solicitud de incorporación de cambios y la confirmación más reciente con una marca de tiempo relativa. La salida se canaliza a través de un buscapersonas, que respeta `GIT_PAGER` o `PAGER`, y el valor predeterminado es `less -R`.\n\n| Flag | Description |\n| ------------- | -------------------------------------- |\n| `-s, --short` | Salida compacta (solo nombres de rama) |\n| `--json` | Datos de pila de salida como JSON |\n\n**Ejemplos:**\n\n```shell\ngh stack view\ngh stack view --short\ngh stack view --json\n```\n\n### `gh stack checkout`\n\nConsulte una pila por su número de pila, un número de solicitud de incorporación de cambios, una dirección URL de solicitud de incorporación de cambios o un nombre de rama.\n\n```shell\ngh stack checkout [ | | | ]\n```\n\nUn número sin sistema se interpreta primero como un número de solicitud de incorporación de cambios o pila. Estos son identificadores con ámbito de repositorio que se muestran en la interfaz de GitHub usuario. Si nada coincide con el número, se intenta como un nombre de rama.\n\nAl hacer referencia a una pila remota, el comando captura la pila en GitHub, extrae las ramas y configura la pila localmente. Si la pila ya existe localmente y coincide, el comando cambia a la rama. Si las pilas locales y remotas tienen diferentes composiciones, se le pedirá que resuelva el conflicto.\n\nCuando se proporciona un nombre de rama, el comando lo resuelve solo en pilas con seguimiento local.\n\nCuando se ejecuta el comando sin argumentos en un terminal interactivo, se abre un selector en el que se pueden buscar, se enumeran todas las pilas disponibles, tanto las pilas de las que se realiza un seguimiento localmente como las pilas que solo existen en GitHub. Cada fila muestra el número de pila, su rama inferior y superior, rama base, una barra de estado que resume cuántos de sus solicitudes de incorporación de cambios se combinan, abren, cierran o aún no se insertan, y si la pila está disponible localmente o solo en el remoto. Filtre con las pestañas **Todos**, **Locales** y **Remotos** , o escriba `/` para buscar. Se omiten las pilas totalmente combinadas. Al seleccionar una pila solo remota, se clona localmente antes de cambiar a ella.\n\n**Ejemplos:**\n\n```shell\n# Check out a stack by its stack number\ngh stack checkout 7\n\n# Check out a stack by pull request number\ngh stack checkout 42\n\n# Check out a stack by pull request URL\ngh stack checkout https://github.com/owner/repo/pull/42\n\n# Check out a stack by branch name (local only)\ngh stack checkout feature-auth\n\n# Interactive — pick from all available stacks (local and remote)\ngh stack checkout\n```\n\n### `gh stack modify`\n\nReestructure interactivamente la pila actual.\n\n```shell\ngh stack modify [flags]\n```\n\nAbre una interfaz de usuario de terminal interactiva para reestructurar una pila. Todos los cambios se almacenan provisionalmente en la interfaz y se aplican juntos al presionar Ctrl+S. No se pueden modificar las ramas de las solicitudes de incorporación de cambios combinadas.\n\n| Flag | Description |\n| ------------ | --------------------------------------------------------------------------------------------- |\n| `--continue` | Continuar después de resolver conflictos |\n| `--abort` | Anule la sesión de modificación y restaure la pila en su estado antes de ejecutar el comando. |\n\n**Condiciones previas**\n\nEl comando comprueba estas condiciones antes de abrir la interfaz:\n\n1. Debe tener una pila activa desprotegida localmente.\n2. El árbol de trabajo debe estar limpio, sin cambios no confirmados.\n3. No hay ninguna base en curso.\n4. No se pone en cola ninguna solicitud de incorporación de cambios en la pila para la combinación.\n5. El historial de confirmaciones debe ser lineal, sin confirmaciones de combinación ni ramas diverged.\n\n**Operations**\n\n| Funcionamiento | Key | Effect |\n| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------ |\n| Drop | | |\n| x | Quite la rama y sus confirmaciones de la pila. Se conservan la rama local y la solicitud de incorporación de cambios asociadas. | |\n| Plegado hacia abajo | | |\n| d | Absorba confirmaciones en la rama siguiente, hacia el tronco. La rama plegada se quita de la pila. | |\n| Plegado hacia arriba | | |\n| u | Absorba confirmaciones en la rama anterior, lejos del tronco. La rama plegada se quita de la pila. | |\n| Insertar a continuación | | |\n| i | Inserte una nueva rama vacía debajo del cursor, hacia el tronco. | |\n| Insertar arriba | | |\n| Yo | Inserte una nueva rama vacía encima del cursor, lejos del tronco. | |\n| Bajar | | |\n| Mayús+↓ | Reordene la rama hacia abajo, hacia el tronco. | |\n| Subir | | |\n| Mayús+↑ | Reordene la rama hacia arriba, lejos del tronco. | |\n| Rename | | |\n| r | Cambie el nombre de la rama mediante un símbolo del sistema insertado. | |\n| Undo | | |\n| z | Deshacer la última acción preconfigurada. | |\n\n**Fase de aplicación**\n\nAl presionar Ctrl+S, los cambios almacenados provisionalmente se aplican mediante el cambio de nombre de las ramas, la inserción de nuevas ramas, el plegado o la colocación de ramas y la ejecución de una base de rebase en cascada para crear un historial de confirmaciones lineal con el estado de pila que desee.\n\nSi se produce un conflicto de rebase, puede:\n\n* Resuelva los conflictos, almacene provisionalmente los archivos y, a continuación, ejecute `gh stack modify --continue`.\n* Ejecute `gh stack modify --abort` para anular la operación y restaurar la pila en su estado anterior.\n\n**Después de modificar**\n\nSi ya ha creado una pila de solicitudes de incorporación de cambios en GitHub, ejecute `gh stack submit` para insertar las ramas actualizadas y volver a crear la pila. La pila anterior se reemplaza automáticamente.\n\n**Ejemplos:**\n\n```shell\n# Open the interactive modify interface\ngh stack modify\n\n# Continue after resolving a conflict\ngh stack modify --continue\n\n# Abort and restore to the previous state\ngh stack modify --abort\n```\n\n### `gh stack unstack`\n\nQuite una pila del seguimiento local y desstackla en GitHub. Este comando también está disponible como `gh stack delete`.\n\n```shell\ngh stack unstack [] [flags]\n```\n\nSin ningún argumento, el comando tiene como destino la pila activa, que es la pila que contiene la rama desprotegida actualmente. Desapila la pila en GitHub y quita el seguimiento local.\n\nProporcione un número de pila, el identificador que se muestra en la interfaz de usuario de pila en GitHub, para desmontar una pila específica. Esto funciona desde cualquier lugar del repositorio, independientemente de si la pila se desprotegió localmente, ya que la pila se desmonta directamente a través de la GitHub API. Cuando la pila también está disponible localmente, también se quita su seguimiento local.\n\nLas solicitudes de incorporación de cambios combinadas, combinadas o en cola para la combinación no se pueden quitar de una pila en GitHub y permanecer parte de la pila. Cuando se quita cada solicitud de incorporación de cambios, la pila se disuelva y se quita cualquier seguimiento local. Cuando algunas solicitudes de incorporación de cambios permanecen apiladas, la pila se mantiene y el seguimiento local, si existe, no se modifica. Use `--local` para omitir la operación remota y quitar solo el seguimiento local.\n\nEste comando es útil cuando necesita reestructurar una pila quitando una rama, insertando una rama, reordenando ramas, cambiando el nombre de las ramas o realizando otros cambios grandes. Después de desmontar, use `gh stack init` para volver a crear la pila con la estructura que desee. Las ramas existentes se adoptan automáticamente.\n\n| Flag | Description |\n| --------- | ---------------------------------------------------------- |\n| `--local` | Quitar solo la pila localmente, mantenerla activada GitHub |\n\n**Ejemplos:**\n\n```shell\n# Unstack the current stack on GitHub and remove local tracking\ngh stack unstack\n\n# Unstack a specific stack by its number\ngh stack unstack 7\n\n# Only remove local tracking\ngh stack unstack --local\n```\n\n## Operaciones remotas\n\n### `gh stack submit`\n\nInserte todas las ramas y, a continuación, cree o actualice las solicitudes de incorporación de cambios y la pila en GitHub.\n\n```shell\ngh stack submit [flags]\n```\n\nCrea una solicitud de incorporación de cambios para cada rama de la pila, insertando ramas en el remoto. Después de crear solicitudes de incorporación de cambios, `submit` crea automáticamente una pila en GitHub para vincular las solicitudes de incorporación de cambios. Si la pila ya existe en GitHub, por ejemplo desde un envío anterior, se agregan nuevas solicitudes de incorporación de cambios a la pila existente.\n\nSi todas las solicitudes de incorporación de cambios de la pila ya se han combinado, esa pila está completa y no se puede extender. En ese caso, `submit` inicia automáticamente una nueva pila raíz en el tronco para las ramas no combinadas y la crea en GitHub, dejando sin modificar la pila combinada.\n\nEn un terminal interactivo, `submit` abre un editor de pantalla completa en una sola pantalla.\n\n* **Panel izquierdo.** Todas las ramas sin una solicitud de incorporación de cambios se incluyen de forma predeterminada. Anule la selección de cualquiera que no quiera enviar con Ctrl+X. Dado que cada solicitud de incorporación de cambios se basa en la rama debajo de ella, la selección de una rama también anula la selección de las apiladas encima de ella y vuelve a incluir una rama que incluye las debajo de ella de las que depende. Las ramas que ya tienen una solicitud de incorporación de cambios, ya sean abiertas, borradores, en cola o combinadas, se muestran para el contexto, pero están bloqueadas. Edite los de la Web.\n* **Panel derecho.** Para la rama centrada, redacte el título y la descripción y elija si la solicitud de incorporación de cambios se abre lista para su revisión o como borrador. La descripción se rellena previamente desde la plantilla o confirmaciones de solicitud de incorporación de cambios del repositorio, con una vista previa de Markdown y un `$EDITOR` escape. El enfoque de una rama bloqueada muestra una tarjeta de solo lectura con un vínculo a su solicitud de incorporación de cambios. Presione o para abrirlo en el explorador.\n\nPresione Ctrl+S para enviar todas las solicitudes de incorporación de cambios incluidas a la vez. El editor admite la entrada de teclado y mouse. Pase `--auto`o ejecute el comando en un terminal no interactivo, como CI, para omitir el editor y usar títulos generados automáticamente.\n\nSi las ramas ya tienen solicitudes de incorporación de cambios abiertas, pero no existe ninguna pila en GitHub, tiene la opción de vincular las solicitudes de incorporación de cambios a una pila con Ctrl+B.\n\nEn el editor, las nuevas solicitudes de incorporación de cambios están listas para su revisión. Puede voltear cualquier solicitud de incorporación de cambios a borrador con el botón de alternancia. Con `--auto`, las nuevas solicitudes de incorporación de cambios se crean como borradores a menos que pase `--open`.\n\n| Flag | Description |\n| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `--auto` | Omitir el editor y usar títulos de solicitud de incorporación de cambios generados automáticamente |\n| `--open` | Cree nuevas solicitudes de incorporación de cambios como listas para su revisión en lugar de borradores y marque las solicitudes de incorporación de cambios existentes como listas para su revisión. |\n| `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) |\n\n**Ejemplos:**\n\n```shell\ngh stack submit\ngh stack submit --auto\ngh stack submit --open\n```\n\n### `gh stack sync`\n\nCapture, vuelva a base, inserte y sincronice el estado de solicitud de incorporación de cambios en un solo comando.\n\n```shell\ngh stack sync [flags]\n```\n\nSincroniza toda la pila.\n\n1. **Traer.** Captura los cambios más recientes de `origin`.\n2. **Reconciliar la pila remota.** Refleja la pila en GitHub localmente. Cuando se han agregado solicitudes de incorporación de cambios a la pila en GitHub, de modo que el remoto esté delante de la pila local, sus ramas se extraen y se anexan automáticamente a la pila local. Cuando las pilas locales y remotas se han divergido originalmente, por ejemplo, porque agregó una rama localmente mientras se agregaron diferentes solicitudes de incorporación de cambios a la pila en GitHub, se le pedirá que resuelva la diferencia. Consulte [Pilas diverged](#diverged-stacks). En un terminal no interactivo, una divergencia anula la sincronización y nada se inserta o actualiza.\n3. **Tronco rápido hacia delante.** Avanza rápidamente la rama del tronco para que coincida con el remoto. Este paso se omite si las ramas se han divergido.\n4. **Base en cascada.** Vuelve a base de todas las ramas de pila en sus elementos primarios actualizados, pero solo si se mueve el tronco. Si se detecta un conflicto, todas las ramas se restauran a su estado original y se recomienda ejecutar `gh stack rebase` para resolver los conflictos de forma interactiva.\n5. **Push.** Inserta todas las ramas mediante `--force-with-lease` si se produjo una base de datos.\n6. **Sincronizar solicitudes de incorporación de cambios.** Sincroniza el estado de la solicitud de incorporación de cambios de GitHub e informa del estado de cada solicitud de incorporación de cambios.\n7. **Sincronice la pila.** Vincula las solicitudes de incorporación de cambios abiertas de la pila en una pila en GitHub, creando el objeto de pila remota si aún no existe o actualizándolo si se forma parcialmente. Esto solo sucede cuando existen dos o más solicitudes de incorporación de cambios. La sincronización nunca abre solicitudes de incorporación de cambios. Úselo `gh stack submit` para eso.\n8. **Prune.** En terminales interactivos, se le pide que elimine las ramas locales para las solicitudes de incorporación de cambios combinadas. Use `--prune` para eliminar automáticamente.\n\nUna actualización remota limpia, donde se agregan solicitudes de incorporación de cambios sobre la pila local, se extrae automáticamente sin preguntar, por lo que `sync` es seguro ejecutarse en la automatización. La sincronización solo solicita cuándo las pilas se han divergido realmente.\n\n#### Pilas divergidas\n\nCuando ninguna pila es un prefijo limpio del otro, por ejemplo, porque agregó una rama localmente mientras se agregaron solicitudes de incorporación de cambios independientes a la misma pila en GitHub, la sincronización no puede combinar las dos automáticamente. En un terminal interactivo, ofrece tres opciones.\n\n* **Use la pila remota como origen de la verdad.** Reemplaza la composición de la pila local por el control remoto y extrae las ramas que faltan. Si se encontraba en una rama que la pila remota ya no contiene, se le moverá a la rama de supervivencia más cercana. Esto requiere un estado de trabajo limpio sin cambios no confirmados.\n* **Elimine la pila en GitHub.** Elimina el objeto de pila en GitHub y detiene la sincronización. Las solicitudes de incorporación de cambios y las ramas locales no se modifican y solo se quita la pila de GitHub . Vuelva a crear la pila con `gh stack submit`, ejecutándose `gh stack modify` primero si desea cambiar su estructura. Esta es la manera de hacer coincidir GitHub la pila local, ya que `submit`, a diferencia `sync`de , también crea solicitudes de incorporación de cambios para las ramas que aún no se han enviado.\n* **Cancelar.** Anula la sincronización sin insertar ramas ni actualizar las solicitudes de incorporación de cambios.\n\nEn un terminal no interactivo, una divergencia anula la sincronización, saliendo correctamente, sin insertar ramas ni actualizar solicitudes de incorporación de cambios. Para resolverlo, desstacking y volver a crear la pila.\n\n| Flag | Description |\n| ----------------- | --------------------------------------------------------------------------------------------------- |\n| `--remote ` | Remoto para capturar e insertar en (el valor predeterminado es el remoto detectado automáticamente) |\n| `--prune` | Eliminación de ramas locales para solicitudes de incorporación de cambios combinadas |\n\n**Ejemplos:**\n\n```shell\ngh stack sync\n\n# Sync and automatically prune merged branches\ngh stack sync --prune\n```\n\n### `gh stack rebase`\n\nExtraiga del control remoto y ejecute una base en cascada a través de la pila.\n\n```shell\ngh stack rebase [flags] [branch]\n```\n\nCaptura los cambios más recientes de `origin`y garantiza que cada rama de la pila tenga la punta de la capa anterior en su historial de confirmaciones. Las ramas se vuelven a base en orden, desde el tronco hacia arriba.\n\nSi se ha combinado la solicitud de incorporación de cambios de una rama, la base cambia automáticamente al `--onto` modo para reproducir correctamente las confirmaciones en la parte superior del destino de combinación.\n\nSi se produce un conflicto de rebase, la operación pausa e imprime los archivos en conflicto con números de línea. Resuelva los conflictos, preconfigurarlos con `git add`y, a continuación, continúe con `--continue`. Para deshacer toda la base de datos, use `--abort` para restaurar todas las ramas a su estado antes de la rebase.\n\n| Flag | Description |\n| --------------------------------- | ------------------------------------------------------------------------------------------------------- |\n| `--downstack` | Solo rebase las ramas del tronco a la rama actual |\n| `--upstack` | Solo las ramas de base de la rama actual a la parte superior |\n| `--no-trunk` | Omita el tronco. Solo se bifurca la pila de rebase entre sí, sin captura ni base de tronco. |\n| `--continue` | Continuar con la base de datos después de resolver conflictos |\n| `--abort` | Anule la base de datos y restaure todas las ramas en su estado antes de la rebase. |\n| `--remote ` | Remoto para capturar desde (el valor predeterminado es el remoto detectado automáticamente) |\n| `--committer-date-is-author-date` | Establezca la fecha de confirmación en la fecha del autor durante la rebase. Alias: `--preserve-dates`. |\n\n| Argumento | Description |\n| ---------- | ----------------------------------------------------------- |\n| `[branch]` | Rama de destino (el valor predeterminado es la rama actual) |\n\n**Ejemplos:**\n\n```shell\n# Rebase the entire stack\ngh stack rebase\n\n# Only rebase branches below the current one\ngh stack rebase --downstack\n\n# Only rebase branches above the current one\ngh stack rebase --upstack\n\n# Rebase stack branches without pulling from or rebasing with trunk\ngh stack rebase --no-trunk\n\n# After resolving a conflict\ngh stack rebase --continue\n\n# Abort rebase and restore everything\ngh stack rebase --abort\n\n# Rebase and preserve committer date as author date\ngh stack rebase --committer-date-is-author-date\n```\n\n### `gh stack push`\n\nInserte las ramas activas de la pila actual en el remoto.\n\n```shell\ngh stack push [flags]\n```\n\nInserta cada rama activa, excepto las ramas combinadas y en cola, en un solo `git push`, mediante una comprobación explícita por rama `--force-with-lease` . La actualización no es atómica. Ramas cuyas concesiones se pueden actualizar incluso si se rechaza otra rama. Corrija la rama rechazada y vuelva a ejecutar el comando. Las ramas que ya se actualizaron permanecen sin cambios. Este comando no crea ni actualiza solicitudes de incorporación de cambios. Úselo `gh stack submit` para eso.\n\n| Flag | Description |\n| ----------------- | ----------------------------------------------------------------------------------------- |\n| `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) |\n\n**Ejemplos:**\n\n```shell\ngh stack push\ngh stack push --remote upstream\n```\n\n### `gh stack link`\n\nVincule las solicitudes de incorporación de cambios en una pila sin GitHub seguimiento local.\n\n```shell\ngh stack link [flags] [...]\n```\n\nCrea o actualiza una pila a GitHub partir de nombres de rama o números de solicitud de incorporación de cambios y direcciones URL. Este comando no crea ni modifica ningún estado de seguimiento local. Está diseñado para personas que administran ramas con otras herramientas localmente, como Jujutsu, Sapling o git-town, y quieren abrir una pila de solicitudes de incorporación de cambios. Consulte [Uso de otras herramientas con solicitudes de incorporación de cambios apiladas](/es/pull-requests/reference/use-other-tools-with-stacked-pull-requests).\n\nProporcione argumentos en orden de pila, de abajo a arriba. Los argumentos de rama se insertan automáticamente en el remoto antes de crear o buscar solicitudes de incorporación de cambios. En el caso de las ramas que ya tienen solicitudes de incorporación de cambios abiertas, se usan esas solicitudes de incorporación de cambios. En el caso de las ramas sin solicitudes de incorporación de cambios, las nuevas solicitudes de incorporación de cambios se crean automáticamente con el encadenamiento de rama base correcto. Las solicitudes de incorporación de cambios existentes cuya rama base no coincide con la cadena esperada se corrigen automáticamente.\n\nSi las solicitudes de incorporación de cambios aún no están en una pila, se crea una nueva pila. Si algunas de las solicitudes de incorporación de cambios ya están en una pila, la pila existente se actualiza para incluir las nuevas solicitudes de incorporación de cambios. Las solicitudes de incorporación de cambios existentes nunca se quitan de una pila, ya que la actualización solo es suma.\n\nPara aumentar una pila existente sin volver a enumerar sus solicitudes de incorporación de cambios, pase un número de pila, el número que se muestra en la interfaz de usuario de pila en GitHub, como primer argumento. Los argumentos restantes se anexan a la parte superior de esa pila. Los argumentos que ya están en la pila se omiten y se rechazan los argumentos que pertenecen a una pila diferente. Dado que los números de solicitud de incorporación de cambios y pila nunca se superponen, un primer argumento numérico se trata como una pila solo cuando coincide con una pila existente. De lo contrario, se trata como una solicitud de incorporación de cambios o una rama.\n\n| Flag | Description |\n| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `--base ` | Rama base para la parte inferior de la pila (el valor predeterminado es la rama predeterminada del repositorio). Esta marca se omite cuando se agrega a una pila existente. |\n| `--open` | Marcar las solicitudes de incorporación de cambios nuevas y existentes como listas para su revisión |\n| `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) |\n\n**Ejemplos:**\n\n```shell\n# Link branches into a stack (pushes, creates pull requests, creates stack)\ngh stack link feature-auth feature-api feature-ui\n\n# Link existing pull requests by number\ngh stack link 10 20 30\n\n# Link existing pull requests by URL\ngh stack link https://github.com/owner/repo/pull/10 https://github.com/owner/repo/pull/20\n\n# Add branches to an existing stack of pull requests\ngh stack link 42 43 feature-auth feature-ui\n\n# Append to the top of an existing stack by its stack number, with no need\n# to list the pull requests already in stack 7 again\ngh stack link 7 48 feature-ui\n\n# Use a different base branch and mark pull requests as ready for review\ngh stack link --base develop --open feat-a feat-b feat-c\n```\n\n### `gh stack merge`\n\nCombine una o varias solicitudes de incorporación de cambios apiladas a la vez.\n\n```shell\ngh stack merge [ | ]\n```\n\nCombina todas las solicitudes de incorporación de cambios de la pila, hasta e incluye la solicitud de incorporación de cambios que elija, en la rama base. La combinación es una única operación de todo o nada. Si no se puede combinar alguna solicitud de incorporación de cambios, no se combina ninguna de ellas.\n\nSin ningún argumento, el comando usa la pila local activa. Proporcione un número de pila para combinar una pila que no haya desprotegido, que es una operación puramente remota, o proporcione un número de solicitud de incorporación de cambios para combinar directamente hasta esa solicitud de incorporación de cambios.\n\nEn un terminal interactivo, el sistema le pide que elija las solicitudes de incorporación de cambios que se van a combinar, elija el método merge y confirme. En un terminal no interactivo, o cuando se usa `--yes`, toda la pila o todo hasta la solicitud de incorporación de cambios que especifique, se combina sin preguntar, mediante el método de combinación que usó por última vez a menos que especifique uno.\n\nSolo se comprueba el estado básico de la solicitud de incorporación de cambios antes de la combinación. Cada solicitud de incorporación de cambios debe estar abierta y no debe ser un borrador.\nGitHub evalúa las reglas de repositorio y protección de rama cuando se ejecuta la combinación y se notifica cualquier error.\n\n> \\[!NOTE]\n> No se pueden omitir los requisitos de combinación al combinar solicitudes de incorporación de cambios apiladas.\n\nSi la rama base usa una cola de mezcla, la pila se agrega a la cola en lugar de combinarse directamente. La cola elige el método de combinación, por lo que la solicitud omite el paso del método de combinación y las `--merge-method`marcas , `--squash`, `--rebase`y `--merge` se omiten con una advertencia. Las solicitudes de incorporación de cambios que seleccione se agregan a la cola juntas, pero se combinan a medida que la cola las procesa, por lo que pueden llegar a grupos independientes en lugar de en todos a la vez.\n\n| Flag | Description |\n| ----------------------------------- | ------------------------------------------------------------------- |\n| `--merge-method ` | Método de combinación que se va a usar: `merge`, `squash`o `rebase` |\n| `--merge`, , `--squash`, `--rebase` | Abreviaturas del método de combinación correspondiente |\n| `-y, --yes` | Combinar sin solicitar confirmación |\n\n**Ejemplos:**\n\n```shell\n# Merge the current stack, choosing pull requests interactively\ngh stack merge\n\n# Merge a stack you do not have checked out, by stack number\ngh stack merge 7\n\n# Merge everything up to and including pull request 42\ngh stack merge 42\n\n# Merge the whole current stack without prompting, squashing commits\ngh stack merge --yes --squash\n```\n\n## Navegación\n\nLos comandos de navegación le mueven entre ramas de la pila actual sin tener que recordar nombres de rama. La parte inferior de la pila es la rama más cercana al tronco y la parte superior es la más alejada de ella.\n`up` se aleja del tronco y `down` se mueve hacia él.\n\nTodos los comandos de navegación fijan los límites de la pila. Subir desde la parte superior o hacia abajo desde la parte inferior, no hace nada y muestra un mensaje.\n\n### `gh stack switch`\n\nCambie interactivamente a otra rama de la pila.\n\n```shell\ngh stack switch\n```\n\nMuestra un selector interactivo que muestra todas las ramas de la pila actual, ordenadas desde arriba, más alejadas del tronco, hasta la parte inferior, más cercanas al tronco, con su número de posición. Seleccione una rama para desérsela.\n\nEste comando requiere un terminal interactivo.\n\n**Ejemplos:**\n\n```shell\ngh stack switch\n# → Select a branch in the stack to switch to\n# 5. frontend\n# 4. api-endpoints\n# 3. auth-layer\n# 2. db-schema\n# 1. config-setup\n```\n\n### `gh stack up`\n\nSubir hacia la parte superior de la pila, lejos del tronco.\n\n```shell\ngh stack up [n]\n```\n\nMueve las ramas ascendentes `n` , de forma predeterminada a 1. Si está en la rama del tronco, `up` se mueve a la primera rama de pila.\n\n**Ejemplos:**\n\n```shell\n# Move up one layer\ngh stack up\n\n# Move up three layers\ngh stack up 3\n```\n\n### `gh stack down`\n\nBaja hacia abajo hacia la parte inferior de la pila, hacia el tronco.\n\n```shell\ngh stack down [n]\n```\n\nMueve las ramas hacia abajo `n` , de forma predeterminada a 1.\n\n**Ejemplos:**\n\n```shell\n# Move down one layer\ngh stack down\n\n# Move down two layers\ngh stack down 2\n```\n\n### `gh stack top`\n\nVaya a la parte superior de la pila.\n\n```shell\ngh stack top\n```\n\nEcha un vistazo a la rama más alejada del tronco.\n\n### `gh stack bottom`\n\nVaya a la parte inferior de la pila.\n\n```shell\ngh stack bottom\n```\n\nEcha un vistazo a la rama más cercana al tronco.\n\n### `gh stack trunk`\n\nSalta a la rama del tronco.\n\n```shell\ngh stack trunk\n```\n\nComprueba la rama de tronco de la pila actual, como `main`. Debe estar en una rama que forme parte de una pila.\n\n## Utilities\n\n### `gh stack alias`\n\nCree un alias de comando corto para que pueda escribir menos.\n\n```shell\ngh stack alias [flags] [name]\n```\n\nInstala un script contenedor pequeño en `~/.local/bin/` que reenvía todos los argumentos a `gh stack`. El nombre de alias predeterminado es `gs`, pero puede elegir cualquier nombre pasándolo como argumento. Después de la instalación, puede ejecutar `gs push` en lugar de `gh stack push`.\n\nEn Windows, no se admite la creación automática de alias. El comando imprime instrucciones manuales para crear un archivo por lotes o una función de PowerShell.\n\n| Flag | Description |\n| ---------- | ---------------------------------------------- |\n| `--remove` | Eliminación de un alias que creó anteriormente |\n\n**Ejemplos:**\n\n```shell\n# Create the default alias (gs), so that \"gs push\" and \"gs view\" both work\ngh stack alias\n\n# Create a custom alias\ngh stack alias gst\n\n# Remove an alias\ngh stack alias --remove\ngh stack alias --remove gst\n```\n\n### `gh stack feedback`\n\nComparta comentarios sobre la `gh stack` extensión.\n\n```shell\ngh stack feedback [title]\n```\n\nAbre una discusión en el [repositorio gh-stack](https://github.com/github/gh-stack) para que pueda enviar comentarios. Opcionalmente, puede proporcionar un título para la publicación de discusión.\n\n**Ejemplos:**\n\n```shell\ngh stack feedback\ngh stack feedback \"Support for reordering branches\"\n```\n\n## Variables de entorno\n\n| Variable | Valores | Description |\n| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |\n| `GH_STACK_THEME` | | |\n| `auto` (predeterminado), `light`, `dark` | Controla la paleta de colores de las pantallas interactivas para `submit`, `modify`y `view`todos los resultados de comandos de color. Los colores se adaptan automáticamente al fondo del terminal. Establezca esta variable para forzar la paleta clara o oscura cuando un terminal no informa de su fondo, lo que puede ocurrir en algunas configuraciones o `tmux` SSH. | |\n\n```shell\n# Force the light palette for one command\nGH_STACK_THEME=light gh stack view\n```\n\n## Códigos de salida\n\n| Code | Meaning |\n| ------------------- | ----------------------------------------------------------------------------------------------- |\n| 0 | Success |\n| 1 | Error genérico |\n| 2 | No se encuentra en una pila o no se encuentra ninguna pila |\n| 3 | Conflicto de rebase |\n| 4 | |\n| GitHub Error de API | |\n| 5 | Argumentos o marcas no válidos |\n| 6 | Se requiere la desambiguación, porque la rama pertenece a varias pilas |\n| 7 | Rebase ya en curso |\n| 8 | La pila está bloqueada por otro proceso |\n| 9 | Las solicitudes de incorporación de cambios apiladas no están habilitadas para este repositorio |\n| 10 | Modificación de la sesión interrumpida y se requiere recuperación |\n\n## Lectura adicional\n\n* [Solicitudes de incorporación de cambios apiladas](/es/pull-requests/reference/stacked-pull-requests)\n* [Creación de solicitudes de incorporación de cambios apiladas](/es/pull-requests/how-tos/create-pull-requests/creating-stacked-pull-requests)\n* [Administración de solicitudes de incorporación de cambios apiladas](/es/pull-requests/how-tos/create-pull-requests/managing-stacked-pull-requests)\n* [Solución de problemas de solicitudes de incorporación de cambios apiladas](/es/pull-requests/how-tos/merge-and-close-pull-requests/troubleshooting-stacked-pull-requests)"}