Ihr Code wird nie gespeichert. Verarbeitung ausschließlich in EU-Rechenzentren. DSGVO-konform.
Zu unseren SicherheitsstandardsLurus Code – CLI
Die Lurus Code CLI wird mit dem Befehl `lurus` aufgerufen und bietet einen vollständigen KI-gestützten Entwicklungsworkflow direkt im Terminal.
npm install -g @scramble-cloud/lurus-code-cli Installation & Grundlagen
CLI global via npm installieren und in Sekunden loslegen.
npm install -g @scramble-cloud/lurus-code-cli lurus [befehl] [optionen] Ohne Befehl: startet interaktiven Chat
Konfigurationsdateien
~/.lurus/auth.json Authentifizierungsdaten (JWT / API-Key) ~/.lurus/settings.json Globale Einstellungen (Modell, MCP-Server) ./.lurus/settings.json Projektspezifische Einstellungen LURUS.md Projektkontext für den KI-Agenten .lurus/rules/*.md Projektregeln .lurus/commands/*.md Benutzerdefinierte Slash-Befehle Authentifizierung
Registrieren, anmelden und Ihr Lurus Code-Konto verwalten.
register
Erstellt ein neues Lurus Code-Konto über einen sicheren browserbasierten Device-Flow.
lurus register How it works
- 1 Die CLI sendet eine Anfrage an
/auth/device/codeund erhält einen temporären Device-Code. - 2 Ihr Browser öffnet sich automatisch auf der Registrierungsseite.
- 3 Im Terminal erscheint ein kurzer Benutzercode (z. B.
ABC-123). - 4 Nach Abschluss der Registrierung im Browser geben Sie den Code ein.
- 5 Die CLI fragt
/auth/device/tokenab bis zur Bestätigung und speichert dann JWT-Tokens lokal.
ℹ Kein Browser verfügbar? Die URL wird manuell im Terminal angezeigt.
ℹ Der Code läuft nach einigen Minuten ab (konfigurierbar über das Backend).
login
Authentifiziert sich mit einem bestehenden Lurus Code-Konto. Unterstützt drei verschiedene Methoden.
lurus login [optionen] Options
(keine) Browserbasierter Device-Flow (Standard) --api-key Anmeldung mit API-Key (kein Browser erforderlich) --email Anmeldung mit E-Mail-Adresse und Passwort ℹ Gespeichert in: ~/.lurus/auth.json
Methods
Methode 1 – Browser-Flow (Standard)
lurus login Browser öffnen → Einmalcode eingeben → fertig
Methode 2 – E-Mail & Passwort
lurus login --email Methode 3 – API-Key
lurus login --api-key logout
Meldet den aktuellen Benutzer ab und löscht lokale Authentifizierungsdaten.
lurus logout [optionen] Options
(keine) Nur aktuelle Sitzung beenden --all Von allen Geräten gleichzeitig abmelden auth status
Zeigt den aktuellen Authentifizierungsstatus und Kontoinformationen an.
lurus auth status How it works
- 1 Liest lokale Authentifizierungsdaten aus
~/.lurus/auth.json. - 2 Validiert die Sitzung via GET
/auth/profile. - 3 Gibt Name, E-Mail, Plan, Auth-Typ und API-URL aus.
Output Fields
Chat & Interaktion
Interaktive Sitzung starten oder einen einzelnen Prompt senden. chat ist der Standardbefehl.
chat
lurus chat [prompt...] [optionen] lurus [prompt...] # identisch – chat ist der Standard Startet eine interaktive Chat-Sitzung mit dem KI-Agenten oder sendet einen einzelnen Prompt und beendet sich. chat ist der Standardbefehl – er läuft auch ohne explizite Angabe.
Options
--model <modell> -m KI-Modell wählen (z. B. sonnet, opus, haiku) --prompt <text> -p Einzelnen Prompt senden und beenden --continue -c Letzte Sitzung für dieses Projekt fortsetzen --resume <id> -r Bestimmte Sitzung anhand der ID fortsetzen --dangerously-skip-permissions — Alle Berechtigungsabfragen überspringen (**Nur CI/CD!**) --pipe — JSON-Events auf stdout, Berechtigungsantworten von stdin (IDE-Integration) --output-format <format> — Ausgabeformat: text (Standard), stream-json, json --add-dir <verzeichnisse...> — Zusätzliche Verzeichnisse zum Kontext hinzufügen --from-pr <nummer> — PR-Diff als initialen Kontext laden --json-schema <pfad> — JSON-Schema für validierte strukturierte Ausgabe --permission-mode <modus> — Berechtigungsmodus: default, acceptEdits, plan, bypassPermissions --chrome — Browser-Automatisierung via Chrome DevTools Protocol aktivieren --debug — Ausführliche Debug-Ausgabe aktivieren Examples
lurus chat Interaktive Sitzung starten
lurus chat -p "Erkläre die Architektur dieses Projekts" Einzelnen Prompt senden (keine interaktive Sitzung)
lurus chat -m opus Mit einem bestimmten Modell starten
lurus chat --continue Letzte Sitzung fortsetzen
lurus chat --resume abc123def456 Bestimmte Sitzung anhand der ID fortsetzen
lurus chat --from-pr 42 PR-Diff als Kontext laden (erfordert git oder gh CLI)
lurus chat -p "Schreibe Tests für auth.service.ts" --dangerously-skip-permissions CI/CD – nicht-interaktiv, alle Berechtigungen automatisch gewähren
lurus chat --pipe JSON-Ausgabe für IDE-Integration (VS Code-Erweiterung usw.)
lurus chat -p "Code analysieren" --output-format json --json-schema ./schema.json Strukturierte JSON-Ausgabe mit Schema-Validierung
lurus chat --add-dir ./src --add-dir ./tests Mehrere Verzeichnisse zum Kontext hinzufügen
lurus chat --permission-mode plan Nur-Lesen, keine Dateiänderungen
Berechtigungsmodi
default Fragt vor jeder Tool-Nutzung acceptEdits Dateiänderungen werden automatisch akzeptiert plan Nur-Lesen – keine Änderungen möglich bypassPermissions Alle Berechtigungen automatisch gewähren Interaktiver Modus – Tastaturkürzel
Geben Sie ? ein, um alle verfügbaren Kürzel anzuzeigen.
!ls -la) Stapelverarbeitung
Mehrere Prompts aus einer Textdatei sequenziell verarbeiten. Ideal für Skripte, Pipelines und die Automatisierung wiederkehrender Aufgaben.
batch
lurus batch <datei> [optionen] Verarbeitet mehrere Prompts aus einer Textdatei sequenziell. Ideal für Skripte, Pipelines und die Automatisierung wiederkehrender Aufgaben.
Options
--model <modell> -m — Zu verwendendes KI-Modell --output-format <format> -o text Ausgabeformat: text oder json --continue-on-error — false Bei Fehlern weiterverarbeiten Dateiformat
Prompts werden durch --- (drei Bindestriche) getrennt. Zeilen, die mit # beginnen, sind Kommentare und werden ignoriert.
Examples
lurus batch prompts.txt Einfache Stapelverarbeitung (Textausgabe)
lurus batch prompts.txt -o json JSON-Ausgabe für maschinelle Verarbeitung
lurus batch prompts.txt --continue-on-error Fehler überspringen und alle Prompts verarbeiten
lurus batch prompts.txt -m haiku Bestimmtes Modell verwenden (günstiger für einfache Aufgaben)
lurus batch prompts.txt -o json --continue-on-error > results.json Kombination: JSON-Ausgabe und Fehler überspringen
Plugin-Verwaltung
Plugins erweitern die Lurus Code CLI mit zusätzlichen Slash-Befehlen und Workflows. Sie können global oder pro Projekt installiert werden.
Offizielle Plugins
lurus-security Security-Scanning mit 4 Phasen und SARIF-Export /scan lurus-code-review Code-Review mit HTML/JSON-Export /review lurus-commit KI-generierte Commit-Nachrichten /commit lurus-docs Automatische Dokumentationsgenerierung /docs lurus-test Testgenerierung und TDD-Workflows /test, /tdd plugin install
lurus plugin install <nameOderPfad> [optionen] Installiert ein Plugin aus dem offiziellen Registry, einem lokalen Pfad oder installiert alle verfügbaren Plugins.
lurus plugin install lurus-security Offizielles Plugin global installieren lurus plugin install all Alle offiziellen Plugins auf einmal installieren lurus plugin install ./mein-plugin Aus lokalem Entwicklungspfad installieren lurus plugin install lurus-security --project Nur für aktuelles Projekt installieren plugin remove
lurus plugin remove <name> [optionen] Entfernt ein installiertes Plugin.
lurus plugin remove lurus-security Ein einzelnes Plugin entfernen lurus plugin remove all Alle Plugins entfernen lurus plugin remove lurus-docs --project Projektspezifisches Plugin entfernen plugin list
lurus plugin list Listet alle installierten Plugins und verfügbare offizielle Plugins auf.
MCP-Server-Verwaltung
MCP (Model Context Protocol) ermöglicht die Integration externer Tools in den KI-Agenten. MCP-Server stellen dem Agenten zusätzliche Tools zur Verfügung (z. B. Datenbankzugriff, externe APIs, Dateisystem-Tools).
mcp add
lurus mcp add <name> --command <cmd> [optionen] Fügt einen neuen MCP-Server zur Konfiguration hinzu.
--command <cmd> Befehl zum Starten des Servers **(erforderlich)** --args <args...> Argumente für den Serverbefehl --env <paare...> Umgebungsvariablen im Format SCHLÜSSEL=WERT --trust Server vertrauen (keine Berechtigungsabfragen für seine Tools) --project Zum Projektbereich hinzufügen (Standard: global) lurus mcp add filesystem --command npx --args @modelcontextprotocol/server-filesystem / Dateisystem-Server hinzufügen
lurus mcp add github --command npx --args @modelcontextprotocol/server-github --env GITHUB_TOKEN=ghp_xxx GitHub-Server mit Token
lurus mcp add my-server --command ./server.sh --trust Vertrauenswürdiger lokaler Server (keine Bestätigung bei Tool-Nutzung)
lurus mcp add db-tools --command npx --args mcp-db-server --project Projektspezifischer Datenbank-Server
mcp remove
lurus mcp remove <name> [optionen] Entfernt einen konfigurierten MCP-Server.
lurus mcp remove filesystem Globalen Server entfernen lurus mcp remove db-tools --project Projektserver entfernen mcp list
lurus mcp list Listet alle konfigurierten MCP-Server auf (global und projektspezifisch).
CLI-Verwaltung
CLI aktuell halten und Shell-Vervollständigungen konfigurieren.
update
Aktualisiert die Lurus Code CLI auf die neueste verfügbare Version.
lurus update [optionen] Options
--check Prüfen, ob ein Update verfügbar ist, ohne es zu installieren How it works
- 1 Liest die aktuell installierte Version.
- 2 Fragt das npm-Registry nach der neuesten Version ab (
npm view @lurus/code version). - 3 Führt
npm update -g @lurus/codeaus, wenn ein Update verfügbar ist.
Examples
lurus update --check Prüfen, ob ein Update verfügbar ist
lurus update Update installieren
completions
Generiert Shell-Vervollständigungsskripte für Tab-Vervollständigung aller lurus-Befehle und Optionen.
lurus completions <shell> ℹ Nach der Einrichtung funktioniert Tab-Vervollständigung für alle Befehle, Optionen und Argumente.
Shell Setup
echo 'eval "$(lurus completions bash)"' >> ~/.bashrc && source ~/.bashrc echo 'eval "$(lurus completions zsh)"' >> ~/.zshrc && source ~/.zshrc lurus completions fish > ~/.config/fish/completions/lurus.fish CI/CD-Befehle
Diese Befehle sind für automatisierte Pipelines optimiert: headless (kein Browser), mit definierten Exit-Codes und optionaler GitHub-Integration.
security-ci
Führt einen KI-gestützten Security-Scan im CI/CD-Modus aus. Analysiert Code in 4 Phasen und gibt Ergebnisse als SARIF, JSON, HTML oder Text aus.
lurus security-ci [optionen] Options
--model <modell> — KI-Modell überschreiben --format <format> sarif Ausgabeformat: sarif, json, html, text --output <pfad> lurus-security-results.sarif Ausgabedatei --fail-on <severity> high Exit-Code ≠ 0 bei dieser Severity oder höher --diff — Nur geänderte Dateien scannen (via git diff) --diff-base <ref> HEAD Git-Ref für Diff-Vergleich --no-upload — Ergebnisse nicht ins Backend hochladen --pr-comments — Findings als PR-Review-Kommentare posten --comment-min-severity <severity> medium Mindest-Severity für PR-Kommentare Phases
[1/4] Discovery Dateien und Projektstruktur analysieren [2/4] Analysis Sicherheitslücken identifizieren [3/4] Verification Findings verifizieren (False Positives entfernen) [4/4] Remediation Konkrete Fix-Vorschläge generieren Exit Codes
Examples
lurus security-ci Standard-Scan mit SARIF-Ausgabe
lurus security-ci --diff --format json --output results.json Nur geänderte Dateien scannen (ideal für PRs)
lurus security-ci --diff --diff-base main Gegen main-Branch vergleichen
lurus security-ci --fail-on medium Bereits bei mittlerer Severity fehlschlagen
lurus security-ci --pr-comments --comment-min-severity high Mit PR-Kommentaren (in GitHub Actions)
lurus security-ci --format html --output security-report.html HTML-Bericht für Entwickler generieren
- name: Lurus Security Scan
run: lurus security-ci --diff --pr-comments
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} total_findings, blocking_findings, passed code-review-ci
Führt einen KI-gestützten Code-Review im CI/CD-Modus aus. Unterstützt automatische PR-Kommentare und Verdicts (APPROVE / REQUEST_CHANGES).
lurus code-review-ci [optionen] Options
--model <modell> — KI-Modell überschreiben --format <format> json Ausgabeformat: json, html, text --output <pfad> lurus-code-review-results.json Ausgabedatei --fail-on <severity> high Exit-Code ≠ 0 bei dieser Severity oder höher --full — Gesamtes Projekt reviewen (Standard: git diff) --staged — Nur staged Changes reviewen --diff-base <ref> — Git-Ref für Diff-Vergleich --pr-comments — Findings als PR-Review-Kommentare posten --verdict — PR-Review-Verdict abgeben (APPROVE / REQUEST_CHANGES) --comment-min-severity <severity> medium Mindest-Severity für PR-Kommentare Phases
[1/4] Discovery Geänderte Dateien identifizieren [2/4] Analysis Code-Qualität und Muster analysieren [3/4] Verification Findings validieren [4/4] Suggestions Konkrete Verbesserungsvorschläge erstellen Exit Codes
Verdicts
approve Code ist in Ordnung, PR kann gemergt werden needsChanges Änderungen erforderlich (REQUEST_CHANGES) comment Nur Kommentare, kein formelles Verdict Examples
lurus code-review-ci Standard-Review des aktuellen git diff
lurus code-review-ci --full Gesamtes Projekt reviewen
lurus code-review-ci --staged Nur staged Changes (vor dem Commit)
lurus code-review-ci --format html --output review.html --pr-comments HTML-Bericht mit PR-Kommentaren
lurus code-review-ci --pr-comments --verdict Mit automatischem Verdict (APPROVE oder REQUEST_CHANGES)
lurus code-review-ci --diff-base develop Gegen Feature-Branch vergleichen
- name: Lurus Code Review
run: lurus code-review-ci --pr-comments --verdict
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} Slash-Befehle (im Chat)
Slash-Befehle werden innerhalb einer aktiven lurus chat-Sitzung eingegeben. Sie beginnen immer mit /. Tab-Vervollständigung ist verfügbar.
/help zeigt alle verfügbaren Befehle mit Beschreibungen.
Sitzung & Info
/help Zeigt alle verfügbaren Slash-Befehle mit kurzen Beschreibungen.
/status Zeigt den vollständigen Sitzungsstatus: aktuelles Modell und Interaktionsmodus, Sitzungs-ID und Anzahl der Turns, Sitzungskosten und Kontostand, Token-Nutzung (Eingabe / Ausgabe), Dateien im Kontext.
/cost Kompakte Anzeige von Token-Nutzung und Sitzungskosten (Modell, Nachrichten, Eingabe-Tokens, Ausgabe-Tokens, Sitzungskosten, Kontostand).
/stats Detaillierte Sitzungsstatistiken: Dauer, Modell, Modus, Turns, Tokens, Dateien im Kontext, Anzahl geladener Tools.
/doctor Umgebungsdiagnose – prüft und zeigt: Node.js-Version, Git-Version und -Status, aktuelles Verzeichnis und Branch, API-URL und Verbindungsstatus, Modell, Modus, CLI-Version und Betriebssystem.
/report Erstellt einen Sitzungsanalysebericht.
/report HTML-Bericht (öffnet sich im Browser) /report --json JSON-Export nach lurus-report.json /report --json pfad/zur/datei.json JSON an einem bestimmten Pfad /changelog Generiert einen CHANGELOG.md-Eintrag im Keep-a-Changelog-Format aus dem git-Log seit dem letzten Tag.
/mermaid Generiert Mermaid-Diagramme aus der Codebasis.
/mermaid Projektarchitektur-Diagramm /mermaid Datenbankschema Datenbankschema-Diagramm /mermaid Authentifizierungsfluss Authentifizierungsfluss-Diagramm /vim Zeigt Anweisungen zur Aktivierung des Vim-Modus in der Shell (~/.inputrc).
Konfiguration & Projekt
/config Zeigt die aktuelle Konfiguration: API-URL, Modell, Prompt-Caching, maximale Tokens, Fallback-Modell, Utility-Modell, Modell-Aliase, Benachrichtigungen, Bypass-Permissions-Status, geladene Kontextquellen (LURUS.md, Regeln).
/init Analysiert das aktuelle Projekt und generiert eine LURUS.md-Datei mit: Projektbeschreibung, Tech-Stack, Projektstruktur, Coding-Konventionen, Build-/Test-/Lint-Befehlen und Architekturentscheidungen.
/init # Projekt analysieren und LURUS.md generieren...
/rules Verwaltet Projektregeln (gespeichert in .lurus/rules/*.md).
/rules Alle Regeln auflisten /rules show <name> Regelinhalt anzeigen /rules create [name] Neue Regel erstellen (Vorlage) /permissions Verwaltet dauerhafte Berechtigungen (erstellt durch Auswahl von [i]mmer bei Tool-Anfragen).
/permissions Alle gespeicherten Berechtigungen anzeigen /permissions clear Projektberechtigungen zurücksetzen /permissions clear global Globale Berechtigungen zurücksetzen /theme Legt das Terminal-Farbschema fest.
/theme dark Dunkles Design /theme light Helles Design /theme auto Automatisch (folgt der Terminal-Einstellung) /statusline Steuert die Terminal-Statusleiste.
/statusline Aktuelle Statusleiste anzeigen /statusline on Statusleiste dauerhaft aktivieren /statusline off Statusleiste deaktivieren Sitzungsverwaltung
/resume Zeigt frühere Sitzungen für das aktuelle Projekt und ermöglicht deren Fortsetzung.
/resume Alle Sitzungen anzeigen /resume auth Sitzungen nach Schlüsselwort filtern Zum Fortsetzen: lurus chat --resume
/sessions Verwaltet Sitzungen.
/sessions Sitzungen für aktuelles Projekt /sessions here Sitzungen im aktuellen Verzeichnis /sessions all Alle Sitzungen über alle Projekte hinweg /sessions delete <id> Eine Sitzung löschen /recall Durchsucht alle Sitzungen nach einem Begriff.
/recall authentifizierung Sitzungen finden, die "authentifizierung" enthalten /recall --load <id> Gefundene Sitzung laden und wiederherstellen /clear Löscht den Gesprächsverlauf der aktuellen Sitzung (kann nicht rückgängig gemacht werden).
/save Exportiert die aktuelle Sitzung als Markdown-Datei.
/save Speichert als lurus-session-<zeitstempel>.md /save meine-sitzung.md An einem bestimmten Pfad speichern /rewind Selektives Zurücksetzen.
/rewind chat Letzte Nachrichten aus dem Gespräch entfernen /rewind code Letzte Dateiänderungen rückgängig machen (Checkpoint) Kontextverwaltung
/context Zeigt die Kontextfenster-Auslastung: System-Prompt, Verzeichnisbaum, Gesprächs-Tokens, insgesamt verwendet vs. verbleibend.
/add Fügt Dateien oder Verzeichnisse zum Kontext hinzu.
/add src/auth.service.ts/add src/auth/ tests//add package.json README.md /drop Entfernt Dateien aus dem Kontext.
/drop src/auth.service.ts/drop tests/ /copy Kopiert die letzte KI-Antwort in die Zwischenablage (macOS, Linux, Windows).
/paste Fügt ein Bild aus der Zwischenablage in den Chat ein (für visuelle Analyse wie UI-Screenshots).
/compress / /compact Komprimiert den Gesprächsverlauf, um Kontextfenster-Platz freizugeben. Alte Nachrichten werden per LLM zusammengefasst. Zeigt die Anzahl der eingesparten Tokens. /compact ist ein Alias für /compress.
Code-Indizierung
/indexing Verwaltet die semantische Code-Indizierung (RAG – Retrieval Augmented Generation).
/indexing Status anzeigen (Chunks, Dateien, Kontingent) /indexing on Indizierung aktivieren /indexing off Indizierung deaktivieren /indexing rebuild Index löschen und neu aufbauen /indexing clear Lokalen Index + Backend-Kontingent zurücksetzen Git & GitHub
/git Führt Git-Befehle direkt aus dem Chat aus.
/git status/git log --oneline -10/git diff HEAD~1/git branch -a /commit Generiert KI-Commit-Nachrichten für staged Changes.
/commit KI generiert Commit-Nachricht /commit "meine nachricht" Direkt mit benutzerdefinierter Nachricht committen - 1 Prüft, ob Änderungen gestaged sind.
- 2 Falls nicht: fragt, ob alle Änderungen gestaged werden sollen.
- 3 KI analysiert den Diff und generiert eine Commit-Nachricht.
- 4 Bestätigung: `[j]a / [n]ein / [b]earbeiten`
/create-pr Erstellt einen Pull Request mit KI-generiertem Titel und Beschreibung.
/create-pr Automatisch generierter Titel und Beschreibung /create-pr --draft Als Draft-PR erstellen /create-pr --reviewer benutzername Reviewer hinzufügen /create-pr --label bug Label hinzufügen Erforderlich: GitHub CLI (gh) installiert und authentifiziert.
/fix-issue Analysiert und behebt ein GitHub-Issue automatisch.
/fix-issue 42
- 1 Lädt Issue-Details via `gh`.
- 2 Erstellt Branch `fix/issue-42`.
- 3 KI analysiert die Codebasis und implementiert den Fix.
/analyze-issue Analysiert ein GitHub-Issue (nur lesend, keine Änderungen).
/analyze-issue 42
/fix-pr Behebt automatisch offene PR-Review-Kommentare.
/fix-pr
Lädt alle Review-Kommentare des aktuellen PRs und implementiert die vorgeschlagenen Korrekturen.
/worktree Verwaltet Git-Worktrees.
/worktree create <branch> Neuen Worktree erstellen /worktree list Alle Worktrees auflisten /worktree switch <branch> Zu einem Worktree wechseln Tools & Tests
/tools Listet alle verfügbaren Agenten-Tools auf.
/tools Nur Namen auflisten /tools desc Mit Beschreibungen /web Lädt den Inhalt einer URL und fügt ihn dem Chat-Kontext hinzu.
/web https://docs.example.com/api
/lint Führt den konfigurierten Linter aus.
/lint npm run lint /lint fix npm run lint -- --fix /test Führt Tests aus.
/test npm test /test npm run test:unit Benutzerdefinierter Befehl /test jest auth.spec.ts Bestimmte Testdatei /tdd TDD-Workflow (Test-Driven Development).
/tdd <feature> TDD-Zyklus starten (Rot → Grün → Refaktorieren) /tdd on TDD-Guard aktivieren (Warn-Modus) /tdd strict TDD-Guard (strikter Modus, blockiert ohne Tests) /tdd off TDD-Guard deaktivieren /tdd-implement Implementiert Code für bereits vorhandene, fehlschlagende Tests. Die KI führt npm test aus, implementiert Code für jeden fehlschlagenden Test und stellt sicher, dass keine Regressionen auftreten.
/tdd-implement
/edit Öffnet den konfigurierten Editor ($EDITOR) für mehrzeilige Eingabe. Nach dem Speichern wird der Inhalt als Prompt gesendet.
/edit # Öffnet vi/vim/nano/code je nach $EDITOR-Variable
/diff Zeigt alle Dateiänderungen seit Sitzungsstart (geänderte Dateien und farbiger Diff-Patch).
/diff
/undo Macht die letzten Dateiänderungen rückgängig (checkpoint-basiert).
/undo # Wiederherstellung zu: Vor auth.service.ts-Bearbeitung (14:32:15) # ✓ auth.service.ts, user.service.ts wiederhergestellt
Modell & Modus
/model Zeigt das KI-Modell für die aktuelle Sitzung an oder ändert es.
/model Aktuelles Modell und verfügbare Modelle anzeigen /model sonnet Zu Claude Sonnet wechseln /model opus Zu Claude Opus wechseln (leistungsstärker) /model haiku Zu Claude Haiku wechseln (schneller/günstiger) Modell-Aliase aus der Konfiguration werden automatisch aufgelöst.
/utilitymodel Zeigt das Utility-Modell an oder ändert es (wird für interne Aufgaben wie Zusammenfassung verwendet).
/utilitymodel Aktuelles Utility-Modell anzeigen /utilitymodel haiku Auf Haiku setzen (günstiger für interne Aufgaben) /utilitymodel clear Auf Standard zurücksetzen /mode Wechselt den Agenten-Interaktionsmodus.
/mode Aktuellen Modus und alle verfügbaren Modi anzeigen /mode agent Vollständiger Tool-Zugriff (Standard) /mode plan Nur-Lesen und Planung, keine Änderungen /mode ask Nur-Lesen, Q&A-Modus /mode debug Systematisches Debugging agent Vollständiger Tool-Zugriff – kann Code schreiben und ausführen plan Nur-Lesen – erstellt Pläne und Analysen ohne Änderungen ask Nur-Lesen – beantwortet Fragen ohne Tool-Nutzung debug Systematisches Debugging (beste Ergebnisse mit IDE-Verbindung) /max Schaltet den Max-Modus um (verzögert automatische Kontextkomprimierung). Im Max-Modus wird die automatische Komprimierung bei 85% Auslastung ausgelöst (Standard: 50%).
/max
/thinking Schaltet erweitertes Denken ein oder aus. Erweitertes Denken ermöglicht es dem Modell, komplexe Probleme Schritt für Schritt durchzuarbeiten (verbessert die Qualität bei komplexen Aufgaben, kostet mehr Tokens).
/thinking Aktivieren /thinking off Deaktivieren Plugins & Erweiterungen
/plugins Verwaltet Plugins direkt aus dem Chat.
/plugins Installierte Plugins auflisten /plugins install lurus-security Plugin installieren /plugins install all Alle offiziellen Plugins installieren /plugins remove lurus-docs Plugin entfernen /mcp Zeigt MCP-Server-Status und verfügbare Tools.
/mcp Alle Server und ihre Tools anzeigen /mcp restart <name> Einen Server neu starten /commands Listet alle benutzerdefinierten Befehle, Skills und Custom Agents auf (aus .lurus/commands/*.md, Skills mit aktiv/inaktiv-Status, Custom Agents mit Tools und Modell).
/commands
/skills Verwaltet Skills (wiederverwendbare KI-Workflows).
/skills Alle Skills auflisten /skills activate <name> Skill aktivieren /skills deactivate <name> Skill deaktivieren /skills audit Skills auf Probleme prüfen /skillify Konvertiert die aktuelle Sitzung in einen wiederverwendbaren Skill. Die KI analysiert die Sitzung, identifiziert wiederholbare Prozesse und erstellt eine SKILL.md-Datei in .lurus/skills/ oder ~/.lurus/skills/.
/skillify
/create-hook Erstellt Hook-Boilerplate für ereignisbasierte Automatisierung.
/create-hook PreToolUse mein-hook Shell-Hook erstellen /create-hook PostToolUse mein-hook --ts TypeScript-Hook erstellen PreToolUse Vor jeder Tool-Ausführung PostToolUse Nach erfolgreicher Tool-Ausführung PostToolUseFailure Nach fehlgeschlagener Tool-Ausführung SessionStart Wenn eine Sitzung startet SessionEnd Wenn eine Sitzung endet UserPromptSubmit Bei jeder Prompt-Eingabe SubagentStart Wenn ein Subagent startet Stop Wenn der Agent stoppt PreCompact Vor der Kontextkomprimierung Notification Bei Benachrichtigungen /hooks Verwaltet Hooks.
/hooks validate hooks.json auf Fehler prüfen Review & Sicherheit
/review / /code-review Führt einen KI-Code-Review aus (erfordert lurus-code-review-Plugin).
/review Uncommitted Changes reviewen /review --full Gesamtes Projekt reviewen /review --staged Nur staged Changes /review --diff-base main Gegen Branch/Ref vergleichen /review --tier max Beste Modelle verwenden (Opus usw.) /review --tier eu Nur EU-Modelle verwenden /review --html HTML-Bericht generieren /review --json output.json JSON-Export /review --model opus Modell für alle Phasen überschreiben /scan / /security-review Führt einen Security-Scan aus (erfordert lurus-security-Plugin).
/scan Gesamtes Projekt scannen /scan --diff Nur geänderte Dateien /scan --diff-base main Gegen Branch/Ref vergleichen /scan --tier max Beste Modelle /scan --tier eu Nur EU-Modelle /scan --html HTML-Bericht generieren /scan --json output.json JSON-Export /scan --model opus Modell überschreiben Orchestrierung & IDE
/orchestrate Startet einen Multi-Agenten-Workflow.
/orchestrate Verfügbare Workflows anzeigen /orchestrate feature <prompt> Feature-Entwicklung /orchestrate bugfix <prompt> Bug-Behebung /orchestrate refactor <prompt> Code-Refaktorierung /orchestrate security <prompt> Sicherheitsüberprüfung /orchestrate review <prompt> Code-Review /orchestrate auto <spezifikation> Autonomer Loop bis die Spezifikation erfüllt ist Autonomer Loop mit Grenzen:
/orchestrate auto "Vollständige Benutzerauthentifizierung implementieren" --max-iterations 30 --max-tokens 5000000 --max-cost 50 --max-subtasks 25 feature Feature-Entwicklung mit Planung, Implementierung und Tests bugfix Systematische Bug-Analyse und -Behebung refactor Code-Qualitätsverbesserung ohne Verhaltensänderungen security Sicherheitsanalyse und -härtung review Umfassender Code-Review auto Autonomer Loop: Aufgabe in Unteraufgaben aufteilen und iterativ lösen /ide Verwaltet die IDE-Verbindung (VS Code).
/ide Verbindungsstatus anzeigen /ide enable Mit VS Code verbinden /ide disable Verbindung trennen - ✓ Diff-Ansicht für Dateiänderungen direkt in VS Code
- ✓ Inline-Diagnostics (Linter-/Compiler-Fehler im Chat-Kontext)
- ✓ Debug-Sitzungsintegration
/quit / /exit Beendet die Chat-Sitzung.
/quit Sitzung beenden /exit Sitzung beenden (Alias) Schnellreferenz
CLI-Befehle (Top-Level)
lurus register lurus login lurus logout [--all] lurus auth status lurus chat lurus chat -p "..." lurus chat -c lurus batch <datei> lurus plugin install <name> lurus plugin remove <name> lurus plugin list lurus mcp add <name> lurus mcp remove <name> lurus mcp list lurus update [--check] lurus completions <shell> lurus security-ci lurus code-review-ci Slash-Befehle (im Chat)
/help, /status, /cost, /stats, /doctor, /report, /changelog, /mermaid
/config, /init, /rules, /permissions, /theme, /statusline
/resume, /sessions, /recall, /clear, /save, /rewind
/context, /add, /drop, /copy, /paste, /compress, /compact
/indexing
/git, /commit, /create-pr, /fix-issue, /analyze-issue, /fix-pr, /worktree
/tools, /web, /lint, /test, /tdd, /tdd-implement, /edit, /diff, /undo
/model, /utilitymodel, /mode, /max, /thinking
/plugins, /mcp, /commands, /skills, /skillify, /create-hook, /hooks
/review, /code-review, /scan, /security-review
/orchestrate, /ide
/quit, /exit
Best Practices & Code-Beispiele
Praktische Beispiele, häufige Fehler und Tipps für die optimale Nutzung der Lurus Code CLI.
Authentifizierung
API-Keys in CI/CD verwenden – kein Browser-Flow
Der Browser-basierte Login erfordert Benutzerinteraktion und funktioniert nicht in headless-Umgebungen. Verwenden Sie immer API-Keys für Pipelines.
✅ Richtig – API-Key über Umgebungsvariable
# In CI/CD-Secrets setzen (z. B. GitHub Actions) export LURUS_API_KEY=lurus_ihr_key_hier # Oder direkt dem Befehl übergeben LURUS_API_KEY=lurus_xxx lurus security-ci --diff
❌ Falsch – Browser-Flow in CI/CD
# Hängt in einer headless-Umgebung! lurus login # Erfordert Browser-Interaktion
Speichern Sie den API-Key als GitHub Secret (LURUS_API_KEY) und injizieren Sie ihn über env: in Ihrem Workflow.
Authentifizierung nach Login immer prüfen
Nach dem Login immer prüfen, ob die Session aktiv ist, bevor eine Session gestartet wird.
✅ Richtig – Nach Login prüfen
lurus login lurus auth status # ✓ Authenticated # Name: Max Mustermann # Plan: pro
Wenn lurus auth status "Not authenticated" anzeigt, führen Sie lurus login erneut aus oder prüfen Sie Ihren API-Key.
Sicheres Abmelden von allen Geräten
Beim Gerätewechsel oder bei Verdacht auf eine kompromittierte Session von allen Geräten abmelden.
✅ Richtig – Von allen Geräten abmelden
# Von allen Geräten abmelden (z. B. beim Laptop-Wechsel) lurus logout --all # Dann auf dem neuen Gerät anmelden lurus login
Chat & Interaktion
--permission-mode plan für Nur-Lesen-Analysen verwenden
Wenn Sie Code nur analysieren, ohne Änderungen vorzunehmen, nutzen Sie den Plan-Modus. Dies verhindert unbeabsichtigte Dateiänderungen.
✅ Richtig – Nur-Lesen-Analyse
# Architektur analysieren ohne Änderungen lurus chat -p "Erkläre den Authentifizierungsfluss" --permission-mode plan # Oder Modus im Chat wechseln lurus chat > /mode plan > Analysiere alle API-Endpunkte in src/routes/
❌ Suboptimal – Standard-Modus für Nur-Lesen-Aufgaben
# Im Standard-Modus kann der Agent unerwartet Dateien ändern lurus chat -p "Erkläre den Authentifizierungsfluss" # Agent könnte Dateien erstellen oder ändern
Nutzen Sie /mode plan in einer aktiven Session, um jederzeit in den Nur-Lesen-Modus zu wechseln.
Kontext vor Fragen laden
Fügen Sie relevante Dateien zum Kontext hinzu, bevor Sie komplexe Fragen stellen. Das gibt dem KI-Agenten bessere Informationen.
✅ Richtig – Erst Kontext laden
lurus chat > /add src/auth/ src/users/ tests/auth/ > /indexing on > Erkläre jetzt den vollständigen Authentifizierungsfluss und identifiziere potenzielle Sicherheitsprobleme
❌ Suboptimal – Ohne Kontext fragen
lurus chat > Erkläre den Authentifizierungsfluss # KI-Agent hat keinen Dateikontext und gibt generische Antworten
Nutzen Sie /context, um zu prüfen, wie viel des Kontextfensters bereits belegt ist.
Sessions fortsetzen statt neu starten
Sessions bewahren Kontext und Verlauf. Fortsetzen ist effizienter als jedes Mal neu zu starten.
✅ Richtig – Letzte Session fortsetzen
# Dort weitermachen, wo Sie aufgehört haben lurus chat -c # Oder eine bestimmte Session fortsetzen lurus chat --resume abc123def456 # Im Chat: vergangene Sessions durchsuchen > /recall "Authentifizierungs-Refactoring"
Nutzen Sie /save meine-feature.md, um wichtige Sessions als Markdown für spätere Referenz zu exportieren.
--output-format json für Scripting verwenden
Für automatisierte Workflows nutzen Sie JSON-Ausgabe, um KI-Antworten programmatisch zu verarbeiten.
✅ Richtig – JSON-Ausgabe für Scripting
# Strukturierte Ausgabe erhalten und mit jq verarbeiten lurus chat -p "Liste alle öffentlichen API-Endpunkte als JSON-Array" \ --output-format json \ --json-schema ./api-schema.json | jq '.endpoints' # Stream-JSON für Echtzeit-Verarbeitung lurus chat -p "Analysiere diese Datei" --output-format stream-json
Stapelverarbeitung
Prompt-Dateien mit Kommentaren strukturieren
Verwenden Sie Kommentare (#) und klare Trennzeichen (---), um Batch-Dateien wartbar zu gestalten.
✅ Richtig – Gut strukturierte Prompt-Datei
# prompts.txt # ============================================ # Batch: Dokumentationsgenerierung v1.0 # Ausführen: lurus batch prompts.txt -o json # ============================================ # Prompt 1: Auth-Modul Analysiere src/auth/auth.service.ts und generiere JSDoc-Kommentare für alle öffentlichen Methoden --- # Prompt 2: User-Modul Analysiere src/users/user.service.ts und generiere JSDoc-Kommentare für alle öffentlichen Methoden --- # Prompt 3: Zusammenfassung Erstelle eine README.md-Übersicht für das src/-Verzeichnis
❌ Suboptimal – Unstrukturierte Prompt-Datei
Analysiere auth.service.ts --- Analysiere user.service.ts --- Erstelle README
Verwenden Sie -m haiku für einfache Dokumentationsaufgaben, um Kosten erheblich zu reduzieren.
Immer --continue-on-error in CI/CD verwenden
In Pipelines sollte ein einzelner fehlgeschlagener Prompt nicht den gesamten Batch abbrechen. Nutzen Sie --continue-on-error und prüfen Sie den Exit-Code.
✅ Richtig – Fehlertoleranter Batch in CI
# In GitHub Actions
- name: Dokumentation generieren
run: |
lurus batch doc-prompts.txt \
-o json \
--continue-on-error \
> batch-results.json
# Prüfen wie viele erfolgreich waren
jq '.succeeded, .failed' batch-results.json ❌ Falsch – Batch ohne Fehlerbehandlung
# Ein fehlgeschlagener Prompt bricht den gesamten Batch ab lurus batch doc-prompts.txt # Exit-Code 1 = Pipeline schlägt sofort fehl
Günstigere Modelle für einfache Aufgaben verwenden
Nicht jede Aufgabe erfordert das leistungsstärkste Modell. Nutzen Sie haiku für einfache Dokumentation, sonnet für komplexe Analysen.
✅ Richtig – Modellauswahl nach Aufgabenkomplexität
# Einfache Dokumentation → haiku (schnell & günstig) lurus batch simple-docs.txt -m haiku # Komplexe Sicherheitsanalyse → opus (leistungsstärkste) lurus batch security-analysis.txt -m opus # Standard → sonnet (gute Balance) lurus batch mixed-tasks.txt
Prüfen Sie Token-Kosten mit /cost in einer interaktiven Session, bevor Sie große Batches ausführen.
Plugin-Verwaltung
Plugins per Projekt für Isolation installieren
Verwenden Sie --project, um Plugins nur für das aktuelle Projekt zu installieren. Das vermeidet Konflikte zwischen verschiedenen Projekten.
✅ Richtig – Projektspezifische Installation
# Security-Plugin nur für dieses Projekt installieren cd /pfad/zu/meinem-projekt lurus plugin install lurus-security --project # Projekt-Plugins prüfen lurus plugin list # lurus-security v1.2.0 [project]
❌ Suboptimal – Globale Installation für alle Projekte
# Installiert global – betrifft alle Projekte lurus plugin install lurus-security # Kann mit anderen Projektkonfigurationen kollidieren
Nutzen Sie globale Installation nur für Plugins, die Sie in jedem Projekt verwenden (z. B. lurus-commit).
Alle Plugins für ein vollständiges Setup installieren
Für eine vollständige Entwicklungsumgebung alle offiziellen Plugins auf einmal installieren.
✅ Richtig – Vollständiges Setup mit einem Befehl
# Alle offiziellen Plugins global installieren lurus plugin install all # Installation prüfen lurus plugin list # lurus-security v1.2.0 [global] # lurus-code-review v1.0.0 [global] # lurus-commit v1.0.0 [global] # lurus-docs v1.0.0 [global] # lurus-test v1.0.0 [global] # Jetzt im Chat verfügbar: # /scan, /review, /commit, /docs, /test, /tdd
MCP-Server-Verwaltung
--trust nur für lokale, verifizierte Server verwenden
Das --trust-Flag deaktiviert Berechtigungs-Prompts für die Tools eines Servers. Verwenden Sie es nur für Server, die Sie vollständig kontrollieren.
✅ Richtig – Nur lokale Server vertrauen
# Lokaler Server, den Sie selbst geschrieben haben → trust ist OK lurus mcp add mein-db-tools --command ./scripts/db-mcp.sh --trust # Externer Server → niemals ohne Prüfung vertrauen lurus mcp add filesystem --command npx --args @modelcontextprotocol/server-filesystem / # (Kein --trust: jede Tool-Nutzung erfordert Bestätigung)
❌ Gefährlich – Externen Servern vertrauen
# Niemals mit nicht vertrauenswürdigen Servern! lurus mcp add unbekannter-server --command npx --args some-unknown-mcp --trust # Könnte beliebigen Code ohne Bestätigung ausführen
Nutzen Sie /mcp im Chat, um zu sehen, welche Tools ein Server bereitstellt, bevor Sie ihm vertrauen.
Umgebungsvariablen für Secrets verwenden
API-Token und Secrets über --env übergeben, niemals im Script hardcoden.
✅ Richtig – Secrets über Umgebungsvariablen
# GitHub-Token über --env übergeben
lurus mcp add github \
--command npx \
--args @modelcontextprotocol/server-github \
--env GITHUB_TOKEN=$GITHUB_TOKEN
# Oder aus Umgebung lesen
lurus mcp add github \
--command npx \
--args @modelcontextprotocol/server-github \
--env GITHUB_TOKEN=${GITHUB_TOKEN} ❌ Falsch – Hardcodierte Secrets
# Niemals Token hardcoden! lurus mcp add github \ --command npx \ --args @modelcontextprotocol/server-github \ --env GITHUB_TOKEN=ghp_abc123xyz # Im Shell-Verlauf sichtbar!
Projektbereich für projektspezifische Tools nutzen
Datenbankserver, projektspezifische APIs und lokale Tools sollten pro Projekt konfiguriert werden.
✅ Richtig – Projektspezifischer MCP-Server
# Projekt-Datenbankserver → nur für dieses Projekt cd /pfad/zu/meinem-projekt lurus mcp add db-tools \ --command npx \ --args mcp-postgres-server \ --env DATABASE_URL=$DATABASE_URL \ --project # Globale Tools (Filesystem, GitHub) → global lurus mcp add filesystem \ --command npx \ --args @modelcontextprotocol/server-filesystem /
CI/CD-Befehle
Immer --diff in PRs verwenden – nie das gesamte Projekt scannen
In PR-Workflows nur geänderte Dateien scannen. Vollständige Projektscans sind langsam und verschwenden Credits.
✅ Richtig – Nur geänderte Dateien scannen
# In GitHub Actions bei pull_request-Events
- name: Lurus Security Scan
run: lurus security-ci --diff --pr-comments
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }} ❌ Suboptimal – Vollständiger Scan bei jedem PR
# Scannt gesamtes Projekt bei jedem PR – langsam & teuer! - name: Lurus Security Scan run: lurus security-ci # Kein --diff-Flag
Verwenden Sie --diff-base main, um gegen den main-Branch statt HEAD zu vergleichen.
Severity-Schwellwerte schrittweise konfigurieren
Beginnen Sie mit --fail-on critical und senken Sie den Schwellwert, während das Team bestehende Issues behebt.
✅ Richtig – Schrittweise Severity-Schwellwerte
# Phase 1: Nur bei kritischen Issues blockieren lurus security-ci --diff --fail-on critical # Phase 2: Nach Behebung kritischer Issues lurus security-ci --diff --fail-on high # Phase 3: Strenger Modus lurus security-ci --diff --fail-on medium
Nutzen Sie --no-upload, wenn Sie Scans ausführen möchten, ohne Ergebnisse ans Backend hochzuladen.
GitHub Actions Outputs für Benachrichtigungen nutzen
Lurus CI-Befehle setzen GitHub Actions Outputs, die Sie für Slack/Teams-Benachrichtigungen verwenden können.
✅ Richtig – Outputs für Benachrichtigungen nutzen
- name: Lurus Security Scan
id: security
run: lurus security-ci --diff --pr-comments
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
- name: Bei Findings benachrichtigen
if: steps.security.outputs.blocking_findings > 0
uses: slackapi/slack-github-action@v1
with:
payload: |
{"text": "⚠️ ${{ steps.security.outputs.total_findings }} Sicherheitsfunde!"} Vollständige CI/CD-Pipeline: Security + Code Review
Security-Scan und Code-Review in einem einzigen Workflow kombinieren für vollständige KI-gestützte Quality Gates.
✅ Vollständiges Pipeline-Beispiel
name: KI Code-Qualität
on:
pull_request:
branches: [main, develop]
jobs:
ai-quality:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0 # Vollständiger Verlauf für Diff
- name: Lurus installieren
run: npm install -g @scramble-cloud/lurus-code-cli
- name: Security Scan
id: security
run: lurus security-ci --diff --pr-comments --fail-on high
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
- name: Code Review
id: review
run: lurus code-review-ci --pr-comments --verdict
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
- name: SARIF hochladen
uses: github/codeql-action/upload-sarif@v3
if: always()
with:
sarif_file: lurus-security-results.sarif Slash-Befehle
Jedes neue Projekt mit /init initialisieren
Führen Sie /init am Anfang jedes neuen Projekts aus, um dem KI-Agenten vollständigen Projektkontext zu geben.
✅ Richtig – Projektinitialisierung
# Im Projektstamm lurus chat > /init # Analysiere Projekt und generiere LURUS.md... # ✓ LURUS.md erstellt # Der KI-Agent kennt jetzt: # - Tech-Stack (TypeScript, React, PostgreSQL) # - Projektstruktur # - Build/Test/Lint-Befehle # - Coding-Konventionen
Aktualisieren Sie LURUS.md regelmäßig, wenn sich das Projekt weiterentwickelt. Der KI-Agent liest sie bei jedem Sitzungsstart.
/compress für lange Sessions nutzen
Wenn das Kontextfenster voll wird, komprimieren Sie den Konversationsverlauf statt eine neue Session zu starten.
✅ Richtig – Komprimieren statt neu starten
# Kontextnutzung prüfen > /context # Kontextauslastung: ████████░░ 78.3% # Komprimieren wenn ~80% erreicht > /compress # ✓ Komprimiert 45.123 → 8.234 Token (36.889 Token gespart) # Weiterarbeiten > Fahre mit der Implementierung des OAuth2-Flows fort
❌ Suboptimal – Neue Session bei vollem Kontext
# Verliert allen Kontext und Verlauf! > /quit lurus chat # Neue Session – KI hat keine Erinnerung an vorherige Arbeit
/tdd für qualitätsgetriebene Entwicklung nutzen
Der TDD-Workflow sichert Code-Qualität durch Tests-zuerst. Nutzen Sie /tdd on für dauerhaften Guard-Modus.
✅ Richtig – TDD-Workflow
# TDD-Guard für die Session aktivieren > /tdd on # ✓ TDD-Guard aktiviert (Warn-Modus) # TDD-Zyklus für ein Feature starten > /tdd BenutzerAuthentifizierung # [RED] Schreibe fehlschlagende Tests... # [GREEN] Implementiere minimalen Code... # [REFACTOR] Verbessere Code-Qualität... # Oder für bestehende fehlschlagende Tests implementieren > /tdd-implement # Führe npm test aus... 3 Tests schlagen fehl # Implementiere Fixes...
/orchestrate für komplexe mehrstufige Aufgaben nutzen
Für komplexe Features, die Planung, Implementierung und Tests erfordern, Orchestrierung statt eines einzelnen Prompts verwenden.
✅ Richtig – Orchestrierte Feature-Entwicklung
# Komplexes Feature → Orchestrierung nutzen
> /orchestrate feature "OAuth2-Login mit Google und GitHub hinzufügen"
# Autonomer Loop für große Aufgaben
> /orchestrate auto "Vollständige Benutzerverwaltung mit RBAC implementieren" \
--max-iterations 20 \
--max-cost 30
# Alle Änderungen nach Orchestrierung prüfen
> /diff ❌ Suboptimal – Einzelner Prompt für komplexe Aufgaben
# Zu komplex für einen einzelnen Prompt – inkonsistente Ergebnisse > Implementiere vollständigen OAuth2-Login mit Google und GitHub, inklusive Tests, Dokumentation und Fehlerbehandlung
/thinking für komplexe Architekturentscheidungen aktivieren
Extended Thinking für komplexe Probleme aktivieren, die tiefe Analyse erfordern.
✅ Richtig – Extended Thinking für komplexe Probleme
# Extended Thinking aktivieren > /thinking # ✓ Extended Thinking aktiviert # Jetzt komplexe Architekturfragen stellen > Analysiere das aktuelle Datenbankschema und schlage eine Migrationsstrategie vor, um Multi-Tenancy ohne Datenverlust zu unterstützen # Für einfache Aufgaben deaktivieren (spart Token) > /thinking off
Extended Thinking kostet mehr Token, verbessert aber die Qualität bei komplexen Architekturentscheidungen erheblich.
Häufige Fehler & Lösungen
Error: Not authenticated Keine gültige Session oder abgelaufener Token.
Führen Sie `lurus login` aus oder setzen Sie `LURUS_API_KEY` als Umgebungsvariable.
# Lösung 1: Neu anmelden lurus login # Lösung 2: API-Key verwenden export LURUS_API_KEY=lurus_ihr_key lurus auth status
Error: Rate limit exceeded Zu viele Anfragen in kurzer Zeit.
Warten Sie einige Sekunden und versuchen Sie es erneut. Verwenden Sie `--continue-on-error` im Batch-Modus.
# Im Batch-Modus: Rate-Limit-Fehler überspringen lurus batch prompts.txt --continue-on-error # Guthaben prüfen lurus auth status # Balance: 0,50 € (niedrig!)
Kontextfenster voll (100%) Der Konversationsverlauf ist zu lang.
Nutzen Sie `/compress`, um den Verlauf zusammenzufassen, oder `/clear` für einen Neustart.
# Option 1: Komprimieren (bewahrt Kontext) > /compress # Option 2: Löschen (verliert Verlauf) > /clear # Option 3: Max-Modus aktivieren, um Komprimierung zu verzögern > /max
Exit-Code 2: Scan fehlgeschlagen (technischer Fehler) Netzwerkfehler, Authentifizierungsproblem oder interner Fehler.
Authentifizierungsstatus und Netzwerkverbindung prüfen. Mit `--debug` für Details ausführen.
# Authentifizierung prüfen lurus auth status # Mit Debug-Ausgabe ausführen lurus security-ci --debug # Prüfen ob das Problem temporär ist lurus update --check # Ist die CLI aktuell?
Plugin nach Installation nicht gefunden Plugin im falschen Bereich installiert (global vs. Projekt).
Mit `lurus plugin list` prüfen und mit korrektem Bereich neu installieren.
# Installierte Plugins prüfen lurus plugin list # Für aktuelles Projekt neu installieren lurus plugin install lurus-security --project # Oder global installieren lurus plugin install lurus-security
MCP-Server: connection refused Serverprozess konnte nicht gestartet werden oder Port ist blockiert.
Server mit `/mcp restart <name>` neu starten und Logs prüfen.
# Im Chat: Server neu starten > /mcp restart mein-server # Server-Status prüfen > /mcp # filesystem ❌ disconnected # Entfernen und neu hinzufügen lurus mcp remove mein-server lurus mcp add mein-server --command ./server.sh
Erweiterte Befehlskombinationen
Vollständiger PR-Workflow
Von der Feature-Entwicklung bis zum gemergten PR – vollständig automatisiert.
# 1. Session starten und Projekt initialisieren lurus chat > /init > /mode agent # 2. Feature mit TDD entwickeln > /tdd BenutzerAuthentifizierung # 3. Alle Tests ausführen > /test # 4. Sicherheitscheck > /scan --diff # 5. Code-Review > /review --staged # 6. Commit und PR > /commit > /create-pr --reviewer team-lead
Automatisierter nächtlicher Qualitätsbericht
Eine vollständige Qualitätspipeline, die jede Nacht läuft und Berichte generiert.
# nightly-quality.yml
name: Nächtlicher Qualitätsbericht
on:
schedule:
- cron: '0 2 * * *' # Jede Nacht um 2 Uhr
jobs:
quality-report:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: npm install -g @scramble-cloud/lurus-code-cli
# Security-Scan → HTML-Bericht
- run: lurus security-ci --format html --output security.html
env:
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
# Code-Review → JSON-Bericht
- run: lurus code-review-ci --full --format json --output review.json
env:
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
# Batch: Changelogs generieren
- run: lurus batch nightly-prompts.txt -o json --continue-on-error
env:
LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
- uses: actions/upload-artifact@v4
with:
name: quality-reports
path: |
security.html
review.json Multi-Repository Security-Audit
Mehrere Repositories parallel mit einer Batch-Datei scannen.
# audit-prompts.txt # Sicherheits-Audit für alle Microservices Analysiere src/auth-service/ auf Sicherheitslücken und generiere einen SARIF-Bericht --- Analysiere src/payment-service/ auf Sicherheitslücken und generiere einen SARIF-Bericht --- Analysiere src/user-service/ auf Sicherheitslücken und generiere einen SARIF-Bericht
# Audit über alle Services ausführen lurus batch audit-prompts.txt -o json --continue-on-error > audit-results.json # Ergebnisse prüfen jq '.results[] | select(.status == "error")' audit-results.json
Interaktive Session mit vollständigem MCP-Setup
Eine vollständig konfigurierte Session mit GitHub-, Filesystem- und Datenbanktools.
# Setup (einmalig) lurus mcp add github \ --command npx \ --args @modelcontextprotocol/server-github \ --env GITHUB_TOKEN=$GITHUB_TOKEN lurus mcp add filesystem \ --command npx \ --args @modelcontextprotocol/server-filesystem / lurus mcp add db \ --command npx \ --args mcp-postgres-server \ --env DATABASE_URL=$DATABASE_URL \ --project --trust # Session starten lurus chat > /mcp # Alle Server prüfen > /indexing on # Semantische Code-Suche aktivieren > /mode agent # Vollständiger Tool-Zugriff # Jetzt kann die KI: # - Dateien über Filesystem-MCP lesen/schreiben # - GitHub Issues/PRs abfragen # - Datenbankabfragen ausführen # - Die Codebasis semantisch durchsuchen
Workflows in Aktion
Die wichtigsten CLI-Workflows als animierte Terminal-Demos. Klicken Sie auf ↺, um eine Animation neu zu starten.
Demo 1: Login & Authentifizierung
Authentifizieren Sie sich in Sekunden per Browser-OAuth.
Demo 2: Erste Chat-Session
Starten Sie eine interaktive KI-Coding-Session mit einem einzigen Befehl.
Demo 3: Batch-Verarbeitung
Mehrere KI-Aufgaben nacheinander verarbeiten – ideal für CI/CD-Pipelines.
Demo 4: Security-Scan
Vollständigen Projekt-Security-Scan ausführen und SARIF-Report für CI/CD generieren.
Demo 5: Automatisierter Code-Review
KI-Code-Review in CI ausführen und Verdict als PR-Kommentar posten.
Installation & Grundlagen
Vollständige Referenz aller Lurus Code CLI-Befehle. Erfahren Sie, wie Sie den KI-Coding-Agenten direkt im Terminal verwenden.