Como os desenvolvedores de software configuram o contexto de repositório e os arquivos de exclusão no Supermaven para gerenciar a indexação e a privacidade do código

A engenharia de software moderna assistida por inteligência artificial depende fortemente de uma profunda percepção de contexto. Enquanto os primeiros mecanismos de autocompletar código operavam estritamente com base em heurísticas de tokens locais ou pequenos trechos de prefixo e sufixo, as ferramentas de ponta aproveitam amplas janelas de contexto para analisar padrões arquiteturais, bibliotecas customizadas, dependências de projetos e relacionamentos entre múltiplos arquivos em repositórios inteiros. O Supermaven estabeleceu-se como uma referência no setor nesse espaço ao combinar uma janela de contexto ultragrande de 1 milhão de tokens com uma latência de preenchimento inferior a 200 milissegundos, impulsionada por sua arquitetura neural proprietária. No entanto, fornecer a um agente de IA visibilidade abrangente sobre uma base de código introduz desafios críticos de segurança e conformidade: propriedade intelectual confidencial, segredos de configuração de produção, chaves criptográficas privadas e dados sensíveis de clientes não devem ser inadvertidamente ingeridos, transmitidos ou armazenados em cache.

Configurar o Supermaven para equilibrar uma inteligência rica sobre a base de código com uma rigorosa privacidade de dados requer a compreensão de seus mecanismos de indexação de contexto, de suas políticas de governança de dados e dos controles de configuração disponíveis nos diferentes ambientes de desenvolvimento integrado (IDEs). Como o Supermaven não implementa um arquivo de exclusão universal no nível raiz como os sistemas de controle de versão padrão, os desenvolvedores devem adotar uma estratégia de configuração em camadas — combinando regras de exclusão no nível do editor, inicialização condicional de plugins, delimitação de escopo de workspace e uma moderna higiene de repositório — para controlar com exatidão qual código é indexado e transmitido.

A mecânica arquitetural do contexto de repositório no Supermaven

Para gerenciar o contexto do repositório com eficácia, as equipes de engenharia devem primeiro compreender como o Supermaven constrói seu modelo mental de um projeto e onde se situam os limites de dados entre o hardware local e os endpoints de inferência em nuvem.

