Sparda

SPARDA

🇫🇷 Francés — La IA escribe. SPARDA prueba. Una puerta determinista y fuera de línea que detecta cuando una modificación de IA retira una guardia, expone una ruta o rompe un invariante — sin clave API, directamente en el bucle de edición del agente. Para entenderlo todo en 10 minutos (dolor, arquitectura, visión): SPARDA-EXPLIQUE.md.

---

La IA escribe. SPARDA prueba.

La IA escribe. SPARDA prueba.

La capa de confianza para backends escritos por IA. SPARDA compila tu backend — rutas, consultas de base de datos, mutaciones de estado, guardias, efectos secundarios — en un único grafo de comportamiento determinista, y luego prueba estáticamente qué puede y qué no puede romperse antes de que despliegues: sin mutación sin guardia, sin invariante roto, sin escritura agregada no atómica.

100% local · determinista · cero clave API · sin cuenta en la nube. Falla ruidosamente ante un riesgo real, y cuando solo puede ver parte de tu aplicación dice PROVEN (PARTIAL) — nunca un falso verde. Y cuando puede probar que ni siquiera estaba mirando toda tu aplicación, dice PREMISE NOT VERIFIED y no afirma nada en absoluto.

Prueba en 60 segundos

Desde tu aplicación Express, FastAPI, Flask, Next.js, NestJS o Medusa — nada que configurar:

npx sparda-mcp apocalypse   # prove the tree is safe to deploy — exit 1 on any real risk, or on an unverified premise
npx sparda-mcp prove        # the whole verdict: proof + coverage + shareable seal
npx sparda-mcp badge        # a README badge: proven · coverage% · routes

Bajo el capó, compila tu backend en un único grafo independiente del lenguaje — el Unified Behavior Graph (UBG), serializado como .sparda/ubg.json bajo la especificación SBIR (SPARDA Behavior IR) — y cada comando es una pasada sobre ese grafo.

La cuña — detectar una edición de IA que elimina una guardia, en el bucle

Lo único que una revisión de diff de texto y un escáner de patrones no pueden hacer estructuralmente: probar que esta edición específica eliminó una protección que la versión anterior tenía. sparda gate compara el grafo de comportamiento antes/después de una edición y bloquea una regresión — determinista, fuera de línea, en menos de un segundo, salida 2 (el contrato PostToolUse de Claude Code que detiene el bucle de edición del agente). Véalo de principio a fin con un solo comando, sin configuración:

npm run wedge     # (from a clone)  — or drive it on your own app with `sparda gate --arm` then `sparda gate --hook`

  1. baseline armed on the guarded code   (POST /admin/delete-user · requireAdmin)
  2. an AI edit "simplifies" requireAdmin → a pass-through (still compiles, still 200s)
  3. sparda gate on the edit:
       ✗ [critical] GUARD_REMOVED — POST /admin/delete-user was guarded in the baseline
                    and is now reachable without any guard (src/app.js:11)
     ⏱  ~40 ms · deterministic · offline · no API key
     ⛔ exit 2 on --hook — Claude Code PostToolUse blocks the edit

Conéctalo a Claude Code en una línea — el plugin registra un hook PostToolUse que ejecuta npx -y sparda-mcp gate --hook después de cada Edit/Write, de modo que una edición que elimina una guardia se detecta antes de que aterrice.

[!IMPORTANT]
La prueba de compilación de rutas — reprodúcela tú mismo. SPARDA compila monstruos reales de código abierto a su grafo de comportamiento con cero fallos, cada uno en ≈1–2 segundos: Next.js Dub (579 rutas), NestJS Immich (281), MedusaJS (477). Resuelve de forma nativa la inyección de dependencias profunda, los controladores externos y los manejadores de Next.js. Un solo comando los clona y los vuelve a medir en tu máquina:

node bench/repro.mjs        # → bench/route-proof.json

Honestidad primero: compilar una ruta es un resultado del analizador (el número anterior); probar que es segura es un veredicto separado por repositorio — y la mayoría de las aplicaciones reales devuelven NOT_PROVEN, que es el estado verdadero, no un fallo. (Nuestro corpus completo de 25 repositorios compila bajo estrés 3,565 rutas a ~150 rutas/s; ese necesita el corpus descargado.)

