Mirdan

Orquestador de Calidad de Código por IA — ahorra entre un 30 y un 45% de tus tokens de codificación de IA de pago al ejecutar una capa de inteligencia local que se encarga del triaje, linting, comprobación de tipos, ejecución de pruebas y validación, para que modelos costosos como Claude Opus se centren en escribir código.

uv tool install mirdan                  # Install mirdan
mirdan llm setup                        # Auto-installs backend, downloads model, configures
mirdan init --claude-code               # or --cursor
# Done. Quality enforcement + local intelligence is now automatic.

Funciona con Claude Code, Cursor IDE y Cursor CLI. Se ejecuta en portátiles de 16GB. Todo permanece local.

Capa de Inteligencia Local (Nuevo en 2.0)

Mirdan 2.0 delega el trabajo rutinario a un pequeño modelo local (Gemma 4) que se ejecuta en tu máquina. El modelo de pago se centra exclusivamente en el razonamiento complejo y la escritura de código.

Antes de programar:

• Triaje — clasifica las tareas. Las tareas triviales (corregir una importación, formatear un archivo) nunca llegan al modelo de pago. Cero tokens gastados.

• Investigación — recopila contexto del código base, documentación de bibliotecas y convenciones del proyecto localmente (solo 64GB+).

Después de programar:

• Ejecutor de comprobaciones — ejecuta ruff, mypy, pytest localmente. El LLM analiza la salida, corrige automáticamente el lint y solo informa de fallos complejos.

• Validación inteligente — 64 reglas de calidad + filtrado de falsos positivos por LLM, agrupación de causas raíz y sugerencias de corrección.

• Corrección automática — mirdan check --smart --fix aplica correcciones de búsqueda/reemplazo generadas por el LLM con verificación.

Configuración rápida

mirdan llm setup              # Detects hardware, installs backend, downloads model, configures
mirdan init --claude-code     # or --cursor
mirdan llm status             # Verify it's working

Todo se ejecuta localmente. Sin servidores remotos. Ningún dato sale de tu máquina.

¿Por qué Mirdan?

Los asistentes de codificación de IA generan código rápidamente, pero sin barreras de seguridad producen basura: secretos codificados, inyección SQL, funciones de marcador de posición, importaciones alucinadas, bloques except vacíos y código que parece correcto pero falla en producción.

Mirdan soluciona esto interceptando tu flujo de trabajo de IA en dos puntos:

1. Antes de programar — enhance_prompt enriquece tu tarea con requisitos de calidad, restricciones de seguridad y estándares específicos del framework para que la IA produzca mejor código desde el principio.

2. Después de programar — validate_code_quality detecta lo que se escapó: 64 reglas que cubren vulnerabilidades de seguridad, antipatrones específicos de IA y mejores prácticas del lenguaje.

Una vez instalado, se ejecuta de forma invisible a través de hooks del IDE. Tú solo programas normalmente.

Lo que detecta

Esto es lo que mirdan marca en una sola función de código típico generado por IA:

API_KEY = "sk-proj-abc123456789"           # SEC001: hardcoded API key
def get_users(user_id):
    query = f"SELECT * FROM users WHERE id={user_id}"  # SEC005 + AI008: SQL injection
    result = eval(user_input)              # PY001: code injection via eval()
    data = requests.get(url, verify=False) # SEC007: SSL verification disabled
    try:
        process(data)
    except:                                # PY003: bare except
        pass

Resultado: Puntuación 0.0/1.0, 6 errores, 3 advertencias. Con la corrección automática, mirdan resuelve 5 de estos automáticamente.

Lo que añade a tus prompts

Cuando le pides a un asistente de IA que "Cree un endpoint de autenticación de usuario en FastAPI con tokens JWT", el enhance_prompt de mirdan detecta que esto toca la seguridad e inyecta:

• Estándares del framework: "Usa Depends() con Annotated para inyección de dependencias con seguridad de tipos"

• Restricciones de seguridad: "Comprueba que no haya secretos o credenciales codificados"

• Requisitos de calidad: "Usa modelos Pydantic para todos los cuerpos de solicitud y esquemas de respuesta"

• Pasos de verificación: "Asegúrate de que el manejo de errores cubra todas las operaciones asíncronas"

La IA recibe una guía estructurada en lugar de un prompt vacío, produciendo mejor código al primer intento.

Inicio rápido

Instalación

uv tool install mirdan                   # Install mirdan
mirdan llm setup                         # Auto-installs LLM backend + downloads model

# Optional extras:
uv tool install 'mirdan[ast]'            # + tree-sitter for TS/JS AST analysis
uv tool install 'mirdan[enterprise]'     # + truststore for corporate SSL inspection

# Upgrade:
uv tool upgrade mirdan

# Or with pip:
pip install mirdan

Configura tu IDE

mirdan init --claude-code    # Claude Code: hooks, rules, skills, agents
mirdan init --cursor         # Cursor: hooks, rules, AGENTS.md, BUGBOT.md
mirdan init --all            # Both IDEs