┌──────────────────────────────────────────────────────────────────────────┐
│              Arquitetura de Contexto e Privacidade do Supermaven         │
├──────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  Ambiente Local do Desenvolvedor                                         │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │ Workspace Ativo / Repositório                                      │  │
│  │  ├── Arquivos Fonte (*.ts, *.py, *.go) ──> [Monitor de Arquivos]   │  │
│  │  ├── Arquivos Sensíveis (.env, *.key)  ──> [Filtros de Exclusão]   │  │
│  │  └── Buffers Abertos no Editor         ──> [Sinc. de Buffers]      │  │
│  └───────────────────────────────────┬────────────────────────────────┘  │
│                                      │ Payload de Contexto Filtrado      │
│                                      ▼ (HTTPS / TLS 1.3)                 │
│  Infraestrutura em Nuvem do Supermaven (AWS)                             │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │ Agregador de Contexto de 1 Milhão de Tokens                        │  │
│  │  ├── Modelagem de Sequências de Longo Alcance (Motor Babble)       │  │
│  │  ├── Alinhamento Semântico Rápido Entre Múltiplos Arquivos         │  │
│  │  └── Geração de Conclusão do Próximo Token em < 200 ms             │  │
│  └───────────────────────────────────┬────────────────────────────────┘  │
│                                      │                                   │
│  Salvaguardas de Privacidade e Retenção                                  │
│  ┌───────────────────────────────────┴────────────────────────────────┐  │
│  │ • Retenção Absoluta de Dados por 7 Dias (Expurgo Efêmero Automático│  │
│  │ • Garantia Estrita de Treinamento Zero (Código Jamais Usado p/ Pesos│  │
│  │ • Isolamento de Provedores de Modelos Externos (Apenas Motor Inline)│  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘

Agregação de contexto e a janela de 1 milhão de tokens

Ao contrário das integrações tradicionais de Language Server Protocol (LSP) que computam árvores de sintaxe abstrata (ASTs) na CPU local do desenvolvedor, o Supermaven utiliza um pipeline de indexação nativo na nuvem:

1. Ingestão local de arquivos: Ao abrir uma pasta de projeto, a extensão do Supermaven registra monitores no sistema de arquivos para descobrir ativos do projeto, avaliar a estrutura do repositório e acompanhar os buffers abertos.
2. Montagem de contexto via streaming: Conforme os desenvolvedores navegam e modificam arquivos, o cliente sincroniza a posição do cursor, o histórico recente de edições e os módulos relacionados do projeto em um payload de contexto agregado.
3. Inferência de contexto longo em nuvem: O contexto agregado é transmitido para os servidores de inferência de alto desempenho do Supermaven hospedados na Amazon Web Services (AWS). Lá, o modelo processa até 1.000.000 de tokens de contexto da base de código para exibir sugestões em linha que refletem fielmente interfaces entre módulos, definições de tipos customizadas e convenções idiomáticas do framework.
4. Entrega em menos de 200 ms: Ao evitar a avaliação neural no dispositivo, o Supermaven minimiza o consumo de bateria e o ruído dos ventiladores nos notebooks dos desenvolvedores, alcançando velocidades de completamento quase instantâneas.

O desafio operacional surge porque o monitor de arquivos do cliente e o sincronizador de buffers vão, por padrão, varrer todos os arquivos acessíveis dentro da raiz do workspace, a menos que os desenvolvedores definam limites deliberadamente.

Estrutura de privacidade do Supermaven: compreendendo a política de código

Antes de modificar os arquivos de configuração do IDE, desenvolvedores e líderes de segurança devem compreender as proteções legais e técnicas estabelecidas pela Supermaven Code Policy e pela Privacy Policy.

┌──────────────────────────────────────────────────────────────────────────────────┐
│                Classificação e Tratamento de Dados do Supermaven                 │
├────────────────────────────┬─────────────────────────────────────────────────────┤
│ Categoria de Dados         │ Tratamento Técnico e Política de Retenção           │
├────────────────────────────┼─────────────────────────────────────────────────────┤
│ Dados de Código            │ • Código-fonte enviado via plugins oficiais.        │
│ (Code Data)                │ • Sujeitos a um limite estrito de retenção de 7     │
│                            │   dias.                                             │
│                            │ • Expurgo automático dos sistemas internos da AWS.  │
│                            │ • NUNCA usados para treinar ou ajustar modelos      │
│                            │   comerciais.                                       │
│                            │ • Jamais compartilhados com terceiros não           │
│                            │   autorizados.                                      │
├────────────────────────────┼─────────────────────────────────────────────────────┤
│ Dados de Supermaven Chat   │ • Prompts e trechos de código submetidos            │
│                            │   explicitamente ao chat.                           │
│                            │ • Transmitidos a provedores terceiros selecionados  │
│                            │   (ex.: Anthropic, OpenAI) conforme o modelo.       │
│                            │ • Regidos pelos termos de uso do respectivo         │
│                            │   provedor.                                         │
├────────────────────────────┼─────────────────────────────────────────────────────┤
│ Dados de Conta e           │ • E-mails de usuários, endereços IP, identificadores│
│ Telemetria                 │   de faturamento.                                   │
│                            │ • Tratados conforme diretrizes da Política de       │
│                            │   Privacidade padrão.                               │
│                            │ • Armazenados de forma independente dos             │
│                            │   repositórios de código.                           │
└────────────────────────────┴─────────────────────────────────────────────────────┘

A regra de retenção efêmera de 7 dias

O Supermaven diferencia explicitamente os metadados de contas de usuário do código-fonte proprietário:

• Cronograma rigoroso de exclusão: Qualquer dado de código enviado aos servidores do Supermaven durante sessões de autocompletar em linha é mantido por no máximo 7 dias antes de ser totalmente expurgado dos sistemas de armazenamento interno.
• Sem treinamento de modelos: Os termos contratuais do Supermaven garantem que os dados de código nunca serão usados para desenvolver, ajustar (fine-tune) ou avaliar modelos de machine learning. Seus algoritmos proprietários e lógica de negócios não vazam para futuros modelos fundamentais.
• Segurança de infraestrutura: Os dados de código são processados em instâncias de VPC isoladas na AWS. O acesso à infraestrutura por terceiros é restrito a provedores de hospedagem essenciais sob acordos de confidencialidade rigorosos.

Conclusão em linha versus chat interativo

Há uma distinção fundamental entre o autocompletar de código em linha e o Supermaven Chat:

• Sugestões em linha: Baseiam-se exclusivamente na infraestrutura neural interna do Supermaven. Os trechos de código transmitidos para gerar sugestões em linha permanecem cobertos pelas regras estritas de treinamento zero e retenção de 7 dias.
• Chat interativo: Quando os desenvolvedores utilizam recursos de chat e configuram modelos como Claude 3.5 Sonnet ou GPT-4o, os trechos de código relevantes e os prompts são encaminhados a fornecedores externos de modelos (Anthropic ou OpenAI). Essas transmissões passam a ser regidas pelas políticas de tratamento de dados desses fornecedores terceiros, e não pelas proteções da infraestrutura interna do Supermaven.

Configurando arquivos ignore e escopo de repositório no Neovim

Os desenvolvedores que utilizam Neovim frequentemente adotam o Supermaven por meio do plugin oficial supermaven-nvim devido ao seu baixo consumo de recursos e respostas rápidas. No entanto, configurar a exclusão de arquivos no Neovim requer atenção cuidadosa ao esquema de configuração do plugin.

Ciclo de vida do buffer no Neovim com Supermaven:

  [Arquivo aberto no buffer]
           │
           ▼
  [Verificar `condition()`] ──── Retorna false ───> [Supermaven interrompido / Sem tráfego]
           │
       Retorna true
           │
           ▼
  [Verificar `ignore_filetypes`] ── Corresponde ao ignore ──> [Sugestões ocultas / UI suprimida]
           │                                                                 │
       Não ignorado                                                          ▼
           │                                            *Nota: o buffer ainda pode sincronizar*
           ▼
  [Completamentos em linha ativos]

1. Supressão básica de tipos de arquivo com ignore_filetypes

A opção de configuração mais simples no supermaven-nvim é a tabela ignore_filetypes. Essa configuração instrui o plugin a não exibir sugestões de preenchimento ao editar formatos de arquivo específicos:

-- ~/.config/nvim/lua/plugins/supermaven.lua (ou init.lua)
require("supermaven-nvim").setup({
  keymaps = {
    accept_suggestion = "<Tab>",
    clear_suggestion = "<C-]>",
    accept_word = "<C-j>",
  },
  ignore_filetypes = {
    env = true,          -- Suprime sugestões em arquivos .env
    markdown = true,     -- Suprime em documentação/anotações
    text = true,         -- Arquivos de texto simples
    yaml = true,         -- Evita autocompletar em configurações de Kubernetes/CI
    json = true,         -- Esquemas de configuração e manifestos de pacotes
    sql = true,          -- Consultas de banco de dados e migrações
    gitcommit = true,    -- Mensagens de commit do Git
  },
  color = {
    suggestion_color = "#888888",
    cterm = 244,
  },
  disable_inline_completion = false,
  disable_keymaps = false,
})

2. A ressalva de transmissão de buffers e salvaguardas avançadas com condition()

Uma nuance técnica crucial identificada por desenvolvedores focados em segurança é que ignore_filetypes suprime principalmente a renderização de sugestões em linha na interface do editor. Em certas versões do cliente do servidor de linguagem, os buffers de arquivos carregados na memória ainda podem ser capturados pelo daemon em segundo plano.

Para garantir que arquivos confidenciais e diretórios sensíveis fiquem completamente isolados do processo do Supermaven, os desenvolvedores devem utilizar a função de retorno condition(). A função condition() é avaliada dinamicamente antes de o Supermaven atuar sobre um buffer:

require("supermaven-nvim").setup({
  -- Gatekeeper dinâmico: retorne false para parar totalmente o Supermaven no buffer
  condition = function()
    local filepath = vim.api.nvim_buf_get_name(0)
    
    -- Excluir arquivos sem caminho (buffers temporários scratch)
    if filepath == "" then
      return true
    end

    -- 1. Excluir arquivos de ambiente sensíveis e segredos
    if string.match(filepath, "%.env") 
       or string.match(filepath, "credentials")
       or string.match(filepath, "secrets/")
       or string.match(filepath, "/%.aws/")
       or string.match(filepath, "/%.ssh/") then
      return false
    end

    -- 2. Excluir certificados e chaves criptográficas
    if string.match(filepath, "%.pem$")
       or string.match(filepath, "%.key$")
       or string.match(filepath, "%.crt$") then
      return false
    end

    -- 3. Excluir projetos proprietários específicos ou pastas restritas por compliance
    if string.match(filepath, "/work/proprietary%-fintech/")
       or string.match(filepath, "/client%-classified/") then
      return false
    end

    -- 4. Excluir cargas de dados excessivas ou arquivos compilados
    local file_size = vim.fn.getfsize(filepath)
    if file_size > 1048576 then -- Limite de 1 MB
      return false
    end

    return true
  end,
})

3. Controle programático via Autocommands

Para obter segurança absoluta (isolamento air-gapped) ao abrir chaves privadas ou repositórios com exigências de conformidade, os desenvolvedores podem invocar a API programática do Supermaven diretamente em autocommands do Neovim:

-- Forçar interrupção do Supermaven em eventos de buffers sensíveis
vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
  pattern = { "*.env", "*.env.*", "*/secrets/*", "*.pem", "*.key" },
  callback = function()
    pcall(function()
      require("supermaven-nvim.api").stop()
    end)
  end,
})