Lo que el grafo desbloquea — 100% local, determinista, 4 dependencias exactamente fijadas, cero clave API:

Comando	Qué hace
prove	El veredicto de confianza completo en un solo gesto — prueba + cobertura + verificación de premisa + un sello compartible (--json / --markdown)
apocalypse	Prueba el despliegue — ninguna guardia, invariante, transacción o límite de agregado puede romperse (SARIF + puerta de CI)
heal	Autocuración, probada — la puerta que Copilot Autofix no tiene: una corrección se envía solo si la reproducción coincide, verify sigue pasando, y apocalypse no encuentra ningún riesgo nuevo / ninguna guardia eliminada. Quien haya escrito la corrección, la máquina la juzga.
badge	El artefacto compartible — una insignia SVG autocontenida + fragmento de README (veredicto · cobertura · rutas)
dossier	El informe público — una página HTML autocontenida: veredicto, riesgos y los propios puntos ciegos de SPARDA
ubg	Compila el código fuente a su grafo de comportamiento (Express · FastAPI · Flask · Next.js · NestJS · Medusa de forma nativa; cualquier stack vía OpenAPI)
timeless	Viaje en el tiempo — graba una solicitud de producción, reprodúcela byte a byte idéntica, exporta el error como prueba
mirror	Ejecuta el grafo — sirve el comportamiento compilado por HTTP sin framework y sin código fuente
init / dev	Runtime, opcional — expone el grafo a clientes de IA como un servidor MCP en vivo (+ Twin, Immune, Evolution)

El probador es el producto. El servidor MCP es una salida del grafo, no el punto — SPARDA compila el comportamiento de todo el sistema, luego prueba, reproduce, cura y (opcionalmente) lo sirve.

Nomenclatura: SBIR es la especificación (el formato, como "JSON"); UBG es el grafo compilado en sí (el artefacto, ubg.json). El servidor MCP es una salida del grafo, no el producto.

Opcional: exponer el grafo a clientes de IA (runtime MCP)

Más allá de probar, SPARDA puede convertir tu aplicación en ejecución en un servidor MCP en vivo — el grafo, ejecutable, con seguridad de escritura y una capa inmune. Esto es opcional y separado del probador anterior.

1. Escanea + inyecta — ejecuta una vez, desde el directorio de tu aplicación:

   npx sparda-mcp init
   

   SPARDA analiza tus rutas (AST), genera un router /mcp marcado, lo inyecta en tu aplicación (con una copia de seguridad) y escribe sparda.json. Cada paso es reversible.

2. Inicia tu aplicación, luego inicia el puente:

   npx sparda-mcp dev
   

3. Conecta tu cliente. init imprime un bloque listo para pegar para claude_desktop_config.json, prellenado con el nombre y la ruta de tu aplicación:

   {
     "mcpServers": {
       "your-app": {
         "command": "npx",
         "args": ["sparda-mcp", "dev"],
         "cwd": "/absolute/path/to/your-app"
       }
     }
   }
   

   Claude Code se conecta al mismo puente. Eso es todo — tu aplicación en ejecución ahora es un conjunto de herramientas MCP que tu IA puede llamar.

Prueba la Demo Independiente

Para ver SPARDA en acción al instante sin modificar tu código:

npx sparda-mcp demo

Esto ejecuta todo el ciclo de vida de MCP (detectar → analizar → generar → inyectar → eliminar) en una aplicación de demostración incluida en una carpeta temporal, en unos 10 segundos. Para el compilador en sí, ejecuta npx sparda-mcp ubg y luego apocalypse en cualquier aplicación Express/FastAPI.

Informe de Caja Negra

SPARDA está diseñado como un organismo local. Para ver qué recuerda y cuánto cómputo ha reciclado:

npx sparda-mcp report

Esto imprime un panel de terminal que agrega tus herramientas expuestas, opt-ins de escritura, decisiones del diario de pruebas y herramientas compuestas cristalizadas.

Para escribir un panel HTML autocontenido y fuera de línea en .sparda/report.html, añade la bandera --html:

npx sparda-mcp report --html

Para generar JSON crudo para integración:

npx sparda-mcp report --json

Prueba de Despliegue: Apocalipsis

El Grafo de Comportamiento de SPARDA es un modelo formal de tu sistema. En lugar de esperar fallos en tiempo de ejecución o depender de vibraciones de análisis estático, puedes probar estáticamente la seguridad de tu backend antes de cualquier despliegue:

npx sparda-mcp apocalypse

Este comando lee el .sparda/ubg.json compilado (con cero análisis de código fuente en tiempo de ejecución) y descarga cinco obligaciones de corrección estática:

• Mutación sin Guardia (Crítico): Marca cualquier ruta de mutación que no cruce una guard de seguridad.
• Escritura Agregada No Atómica (Alto): Marca cuando una API escribe en múltiples tablas del mismo Dominio de Consistencia (Agregado) fuera de un único ámbito de transacción.
• Escritura Restringida No Validada (Medio): Marca escrituras en columnas con invariantes declarados (CHECK, NOT NULL, UNIQUE — analizados desde tu DDL .sql o schema.prisma, incluidos los enums de Prisma) sin validación previa (Zod/Pydantic).
• Efecto Observable Irreversible (Alto): Marca acciones fuera de proceso (como cargos de Stripe) que ocurren junto con escrituras de estado sin una ruta de compensación estructural (como un catch-reembolso).
• Análisis de Flujo de Contaminación (Alto): Rastrea variables de entrada no confiables a través del AST para asegurar que no corrompan sumideros críticos.
• Dominancia de Guardias (Medio): Prueba que las guardias de seguridad de nivel superior no pueden ser eludidas por rutas hermanas anidadas o superpuestas.
• Bypass de Miembro de Agregado (Info): Marca la mutación directa de una tabla miembro sin pasar por la raíz del agregado.

Para guardar tu grafo actual como una línea base segura:

npx sparda-mcp apocalypse --save-baseline

Las ejecuciones posteriores compararán el grafo candidato contra esta línea base para detectar vectores de regresión:

• Eliminación de cualquier guard de seguridad (Crítico).
• Eliminación de un invariante SQL de base de datos (Alto).
• Expansión del radio de explosión de la API (Medio).

Si se encuentra algún hallazgo Crítico o Alto, apocalypse sale con un código no cero para bloquear tu pipeline de CI.

Un paso en tu flujo de trabajo — los hallazgos llegan a la pestaña de Seguridad de GitHub (SARIF):

- uses: zyx77550/sparda@main
  with:
    sarif: 'true'

Viaje en el Tiempo: Timeless

Cada solicitud de producción es determinista entre sus efectos — el compilador sabe exactamente dónde vive el no determinismo (db, http, reloj, aleatorio, uuid: los nodos de efecto del grafo). Timeless registra solo esos puntos (unos pocos KB por solicitud) y reproduce la solicitud byte a byte idéntica contra tu código actual, con la base de datos, los webhooks y el reloj virtualizados desde la grabación:

npx sparda-mcp timeless                # list recorded flights
npx sparda-mcp timeless replay <id>    # re-fly it — byte-identical or loud divergence
npx sparda-mcp timeless export <id>    # the production bug is now a vitest test

La grabación son dos líneas en tu aplicación (ESM), con muestreo determinista y redacción GDPR integrada:

import { getFlightBox } from 'sparda-mcp/src/flight/box.js';
const box = getFlightBox();
box.arm();
app.use(box.middleware({ sample: 100 })); // 1 request in 100; passwords/tokens redacted by default
const db = box.wrapClient(pgPool); // your query client, tapped

El bucle cerrado que nadie más tiene: error de producción → vuelo grabado → prueba fallida → la IA escribe la corrección → apocalypse prueba que la corrección no rompe ninguna guardia, invariante o transacción → despliega. La reproducción es por solicitud (la captura de carreras concurrentes está fuera del alcance de v1 — declarado, no oculto).

Autocuración, Probada: sparda heal

El bucle anterior, como un solo gesto — y la máquina juzga la corrección, quienquiera que la haya escrito:

npx sparda-mcp heal <flightId>                       # diagnose + write the fix brief
# ...apply the fix (a human, or --agent "your-ai-cli")...
npx sparda-mcp heal <flightId> --check --expect '{"status":404}'

El resumen se construye a partir del propio grafo — le entrega al corregidor el file:line del manejador, las capacidades que la corrección no debe aumentar y las guardias que no debe eliminar. Luego la puerta — el producto real — prueba la corrección en tres ejes a la vez:

1. Comportamiento — la reproducción permisiva del vuelo grabado (mismos insumos deterministas) ahora produce la respuesta esperada, no el error grabado. La corrección puede reformular una consulta (el toque se reetiqueta, permitido); no puede cambiar el orden o los tipos de efectos.
2. Leyes del compilador — verify sigue pasando: el grafo sigue siendo sólido y determinista.
3. Sin regresiones — apocalypse diff contra el grafo congelado previo a la corrección: cero hallazgos nuevos críticos/altos, ninguna guarda eliminada, ningún radio de explosión aumentado.

✓ HEALED & PROVEN — same recorded inputs, correct output, zero law broken, zero protection lost. Ship it.

La compuerta es honesta en ambas direcciones: un error sin corregir, o una "corrección" que silenciosamente elimina una guarda, la mantiene cerrada (salida 1). Esta es la diferencia entre una IA que escribe código plausible y un sistema que prueba que el código es correcto — la capa de confianza que le falta a la era de los agentes.

Cualquier Backend en la Tierra: Reducción OpenAPI

SPARDA analiza Express, FastAPI, Flask y Next.js de forma nativa — y cualquier otra pila mediante el formato que la industria ya acordó. Go, Java, Rails, Laravel, .NET: si tiene un spec OpenAPI, compila.

npx sparda-mcp ubg --openapi openapi.json

Los esquemas de seguridad se convierten en nodos de compuerta guard, los esquemas de respuesta se convierten en retornos tipados, los cuerpos de solicitud declarados cuentan como entrada validada. Combina el spec con tus archivos .sql o schema.prisma y la capa de estado completa — invariantes, agregados, máquinas de estado — se completa a partir de la verdad declarada. (Specs JSON en v1; nos negamos a analizar YAML a medias con cero dependencias.)

La VM Espejo: elimina el framework, la app aún responde

El grafo no es un diagrama — se ejecuta:

npx sparda-mcp mirror

MIRROR — the graph is serving. 3 entrypoint(s) on http://127.0.0.1:4477
  GET    /orders/{orderId}  → {amount, id, status}
  POST   /orders  🔒 bearerAuth  → {amount, id, status}

Sin Express. Sin FastAPI. Sin código fuente — solo ubg.json respondiendo HTTP: las guardas realmente deniegan (401), las respuestas renderizan los esquemas de retorno compilados, las rutas desconocidas devuelven 404 con la tabla de rutas completa. Los equipos de frontend desarrollan contra backends que aún no están desplegados — o que aún no están escritos (apunta mirror a un spec OpenAPI). Cada respuesta lleva x-sparda-mirror: true; el espejo sirve comportamiento declarado, nunca inventa valores de negocio.

Para deshacer todo: npx sparda-mcp remove restaura tu código byte por byte.

La promesa — cada palabra está respaldada por un test en CI

1. Tres minutos, un comando. Escaneo AST, generación de router, inyección reversible — sin configuración.
2. Pruébalo gratis, vete gratis. npx sparda-mcp remove restaura tu código byte por byte (probado en JS, TS, Python, incluso archivos CRLF de Windows). Sin rastro, sin bloqueo.
3. La IA no puede escribir hasta que tú lo digas. Cada POST/PUT/DELETE está deshabilitado por defecto; los habilitas por herramienta, y tu elección sobrevive a cada re-ejecución.
4. Tu app se defiende sola. Una ruta que falla 3 veces seguidas es puesta en cuarentena — la IA no puede martillar tu producción rota. Las anomalías de latencia se marcan. Cero LLM necesario.
5. Nada sale de tu máquina. Sin telemetría hacia nosotros, sin nube, autenticación local por clave, 4 dependencias exactamente fijadas.
6. Lo que aprende nunca se pierde. Diagnósticos, descripciones, configuraciones — versionados con tu git, sobreviviendo a cada re-inicialización.