Esto genera todo: configuración del servidor MCP, hooks de calidad, archivos de reglas y definiciones de agentes. Cuando el LLM está habilitado, los hooks también configuran el triaje local y el ejecutor de comprobaciones. Después de la inicialización, tu IDE automáticamente:

1. Enriquece los prompts con requisitos de calidad antes de las tareas de codificación

2. Valida el código contra reglas de seguridad y calidad después de cada edición

3. Ejecuta una puerta de calidad final antes de completar la tarea

Uso desde la línea de comandos

mirdan validate --file src/auth.py     # Validate a file
mirdan validate --staged               # Validate git staged changes
mirdan fix --file src/auth.py          # Auto-fix violations (pattern-based)
mirdan check --smart                   # Run lint + typecheck + test with LLM analysis
mirdan check --smart --fix src/        # Run checks AND auto-fix with local LLM
mirdan gate                            # CI/CD quality gate (exit 0 or 1)
mirdan scan --dependencies             # Check deps for known CVEs
mirdan scan --directory src/           # Discover codebase conventions
mirdan llm setup                       # Configure local LLM
mirdan llm status                      # Show LLM health, model, hardware
mirdan llm metrics                     # Token savings dashboard

Cómo funciona

Mirdan es un servidor MCP — se conecta a asistentes de codificación de IA (Claude Code, Cursor, Claude Desktop o cualquier cliente MCP) y proporciona herramientas de cumplimiento de calidad.

┌──────────────────────────────────────────────────┐
│  Your AI Assistant (Claude Code / Cursor / etc)  │
│                                                  │
│  1. You type a coding task                       │
│  2. Hook triages task via local LLM ────┐        │
│  3. AI generates code with guidance     │        │
│  4. Hook runs lint/typecheck/test ◄─────┘        │
│  5. AI fixes only complex issues                 │
│  6. Quality gate passes → task complete          │
└──────────────────────────────────────────────────┘
         │                        ▲
         ▼                        │
┌──────────────────────────────────────────────────┐
│  Mirdan MCP Server + Local Intelligence Layer    │
│                                                  │
│  MCP Tools (unchanged):                          │
│  enhance_prompt         → Quality requirements   │
│  validate_code_quality  → 64 rules + LLM enrich │
│  validate_quick         → Fast security checks   │
│  get_quality_standards  → Language/framework ref  │
│  get_quality_trends     → Historical analysis    │
│  scan_dependencies      → CVE detection (OSV)    │
│  scan_conventions       → Convention discovery   │
│                                                  │
│  Local LLM (Gemma 4, runs on your machine):      │
│  Triage          → Classify tasks, save tokens   │
│  Check Runner    → Run ruff/mypy/pytest locally  │
│  Smart Validator → FP filtering, root causes     │
│  Auto-Fix        → Search/replace code fixes     │
│  HTTP Sidecar    → <5ms hook integration         │
└──────────────────────────────────────────────────┘

Reglas de validación

Mirdan viene con 64 reglas en 10 categorías. No se requieren servicios externos: todas las reglas se ejecutan localmente.

Calidad de IA (AI001–AI008)

Reglas que detectan patrones únicos en código generado por IA:

Seguridad (SEC001–SEC014)

Específicas del lenguaje

Además de ARCH001–003 / TSARCH001–004 (longitud de función, longitud de archivo, profundidad de anidamiento, tipos de retorno faltantes), RAG001–002 (superposición de fragmentos, cargadores obsoletos).

Las reglas de Python PY001–PY004 utilizan validación basada en AST, eliminando falsos positivos de cadenas y comentarios. Cuando se instala mirdan[ast], las comprobaciones de arquitectura de TypeScript/JavaScript utilizan tree-sitter para un análisis preciso de la longitud de la función, la profundidad de anidamiento y el tipo de retorno.

32 reglas admiten correcciones automáticas mediante mirdan fix.

Soporte de lenguajes y frameworks

Lenguajes: Python, TypeScript, JavaScript, Go, Java, Rust

33 estándares de framework — mirdan conoce los modismos, mejores prácticas y trampas comunes para cada uno:

React, React Native, Next.js, Nuxt, Vue, SvelteKit, Astro, Flutter, Tailwind, FastAPI, Django, Express, NestJS, Echo, Gin, Spring Boot, Micronaut, Quarkus, Drizzle, Neo4j, Supabase, Convex, Pinecone, Qdrant, Milvus, Weaviate, ChromaDB, FAISS, LangChain, LangGraph, CrewAI, DSPy, tRPC

Cuando enhance_prompt detecta un framework, inyecta requisitos de calidad específicos del framework (p. ej., "Usa Depends() con Annotated" para FastAPI, "Prefiere componentes de servidor" para Next.js).

Perfiles de calidad

Los perfiles ajustan los niveles de cumplimiento en 8 dimensiones. Elige uno que coincida con tu proyecto:

Escala: 0.0–0.3 permisivo | 0.3–0.7 moderado | 0.7–1.0 estricto

mirdan init --quality-profile enterprise
mirdan profile apply fintech          # Change later
mirdan profile suggest                # Let mirdan recommend one

Integración con IDE

Claude Code

mirdan init --claude-code

