opencode-ralph-loop-cli 0.1.0

# Integrações — opencode-ralph-loop-cli

> "De scripts de shell a CronJobs no Kubernetes — integrações para cada fluxo de trabalho."


## Tabela de Resumo

| Integração | Tipo | Versão Mínima | Exemplo |
|---|---|---|---|
| Claude Code | Agente de IA | qualquer | `opencode-ralph-loop-cli init` na etapa de setup do CLAUDE.md |
| Codex (OpenAI) | Agente de IA | qualquer | Adicione `init` ao script de bootstrap do workspace do Codex |
| Gemini CLI | Agente de IA | qualquer | Adicione `init` ao hook de setup do projeto `.gemini/` |
| Opencode | Agente de IA | qualquer | Coloque `check --strict` no hook de pré-sessão do Opencode |
| Cursor | Agente de IA | qualquer | Adicione `init` às instruções de setup do `.cursorrules` |
| Windsurf | Agente de IA | qualquer | Adicione `init` às regras de onboarding do workspace do Windsurf |
| VS Code Copilot | Agente de IA | qualquer | Adicione `init` ao `preLaunchTask` do `.vscode/tasks.json` |
| GitHub Copilot | Agente de IA | qualquer | Adicione `check --strict` ao workflow de CI antes das etapas do Copilot |
| Zed | Agente de IA | qualquer | Adicione `init` à task de setup do workspace do Zed |
| Aider | Agente de IA | qualquer | Adicione chamada `init` ao `.aider.conf.yml` nos comandos de startup |
| Jules | Agente de IA | qualquer | Adicione `init` aos hooks de bootstrap do projeto Jules |
| JetBrains AI | Agente de IA | qualquer | Adicione `init` ao passo before-launch da run configuration do JetBrains |
| Kilo Code | Agente de IA | qualquer | Adicione `init` às instruções de setup do workspace do Kilo Code |
| Roo Code | Agente de IA | qualquer | Adicione `init` ao hook de inicialização do projeto Roo Code |
| Cline | Agente de IA | qualquer | Adicione `init` ao bloco de setup do `.clinerules` |
| Continue | Agente de IA | qualquer | Adicione `init` ao setup do context provider do Continue |
| Factory | Agente de IA | qualquer | Adicione `init` ao pipeline de onboarding do Factory |
| Augment | Agente de IA | qualquer | Adicione `init` ao comando de bootstrap do workspace do Augment |
| Minimax | Agente de IA | qualquer | Adicione `init` ao hook de inicialização do projeto Minimax |
| Z.ai | Agente de IA | qualquer | Adicione `init` à etapa de setup do workspace do agente Z.ai |
| Google Antigravity | Agente de IA | qualquer | Adicione `init` ao hook de configuração do projeto Antigravity |
| Bash | Shell | 4.0 | Source do script de completion, use com `--output json` |
| Zsh | Shell | 5.0 | Source do script de completion via `$fpath` |
| Fish | Shell | 3.0 | Source do script de completion via `~/.config/fish/completions/` |
| PowerShell | Shell | 7.0 | Import do script de completion via profile |
| Nushell | Shell | 0.80 | Source do script de completion via `config.nu` |
| GitHub Actions | CI/CD | N/A | `check --strict` em etapa de workflow |
| GitLab CI | CI/CD | N/A | `check --strict` no bloco `script` do `.gitlab-ci.yml` |
| CircleCI | CI/CD | N/A | `check --strict` em etapa `run` |
| Docker | Container | 20.10 | `init --skip-install` em Dockerfile multi-estágio |
| Alpine | Container | 3.18 | `init --skip-install` em imagem Alpine mínima |
| Kubernetes | Container | 1.25 | CronJob executando `check --strict` em agendamento |
| cargo install | Gerenciador de Pacotes | Rust 1.85 | `cargo install opencode-ralph-loop-cli` |
| Homebrew | Gerenciador de Pacotes | N/A | Tap placeholder — em breve |
| Scoop | Gerenciador de Pacotes | N/A | Manifest placeholder — em breve |


