Ferramentas do editor

Como as ferramentas abrem

Estas ferramentas só existem dentro do editor de código; não são páginas do pager principal. Abra antes um arquivo ou um projeto e use o botão de chave inglesa na parte de cima do editor.

1. 1Toque no botão de chave inglesa (Mais opções) na barra superior do editor. Abre-se um painel com um campo de busca, Buscar ação….
2. 2Escolha um chip de seção: Editar, Exibir, Ir para, Git, IA ou Ferramentas, ou digite no campo de busca para filtrar todas as ações de uma vez.
3. 3Em Ferramentas as ações ficam agrupadas em Executar, Projeto, Colaborar, Utilidades e Ajuda e configurações. Depurar, Explorador de testes e Dependências ficam em Executar; Ferramentas Docker, Monitoramento e Geradores de backend em Projeto; Colaboração ao vivo em Colaborar.
4. 4Problemas e Esquema ficam em Ir para. Os Geradores de IA e as ações de código com IA ficam em IA.
5. 5A paleta de comandos (Ctrl+Shift+P com teclado físico) lista exatamente as mesmas ações: o menu e a paleta compartilham um único registro.

Onde fica cada ferramenta

Painel inferior, painel acoplado, diálogo ou coluna

Atalhos

Depuração

A depuração executa o arquivo aberto com um depurador anexado e mostra o que o programa está fazendo em um painel acoplado sob o editor. O depurador é real só para JavaScript (.js, .mjs, .cjs, .jsx, executados no Node.js integrado). Para qualquer outra linguagem, Depurar arquivo apenas executa o arquivo.

Breakpoints

• Toque no número de uma linha no editor para adicionar ou remover um breakpoint, ou aperte F9 na linha do cursor (Alternar breakpoint). Você pode defini-los antes de iniciar a sessão.
• Os breakpoints vivem só na memória: ao fechar o app, eles são esquecidos.
• A aba Breakpoints lista todos os breakpoints, cada um com uma caixa de ligado/desligado. Toque em uma linha para ir à linha dela no arquivo atual, use o lápis para editá-lo, ✕ para removê-lo ou Limpar tudo. Lista vazia: “Nenhum breakpoint. Toque em um número de linha no editor para adicionar um.”

Iniciar e avançar passo a passo

O Node começa pausado na primeira linha (--inspect-brk), o painel se anexa (“Debugger attached on port N” aparece na saída da execução) e o libera, e o programa roda até atingir um breakpoint ou uma exceção não tratada, que também o pausa.

• Com uma sessão ativa, a barra de ferramentas oferece Continuar (ou Pausar enquanto roda), Passo por cima, Passo para dentro, Passo para fora, Reiniciar e Parar. Os botões de passo só ficam ativos enquanto o programa está pausado.
• Parar desanexa o depurador. O processo em si é parado pelo painel de execução.
• O botão da chama, Hot Reload: reiniciar a sessão ao salvar um arquivo do projeto, vem desligado por padrão.

As quatro abas

Os nomes das abas são sempre em inglês: o app não os traduz.

Condições e logpoints

O lápis de um breakpoint abre Editar breakpoint. Condição (“Pausar só quando esta expressão JavaScript for verdadeira”) faz com que ele pare só nesse caso. Mensagem de log (“Registra em vez de pausar. Use {expressão} para inserir valores”) o transforma em um logpoint que imprime a mensagem e não pausa. Com os dois, ele só imprime quando a condição é verdadeira. Esses dois campos são definidos aqui, não na margem do editor.

Testes

O Explorador de testes encontra os testes do seu projeto, executa-os com o comando do próprio framework e lista os resultados. Ele não traz um executor de testes: roda o comando pelo shell do aparelho (sh -c) na pasta do projeto, então as ferramentas do framework precisam existir no aparelho.

Frameworks e detecção

Há suporte a doze frameworks: Jest, Mocha, Vitest, pytest, unittest, JUnit, Go Test, Cargo Test, PHPUnit, RSpec, Dart Test e Swift XCTest. O PocketCode escolhe um por projeto: o primeiro que encontra pelo arquivo de configuração (por exemplo jest.config.js, pytest.ini, build.gradle, go.mod, Cargo.toml, pubspec.yaml); se nenhum bater, lê o package.json em busca de Jest, Vitest ou Mocha. O unittest não tem arquivo de configuração, então nunca é escolhido sozinho. O subtítulo então mostra “<framework> · N testes em M ficheiros”.

