Neovim als Python-IDE

Vim lebt, derzeit vor allem in der modernen Inkarnation Neovim. Vorkonfigurierte Plug-in-Distributionen zaubern aus dem schlichten Editor eine ausgewachsene Python-Entwicklungsumgebung.

Von Jens Blawatt

Neben IDEs und Editoren wie PyCharm oder VS Code erfreut sich ein uralter Codeeditor noch immer großer Beliebtheit: Vim. Genauer gesagt sein moderner, 2014 abgespaltener Fork Neovim (Nvim). Sein Ziel ist es, die Charakteristiken von Vim beizubehalten, während größere Teile des Codes refaktorisiert und optimiert wurden. Diese Überarbeitungen sollen vor allem die Einstiegsbarrieren für neue Nvim-Entwickler und Plug-in-Autoren senken. Deshalb haben die Neovim-Entwickler ein umfangreiches Lua-Interface geschaffen, mit dem sich Nvim einfacher konfigurieren und erweitern lässt. In der Prioritätenliste des Projekts steht es ganz oben und wird mit jeder neuen Version erweitert.

Boom bei Plug-ins dank Lua-API

Der Lua-API verdankt Neovim einen regelrechten Boom bei der Entwicklung von Erweiterungen. Lua ist eine einfache, aber mächtige Sprache mit einem gut entwickelten Ökosystem, die als eingebettete Sprache, vor allem bei Computerspielen, weit verbreitet ist. In Neovim ersetzt sie schrittweise das sehr spezielle Vimscript und dessen Nachfolger Vim9Script, die im klassischen Vim zur Konfiguration und Erweiterung erforderlich sind.

Ein weiterer Grund für die Beliebtheit von Neovim ist der jetzt integrierte Client für das Language Server Protocol (LSP). Das von Microsoft für VS Code geschaffene LSP beschreibt eine einheitliche Schnittstelle für die Kommunikation von Entwicklungsumgebungen mit Language-Servern – Softwarekomponenten, die die Spezifika einer Sprache definieren. Es standardisiert die Kommunikation für Codevervollständigung, Syntaxhervorhebung, Fehler- und Warnhinweise sowie Refactorings. Mittlerweile ist das Protokoll ein offener Standard unter der MIT-Lizenz. So sind in den letzten Jahren viele unterschiedliche Server für etablierte bis esoterische Programmiersprachen entstanden, die von Freiwilligen, aber auch von namhaften Firmen bereitgestellt und weiterentwickelt werden.

Dazu kommt noch die Integration von Treesitter, einem Parser-Generator, der es ermöglicht, eine effiziente Syntaxstruktur des im Editor bearbeiteten Codes aufzubauen. Das verbessert nicht nur die Syntaxhervorhebung, sondern auch die Codenavigation und erleichtert das Refactoring.

Distributionen für den Schnelleinstieg

Bei allen Erweiterungsmöglichkeiten lässt Neovim seinen Nutzern die Qual der Wahl. Das ist Fluch und Segen zugleich, denn nicht nur bei der Auswahl der Plug-ins, sondern auch bei der Struktur der Konfigurationsdateien gibt es verwirrend viele Möglichkeiten. Das Internet ist voll von Blogbeiträgen und YouTube-Videos mit schnellen bis vollumfänglichen Anleitungen und Erfahrungsberichten, wie die Protagonisten es vermeintlich geschafft haben, ein einzigartig produktives Neovim-Set-up zu schnüren. Wie viele Stunden und Nerven dies gekostet hat, wird selten erwähnt.

Um die Einstiegshürde für angehende Neovim-Enthusiasten zu senken, haben sich um diesen Konfigurationskult herum einige Distributionen entwickelt. Sie versprechen ein gut aufeinander abgestimmtes Set-up wichtiger Plug-ins, einfache Erweiterbarkeit und eine gute Benutzbarkeit. Im Handumdrehen verwandeln sie den schlanken Editor in eine umfassende IDE. Fünf der verbreitetsten Distributionen sind:

• SpaceVim mit rund 20 000 GitHub-Sternen, seit Dezember 2016;
• AstroNvim mit rund 13 000 GitHub-Sternen, seit März 2022;
• LunarVim mit rund 18 000 GitHub-Sternen, seit Juni 2021;
• LazyVim mit rund 17 000 GitHub-Sternen, seit Januar 2023;
• NvChad mit rund 24 000 GitHub-Sternen, seit August 2021.

Für welche man sich entscheidet, bleibt Geschmackssache; die für Python-Entwickler wichtigen Erweiterungen sind bei allen entweder dabei oder schnell nachinstallierbar. Im Folgenden wird AstroNvim verwendet, das eine sehr aktive Community besitzt. Im Projekt AstroCommunity teilen die dort aktiven Personen Snippets für eine einheitliche Konfiguration von Erweiterungen, die nicht im Standardpaket enthalten sind.

Schnellstart mit AstroNvim

Der Einstieg in AstroNvim ist einfach und auf der Getting-Started-Seite erklärt (siehe ix.de/zt35). Die Macher stellen eine einfache User-Konfiguration bereit, die eine gute Grundlage für den Start darstellt. Wer Neovim noch gar nicht konfiguriert hat oder ein Backup seiner Konfiguration anlegt, kann das AstroNvim-Template direkt in das Konfigurationsverzeichnis klonen, und schon kann es losgehen. Um die Verbindung zum allgemeinen Template zu entfernen, muss man nur das .git-Verzeichnis löschen.

$ git clone --depth 1 https://github.com/AstroNvim/template ~/.config/nvim
$ rm -rf ~/.config/nvim/.git

Dazu noch ein Tipp: Grundsätzlich liegen alle Neovim-Konfigurationen im Ordner ~/.config/nvim beziehungsweise unter Windows in ~\AppData\Local\nvim. Das lässt sich allerdings über die Umgebungsvariable $NVIM_APPNAME ändern. So kann man je nach Projekt oder Programmiersprache zwischen unterschiedlichen Set-ups wechseln. Außerdem vereinfacht es, neue Konfiguration zu testen oder Distro-Hopping zu betreiben. Möchte man AstroNvim neben seiner bestehenden Konfiguration verwenden, geht man also wie folgt vor:

$ git clone --depth 1 https://github.com/AstroNvim/template ~/.config/AstroNVIM
$ rm -rf ~/.config/nvim/.git
$ export NVIM_APPNAME=AstroNVIM
$ nvim

Beim ersten Start lädt der Plug-in-Manager Lazy alle notwendigen Plug-ins aus dem Internet – und schon ist AstroNvim einsatzbereit.

Anschließend lassen sich zusätzliche Plug-ins installieren und konfigurieren. Das ist vor allem dann notwendig, wenn man spezielle Sprachunterstützungen etwa für Python oder KI-Erweiterungen braucht, die AstroNvim von Haus aus nicht mitbringt. Um auch hier nicht von Grund auf starten zu müssen, liegt auf GitHub in der Organisation von AstroNvim das AstroCommunity-Repository mit vorkonfigurierten Plug-in-Paketen. Es steht jedermann für die Mitwirkung offen.

Die vor dem ersten Start angelegte Konfiguration sieht bereits eine Stelle vor, in der sich die Community-Konfiguration einbinden lässt. Das Listing zeigt die Konfiguration für alle beschriebenen Funktionen.

Neovim hat sich jetzt in eine umfangreiche Python-IDE verwandelt, die sich in vielen Bereichen nicht hinter den Platzhirschen PyCharm oder Visual Studio Code verstecken muss (siehe Abbildung 1). Der Editor verfügt jetzt über IDE-Features wie