## Integrações com Agentes de IA


### Claude Code
- Adicione `opencode-ralph-loop-cli init` à seção de setup do projeto no `CLAUDE.md`
- Use `check --strict` como gate de pré-sessão para verificar integridade dos templates
- Coloque o binário no `PATH` para que o Claude Code possa chamá-lo de qualquer diretório
- Código de saída 0 confirma que o ambiente está pronto para desenvolvimento assistido por IA

```bash
# Etapa de setup no CLAUDE.md
opencode-ralph-loop-cli doctor && opencode-ralph-loop-cli init
```


### Codex (OpenAI)
- Adicione `init` ao script de bootstrap do workspace do Codex que executa antes das sessões
- Use `check --output json` para alimentar o status de drift no contexto do Codex
- Verifique se o binário está disponível no PATH do sandbox do Codex antes de invocar
- Encadeie a saída JSON com `jaq` para extrair campos relevantes para prompts

```bash
# Bootstrap do Codex
opencode-ralph-loop-cli init --skip-install
opencode-ralph-loop-cli check --output json
```


### Gemini CLI
- Adicione `init` ao hook de setup do projeto `.gemini/` que executa ao abrir o workspace
- Use `check --strict` na validação pré-sessão para bloquear sessões em caso de drift
- A flag `--output quiet` mantém o contexto do Gemini CLI limpo sem saída da ferramenta
- Exponha o código de saída do `doctor` ao Gemini para surfaçar problemas de ambiente

```bash
# Hook de setup do Gemini
opencode-ralph-loop-cli init --skip-install
opencode-ralph-loop-cli check --strict --output quiet
```


### Opencode
- Coloque `check --strict` no hook de pré-sessão do Opencode
- Use `init` na etapa de onboarding do workspace para criar o scaffold dos templates
- O Opencode lê códigos de saída nativamente — use 0 para passar, não-zero para bloquear
- O formato `--output json` integra com o contexto estruturado do Opencode

```bash
# Hook de pré-sessão do Opencode
opencode-ralph-loop-cli check --strict
```


### Cursor
- Adicione `opencode-ralph-loop-cli init` às instruções de setup no `.cursorrules`
- Instrua o Cursor a executar `check --strict` antes de iniciar sessões assistidas por IA
- O nome do binário é curto o suficiente para incluir em instruções em linguagem natural
- Use `--output json` para que o Cursor possa analisar o status de drift programaticamente

```
# Bloco de setup no .cursorrules
Run: opencode-ralph-loop-cli init
Verify: opencode-ralph-loop-cli check --strict --output quiet
```


### Windsurf
- Adicione `init` ao arquivo de regras de onboarding do workspace do Windsurf
- Use `doctor` para verificar o ambiente como primeira etapa de onboarding
- O agente Windsurf lê códigos de saída — não-zero bloqueia a continuação da sessão
- Combine `check --strict` com `--output quiet` para saída limpa do agente

```bash
# Onboarding do Windsurf
opencode-ralph-loop-cli doctor && opencode-ralph-loop-cli init
```


### VS Code Copilot
- Adicione `init` ao `.vscode/tasks.json` como `preLaunchTask` para o workspace
- Use `check --strict` em uma task de validação dedicada para feedback estilo CI
- A saída da task aparece no painel Terminal do VS Code para fácil inspeção
- Encadeie com `doctor` para verificar o ambiente antes do scaffold

```json
{
  "label": "Setup AI Templates",
  "type": "shell",
  "command": "opencode-ralph-loop-cli init",
  "group": "build",
  "presentation": { "reveal": "always" }
}
```


### GitHub Copilot
- Adicione `check --strict` ao workflow de CI antes de quaisquer etapas assistidas pelo Copilot
- Use `--output json` para surfaçar detalhes de drift nos logs de execução do workflow
- O binário executa em qualquer runner Linux, macOS ou Windows do GitHub Actions
- Instale via `cargo install opencode-ralph-loop-cli` na etapa de setup do workflow

```yaml
- name: Verify AI Templates
  run: opencode-ralph-loop-cli check --strict
```


