CLI-Referenz

Lurus 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 npm install -g @scramble-cloud/lurus-code-cli

📦

Installation & Grundlagen

CLI global via npm installieren und in Sekunden loslegen.

Install

npm install -g @scramble-cloud/lurus-code-cli

Usage

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

🌐

Enterprise Proxy Support

Lurus Code respektiert die Standard-Umgebungsvariablen HTTP_PROXY, HTTPS_PROXY und NO_PROXY für CLI-eigene Netzwerkverbindungen, einschließlich Streaming- und SSE-Antworten.

Umgebungsvariablen

Setzen Sie diese Variablen in der Shell, bevor Sie die CLI starten. NO_PROXY ist besonders wichtig für lokale Entwicklung und interne Hosts, die den Unternehmensproxy umgehen sollen.

HTTPS_PROXY Proxy-URL für HTTPS-Anfragen an die Lurus API und andere CLI-eigene HTTPS-Verbindungen.

HTTP_PROXY Proxy-URL für HTTP-Anfragen.

NO_PROXY Kommagetrennte Hosts, die den Proxy umgehen, z. B. localhost,127.0.0.1,::1,.company.local.

NODE_EXTRA_CA_CERTS Pfad zum Corporate-Root-CA-Zertifikat für TLS-Inspection.

Beispiele

Standard-Proxy

export HTTPS_PROXY=http://proxy.company.com:8080
export HTTP_PROXY=http://proxy.company.com:8080
export NO_PROXY=localhost,127.0.0.1,::1,.company.local

Proxy mit Zugangsdaten

export HTTPS_PROXY=http://user:pass@proxy.company.com:8080
# Sonderzeichen in Benutzernamen und Passwörtern URL-encoden

TLS-Inspection

export NODE_EXTRA_CA_CERTS=/path/to/corporate-root-ca.pem
lurus doctor

Diagnose

lurus doctor
lurus status
# Im Chat:
/doctor
/status

Diagnose

lurus doctor kann ohne Login ausgeführt werden und nutzt denselben fetch- und CLI-Netzwerkpfad wie die Laufzeit. /doctor im Chat zeigt dieselbe Diagnose plus Session-Informationen.

✓ lurus doctor testet API-Erreichbarkeit über konfigurierte Proxy- und Custom-CA-Einstellungen.
✓ /doctor ergänzt aktive Session-Details wie Modell, Modus und Session-ID.
✓ lurus status und /status zeigen den konfigurierten Proxy-Status, garantieren ohne Netzwerktest aber keine Verbindung.

Nicht unterstützt

SOCKSALL_PROXYNTLM/KerberosPAC/WPADmTLS-Client-Zertifikate

Sicherheitshinweise

! Proxy-Zugangsdaten können in der Proxy-URL angegeben werden. Sonderzeichen müssen URL-encoded werden; Zugangsdaten sollten nicht in Shell-History oder Skripten gespeichert werden.
! Bei TLS-Inspection muss NODE_EXTRA_CA_CERTS vor dem Start der CLI gesetzt werden. Node.js lädt diese Datei beim Prozessstart.

🔑

Authentifizierung

Registrieren, anmelden und Ihr Lurus Code-Konto verwalten.

CMD

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/code und 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/token ab 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).

Related: login status

CMD

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

Related: register logout

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

CMD

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

Related: login status

CMD

status

Zeigt den aktuellen Authentifizierungsstatus und Kontoinformationen an.

lurus 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.

Related: login logout

Output Fields

NameE-MailPlanAuth-TypAPI-URL

💬

Chat & Interaktion

Interaktive Sitzung starten oder einen einzelnen Prompt senden. chat ist der Standardbefehl.

CMD

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

Flag Short Description

--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

--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, acceptAllEdits, dangerouslySkipAllPermissions

--thinking <modus> — Thinking-Modus: on, adaptive, off

--effort <level> — Reasoning-Aufwand: minimal, low, medium, high, xhigh, max

--max-mode <status> — Max-Kontextmodus: on, off

--mode <modus> — Interaktionsmodus: agent, ask, plan

--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" --permission-mode dangerouslySkipAllPermissions

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 --mode plan

Nur-Lesen-Planungsmodus

Berechtigungsmodi

default Fragt vor jeder Tool-Nutzung

acceptAllEdits Dateiänderungen werden automatisch akzeptiert

dangerouslySkipAllPermissions Gewährt alle Berechtigungen automatisch; wird durch `disableDangerousTrust` blockiert

Interaktiver Modus – Tastaturkürzel

Geben Sie ? ein, um alle verfügbaren Kürzel anzuzeigen.

Tab Slash-Befehl-Autovervollständigung

↑ / ↓ Eingabeverlauf durchsuchen

Ctrl+C Aktuelle Operation abbrechen

Ctrl+R Verlauf rückwärts durchsuchen

Ctrl+L Bildschirm leeren

Ctrl+E Externen Editor für mehrzeilige Eingabe öffnen

!<befehl> Shell-Befehl direkt ausführen (z. B. !ls -la)

/help Alle Slash-Befehle anzeigen

📋

Stapelverarbeitung

Mehrere Prompts aus einer Textdatei sequenziell verarbeiten. Ideal für Skripte, Pipelines und die Automatisierung wiederkehrender Aufgaben.

