Mirdan

KI-Code-Qualitäts-Orchestrator — spart 30-45 % Ihrer bezahlten KI-Programmier-Token, indem er eine lokale Intelligenzschicht ausführt, die Triage, Linting, Typenprüfung, Testausführung und Validierung übernimmt, damit sich teure Modelle wie Claude Opus auf das Schreiben von Code konzentrieren können.

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.

Funktioniert mit Claude Code, Cursor IDE und Cursor CLI. Läuft auf 16-GB-Laptops. Alles bleibt lokal.

Lokale Intelligenzschicht (Neu in 2.0)

Mirdan 2.0 lagert alltägliche Aufgaben an ein kleines lokales Modell (Gemma 4) aus, das auf Ihrem Rechner läuft. Das bezahlte Modell konzentriert sich ausschließlich auf komplexes Denken und das Schreiben von Code.

Bevor Sie programmieren:

• Triage — klassifiziert Aufgaben. Triviale Aufgaben (ein Import-Fix, eine Datei formatieren) erreichen das bezahlte Modell nie. Null Token verbraucht.

• Recherche — sammelt lokal Kontext zur Codebasis, Bibliotheksdokumentationen und Projektkonventionen (nur bei 64 GB+).

Nachdem Sie programmiert haben:

• Check Runner — führt ruff, mypy, pytest lokal aus. Das LLM analysiert die Ausgabe, behebt Lint-Fehler automatisch und meldet nur komplexe Fehler.

• Smarte Validierung — 64 Qualitätsregeln + LLM-Filterung von Fehlalarmen, Gruppierung nach Grundursache und Korrekturvorschläge.

• Auto-Fix — mirdan check --smart --fix wendet LLM-generierte Suchen/Ersetzen-Korrekturen mit Verifizierung an.

Schnelleinrichtung

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

Alles läuft lokal. Keine Remote-Server. Keine Daten verlassen Ihren Rechner.

Warum Mirdan?

KI-Programmierassistenten generieren Code schnell, aber ohne Leitplanken produzieren sie „Slop“: hartcodierte Geheimnisse, SQL-Injection, Platzhalterfunktionen, halluzinierte Importe, leere Except-Blöcke und Code, der zwar richtig aussieht, aber in der Produktion versagt.

Mirdan behebt dies, indem es Ihren KI-Workflow an zwei Punkten abfängt:

1. Vor dem Programmieren — enhance_prompt reichert Ihre Aufgabe mit Qualitätsanforderungen, Sicherheitsbeschränkungen und Framework-spezifischen Standards an, sodass die KI von Anfang an besseren Code produziert.

2. Nach dem Programmieren — validate_code_quality fängt das ab, was durchgerutscht ist: 64 Regeln, die Sicherheitslücken, KI-spezifische Anti-Patterns und Sprach-Best-Practices abdecken.

Nach der Installation läuft es unsichtbar durch IDE-Hooks. Sie programmieren einfach wie gewohnt.

Was es erkennt

Hier ist, was Mirdan bei einer einzelnen Funktion von typischem KI-generiertem Code markiert:

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

Ergebnis: Punktzahl 0,0/1,0, 6 Fehler, 3 Warnungen. Mit Auto-Fix behebt Mirdan 5 davon automatisch.

Was es Ihren Prompts hinzufügt

Wenn Sie einen KI-Assistenten bitten: „Erstelle einen Benutzer-Auth-Endpunkt in FastAPI mit JWT-Token“, erkennt Mirdans enhance_prompt, dass dies die Sicherheit betrifft, und fügt hinzu:

• Framework-Standards: „Verwende Depends() mit Annotated für typsichere Dependency Injection“

• Sicherheitsbeschränkungen: „Prüfe, dass keine Geheimnisse oder Anmeldedaten hartcodiert sind“

• Qualitätsanforderungen: „Verwende Pydantic-Modelle für alle Request-Bodys und Response-Schemas“

• Verifizierungsschritte: „Stelle sicher, dass die Fehlerbehandlung alle asynchronen Operationen abdeckt“

Die KI erhält strukturierte Anleitungen statt eines nackten Prompts und produziert so beim ersten Versuch besseren Code.

Schnellstart

Installation

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

IDE einrichten

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

Dies generiert alles — MCP-Server-Konfiguration, Qualitäts-Hooks, Regeldateien und Agentendefinitionen. Wenn das LLM aktiviert ist, konfigurieren die Hooks auch die lokale Triage und den Check Runner. Nach der Initialisierung erledigt Ihre IDE automatisch:

1. Anreicherung von Prompts mit Qualitätsanforderungen vor Programmieraufgaben

