Crush: KI-Programmierassistent für Endgeräte mit integrierter LSP- und Multimodell-Umschaltung

Crush ist ein KI-Programmierassistent, der im Terminal läuft und vom Charmbracelet-Team entwickelt wurde. Durch die Integration des Large Language Model (LLM) unterstützt Crush mehrere Modelle, zwischen denen der Benutzer flexibel wechseln kann, sowie das Language Server Protocol (LSP) für den Codekontext und Erweiterungen des Model Context Protocol (MCP). Kompatibel mit einer Vielzahl von Betriebssystemen, einschließlich macOS, Linux und Windows, für Entwickler, die ein Terminal bevorzugen, hat Crush ein klares Design, das sich auf Benutzerfreundlichkeit und Leistung konzentriert, und wurde entwickelt, um die Codierung effizienter zu machen.

Funktionsliste

• Unterstützung für mehrere Large Language Models (LLMs) wie OpenAI, Anthropic oder native Modelle (z.B. Ollama), mit der Möglichkeit, das Modell auf halbem Weg zu wechseln.
• Integration des Language Server Protocol (LSP), das Codevervollständigung, Syntaxprüfung und andere Funktionen bietet.
• Unterstützt das Model Context Protocol (MCP) und erweitert die Funktionalität über HTTP, stdio oder SSE.
• Bietet eine Multi-Session-Verwaltung, die es ermöglicht, zwischen Projekten zu wechseln und den Kontext beizubehalten.
• Unterstützt die Ausführung auf allen Plattformen, einschließlich macOS, Linux, Windows (PowerShell und WSL), FreeBSD und mehr.
• Bietet flexible Konfigurationsdateien, die die Konfiguration auf Projektebene oder global unterstützen.
• Eine Liste der von der Gemeinschaft unterstützten Modelle (Catwalk), um es den Benutzern zu erleichtern, Modelle hinzuzufügen oder zu aktualisieren.
• Bietet Code-Generierung und Debugging-Funktionen zur Optimierung von End-to-End-Workflows.

Hilfe verwenden

Einbauverfahren

Crush unterstützt mehrere Installationsmethoden für verschiedene Betriebssysteme und Paketmanager. Nachfolgend finden Sie die detaillierten Installationsschritte:

Installation über Homebrew (macOS/Linux)

1. Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:

   brew install charmbracelet/tap/crush
   

2. Warten Sie, bis die Installation abgeschlossen ist, und geben Sie crush --version Überprüfen Sie, ob die Installation erfolgreich war.

Installation über NPM (plattformübergreifend)

1. Stellen Sie sicher, dass Node.js installiert ist.
2. Läuft im Terminal:

   npm install -g @charmland/crush
   

3. Überprüfen Sie die Version:crush --version.

Installation über Arch Linux

1. Verwenden Sie den Yay Package Manager:

   yay -S crush-bin
   

2. Überprüfen Sie die Installation:crush --version.

Installation über Nix

1. Führen Sie den folgenden Befehl aus:

   nix run github:numtide/nix-ai-tools#crush
   

2. oder über NUR installiert:

   nix-channel --add https://github.com/nix-community/NUR/archive/main.tar.gz nur
   nix-channel --update
   nix-shell -p '(import <nur> { pkgs = import <nixpkgs> {}; }).repos.charmbracelet.crush'
   

Installation über Debian/Ubuntu

1. Fügen Sie die Charm-Softwarequelle hinzu:

   sudo mkdir -p /etc/apt/keyrings
   curl -fsSL https://repo.charm.sh/apt/gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/charm.gpg
   echo "deb [signed-by=/etc/apt/keyrings/charm.gpg] https://repo.charm.sh/apt/ * *" | sudo tee /etc/apt/sources.list.d/charm.list
   

2. Aktualisieren und installieren:

   sudo apt update && sudo apt install crush
   

Installation über Fedora/RHEL

1. Fügen Sie das Yum-Repository hinzu:

   echo '[charm] name=Charm baseurl=https://repo.charm.sh/yum/ enabled=1 gpgcheck=1 gpgkey=https://repo.charm.sh/yum/gpg.key' | sudo tee /etc/yum.repos.d/charm.repo
   

2. Crush installieren:

   sudo yum install crush
   

Überprüfen der Installation

Nachdem die Installation abgeschlossen ist, führen Sie crush --version Überprüfen Sie die Versionsinformationen. Wenn die Versionsnummer angezeigt wird, war die Installation erfolgreich.

API-Schlüssel konfigurieren

Damit das große Sprachmodell ordnungsgemäß funktioniert, muss Crush mit einem API-Schlüssel konfiguriert werden. Nachfolgend finden Sie die Konfigurationsschritte:

1. Abrufen des API-Schlüssels:
   • Zu den unterstützten Modellanbietern gehören OpenAI, Anthropic, Groq oder OpenRouter.
   • Besuchen Sie die offizielle Website des Anbieters, um sich zu registrieren und den API-Schlüssel zu erhalten.
2. Konfigurieren Sie den Schlüssel:
   • Starten Sie es in einem Terminal crush config Rufen Sie den Konfigurationsmodus auf.
   • Geben Sie den API-Schlüssel ein und speichern Sie, wenn Sie dazu aufgefordert werden.
