# Comandos de la CLI de solicitudes de incorporación de cambios apiladas Busque todos los comandos, marcas y código de salida de la gh stack extensión en GitHub CLI. > \[!NOTE] Esta característica está en versión preliminar pública y está sujeta a cambios. La `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/enterprise-cloud@latest/pull-requests/reference/stacked-pull-requests). ## Installation ```shell gh extension install github/gh-stack ``` La extensión requiere GitHub CLI (`gh`) versión 2.0 o posterior. > \[!NOTE] > La `gh stack` extensión usa la GitHub CLI autenticación. Si aún no se ha autenticado, ejecute `gh auth login`. ## Resumen de comandos | Comando | Purpose | | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`gh stack init`](#gh-stack-init) | Inicialice una nueva pila en el repositorio actual. | | [`gh stack add`](#gh-stack-add) | Agregue una nueva rama en la parte superior de la pila actual. | | [`gh stack view`](#gh-stack-view) | Vea la pila actual. | | [`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. | | [`gh stack modify`](#gh-stack-modify) | Reestructure interactivamente la pila actual. | | [`gh stack unstack`](#gh-stack-unstack) | Quite una pila del seguimiento local y desstackla en GitHub. | | [`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. | | [`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. | | [`gh stack rebase`](#gh-stack-rebase) | Extraiga del control remoto y ejecute una base en cascada a través de la pila. | | [`gh stack push`](#gh-stack-push) | Inserte las ramas activas de la pila actual en el remoto. | | [`gh stack link`](#gh-stack-link) | Vincule las solicitudes de incorporación de cambios en una pila sin GitHub seguimiento local. | | [`gh stack merge`](#gh-stack-merge) | Combine una o varias solicitudes de incorporación de cambios apiladas a la vez. | | [`gh stack switch`](#gh-stack-switch) | Cambie interactivamente a otra rama de la pila. | | [`gh stack up`](#gh-stack-up) | Subir hacia la parte superior de la pila, lejos del tronco. | | [`gh stack down`](#gh-stack-down) | Baja hacia abajo hacia la parte inferior de la pila, hacia el tronco. | | [`gh stack top`](#gh-stack-top) | Vaya a la parte superior de la pila. | | [`gh stack bottom`](#gh-stack-bottom) | Vaya a la parte inferior de la pila. | | [`gh stack trunk`](#gh-stack-trunk) | Salta a la rama del tronco. | | [`gh stack alias`](#gh-stack-alias) | Cree un alias de comando corto para que pueda escribir menos. | | [`gh stack feedback`](#gh-stack-feedback) | Comparta comentarios sobre la `gh stack` extensión. | ## Administración de la pila ### `gh stack init` Inicialice una nueva pila en el repositorio actual. ```shell gh stack init [flags] [branches...] ``` Inicializa 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. Al 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`. El comando habilita `git rerere` automáticamente, de modo que las resoluciones de conflictos se recuerden entre rebases. | Flag | Description | | --------------------- | ----------------------------------------------------------------------------------------------- | | `-b, --base ` | Rama de tronco para la pila (el valor predeterminado es la rama predeterminada del repositorio) | **Ejemplos:** ```shell # Interactive — prompts for branch names gh stack init # Non-interactive — specify first branch upfront gh stack init feature-auth # Use a different trunk branch gh stack init --base develop feature-auth # Adopt or create multiple branches at once gh stack init feature-auth feature-api feature-ui ``` ### `gh stack add` Agregue una nueva rama en la parte superior de la pila actual. ```shell gh stack add [flags] [branch] ``` Crea 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. Opcionalmente, 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`. | Flag | Description | | ------------------------ | ------------------------------------------------------------------------------------------------------- | | `-A, --all` | Almacenar provisionalmente todos los cambios, incluidos los archivos sin seguimiento. Se requiere `-m`. | | `-u, --update` | Solo se realizan cambios de fase en los archivos con seguimiento. Se requiere `-m`. | | `-m, --message ` | Cree una confirmación con este mensaje antes de crear la rama. | > \[!NOTE] > `-A` y `-u` son mutuamente excluyentes. **Ejemplos:** ```shell # Create a branch by name gh stack add api-routes # Prompt for a branch name interactively gh stack add # Stage all changes, commit, and auto-generate the branch name gh stack add -Am "Add login endpoint" # Stage only tracked files, commit, and auto-generate the branch name gh stack add -um "Fix auth bug" # Commit already-staged changes and auto-generate the branch name gh stack add -m "Add user model" # Stage all changes, commit, and use an explicit branch name gh stack add -Am "Add tests" test-layer # Stage only tracked files, commit, and use an explicit branch name gh stack add -um "Update docs" docs-layer ``` ### `gh stack view` Vea la pila actual. ```shell gh stack view [flags] ``` Muestra 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`. | Flag | Description | | ------------- | -------------------------------------- | | `-s, --short` | Salida compacta (solo nombres de rama) | | `--json` | Datos de pila de salida como JSON | **Ejemplos:** ```shell gh stack view gh stack view --short gh stack view --json ``` ### `gh stack checkout` Consulte 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. ```shell gh stack checkout [ | | | ] ``` Un 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. Al 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. Cuando se proporciona un nombre de rama, el comando lo resuelve solo en pilas con seguimiento local. Cuando 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. **Ejemplos:** ```shell # Check out a stack by its stack number gh stack checkout 7 # Check out a stack by pull request number gh stack checkout 42 # Check out a stack by pull request URL gh stack checkout https://github.com/owner/repo/pull/42 # Check out a stack by branch name (local only) gh stack checkout feature-auth # Interactive — pick from all available stacks (local and remote) gh stack checkout ``` ### `gh stack modify` Reestructure interactivamente la pila actual. ```shell gh stack modify [flags] ``` Abre 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. | Flag | Description | | ------------ | --------------------------------------------------------------------------------------------- | | `--continue` | Continuar después de resolver conflictos | | `--abort` | Anule la sesión de modificación y restaure la pila en su estado antes de ejecutar el comando. | **Condiciones previas** El comando comprueba estas condiciones antes de abrir la interfaz: 1. Debe tener una pila activa desprotegida localmente. 2. El árbol de trabajo debe estar limpio, sin cambios no confirmados. 3. No hay ninguna base en curso. 4. No se pone en cola ninguna solicitud de incorporación de cambios en la pila para la combinación. 5. El historial de confirmaciones debe ser lineal, sin confirmaciones de combinación ni ramas diverged. **Operations** | Funcionamiento | Key | Effect | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------ | | Drop | | | | x | Quite la rama y sus confirmaciones de la pila. Se conservan la rama local y la solicitud de incorporación de cambios asociadas. | | | Plegado hacia abajo | | | | d | Absorba confirmaciones en la rama siguiente, hacia el tronco. La rama plegada se quita de la pila. | | | Plegado hacia arriba | | | | u | Absorba confirmaciones en la rama anterior, lejos del tronco. La rama plegada se quita de la pila. | | | Insertar a continuación | | | | i | Inserte una nueva rama vacía debajo del cursor, hacia el tronco. | | | Insertar arriba | | | | Yo | Inserte una nueva rama vacía encima del cursor, lejos del tronco. | | | Bajar | | | | Mayús+↓ | Reordene la rama hacia abajo, hacia el tronco. | | | Subir | | | | Mayús+↑ | Reordene la rama hacia arriba, lejos del tronco. | | | Rename | | | | r | Cambie el nombre de la rama mediante un símbolo del sistema insertado. | | | Undo | | | | z | Deshacer la última acción preconfigurada. | | **Fase de aplicación** Al 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. Si se produce un conflicto de rebase, puede: * Resuelva los conflictos, almacene provisionalmente los archivos y, a continuación, ejecute `gh stack modify --continue`. * Ejecute `gh stack modify --abort` para anular la operación y restaurar la pila en su estado anterior. **Después de modificar** Si 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. **Ejemplos:** ```shell # Open the interactive modify interface gh stack modify # Continue after resolving a conflict gh stack modify --continue # Abort and restore to the previous state gh stack modify --abort ``` ### `gh stack unstack` Quite una pila del seguimiento local y desstackla en GitHub. Este comando también está disponible como `gh stack delete`. ```shell gh stack unstack [] [flags] ``` Sin 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. Proporcione 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. Las 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. Este 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. | Flag | Description | | --------- | ---------------------------------------------------------- | | `--local` | Quitar solo la pila localmente, mantenerla activada GitHub | **Ejemplos:** ```shell # Unstack the current stack on GitHub and remove local tracking gh stack unstack # Unstack a specific stack by its number gh stack unstack 7 # Only remove local tracking gh stack unstack --local ``` ## Operaciones remotas ### `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. ```shell gh stack submit [flags] ``` Crea 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. Si 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. En un terminal interactivo, `submit` abre un editor de pantalla completa en una sola pantalla. * **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. * **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. Presione 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. Si 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. En 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`. | Flag | Description | | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `--auto` | Omitir el editor y usar títulos de solicitud de incorporación de cambios generados automáticamente | | `--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. | | `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) | **Ejemplos:** ```shell gh stack submit gh stack submit --auto gh stack submit --open ``` ### `gh stack sync` Capture, vuelva a base, inserte y sincronice el estado de solicitud de incorporación de cambios en un solo comando. ```shell gh stack sync [flags] ``` Sincroniza toda la pila. 1. **Traer.** Captura los cambios más recientes de `origin`. 2. **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. 3. **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. 4. **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. 5. **Push.** Inserta todas las ramas mediante `--force-with-lease` si se produjo una base de datos. 6. **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. 7. **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. 8. **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. Una 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. #### Pilas divergidas Cuando 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. * **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. * **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. * **Cancelar.** Anula la sincronización sin insertar ramas ni actualizar las solicitudes de incorporación de cambios. En 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. | Flag | Description | | ----------------- | --------------------------------------------------------------------------------------------------- | | `--remote ` | Remoto para capturar e insertar en (el valor predeterminado es el remoto detectado automáticamente) | | `--prune` | Eliminación de ramas locales para solicitudes de incorporación de cambios combinadas | **Ejemplos:** ```shell gh stack sync # Sync and automatically prune merged branches gh stack sync --prune ``` ### `gh stack rebase` Extraiga del control remoto y ejecute una base en cascada a través de la pila. ```shell gh stack rebase [flags] [branch] ``` Captura 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. Si 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. Si 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. | Flag | Description | | --------------------------------- | ------------------------------------------------------------------------------------------------------- | | `--downstack` | Solo rebase las ramas del tronco a la rama actual | | `--upstack` | Solo las ramas de base de la rama actual a la parte superior | | `--no-trunk` | Omita el tronco. Solo se bifurca la pila de rebase entre sí, sin captura ni base de tronco. | | `--continue` | Continuar con la base de datos después de resolver conflictos | | `--abort` | Anule la base de datos y restaure todas las ramas en su estado antes de la rebase. | | `--remote ` | Remoto para capturar desde (el valor predeterminado es el remoto detectado automáticamente) | | `--committer-date-is-author-date` | Establezca la fecha de confirmación en la fecha del autor durante la rebase. Alias: `--preserve-dates`. | | Argumento | Description | | ---------- | ----------------------------------------------------------- | | `[branch]` | Rama de destino (el valor predeterminado es la rama actual) | **Ejemplos:** ```shell # Rebase the entire stack gh stack rebase # Only rebase branches below the current one gh stack rebase --downstack # Only rebase branches above the current one gh stack rebase --upstack # Rebase stack branches without pulling from or rebasing with trunk gh stack rebase --no-trunk # After resolving a conflict gh stack rebase --continue # Abort rebase and restore everything gh stack rebase --abort # Rebase and preserve committer date as author date gh stack rebase --committer-date-is-author-date ``` ### `gh stack push` Inserte las ramas activas de la pila actual en el remoto. ```shell gh stack push [flags] ``` Inserta 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. | Flag | Description | | ----------------- | ----------------------------------------------------------------------------------------- | | `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) | **Ejemplos:** ```shell gh stack push gh stack push --remote upstream ``` ### `gh stack link` Vincule las solicitudes de incorporación de cambios en una pila sin GitHub seguimiento local. ```shell gh stack link [flags] [...] ``` Crea 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/enterprise-cloud@latest/pull-requests/reference/use-other-tools-with-stacked-pull-requests). Proporcione 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. Si 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. Para 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. | Flag | Description | | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `--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. | | `--open` | Marcar las solicitudes de incorporación de cambios nuevas y existentes como listas para su revisión | | `--remote ` | Remoto al que se inserta (el valor predeterminado es el remoto detectado automáticamente) | **Ejemplos:** ```shell # Link branches into a stack (pushes, creates pull requests, creates stack) gh stack link feature-auth feature-api feature-ui # Link existing pull requests by number gh stack link 10 20 30 # Link existing pull requests by URL gh stack link https://github.com/owner/repo/pull/10 https://github.com/owner/repo/pull/20 # Add branches to an existing stack of pull requests gh stack link 42 43 feature-auth feature-ui # Append to the top of an existing stack by its stack number, with no need # to list the pull requests already in stack 7 again gh stack link 7 48 feature-ui # Use a different base branch and mark pull requests as ready for review gh stack link --base develop --open feat-a feat-b feat-c ``` ### `gh stack merge` Combine una o varias solicitudes de incorporación de cambios apiladas a la vez. ```shell gh stack merge [ | ] ``` Combina 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. Sin 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. En 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. Solo 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. GitHub evalúa las reglas de repositorio y protección de rama cuando se ejecuta la combinación y se notifica cualquier error. > \[!NOTE] > No se pueden omitir los requisitos de combinación al combinar solicitudes de incorporación de cambios apiladas. Si 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. | Flag | Description | | ----------------------------------- | ------------------------------------------------------------------- | | `--merge-method ` | Método de combinación que se va a usar: `merge`, `squash`o `rebase` | | `--merge`, , `--squash`, `--rebase` | Abreviaturas del método de combinación correspondiente | | `-y, --yes` | Combinar sin solicitar confirmación | **Ejemplos:** ```shell # Merge the current stack, choosing pull requests interactively gh stack merge # Merge a stack you do not have checked out, by stack number gh stack merge 7 # Merge everything up to and including pull request 42 gh stack merge 42 # Merge the whole current stack without prompting, squashing commits gh stack merge --yes --squash ``` ## Navegación Los 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. `up` se aleja del tronco y `down` se mueve hacia él. Todos 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. ### `gh stack switch` Cambie interactivamente a otra rama de la pila. ```shell gh stack switch ``` Muestra 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. Este comando requiere un terminal interactivo. **Ejemplos:** ```shell gh stack switch # → Select a branch in the stack to switch to # 5. frontend # 4. api-endpoints # 3. auth-layer # 2. db-schema # 1. config-setup ``` ### `gh stack up` Subir hacia la parte superior de la pila, lejos del tronco. ```shell gh stack up [n] ``` Mueve 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. **Ejemplos:** ```shell # Move up one layer gh stack up # Move up three layers gh stack up 3 ``` ### `gh stack down` Baja hacia abajo hacia la parte inferior de la pila, hacia el tronco. ```shell gh stack down [n] ``` Mueve las ramas hacia abajo `n` , de forma predeterminada a 1. **Ejemplos:** ```shell # Move down one layer gh stack down # Move down two layers gh stack down 2 ``` ### `gh stack top` Vaya a la parte superior de la pila. ```shell gh stack top ``` Echa un vistazo a la rama más alejada del tronco. ### `gh stack bottom` Vaya a la parte inferior de la pila. ```shell gh stack bottom ``` Echa un vistazo a la rama más cercana al tronco. ### `gh stack trunk` Salta a la rama del tronco. ```shell gh stack trunk ``` Comprueba la rama de tronco de la pila actual, como `main`. Debe estar en una rama que forme parte de una pila. ## Utilities ### `gh stack alias` Cree un alias de comando corto para que pueda escribir menos. ```shell gh stack alias [flags] [name] ``` Instala 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`. En 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. | Flag | Description | | ---------- | ---------------------------------------------- | | `--remove` | Eliminación de un alias que creó anteriormente | **Ejemplos:** ```shell # Create the default alias (gs), so that "gs push" and "gs view" both work gh stack alias # Create a custom alias gh stack alias gst # Remove an alias gh stack alias --remove gh stack alias --remove gst ``` ### `gh stack feedback` Comparta comentarios sobre la `gh stack` extensión. ```shell gh stack feedback [title] ``` Abre 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. **Ejemplos:** ```shell gh stack feedback gh stack feedback "Support for reordering branches" ``` ## Variables de entorno | Variable | Valores | Description | | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | | `GH_STACK_THEME` | | | | `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. | | ```shell # Force the light palette for one command GH_STACK_THEME=light gh stack view ``` ## Códigos de salida | Code | Meaning | | ------------------- | ----------------------------------------------------------------------------------------------- | | 0 | Success | | 1 | Error genérico | | 2 | No se encuentra en una pila o no se encuentra ninguna pila | | 3 | Conflicto de rebase | | 4 | | | GitHub Error de API | | | 5 | Argumentos o marcas no válidos | | 6 | Se requiere la desambiguación, porque la rama pertenece a varias pilas | | 7 | Rebase ya en curso | | 8 | La pila está bloqueada por otro proceso | | 9 | Las solicitudes de incorporación de cambios apiladas no están habilitadas para este repositorio | | 10 | Modificación de la sesión interrumpida y se requiere recuperación | ## Lectura adicional * [Solicitudes de incorporación de cambios apiladas](/es/enterprise-cloud@latest/pull-requests/reference/stacked-pull-requests) * [Creating stacked pull requests](/es/enterprise-cloud@latest/pull-requests/how-tos/create-pull-requests/creating-stacked-pull-requests) * [Administración de solicitudes de incorporación de cambios apiladas](/es/enterprise-cloud@latest/pull-requests/how-tos/create-pull-requests/managing-stacked-pull-requests) * [Troubleshooting stacked pull requests](/es/enterprise-cloud@latest/pull-requests/how-tos/merge-and-close-pull-requests/troubleshooting-stacked-pull-requests)