CMD

batch

lurus batch <datei> [optionen]

Verarbeitet mehrere Prompts aus einer Textdatei sequenziell. Ideal für Skripte, Pipelines und die Automatisierung wiederkehrender Aufgaben.

Options

Flag Short Default Description

--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

0 Alle Prompts erfolgreich verarbeitet

1 Mindestens ein Prompt fehlgeschlagen

🔌

Erweiterungen & Anpassung

Lurus Code erweitert sich über dateibasierte Skills, Commands, Agents, Rules und Hooks sowie über Chat-Slash-Befehle. Projektweite Erweiterungen liegen unter ./.lurus/, persönliche Erweiterungen unter ~/.lurus/.

Erweiterungstypen

Skills Wiederverwendbare KI-Workflows aus Projekt-, User- oder gebündelten Skill-Verzeichnissen. Persistent oder nur für die aktuelle Session aktivierbar. /skills, /skillify

Custom Commands Markdown-definierte Slash-Commands für wiederholbare Prompts und Workflows. /commands

Agents Wiederverwendbare Subagents mit eigenem System-Prompt, Tools, Modell, Turn-Limit und persistentem Trust-Status. /agents

Rules Projekt- und User-Regeldateien neben `LURUS.md`, priorisierbar per Frontmatter. /rules

Hooks Automatisierung bei CLI-/Agent-Ereignissen über `.lurus/hooks.json` und Hook-Dateien. /create-hook, /hooks validate

Install GitHub-Pakete mit Skills und Agents installieren, listen, aktualisieren oder entfernen. /install

Interaktive Verwaltung

/install <github-url|owner/repo> Skill-/Agent-Paket aus GitHub installieren

/install bundle <url1> <url2> ... Mehrere Pakete installieren

/install list|remove|update Installierte Pakete anzeigen, entfernen oder aktualisieren

/agents list|show|run|trust|untrust Custom Agents anzeigen, freigeben und als Subagent ausführen

/commands Geladene eigene Slash-Commands anzeigen

/rules list|show|create Regeln anzeigen oder Projekt-Rule-Template erstellen

/create-hook <event> <name> [--ts] Hook-Boilerplate erstellen und in `.lurus/hooks.json` registrieren

/hooks validate Projekt-Hook-Konfiguration validieren

/mcp refresh-tools MCP-Tool-Registry und Session-Manifest neu laden

/memory clear|edit|sweep Projekt-Memory verwalten

Dateibasierte Erweiterungen

Skills

.lurus/skills/<name>/SKILL.md~/.lurus/skills/<name>/SKILL.md

Frontmatter: name, description, globs, alwaysApply, version, author, license, category, userInvokable, argumentHint

---
name: API Reviewer
description: Prüft REST-API-Änderungen gegen Projektstandards
globs:
  - "src/api/**/*.ts"
version: "1.0.0"
author: "Platform Team"
license: "MIT"
category: review
userInvokable: true
argumentHint: "src/api/users.ts"
---

Prüfe API-Routen, Request-/Response-Typen und Fehlerbehandlung.

Commands

.lurus/commands/<name>.md~/.lurus/commands/<name>.md

Frontmatter: description, allowedTools, model, argumentHint, disableModelInvocation

---
description: Prüft API-Design gegen Projektstandards
argumentHint: "src/api/users.ts"
model: sonnet
allowedTools:
  - Read
  - Grep
disableModelInvocation: false
---

Analysiere `$ARGUMENTS` und prüfe Routen, Typen und Fehlerbehandlung.

Agents

.lurus/agents/<name>.md~/.lurus/agents/<name>.md

Frontmatter: name, description, tools, model, maxTurns

---
name: Security Reviewer
description: Prüft Änderungen auf typische Security-Probleme
tools:
  - Read
  - Grep
  - Bash
model: sonnet
maxTurns: 12
---

Du bist ein fokussierter Security-Review-Subagent.

Rules

LURUS.md.lurus/LURUS.md.lurus/rules/<name>.md~/.lurus/LURUS.md~/.lurus/rules/<name>.md

Frontmatter: description, alwaysApply, priority, globs

---
description: Security-Standards für Backend-Code
alwaysApply: true
priority: 10
---

- Validiere alle externen Eingaben serverseitig.
- Nutze parametrisierte Datenbankabfragen.

Hooks

Hooks werden in .lurus/hooks.json bzw. ~/.lurus/hooks.json konfiguriert. /create-hook erstellt Projekt-Hooks unter ./.lurus/hooks/ als Shell-Datei (.sh, ausführbar) oder TypeScript-Datei (.ts, via npx tsx) und trägt sie in ./.lurus/hooks.json ein. Gültige Hook-Events laut Code: SessionStart, SessionEnd, PreToolUse, PostToolUse, PostToolUseFailure, UserPromptSubmit, SubagentStart, SubagentStop, Stop, PreCompact, ConfigChange, TaskCompleted, Notification.

{
  "PreToolUse": [
    {
      "matcher": "Bash",
      "hooks": [
        {
          "type": "command",
          "command": "bash .lurus/hooks/block-dangerous-bash.sh",
          "timeout": 30000
        }
      ]
    }
  ],
  "PostToolUse": [
    {
      "matcher": "*",
      "hooks": [
        {
          "type": "command",
          "command": "npx tsx .lurus/hooks/log-tool.ts"
        }
      ]
    }
  ]
}

