> ## Documentation Index
> Fetch the complete documentation index at: https://chatcli.edilsonfreitas.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Modo Não-Interativo (One-Shot)

> Aprenda a usar o ChatCLI em scripts, automações e pipelines através das flags de linha de comando e do uso de pipes.

O **ChatCLI** não foi projetado apenas para conversas interativas. Ele pode ser uma ferramenta poderosa em seus scripts de automação, pipelines de CI/CD e aliases de shell graças ao seu modo "one-shot".

Neste modo, você pode fazer uma única pergunta, obter a resposta e sair, tudo em um único comando, tornando-o perfeito para integração com outras ferramentas.

***

## Usando as Flags `-p` ou `--prompt`

A maneira mais direta de usar o modo one-shot é com as flags `-p` ou `--prompt`. O ChatCLI executará a pergunta, imprimirá a resposta da IA no `stdout` e encerrará.

```bash theme={"system"}
chatcli -p "Qual é o comando para listar todos os processos que consomem mais de 500MB de RAM no Linux?"
```

A saída será apenas a resposta da IA, pronta para ser lida ou processada por outro script.

***

## Integrando com Pipes ( | )

Uma das formas mais poderosas de usar o modo one-shot é combinando-o com outros comandos de linha de comando através de pipes. O ChatCLI automaticamente detecta se está recebendo dados via `stdin` e os utiliza como contexto.

<Tabs>
  <Tab title="Resumir um git diff">
    ```bash theme={"system"}
    git diff | chatcli -p "Baseado neste diff, gere uma sugestão de mensagem de commit seguindo o padrão Conventional Commits."
    ```
  </Tab>

  <Tab title="Analisar logs">
    ```bash theme={"system"}
    cat /var/log/nginx/error.log | chatcli -p "Encontre o erro mais comum neste log e sugira uma possível causa e solução."
    ```
  </Tab>

  <Tab title="Analisar dados CSV">
    ```bash theme={"system"}
    cat relatorio.csv | chatcli --provider CLAUDEAI --model claude-sonnet-4-6 -p "Análise estes dados e me dê 3 insights principais."
    ```
  </Tab>

  <Tab title="Slash command num pipe">
    ```bash theme={"system"}
    git diff | chatcli -p "/review"
    ```

    O corpo do pipe vira o `$ARGUMENTS` do [slash command](/pt/extensions/slash-commands) — e um comando `mode: coder` pode agir sobre ele com o coder engine completo, no meio da pipeline.
  </Tab>
</Tabs>

***

## Flags Disponíveis no Modo One-Shot

Você pode customizar o comportamento do modo one-shot com as seguintes flags:

| Flag | Descrição |
| :- | :- |
| `-p`, `--prompt` | A pergunta ou instrução principal para a IA. |
| `--provider <nome>` | Sobrescreve o provedor de LLM padrão (ex: `OPENAI`, `OPENAI_ASSISTANT`, `CLAUDEAI`, `BEDROCK`, `GOOGLEAI`, `XAI`, `ZAI`, `MINIMAX`, `MOONSHOT`, `STACKSPOT`, `OLLAMA`, `COPILOT`, `OPENROUTER`, `DEVIN`). |
| `--model <nome>` | Sobrescreve o modelo de IA a ser usado (ex: `gpt-4o`, `claude-sonnet-4-6`). |
| `--timeout <duração>` | Define um tempo limite para a requisição (padrão: `5m`). Ex: `10s`, `1m`. |
| `--max-tokens <num>` | Sobrescreve o número máximo de tokens na resposta. |
| `--no-anim` | Desabilita a animação "Pensando...", ideal para saídas limpas em scripts. |
| `--agent-auto-exec` | No modo agente one-shot, executa o primeiro comando sugerido automaticamente se for considerado seguro. |
| `--realm <nome>` | (StackSpot) Define o `realm` (tenant) para autenticação. |
| `--agent-id <id>` | (StackSpot) Define o `Agent ID` a ser usado. |

***

## Modo Agente em One-Shot

