SYKE - AI Code Impact Analysis

Servidor MCP de grafo de dependências ao vivo e análise de impacto para agentes de codificação de IA. Executa portões de build PASS/WARN/FAIL antes de alterações de código para prevenir falhas em cascata. Suporta TS, Python, Dart, Go, Rust, Java, C++, Ruby.

GitHub

Experimente este MCPPatrocinado

Documentação

SYKE — Sua base de código tem um pulso

Servidor MCP de análise de impacto de código com IA. SYKE monitora cada arquivo que sua IA toca, mapeia grafos de dependência, detecta quebras em cascata e bloqueia builds antes que o dano se espalhe.

Funciona com Claude Code, Cursor, Windsurf e qualquer agente de codificação com IA compatível com MCP.

SYKE Dependency Graph

SYKE Impact Analysis

SYKE Node Detail

Como Funciona

Na inicialização, o SYKE escaneia seu diretório de código e constrói um grafo de dependências completo usando análise estática de imports.
Seu agente de IA modifica arquivos livremente — sem interrupções durante o trabalho normal.
Antes do build/deploy, a IA chama gate_build para verificar se todas as alterações são seguras.
Se as dependências quebrarem, o SYKE detecta falhas em cascata e bloqueia o build com um veredito FAIL.
O dashboard mostra uma visualização em tempo real do seu grafo de dependências com indicadores de risco.

SYKE é uma rede de segurança, não um porteiro. Ele não bloqueia sua IA enquanto trabalha — ele captura o que sua IA deixou passar antes de você publicar.

Início Rápido

1. Crie o arquivo de configuração

Crie ~/.syke/config.json:

{
  "licenseKey": "SYKE-XXXX-XXXX-XXXX-XXXX",
  "geminiKey": "your-gemini-api-key"
}

Obtenha sua chave de licença em syke.cloud/dashboard. Você só precisa de UMA chave de IA. Suportadas: geminiKey, openaiKey, anthropicKey.

2. Registre o servidor MCP

Claude Code:

claude mcp add syke -- npx @syke1/mcp-server@latest

Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "syke": {
      "command": "npx",
      "args": ["@syke1/mcp-server@latest"]
    }
  }
}

Windsurf (~/.codeium/windsurf/mcp_config.json):

{
  "mcpServers": {
    "syke": {
      "command": "npx",
      "args": ["@syke1/mcp-server@latest"]
    }
  }
}

Nota para Windows: Se npx não for encontrado, use o caminho completo: "command": "C:\\Program Files\\nodejs\\npx.cmd"

3. Adicione o portão de build ao seu projeto

Adicione esta linha ao CLAUDE.md do seu projeto (ou arquivo de instruções de IA equivalente):

After completing code changes, always run the gate_build MCP tool before committing or deploying.

Isso garante que seu agente de IA execute automaticamente a verificação de segurança do SYKE após cada tarefa — sem necessidade de solicitação manual.

4. Reinicie seu agente de IA

O SYKE detecta automaticamente o idioma do seu projeto e constrói o grafo de dependências na inicialização. Abra http://localhost:3333 para ver seu dashboard ao vivo.

Recursos

8 Ferramentas MCP

Ferramenta	Nível	Descrição
`gate_build`	Grátis	Verificação obrigatória pré-build. Retorna veredito PASS/WARN/FAIL antes de qualquer build ou deploy.
`check_safe`	Grátis	Veredito rápido de segurança em uma linha: risco ALTO/MÉDIO/BAIXO/NENHUM.
`get_dependencies`	Grátis	Lista imports internos (dependências diretas) de um arquivo.
`analyze_impact`	Pro	Análise completa de impacto com SCC, pontuação de risco e acoplamento git.
`get_hub_files`	Pro	Classifica arquivos por pontuação de importância PageRank.
`refresh_graph`	Pro	Reescaneia todos os arquivos de código e reconstrói o grafo de dependências.
`ai_analyze`	Pro	Análise semântica com IA (Gemini/OpenAI/Claude) de um arquivo e seus dependentes.
`check_warnings`	Pro	Alertas de monitoramento em tempo real para alterações de arquivos que podem quebrar dependentes.

Suporte a Múltiplos Provedores de IA

O SYKE suporta três provedores de IA para análise semântica. Traga sua própria chave:

Provedor	Modelo	Chave de Config	Variável de Ambiente
Google Gemini	`gemini-2.5-flash`	`geminiKey`	`GEMINI_KEY`
OpenAI	`gpt-4o-mini`	`openaiKey`	`OPENAI_KEY`
Anthropic	`claude-sonnet-4-20250514`	`anthropicKey`	`ANTHROPIC_KEY`

Seleção automática: O SYKE usa a primeira chave disponível (Gemini > OpenAI > Anthropic). Forçar provedor: Defina aiProvider na configuração (ou a variável de ambiente SYKE_AI_PROVIDER) para substituir.

Algoritmos Avançados de Grafo

O SYKE vai além da simples contagem de dependências. Cinco algoritmos de nível de produção trabalham juntos para fornecer análise de impacto precisa, rápida e rica em contexto — tudo rodando localmente com custo zero de tokens de IA.

1. Condensação SCC + Ordenação Topológica

Dependências circulares são a fonte nº 1 de análise de impacto enganosa. O SYKE usa o algoritmo de Tarjan para detectar todos os Componentes Fortemente Conectados, condensa-os em um DAG limpo e executa a ordenação topológica para calcular níveis de cascata corretos.

Before: "47 files affected" (inflated by cycles)
After:  "3 files in circular cluster (Level 0) → 5 files (Level 1) → 4 files (Level 2)"

Computação O(V+E) — roda em milissegundos de um dígito
Todo SCC com tamanho > 1 é sinalizado como um cluster de dependência circular
Níveis de cascata são precisos mesmo em bases de código altamente cíclicas

2. Pontuação de Risco Composta

Cinco sinais combinados em uma única pontuação de risco de 0 a 1:

Sinal	Peso	O que mede
Fan-in	30%	Quantos arquivos dependem deste
Índice de Estabilidade	20%	I = Ce/(Ca+Ce) — menor = arquivo base = mais arriscado de alterar
Complexidade Ciclomática	20%	Complexidade interna de ramificações (baseada em regex, 8 linguagens)
Profundidade de Cascata	15%	Quantas camadas o impacto se propaga
PageRank	15%	Importância recursiva no grafo de dependências

auth_service.ts → Risk: 0.82 (CRITICAL)
  Fan-in: 24, Stability: 0.12, Complexity: 47, Cascade: 4 levels, PageRank: 99th

string_utils.ts → Risk: 0.31 (LOW)
  Fan-in: 18, Stability: 0.85, Complexity: 3, Cascade: 1 level, PageRank: 42nd

Agentes de IA agora podem tomar decisões de limite: prossiga se < 0.3, warn if 0.3–0.7, block if > 0.7.

3. Acoplamento Histórico de Alterações

Imports estáticos perdem dependências ocultas — arquivos que sempre mudam juntos, mas não têm relação de import. O SYKE explora seu histórico git (últimos 500 commits) para encontrar esses acoplamentos lógicos.

auth_service.ts changed →
  [Dependency Graph] auth_provider.ts, login_screen.ts
  [Git Coupling — Hidden Dependencies]
    config/auth_config.json (85% confidence, 12 co-changes)
    styles/auth.css (72% confidence, 8 co-changes)

Captura 15–30% dos arquivos impactados que a análise estática perde completamente
Filtra mega-commits (>20 arquivos) para evitar ruído
Cache de 5 minutos com atualização automática

4. PageRank para Importância de Arquivos

Contagens simples de fan-in tratam todos os dependentes igualmente. O PageRank calcula importância recursiva — um arquivo importado por muitos arquivos importantes tem classificação maior do que um importado por muitos arquivos folha.

Before: utils.ts ranked #1 (25 dependents — but all are leaf components)
After:  auth.ts ranked #1 (20 dependents — 15 of which are core modules)

Iteração de Potência padrão com fator de amortecimento 0.85
Pré-computado na inicialização, atualizado incrementalmente em alterações de arquivos
Cada arquivo recebe uma posição e percentil (ex.: "rank #3 de 245, 99º percentil")

5. Atualizações Incrementais de Grafo + Consultas Memorizadas

Para bases de código grandes (10K+ arquivos), reconstruções completas do grafo são muito lentas. O SYKE agora atualiza apenas as arestas do arquivo alterado e invalida apenas as entradas de cache afetadas.