-- Reabilitar o Supermaven ao acessar arquivos-fonte aprovados
vim.api.nvim_create_autocmd({ "BufEnter" }, {
  pattern = { "*.ts", "*.tsx", "*.js", "*.py", "*.go", "*.rs", "*.cpp" },
  callback = function()
    local filepath = vim.api.nvim_buf_get_name(0)
    if not string.match(filepath, "%.env") and not string.match(filepath, "secrets/") then
      pcall(function()
        require("supermaven-nvim.api").start()
      end)
    end
  end,
})

Configurando limites de indexação no Visual Studio Code

No Visual Studio Code, o Supermaven opera como uma extensão que se comunica por meio do Language Server Protocol. Como o Supermaven não lê um arquivo .supermavenignore específico na raiz do workspace, os desenvolvedores controlam o escopo da indexação por meio das regras nativas de exclusão de arquivos do VS Code, configurações do workspace e .gitignore.

┌───────────────────────────────────────────────────────────────────────────┐
│              Hierarquia de Exclusão de Contexto no VS Code                │
├───────────────────────────────────────────────────────────────────────────┤
│                                                                           │
│   Configurações de Usuário (Global ~/.config/Code/User/settings.json)     │
│     └── Exclui chaves pessoais, pastas SSH e credenciais globais          │
│                                                                           │
│   Configurações de Workspace (.vscode/settings.json)                      │
│     └── Exclui segredos do projeto, arquivos de ambiente e artefatos      │
│                                                                           │
│   Arquivo .gitignore do Projeto                                           │
│     └── Higiene padrão do repositório; respeitada por ferramentas         │
│                                                                           │
│   Escopo de Habilitação da Extensão                                       │
│     └── Desativa o Supermaven por completo em workspaces confidenciais    │
│                                                                           │
└───────────────────────────────────────────────────────────────────────────┘