🔗

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).

CMD

mcp add

lurus mcp add <name> (--command <cmd> | --url <url>) [optionen]

Fügt einen neuen MCP-Server zur Konfiguration hinzu. Nutze `--command` für lokale stdio-Server oder `--url` für entfernte HTTP/SSE-Server.

--command <cmd> Befehl zum Starten eines lokalen stdio-Servers

--url <url> Entfernter MCP-Endpunkt

--type <typ> Transporttyp: stdio, http oder sse

--args <args...> Argumente nur für --command-Server

--env <paare...> Umgebungsvariablen im Format SCHLÜSSEL=WERT nur für --command-Server

--cwd <pfad> Arbeitsverzeichnis nur für --command-Server

--header <paare...> HTTP-Header im Format SCHLÜSSEL=WERT nur für --url-Server; Werte werden sicher gespeichert

--timeout <ms> Startup-Timeout in Millisekunden

--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 /

Lokalen Dateisystem-Server hinzufügen

lurus mcp add github --url https://mcp.github.com/mcp --type http --header Authorization=Bearer:$GITHUB_TOKEN

Entfernten GitHub-MCP-Server per URL hinzufügen

lurus mcp add sentry --url https://mcp.sentry.dev/sse --type sse --project

Projektbezogenen SSE-Server hinzufügen

lurus mcp add my-server --command ./server.sh --trust

Vertrauenswürdiger lokaler Server (keine Bestätigung bei Tool-Nutzung)

Genau eines von --command oder --url angeben.
--args, --env und --cwd funktionieren nur mit --command; --header nur mit --url.
headerRefs, includeTools und excludeTools sind Settings-/Runtime-Konfiguration, keine mcp add-Flags.

CMD

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

CMD

mcp list

lurus mcp list

Listet alle konfigurierten MCP-Server auf (global und projektspezifisch).

⚙️

CLI-Verwaltung

CLI aktuell halten und Befehle mit integrierter Hilfe inspizieren.

CMD

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/code aus, wenn ein Update verfügbar ist.

Examples

lurus update --check

Prüfen, ob ein Update verfügbar ist

lurus update

Update installieren

lurus --help

Verfügbare Befehle anzeigen

lurus chat --help

Flags für einen einzelnen Befehl anzeigen

🚀

CI/CD-Befehle

Diese Befehle sind für automatisierte Pipelines optimiert: headless (kein Browser), mit definierten Exit-Codes und optionaler GitHub-Integration.

CI/CD

security-ci

Führt einen KI-gestützten Security-Scan im CI/CD-Modus aus. Erfordert den Pro+-Plan. 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

0 Keine blockierenden Findings (unterhalb des Schwellwerts)

1 Blockierende Findings gefunden

2 Scan fehlgeschlagen (technischer Fehler)

3 Guthaben erschöpft (Teilergebnisse)

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

Related: code-review-ci

GitHub Actions Integration

- name: Lurus Security Scan
  run: lurus security-ci --diff --pr-comments
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

→ GITHUB_STEP_SUMMARY – Markdown-Tabelle mit allen Findings

→ GITHUB_OUTPUT – Variablen total_findings, blocking_findings, passed

CI/CD

code-review-ci

Führt einen KI-gestützten Code-Review im CI/CD-Modus aus. Erfordert den Pro+-Plan. 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

0 Keine blockierenden Findings

1 Blockierende Findings gefunden

2 Review fehlgeschlagen (technischer Fehler)

3 Guthaben erschöpft

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

Related: security-ci

GitHub Actions Integration

- 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. Code-Stand: 69 registrierte Handler plus 8 registrierte Aliase.

/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: Modell, Modus, Session-ID, Turns, Kosten, Token-Nutzung, Kontextdateien und Proxy-Status.

/cost

Kompakte Anzeige von Token-Nutzung, Sitzungskosten und Kontostand.

/stats

Detaillierte Sitzungsstatistiken: Dauer, Modell, Modus, Turns, Tokens, Kontextdateien und geladene Tools.

/doctor

Umgebungsdiagnose mit Node.js, Git, Arbeitsverzeichnis, API-/Proxy-Pfad, Custom-CA-Status, Modell, Modus, Session, CLI-Version und Betriebssystem.

/report

Erstellt einen Sitzungsanalysebericht.

/report HTML-Bericht öffnen

/report --json JSON-Export nach lurus-report.json

/report --json <pfad> 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

⚙️

Konfiguration & Projekt

/config

Zeigt aktuelle Konfiguration: API-URL, Modell, Prompt-Caching, Max-Tokens, Fallback-/Utility-/Compaction-Modell, Modell-Aliase, Notifications, Trust-Sperren und geladene Kontextquellen.

/init

Analysiert das aktuelle Projekt und generiert eine LURUS.md mit Projektbeschreibung, Tech-Stack, Struktur, Konventionen, Build-/Test-/Lint-Befehlen und Architekturentscheidungen.

/rules