Prompts one-shot também resolvem [templates de slash commands](/pt/extensions/slash-commands): `chatcli -p "/review-pr 1326 security"` expande o template de `.chatcli/commands` antes de qualquer execução. Pipes compõem naturalmente — `git diff | chatcli -p "/review"` alimenta o corpo do pipe no `$ARGUMENTS` do comando. Linhas de pré-execução seguem sua política de segurança: aprovação interativa só quando o stdin é um terminal de verdade; execuções via pipe resolvem pelas regras de policy e caem em deny fail-safe — uma regra `allow` explícita (ex.: `{ "pattern": "exec git log", "action": "allow" }` em `~/.chatcli/coder_policy.json`) deixa as linhas `!` de um comando rodarem totalmente unattended, destravando automações em cron/CI.

A mesma regra vale para as confirmações de ferramenta do próprio coder: em `chatcli -p "/coder …"` sem terminal no stdin, uma ação que a sua policy marca como `ask` é negada na hora, em vez de esperar uma resposta que nunca vai chegar, e o modelo segue sem ela. Libere o que uma execução headless precisa no `coder_policy.json` (veja [regras ask em superfícies unattended](/pt/coder/coder-security#regras-ask-em-superficies-unattended-acp-mcp-gateway-one-shot-headless)). Para medir execuções one-shot contra casos fixos, veja [Evals](/pt/agents/harness/evals).

Você também pode invocar o Modo Agente de forma não-interativa. Isso é extremamente útil para automações complexas.

Ao usar `/agent` ou `/run` com a flag `-p`, o ChatCLI pedirá à IA um plano de ação e o imprimirá. Por padrão, ele não executará os comandos.

<Tabs>
  <Tab title="Plano sem execução (padrão)">
    ```bash theme={"system"}
    chatcli -p "/agent encontre todos os arquivos *.tmp no diretório /tmp e os apague."
    ```

    Isso irá exibir o plano sugerido pela IA (ex: `find /tmp -name "*.tmp" -delete`).
  </Tab>

  <Tab title="Com execução automática">
    Para executar o plano automaticamente, use a flag `--agent-auto-exec`. A execução só ocorrerá se o validador de segurança interno não detectar comandos perigosos.

    ```bash theme={"system"}
    chatcli -p "/agent encontre e apague os arquivos .tmp" --agent-auto-exec
    ```

    A IA irá gerar e, se for seguro, executar o comando para limpar os arquivos temporários.
  </Tab>
</Tabs>

<Warning>Use `--agent-auto-exec` com cautela. Embora o validador de segurança bloqueie comandos perigosos conhecidos, sempre revise o comportamento em ambientes de produção.</Warning>

***

## Executando Tools Diretamente — `chatcli tool`

Às vezes você quer o output de uma tool built-in, não a opinião de um modelo sobre ele. Um `-p "@tool ..."` simples **executa a tool e depois envia o resultado pra LLM** como contexto — lento, caro em tokens e impraticável quando o output é grande. O subcomando `tool` executa a tool e imprime o output, **sem nenhuma chamada de LLM**:

```bash theme={"system"}
# Lista todas as tools disponíveis pro subcomando
chatcli tool list

# Executa uma tool com flags normais (argv passa verbatim)
chatcli tool @docs-flatten --root ./docs --format jsonl --output corpus.jsonl

# Ou com um único envelope JSON
chatcli tool docs-flatten '{"root":"./docs","format":"jsonl","output":"corpus.jsonl"}'
```

* **Keyless** — sem provider configurado, sem problema: como as direct tools do servidor MCP, o subcomando só precisa da própria tool.
* **Mesma política de exposição** — o catálogo respeita `CHATCLI_MCP_TOOLS` (tools interativas são excluídas), exatamente como a superfície de tools do MCP.
* **Amigável a scripts** — output no stdout, erros no stderr com exit code 1. Perfeito para cron jobs, etapas de CI e pipes.

<Tip>Use `-p "@tool ..."` quando quiser que o modelo *raciocine sobre* o output da tool; use `chatcli tool` quando só quiser o output.</Tip>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.