Tokenectomy Razor

Tokenectomy Razor

Corrija os Limites de Taxa do Claude Code e Cursor: Gateway de IA Local de Latência Zero e Servidor MCP de Cirurgia de Contexto em Rust

Pare de queimar 20.000 tokens em stack traces de node_modules. O Tokenectomy Razor é um gateway reverso de IA local de sub-milissegundo (127.0.0.1:8080) e servidor MCP complementar escrito em Rust seguro. Remove 41,7%–99,7% do ruído de frameworks de logs de erro de terminal, redige credenciais de banco de dados vazadas/JWTs e armazena prompts em cache gratuitamente.

Início Rápido (10s) • Arquitetura • O Problema • Antes e Depois • Demonstração Interativa ao Vivo • Benchmarks

                                 ┌────────────────────────────────────────────────────────┐
                                 │                   Autonomous Agents                    │
                                 │  Claude Code • Cursor • Antigravity • Cline • Windsurf │
                                 └───────────────────────────┬────────────────────────────┘
                                                             │
                                                             ▼ (HTTP / SSE Outbound Prompts)
   ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
   │                                 ⚡ TOKENECTOMY AI GATEWAY (127.0.0.1:8080)                                       │
   │                                                                                                                  │
   │  ┌─────────────────────────┐   ┌───────────────────────────┐   ┌──────────────────────────────────────────────┐  │
   │  │   Zero-Cost Prompt      │   │   Zero-Leak Credential    │   │         Polyglot Trace Surgery               │  │
   │  │         Cache           │   │         Redaction         │   │            (9 Languages)                     │  │
   │  │  <1ms Hit • 100% Free   │   │  API Keys • JWTs • DB URIs│   │  node_modules • site-packages • .cargo       │  │
   │  └───────────┬─────────────┘   └─────────────┬─────────────┘   └──────────────────────┬───────────────────────┘  │
   │              │                               │                                        │                          │
   │              └───────────────────────────────┼────────────────────────────────────────┘                          │
   │                                              ▼                                                                   │
   │                                 Smart Upstream Auto-Router                                                       │
   │                         (Anthropic • OpenAI • Groq • Ollama Local)                                               │
   └──────────────────────────────────────────────┬───────────────────────────────────────────────────────────────────┘
                                                  │
                 ┌────────────────────────────────┼────────────────────────────────┐
                 ▼                                ▼                                ▼
       api.anthropic.com                  api.openai.com                   localhost:11434
    (Claude 3.5 / 3.7 Sonnet)         (GPT-4o / o1 / o3-mini)              (DeepSeek / Llama)

⚡ Início Rápido (10s)

0. Wrapper de Uma Linha sem Configuração (wrap)

Execute qualquer agente de codificação ou suíte de testes diretamente atrás do gateway de privacidade e cache do Tokenectomy com zero configuração manual de variáveis de ambiente:

# Wrap Claude Code CLI
razor wrap -- claude

# Wrap Aider with DeepSeek or Ollama (Auto-Transpiled on the fly!)
razor wrap -- aider --model deepseek/deepseek-chat

# Wrap test runs to scrub logs and prevent accidental credential leakage
razor wrap npm test

1. Inicie o Gateway de IA Autônomo (Modo Manual)

npx -y tokenectomy-razor --proxy

💡 Roteamento Automático Multi-Provedor Inteligente e Transpilador LLM Universal ATIVADOS por padrão! O Tokenectomy analisa automaticamente caminhos de requisição e cabeçalhos. Precisa executar Claude Code contra DeepSeek ou Ollama? O Tokenectomy transpila de forma transparente o formato Anthropic /v1/messages para OpenAI /v1/chat/completions em tempo real e vice-versa.

2. Conecte Seu Agente Favorito

Aponte seu agente de codificação ou CLI para o gateway local em 127.0.0.1:8080:

3. Painel de FinOps e Segurança em Tempo Real

Abra http://127.0.0.1:8080/dashboard no seu navegador para observar reduções de tokens ao vivo, acertos de cache de prompt, economia em dólares e credenciais redigidas em tempo real.

4. Configuração do Servidor MCP Complementar (Sub-Córtex)

Para agentes que chamam ferramentas de diagnóstico profundas (get_error_context, analyze_code, apply_code_patch):

CLI do Claude Code

claude mcp add tokenectomy npx -y tokenectomy-razor --mcp

CLI do Google Antigravity / Gemini

agy mcp add tokenectomy-razor -- npx -y tokenectomy-razor --mcp

Cursor Composer (.cursor/mcp.json)

{
  "mcpServers": {
    "tokenectomy": {
      "command": "npx",
      "args": ["-y", "tokenectomy-razor", "--mcp"]
    }
  }
}

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "tokenectomy": {
      "command": "npx",
      "args": ["-y", "tokenectomy-razor", "--mcp"]
    }
  }
}