As quatro abas

Executar

• O rodapé tem Executar todos, Só falhados e, enquanto uma execução está em andamento, Parar.
• O cabeçalho tem ícones para Atualizar, Alternar modo watch e Executar com cobertura.
• A árvore de testes vem da leitura dos seus arquivos por padrões de nome (*.test.*, test_*.py, *_test.go, *Test.kt…), até 200 arquivos, ignorando node_modules, .git, build, dist, target, .gradle, __pycache__ e venv.
• O modo watch existe só para Jest, Mocha e Vitest, e apenas despeja a saída do comando em Saída.

Ferramentas Docker

As Ferramentas Docker são uma interface para a ferramenta de linha de comando docker que já está no seu aparelho. O PocketCode não inclui o Docker nem um daemon do Docker, e o painel não tem campo para um host remoto. Então, em um celular típico, as abas que precisam do Docker mostram O Docker não está disponível, enquanto os editores de Dockerfile e de Compose continuam funcionando.

Quando o Docker não está lá

Ao abrir, o painel executa docker --version. Se isso falhar, Contêineres, Imagens, Build e Registro mostram O Docker não está disponível: “O PocketCode executa o comando docker neste dispositivo e não o encontrou. Você ainda pode editar o Dockerfile e o arquivo Compose.” Ele acrescenta a causa real da falha e dois botões, Tentar de novo e Editar Dockerfile. O subtítulo diz Docker indisponível.

Dockerfile e .dockerignore

Esta aba funciona sem o Docker. Comece por um dos 14 modelos — Node.js App, Python App, Java App, Go App, Rust App, Static Site, React App, Next.js, FastAPI, Spring Boot, Django, Ruby on Rails, Laravel, Custom Multi-stage —, edite o texto e Salvar como Dockerfile no projeto. Para o .dockerignore você pode Gerar um arquivo e salvá-lo.

Compose

Nove modelos: Full-stack Node.js, Full-stack Python, Full-stack Java, LAMP Stack, MEAN Stack, Monitoring Stack, ELK Stack, WordPress e Dev Tools. Edite e Salvar o arquivo; ele é sempre salvo como docker-compose.yml, embora o painel leia docker-compose.yml, docker-compose.yaml, compose.yml ou compose.yaml. Com o Docker presente, Compose up, Compose down, Compose build e Compose logs executam docker compose up -d, down, build e logs --tail=100; ficam desativados até o projeto ter um arquivo Compose.

Com o Docker disponível

Limites dos comandos

Cada comando pode rodar por no máximo 300 segundos. Nomes e tags são verificados antes de chegar ao Docker: letras, dígitos e _ : . / @ -, até 255 caracteres, sem começar com -.

Monitoramento

O Monitoramento mede o app em que você está e o aparelho em que ele roda, não um servidor. Ele coleta amostras a cada 2 segundos enquanto o painel está aberto e para quando você o fecha. Para ver o seu próprio servidor há uma aba Servidor separada.

As cinco abas

Regras de alerta

O formulário da regra tem Métrica, Condição (Maior que ou Menor que), Limite (verificado contra o intervalo da métrica), Sustentado durante (segundos) e Severidade (Crítica, Aviso, Info). Os eventos de alerta só são avaliados e mostrados enquanto o painel está aberto; os últimos 100 são mantidos, no máximo um por minuto por regra.

Servidor: o seu próprio Prometheus

Servidor funciona com Prometheus, VictoriaMetrics, Thanos, Mimir, Cortex ou um proxy do Grafana. Informe o Endereço, escolha a Autenticação (Nenhuma, Utilizador e palavra-passe ou Token bearer), defina a atualização (de 5 a 300 segundos, 15 por padrão) e adicione até 12 consultas; cada uma é uma consulta instantânea em PromQL que deve devolver um único valor. Testar ligação verifica a configuração. Enquanto você não o configurar, a aba mostra “Não há servidor configurado. Até configurares um, nada sai deste dispositivo.”

Bibliotecas

Bibliotecas (o menu a chama de Dependências) não é um gerenciador de pacotes. Ela lista as bibliotecas Kotlin/JVM que um projeto declara em .pocketcode/dependencies.json e permite escolher em um catálogo fechado de quatro bibliotecas que vêm dentro do app PocketCode. Só o executor Kotlin completo as usa.