• einen Dateibrowser in der Seitenleiste,
• kontextabhängige Autovervollständigung,
• eine Git-Integration,
• Integration von Unit-Tests mit unittests und pytest,
• eine Fuzzy Search für Kommandos, Dateien und Codeelemente, wie man es aus VS Code kennt,
• ein Outline der Symbole und Strukturen der aktuellen Datei.

Erweiterungen aus der Community

Das astrocommunity.pack.python aus der AstroCommunity installiert direkt einige Zusatzfunktionen, die für die Entwicklung von Python unerlässlich sind. Dazu gehören der Language-Server basedpyright sowie das zum Debuggen von Python-Code passende Modul für das Debugging Adapter Protocol (DAP). Dazu kommen Helfer wie die Formatter Black und isort. Werden weitere Tools wie Ruff gewünscht, lassen sich diese später einfach selbst hinzufügen.

Für die Ausführung von Unit-Test-Suiten werden die entsprechenden Konfigurationen für das Neotest-Plug-in geladen. Für Python-Entwickler besonders hilfreich ist eine Extension für das Wechseln von virtuellen Umgebungen (Virtual Environments), die das Paket ebenfalls nachinstalliert.

Autovervollständigung und mehr durch LSP

Entscheidend für den Einsatz von Neovim als IDE ist die Zusammenarbeit des eingebauten LSP-Clients mit Language-Servern. Für diese Integrationsarbeit sind die Plug-ins Mason und none-ls zuständig. Mason ist ein schlanker Paketmanager speziell für LSP- und DAP-Server sowie für Linter und Formatter. none-ls sorgt für die komfortable Integration in den LSP-Client von Neovim.

Öffnet man jetzt ein Python-Projekt, sind die Autovervollständigungen bereits aktiv. Hierfür wird standardmäßig der aktive Python-Interpreter aus dem Pfad verwendet. Daher sollte man im Vorfeld das gewünschte Virtual Environment manuell aktiviert haben oder auf empfehlenswerte Helfer wie direnv zurückgreifen, die Umgebungsvariablen je nach aktuellem Ordner automatisch setzen und anpassen. Neben der Autovervollständigung bringt die LSP-Integration weitere Funktionen wie die Suche nach Referenzen, den Sprung zur Definition, globales Umbenennen von Symbolen und einige weitere Features mit.

Außerdem werden Fehler im Code und sonstige Diagnosen aus Tools zur statischen Codeanalyse (Linter) angezeigt. Manche Language-Server unterstützen solche Diagnosen direkt, alternativ können Erweiterungen wie Pylint, Ruff oder mypy sie ergänzen.

Das Plug-in trouble.nvim, das sich auch über die AstroCommunity installieren lässt, verbessert die Anzeige von Diagnoseergebnissen wie Fehlern oder Warnungen erheblich. Es gehört aber nicht zum Plug-in-Paket für Python, sondern muss hinzugefügt werden (siehe Listing).

Das Plug-in-Paket astrocommunity.pack.python installiert basedpyright als einzigen Language-Server. Es ist allerdings möglich, einen oder mehrere alternative LSP-Server zu installieren und zu verwenden. Denn derzeit entstehen viele neue Language-Server, bestehende werden geforkt und unter vermeintlich neuem Fokus weiterentwickelt. Außerdem beherrscht nicht jeder Language-Server alle im Protokoll definierten Funktionen.

Deshalb gibt es spezielle Language-Server für gesonderte Aufgaben, etwa das Linting und die Formatierung mit dem Ruff-Server. Wer also zu pyright oder dem Python-Language-Server wechseln oder seine Auswahl erweitern möchte, hat hier die freie Auswahl. Die Verwaltung erfolgt innerhalb von Neovim mit dem Plug-in Mason, das dafür ein integriertes UI bereitstellt.