5. Piping de Terminal e Limpeza de CLI

npm test 2>&1 | npx tokenectomy-razor

🛑 O Problema: Por Que Sua IA Atinge Limites de Taxa e Alucina

Quando seu aplicativo falha durante o desenvolvimento (Next.js, Express, FastAPI, Tokio), o runtime despeja centenas de linhas de encanamento de terceiros de node_modules ou site-packages.

Quando você cola esse despejo de falha bruto no Cursor ou Claude:

1. Consome Seu Limite de Taxa de 5 Horas: Um único erro de Express/Prisma pode despejar 5.000 a 45.000 tokens de código de biblioteca de terceiros que você nunca escreveu. Alguns loops de falha queimam facilmente seu limite de sessão.
2. Dispara Alucinações na IA: O Claude se perde em internals de frameworks (node_modules/express/lib/router/layer.js ou starlette/routing.py) e tenta editar arquivos de biblioteca em vez do seu código de aplicação real.
3. Vaza Segredos e Credenciais: Strings de conexão com senhas brutas de banco de dados, tokens bearer JWT e chaves de nuvem embutidas em rastros de erro são encaminhadas para servidores de modelo externos.

Raw Terminal Crash (45,820 tokens + Leaked Secrets)
     │
     ▼  <0.2ms Local Rust DFA Engine
[Redact Passwords & Keys] ──► [Strip Third-Party Framework Frames] ──► [Isolate Root Cause]
     │
     ▼
Clean Context (118 tokens • Zero Secrets • Sub-millisecond)

🔍 Comparação Antes e Depois

❌ Sem Tokenectomy: A IA Alucina e Queima Contexto

TypeError: Cannot read properties of undefined (reading 'token')
    at loadComponents (/app/node_modules/next/dist/server/load-components.js:14:2)
    at renderToHTML (/app/node_modules/next/dist/server/render.js:50:5)
    at nextServer (/app/node_modules/next/dist/server/next-server.js:80:12)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)
    at runMicrotasks (node:internal/process/task_queues:120:3)
    at checkoutHandler (/app/pages/api/checkout.ts:42:15)
Database connection failed: postgresql://admin:super_secret_password@db.prod.internal:5432/primary
API key leaked: sk-ant-api03-abcdef1234567890abcdef1234567890

O que o Claude faz: Analisa load-components.js e next-server.js, especula sobre internals do Webpack / Next.js e vaza credenciais de conexão para logs de inferência remota.

✅ Com Tokenectomy: Contexto Limpo e Correção Instantânea

// [Tokenectomy Surgery: 5 internal framework frames pruned (83.3%)]
// Source: /app/pages/api/checkout.ts:42:15
42 |   const sessionToken = req.headers.authorization.token;
   |                                                  ^ TypeError: Cannot read properties of undefined (reading 'token')
🛡️ [CONNECTION_STRING_REDACTED]
🛡️ [ANTHROPIC_KEY_REDACTED]

O que o Claude faz: Identifica instantaneamente que a linha 42 em checkout.ts tentou acessar .token em cabeçalhos indefinidos. Sugere encadeamento opcional req.headers.authorization?.token imediatamente. Credenciais redigidas antes da transmissão.

🔬 Benchmarks Verificáveis

Todas as alegações de desempenho são fundamentadas em hardware e reproduzíveis de forma independente em hardware físico (medidas em Intel Core i5-1235U de 10 núcleos @ 15W rodando Arch Linux, Kernel 6.13):

Aviso de Dependência de Hardware: O desempenho depende do hardware; a taxa de transferência relatada representa resultados medidos no hardware de teste especificado (Intel Core i5-1235U de 10 núcleos @ 15W TDP). A taxa de transferência escala com CPUs de desktop/servidor de TDP mais alto e barramentos de memória mais rápidos. Os desenvolvedores são incentivados a auditar o desempenho de forma independente usando o comando de reprodução abaixo.

$ cargo test --release --test stress_benchmark -- --nocapture

=====================================================================================
🧪 TOKENECTOMY OSS VERIFIABLE HEAVY STRESS BENCHMARK (100% REPRODUCIBLE IN OSS)
   Hardware: 10-Core / 12-Thread Intel Core i5-1235U | OS: Arch Linux | Kernel Telemetry Active
   Initial Baseline Process Memory (VmRSS): 3.45 MB
=====================================================================================