1. Configuração de workspace (.vscode/settings.json)

Para evitar que o Supermaven e ferramentas de indexação relacionadas analisem arquivos de configuração confidenciais, adicione padrões explícitos de exclusão ao .vscode/settings.json do seu projeto:

{
  "files.exclude": {
    "**/.git": true,
    "**/.svn": true,
    "**/.hg": true,
    "**/CVS": true,
    "**/.DS_Store": true,
    "**/Thumbs.db": true,
    "**/.env*": true,
    "**/secrets/**": true,
    "**/*.pem": true,
    "**/*.key": true,
    "**/*.p12": true,
    "**/node_modules": true,
    "**/dist": true,
    "**/build": true,
    "**/coverage": true
  },
  "search.exclude": {
    "**/node_modules": true,
    "**/dist": true,
    "**/build": true,
    "**/.env*": true,
    "**/secrets/**": true
  },
  "files.watcherExclude": {
    "**/.git/objects/**": true,
    "**/.git/subtree-cache/**": true,
    "**/node_modules/*/**": true,
    "**/.env*": true,
    "**/secrets/**": true
  }
}

Por que files.watcherExclude é importante

A diretiva files.watcherExclude é fundamental para assistentes de programação com IA. Quando os arquivos são omitidos do monitor de arquivos do editor, o processo de indexação em segundo plano da extensão não recebe notificações de eventos do sistema de arquivos quando eles são modificados, impedindo ciclos acidentais de sincronização de tokens confidenciais.