Catálogo

A aba Catálogo lista as quatro bibliotecas que o PocketCode inclui: kotlinx.coroutines 1.10.2, kotlinx.serialization · JSON 1.7.3, kotlinx.serialization · core 1.7.3 e Okio 3.9.1. O ícone + de uma linha (Adicionar mais o nome da biblioteca) a adiciona ao projeto.

Declaradas

A aba Declaradas lista o que o JSON do projeto declara, com os filtros Todas, Desatualizadas e Não incluídas. Cada linha mostra group:artifact e se o PocketCode a inclui (“Incluída no PocketCode.”, ou “a → b” quando o projeto pede outra versão), com um ícone de atualizar e um de remover. Atualizar N no rodapé atualiza todas as bibliotecas desatualizadas, ou seja, define-as na versão que o PocketCode inclui. O ícone de atualizar do cabeçalho (Resolver agora) prepara as bibliotecas de novo, com os estados “Preparando as bibliotecas…” e “Pronto: as bibliotecas deste projeto estão preparadas.” Sem declarações, mostra Sem dependências.

Uma biblioteca que não está incluída

Se o JSON citar algo fora do catálogo, a linha diz que ela não vem com o PocketCode, “então este projeto roda em modo simples. Remova-a ou use uma das de cima.”

Geradores de backend

Os Geradores de backend escrevem código de servidor a partir de modelos guardados no app. Não é IA: as mesmas configurações sempre dão os mesmos arquivos (os botões Gerar apenas esperam um instante antes). Você lê o resultado no painel e, com um projeto aberto, o salva em backend/.

As abas

Salvar no projeto

Salvar no projeto grava os arquivos gerados em backend/ no projeto; as migrações viram backend/up.sql e backend/down.sql, e a especificação backend/openapi.yaml ou backend/openapi.json. Os caminhos não podem sair da pasta do projeto. Se alguns arquivos já existirem, ele pergunta Sobrescrever arquivos? (“N arquivo(s) já existem no projeto e serão sobrescritos.”). Em caso de sucesso diz “Salvos N arquivo(s) em backend/ no projeto”, e se a gravação falhar “Não foi possível salvar os arquivos gerados”. Exige um projeto aberto.

Geradores de IA

Os Geradores de IA têm cinco abas, mas só três usam IA. API e Schema são modelos offline que rodam no aparelho; Traduzir, Segurança e Desempenho enviam o código que você cola ao seu provedor de IA conectado.

As cinco abas

O que as abas de IA exigem

Um provedor de IA conectado e acesso à internet. Na primeira vez, um aviso pergunta Enviar para <provider>?; Enviar compartilha o código que você colou, Cancelar não compartilha nada. API e Schema não precisam de provedor nem de rede. Antes de gerar, a área de resultado diz “O resultado vai aparecer aqui assim que for gerado.”

Ações de código com IA

A seção IA do menu tem ações que trabalham sobre o seu código: explicar, testes, documentação, código a partir de comentários, refatorar e cinco ações rápidas. Elas enviam o código ao seu provedor de IA conectado, depois de um aviso que você aceita, e mostram a resposta.

As ações

Aplicar e Inserir no painel acoplado

O painel acoplado tem no máximo 300 dp de altura e um ✕ para fechar. Inserir coloca a resposta no cursor. Aplicar substitui só o trecho de código que foi enviado à IA (a função em Gerar documentação; a seleção em Refatorar, ou o arquivo inteiro se nada estava selecionado) pela resposta, sem prévia e em um único passo de desfazer. Se você mudou esse código enquanto a IA respondia e ele não é mais encontrado, nada é alterado e o painel diz “O código mudou enquanto a IA respondia, por isso o resultado não foi aplicado. Copie-o em vez disso.” O Copiar, ao lado do código gerado, o copia para a área de transferência (“Copiado para a área de transferência”); o painel inferior tem o seu próprio Copiar para a resposta toda.

Colaboração ao vivo

A Colaboração ao vivo permite que dois ou mais aparelhos editem um arquivo juntos na mesma rede Wi-Fi. É gratuita, não precisa de conta e não tem servidor: o celular do anfitrião escuta na sua rede local, os convidados o encontram, digitam um código de seis dígitos e o anfitrião os deixa entrar. Nada passa pela internet.

