> ## Documentation Index > Fetch the complete documentation index at: https://docs.tyba.dev/llms.txt > Use this file to discover all available pages before exploring further. # A linha de comando do TYBA > O prompt do shell sai da tela e a linha onde você digita vira um editor do app — com sugestão enquanto você escreve. Ajuda de digitação — sugestão em cinza, lista enquanto você escreve — **não é feature de terminal**. É feature de editor de texto. Numa grade de células que o shell pinta, não existe onde desenhar sugestão: o `zle` do zsh e o `readline` do bash são donos da linha, do cursor e do redesenho. A saída é não deixar o shell desenhar a linha. É isso que a **linha de comando do TYBA** faz: o `PS1` sai da tela e a caixa onde você digita passa a ser do app. **Vem ligada.** Instalação nova já abre com ela. Para desligar, use **Configurações → Code → Linha de comando do TYBA**, na chave *Usar a linha do TYBA*. A escolha vale para sessões **novas** — o modo entra no nascimento do shell, então a sessão já aberta segue como está. ## O que você ganha | | | | ----------------------------------------- | ------------------------------------------------------------------------------------------ | | **Sugestão em cinza** | O resto de um comando que você já rodou aparece à frente do cursor. `Tab` ou `→` aceita. | | **Completar comandos** | Desde a primeira letra, não só o que você repete — veja abaixo. | | **Histórico e snippets na própria linha** | `↑` e `↓` percorrem a lista sem abrir nada. Snippets aparecem marcados. | | **Caminhos do diretório atual** | Arquivos e pastas de onde você está também completam. | | **Edição de verdade** | Um comando longo se edita como texto, não como linha de terminal. | | **Blocos de comando** | Cada comando vira um cartão — veja [blocos de comando](/pt-br/terminal/blocos-de-comando). | ## Completar comandos A sugestão não depende mais de você já ter rodado aquilo. Cada parte da linha é completada por quem sabe dela: | O que você está digitando | De onde vem a sugestão | | ------------------------- | --------------------------------------------------------------------------------------------------- | | **A primeira palavra** | Os binários do seu `$PATH`, mais os alias, funções e builtins que só o shell daquela sessão conhece | | **O subcomando** | Uma base por comando — `git switch`, `docker compose`, `openssl s_client` | | **A flag** | A mesma base, com a descrição do que cada uma faz | | **O argumento** | Quem sabe dele: nome de branch no `git`, nome de container no `docker` | A ordem não é alfabética. O que você usa mais, e usou há menos tempo, sobe. A primeira palavra vem de duas fontes porque nenhuma das duas sozinha basta. O app lê o `$PATH` do disco, que não custa nada ao shell. Mas `nvm`, `asdf` e `direnv` reescrevem o `$PATH` **depois** que a sessão nasce, e alias e função não existem em disco — esses o próprio shell informa, por sessão. O resultado é a lista que você veria digitando no seu terminal, não a que o app imaginaria. `⌘L` (`Ctrl+Alt+L` fora do macOS) limpa a tela sem fechar a sessão. ## O histórico que você já tem Na primeira vez, o TYBA **importa o histórico do seu shell** — zsh, bash e fish — para a sugestão nascer sabendo o que você roda, em vez de esperar você digitar tudo de novo. É só leitura: os arquivos de histórico do seu shell não são alterados. Para procurar dentro dele com escopo e filtro, veja a [paleta de comandos](/pt-br/interface/paleta-de-comandos). ## Quem recebe a tecla A linha do TYBA **não** é sempre a dona do teclado, e isso é correção, não conforto: `ssh`, `psql`, `python`, o pedido de senha do `sudo` — todos leem o que você digita **durante** o comando. Uma caixa que engolisse essas teclas receberia a sua senha e não a mandaria a lugar nenhum. | Situação | Quem recebe | | ----------------------------------------- | ------------------- | | App de tela cheia (`vim`, `htop`, `less`) | O terminal, cru | | Comando em execução | O terminal, cru | | Shell parado no prompt | **A linha do TYBA** | `Ctrl+C`, `Ctrl+D` e `Ctrl+Z` vão para o processo mesmo com a linha em foco — são sinais, não texto. `Ctrl+C` também limpa a caixa, que é o que você espera dele. Enquanto um comando roda, a seta para cima e para baixo **não** vai para o programa se o terminal estiver esperando uma linha inteira. Ali ela não serviria para nada e ainda apareceria como `^[[A` na saída guardada. Em `vim`, `htop` ou num menu que lê tecla a tecla, ela passa normalmente. ## Se algo travar **`Alt+~` dentro do terminal devolve o prompt do shell na hora**, sem fechar a sessão nem perder o que está rodando. É a válvula de escape, e ela existe porque a heurística pode falhar num shell com configuração exótica. Para voltar de vez, desligue a chave nas Configurações — as sessões já abertas seguem como estão até você abrir outra. ## Onde funciona | | | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | **zsh e bash** | Sim, com [shell integration](/pt-br/terminal/shell-integration) ligada — é ela que avisa ao app onde o prompt começa e termina. | | **fish, nu, PowerShell, cmd** | Não. A sessão funciona normalmente, com o prompt do shell. | | **Sessões SSH** | Não. O shell é do outro lado, e o TYBA não escreve na máquina remota. | | **Sessões de agente** | Não se aplica — ali a caixa de texto é o [composer](/pt-br/agente/composer). | Sem os marcadores da shell integration não há como saber que o shell está no prompt. Nesse caso o TYBA **degrada para o terminal clássico** em vez de adivinhar. ## Veja também O que a linha do TYBA liga junto. O pré-requisito, e por que ele não toca nos seus dotfiles. Histórico e snippets também vivem lá, sem depender desta página. Onde mora a chave, e o resto da seção Code.