Lo que no prometemos: los límites honestos en docs/SECURITY.md.

Cómo funciona

1. npx sparda-mcp init analiza tu código (AST), extrae cada ruta e inyecta un router marcado diminuto (/mcp) en tu app — totalmente reversible con npx sparda-mcp remove.
2. Las llamadas a herramientas se ejecutan dentro de tu proceso de app en vivo — pools de BD calientes, cadena de autenticación real, datos reales. SPARDA no añade infraestructura: el cómputo viene de tu proceso anfitrión, la inteligencia del modelo propio de tu cliente de IA (muestreo MCP), el almacenamiento de sparda.json + git.
3. Las herramientas de escritura (POST/PUT/DELETE) están deshabilitadas por defecto. Optas por cada herramienta en sparda.json — tus elecciones sobreviven a re-ejecuciones.
4. Los docstrings sospechosos se sanitizan antes de llegar a la IA (defensa contra inyección de prompts).
5. npx sparda-mcp doctor --app audita tu código en busca de desviaciones: detecta herramientas obsoletas (IA viendo fantasmas), rutas desincronizadas, desviación de esquemas mediante huellas digitales y configuraciones zombi. Los problemas de alta severidad activan un código de salida distinto de cero para tu pipeline de CI.
6. npx sparda-mcp seed export/import te permite empaquetar y compartir el "genoma" de tu app (memoria semántica, flujos de trabajo, anticuerpos) de forma segura, transfiriendo memoria inmune entre entornos o entre pilas similares con cero fuga de datos.
7. npx sparda-mcp twin inicia un servidor simulado seguro de tu backend en el puerto original. Sirve llamadas GET a partir de ejemplares aprendidos (formas de respuesta observadas y datos simulados) y devuelve escrituras 202 simuladas sin tocar jamás tu base de datos real o tus APIs de producción. Aprende ejemplares ejecutando npx sparda-mcp twin --learn.
8. npx sparda-mcp grammar mapea el grafo de secuencias válidas de llamadas a herramientas (circuitos observados e hipótesis candidatas) para prevenir la alucinación de rutas por parte del LLM.
9. npx sparda-mcp evolve muta cadenas candidatas y las prueba contra el gemelo en memoria, promoviendo cadenas exitosas a sugerencias de flujos de trabajo evolucionados.

Lo que SPARDA le da a tu IA

Operar, no solo leer

Cada ruta se convierte en una herramienta que se ejecuta contra tu proceso en vivo — autenticación real, datos reales, conexiones calientes. Una llamada a sparda_get_context le entrega a la IA toda la imagen viva: herramientas habilitadas, flujos de trabajo sugeridos, telemetría de ejecución, estado de cuarentena y memoria inmune — para que cada sesión se reanude donde terminó la anterior.

Prueba la edición antes de hacer commit — la única verificación que un LLM no puede hacerse a sí mismo

La IA acaba de editar una ruta. ¿Eliminó silenciosamente una guarda? Llama a sparda_prove y lo descubre ahora, no en una ejecución de CI posterior. La herramienta recompila la app a su grafo de comportamiento, descarga las mismas obligaciones estáticas que sparda apocalypse y devuelve un veredicto determinista — la palabra exacta que emiten el CLI y la insignia, para que nunca pueda sobre-afirmar (una app limpia con baja cobertura lee SURFACE, nunca un PROVEN desnudo). Guarda una línea base una vez (sparda apocalypse --save-baseline) y cada sparda_prove posterior marca cualquier hallazgo con regression: true — la guarda que tu edición eliminó, la ruta que descartó, el radio de explosión que aumentó. Eso es "La IA escribe. SPARDA prueba." dentro del bucle de edición. Los clientes que listan prompts MCP también reciben el flujo de trabajo prove-my-edit.

Seguridad de escritura: la IA no puede escribir hasta que tú lo digas

