# Lua no Maguyva: grafos de código para jogos, plugins e OpenResty

Canonical source: https://maguyva.ai/pt-br/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).

O Maguyva oferece suporte a Lua com AST, símbolos e grafo, para que agentes de IA sigam módulos, métodos com dois-pontos, classes com metatables e cadeias de require.

## Panorama de suporte

- Nível: Suporte a AST e símbolos
- Programação
- Extensões: .lua
- Parsing real de AST para busca com consciência de sintaxe e contexto estrutural.
- Símbolos nomeados alimentam a busca semântica e as referências cruzadas. A navegação por grafo fica disponível quando a extração de relações está habilitada.
- Esta linguagem fornece símbolos e relações para a busca orientada por grafo; os tipos de aresta compatíveis variam de acordo com seus construtos nativos.
- A análise de AST e a extração de símbolos estão disponíveis.

## Uso ideal

- Código de jogos e scripts de engine em que módulos, classes baseadas em tabelas e handlers de eventos chamam uns aos outros.
- Plugins do Neovim e configuração do editor espalhados por muitos módulos carregados com require.
- OpenResty e outros usos de Lua embarcado, em que handlers de requisição ficam ao lado de módulos auxiliares compartilhados.

## Fluxos de trabalho de agente

- Encontrar todos os chamadores de uma função de módulo antes de mudar seus argumentos.
- Rastrear quais módulos carregam um helper compartilhado com require antes de movê-lo.
- Mapear quais tabelas herdam de uma classe base por meio de `setmetatable`.

## Onde Lua derruba ferramentas de IA superficiais

Lua não tem palavra-chave para classes. Objetos são tabelas, métodos são funções guardadas nelas, e herança é uma chamada a `setmetatable`. Um módulo é o que `require` retornar. A estrutura é real, mas vive em convenções que uma busca de texto não entende.

O Maguyva lê essas convenções como estrutura, para que um agente possa perguntar quem chama um método ou quais tabelas estendem uma base e receber uma resposta direta.

## O que o Maguyva extrai em Lua

O Maguyva cobre arquivos `.lua`. Declarações de função, definições `local function` e expressões de função são extraídas, e métodos com dois-pontos como `function Account:deposit()` são atribuídos à tabela dona deles, `Account`. Cadeias de métodos são seguidas chamada a chamada, e chamadas em `self` continuam ligadas ao objeto que as contém.

As convenções do Lua viram relações:

- `require`, `dofile` e `loadfile` registram imports.
- Uma chamada a `setmetatable` no nível do módulo registra herança.
- `ClassName:new()`, `ClassName.new()` e `setmetatable({...}, ClassName)` contam como instanciação.
- `error()` registra um throw, e `pcall` e `xpcall` registram um catch.

O grafo também registra leituras e escritas e fluxo de controle.

## Exemplos de prompts para agentes

- "Quem chama `Inventory:addItem`, e de quais scripts?" (`find_symbol`, depois `dependency_search` incoming)
- "Quais módulos carregam `util.http` com require?" (`dependency_search`)
- "Rastreie o que acontece quando o jogador leva dano." (`get_task_context`)

## Limitações conhecidas

- Cerca de 150 nomes são filtrados das relações: a biblioteca padrão do Lua (`string`, `table`, `math`, `io`, `os`, `coroutine`, `debug` e `utf8`) mais as APIs `vim.*` do Neovim e `ngx.*` do OpenResty. Chamadas a essas APIs não são arestas do grafo, então use `text_pattern_search` para encontrá-las.
- Como módulos e classes são montados com chamadas e tabelas comuns, os presets `classes` e `imports` do `structural_search` não selecionam nada para Lua. Use `find_symbol` ou `text_pattern_search`.
- Lua não tem interfaces nem anotações de tipo, então as relações de implementação de interface e de referência de tipo estão marcadas como não aplicáveis.

## Próximos passos

Conecte um repositório pelo [início rápido](/pt-br/docs/quickstart) e depois confira a matriz de suporte na [página de compatibilidade](/pt-br/docs/compatibility). Para engines que embarcam Lua em código nativo, leia também o [guia de C](/pt-br/languages/c).

## Detalhes do motor

- O suporte a Lua cobre `.lua`. Métodos com dois-pontos como `function Account:deposit()` são atribuídos à tabela dona deles.
- `require`, `dofile` e `loadfile` registram imports, `setmetatable` no nível do módulo registra herança e `ClassName:new()` conta como instanciação.
- `error()` registra um throw e `pcall` um catch, enquanto cerca de 150 nomes da biblioteca padrão, de `vim.*` e de `ngx.*` são filtrados.

## Pontos de entrada MCP úteis

- `find_symbol`: Use para uma função de módulo ou método com dois-pontos quando precisar da definição e dos chamadores.
- `dependency_search`: Use a travessia incoming em um módulo compartilhado para ver quais arquivos o carregam com require antes de movê-lo.
- `text_pattern_search`: Use para chamadas a `vim.*`, `ngx.*` ou à biblioteca padrão, que são filtradas do grafo.