2. Ativação da extensão em nível de workspace

Ao prestar serviços para múltiplas organizações ou alternar entre projetos de código aberto e bases de código empresariais proprietárias, configurações globais muitas vezes não são suficientes. Os desenvolvedores devem alternar o Supermaven por workspace:

1. Abra o projeto confidencial no VS Code.
2. Abra a Paleta de Comandos (Ctrl+Shift+P no Linux/Windows, Cmd+Shift+P no macOS).
3. Digite e selecione Extensions: Disable (Workspace).
4. Procure por Supermaven e pressione Enter.

Isso garante que o binário do cliente de linguagem seja totalmente encerrado dentro daquela instância de workspace, impedindo qualquer indexação em segundo plano, tráfego de rede ou envio de telemetria.

Segmentação de workspaces do desenvolvedor:

[Projeto padrão de código aberto] ──> Supermaven ativado (Contexto de 1M ativo)
[Repositório de ferramentas internas] ──> Supermaven ativado (Exclusões via settings.json)
[Monorepo fintech confidencial]   ──> Supermaven desativado no workspace (Air-Gapped)

Configuração em IDEs JetBrains

Desenvolvedores que utilizam IntelliJ IDEA, WebStorm, PyCharm ou outras IDEs JetBrains interagem com o Supermaven por meio do plugin do JetBrains Marketplace. A JetBrains oferece mecanismos nativos para limitar a inspeção de código e a indexação por IA.

1. Escopos (Scopes) e pastas excluídas

1. Clique com o botão direito em qualquer diretório com dados sensíveis (ex.: config/secrets, infra/credentials).
2. Selecione Mark Directory as -> Excluded.
3. Pastas excluídas são ignoradas pela inspeção de código, indexação de símbolos e pipelines de completamento.

2. Ignorar tipos de arquivo

Para impedir que a JetBrains e extensões de completamento de terceiros façam a leitura de arquivos de configuração:

1. Vá em Settings / Preferences -> Editor -> File Types.
2. Localize Ignored Files and Folders.
3. Adicione os padrões sensíveis:

   *.env;*.pem;*.key;*.p12;secrets;credentials;
   

4. Clique em Apply.

A migração para o Cursor e suporte nativo ao .cursorignore

Em novembro de 2024, a equipe do Supermaven uniu-se ao Cursor, e a tecnologia subjacente de contexto longo (incluindo a arquitetura de inferência customizada e a modelagem de sequências em múltiplos arquivos) foi integrada ao motor nativo de autocompletar do Cursor ("Cursor Tab"). Para os desenvolvedores que migram do Supermaven autônomo para o editor Cursor, o gerenciamento do contexto de repositório e da privacidade se torna significativamente mais granular por meio do suporte nativo ao .cursorignore.

Utilizando o .cursorignore