### Zed
- Adicione `init` à task de setup do workspace do Zed em `.zed/tasks.json`
- Use `check --strict` como task de pré-sessão para impor integridade dos templates
- As tasks do Zed exibem a saída no painel de tasks para visibilidade
- Combine com `doctor` para validar o ambiente ao abrir o workspace

```json
{
  "label": "Setup AI Templates",
  "command": "opencode-ralph-loop-cli",
  "args": ["init"]
}
```


### Aider
- Adicione chamada `init` à seção de comandos de startup do `.aider.conf.yml`
- Use `check --output json` para alimentar o status dos templates no contexto do Aider
- O binário é um único executável estático sem dependências de runtime além do bun
- Encadeie a saída JSON com `jaq` para extrair caminhos de arquivo para injeção de contexto

```yaml
# .aider.conf.yml
auto-commits: false
message: |
  Run: opencode-ralph-loop-cli init --skip-install
```


### Jules
- Adicione `init` aos hooks de bootstrap do projeto Jules que executam antes das sessões
- Use `check --strict` como gate que bloqueia o início da sessão em caso de drift
- O Jules lê códigos de saída — use a distinção 0 vs não-zero para controle de fluxo
- A flag `--output quiet` evita que a saída da ferramenta polua o contexto do Jules

```bash
# Hook de bootstrap do Jules
opencode-ralph-loop-cli init --skip-install
opencode-ralph-loop-cli check --strict --output quiet
```


### JetBrains AI
- Adicione `init` à run configuration do JetBrains como etapa de before-launch de ferramenta externa
- Use `doctor` na etapa before-launch para verificar a prontidão do ambiente
- As run configurations do JetBrains suportam verificação de código de saída — não-zero bloqueia o launch
- Configure o diretório de trabalho para a raiz do projeto para resolução correta de caminhos

```xml
<!-- .idea/runConfigurations/setup.xml -->
<ExternalSystemBeforeLaunchTask ... />
<!-- Command: opencode-ralph-loop-cli init -->
```


### Kilo Code
- Adicione `init` às instruções de setup do workspace do Kilo Code
- Use `check --strict` como etapa de verificação pré-sessão
- O binário lê o diretório atual como raiz do projeto automaticamente
- O código de saída 0 sinaliza prontidão para a validação de ambiente do Kilo Code

```bash
# Setup do Kilo Code
opencode-ralph-loop-cli init && opencode-ralph-loop-cli check --strict
```


### Roo Code
- Adicione `init` ao hook de inicialização do projeto Roo Code
- Use `check --output json` para expor o status dos templates ao contexto do Roo Code
- O Roo Code pode analisar a saída JSON nativamente para tomada de decisão estruturada
- Combine `doctor` e `init` em um único comando de bootstrap para eficiência

```bash
# Hook de inicialização do Roo Code
opencode-ralph-loop-cli doctor && opencode-ralph-loop-cli init
```


### Cline
- Adicione `init` ao bloco de setup do `.clinerules` que executa ao abrir o workspace
- Use `check --strict` como gate de pré-task para evitar sessões afetadas por drift
- O Cline lê códigos de saída para determinar se deve prosseguir com tasks de IA
- A flag `--skip-install` é útil em ambientes onde o bun não está disponível

```
# Bloco de setup no .clinerules
Run: opencode-ralph-loop-cli init --skip-install
Gate: opencode-ralph-loop-cli check --strict --output quiet
```


### Continue
- Adicione `init` ao script de setup do context provider do Continue
- Use `check --output json` para injetar o status dos templates no contexto do Continue
- O Continue pode usar campos da saída JSON para incluir snippets de contexto condicionalmente
- Encadeie a saída do comando `list` para expor hashes dos templates gerenciados ao Continue

```bash
# Setup do Continue
opencode-ralph-loop-cli init
opencode-ralph-loop-cli list --output json
```


### Factory
- Adicione `init` ao pipeline de onboarding do Factory como primeira etapa
- Use `check --strict` como gate do pipeline antes da geração de código assistida por IA
- Pipelines do Factory suportam roteamento por código de saída — 0 continua, não-zero para
- O formato `--output json` integra com os dados estruturados do pipeline do Factory