Mason lässt sich unterschiedlich einsetzen: Ist der Name des zu installierenden Servers bereits bekannt, kann er direkt über das entsprechende Kommando installiert werden. Für Ruff wäre dies :MasonInstall ruff-lsp. Die Liste aller bereitstehenden Pakete erhält man durch die Eingabe von :Mason. Dabei öffnet sich das interaktive Menü, über das neben der Filterung nach unterschiedlichen Anwendungsbereichen auch direkt Installationen und Updates ausgelöst werden können.

Debugging auch remote

Um Debugging innerhalb von Neovim zu ermöglichen, kommt eine ähnliche Logik wie bei LSP zum Einsatz. Denn neben LSP beherrscht Neovim auch das Debug Adapter Protocol (DAP), ein weiteres offenes Protokoll, das die Kommunikation zwischen IDEs und Debuggern standardisiert. Das Language Pack für Python installiert die erforderlichen Module und Plug-ins und richtet sie sinnvoll ein. Ein Ausweichen auf andere IDEs oder Konsolenprogramme wie pdb, ipdb oder pudb ist nicht mehr nötig.

Wie aus anderen IDEs gewohnt, lassen sich über Tastenkombinationen oder Kommandos (hier :DapBreak) Haltepunkte an entsprechender Stelle setzen. Der Befehl :DapNew startet eine neue Debugging-Session. Hier besteht die Möglichkeit, die aktuelle Datei auszuführen, wahlweise mit Optionen, oder sich an einen von debugpy initiierten Remote-Debugging-Prozess zu hängen, der auf einem Server oder in einem Container läuft.

Sobald die Session startet, schaltet das Fensterlayout um und zeigt spezielle Panels für die Debugging-Session (Abbildung 2). Sie enthalten übrigens ein für Neovim seltenes UI-Element, nämlich eine Button-Leiste zum Steuern der Sprungaktionen während des Debuggens. In dieser Ansicht ist es dann möglich, wie in PyCharm oder VS Code den aktuellen Aufrufstack und lokale Variablen zu überwachen oder die Konsolenausgabe zu verfolgen. Zusätzlich bekommt der Benutzer direkt eine Python-REPL angeboten, in der er im Kontext des Haltepunkts Python-Code schreiben und ausführen kann.

Beendet man die Session manuell mit dem Kommando :DapTerminate oder über das normale Ende des Programms, schaltet sich das Layout automatisch wieder um. Auch wenn hier zur Verdeutlichung nur die Kommandos genannt wurden, existieren natürlich für all diese Aktionen ebenfalls Key-Bindings.

Gut gerüstet für Unit-Tests

Neben dem Debuggen ist eine weitere Funktion für eine gute IDE unerlässlich: die Integration von Unit-Tests. Auch hierfür hat AstroNvim ein Plug-in integriert: NeoTest. Durch das Language Pack erfährt auch dies die nötige Konfiguration für die Verwendung mit Python.

NeoTest erlaubt es, Tests des Standard-Python-Testframeworks unittest und des Frameworks pytest auszuführen. Dabei lässt es kaum etwas vom Funktionsumfang großer IDEs vermissen und lehnt sich auch im Layout an diese an. Es bringt eine Seitenleiste mit, die alle Tests der jeweiligen Module auflistet. Von hier kann man nicht nur das letzte Testergebnis ablesen, sondern auch gezielt einzelne Tests der Suite starten oder zum (fehlerhaften) Test im Code springen.

NeoTest integriert sich darüber hinaus in den Codeeditor und zeigt Testergebnisse und Hinweise direkt an den Tests oder in einem Overlay-Fenster an. Auch Watcher für das Überwachen und automatische Ausführen von Tests bei Änderungen sind enthalten (siehe Abbildung 3).

Wem das zu umfangreich ist, dem sei das Plug-in vim-test nahegelegt. Es stellt einfache, kontextbasierte Kommandos bereit, mit denen sich direkt in den Testdateien Tests ausführen lassen, und arbeitet ebenfalls mit unittest und pytest zusammen.