Hospedar uma sessão

1. 1Em Hospedar neste dispositivo, digite um nome de sessão e toque em Começar a hospedar. A sessão compartilha o texto do arquivo que você tem aberto.
2. 2Dê o Código de emparelhamento de seis dígitos a quem vai entrar (“Diz este código a quem se juntar”).
3. 3Quando alguém digitar o código certo, seu aparelho pergunta Alguém quer juntar-se: “<name> escreveu o código correto. Se o deixares entrar, partilhas o ficheiro com o dispositivo dele.” Escolha Deixar entrar ou Recusar. Você tem até 90 segundos.
4. 4Encerre com Encerrar sessão no cabeçalho.

Entrar em uma sessão

1. 1Abra o painel na mesma Wi-Fi. Pares na sua rede escaneia a LAN (Escaneando a LAN…) e diz Nenhum par encontrado se ninguém estiver hospedando.
2. 2Digite os seis dígitos do anfitrião em Código do anfitrião (“Sem ele ninguém entra. A sessão não sai da tua rede.”).
3. 3Toque no anfitrião e espere que ele o deixe entrar (até 120 segundos). O conteúdo do arquivo que você tinha aberto é substituído pelo texto do anfitrião.
4. 4Saia com Sair no cabeçalho.

Dentro de uma sessão

O que é compartilhado

• O texto do arquivo ativo do anfitrião no momento em que a sessão começa. Uma sessão compartilha um buffer: não a árvore do projeto, nem outros arquivos.
• Depois disso, as edições de todos se mesclam (CRDT) e os cursores remotos aparecem no editor com um nome e uma cor.
• O anfitrião retransmite tudo: os convidados falam com o anfitrião, não entre si.
• Todo convidado que o anfitrião deixa entrar pode editar o texto compartilhado.
• Se a conexão de um convidado cair, o app tenta de novo até seis vezes (de 1 s crescendo até 15 s) e reconcilia o que foi digitado nesse meio-tempo.

Rede e permissão

A partir do Android 13, hospedar e entrar exigem a permissão de dispositivos próximos do Android (nas versões mais novas do Android é uma permissão de rede local). Quando você começa a hospedar, busca ou entra e ela falta, abre-se o diálogo de permissão do próprio Android: permita e toque de novo. Se você recusar, hospedar e entrar continuam recusados (a próxima tentativa mostra a explicação de novo) até que você a permita nas configurações do app no Android. A explicação da permissão e os erros de conexão aparecem no idioma do app.

Problemas

Problemas é uma lista única de tudo o que o editor encontrou de errado em todas as abas abertas, agrupado por arquivo. É um diálogo em tela cheia, não um painel inferior.

Filtros

Filtre por origem — Compilador/LSP, Marcadores e Estilo, cada um com a sua contagem — e por severidade — Erros, Avisos, Info e Dicas. Compilador/LSP e Marcadores vêm ligados por padrão. Estilo (as regras do linter) só é calculado quando você o liga, com “Analisando o estilo…”, e nada é calculado enquanto o diálogo está fechado.

Linhas

Os problemas são deduplicados e ordenados por severidade e depois por linha. Toque em uma linha para ir a “Linha N, Col M”. O grupo do arquivo ativo tem Correções rápidas, que abre o painel de correções rápidas. F8 e Shift+F8 saltam para o próximo ou o anterior erro, aviso ou marcador TODO sem abrir o diálogo. Sem nada para mostrar, aparece Sem problemas.

Esquema

O Esquema é uma coluna à direita do editor que lista as classes, interfaces, funções, blocos de import e seções // region do arquivo e permite ir até elas. Um parser simples o monta; ele não usa o servidor de linguagem.

O que ele reconhece

• Linhas que começam com class, interface, object, enum class, fun ou suspend fun e abrem um { — declarações no estilo Kotlin.
• Blocos de três ou mais linhas consecutivas que começam com import .
• Regiões escritas como // region Name e fechadas com // endregion.
• Ele atualiza 0,8 segundo depois de você parar de digitar.

Como usar

Digite em Filtrar símbolos… (ele casa com parte do texto, não é aproximado) e toque em uma entrada para ir à linha dela. Sem símbolos aparece quando o filtro não casa com nada.