Genera .mcp.json, hooks, reglas, 7 habilidades (/code, /debug, /review, /plan, /quality, /scan, /gate) y 5 agentes (quality-gate, security-audit, test-quality, convention-check, architecture-reviewer).

Los niveles de rigor de los hooks controlan qué tan agresivamente interviene mirdan:

Cursor

mirdan init --cursor

Genera una integración completa de Cursor 2.x:

• Reglas — .cursor/rules/*.mdc (siempre activas, seguridad, planificación, depuración, agente, específicas del lenguaje)

• Hooks — .cursor/hooks.json con hooks de tipo prompt + tipo comando, scripts .cursor/hooks/*.sh

• Subagentes — .cursor/agents/*.md (quality-validator, security-scanner, test-auditor, slop-detector, architecture-reviewer)

• Habilidades — .cursor/skills/*/SKILL.md siguiendo el Estándar de Habilidades de Agente (code, debug, review, plan, quality, scan, gate)

• Comandos — .cursor/commands/*.md comandos slash (/code, /debug, /review, /plan, /quality, /scan, /gate)

• Entorno — .cursor/environment.json para entornos de Cloud Agent

• Configuración — .cursor/mcp.json, AGENTS.md, BUGBOT.md

Cursor tiene límites de ranuras de herramientas. Establece MIRDAN_TOOL_BUDGET para controlar qué herramientas se exponen (2 = solo validación, 5+ = todas las herramientas).

Claude Desktop / Cualquier cliente MCP

Añade a tu configuración MCP:

{
  "mcpServers": {
    "mirdan": {
      "command": "uvx",
      "args": ["mirdan"]
    }
  }
}

Redes corporativas (Netskope, Zscaler, proxy de Artifactory): pasa variables de entorno para SSL y descargas de modelos:

{
  "mcpServers": {
    "mirdan": {
      "command": "uvx",
      "args": ["mirdan"],
      "env": {
        "MIRDAN_HF_ENDPOINT": "https://artifactory.corp.com/hf",
        "MIRDAN_HF_TOKEN": "your-artifactory-token",
        "MIRDAN_SSL_CERT_FILE": "/path/to/corporate-ca-bundle.crt"
      }
    }
  }
}

Despliegue empresarial

Para el cumplimiento en toda la organización mediante configuración gestionada:

macOS: /Library/Application Support/ClaudeCode/managed-mcp.json Linux: /etc/claude-code/managed-mcp.json

{
  "mcpServers": {
    "mirdan": {
      "command": "uvx",
      "args": ["mirdan"]
    }
  }
}

Integración CI/CD

GitHub Actions

Añade este flujo de trabajo a .github/workflows/mirdan.yml:

name: Mirdan Quality Gate
on: [pull_request]

jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: astral-sh/setup-uv@v4
      - run: uv tool install mirdan
      - run: mirdan gate

Exportación SARIF para escaneo de código de GitHub

- run: mirdan export --format sarif > results.sarif
- uses: github/codeql-action/upload-sarif@v3
  with:
    sarif_file: results.sarif

Hook de Pre-commit

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: mirdan
        name: mirdan quality gate
        entry: mirdan validate --staged --quick
        language: system
        types: [python]

Insignias de calidad

mirdan export --format badge > .mirdan/badge.json

Configuración

mirdan init genera .mirdan/config.yaml. Secciones clave:

version: "1.0"

project:
  name: "MyApp"
  primary_language: "python"
  frameworks: ["fastapi", "react"]

# Quality enforcement levels
quality:
  security: "strict"           # strict|moderate|permissive
  architecture: "moderate"
  documentation: "moderate"
  testing: "strict"

# Or use a named profile (overrides quality section)
quality_profile: "default"

# Semantic validation and dependency scanning
semantic:
  enabled: true
  analysis_protocol: "security"  # none|security|comprehensive

dependencies:
  enabled: true
  osv_cache_ttl: 86400           # 24 hours
  scan_on_gate: true
  fail_on_severity: "high"       # critical|high|medium|low|none

# Score thresholds
thresholds:
  severity_error_weight: 0.25
  severity_warning_weight: 0.08
  arch_max_function_length: 30
  arch_max_file_length: 300
  # Per-file threshold overrides (glob patterns)
  file_overrides:
    - pattern: "tests/**"
      arch_max_function_length: 60
    - pattern: "scripts/**"
      arch_max_file_length: 500

# Hook behavior
hooks:
  enabled_events: ["PreToolUse", "PostToolUse", "Stop"]
  quick_validate_timeout: 5000
  auto_fix_suggestions: true

La configuración del LLM va en .mirdan.yaml (escrito por mirdan llm setup):

llm:
  enabled: true
  backend: llamacpp                # llamacpp (default) or ollama
  model_keep_alive: 5m             # Unload model after idle (saves RAM)

Consulta la referencia completa de configuración de LLM o ejecuta mirdan llm setup para configurar automáticamente.

Funciones avanzadas

Validación basada en AST

Las reglas de Python PY001–PY004 se verifican mediante el módulo ast, eliminando falsos positivos de eval