• Las escrituras (POST/PUT/DELETE) vienen deshabilitadas. Habilítalas por herramienta en sparda.json; tu elección sobrevive a cada re-inicialización.
• Una escritura habilitada nunca se ejecuta en la primera llamada. SPARDA devuelve un sobre awaiting_confirmation — un token de un solo uso más una vista previa de la acción — y hace commit solo después de un paso de confirmación explícito.
• Cuando tu cliente soporta elicitación MCP, ese prompt de confirmación aparece en la propia interfaz de la IA.
• Prueba-después-de-escribir: cada escritura exitosa va seguida de una relectura del mismo recurso, para que la IA — y tú — vean el efecto real, no una suposición esperanzada.

Tu app se defiende sola — cero LLM en la ruta crítica

• Cuarentena. Una herramienta que devuelve 3 errores 5xx consecutivos es puesta en cuarentena: las llamadas posteriores reciben un 503 con una razón y un retraso de reintento en lugar de martillar tu ruta rota. Después de un enfriamiento se abre a medias para una sola sonda.
• Marcas de latencia y anomalías. El router aprende la línea base de cada ruta y marca desviaciones localmente, en unas pocas líneas de matemáticas.
• Diagnóstico adaptativo, solo ante sorpresas. Una falla genuinamente nueva despierta el modelo propio de tu cliente de IA para diagnosticarla una vez; el diagnóstico se almacena en caché como un "anticuerpo" en sparda.json, de modo que la misma falla posterior cuesta cero tokens. Clonar tu código no clona su memoria inmune.

Una capa de inteligencia gratuita, cero clave API

En la primera conexión, el modelo propio de tu cliente de IA (mediante muestreo MCP) reescribe las rutas crudas en descripciones de herramientas en lenguaje de negocio y propone flujos de trabajo de varios pasos — almacenados en caché en sparda.json y expuestos como prompts MCP. Nada que configurar, nada que pagar.

Se vuelve más barato cuanto más lo usas

• Reciclaje de respuestas. Cuando una lectura sigue devolviendo la misma respuesta, SPARDA sirve la siguiente llamada idéntica directamente desde memoria — sin tocar tu app anfitriona. Solo lecturas; las escrituras siempre llegan al anfitrión.
• Un indicador de reciclaje. GET /mcp/stats cuenta cuántas llamadas fueron respondidas desde el conocimiento propio de SPARDA vs. cuántas pagaron la ruta del anfitrión. Lee 0% el primer día y se llena con el uso — una medida, nunca una promesa.

Herramientas que nadie escribió — Labs, opcional, OFF por defecto

Actívalo con "labs": { "recordSequences": true } en sparda.json. SPARDA entonces nota cuando la salida de una herramienta alimenta la entrada de la siguiente y registra el circuito — solo estructura (nombres de herramientas, nombres de argumentos, conteos), nunca tus datos. Un circuito de solo lectura visto suficientes veces se cristaliza en una herramienta compuesta, anunciada a mitad de sesión: una llamada ejecuta toda la cadena, alimentando automáticamente cada paso desde la respuesta real del paso anterior. Las rutas de escritura nunca se absorben — su confirmación por llamada siempre se mantiene.

Contexto vivo y telemetría

GET /mcp/stats (llamadas/errores por herramienta, "pureza" de la herramienta, estado de cuarentena) y GET /mcp/events (errores, anomalías de latencia, diagnósticos en caché) exponen exactamente lo que tu app está haciendo — presentado a la IA como notificaciones en vivo.

Construido para clientes de IA: la Skill incluida

SPARDA incluye una Agent Skill (SKILL.md) que enseña a cualquier cliente de IA compatible cómo manejar un servidor SPARDA a su máximo potencial — llama a sparda_get_context primero, explota el reciclaje de respuestas, respeta la cuarentena, prefiere circuitos cristalizados sobre re-recorrer una cadena y sigue el protocolo de dos fases escribir-confirmar. La lista de herramientas en vivo por proyecto siempre proviene de sparda_get_context en tiempo de ejecución, para que la guía nunca quede obsoleta.

Frameworks soportados