```bash
# Etapa do pipeline de onboarding do Factory
opencode-ralph-loop-cli init
opencode-ralph-loop-cli check --strict --output json
```


### Augment
- Adicione `init` à lista de comandos de bootstrap do workspace do Augment
- Use `doctor` primeiro para verificar o ambiente, depois `init` para criar o scaffold
- O Augment pode usar `check --output json` para surfaçar status dos templates no contexto
- A flag `--skip-install` habilita uso em ambientes de sandbox restritos

```bash
# Bootstrap do Augment
opencode-ralph-loop-cli doctor
opencode-ralph-loop-cli init --skip-install
```


### Minimax
- Adicione `init` à configuração do hook de inicialização do projeto Minimax
- Use `check --strict` para impor integridade dos templates antes das sessões de IA
- Agentes Minimax leem códigos de saída para controle de fluxo — 0 continua, não-zero para
- Combine com `--output quiet` para contexto limpo do agente sem ruído da ferramenta

```bash
# Hook de inicialização do Minimax
opencode-ralph-loop-cli init && opencode-ralph-loop-cli check --strict --output quiet
```


### Z.ai
- Adicione `init` à etapa de setup do workspace do agente Z.ai
- Use `check --output json` para alimentar o status dos templates no contexto do agente Z.ai
- O binário é autocontido e não requer arquivos de configuração adicionais
- Os códigos de saída mapeiam claramente para o controle de fluxo do Z.ai: 0 para passar, não-zero para falhar

```bash
# Setup do workspace Z.ai
opencode-ralph-loop-cli init
opencode-ralph-loop-cli check --output json
```


### Google Antigravity
- Adicione `init` ao hook de configuração do projeto Antigravity
- Use `check --strict` como gate de pré-sessão para bloquear sessões em caso de drift
- Agentes Antigravity podem analisar `--output json` para injeção estruturada de contexto
- O comando `doctor` surfaça problemas de ambiente antes do início do scaffold

```bash
# Hook de configuração do Antigravity
opencode-ralph-loop-cli doctor && opencode-ralph-loop-cli init
opencode-ralph-loop-cli check --strict
```


## Integrações com Shell


### Bash
- Gere e instale as completions com os comandos abaixo
- Recarregue seu shell ou faça source do `.bashrc` para ativar imediatamente
- Todos os subcomandos, flags e valores de `--output` são cobertos pelas completions

```bash
opencode-ralph-loop-cli completions bash \
  > ~/.local/share/bash-completion/completions/opencode-ralph-loop-cli
source ~/.bashrc
```


### Zsh
- Gere o script de completion e coloque-o no seu `$fpath`
- Execute `compinit` após instalar se as completions não carregarem automaticamente

```zsh
opencode-ralph-loop-cli completions zsh \
  > ~/.zsh/completions/_opencode-ralph-loop-cli
autoload -U compinit && compinit
```


### Fish
- Coloque o script de completion no diretório de completions do Fish
- O Fish carrega automaticamente todos os scripts nesse diretório ao iniciar

```fish
opencode-ralph-loop-cli completions fish \
  > ~/.config/fish/completions/opencode-ralph-loop-cli.fish
```


### PowerShell
- Gere o script de completion e adicione-o ao seu perfil do PowerShell
- Reinicie o PowerShell ou faça dot-source do seu perfil para ativar

```powershell
opencode-ralph-loop-cli completions powershell | Out-String | Invoke-Expression
# Para persistir: adicione a linha acima ao $PROFILE
```


### Nushell
- Gere o script de completion e faça source dele no `config.nu`
- As completions do Nushell são definidas como blocos `def` com anotações `@`

```nu
opencode-ralph-loop-cli completions nushell | save ~/.config/nushell/completions/opencode-ralph-loop-cli.nu
# Adicione ao config.nu: source ~/.config/nushell/completions/opencode-ralph-loop-cli.nu
```


## Integrações com CI/CD