Diferente do Supermaven avulso, o Cursor oferece suporte nativo a um arquivo .cursorignore na raiz do projeto, utilizando a sintaxe de padrões padrão do .gitignore. Qualquer arquivo ou diretório correspondente ao .cursorignore é totalmente excluído da indexação de código em segundo plano, de embeddings semânticos e da construção da janela de contexto:

# .cursorignore - Colocar na raiz do projeto

# 1. Arquivos de ambiente e credenciais
.env*
*.pem
*.key
*.cert
*.p12
credentials.json
service-account.json

# 2. Diretórios de segredos e conformidade
secrets/
private/
compliance/
certs/

# 3. Dependências de terceiros e saídas de compilação
node_modules/
vendor/
dist/
build/
.next/
target/

# 4. Grandes arquivos que não são código e dumps de banco de dados
*.sql
*.sqlite
*.dump
*.csv
*.parquet
dataset/

Modo de privacidade do Cursor (Privacy Mode)

Além do .cursorignore, os desenvolvedores que atuam em ambientes com exigências rígidas de conformidade podem ativar o Privacy Mode no Cursor:

• Retenção zero de dados: No Privacy Mode, nenhuma parte do seu código é armazenada em servidores remotos e os prompts são processados de maneira estritamente efêmera.
• Conformidade SOC 2 Tipo II: A infraestrutura do Cursor é certificada para manter segmentação rigorosa de dados e padrões de segurança corporativa.

Melhores práticas para privacidade de código em fluxos com IA

Configurar arquivos ignore e ajustes no editor é apenas uma parte de uma postura sólida de segurança. As equipes de desenvolvimento devem estabelecer procedimentos operacionais padrão que minimizem riscos desde o planejamento.

┌──────────────────────────────────────────────────────────────────────────┐
│             Defesa em Profundidade para Segurança de Código com IA       │
├──────────────────────────────────────────────────────────────────────────┤
│  Camada 1: Gerenciamento de Segredos                                     │
│  • Eliminar credenciais fixas no código; injetar segredos em runtime.    │
│                                                                          │
│  Camada 2: Higiene do Repositório (.gitignore e .cursorignore)           │
│  • Garantir que arquivos sensíveis sejam ignorados no controle de versão.│
│                                                                          │
│  Camada 3: Escopo no Editor (VS Code settings.json / Neovim)             │
│  • Suprimir monitoramento de arquivos e envio de buffers em caminhos.    │
│                                                                          │
│  Camada 4: Segmentação de Rede e de Workspaces                           │
│  • Desativar extensões em workspaces com restrições de compliance.       │
│                                                                          │
│  Camada 5: Verificação de Políticas do Fornecedor                        │
│  • Auditar retenção de 7 dias e garantias de treinamento zero.           │
└──────────────────────────────────────────────────────────────────────────┘

1. Migrar segredos de arquivos para variáveis de ambiente em runtime

A forma mais confiável de impedir que uma ferramenta de IA leia um segredo é assegurar que ele nunca exista como arquivo de texto simples no diretório do workspace.

• Gerenciadores de segredos: Use ferramentas como Doppler, HashiCorp Vault, AWS Secrets Manager ou 1Password CLI para injetar credenciais diretamente na memória do processo em tempo de execução:

  # Em vez de salvar credenciais em um arquivo .env no disco:
  doppler run -- npm start
  

• Hooks de pré-commit do Git: Implemente ferramentas como git-secrets, trufflehog ou gitleaks em ganchos de pré-commit para bloquear commits que contenham acidentalmente chaves de API ou tokens.

2. Verificar a autenticidade das extensões oficiais

A Supermaven Code Policy estipula expressamente que suas garantias de retenção de 7 dias e de treinamento zero se aplicam apenas quando os desenvolvedores utilizam extensões oficiais vinculadas a partir de supermaven.com. Forks de terceiros, wrappers comunitários não oficiais ou adaptações não verificadas podem se comunicar com endpoints arbitrários ou não oferecer o devido isolamento de dados. Sempre verifique as assinaturas do publicador:

• VS Code Marketplace: Publicador supermaven (ID da extensão: supermaven.supermaven).
• Neovim: Repositório supermaven-inc/supermaven-nvim.
• JetBrains: Fornecedor Supermaven, Inc..