Before: 1 file changed → re-parse all 500 files → 2+ seconds
After:  1 file changed → re-parse 1 file → edge diff → 50ms
        Same file queried again → cache hit → O(1) instant

Índice reverso permite invalidação de cache O(afetados) em vez de O(tamanho_do_cache)
SCC e PageRank são recalculados após alterações de arestas (ainda < 100ms para 10K arquivos)
Cache LRU de 500 entradas com diagnósticos de acerto/erro

Suporte a Linguagens

Detectadas automaticamente, sem configuração: Dart/Flutter, TypeScript/JavaScript, Python, Go, Rust, Java, C++, Ruby.

Dashboard Web

Visualização ao vivo do grafo de dependências em localhost:3333 com:

Grafo de nós 3D interativo (clique em qualquer arquivo para ver suas conexões)
Monitoramento de cascata em tempo real
Indicadores de nível de risco
Detecção de servidor offline com reconexão automática

Configuração

O SYKE lê de ~/.syke/config.json (principal) com substituições por variáveis de ambiente:

Chave de Config	Variável de Ambiente	Descrição	Obrigatório
`licenseKey`	`SYKE_LICENSE_KEY`	Chave de licença Pro do dashboard	Não (o nível gratuito funciona sem)
`geminiKey`	`GEMINI_KEY`	Chave da API Google Gemini para `ai_analyze`	Não (qualquer chave de IA)
`openaiKey`	`OPENAI_KEY`	Chave da API OpenAI para `ai_analyze`	Não (qualquer chave de IA)
`anthropicKey`	`ANTHROPIC_KEY`	Chave da API Anthropic para `ai_analyze`	Não (qualquer chave de IA)
`aiProvider`	`SYKE_AI_PROVIDER`	Forçar provedor de IA: `gemini`, `openai` ou `anthropic`	Não (seleção automática)
`port`	`SYKE_WEB_PORT`	Porta do dashboard (padrão: 3333)	Não

Exemplo completo de configuração (~/.syke/config.json):

{
  "licenseKey": "SYKE-XXXX-XXXX-XXXX-XXXX",
  "geminiKey": "AIza...",
  "openaiKey": "",
  "anthropicKey": "",
  "port": 3333
}

Fluxo de Trabalho Recomendado

You (developer)          AI Agent            SYKE
     |                      |                  |
     |-- "Add feature X" -->|                  |
     |                      |-- modifies files |
     |                      |-- modifies files |
     |                      |-- modifies files |
     |                      |                  |
     |                      |-- gate_build --->|
     |                      |                  |-- scans graph
     |                      |                  |-- checks impact
     |                      |<-- PASS/FAIL ----|
     |                      |                  |
     |<-- "Done. Safe to    |                  |
     |    build." ----------|                  |

Fundadores 100 — Pro Gratuito para Adotantes Iniciais

Estamos dando aos primeiros 100 desenvolvedores acesso Pro completo por 30 dias — sem cartão de crédito, sem compromisso.

O que você recebe:

Todas as 8 ferramentas MCP com algoritmos avançados (SCC, PageRank, Pontuação de Risco, Acoplamento Git)
Arquivos ilimitados, suporte a múltiplos projetos
Monitoramento de cascata em tempo real + dashboard web
Análise semântica com IA (BYOK — Gemini, OpenAI ou Claude)

Como reivindicar:

Cadastre-se em syke.cloud
Dê uma estrela neste repositório
Clique em "I Starred" no seu dashboard → 30 dias Pro desbloqueados

As vagas são limitadas. Quando acabarem, acabaram.

Código-Fonte

Este repositório contém o código-fonte do nível gratuito — o mecanismo central do grafo de dependências, plugins de linguagem e 3 ferramentas MCP gratuitas (gate_build, check_safe, get_dependencies).

Os recursos Pro e Cortex (algoritmos avançados, análise de IA, monitoramento em tempo real, dashboard web) estão incluídos no pacote npm como código compilado.

Licença

Elastic License 2.0 (ELv2)

Você pode usar, modificar e distribuir o SYKE livremente, com duas limitações:

Sem serviço gerenciado — Você não pode oferecer o SYKE como um serviço hospedado/gerenciado para terceiros.
Sem contornar a chave de licença — Você não pode remover, desabilitar ou contornar a funcionalidade da chave de licença.