SYKE - AI Code Impact Analysis

Servidor MCP de análisis de impacto y grafo de dependencias en vivo para agentes de codificación de IA. Ejecuta compuertas de compilación PASS/WARN/FAIL antes de cambios de código para prevenir fallos en cascada. Compatible con TS, Python, Dart, Go, Rust, Java, C++, Ruby.

GitHub

Prueba este MCPPatrocinado

Documentación

SYKE — Tu código tiene pulso

Servidor MCP de análisis de impacto de código con IA. SYKE monitorea cada archivo que tu IA toca, mapea grafos de dependencias, detecta fallos en cascada y bloquea builds antes de que el daño se propague.

Funciona con Claude Code, Cursor, Windsurf y cualquier agente de codificación con IA compatible con MCP.

SYKE Dependency Graph

SYKE Impact Analysis

SYKE Node Detail

Cómo funciona

Al iniciar, SYKE escanea tu directorio de código fuente y construye un grafo de dependencias completo mediante análisis estático de imports.
Tu agente de IA modifica archivos libremente — sin interrupciones durante el trabajo normal.
Antes de build/deploy, la IA llama a gate_build para verificar si todos los cambios son seguros.
Si las dependencias se rompen, SYKE detecta fallos en cascada y bloquea el build con un veredicto FAIL.
El panel de control muestra una visualización en tiempo real de tu grafo de dependencias con indicadores de riesgo.

SYKE es una red de seguridad, no un guardián. No bloquea a tu IA mientras trabaja — detecta lo que tu IA pasó por alto antes de que lo envíes.

Inicio rápido

1. Crear archivo de configuración

Crea ~/.syke/config.json:

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

Obtén tu clave de licencia en syke.cloud/dashboard. Solo necesitas UNA clave de IA. Compatible con: geminiKey, openaiKey, anthropicKey.

2. Registrar el 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: Si npx no se encuentra, usa la ruta completa: "command": "C:\\Program Files\\nodejs\\npx.cmd"

3. Agrega la puerta de build a tu proyecto

Agrega esta línea al CLAUDE.md de tu proyecto (o archivo de instrucciones de IA equivalente):

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

Esto asegura que tu agente de IA ejecute automáticamente la verificación de seguridad de SYKE después de cada tarea — sin necesidad de indicaciones manuales.

4. Reinicia tu agente de IA

SYKE detecta automáticamente el lenguaje de tu proyecto y construye el grafo de dependencias al iniciar. Abre http://localhost:3333 para ver tu panel en vivo.

Características

8 herramientas MCP

Herramienta	Nivel	Descripción
`gate_build`	Gratis	Verificación obligatoria pre-build. Devuelve veredicto PASS/WARN/FAIL antes de cualquier build o deploy.
`check_safe`	Gratis	Veredicto rápido de seguridad en una línea: riesgo HIGH/MEDIUM/LOW/NONE.
`get_dependencies`	Gratis	Lista imports internos (dependencias directas) de un archivo.
`analyze_impact`	Pro	Análisis de impacto completo con SCC, puntuación de riesgo y acoplamiento git.
`get_hub_files`	Pro	Clasifica archivos por puntuación de importancia PageRank.
`refresh_graph`	Pro	Re-escanea todos los archivos fuente y reconstruye el grafo de dependencias.
`ai_analyze`	Pro	Análisis semántico con IA (Gemini/OpenAI/Claude) de un archivo y sus dependientes.
`check_warnings`	Pro	Alertas de monitoreo en tiempo real para cambios de archivos que puedan romper dependientes.

Soporte multi-proveedor de IA

SYKE soporta tres proveedores de IA para análisis semántico. Trae tu propia clave:

Proveedor	Modelo	Clave de configuración	Variable de entorno
Google Gemini	`gemini-2.5-flash`	`geminiKey`	`GEMINI_KEY`
OpenAI	`gpt-4o-mini`	`openaiKey`	`OPENAI_KEY`
Anthropic	`claude-sonnet-4-20250514`	`anthropicKey`	`ANTHROPIC_KEY`

Selección automática: SYKE usa la primera clave disponible (Gemini > OpenAI > Anthropic). Forzar proveedor: Establece aiProvider en la configuración (o la variable de entorno SYKE_AI_PROVIDER) para anular.

Algoritmos avanzados de grafos

SYKE va más allá del simple conteo de dependencias. Cinco algoritmos de nivel de producción trabajan juntos para entregar un análisis de impacto preciso, rápido y con contexto — todo ejecutándose localmente con costo cero de tokens de IA.

1. Condensación SCC + Orden topológico

Las dependencias circulares son la fuente #1 de análisis de impacto engañoso. SYKE usa el algoritmo de Tarjan para detectar todos los Componentes Fuertemente Conectados, los condensa en un DAG limpio, y luego ejecuta orden topológico para calcular niveles de cascada correctos.

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

Computación O(V+E) — se ejecuta en milisegundos de un solo dígito
Cada SCC con tamaño > 1 se marca como un clúster de dependencia circular
Los niveles de cascada son precisos incluso en codebases altamente cíclicos

2. Puntuación de riesgo compuesta

Cinco señales combinadas en una única puntuación de riesgo 0–1:

Señal	Peso	Qué mide
Fan-in	30%	Cuántos archivos dependen de este
Índice de estabilidad	20%	I = Ce/(Ca+Ce) — menor = archivo base = más riesgoso de cambiar
Complejidad ciclomática	20%	Complejidad interna de ramificación (basada en regex, 8 lenguajes)
Profundidad de cascada	15%	Cuántas capas de profundidad se propaga el impacto
PageRank	15%	Importancia recursiva en el grafo de dependencias

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

Los agentes de IA ahora pueden tomar decisiones por umbral: proceder si < 0.3, warn if 0.3–0.7, block if > 0.7.

3. Acoplamiento de cambios históricos

Los imports estáticos no detectan dependencias ocultas — archivos que siempre cambian juntos pero no tienen relación de import. SYKE analiza tu historial de git (últimos 500 commits) para encontrar estos acoplamientos 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)

Detecta el 15–30% de archivos impactados que el análisis estático pasa por alto por completo
Filtra mega-commits (>20 archivos) para evitar ruido
Caché de 5 minutos con auto-refresco

4. PageRank para importancia de archivos

El conteo simple de fan-in trata a todos los dependientes por igual. PageRank calcula importancia recursiva — un archivo importado por muchos archivos importantes se clasifica más alto que uno importado por muchos archivos hoja.

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)

Iteración de potencia estándar con factor de amortiguación 0.85
Precalculado al inicio, actualizado incrementalmente en cambios de archivos
Cada archivo obtiene una posición de rango y percentil (ej., "rango #3 de 245, percentil 99")

5. Actualizaciones incrementales de grafos + consultas memoizadas

Para codebases grandes (10K+ archivos), las reconstrucciones completas de grafos son demasiado lentas. SYKE ahora actualiza solo los bordes del archivo cambiado e invalida solo las entradas de caché afectadas.

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

El índice inverso permite invalidación de caché O(afectados) en lugar de O(tamaño_caché)
SCC y PageRank se recalculan después de cambios de bordes (aún < 100ms para 10K archivos)
Caché LRU de 500 entradas con diagnósticos de aciertos/fallos

Soporte de lenguajes

Auto-detectado, cero configuración: Dart/Flutter, TypeScript/JavaScript, Python, Go, Rust, Java, C++, Ruby.

Panel web

Visualización en vivo del grafo de dependencias en localhost:3333 con:

Grafo de nodos 3D interactivo (haz clic en cualquier archivo para ver sus conexiones)
Monitoreo de cascada en tiempo real
Indicadores de nivel de riesgo
Detección de servidor desconectado con reconexión automática

Configuración

SYKE lee desde ~/.syke/config.json (principal) con anulaciones por variables de entorno:

Clave de configuración	Variable de entorno	Descripción	Requerido
`licenseKey`	`SYKE_LICENSE_KEY`	Clave Pro del panel de control	No (el nivel Gratis funciona sin ella)
`geminiKey`	`GEMINI_KEY`	Clave API de Google Gemini para `ai_analyze`	No (cualquier clave de IA)
`openaiKey`	`OPENAI_KEY`	Clave API de OpenAI para `ai_analyze`	No (cualquier clave de IA)
`anthropicKey`	`ANTHROPIC_KEY`	Clave API de Anthropic para `ai_analyze`	No (cualquier clave de IA)
`aiProvider`	`SYKE_AI_PROVIDER`	Forzar proveedor de IA: `gemini`, `openai` o `anthropic`	No (auto-selección)
`port`	`SYKE_WEB_PORT`	Puerto del panel (predeterminado: 3333)	No

Ejemplo de configuración completa (~/.syke/config.json):

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

Flujo de trabajo 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 gratis para primeros adoptantes

Estamos dando a los primeros 100 desarrolladores acceso Pro completo por 30 días — sin tarjeta de crédito, sin condiciones.

Lo que obtienes:

Las 8 herramientas MCP con algoritmos avanzados (SCC, PageRank, Puntuación de riesgo, Acoplamiento git)
Archivos ilimitados, soporte multi-proyecto
Monitoreo de cascada en tiempo real + panel web
Análisis semántico con IA (BYOK — Gemini, OpenAI o Claude)

Cómo reclamarlo:

Regístrate en syke.cloud
Dale estrella a este repositorio
Haz clic en "Di Estrella" en tu panel de control → 30 días de Pro desbloqueados

Los lugares son limitados. Una vez que se agotan, se agotan.

Código fuente

Este repositorio contiene el código fuente del nivel Gratis — el motor central del grafo de dependencias, los plugins de lenguajes y 3 herramientas MCP gratuitas (gate_build, check_safe, get_dependencies). Las características Pro y Cortex (algoritmos avanzados, análisis con IA, monitoreo en tiempo real, panel web) están incluidas en el paquete npm como código compilado.

Licencia

Licencia Elastic 2.0 (ELv2)

Puedes usar, modificar y distribuir SYKE libremente, con dos limitaciones:

Sin servicio gestionado — No puedes ofrecer SYKE como servicio alojado/gestionado a terceros.
Sin evasión de clave de licencia — No puedes eliminar, deshabilitar o eludir la funcionalidad de clave de licencia.