3. Acompanhar os indicadores na barra de status

Tanto no VS Code quanto na JetBrains, o Supermaven exibe um indicador na barra de status inferior direita. Esse widget fornece visibilidade em tempo real sobre:

• Estado da indexação: Confirma se o repositório está passando pela ingestão inicial de contexto.
• Status da conta: Mostra o plano ativo (Free vs. Pro) e o status de autenticação.
• Conectividade: Indica se o cliente está se comunicando com o endpoint de inferência em nuvem.

Clicar no indicador da barra de status permite que os desenvolvedores pausem as sugestões imediatamente caso um buffer não autorizado seja aberto.

Matriz comparativa: Métodos de configuração de privacidade

A matriz a seguir compara as diversas técnicas de configuração disponíveis para gerenciar o contexto de repositório e a privacidade no Supermaven nos diferentes ambientes de desenvolvimento:

Guia prático de implementação passo a passo

Para colocar essas estratégias em prática, siga este roteiro ao configurar um projeto com dados confidenciais:

Passo 1: Auditar o repositório em busca de ativos sensíveis

Faça uma varredura na estrutura do projeto para identificar credenciais, arquivos .env, certificados ou bases de dados proprietárias:

find . -maxdepth 3 -name "*.env*" -o -name "*.pem" -o -name "*.key" -o -name "*secret*"

Passo 2: Estabelecer higiene no controle de versão

Garanta que todos os arquivos identificados estejam listados no .gitignore:

# .gitignore
.env
.env.local
.env.production
*.pem
*.key
secrets/

Passo 3: Configurar proteções específicas do editor

Se estiver usando o VS Code:

Crie ou atualize o .vscode/settings.json:

{
  "files.exclude": {
    "**/.env*": true,
    "**/secrets/**": true,
    "**/*.pem": true,
    "**/*.key": true
  },
  "files.watcherExclude": {
    "**/.env*": true,
    "**/secrets/**": true
  }
}

Se estiver usando o Neovim:

Adicione o filtro de caminhos à sua configuração do supermaven-nvim:

require("supermaven-nvim").setup({
  condition = function()
    local filepath = vim.api.nvim_buf_get_name(0)
    if string.match(filepath, "%.env") or string.match(filepath, "secrets/") then
      return false
    end
    return true
  end,
})

Se estiver usando o Cursor:

Crie o .cursorignore na raiz do projeto:

.env*
secrets/
*.pem
*.key

Passo 4: Validar o status ativo

Abra seu editor e verifique:

1. Abra um arquivo-fonte padrão (ex.: src/index.ts). Confirme se as sugestões em linha aparecem conforme o esperado.
2. Abra um arquivo sensível (ex.: .env). Confirme se a barra de status indica o Supermaven desativado ou pausado, ou se nenhuma sugestão em linha é exibida.
3. Avalie os requisitos de conformidade da sua organização para decidir se a desativação no nível de workspace ou o gerenciamento de segredos em runtime é necessária para uma garantia máxima.

Conclusão

A janela de contexto de 1 milhão de tokens do Supermaven oferece ganhos expressivos de produtividade ao entregar sugestões de código rápidas e ricas em contexto em bases de código complexas. No entanto, manter o controle sobre a indexação da base de código e a propriedade intelectual requer uma estratégia de configuração intencional. Como o Supermaven não depende de um arquivo .supermavenignore independente, os desenvolvedores devem aproveitar todo o espectro de controles disponíveis: utilizar callbacks condition() e comandos programáticos de desligamento no Neovim, configurar files.exclude e watcherExclude no VS Code, desativar extensões em workspaces confidenciais e migrar para o .cursorignore quando aplicável.

Ao unir essas salvaguardas no nível do editor ao limite contratual de retenção de 7 dias do Supermaven, aos compromissos de treinamento zero e ao gerenciamento moderno de segredos em runtime, as equipes de engenharia podem aproveitar todo o poder do autocompletar com IA sem expor código-fonte proprietário nem credenciais de segurança críticas.