# Lua in Maguyva: Code-Graphen für Spiele, Plugins und OpenResty

Canonical source: https://maguyva.ai/de/languages/lua

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

Maguyva unterstützt Lua mit AST, Symbolen und Graph, damit KI-Agenten Module, Doppelpunkt-Methoden, Metatable-Klassen und require-Ketten in Lua-Code verfolgen.

## Unterstützungsüberblick

- Stufe: AST- und Symbol-Support
- Programmierung
- Dateiendungen: .lua
- Echtes AST-Parsing für syntaxbewusste Suche und strukturellen Kontext.
- Benannte Symbole speisen semantisches Lookup und Cross-Referenzierung. Graph-Navigation ist verfügbar, wenn die Beziehungsextraktion aktiviert ist.
- Diese Sprache liefert Symbole und Beziehungen für die graphgestützte Suche; die unterstützten Kantentypen variieren je nach nativen Konstrukten der Sprache.
- AST-Parsing und Symbolextraktion sind beide verfügbar.

## Am besten geeignet

- Spielcode und Engine-Skripte, in denen Module, tabellenbasierte Klassen und Event-Handler sich gegenseitig aufrufen.
- Neovim-Plugins und Editor-Konfiguration, verteilt auf viele per require geladene Module.
- OpenResty und anderes eingebettetes Lua, bei dem Request-Handler neben gemeinsamen Helfermodulen liegen.

## Agentenabläufe

- Alle Aufrufer einer Modulfunktion finden, bevor sich ihre Argumente ändern.
- Verfolgen, welche Module einen gemeinsamen Helfer per require laden, bevor er verschoben wird.
- Abbilden, welche Tabellen über `setmetatable` von einer Basisklasse erben.

## Wo Lua oberflächliche KI-Tools ins Stolpern bringt

Lua hat kein Schlüsselwort für Klassen. Objekte sind Tabellen, Methoden sind darin gespeicherte Funktionen, und Vererbung ist ein `setmetatable`-Aufruf. Ein Modul ist, was auch immer `require` zurückgibt. Die Struktur ist real, aber sie steckt in Konventionen, die eine Textsuche nicht versteht.

Maguyva liest diese Konventionen als Struktur, damit ein Agent fragen kann, wer eine Methode aufruft oder welche Tabellen eine Basis erweitern, und eine direkte Antwort bekommt.

## Was Maguyva in Lua extrahiert

Maguyva deckt `.lua`-Dateien ab. Funktionsdeklarationen, `local function`-Definitionen und Funktionsausdrücke werden extrahiert, und Doppelpunkt-Methoden wie `function Account:deposit()` werden ihrer besitzenden Tabelle `Account` zugeordnet. Methodenketten werden Aufruf für Aufruf verfolgt, und Aufrufe über `self` bleiben an das umgebende Objekt gebunden.

Die Konventionen von Lua werden so auf Beziehungen abgebildet:

- `require`, `dofile` und `loadfile` erfassen Importe.
- Ein `setmetatable`-Aufruf auf Modulebene erfasst Vererbung.
- `ClassName:new()`, `ClassName.new()` und `setmetatable({...}, ClassName)` zählen als Instanziierung.
- `error()` erfasst ein Throw, `pcall` und `xpcall` erfassen ein Catch.

Der Graph erfasst außerdem Lese- und Schreibzugriffe sowie den Kontrollfluss.

## Beispiel-Prompts für Agenten

- „Wer ruft `Inventory:addItem` auf, und aus welchen Skripten?“ (`find_symbol`, dann `dependency_search` incoming)
- „Welche Module laden `util.http` per require?“ (`dependency_search`)
- „Verfolge, was passiert, wenn der Spieler Schaden nimmt.“ (`get_task_context`)

## Bekannte Grenzen

- Etwa 150 Namen werden aus den Beziehungen gefiltert: die Lua-Standardbibliothek (`string`, `table`, `math`, `io`, `os`, `coroutine`, `debug` und `utf8`) sowie die Neovim-API `vim.*` und die OpenResty-API `ngx.*`. Aufrufe dieser APIs sind keine Graphkanten; verwende `text_pattern_search`, um sie zu finden.
- Weil Module und Klassen aus gewöhnlichen Aufrufen und Tabellen entstehen, wählen die Presets `classes` und `imports` in `structural_search` für Lua nichts aus. Verwende stattdessen `find_symbol` oder `text_pattern_search`.
- Lua hat weder Interfaces noch Typannotationen, daher sind Beziehungen für Interface-Implementierung und Typreferenzen als nicht anwendbar markiert.

## Nächste Schritte

Verbinde ein Repository über den [Schnellstart](/de/docs/quickstart) und prüfe dann die Unterstützungsmatrix auf der [Kompatibilitätsseite](/de/docs/compatibility). Für Engines, die Lua in nativen Code einbetten, lies auch den [C-Leitfaden](/de/languages/c).

## Engine-Einordnung

- Die Lua-Unterstützung umfasst `.lua`. Doppelpunkt-Methoden wie `function Account:deposit()` werden ihrer besitzenden Tabelle zugeordnet.
- `require`, `dofile` und `loadfile` erfassen Importe, `setmetatable` auf Modulebene erfasst Vererbung, und `ClassName:new()` zählt als Instanziierung.
- `error()` erfasst ein Throw und `pcall` ein Catch, während etwa 150 Namen aus Standardbibliothek, `vim.*` und `ngx.*` gefiltert werden.

## Nützliche MCP-Einstiegspunkte

- `find_symbol`: Nutz es für eine Modulfunktion oder Doppelpunkt-Methode, wenn du Definition und Aufrufer brauchst.
- `dependency_search`: Nutz die eingehende Traversierung auf einem gemeinsamen Modul, um vor dem Verschieben zu sehen, welche Dateien es per require laden.
- `text_pattern_search`: Nutz es für Aufrufe in `vim.*`, `ngx.*` oder die Standardbibliothek, die aus dem Graphen gefiltert werden.