Suchen und Finden mit Telescope

IDEs bieten eine immer größere Anzahl an Funktionen, die kontextbasiert oder permanent zur Verfügung stehen können. Sie schnell auffindbar und übersichtlich anzubieten, ohne ein Meer an Buttons oder einen Wald verschachtelter Menübäume zu erschaffen, ist eine Kunst. Auch deshalb hat sich bei VS Code und PyCharm eine Art Fuzzy Finding durchgesetzt. Mit einem Tastendruck ist es möglich, eine Suche zu öffnen und über die Eingabe des gewünschten oder gesuchten Befehls eine direkte Auswahl zu treffen.

Das Äquivalent für Neovim ist die Erweiterung Telescope. In einfachster Form ist sie mit der Suche in VS Code vergleichbar – ist aber so modular aufgebaut, dass die vielen eigenen Picker, also Auswahldialoge, durch andere Plug-ins erweitert werden können. Zum Standard gehören unter anderem folgende Picker:

• Auswahl aus Color Schemes (mit Vorschau),
• alle Dateien des Workspace (berücksichtigt .gitignore),
• alle registrierten Kommandos,
• alle Tastenkombinationen,
• alle offenen Buffer.

Daneben macht sich die LSP-Integration die Modularität von Telescope zunutze und erlaubt die Navigation zu Symbolen (also zum Beispiel Klassen, Variablen, Funktionen) durch die Auflistung von Referenzen, allen Symbolen der aktuellen Datei oder des aktuellen Workspace. In Verbindung mit der Möglichkeit, zwischen Buffern zu springen, die ebenfalls über Telescope auswählbar sind, entsteht ein mächtiges Werkzeug für schnelle Navigation in der Codebasis (siehe Abbildung 4).

Refactoring mit LSP-Hilfe

Refactoring bezeichnet den Prozess der Verbesserung des Quellcodes, ohne dabei das äußere Verhalten einer Anwendung zu verändern. Unnötige Komplexitäten werden reduziert, Redundanzen entfernt und Strukturen optimiert, um die langfristige Entwicklung und Pflege eines Projekts zu erleichtern. IDEs bieten hierfür meist spezielle Funktionen, etwa zum Herauslösen von Variablen oder Blöcken, oder das Verschieben bestimmter Codeblöcke in neue Module. Eine hilfreiche Refactoring-Funktion ist aber schon, Symbole über die gesamte Codebasis hinweg umzubenennen.

Dank LSP-Client ist das prinzipiell auch in Neovim möglich. Die verschiedenen Language-Server implementieren aber Refactoring-Funktionen in unterschiedlichem Umfang. Mit dem Plug-in refactoring.nvim können noch weitere Features des LSP gebunden und verwendet werden. Über die Community-Konfiguration werden hier direkt entsprechende Tastenkombinationen festgelegt. Funktionen wie das Extrahieren eines Blocks in eine neue Funktion oder Datei oder das Extrahieren von Variablen sind so direkt zugreifbar. Bei dieser Art des Refactorings spielen aber andere IDEs, vor allem PyCharm, ihre Stärken wesentlich besser aus.

Vim-Aktionen, aber mit Struktur

