# Lua in Maguyva: grafi del codice per giochi, plugin e OpenResty

Canonical source: https://maguyva.ai/it/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 supporta Lua con AST, simboli e grafo, così gli agenti IA seguono moduli, metodi con i due punti, classi basate su metatable e catene di require.

## Istantanea del supporto

- Livello: Supporto AST e simboli
- Programmazione
- Estensioni: .lua
- Analisi AST reale per ricerca sintattica e contesto strutturale.
- I simboli nominati alimentano la ricerca semantica e i riferimenti incrociati. La navigazione del grafo è disponibile quando è abilitata l’estrazione delle relazioni.
- Questo linguaggio contribuisce con simboli e relazioni alla ricerca basata sul grafo; i tipi di arco supportati variano in base ai suoi costrutti nativi.
- Sono disponibili sia l’analisi AST sia l’estrazione dei simboli.

## Il più adatto per

- Codice di gioco e script del motore in cui moduli, classi basate su tabelle e gestori di eventi si chiamano a vicenda.
- Plugin di Neovim e configurazione dell'editor suddivisi in molti moduli caricati con require.
- OpenResty e altri usi di Lua embedded, in cui i gestori delle richieste stanno accanto a moduli di supporto condivisi.

## Workflow degli agenti

- Trovare tutti i chiamanti di una funzione di modulo prima di cambiarne gli argomenti.
- Tracciare quali moduli caricano con require un helper condiviso prima di spostarlo.
- Mappare quali tabelle ereditano da una classe base tramite `setmetatable`.

## Dove Lua fa inciampare gli strumenti di IA superficiali

Lua non ha una parola chiave per le classi. Gli oggetti sono tabelle, i metodi sono funzioni memorizzate al loro interno e l'ereditarietà è una chiamata a `setmetatable`. Un modulo è qualsiasi cosa restituisca `require`. La struttura è reale, ma vive in convenzioni che una ricerca testuale non capisce.

Maguyva legge queste convenzioni come struttura, così un agente può chiedere chi chiama un metodo o quali tabelle estendono una base e ottenere una risposta diretta.

## Cosa estrae Maguyva in Lua

Maguyva copre i file `.lua`. Vengono estratte dichiarazioni di funzione, definizioni `local function` ed espressioni di funzione, e i metodi con i due punti come `function Account:deposit()` vengono attribuiti alla tabella proprietaria, `Account`. Le catene di metodi vengono seguite chiamata per chiamata, e le chiamate su `self` restano legate all'oggetto che le contiene.

Le convenzioni di Lua diventano relazioni:

- `require`, `dofile` e `loadfile` registrano import.
- Una chiamata a `setmetatable` a livello di modulo registra un'ereditarietà.
- `ClassName:new()`, `ClassName.new()` e `setmetatable({...}, ClassName)` contano come istanziazione.
- `error()` registra un throw, e `pcall` e `xpcall` registrano un catch.

Il grafo registra anche letture e scritture e flusso di controllo.

## Esempi di prompt per agenti

- "Chi chiama `Inventory:addItem`, e da quali script?" (`find_symbol`, poi `dependency_search` incoming)
- "Quali moduli caricano `util.http` con require?" (`dependency_search`)
- "Traccia cosa succede quando il giocatore subisce danni." (`get_task_context`)

## Limiti noti

- Circa 150 nomi vengono filtrati dalle relazioni: la libreria standard di Lua (`string`, `table`, `math`, `io`, `os`, `coroutine`, `debug` e `utf8`) più le API `vim.*` di Neovim e `ngx.*` di OpenResty. Le chiamate a queste API non sono archi del grafo, quindi usa `text_pattern_search` per trovarle.
- Poiché moduli e classi sono costruiti con chiamate e tabelle normali, i preset `classes` e `imports` di `structural_search` non selezionano nulla per Lua. Usa invece `find_symbol` o `text_pattern_search`.
- Lua non ha interfacce né annotazioni di tipo, quindi le relazioni di implementazione di interfacce e di riferimento di tipo sono marcate come non applicabili.

## Prossimi passi

Collega un repository con la [guida rapida](/it/docs/quickstart), poi consulta la matrice di supporto nella [pagina di compatibilità](/it/docs/compatibility). Per i motori che incorporano Lua nel codice nativo, leggi anche la [guida a C](/it/languages/c).

## Dettagli del motore

- Il supporto a Lua copre `.lua`. I metodi con i due punti come `function Account:deposit()` vengono attribuiti alla tabella proprietaria.
- `require`, `dofile` e `loadfile` registrano import, `setmetatable` a livello di modulo registra un'ereditarietà e `ClassName:new()` conta come istanziazione.
- `error()` registra un throw e `pcall` un catch, mentre circa 150 nomi della libreria standard, di `vim.*` e di `ngx.*` vengono filtrati.

## Punti di ingresso MCP utili

- `find_symbol`: Usalo per una funzione di modulo o un metodo con i due punti quando ti servono definizione e chiamanti.
- `dependency_search`: Usa l'attraversamento incoming su un modulo condiviso per vedere quali file lo caricano con require prima di spostarlo.
- `text_pattern_search`: Usalo per le chiamate a `vim.*`, `ngx.*` o alla libreria standard, che vengono filtrate dal grafo.