🔥 [TEST 1/3] QUARTER-MILLION LINES LOG REDACTION TORTURE (250,000 LINES / 25MB+ BUFFER)
  ├── Buffer Size: 24.44 MB (250000 lines)
  ├── Redaction Latency: 471.05ms (51.9 MB/sec)
  ├── Line Throughput: 530,735 lines/sec
  ├── Peak Memory (VmRSS): 76.05 MB (Delta: +72.60 MB)
  └── Status: ✅ PASSED (100% of 250,000 lines sanitized, zero memory balloon)

🔥 [TEST 2/3] REDOS CATASTROPHIC BACKTRACKING TORTURE (50,000 CHARS PAYLOAD)
  ├── Attack Payload Size: 50,082 characters
  ├── Execution Latency: 1.165 ms
  └── Status: ✅ PASSED (Linear O(N) evaluation, ReDoS-resistant on tested payloads)

🔥 [TEST 3/3] HIGH-CONCURRENCY TORTURE (100 PARALLEL OS THREADS)
  ├── Thread Concurrency: 100 concurrent OS threads
  ├── Successful Operations: 100/100 (100.0%)
  ├── Total Elapsed: 11.31ms
  ├── Concurrency Throughput: 17,688 ops/sec
  ├── Final VmRSS: 78.99 MB
  └── Status: ✅ PASSED (Zero race condition, zero deadlock)

=====================================================================================
🏆 TOKENECTOMY OSS STRESS BENCHMARK: 3/3 PASSED (100% GREEN)
   Total Suite Duration: 580.83ms
   Bounded Final VmRSS: 78.99 MB
=====================================================================================
test test_oss_heavy_stress_benchmark ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.58s

🛡️ Benchmark de Redação Automatizada e Sanitização de Segredos

Avaliado em um fixture de teste de benchmark interno (tests/fixtures/) de 12 rastros de falha poliglotas (Rust, Python, TypeScript, Go, YAML) contendo 22 credenciais de verdade fundamental e controles negativos limpos. Avaliado frente a frente contra Gitleaks v8.30.1 (conjunto de regras padrão).

Nota Arquitetural: O Gitleaks é projetado principalmente como um scanner de commit/diff de repositório, não um redator de rastros de runtime em memória. O Tokenectomy Razor é projetado especificamente para sanitização de fluxo em runtime e cirurgia de stack trace.

1. Precisão, Recall e F1-Score por Categoria

2. Resumo de Desempenho e Arquitetura Frente a Frente

3. Redução de Tokens e Economia de Contexto LLM (tiktoken cl100k_base)

🔌 Configuração Avançada de Agente e Gateway

1. Opções de Gateway de IA Multi-Provedor (--proxy)

O gateway do Tokenectomy roda localmente em 127.0.0.1:8080 com zero configuração manual. Em ambientes de desenvolvimento complexos ou topologias de agentes em contêineres, você pode personalizar o binding e o roteamento:

# Default Smart Auto-Routing (routes Anthropic, OpenAI, and Ollama requests dynamically):
razor --proxy

# Safety Circuit Breaker: Prevent runaway agent loops from burning your hourly budget or 5-hour window:
razor --proxy --max-hourly-tokens 200000

# Resilient 429 Auto-Retry: Automatically pause and retry when hitting upstream rate limits (default: on):
razor --proxy --max-retries 5

# Explicit upstream override (e.g. Groq, vLLM, or OpenRouter):
razor --proxy --upstream-url https://api.groq.com/openai/v1

# Secure remote container binding with mandatory bearer token:
razor --proxy --proxy-bind 0.0.0.0:8080 --allow-remote --proxy-token "$MY_GATEWAY_TOKEN"

Métricas em Tempo Real & Exportação Prometheus

O Tokenectomy Razor expõe dados ao vivo de FinOps e economia de tokens via JSON:

curl http://127.0.0.1:8080/v1/metrics

Retorna telemetria instantânea para rate_limits_mitigated, circuit_breaker_trips, last_latency_ms, current_hourly_tokens, cache_hits, cache_tokens_saved e estimated_cost_saved_usd.

2. CLI Autônomo & Limpeza de Terminal

Ao depurar ou canalizar diretamente a saída de testes do terminal:

# Pipe terminal test failures through the surgical redactor:
npm test 2>&1 | razor --scrub

# Sanitize a specific raw log file:
razor --scrub --file /var/log/app/error.log > sanitized.log

# Offline local air-gapped mode (zero external network calls):
cat failure.log | razor --scrub --local-only

🛠️ Ferramentas MCP Expostas

O Tokenectomy Razor está em conformidade com o Glama Grade A Tool Definition Quality Score (TDQS) com limites explícitos de parâmetros:

🌐 Ecossistemas Poliglotas Suportados

📦 Opções de Instalação

Método 1: Instantâneo via npx (Zero Configuração de Toolchain)

npx -y tokenectomy-razor --mcp

Método 2: Cargo (crates.io)

cargo install tokenectomy