• Next.js App Router (13/14/15) — inyección basada en archivos. SPARDA crea un manejador de ruta catch-all. Resuelve nativamente manejadores envueltos (export const POST = withAuth(h)) y cadenas de efectos profundas.
• NestJS — inyección de router basada en AST. Resuelve profundamente la Inyección de Dependencias de múltiples saltos (Controller → Service → Repository), DI heredada e imports baseUrl/paths. Soporta completamente decoradores compuestos (applyDecorators). Resuelve escrituras ORM: repositorios inyectados de Prisma, Kysely y TypeORM (@InjectRepository(Entity) → this.repo.save()).
• Strapi — Ingestión AST nativa de content-types de Strapi, controladores centrales y rutas personalizadas.
• Express 4/5 (JS/TS, ESM/CJS) — inyección de router basada en AST. Resuelve profundamente controladores externos, esquemas Mongoose, re-exportaciones barrel y manejadores en línea. Usa escaneo dinámico de árbol para encontrar puntos de entrada no estándar (bootstrap.ts, etc.).
• MedusaJS — Ingestión AST nativa de enrutamiento de comercio electrónico complejo.
• Cualquier Backend en la Tierra (Go, Java, Rails, Laravel) — Compila perfectamente desde specs OpenAPI 3.x.
• FastAPI (Python >= 3.9) — inyección de router basada en AST.

Efectos que resuelve (lo que hace que las pruebas de irreversibilidad y atomicidad sean contundentes)

• Bases de datos — Prisma (incl. relaciones nombradas/multilínea e $transaction(tx ⇒ …) interactivo), TypeORM, Kysely, Drizzle, Knex, Sequelize, Mongoose y SQL crudo. Las claves foráneas se convierten en dominios de agregación/consistencia, de modo que una escritura multi-tabla fuera de una transacción se detecta.
• Efectos secundarios externos — reconocidos por la forma de la llamada y por el origen del import, de modo que un efecto saliente irreversible junto a una escritura de BD se prueba como compensable-o-no: fetch/axios/got, Stripe, Twilio, SendGrid/Resend/nodemailer, AWS SDK v3 (send(new PutObjectCommand())) y otros clientes de pago/correo/nube/cola. Una lectura en dicho cliente sigue siendo un GET no observable — sin falsas alarmas.

Postura de seguridad (honesta)

• 4 dependencias de ejecución, fijadas con precisión.
• Resolución dinámica de claves locales. El router generado no contiene secretos incrustados. Resuelve las claves de autorización en tiempo de ejecución desde la variable de entorno SPARDA_LOCAL_KEY o el archivo local ignorado por git .sparda/key, y falla de forma cerrada (503) cuando no se encuentra ninguna. Para configuraciones personalizadas de producción o staging, puedes anular este comportamiento exponiendo SPARDA_LOCAL_KEY en tu entorno.
• Clave local en cada llamada al router; protección contra bucles de autorreferencia; tiempos de espera de 30 s; truncamiento de salida de 8 KB.
• Inyección posicionada por AST con respaldo y reanálisis posterior a la inyección; npx sparda-mcp remove deja un diff de git limpio.
• La persistencia está libre de valores: SPARDA registra estructura (nombres de herramientas, nombres de campos, huellas digitales), nunca tus cargas útiles.

Modelo de amenazas completo y brechas conocidas: docs/SECURITY.md.

Documentación

• docs/ARCHITECTURE.md — cómo encajan init, el router inyectado y el puente, además del esquema sparda.json.
• docs/SECURITY.md — modelo de amenazas, defensas y brechas conocidas honestas.
• docs/TESTING.md — cómo se mantienen honestas las promesas anteriores en CI.
• docs/ERRORS.md — la base de conocimiento de errores.

Más allá del núcleo abierto

SPARDA es gratuito, incluso en producción (consulta la Licencia). Capacidades a nivel de equipo — políticas de acceso granular por persona y un registro de auditoría firmado y a prueba de manipulaciones — están planificadas para un futuro nivel de pago. El núcleo abierto se sostiene por sí solo; nada aquí está limitado para hacerte subir de plan.

Licencia

Business Source License 1.1 — uso gratuito, incluso en producción. No puedes revender SPARDA ni ofrecerlo como un servicio comercial competidor. Cada versión se convierte a Apache 2.0 cuatro años después de su publicación.

Por Residual Labs