Verwaltet Projektregeln aus .lurus/rules/*.md, ~/.lurus/rules/*.md und LURUS-Kontextdateien.

/rules Alle Regeln auflisten

/rules list Alias/Explizite Listenansicht

/rules show <name> Regelinhalt anzeigen

/rules create [name] Neue Projektregel mit Template erstellen

Frontmatter: description, alwaysApply, priority und optional globs.

/permissions

Verwaltet persistente Berechtigungen, die durch dauerhafte Zustimmung bei Tool-Anfragen entstehen.

/permissions Gespeicherte Berechtigungen anzeigen

/permissions clear Projektberechtigungen zurücksetzen

/permissions clear global Globale Berechtigungen zurücksetzen

/trust

Zeigt oder schaltet den gefährlichen Trust-Modus der aktuellen Session. Aktivierung erfordert die Bestätigungsphrase I understand the risks und kann durch disableDangerousTrust blockiert sein.

/trust Aktuellen Status anzeigen

/trust on Permission-Prüfungen für diese Session deaktivieren

/trust off Normale Permission-Prüfungen wieder aktivieren

🗂️

Sitzungsverwaltung

/resume

Zeigt frühere Sitzungen für das aktuelle Projekt und ermöglicht deren Fortsetzung.

/resume Alle Sitzungen anzeigen

/resume <suche> Sitzungen nach Stichwort filtern

/sessions

Verwaltet gespeicherte Sitzungen.

/sessions Sitzungen für aktuelles Projekt

/sessions here Sitzungen im aktuellen Verzeichnis

/sessions all Alle Sitzungen

/sessions delete <id> Sitzung löschen

/recall

Durchsucht gespeicherte Sitzungen und kann gefundene Sitzungen laden.

/recall <query> Sitzungen nach Inhalt finden

/recall --load <id> Gefundene Sitzung laden

/clear

Löscht den Gesprächsverlauf der aktuellen Sitzung.

/save

Exportiert die aktuelle Sitzung als Markdown-Datei.

/save Standarddatei mit Zeitstempel

/save <pfad> An bestimmtem Pfad speichern

/rewind

Setzt Chat-Nachrichten oder Code-Änderungen selektiv zurück.

/rewind chat Letzte Nachrichten entfernen

/rewind code Letzte Dateiänderungen per Checkpoint rückgängig machen

/memory

Zeigt und verwaltet die projektlokale Auto-Memory unter .lurus/memory/.

/memory Index und Topic-Dateien anzeigen

/memory clear Projekt-Memory löschen

/memory edit MEMORY.md im Editor öffnen

/memory sweep Konsolidierung sofort starten

📎

Kontextverwaltung

/context

Zeigt die Kontextfenster-Auslastung: System-Prompt, Verzeichnisbaum, Gesprächs-Tokens, verwendet vs. verbleibend.

/detach / /drop

Entfernt angehängte Dateien oder Ordner aus dem aktuellen Prompt-Kontext. /drop ist Alias.

/detach Alle Anhänge entfernen

/detach <nummer> Anhang per Index entfernen

/drop <name-oder-pfad> Alias für `/detach`

/copy

Kopiert die letzte KI-Antwort in die Zwischenablage.

/paste

Fügt ein Bild aus der Zwischenablage in den Chat ein.

/compress / /compact

Komprimiert die Konversationshistorie per LLM; /compact ist Alias.

/refresh / /reindex

Baut den Datei-Suchindex für @-Autocomplete im aktuellen Workspace neu auf; /reindex ist Alias.

🔍

Code-Indizierung

/indexing

Verwaltet die semantische Code-Indizierung (RAG).

/indexing Status anzeigen

/indexing on Indizierung aktivieren

/indexing off Indizierung deaktivieren

/indexing rebuild Index neu aufbauen

/indexing clear Lokalen Index und Backend-Quota zurücksetzen

🐙

Git & GitHub

/commit

Generiert KI-Commit-Nachrichten für staged Changes oder verwendet eine angegebene Nachricht.

/commit KI generiert Commit-Nachricht

/commit "meine Nachricht" Direkt committen

/create-pr

Erstellt einen Pull Request mit KI-generiertem Titel und Beschreibung.

/create-pr PR erstellen

/create-pr --draft Draft-PR

/create-pr --reviewer <name> Reviewer hinzufügen

/create-pr --label <label> Label hinzufügen

/fix-issue

Analysiert und behebt ein GitHub-Issue automatisch.

/fix-issue 42

/analyze-issue

Analysiert ein GitHub-Issue nur lesend.

/analyze-issue 42

/fix-pr

Behebt automatisch offene PR-Review-Kommentare des aktuellen PRs.

/fix-pr

🧪

Tools, Tests & Medien

/tools

Listet verfügbare Agenten-Tools auf.

/tools Nur Namen

/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

/docs

Startet einen Agenten-Workflow zur Dokumentationsgenerierung.

/docs Projekt dokumentieren

/docs <ziel> Datei, Ordner, Modul oder Freitext-Ziel dokumentieren

/image / /img

Generiert ein Bild aus einem Prompt und speichert es unter .lurus/images/.

/image <prompt> Bild generieren

/image --model=<provider> <prompt> Provider erzwingen

/image --aspect=landscape <prompt> Seitenverhältnis wählen

/image models --refresh Providerliste aktualisieren

/image-edit / /img-edit

Bearbeitet ein vorhandenes Bild mit einem Prompt.

/image-edit <pfad> <prompt> Bild bearbeiten

/image-edit --model=<provider> <pfad> <prompt> Edit-Provider erzwingen

/img-edit <pfad> <prompt> Alias

/video / /vid

Generiert ein KI-Video unter .lurus/videos/; --seconds=4|8|12 ist erforderlich.

/video --seconds=4 <prompt> Video im Hochformat

/video --seconds=12 --landscape <prompt> Querformat

/video --seconds=8 --ref=<bildpfad> <prompt> Referenzbild verwenden

/test

Führt Tests aus.

/test Standardtestbefehl

/test npm run test:unit Eigener Befehl

/test jest auth.spec.ts Bestimmte Testdatei

/tdd

TDD-Workflow und TDD-Guard.

/tdd <feature> TDD-Zyklus starten

/tdd on Warn-Modus

/tdd strict Strikter Modus

/tdd off Deaktivieren

/tdd-implement

Implementiert Code für bereits vorhandene, fehlschlagende Tests.

/tdd-implement

/edit

Öffnet $EDITOR für mehrzeilige Eingaben und sendet den gespeicherten Inhalt als Prompt.

/diff

Zeigt alle Dateiänderungen seit Sitzungsstart.

/undo

Macht letzte Dateiänderungen checkpoint-basiert rückgängig.

🤖

Modell & Modus

/model

Zeigt oder ändert das KI-Modell der aktuellen Session.

/model Aktuelles Modell anzeigen

/model sonnet Modell wechseln

/utilitymodel

Zeigt oder ändert das Utility-Modell für interne Aufgaben.

/utilitymodel Anzeigen

/utilitymodel <modell> Setzen

/utilitymodel clear Zurücksetzen

/compactionmodel

Zeigt oder ändert das Modell für Kontextkomprimierung und Memory-Extraktion.

/compactionmodel Anzeigen

/compactionmodel <modell> Setzen

/compactionmodel clear Zurücksetzen

/mode

Wechselt den Interaktionsmodus.

/mode agent Implementierungsmodus

/mode plan Nur-Lesen-Planung

/mode ask Nur-Lesen-Q&A

/mode debug Systematisches Debugging

/agent

Shortcut für /mode agent, optional direkt mit Prompt.

/agent In agent wechseln

/agent <prompt> Modus wechseln und Prompt senden

/plan

Shortcut für /mode plan, optional direkt mit Prompt.

/plan In plan wechseln

/plan <prompt> Planungs-Prompt senden

/ask

Shortcut für /mode ask, optional direkt mit Prompt.

/ask In ask wechseln

/ask <prompt> Frage senden

/debug

Shortcut für /mode debug, optional direkt mit Prompt.

/debug In debug wechseln

/debug <prompt> Debug-Prompt senden

/max

Schaltet Max-Modus um; Auto-Komprimierung wird später ausgelöst.

/thinking

Schaltet erweitertes Denken ein oder aus.

/thinking Aktivieren

/thinking off Deaktivieren

/effort

Zeigt oder setzt Reasoning-Effort: minimal, low, medium, high, xhigh, max.

/effort Status anzeigen

/effort medium Mittleren Effort setzen

/effort max Maximalen Effort setzen

/costsaving

Zeigt oder ändert den Cost-Saving-Modus für Subagents und Orchestrierungsrollen.

/costsaving Status

/costsaving on Aktivieren

/costsaving off Deaktivieren

/displaycost

Zeigt oder ändert, ob EUR-Kosten nach Turns und am Session-Ende ausgegeben werden.

/displaycost Status

/displaycost on Aktivieren

/displaycost off Deaktivieren

🔌

Erweiterungen & MCP

/install

Installiert und verwaltet GitHub-Pakete mit Skills und Agents.

/install <github-url> GitHub-URL installieren

/install <owner/repo> GitHub-Kurzform installieren

/install bundle <url1> <url2> ... Mehrere Pakete installieren

/install list Installierte Pakete anzeigen

/install remove <name> Paket entfernen

/install update [name] Paket aktualisieren oder Hinweis für Einzelupdates anzeigen

/mcp

Zeigt MCP-Server-Status, verfügbare Tools und verwaltet das Tool-Manifest.

/mcp Server und Tools anzeigen

/mcp restart <name> Server neu starten

/mcp refresh-tools Tool-Registry und Manifest aktualisieren

/commands

Listet geladene eigene Slash-Commands aus .lurus/commands/*.md und ~/.lurus/commands/*.md.

/agents

Verwaltet Custom Agents. Agents sind standardmäßig untrusted und müssen vor /agents run freigegeben werden.

/agents list Agents anzeigen

/agents show <name> Details anzeigen

/agents run <name> <prompt> Agent als Subagent starten

/agents trust <name> Persistent vertrauen

/agents untrust <name> Trust entfernen

/skills

Verwaltet Skills aus gebündelten, projektlokalen und globalen Skill-Verzeichnissen.

/skills Skills mit Status anzeigen

/skills show <name> Metadaten und Inhalt anzeigen

/skills activate <name> Persistent aktivieren

/skills deactivate <name> Persistent deaktivieren

/skills activate-session <name> Nur diese Session aktivieren

/skills deactivate-session <name> Nur diese Session deaktivieren

/skills audit Skills prüfen

/skillify

Konvertiert die aktuelle Session in eine wiederverwendbare SKILL.md und fragt Projekt- oder Personal-Speicherort ab.

/create-hook

Erstellt Hook-Boilerplate unter ./.lurus/hooks/ und registriert ihn in ./.lurus/hooks.json.

/create-hook PreToolUse block-dangerous-bash Shell-Hook erstellen

/create-hook PostToolUse audit/log-tool --ts TypeScript-Hook erstellen

SessionStart Session startet

SessionEnd Session endet

PreToolUse Vor Tool-Ausführung

PostToolUse Nach erfolgreicher Tool-Ausführung

PostToolUseFailure Nach fehlgeschlagener Tool-Ausführung

UserPromptSubmit Nach Nutzer-Prompt

SubagentStart Subagent startet

SubagentStop Subagent endet

Stop Agent stoppt

PreCompact Vor Kontextkomprimierung

ConfigChange Gültig in hooks.json, kein Template

TaskCompleted Gültig in hooks.json, kein Template

Notification Gültig in hooks.json, kein Template

/hooks

Validiert die Projekt-Hook-Konfiguration ./.lurus/hooks.json.

/hooks validate hooks.json validieren

🛡️

Review & Sicherheit

/review / /code-review

Führt einen KI-Code-Review aus; /code-review ist Alias.

/review Aktuellen Diff reviewen

/review --full Gesamtes Projekt

/review --staged Nur staged Changes

/review --diff-base <ref> Gegen Ref vergleichen

/review --html HTML-Bericht

/review --json <path> JSON-Export

/review --model <alias> Modell überschreiben

/security-review / /scan

Führt einen Security-Scan aus; /scan ist Alias.

/scan Projekt scannen

/scan --diff Nur geänderte Dateien

/scan --diff-base <ref> Gegen Ref vergleichen

/scan --html HTML-Bericht

/scan --json <path> JSON-Export

/scan --model <alias> 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> Refactoring

/orchestrate security <prompt> Security-Workflow

/orchestrate review <prompt> Code-Review

/orchestrate auto <spezifikation> Autonomer Loop

/ide

Verwaltet die IDE-Verbindung.

/ide Status anzeigen

/ide enable Mit VS Code verbinden

/ide disable Verbindung trennen

/quit / /exit

Beendet die Chat-Session. Diese Befehle werden direkt im Chat-Loop abgefangen.

⚡

Schnellreferenz

CLI-Befehle (Top-Level)

Command Category Description

lurus

Chat Startet den Standardbefehl `chat` interaktiv.

lurus chat [prompt...]

Chat Interaktive Session starten oder Prompt übergeben.

lurus chat -p "..."

Chat Einzelprompt senden und beenden.

lurus chat -c

Chat Letzte Session für das aktuelle Projekt fortsetzen.

lurus chat -r <id>

Chat Bestimmte Session per ID fortsetzen.

lurus batch <file>

Batch Mehrere Prompts aus einer Datei verarbeiten.

lurus register

Auth Neues Konto erstellen.

lurus login [--api-key|--email]

Auth Anmelden per Browser, API-Key oder E-Mail/Passwort.

lurus logout [--all]

Auth Aktuelle Session oder alle Sessions abmelden.

lurus status

Auth Authentifizierungs- und Kontostatus anzeigen.

lurus doctor

Diagnose Umgebung, Proxy und Konnektivität prüfen.

lurus mcp

MCP MCP-Server-Verwaltung; Subcommands siehe `add`, `remove`, `list`.

lurus mcp add <name>

MCP MCP-Server hinzufügen.

lurus mcp remove <name>

MCP MCP-Server entfernen.

lurus mcp list

MCP Konfigurierte MCP-Server auflisten.

lurus update [--check]

Verwaltung CLI aktualisieren oder nur auf Updates prüfen.

lurus security-ci

CI/CD Security-Scan headless mit Exit-Codes ausführen.

lurus code-review-ci

CI/CD Code-Review headless mit Exit-Codes ausführen.

lurus ext-bridge

Intern Versteckte NDJSON-Pipe für IDE-Erweiterungen.

lurus --help

Hilfe Commander-Hilfe anzeigen.

Slash-Befehle (im Chat)

Session & Info

/help, /status, /cost, /stats, /doctor, /report, /changelog, /mermaid, /quit, /exit

Konfiguration & Regeln

/config, /init, /rules, /rules show <name>, /rules create [name], /permissions, /permissions clear, /trust, /trust on, /trust off

Sessions & Memory

/resume, /sessions, /sessions delete <id>, /sessions all, /recall, /recall --load <id>, /clear, /save, /save <path>, /rewind, /memory, /memory clear, /memory edit, /memory sweep

Kontext

/context, /detach, /drop, /copy, /paste, /compress, /compact, /refresh, /reindex

Code-Indexierung

/indexing, /indexing on, /indexing off, /indexing rebuild, /indexing clear

Git & GitHub

/commit, /create-pr, /fix-issue, /analyze-issue, /fix-pr

Tools, Tests & Medien

/tools, /web, /docs, /image, /img, /image-edit, /img-edit, /video, /vid, /test, /tdd, /tdd-implement, /edit, /diff, /undo

Modell & Modus

/model, /utilitymodel, /compactionmodel, /mode, /agent, /plan, /ask, /debug, /max, /thinking, /effort, /costsaving, /displaycost

Erweiterungen & MCP

/install, /install bundle, /install list, /install update [name], /install remove <name>, /commands, /agents, /agents list, /agents show <name>, /agents run <name> <prompt>, /agents trust <name>, /agents untrust <name>, /skills, /skills show <name>, /skills activate <name>, /skills deactivate <name>, /skills activate-session <name>, /skills deactivate-session <name>, /skills audit, /mcp, /mcp restart <name>, /mcp refresh-tools, /skillify

Hooks

/create-hook <event> <name> [--ts], /hooks validate

Review & Security

/review, /code-review, /security-review, /scan

Orchestrierung & IDE

/orchestrate, /ide, /ide enable, /ide disable

🗂️

✨

Best Practices & Code-Beispiele

Praktische Beispiele, häufige Fehler und Tipps für die optimale Nutzung der Lurus Code CLI.

🔑

Authentifizierung

BEST PRACTICE

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

bash

# 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

bash

# 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.

BEST PRACTICE

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

bash

lurus login
lurus status
# ✓ Authenticated
#   Name:  Max Mustermann
#   Plan:  pro

💡

Wenn lurus status "Not authenticated" anzeigt, führen Sie lurus login erneut aus oder prüfen Sie Ihren API-Key.

BEST PRACTICE

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

bash

# Von allen Geräten abmelden (z. B. beim Laptop-Wechsel)
lurus logout --all

# Dann auf dem neuen Gerät anmelden
lurus login

💬

Chat & Interaktion

BEST PRACTICE

--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

bash

# Architektur analysieren ohne Änderungen
lurus chat -p "Erkläre den Authentifizierungsfluss" --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

bash

# 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.

BEST PRACTICE

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

bash

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

bash

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.

BEST PRACTICE

Sessions fortsetzen statt neu starten

Sessions bewahren Kontext und Verlauf. Fortsetzen ist effizienter als jedes Mal neu zu starten.

✅ Richtig – Letzte Session fortsetzen

bash

# 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.

BEST PRACTICE

--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

bash

# 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

BEST PRACTICE

Prompt-Dateien mit Kommentaren strukturieren

Verwenden Sie Kommentare (#) und klare Trennzeichen (---), um Batch-Dateien wartbar zu gestalten.

✅ Richtig – Gut strukturierte Prompt-Datei

bash

# 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

bash

Analysiere auth.service.ts
---
Analysiere user.service.ts
---
Erstelle README

💡

Verwenden Sie -m haiku für einfache Dokumentationsaufgaben, um Kosten erheblich zu reduzieren.

BEST PRACTICE

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

bash

# 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

bash

# Ein fehlgeschlagener Prompt bricht den gesamten Batch ab
lurus batch doc-prompts.txt
# Exit-Code 1 = Pipeline schlägt sofort fehl

BEST PRACTICE

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

bash

# 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.

🔌

Erweiterungen & Anpassung

BEST PRACTICE

Projekt-Erweiterungen in .lurus/ ablegen

Nutzen Sie projektlokale Dateien für Team-Workflows, damit Skills, Commands, Agents, Rules und Hooks mit der Codebasis versioniert werden.

✅ Richtig – Projektlokale Erweiterungsdateien

bash

# Eigener Slash-Command
.lurus/commands/security-review.md

# Projekt-Skill
.lurus/skills/api-review/SKILL.md

# Projekt-Agent
.lurus/agents/migration-reviewer.md

# Projektregeln und Hooks
.lurus/rules/coding-style.md
.lurus/settings.json

❌ Suboptimal – Versteckter User-only Workflow

bash

# Nur auf einer Maschine verfügbar
~/.lurus/commands/security-review.md
# Teammitglieder laden diesen Command nicht automatisch

💡

Nutzen Sie ~/.lurus/ nur für persönliche Workflows, die das Projekt nicht beeinflussen sollen.

BEST PRACTICE

Slash-Befehle für interaktive Verwaltung nutzen

Verwalten Sie installierte Skill-Pakete und Runtime-Erweiterungen innerhalb einer aktiven Chat-Session.

✅ Richtig – Erweiterungen im Chat verwalten

bash

lurus chat
> /install https://github.com/org/skill-package
> /skills
> /commands
> /create-hook
> /hooks

🔗

MCP-Server-Verwaltung

BEST PRACTICE

--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

bash

# 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

bash

# 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.

BEST PRACTICE

Umgebungsvariablen für Secrets verwenden

API-Token und Secrets über --env übergeben, niemals im Script hardcoden.

✅ Richtig – Secrets über Umgebungsvariablen

bash

# 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

bash

# Niemals Token hardcoden!
lurus mcp add github \
  --command npx \
  --args @modelcontextprotocol/server-github \
  --env GITHUB_TOKEN=ghp_abc123xyz  # Im Shell-Verlauf sichtbar!

BEST PRACTICE

Projektbereich für projektspezifische Tools nutzen

Datenbankserver, projektspezifische APIs und lokale Tools sollten pro Projekt konfiguriert werden.

✅ Richtig – Projektspezifischer MCP-Server

bash

# 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

BEST PRACTICE

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

bash

# 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

bash

# 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.

BEST PRACTICE

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

bash

# 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.

BEST PRACTICE

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

bash

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

BEST PRACTICE

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

bash

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

BEST PRACTICE

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

bash

# 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.

BEST PRACTICE

/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

bash

# 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

bash

# Verliert allen Kontext und Verlauf!
> /quit
lurus chat  # Neue Session – KI hat keine Erinnerung an vorherige Arbeit

BEST PRACTICE

/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

bash

# 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...

BEST PRACTICE

/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

bash

# 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

bash

# Zu komplex für einen einzelnen Prompt – inkonsistente Ergebnisse
> Implementiere vollständigen OAuth2-Login mit Google und GitHub, 
  inklusive Tests, Dokumentation und Fehlerbehandlung

BEST PRACTICE

/thinking für komplexe Architekturentscheidungen aktivieren

Extended Thinking für komplexe Probleme aktivieren, die tiefe Analyse erfordern.

✅ Richtig – Extended Thinking für komplexe Probleme

bash

# 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

Error: Not authenticated

Keine gültige Session oder abgelaufener Token.

✓

Führen Sie `lurus login` aus oder setzen Sie `LURUS_API_KEY` als Umgebungsvariable.

bash

# Lösung 1: Neu anmelden
lurus login

# Lösung 2: API-Key verwenden
export LURUS_API_KEY=lurus_ihr_key
lurus status

ERROR

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.

bash

# Im Batch-Modus: Rate-Limit-Fehler überspringen
lurus batch prompts.txt --continue-on-error

# Guthaben prüfen
lurus status
# Balance: 0,50 € (niedrig!)

ERROR

Kontextfenster voll (100%)

Der Konversationsverlauf ist zu lang.

✓

Nutzen Sie `/compress`, um den Verlauf zusammenzufassen, oder `/clear` für einen Neustart.

bash

# Option 1: Komprimieren (bewahrt Kontext)
> /compress

# Option 2: Löschen (verliert Verlauf)
> /clear

# Option 3: Max-Modus aktivieren, um Komprimierung zu verzögern
> /max

ERROR

Exit-Code 2: Scan fehlgeschlagen (technischer Fehler)

Netzwerkfehler, Authentifizierungsproblem oder interner Fehler.

✓

Authentifizierungsstatus und Netzwerkverbindung mit `lurus doctor` prüfen. Mit `--debug` erhalten Sie befehlsspezifische Details.

bash

# Authentifizierung prüfen
lurus status

# Netzwerk-, Proxy- und CA-Konfiguration ohne Login diagnostizieren
lurus doctor

# Mit Debug-Ausgabe ausführen
lurus security-ci --debug

# Prüfen ob das Problem temporär ist
lurus update --check  # Ist die CLI aktuell?

ERROR

Erweiterung nicht geladen

Die Datei liegt im falschen Bereich, hat ungültiges Frontmatter oder die Chat-Session wurde vor dem Erstellen der Datei gestartet.

✓

Projekt-/User-Pfade prüfen und geladene Elemente im Chat inspizieren.

bash

# Projektlokaler Command
.lurus/commands/security-review.md

# Projektlokaler Skill
.lurus/skills/api-review/SKILL.md

# Im Chat: geladene Erweiterungen prüfen
> /skills
> /commands
> /hooks

ERROR

MCP-Server: connection refused

Serverprozess konnte nicht gestartet werden oder Port ist blockiert.

✓

Server mit `/mcp restart <name>` neu starten und Logs prüfen.

bash

# 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

EXAMPLE

Vollständiger PR-Workflow

Von der Feature-Entwicklung bis zum gemergten PR – vollständig automatisiert.

bash

# 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

EXAMPLE

Automatisierter nächtlicher Qualitätsbericht

Eine vollständige Qualitätspipeline, die jede Nacht läuft und Berichte generiert.

bash

# 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

EXAMPLE

Multi-Repository Security-Audit

Mehrere Repositories parallel mit einer Batch-Datei scannen.

bash

# 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

bash – run

# 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

EXAMPLE

Interaktive Session mit vollständigem MCP-Setup

Eine vollständig konfigurierte Session mit GitHub-, Filesystem- und Datenbanktools.

bash

# 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.

WORKFLOW 1 · Authentifizierung

Demo 1: Login & Authentifizierung

Authentifizieren Sie sich in Sekunden per Browser-OAuth.

lurus login

WORKFLOW 2 · Chat

Demo 2: Erste Chat-Session

Starten Sie eine interaktive KI-Coding-Session mit einem einzigen Befehl.

lurus chat

WORKFLOW 3 · Batch

Demo 3: Batch-Verarbeitung

Mehrere KI-Aufgaben nacheinander verarbeiten – ideal für CI/CD-Pipelines.

lurus batch

WORKFLOW 4 · Security

Demo 4: Security-Scan

Vollständigen Projekt-Security-Scan ausführen und SARIF-Report für CI/CD generieren.

lurus security-ci

WORKFLOW 5 · Code-Review

Demo 5: Automatisierter Code-Review

KI-Code-Review in CI ausführen und Verdict als PR-Kommentar posten.

lurus code-review-ci

Installation & Grundlagen

Vollständige Referenz aller Lurus Code CLI-Befehle. Erfahren Sie, wie Sie den KI-Coding-Agenten direkt im Terminal verwenden.

Jetzt starten CLI Features →