Processamento de Texto

Expressoes regulares, diff de texto e divisao semantica de texto.

Carregamento

local text = require("text")

Expressoes Regulares

Compilar

local re, err = text.regexp.compile("[0-9]+")

Retorna: Regexp, error

Match

local ok = re:match_string("abc123")

Retorna: boolean

Find

local match = re:find_string("abc123def")

Retorna: string | nil

Find All

local matches = re:find_all_string("a1b2c3")

Retorna: string[]

Find com Grupos

local match = re:find_string_submatch("user@example.com")

Retorna: string[] | nil (match completo + grupos de captura)

Find All com Grupos

local matches = re:find_all_string_submatch("a=1 b=2")

Retorna: string[][]

Find Index

local pos = re:find_string_index("abc123")

Retorna: table | nil ({inicio, fim}, base 1)

Find All Index

local positions = re:find_all_string_index("a1b2c3")

Retorna: table[]

Replace

local result = re:replace_all_string("a1b2", "X")

Retorna: string

Split

local parts = re:split("a,b,c", -1)

Retorna: string[]

Contagem de Subexpressoes

local count = re:num_subexp()

Retorna: number

Nomes de Subexpressoes

local names = re:subexp_names()

Retorna: string[]

String do Padrão

local pattern = re:string()

Retorna: string

Diff de Texto

Compare versoes de texto e gere patches. Baseado em go-diff (diff-match-patch do Google).

Criar Differ

local diff, err = text.diff.new()
local diff, err = text.diff.new(options)

Retorna: Differ, error

Opções {id="diff-options"}

Compare

Encontra diferencas entre dois textos. Retorna um array de operações descrevendo como transformar text1 em text2.

local diff, _ = text.diff.new()
local diffs, err = diff:compare("hello world", "hello there")

-- diffs contem:
-- {operation = "equal", text = "hello "}
-- {operation = "delete", text = "world"}
-- {operation = "insert", text = "there"}

Retorna: table, error (array de {operation, text})

Operações: "equal", "delete", "insert"

Summarize

Conta caracteres alterados entre versoes.

local diffs, _ = diff:compare("hello world", "hello there")
local summary = diff:summarize(diffs)

-- summary.equals = 6 (caracteres inalterados)
-- summary.deletions = 5 (caracteres removidos)
-- summary.insertions = 5 (caracteres adicionados)

Retorna: table ({insertions, deletions, equals})

Pretty Text

Formata diff com cores ANSI para exibicao em terminal.

local formatted, err = diff:pretty_text(diffs)
print(formatted)

Retorna: string, error

Pretty HTML

Formata diff como HTML com tags <del> e <ins>.

local html, err = diff:pretty_html(diffs)
-- Retorna: "hello <del>world</del><ins>there</ins>"

Retorna: string, error

Criar Patches

Gera patches que podem ser aplicados para transformar um texto em outro. Patches podem ser serializados e aplicados depois.

local text1 = "The quick brown fox jumps over the lazy dog"
local text2 = "The quick red fox jumps over the lazy cat"

local patches, err = diff:patch_make(text1, text2)

Retorna: table, error

Aplicar Patches

Aplica patches para transformar texto. Retorna o resultado e se todos os patches foram aplicados com sucesso.

local result, success = diff:patch_apply(patches, text1)
-- result = "The quick red fox jumps over the lazy cat"
-- success = true

Retorna: string, boolean

Divisao de Texto

Divide documentos grandes em chunks menores preservando limites semanticos. Baseado no text splitter do langchaingo.

Splitter Recursivo

Divide texto usando uma hierarquia de separadores. Primeiro tenta dividir em duas quebras de linha (paragrafos), depois quebra simples, depois espacos, depois caracteres. Usa separadores menores quando chunks excedem o limite de tamanho.

local splitter, err = text.splitter.recursive({
    chunk_size = 1000,
    chunk_overlap = 100
})

local long_text = "Este e um texto longo que precisa ser dividido..."
local chunks, err = splitter:split_text(long_text)
-- chunks = {"Este e um texto...", "...longo que precisa...", "...ser dividido..."}

Retorna: Splitter, error

Opções {id="recursive-splitter-options"}

Splitter Markdown

Divide documentos markdown respeitando a estrutura. Tenta manter headings com seu conteudo, blocos de código intactos e linhas de tabela juntas.

local splitter, err = text.splitter.markdown({
    chunk_size = 2000,
    code_blocks = true,
    heading_hierarchy = true
})

local readme = fs.read("README.md")
local chunks, err = splitter:split_text(readme)

Retorna: Splitter, error

Opções {id="markdown-splitter-options"}

Split Text

Divide um único documento em um array de chunks.

local chunks, err = splitter:split_text(document)

for i, chunk in ipairs(chunks) do
    -- Processa cada chunk (ex: criar embedding, enviar para LLM)
    process(chunk)
end

Retorna: string[], error

Split Batch

Divide multiplos documentos preservando seus metadados. Cada documento de entrada pode produzir multiplos chunks de saida. Todos os chunks herdam os metadados do documento fonte.

-- Entrada: paginas de um PDF com numeros de pagina
local pages = {
    {content = "Conteudo da primeira pagina...", metadata = {page = 1}},
    {content = "Conteudo da segunda pagina...", metadata = {page = 2}}
}

local chunks, err = splitter:split_batch(pages)

-- Saida: cada chunk sabe de qual pagina veio
for _, chunk in ipairs(chunks) do
    print("Pagina " .. chunk.metadata.page .. ": " .. chunk.content:sub(1, 50))
end

Retorna: table, error (array de {content, metadata})

Erros

Veja Error Handling para trabalhar com erros.