Wenn du `skillspector mcp` ausführen möchtest, installiere das MCP-Extra bei der Installation:```bash
uv tool install 'skillspector[mcp] @ git+https://github.com/NVIDIA/skillspector.git'

### Docker (kein Python erforderlich)

Führen Sie SkillSpector aus, ohne Python zu installieren, indem Sie es lokal aus dem enthaltenen [Dockerfile](https://github.com/nvidia/skillspector/blob/main/Dockerfile) erstellen. Das Image basiert auf dem offiziellen Docker-Python-Image `3.12-slim-bookworm`.

**Image erstellen:**```bash
make docker-build
# or: docker build -t skillspector .

**Scan mit LLM-Analyse** durch Übergabe von Anmeldedaten mit einer lokalen `.env`-Datei:```bash
cat > .env <<'EOF'
SKILLSPECTOR_PROVIDER=anthropic
ANTHROPIC_API_KEY=sk-ant-...
EOF

Oder übergebe die Anmeldedaten direkt aus deiner Shell-Umgebung:```bash
docker run --rm \
  -v "$PWD:/scan" \
  -e SKILLSPECTOR_PROVIDER=anthropic \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  skillspector scan ./my-skill/

**Optionaler Alias** für wiederholte statische Scans:```bash
alias skillspector-docker='docker run --rm -v "$PWD:/scan" skillspector'
skillspector-docker scan ./my-skill/ --no-llm

#### Größenlimits

SkillSpector erzwingt zwei unabhängige Obergrenzen für Remote- und Archiv-Eingaben, um die Auswirkungen übermäßig großer Downloads und Zip-Bomben zu begrenzen:

- **Pro-Ingest-Obergrenze**: `INGEST_MAX_BYTES` (100 MiB) — angewendet auf gestreamte URL-Downloads, die gesamte unkomprimierte Größe von Zip-Archiven und die Festplattennutzung nach dem Klonen von Git-Repos.
- **Zip-Element-Obergrenze**: `INGEST_MAX_ZIP_MEMBERS` (10.000) — begrenzt die Anzahl der Einträge in einer einzelnen Zip-Datei.

Beachten Sie, dass die Analyse-Obergrenze von 1 MB pro Datei (`MAX_FILE_BYTES`) eine separate, nachgelagerte Grenze ist: Sie begrenzt, was einzelne Analyzer aus einem bereits ingestierten Verzeichnis auslesen. Die oben genannten Ingest-Obergrenzen begrenzen, wie viel Inhalt überhaupt auf der Festplatte landen kann. Eine Verletzung einer der Ingest-Obergrenzen schlägt mit einem `IngestLimitExceededError` fehl (Fail-Closed-Prinzip).

### Ausgabeformate```bash
# Terminal output (default) - pretty formatted
skillspector scan ./my-skill/

# JSON output - machine readable
skillspector scan ./my-skill/ --format json --output report.json

# Markdown output - for documentation
skillspector scan ./my-skill/ --format markdown --output report.md

# SARIF output - for CI/CD integration and IDE tooling
skillspector scan ./my-skill/ --format sarif --output report.sarif

Unterstützt mehrsprachige Erkennung (zh/ja/ko) sowie Terminal-/JSON-/Markdown-Ausgabe.