2. Validierung von Code gegen Sicherheits- und Qualitätsregeln nach jeder Bearbeitung

3. Durchführung eines abschließenden Qualitäts-Gates vor Abschluss der Aufgabe

Verwendung über die Befehlszeile

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

Funktionsweise

Mirdan ist ein MCP-Server — er verbindet sich mit KI-Programmierassistenten (Claude Code, Cursor, Claude Desktop oder jedem MCP-Client) und stellt Werkzeuge zur Qualitätssicherung bereit.

┌──────────────────────────────────────────────────┐
│  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         │
└──────────────────────────────────────────────────┘

Validierungsregeln

Mirdan wird mit 64 Regeln in 10 Kategorien ausgeliefert. Keine externen Dienste erforderlich — alle Regeln laufen lokal.

KI-Qualität (AI001–AI008)

Regeln, die Muster erkennen, die für KI-generierten Code einzigartig sind:

Sicherheit (SEC001–SEC014)

Sprachspezifisch

Plus ARCH001–003 / TSARCH001–004 (Funktionslänge, Dateilänge, Verschachtelungstiefe, fehlende Rückgabetypen), RAG001–002 (Chunk-Überlappung, veraltete Loader).

Python-Regeln PY001–PY004 verwenden AST-basierte Validierung — dies eliminiert Fehlalarme durch Strings und Kommentare. Wenn mirdan[ast] installiert ist, verwenden TypeScript/JavaScript-Architekturprüfungen tree-sitter für eine genaue Analyse von Funktionslänge, Verschachtelungstiefe und Rückgabetyp.

32 Regeln unterstützen automatische Korrekturen via mirdan fix.

Sprach- und Framework-Unterstützung

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

33 Framework-Standards — Mirdan kennt die Idiome, Best Practices und häufigen Fallstricke für jedes:

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

Wenn enhance_prompt ein Framework erkennt, fügt es Framework-spezifische Qualitätsanforderungen ein (z. B. „Verwende Depends() mit Annotated“ für FastAPI, „Bevorzuge Server-Komponenten“ für Next.js).

Qualitätsprofile

Profile stimmen die Durchsetzungsstufen über 8 Dimensionen ab. Wählen Sie eines, das zu Ihrem Projekt passt:

Skala: 0.0–0.3 permissiv | 0.3–0.7 moderat | 0.7–1.0 streng

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

IDE-Integration

Claude Code

mirdan init --claude-code

Generiert .mcp.json, Hooks, Regeln, 7 Skills (/code, /debug, /review, /plan, /quality, /scan, /gate) und 5 Agenten (quality-gate, security-audit, test-quality, convention-check, architecture-reviewer).

Die Strenge der Hooks steuert, wie aggressiv Mirdan eingreift:

Cursor

mirdan init --cursor

Generiert eine vollständige Cursor 2.x-Integration:

• Regeln — .cursor/rules/*.mdc (immer aktiv, Sicherheit, Planung, Debug, Agent, sprachspezifisch)

• Hooks — .cursor/hooks.json mit Prompt-Typ + Befehls-Typ-Hooks, .cursor/hooks/*.sh Skripte

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

• Skills — .cursor/skills/*/SKILL.md gemäß dem Agent Skills Standard (code, debug, review, plan, quality, scan, gate)

• Befehle — .cursor/commands/*.md Slash-Befehle (/code, /debug, /review, /plan, /quality, /scan, /gate)

• Umgebung — .cursor/environment.json für Cloud-Agent-Umgebungen

• Konfiguration — .cursor/mcp.json, AGENTS.md, BUGBOT.md

Cursor hat Limits für Tool-Slots. Setzen Sie MIRDAN_TOOL_BUDGET, um zu steuern, welche Tools verfügbar sind (2 = nur Validierung, 5+ = alle Tools).

Claude Desktop / Jeder MCP-Client

Fügen Sie dies zu Ihrer MCP-Konfiguration hinzu:

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

Unternehmensnetzwerke (Netskope, Zscaler, Artifactory-Proxy): Übergeben Sie Umgebungsvariablen für SSL und Modell-Downloads:

{
  "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"
      }
    }
  }
}

Unternehmensbereitstellung

Für organisationsweite Durchsetzung über verwaltete Konfiguration:

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

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

CI/CD-Integration

GitHub Actions

Fügen Sie diesen Workflow zu .github/workflows/mirdan.yml hinzu:

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

SARIF-Export für GitHub Code Scanning

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

Pre-commit Hook

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

Qualitäts-Badges

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

Konfiguration

mirdan init generiert .mirdan/config.yaml. Wichtige Abschnitte:

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

Die LLM-Konfiguration erfolgt in .mirdan.yaml (geschrieben von `