Allerdings bietet Neovim mit den Vi Motions ein Feature, das es mit allen vi-Abkömmlingen gemeinsam hat: die Kombination von Aktionen wie Markieren (v), Löschen (d) oder Ändern (c) mit Textpassagen und deren Begrenzern (Klammern, Leerzeichen, Anführungszeichen et cetera). Beispielsweise löscht diw das Wort, auf dem sich der Cursor befindet, innerhalb (i), also ohne angrenzende Leerzeichen, daw entfernt auch diese mit, ci( löscht alles innerhalb der runden Klammern und geht dann in den Insert-Modus, va[ markiert den gesamten Klammerausdruck inklusive der öffnenden und schließenden eckigen Klammer.

Dieses Prinzip wird durch den Parser Treesitter und die Treesitter Text Objects deutlich erweitert. Damit lassen sich gezielt Objekte innerhalb des Codes ansprechen, markieren und ändern. Damit können über die Motions neben normalen Strukturelementen wie Wörtern oder Klammern auch Sprachbestandteile gezielt angesprochen werden. Die im Python-Kontext wichtigen Objekte sind:

• Funktion (@function)
• Schleife (@loop)
• Bedingung (@condition)
• Klasse (@class )
• Parameter (@parameter)

Wie die einzelnen Textobjekte an Tastenkürzel gebunden sind, ist wie so oft die Einstellungssache der Plug-ins. AstroNvim hat hier bereits ein Binding festgelegt. Dabei steht

• f für eine Funktion,
• ? für eine Bedingung,
• o für eine Schleife,
• p für einen Parameter,
• c für eine Klasse.

Verinnerlicht man diese Tastenbefehle, lassen sich so gezielt Objekte markieren oder ändern. cif ändert das Innere einer Funktion, die Funktionssignatur bleibt erhalten. ci? ändert das Innere des aktuellen If-Blocks. Solche Textobjekte lassen sich ebenfalls verschieben oder tauschen und auch dafür hat AstroNvim Tastenkombinationen eingerichtet. Mit >F lässt sich etwa eine Funktion mit der nächsten tauschen oder mit >P die Reihenfolge von Funktionsparametern ändern.

Der effiziente Einsatz dieses Verfahrens erfordert neben einer guten Kenntnis der Codebase auch ein gewisses motorisches Gedächtnis, denn sonst ist der mentale Overhead sehr hoch. Wer allerdings die Arbeitsweise und die Tastenkombinationen verinnerlicht hat, kann damit schnell arbeiten.

KI-gestütztes Coding von Autocomplete bis Chat

Alle IDEs, die generative KI einbinden, tun das auf zwei verschiedene Arten. Eine ist das Generieren von Code an der Stelle des Cursors, also eine Art erweiterte Autovervollständigung. Der prominenteste Vertreter dürfte der GitHub Copilot sein. Die Alternative hierzu ist der Chat mit einem Sprachmodell, in der Regel in einer Seitenleiste. Hier kann man Fragen zum Code stellen, Code generieren und in den bestehenden Code übernehmen. Mittlerweile entstehen dedizierte IDEs, die sich ganz auf die Integration dieser Funktionen konzentrieren. Das prominenteste Beispiel ist derzeit Cursor AI.

Obwohl AstroNvim in der Standardinstallation keine KI-Erweiterung mitbringt, stehen einige über die AstroCommunity zur Verfügung. Zurzeit entstehen viele solcher Plug-ins, die versuchen, die großen SOTA-Modelle (State of the Art) aber auch freie Modelle wie Llama 3 zu integrieren und für die Entwicklung nutzbar zu machen. Als Beispiele dienen hier GitHub Copilot, Avante und Parrot.

Copilot – vervollständigen oder chatten

Der GitHub Copilot als Veteran der KI-Unterstützung lässt sich auch in AstroNvim nutzen. Aktiviert man das Plug-in aus der AstroCommunity, reicht eine einfache Anmeldung über das Kommando :Copilot auth. Nachdem man zur Authentifizierung kurz auf die GitHub-Seite geleitet wird, kann Copilot schon verwendet werden. Wie in anderen IDEs generiert der Assistent den vorgeschlagenen Code beim Schreiben, mit der Tabulatortaste lässt sich der Vorschlag übernehmen. Diese Art Unterstützung ist Geschmackssache, funktioniert aber in Neovim ähnlich schnell wie in Visual Studio Code.

Eine Alternative oder Ergänzung ist das Plug-in Copilot Chat, das eine Art Pop-up-Menü mit einer Chatfunktion mitbringt. Hier können Fragen zum Code gestellt oder Codeerzeugung in Auftrag gegeben werden. Das Overlay bleibt aktiv und der Benutzer kann von dort die passenden Snippets in seinen Code übernehmen.

Avante – Cursor AI für Vim

Einen anderen Weg geht avante.nvim. Die Macher dieses Plug-ins wollen die Funktionsweise von Cursor AI in Neovim abbilden und KI für möglichst viele Aufgaben bei der Softwareentwicklung nutzen, von der Autovervollständigung bis zur Automatisierung von Prozessen. Anwender haben hier die Möglichkeit, unterschiedliche Modelle von Copilot über ChatGPT, Azure OpenAI bis hin zu selbst gehosteten Ollama-Modellen zu verwenden.

Der Befehl :AvanteChat öffnet ein Panel auf der rechten Seite für den direkten Chat mit den Sprachmodellen. Vorgeschlagene Code-Snippets aus der Konversation können über Tastenbefehle in den eigenen Code (teilweise) übernommen werden – jedoch nicht direkt, sondern das Plug-in zeigt vorher in einem Diff-Fenster an, wie sich die Änderung auswirkt.

Alternativ lassen sich mit AvanteAsk oder <leader>aa Fragen zum ausgewählten Code stellen und Antworten ebenfalls einfach in den eigenen Code übernehmen. In Abbildung 5 wird die Funktion genutzt, um Typannotationen und Docstrings zu ergänzen.

Eine weitere spannende Funktion ist AvanteEdit (oder <leader>ae). Hiermit lässt sich Code markieren und ein Änderungsbefehl anwenden. Die Änderungen geschehen dann nicht erst in der Seitenleiste oder der Diff-Darstellung, sondern werden direkt live im Code durchgeführt.

In avante.nvim lassen sich die einzelnen Prompts hinter den jeweiligen Kommandos je Projekt überschreiben. avante.nvim schaut dann unter anderem im Projektverzeichnis nach Dateien mit einem entsprechenden Namensmuster und bindet sie als Template im MiniJinja-Format mit ein.

avante.nvim ist noch recht jung, hat aber schon eine beachtliche Zahl an Sternen auf GitHub gesammelt. Die Integration in den Entwicklungsprozess ist gelungen und steht beim Programmieren nicht im Weg. Je nach Auswahl des Modells muss man jedoch mit langen Antwortzeiten rechnen. Wie bei der Copilot-Integration reagieren die großen, über Services angebotenen Modelle zügig. Bei selbst gehosteten Modellen kann die merkliche Verzögerung einem jedoch einige Geduld abverlangen.

Parrot – flexibler Papagei

Noch flexibler in der Anwendung ist das Plug-in parrot.nvim, das aber noch nicht in die AstroCommunity aufgenommen wurde. Auch hier lassen sich unterschiedliche LLMs und Anbieter konfigurieren. Die können Entwickler anschließend im Editor mit :PrtProvider und :PrtModel auswählen und damit ihr Sprachmodell schnell wechseln.

Auch bei Parrot stehen im Entwicklungsprozess Kommandos zur Verfügung, über die Entwickler den Code im aktuellen Kontext ändern oder erweitern, aber auch mit dem jeweiligen Modell chatten können. Wie bei avante.nvim gibt es in Parrot spezielle Befehle für das Fragen (:PrtAsk) oder Starten eines neuen Chats (:PrtChatNew). Darüber hinaus existieren Kommandos, hinter denen sich vorformulierte Prompts befinden, um Code zu (re-)implementieren oder anzufügen. Ein Anwendungsfall ist hier das Reimplementieren einer bestehenden Funktion unter Performance-Gesichtspunkten. Außerdem können die Antworten des Modells direkt in einem neuen Buffer via Split oder Tab geöffnet werden. Dies macht die Interaktion etwas Vim-natürlicher als bei avante.nvim, in dem eine dedizierte Seitenleiste verwendet wird.

Um Parrot genau auf die eigenen Bedürfnisse anzupassen, implementiert es benutzerdefinierte Hooks. Damit lassen sich leicht eigene Kommandos definieren, die die eingebauten Funktionen des Plug-ins nutzen und mit einem einfachen Templatesystem für individuelle Prompts kombinieren.

Ausblick auf Git und Einblick in Datenbanken

Neben den genannten Features existieren noch viele weitere, die AstroNvim in die Neovim-Konfiguration einbringt. Für die Git-Integration bringt AstroNvim das Plug-in Gitsigns mit, das sich gut in die Oberfläche integriert und Icons für die Versionsverwaltung in der Seitenleiste anzeigt. Es ermöglicht das Staging einzelner Zeilen, zeigt modifizierte Zeilen an und bindet die Ausgabe von git blame ein, um zu zeigen, wer eine Zeile zuletzt angefasst hat. Weit mehr Git-Aktionen beherrscht vim-fugitive, eine Erweiterung des klassischen Vim, die aber auch in Neovim funktioniert und immer noch sehr beliebt ist. Eine vollständig in Lua entwickelte Alternative ist Neogit. Es wirkt moderner und aufgeräumter und macht einzelne Git-Befehle und deren Parameter besser zugänglich.

Im Entwicklungsprozess ist es immer wieder wichtig, einen Blick in die Backend-Datenbanken zu werfen, um zu wissen, was mit den Daten wirklich passiert. Hier bietet Neovim leider keine wirklich attraktive Alternative zu den Funktionen von PyCharm oder eigenständigen Datenbankwerkzeugen. Mit dem Plug-in vim-dadbod(-ui) bekommt man immerhin ein kleines Tool an die Hand, das für einfache Einblicke in die Daten reichen sollte. Hier lassen sich Verbindungen verwalten, einige Datenbankobjekte einsehen und SQL-Statements ausführen. Das ist allerdings bei Weitem nicht vergleichbar mit den mächtigen Funktionen, die etwa PyCharm mit seinen Datenbankwerkzeugen bereitstellt.

Tastenkombinationen finden mit Which-Key

Zum Abschluss noch ein Feature, das zwar nicht direkt etwas mit IDE-Fähigkeiten zu tun hat, aber auch für Entwickler extrem hilfreich und ein Default-Bestandteil der AstroNvim-Distribution ist. Das gesamte Vim-Universum, egal ob Neovim, AstroNvim oder die klassische Variante, lebt von Key-Bindings. Sie zu überblicken und zu lernen ist eine der größten Hürden für Vim-Einsteiger, aber auch für erfahrene Nutzer, die neue Erweiterungen einsetzen. Hier hilft das Plug-in Which-Key: Es stellt beim Drücken einer Taste (im Normal-Modus) ein kleines Hilfemenü dar, das anzeigt, wie die gedrückte Taste im Folgenden zu einer Aktion kombiniert werden kann (siehe Abbildung 6).

Fazit

Vim und seine Derivate sind aus der langen Geschichte der Softwareentwicklung nicht wegzudenken. In jüngerer Zeit haben der Erfolg von Neovim und die vielen Distributionen gezeigt, dass viele Entwickler sich in die etwas andere Art der Interaktion mit dem Entwicklungswerkzeug hineindenken.

Trotz der Distributionen und des einfacheren Zugangs ist und bleibt Neovim aber eher eine Lösung für Nerds und Enthusiasten, die bereit sind, sich intensiv mit der gewählten Entwicklungsumgebung zu beschäftigen. Denn ohne die Bereitschaft, etwas Lua zu lernen und Zeit in die richtige Konfiguration und das Zusammenspiel von Plug-ins zu stecken, wird man auf Dauer nicht glücklich. Ist man dazu allerdings bereit, kann man damit sehr produktiv, performant und vor allem flexibel arbeiten. (ulw@ix.de)