### GitHub Actions

```yaml
name: Verificar Templates de IA

on:
  push:
    branches: [main]
  pull_request:

jobs:
  template-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Instalar Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: 1.85

      - name: Instalar opencode-ralph-loop-cli
        run: cargo install opencode-ralph-loop-cli

      - name: Verificar doctor
        run: opencode-ralph-loop-cli doctor

      - name: Verificar drift de templates
        run: opencode-ralph-loop-cli check --strict --output json
```


### GitLab CI

```yaml
template-check:
  stage: validate
  image: rust:1.85
  before_script:
    - cargo install opencode-ralph-loop-cli
  script:
    - opencode-ralph-loop-cli doctor
    - opencode-ralph-loop-cli check --strict --output json
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH == "main"'
```


### CircleCI

```yaml
version: 2.1

jobs:
  template-check:
    docker:
      - image: rust:1.85
    steps:
      - checkout
      - run:
          name: Instalar opencode-ralph-loop-cli
          command: cargo install opencode-ralph-loop-cli
      - run:
          name: Verificar ambiente
          command: opencode-ralph-loop-cli doctor
      - run:
          name: Verificar drift de templates
          command: opencode-ralph-loop-cli check --strict --output json

workflows:
  validate:
    jobs:
      - template-check
```


## Integrações com Containers


### Docker Multi-Estágio

```dockerfile
FROM rust:1.85-slim AS tool-builder
RUN cargo install opencode-ralph-loop-cli

FROM node:20-slim AS template-setup
COPY --from=tool-builder /usr/local/cargo/bin/opencode-ralph-loop-cli /usr/local/bin/
WORKDIR /app
COPY . .
RUN opencode-ralph-loop-cli init
RUN cd .opencode && npm install

FROM node:20-slim AS final
WORKDIR /app
COPY --from=template-setup /app .
```


### Imagem Alpine Mínima

```dockerfile
FROM rust:1.85-alpine AS builder
RUN apk add --no-cache musl-dev
RUN cargo install opencode-ralph-loop-cli

FROM alpine:3.18
COPY --from=builder /usr/local/cargo/bin/opencode-ralph-loop-cli /usr/local/bin/
WORKDIR /workspace
# Pular bun install — execute no startup do container ou em estágio separado
RUN opencode-ralph-loop-cli init --skip-install
```


### Kubernetes CronJob

```yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: template-drift-check
  namespace: default
spec:
  schedule: "0 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: drift-checker
              image: rust:1.85-slim
              command:
                - /bin/sh
                - -c
                - |
                  cargo install opencode-ralph-loop-cli && \
                  opencode-ralph-loop-cli check --strict --output json
              volumeMounts:
                - name: workspace
                  mountPath: /workspace
          volumes:
            - name: workspace
              persistentVolumeClaim:
                claimName: workspace-pvc
```


## Integrações com Gerenciadores de Pacotes


### cargo install

```bash
# Instalar versão mais recente
cargo install opencode-ralph-loop-cli

# Instalar versão específica
cargo install opencode-ralph-loop-cli --version 0.1.0

# Verificar instalação
opencode-ralph-loop-cli --version
```

- Requer Rust 1.85 ou superior
- O binário é instalado em `~/.cargo/bin/` por padrão
- Certifique-se de que `~/.cargo/bin/` está no seu `PATH`


### Homebrew (em breve)

```bash
# Tap placeholder — ainda não disponível
# brew tap TODO/opencode-ralph-loop-cli
# brew install opencode-ralph-loop-cli
```

- A fórmula Homebrew será publicada após o primeiro lançamento estável
- Acompanhe o repositório para atualizações sobre disponibilidade


### Scoop (em breve)

```powershell
# Manifest Scoop placeholder — ainda não disponível
# scoop bucket add TODO https://github.com/TODO/scoop-bucket
# scoop install opencode-ralph-loop-cli
```

- O manifest Scoop será publicado junto com os binários de release para Windows
- Acompanhe o repositório para atualizações sobre disponibilidade


Disponível também em [English](INTEGRATIONS.md)