Método 3: Binários Autônomos Pré-compilados

Binários de release autônomos e sem dependências disponíveis em GitHub Releases:

• Linux: x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl, aarch64-unknown-linux-gnu
• macOS: aarch64-apple-darwin (Apple Silicon M1/M2/M3/M4), x86_64-apple-darwin (Intel)
• Windows: x86_64-pc-windows-msvc.exe

Método 4: Contêiner Docker Multi-Arquitetura (GHCR)

docker pull ghcr.io/tokenectomy-labs/razor:latest
docker run -i ghcr.io/tokenectomy-labs/razor:latest --mcp

⚖️ Comparação de Edições

Precisa de Auto-Cura de AST Empresarial? Explore o Nível Sentinel

🗺️ Roadmap & Marcos

🔒 Segurança & Invariantes

• Execução Local por Padrão: Todo parsing de stack trace, poda de quadros e redação de segredos executam localmente em hardware físico.
• Egresso de Rede Documentado: No modo servidor MCP, search_stack_overflow é a única ferramenta com egresso de rede de saída (HTTPS para api.stackexchange.com). O payload é estritamente limitado a texto de assinatura de erro sanitizado e redigido (sem linhas de código, sem caminhos locais, zero credenciais). Em ambientes isolados (air-gapped), use --local-only para desabilitar a busca de rede completamente.
• Correspondência de Padrões Determinística em Tempo Linear: Todos os correspondentes de padrões utilizam motores de regex DFA sem retrocesso (tempo linear $O(N)$) e avaliação de autômatos Aho-Corasick.
• Isolamento de Limite de Travessia de Caminho: Operações de arquivo são estritamente bloqueadas dentro da raiz do workspace ativo (CWD). Travessias de caminho (../) e symlinks não autorizados são bloqueados.
• Implementação Segura em Rust: Caminhos de execução centrais impõem garantias de memória segura do Rust com leitores de fluxo limitados (.take()) prevenindo exaustão de recursos.

Para divulgações de vulnerabilidades, revise nossa Política de Segurança.

⚖️ Aviso Legal & Isenção de Responsabilidade para Forks Derivados

O Tokenectomy Razor é fornecido estritamente para produtividade legal de desenvolvedores, observabilidade, cirurgia de logs e redação defensiva de credenciais. Quaisquer forks derivados, clones, redistribuições ou implantações privadas operam completamente independentes dos autores originais. A Tokenectomy Labs e seus mantenedores assumem zero responsabilidade por ações ilegais, maliciosas ou não autorizadas cometidas por terceiros usando este código ou seus derivados. Todos os operadores downstream assumem 100% de responsabilidade individual pela conformidade com leis de segurança cibernética locais e internacionais. Consulte DISCLAIMER.md para os termos legais completos.

❓ Perguntas Frequentes (FAQ)

Como o Tokenectomy Razor impede que o Claude Code e o Cursor atinjam limites de taxa?

Quando testes ou builds de terminal falham, frameworks como Next.js, Express, Jest e Django despejam milhares de quadros de stack internos (node_modules, site-packages). Enviar logs de crash brutos de 5.000 linhas consome de 15.000 a 45.000 tokens por prompt, drenando seu limite de sessão de 5 horas em minutos. O Tokenectomy Razor intercepta logs e remove 95% do encanamento de framework não acionável, reduzindo um log de crash de 40.000 caracteres para menos de 200 tokens essenciais em <0,2ms.

Como faço para impedir que o Cursor envie logs de erro do node_modules para LLMs?

Execute o Tokenectomy Razor como um proxy reverso local de Gateway de IA (npx -y tokenectomy-razor --proxy). Nas configurações do Cursor, aponte sua URL Base da OpenAI para http://127.0.0.1:8080/v1. Qualquer saída de erro de terminal colada ou referenciada pelo Composer será automaticamente sanitizada, limpa e armazenada em cache em tempo real antes de chegar aos servidores de modelo.

Como o Tokenectomy impede vazamento de credenciais em logs de erro?

Toda cirurgia de log e redação de segredos executa 100% localmente na sua máquina em memória antes da transmissão de saída. O Razor usa regex determinística em tempo linear e autômatos Aho-Corasick para detectar e redigir URIs de conexão PostgreSQL/MongoDB, tokens bearer JWT e chaves de API de nuvem com tokens [REDACTED]. Zero egresso de nuvem é necessário para a limpeza.

🤝 Comunidade & Recursos

• 🌐 Site Oficial
• 📖 Documentação
• 🏗️ Arquitetura do Sistema
• 📋 Changelog
• 🤝 Diretrizes de Contribuição
• 🔒 Política de Segurança
• ⚖️ Isenção de Responsabilidade & Responsabilidade