3. Unterstützung für lokale Modelle:
   • Wenn Sie ein lokales Modell (z. B. Ollama) verwenden, müssen Sie die OpenAPI-konforme Schnittstelle konfigurieren. Beispiel:

     {
     "$schema": "https://charm.land/crush.json",
     "providers": {
     "ollama": {
     "type": "openai",
     "base_url": "http://127.0.0.1:11434/v1",
     "api_key": "ollama",
     "models": [
     {
     "id": "devstral",
     "name": "devstral",
     "context_window": 131072
     }
     ]
     }
     }
     }
     

   • Speichern Sie die Konfigurationsdatei im Projektverzeichnis oder ~/.crush/config.json.

Hauptmerkmale der Verwendung von Crush

Codegenerierung

1. Geben Sie in das Terminal crush codeund beschreibt dann die Bedürfnisse, wie z. B.:

   crush code "编写一个 Python 函数，计算斐波那契数列"
   

2. Crush ruft den konfigurierten LLM auf, erzeugt den Code und zeigt ihn an.
3. Wenn der Code den Block nicht korrekt umbricht, wird die CRUSH.md Datei, um Regeln hinzuzufügen:

   ```python
   # 代码示例
   

Code-Fehlersuche

1. Einfuhr crush debugfügen Sie den problematischen Code ein.
2. Crush wird den Code analysieren und eine Lösung vorschlagen.
3. Verbessertes Debugging mit LSP:
   • Konfigurieren Sie einen LSP-Server, z. B. den von Go gopls::

     {
     "$schema": "https://charm.land/crush.json",
     "lsp": {
     "go": { "command": "gopls" },
     "typescript": { "command": "typescript-language-server", "args": ["--stdio"] }
     }
     }
     

   • Crush verwendet LSPs zur Syntaxprüfung und für ergänzende Vorschläge.

Sitzungsmanagement

1. Erstellen Sie eine neue Sitzung:crush session new <项目名>.
2. Sitzungen umschalten:crush session switch <项目名>.
3. Sehen Sie sich die Liste der Sitzungen an:crush session list.
4. Sitzungen behalten den Kontext bei und stellen sicher, dass Arbeitsabläufe aus verschiedenen Projekten nicht miteinander in Konflikt geraten.

Erweiterte Funktionen (MCP)

1. Konfigurieren Sie den MCP-Server:

   {
   "mcp": {
   "transport": "http",
   "endpoint": "http://example.com/mcp"
   }
   }
   

2. Crush erweitert die Funktionalität durch den Zugriff auf externe Tools oder Dienste über den MCP.

Validierung von Freigabedateien

Crush bietet eine Signaturprüfung, um sicherzustellen, dass die heruntergeladenen Dateien sicher sind:

1. Laden Sie die Freigabe- und Signaturdateien herunter (z. B. checksums.txtundchecksums.txt.sig).
2. Führen Sie den Befehl verify aus:

   cosign verify-blob \
   --certificate-identity 'https://github.com/charmbracelet/meta/.github/workflows/goreleaser.yml@refs/heads/main' \
   --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
   --cert 'https://github.com/charmbracelet/crush/releases/download/v0.1.11/checksums.txt.pem' \
   --signature 'https://github.com/charmbracelet/crush/releases/download/v0.1.11/checksums.txt.sig' \
   ./checksums.txt
   

3. Die Ausgabe zeigt "Verified OK" an, was bedeutet, dass die Datei sicher ist.

Anwendungsszenario

1. Effiziente Kodierung von Terminals
   • Wenn Entwickler Code im Terminal schreiben, generiert Crush schnell Codeschnipsel, bietet Debugging-Vorschläge und reduziert den Zeitaufwand für den Wechsel zu einem Browser oder einer IDE.
2. Projektübergreifendes Management
   • Entwickler, die mehrere Projekte verwalten, können mit der Sitzungsverwaltung von Crush den Kontext verschiedener Projekte speichern und schnell zwischen Arbeitsumgebungen wechseln.
3. Entwicklung eines lokalen Modells
   • Entwickler, die lokale Modelle wie Ollama verwenden, können Crush nutzen, um Code in einer netzunabhängigen Umgebung zu generieren und zu debuggen.
4. Teamarbeit
   • Teams können ihre Entwicklungsumgebung vereinheitlichen und effizienter zusammenarbeiten, indem sie Konfigurationsdateien und Catwalk-Modellbibliotheken gemeinsam nutzen.

QA

1. Welche Betriebssysteme werden von Crush unterstützt?
   • Crush unterstützt macOS, Linux, Windows (einschließlich PowerShell und WSL), FreeBSD, OpenBSD und NetBSD.
2. Wie kann ich zwischen verschiedenen LLMs wechseln?
   • Laufen in einer Sitzung crush model switch <模型名>, oder geben Sie das Modell in einer Konfigurationsdatei an.
3. Unterstützt Crush die Offline-Nutzung?
   • Mit lokalen Modellen (wie z. B. Ollama) und lokalen Konfigurationen kann Crush vollständig offline laufen.
4. Wie lässt sich das Problem der Darstellung von Codeblöcken lösen?
   • existieren CRUSH.md Datei, um Codeblockregeln hinzuzufügen, oder überprüfen Sie die Einstellungen des LLM-Ausgabeformats.