Für LLM-Scans mit höherer Parallelität konfigurieren Sie mehrere API-Schlüssel gemäß
[`.env.example`](https://github.com/nvidia/skillspector/blob/main/contrib/batch_scan/.env.example) — der Pool verbessert Durchsatz
und Ausfallsicherheit, sofern die Schlüssel kein Konto-weites Rate-Limit teilen.

Siehe den [Contrib-Guide](https://github.com/nvidia/skillspector/blob/main/contrib/batch_scan/docs) für Details.

> **Hinweis zur LLM-Unterstützung:** Die Standardkonfiguration zielt auf DeepSeek als
> günstigste öffentliche Option ab. DeepSeek-Chat wird
> [voraussichtlich eingestellt](https://api-docs.deepseek.com/), und der Beitragende
> hat keine Hardware, um gegen lokale Modelle zu testen. Der Batch-Scanner wurde
> ursprünglich mit OpenAI-kompatiblen Endpunkten getestet — DeepSeeks fehlende
> Unterstützung für strukturierte Ausgaben erforderte manuelle JSON-Parsing-Patches.
> Wenn Sie ein universelleres Backend beitragen können (Ollama, vLLM oder einen
> anderen Anbieter), sind PRs sehr willkommen.

### Unterdrücken falsch positiver Ergebnisse (Baseline)

Unterdrücken Sie bekannte/akzeptierte Befunde, sodass der Risikoscore nur nicht
bearbeitete Probleme widerspiegelt und erneute Scans nur *neue* Befunde anzeigen.
Siehe den [Suppressions-Guide](https://github.com/nvidia/skillspector/blob/main/docs/SUPPRESSION.md) für die vollständige Referenz.```bash
# Accept all current findings into a baseline (run once), then commit it.
skillspector baseline ./my-skill/ -o .skillspector-baseline.yaml

# Scan against the baseline — only NEW findings are reported and scored.
skillspector scan ./my-skill/ --baseline .skillspector-baseline.yaml

# Review what was suppressed (still excluded from the score).
skillspector scan ./my-skill/ --baseline .skillspector-baseline.yaml --show-suppressed

### MCP-Server

Führen Sie SkillSpector als [Model Context Protocol](https://modelcontextprotocol.io)-Server aus, damit jeder MCP-fähige Agent (Claude Code, Codex CLI, Gemini CLI) oder eine entfernte Laufzeitumgebung das Scannen als Werkzeug aufrufen und **Skill-/MCP-Installationen anhand des Ergebnisses freigeben oder blockieren kann** – das macht SkillSpector zu einer Laufzeit-Schutzmaßnahme statt zu einem separaten Audit-Schritt.

`skillspector mcp` erfordert `skillspector[mcp]`.```bash
# Install, or reinstall if you already used the CLI-only path
uv tool install --force 'skillspector[mcp] @ git+https://github.com/NVIDIA/skillspector.git'

# FastMCP stdio transport for local CLI agents
skillspector mcp

# streamable HTTP/SSE transport for remote / A2A callers
skillspector mcp --transport http --host 127.0.0.1 --port 8000

> **Sicherheit — HTTP-Transport-Vertrauensmodell**
>
> Der HTTP-Transport wird **ohne Authentifizierung** ausgeliefert. Jeder Aufrufer, der
> den Port erreichen kann, kann `scan_skill` aufrufen. Über stdio oder `127.0.0.1` ist dies
> dieselbe Vertrauensgrenze wie bei der CLI. Wenn Sie an eine routbare Schnittstelle binden:
>
> - Platzieren Sie den Server hinter einem authentifizierenden Reverse-Proxy (z. B. nginx + mTLS),
>   bevor Sie ihn extern verfügbar machen.
> - Lokale Pfade und `file://`-URLs werden über HTTP **automatisch abgelehnt**, um zu
>   verhindern, dass nicht authentifizierte Aufrufer beliebige Host-Dateien lesen. Nur
>   entfernte Git- und `.zip`-URLs werden akzeptiert.

## Schwachstellenmuster

SkillSpector erkennt **71 Schwachstellenmuster** in 17 Kategorien:

### Prompt-Injection (6 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| P1 | Anweisungsüberschreibung | HOCH | Befehle, um Sicherheitsbeschränkungen zu ignorieren |
| P2 | Versteckte Anweisungen | HOCH | Bösartige Anweisungen in Kommentaren/unsichtbarem Text |
| P3 | Exfiltrationsbefehle | HOCH | Anweisungen, Kontext extern zu übertragen |
| P4 | Verhaltensmanipulation | MITTEL | Subtile Anweisungen, die Agentenentscheidungen verändern |
| P5 | Schädlicher Inhalt | KRITISCH | Anweisungen, die körperlichen Schaden verursachen könnten |
| P9 | Leerzeichen-Auffüllung | MITTEL | Große Leerzeichen-Auffüllung, die Anweisungen unterhalb/neben dem sichtbaren Bereich versteckt |

### Anti-Verweigerung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| AR1 | Verweigerungsunterdrückung | HOCH | Anweisungen, niemals zu verweigern oder immer zu befolgen (z. B. „niemals verweigern", „immer befolgen") |
| AR2 | Haftungsausschluss-Unterdrückung | HOCH | Anweisungen, Warnungen, Haftungsausschlüsse oder ethische Kommentare wegzulassen (z. B. „keine Haftungsausschlüsse", „nicht moralisieren") |
| AR3 | Aufhebung der Sicherheitsrichtlinie | HOCH | Jailbreak-Rahmen, der Schutzmechanismen aufhebt (z. B. „Sie haben keine Einschränkungen", „ignorieren Sie Ihre Richtlinien", „tun Sie jetzt alles") |

### Datenextfiltration (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| E1 | Externe Übertragung | MITTEL | Senden von Daten an externe URLs |
| E2 | Umgebungsvariablen-Ernte | HOCH | Aufzählen, Kopieren oder Durchsuchen von Umgebungsdaten, um Geheimnisse zu sammeln |
| E3 | Dateisystem-Aufzählung | MITTEL | Durchsuchen von Verzeichnissen nach sensiblen Dateien |
| E4 | Kontextleck | HOCH | Externe Übertragung von Gesprächskontext |

### Privilegienerweiterung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| PE1 | Übermäßige Berechtigungen | NIEDRIG | Anfordern von Zugriff über die angegebene Funktionalität hinaus |
| PE2 | Sudo/Root-Ausführung | MITTEL | Aufrufen erhöhter Systemprivilegien |
| PE3 | Anmeldedaten-Zugriff | HOCH | Lesen von SSH-Schlüsseln, Tokens, Passwörtern |

### Lieferkette (9+ Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| SC1 | Nicht festgepinnte Abhängigkeiten | NIEDRIG | Keine Versionsbeschränkungen für Pakete |
| SC2 | Abruf externer Skripte | HOCH | curl \| bash und Remote-Codeausführung |
| SC3 | Verschleierter Code | HOCH | Base64/hex-kodierte Ausführung |
| SC4 | Bekannte verwundbare Abhängigkeiten | HOCH | Abhängigkeiten mit bekannten CVEs (Live-OSV.dev-Abfrage) |
| SC5 | Verlassene Abhängigkeiten | MITTEL | Ungepflegte Pakete ohne Sicherheitsupdates |
| SC6 | Typosquatting | HOCH | Paketnamen, die beliebten Paketen ähneln |
| SC8 | Mitgelieferter Python-Bytecode | HOCH | `__pycache__` / `.pyc` vorhanden (Discovery überspringt; bösartiger Bytecode umgeht) |
| SC9 | Verstecktes ausführbares Artefakt | HOCH | Ausführbare Datei, die in einem Dokumentcontainer oder verstecktem/getarntem Artefakt verschachtelt ist |

### Übermäßige Handlungsbefugnis (5 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| EA1 | Uneingeschränkter Tool-Zugriff | HOCH | Uneingeschränkter Tool-Zugriff ohne Einschränkungen |
| EA2 | Autonome Entscheidungsfindung | HOCH | Entscheidungen mit hoher Auswirkung ohne menschliche Kontrolle |
| EA3 | Scope-Ausweitung | MITTEL | Fähigkeiten, die über den angegebenen Zweck hinausgehen |
| EA4 | Unbegrenzter Ressourcenzugriff | MITTEL | Keine Ratenbegrenzungen oder Kontingente für den Ressourcenverbrauch |
| EA5 | Auswahl externer Modelle oder Anbieter | MITTEL/HOCH | Modell-/Anbieter-Pins oder Coding-CLI-Shell-Aufrufe, die Abrechnungskonten wechseln können |

### Ausgabebehandlung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| OH1 | Unvalidierte Ausgabe-Injektion | HOCH | Modellausgabe ohne Bereinigung verwendet |
| OH2 | Kontextübergreifende Ausgabe | MITTEL | Ausgabe fließt ohne Validierung über Vertrauensgrenzen |
| OH3 | Unbegrenzte Ausgabe | MITTEL | Keine Begrenzungen für Ausgabegröße oder Generierungsrate |

### System-Prompt-Leckage (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| P6 | Direktes Leck | HOCH | Anweisungen, die System-Prompts oder interne Regeln offenlegen |
| P7 | Indirekte Extraktion | MITTEL | Extraktion durch Umformulierung, Übersetzung oder Seitenkanäle |
| P8 | Tool-basierte Exfiltration | HOCH | System-Prompts, die über Dateischreibvorgänge oder Netzwerkanfragen exfiltriert werden |

### Speichervergiftung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| MP1 | Persistente Kontext-Injektion | HOCH | Inhalte, die darauf ausgelegt sind, über Interaktionen hinweg zu bestehen |
| MP2 | Kontextfenster-Auffüllung | MITTEL | Füllinhalte, die Sicherheitsbeschränkungen verdrängen |
| MP3 | Speichermanipulation | HOCH | Manipulation des Agentenspeichers oder gespeicherter Zustände |

### Tool-Missbrauch (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TM1 | Tool-Parameter-Missbrauch | HOCH | Präparierte Parameter für unbeabsichtigtes Verhalten (shell=True, --force) |
| TM2 | Verkettungs-Missbrauch | HOCH | Tool-Ketten, die einzelne Sicherheitsprüfungen umgehen |
| TM3 | Unsichere Standardwerte | MITTEL | Übermäßig freizügige Standardwerte (deaktiviertes TLS, keine Authentifizierung) |

### Schurken-Agent (2 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| RA1 | Selbstmodifikation | KRITISCH | Ändern des eigenen Codes oder der Konfiguration zur Laufzeit |
| RA2 | Sitzungspersistenz | HOCH | Unbefugte Persistenz über Cron-Jobs oder Startskripte |

### Trigger-Missbrauch (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TR1 | Übermäßig breiter Trigger | MITTEL | Triggermuster, die auf gebräuchliche Wörter passen |
| TR2 | Schattenbefehls-Trigger | HOCH | Trigger, die eingebaute Befehle oder andere Skills überschatten |
| TR3 | Keyword-Köder-Trigger | MITTEL | Generische Trigger, die darauf ausgelegt sind, die Aktivierung zu maximieren |

### Verhaltens-AST (9 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| AST1 | exec()-Aufruf | KRITISCH | Direkter exec(), der beliebige Codeausführung ermöglicht |
| AST2 | eval()-Aufruf | HOCH | Direktes eval(), das beliebige Ausdrücke auswertet |
| AST3 | Dynamischer Import | HOCH | \_\_import\_\_(), das zur Laufzeit beliebige Module lädt |
| AST4 | subprocess-Aufruf | HOCH | Externe Befehlsausführung über subprocess |
| AST5 | os.system / exec-Familie | HOCH | Shell-Befehle über das os-Modul |
| AST6 | compile()-Aufruf | MITTEL | Erstellung von Codeobjekten aus Zeichenfolgen |
| AST7 | Dynamisches getattr() | MITTEL | Beliebiger Attributzugriff mit nicht-literalen Namen |
| AST8 | Gefährliche Ausführungskette | KRITISCH | exec/eval kombiniert mit dynamischer Quelle (Netzwerk, kodierte Daten) |
| AST9 | Reflektiver getattr()-Sink | HOCH | Reflektives exec über `getattr(os,'system')` / `getattr(builtins,'exec')`, das AST1/AST5 umgeht |

### Taint-Tracking (5 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TT1 | Direkter Taint-Fluss | HOCH | Daten fließen direkt von einer Quelle zu einer Senke ohne Bereinigung |
| TT2 | Variablenvermittelter Taint-Fluss | MITTEL | Daten fließen über Zwischenvariablen von der Quelle zur Senke |
| TT3 | Anmeldedaten-Exfiltrationskette | KRITISCH | Anmeldedaten (Umgebungsvariablen, Geheimnisse) fließen zu Netzwerk-Ausgabesenken |
| TT4 | Dateilesen zu Netzwerk-Exfiltration | HOCH | Dateiinhalte fließen zu Netzwerk-Ausgabesenken |
| TT5 | Externe Eingabe zu Codeausführung | KRITISCH | Netzwerk- oder Benutzereingaben fließen zu exec/eval/subprocess-Senken |

### YARA-Signaturen (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| YR1 | Malware-Übereinstimmung | KRITISCH | YARA-Regelübereinstimmung für bekannte Malware-Signaturen |
| YR2 | Webshell-Übereinstimmung | KRITISCH | YARA-Regelübereinstimmung für Webshell-Muster |
| YR3 | Cryptominer-Übereinstimmung | HOCH | YARA-Regelübereinstimmung für Krypto-Mining-Indikatoren |
| YR4 | Hack-Tool-/Exploit-Übereinstimmung | HOCH | YARA-Regelübereinstimmung für Hack-Tools oder Exploit-Code |

### MCP Least Privilege (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| LP1 | Nicht deklarierte Fähigkeit | HOCH | Code verwendet Fähigkeiten, die nicht in den deklarierten Berechtigungen aufgeführt sind |
| LP2 | Wildcard-Berechtigung | MITTEL | Berechtigungsliste enthält Wildcards (\*, all, full, any) |
| LP3 | Fehlende Berechtigungsdeklaration | MITTEL | Kein Berechtigungsfeld, aber Code hat erkennbare Fähigkeiten |
| LP4 | Überdeklarierte Berechtigung | NIEDRIG | Berechtigung deklariert, aber keine entsprechende Codefähigkeit gefunden |

### MCP-Tool-Vergiftung (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TP1 | Versteckte Anweisungen | HOCH | Versteckte Anweisungen in Metadaten (HTML-Kommentare, Nullbreitenzeichen, Base64, Daten-URIs) |
| TP2 | Unicode-Täuschung | HOCH | Homoglyphen, RTL-Overrides, gemischtsprachige Bezeichner in Tool-Metadaten |
| TP3 | Parameterbeschreibungs-Injektion | MITTEL | Injektionsmuster in Parameterdefinitionen (Overrides, System-Tokens, bösartige Standardwerte) |
| TP4 | Beschreibungs-Verhaltens-Diskrepanz | MITTEL | Deklarierte Tool-Beschreibung entspricht nicht dem tatsächlichen Codeverhalten (LLM-gestützt) |

Alle erkannten Muster sind in den obigen Tabellen aufgeführt.

## Risikobewertung

### Bewertungsberechnung

- **KRITISCHE Probleme**: +50 Punkte
- **HOHE Probleme**: +25 Punkte
- **MITTEL Probleme**: +10 Punkte
- **NIEDRIGE Probleme**: +5 Punkte
- **Ausführbare Skripte**: 1,3-facher Multiplikator

### Schweregradstufen

| Punktzahl | Schweregrad | Empfehlung |
|-------|----------|----------------|
| 0-20 | NIEDRIG | SICHER |
| 21-50 | MITTEL | VORSICHT |
| 51-80 | HOCH | NICHT INSTALLIEREN |
| 81-100 | KRITISCH | NICHT INSTALLIEREN |

## Beispielausgabe

### Terminalausgabe```
 SkillSpector Security Report  v2.0.0

Skill: suspicious-skill
Source: ./suspicious-skill/
Scanned: 2026-01-29 10:30:00 UTC

        Risk Assessment
 Metric          Value
 Score           78/100
 Severity        HIGH
 Recommendation  DO NOT INSTALL

        Components (3)
 File              Type      Lines  Executable
 SKILL.md          markdown    142  No
 scripts/sync.py   python       87  Yes
 requirements.txt  text          3  No

Issues (2)

  HIGH: Env Variable Harvesting (E2)
    Location: scripts/sync.py:23
    Finding: for key, val in os.environ.items():...
    Confidence: 94%
    Explanation: This code collects environment variables containing
    API keys and secrets, then sends them to an external server.

  HIGH: External Transmission (E1)
    Location: scripts/sync.py:45
    Finding: requests.post("https://api.skill.io/env"...
    Confidence: 89%
    Explanation: Data is being sent to an external server. Combined
    with env harvesting above, this indicates credential exfiltration.

## Integration von SkillSpector

SkillSpector ist darauf ausgelegt, von anderen Tools gesteuert zu werden (CI-Pipelines, Installations-Gates, Editor-Integrationen). Sein Exit-Code und die JSON-Ausgabe sind ein stabiler Vertrag.

### Exit-Codes

`skillspector scan` endet mit:

| Code | Bedeutung |
|------|-----------|
| `0` | Scan abgeschlossen, `risk_score` ≤ 50 (Empfehlung `SAFE` oder `CAUTION`) |
| `1` | Scan abgeschlossen, `risk_score` > 50 (Empfehlung `DO_NOT_INSTALL`) |
| `2` | Fehler (ungültige Eingabe, nicht lesbare Quelle, interner Fehler) |

> Der Exit-Code fasst `SAFE` und `CAUTION` zu `0` zusammen. Um unterschiedlich darauf zu reagieren (z. B. *warnen* bei `CAUTION`, aber *blockieren* bei `DO_NOT_INSTALL`), lesen Sie das Feld `recommendation` aus der JSON-Ausgabe, anstatt sich auf den Exit-Code zu verlassen.

### Maschinenlesbare Ausgabe

`--format json` erzeugt einen JSON-Bericht; ohne `--output`/`-o` wird er auf stdout geschrieben:```bash
skillspector scan ./my-skill/ --format json

- `risk_assessment.severity` ∈ `LOW | MEDIUM | HIGH | CRITICAL`.
- `risk_assessment.recommendation` ∈ `SAFE | CAUTION | DO_NOT_INSTALL`, abgeleitet aus der Schwere: `LOW → SAFE`, `MEDIUM → CAUTION`, `HIGH`/`CRITICAL → DO_NOT_INSTALL`.
- `metadata.llm_error` erscheint nur, wenn eine LLM-Analyse angefordert, aber nicht verfügbar war.
- `metadata.inference_usage` enthält einen bereinigten Datensatz pro LLM-Antwort, wenn der
  Anbieter Token-Zähler offenlegt. Es ist eine leere Liste, wenn die Nutzung nicht verfügbar ist;
  SkillSpector schätzt fehlende Token niemals. Die Prompt-Summen umfassen Cache-Lese-
  und -Schreibvorgänge, sodass die nachgelagerte Preisberechnung diese Partitionen sicher trennen kann.
  `model_source` unterscheidet ein unabhängig identifiziertes Anbietermodell von
  dem exakt angeforderten Modell, das verwendet wird, wenn die Antwortidentität fehlt oder mehrdeutig ist.
  SkillSpector sendet derzeit keine Anthropic-Prompt-Cache-Steuerungen, daher können
  seine Scan-Anfragen die separaten 5-Minuten- oder 1-Stunden-Cache-Schreibstufen nicht auswählen;
  TTL-spezifische Antwortfelder werden defensiv in den aggregierten
  Cache-Schreibzähler normalisiert.
- Siehe [Inference usage telemetry](https://github.com/nvidia/skillspector/blob/main/docs/INFERENCE_USAGE.md) für den vollständigen
  Herkunfts-, Cache-Abrechnungs-, Datenschutz-, Fail-Closed-Erfassungs- und nachgelagerten
  Preisvertrag.
- Die vollständige Form pro Problem wird durch `Finding.to_dict()` in [models.py](https://github.com/nvidia/skillspector/blob/main/src/skillspector/models.py) definiert; verlassen Sie sich auf die obigen Felder und behandeln Sie zusätzliche Felder als Best-Effort.

Für CI/IDE-Tooling gibt `--format sarif` SARIF 2.1.0 aus.

### Empfohlene Gate-Zuordnung

Wenn Sie SkillSpector als Installations-Gate verwenden, ordnen Sie die Empfehlung einer Aktion zu:

| `recommendation` | Vorgeschlagene Aktion |
|------------------|------------------|
| `SAFE` | zulassen |
| `CAUTION` | Benutzer auffordern / warnen |
| `DO_NOT_INSTALL` | blockieren |

SkillSpector berechnet die Score-Bandbreite und die Empfehlung; wie streng das Gate ist (z. B. ob `CAUTION` in CI blockiert), ist eine Richtlinienentscheidung des integrierenden Tools.

## Entwicklung

### Einrichtung

Alle `make`-Ziele setzen voraus, dass bereits eine virtuelle Umgebung erstellt und aktiviert ist. Das Makefile verwendet **uv**, falls verfügbar, sonst **pip**.```bash
# Clone, create venv, activate, install dev dependencies
git clone https://github.com/NVIDIA/skillspector.git
cd skillspector
uv venv .venv && source .venv/bin/activate
# or: python3 -m venv .venv && source .venv/bin/activate
make install-dev

# Run tests
make test

# Run tests with coverage
make test-cov

# Run linting
make lint

# Format code
make format

## Lizenz

Apache License 2.0 – Details siehe [LICENSE](https://github.com/nvidia/skillspector/blob/main/LICENSE).

## Mitwirken

Beiträge sind willkommen! Bitte lesen Sie unsere Richtlinien für Mitwirkende und reichen Sie Pull Requests ein.

## Support

- **Probleme**: [GitHub Issues](https://github.com/NVIDIA/skillspector/issues)