Melhoramentos na impressão de variáveis e ações do modo LAIR.

Author: leonelsanchesdasilva

.gitignore

@@ -104,4 +104,5 @@ dist
 .tern-port
 
 # Claude
+.claude/
 CLAUDE.md

fontes/interpretador/comum.ts

@@ -42,10 +42,8 @@ export async function visitarDeclaracaoConst(
         );
     }
 
-    return {
-        tipo: declaracao.tipo,
-        tipoExplicito: declaracao.tipoExplicito,
-    };
+    // Retorna o valor da constante para o modo LAIR
+    return interpretador.pilhaEscoposExecucao.obterValorVariavel(declaracao.simbolo);
 }
 
 export async function visitarDeclaracaoDefinicaoFuncao(

fontes/interpretador/interpretador-com-importacao.ts

@@ -1,4 +1,4 @@
-import { Const, Declaracao, FuncaoDeclaracao } from '@designliquido/delegua/declaracoes';
+import { Const, Declaracao, FuncaoDeclaracao, Var } from '@designliquido/delegua/declaracoes';
 import { SimboloInterface } from '@designliquido/delegua/interfaces';
 import { Interpretador } from '@designliquido/delegua/interpretador';
 import { AcessoMetodoOuPropriedade } from '@designliquido/delegua/construtos';
@@ -50,6 +50,14 @@ export class InterpretadorComImportacao
         return comum.visitarConstrutoImportarBiblioteca(this, importarBiblioteca);
     }
 
+    override async visitarDeclaracaoVar(declaracao: Var): Promise<any> {
+        // Chama o método da classe base para fazer a declaração
+        await super.visitarDeclaracaoVar(declaracao);
+
+        // Retorna o valor da variável para o modo LAIR
+        return this.pilhaEscoposExecucao.obterValorVariavel(declaracao.simbolo);
+    }
+
     override visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         return comum.visitarDeclaracaoConst(this, declaracao);
     }

fontes/maquinas-estados-lair/maquina-estados-lair-delegua.ts

@@ -1,14 +1,12 @@
+import chalk from "chalk";
 import { colorize } from "json-colorizer";
-import { RetornoExecucaoInterface } from "@designliquido/delegua";
+import { Const, RetornoExecucaoInterface, Var } from "@designliquido/delegua";
 
 import { FormatadorJson } from "../formatadores";
 import { LexadorJson } from "../lexador/lexador-json";
 import { MaquinaEstadosLairBase } from "./maquina-estados-lair-base";
 
 export class MaquinaEstadosLairDelegua extends MaquinaEstadosLairBase {
-    lexadorJson: LexadorJson;
-    formatadorJson: FormatadorJson;
-    linhas: string[];
     escoposAbertos: number;
 
     constructor(
@@ -19,6 +17,85 @@ export class MaquinaEstadosLairDelegua extends MaquinaEstadosLairBase {
         this.escoposAbertos = 0;
     }
 
+    /**
+     * Verifica se um valor é um tipo simples (número, texto, lógico, nulo)
+     */
+    private ehTipoSimples(valorRetornado: any): boolean {
+        if (!valorRetornado) return false;
+
+        const tipo = valorRetornado.tipo;
+        const valorReal = valorRetornado.valor;
+
+        // Tipos simples: número, texto, lógico, nulo
+        if (tipo === 'número' || tipo === 'texto' || tipo === 'lógico') {
+            return true;
+        }
+
+        if (valorReal === null || valorReal === undefined) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Formata um valor simples para exibição amigável no LAIR
+     */
+    private formatarValorSimples(valorRetornado: any): string {
+        const tipo = valorRetornado?.tipo || 'desconhecido';
+        const valorReal = valorRetornado?.valor;
+
+        if (tipo === 'texto') {
+            return chalk.green(`"${valorReal}"`);
+        } 
+        
+        if (tipo === 'número') {
+            return chalk.cyan(String(valorReal));
+        } 
+        
+        if (tipo === 'lógico') {
+            return chalk.yellow(String(valorReal));
+        } 
+        
+        if (valorReal === null || valorReal === undefined) {
+            return chalk.gray('nulo');
+        }
+
+        return String(valorReal);
+    }
+
+    /**
+     * Detecta se é uma declaração de variável e retorna informações sobre ela
+     */
+    private detectarDeclaracaoVariavel(declaracoes: any[]): {
+        ehDeclaracao: boolean;
+        nomeVariavel?: string;
+        valor?: any;
+        tipo?: string;
+    } {
+        if (!declaracoes || declaracoes.length === 0) {
+            return { ehDeclaracao: false };
+        }
+
+        const primeiraDeclaracao = declaracoes[0];
+
+        // Verifica se é uma declaração Var ou Const
+        if (primeiraDeclaracao.constructor === Var ||
+            primeiraDeclaracao.constructor === Const) {
+            const simbolo = primeiraDeclaracao.simbolo;
+            const inicializador = primeiraDeclaracao.inicializador;
+
+            return {
+                ehDeclaracao: true,
+                nomeVariavel: simbolo?.lexema,
+                valor: inicializador,
+                tipo: primeiraDeclaracao.constructor === Const ? 'const' : 'var'
+            };
+        }
+
+        return { ehDeclaracao: false };
+    }
+
     async executarOuAcumular(linha: string): Promise<any> {
         // Algoritmo: detectar chave aberta na linha sem fechamento.
         this.linhas.push(linha);
@@ -36,14 +113,55 @@ export class MaquinaEstadosLairDelegua extends MaquinaEstadosLairBase {
             this.interfaceLeitura.prompt();
             return;
         } else {
-            const { resultado } = await this.executarLinhas(this.linhas);
-            if (resultado && resultado.length) {
-                const resultadoLexacao = this.lexadorJson.getTokens(resultado[0]);
-                const resultadoFormatacao =
-                    this.formatadorJson.formatar(resultadoLexacao);
-                this.funcaoDeRetorno(colorize(resultadoFormatacao));
+            const retornoExecucao: any = await this.executarLinhas(this.linhas);
+            const { resultado, declaracoes } = retornoExecucao;
+
+            // Detecta se é uma declaração de variável
+            const infoDeclaracao = this.detectarDeclaracaoVariavel(declaracoes);
+
+            if (infoDeclaracao.ehDeclaracao && resultado && resultado.length > 0) {
+                // É uma declaração de variável - mostra mensagem amigável
+                const primeiroResultado = resultado[0];
+                const valorRetornado = primeiroResultado?.valorRetornado || primeiroResultado;
+                const nomeVar = infoDeclaracao.nomeVariavel;
+                const tipoVar = valorRetornado?.tipo || 'desconhecido';
+
+                let valorFormatado: string;
+                if (this.ehTipoSimples(valorRetornado)) {
+                    valorFormatado = this.formatarValorSimples(valorRetornado);
+                } else {
+                    // Para objetos/dicionários, mostra apenas "dicionário" ou similar
+                    valorFormatado = chalk.magenta(`{...} (${tipoVar})`);
+                }
+
+                const mensagem = chalk.dim(`(criada variável ${chalk.bold(nomeVar)} com o valor ${valorFormatado})`);
+                this.funcaoDeRetorno(mensagem);
+            } else if (resultado && resultado.length > 0) {
+                // É uma expressão - verifica se é tipo simples ou complexo
+                const primeiroResultado = resultado[0];
+                const valorRetornado = primeiroResultado?.valorRetornado || primeiroResultado;
+
+                if (this.ehTipoSimples(valorRetornado)) {
+                    // Para tipos simples, mostra de forma amigável
+                    const valorFormatado = this.formatarValorSimples(valorRetornado);
+                    this.funcaoDeRetorno(valorFormatado);
+                } else {
+                    // Para objetos/dicionários, mostra apenas o valor interno sem metadados
+                    const valorReal = valorRetornado?.valor;
+                    if (valorReal !== undefined && valorReal !== null) {
+                        this.funcaoDeRetorno(colorize(JSON.stringify(valorReal, null, 2)));
+                    } else {
+                        // Padrão para o formato original se não conseguir extrair o valor
+                        const resultadoLexacao = this.lexadorJson.getTokens(primeiroResultado);
+                        const resultadoFormatacao = this.formatadorJson.formatar(resultadoLexacao);
+                        this.funcaoDeRetorno(colorize(resultadoFormatacao));
+                    }
+                }
             }
 
+            // Limpa as linhas acumuladas
+            this.linhas = [];
+
             this.interfaceLeitura.setPrompt("\ndelegua> ");
             this.interfaceLeitura.prompt();
         }

fontes/nucleo-execucao.ts

@@ -555,9 +555,14 @@ export class NucleoExecucao
             return { resultado: [] } as RetornoExecucaoInterface;
         }
 
-        return await this.executar(retornoAvaliadorSintatico.declaracoes,
+        const retorno = await this.executar(retornoAvaliadorSintatico.declaracoes,
             true
         );
+
+        // Adicionamos as declarações ao retorno para que a máquina de estados LAIR possa usá-las
+        (retorno as any).declaracoes = retornoAvaliadorSintatico.declaracoes;
+
+        return retorno;
     }
 
     /**

testes/nucleo-execucao.test.ts

@@ -348,4 +348,157 @@ tente {
             expect(nucleoExecucao.dialetos['pitugues']).toBe('Pituguês');
         });
     });
+
+    describe('Modo LAIR - Declaração de variáveis', () => {
+        it('Deve retornar valor ao declarar variável numérica', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado = await nucleoExecucao.executarLinhas(['var a = 1']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            const valorResultado = resultado.resultado[0] as any;
+            expect(valorResultado).toHaveProperty('valorRetornado');
+            expect(valorResultado.valorRetornado).toHaveProperty('valor', 1);
+            expect(valorResultado.valorRetornado).toHaveProperty('tipo', 'número');
+        });
+
+        it('Deve retornar valor ao declarar variável textual', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado = await nucleoExecucao.executarLinhas(['var nome = "João"']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            const valorResultado = resultado.resultado[0] as any;
+            expect(valorResultado).toHaveProperty('valorRetornado');
+            expect(valorResultado.valorRetornado).toHaveProperty('valor', 'João');
+            expect(valorResultado.valorRetornado).toHaveProperty('tipo', 'texto');
+        });
+
+        it('Deve retornar valor ao declarar variável lógica', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado = await nucleoExecucao.executarLinhas(['var ativo = verdadeiro']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            const valorResultado = resultado.resultado[0] as any;
+            expect(valorResultado).toHaveProperty('valorRetornado');
+            expect(valorResultado.valorRetornado).toHaveProperty('valor', true);
+            expect(valorResultado.valorRetornado).toHaveProperty('tipo', 'lógico');
+        });
+
+        it('Deve retornar valor ao declarar variável com dicionário', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado = await nucleoExecucao.executarLinhas(['var dados = {"nome": "João", "idade": 30}']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            const valorResultado = resultado.resultado[0] as any;
+            expect(valorResultado).toHaveProperty('valorRetornado');
+            expect(valorResultado.valorRetornado).toHaveProperty('valor');
+            expect(valorResultado.valorRetornado.valor).toHaveProperty('nome', 'João');
+            expect(valorResultado.valorRetornado.valor).toHaveProperty('idade', 30);
+            expect(valorResultado.valorRetornado).toHaveProperty('tipo', 'dicionário');
+        });
+
+        it('Deve retornar valor ao declarar constante numérica', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado = await nucleoExecucao.executarLinhas(['const PI = 3.14']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            const valorResultado = resultado.resultado[0] as any;
+            expect(valorResultado).toHaveProperty('valorRetornado');
+            expect(valorResultado.valorRetornado).toHaveProperty('valor', 3.14);
+            expect(valorResultado.valorRetornado).toHaveProperty('tipo', 'número');
+        });
+    });
+
+    describe('Modo LAIR - Inspeção de variáveis', () => {
+        it('Deve retornar estrutura completa ao inspecionar variável numérica', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+            // Ativa modo LAIR para manter contexto entre chamadas
+            (nucleoExecucao.avaliadorSintatico as any).modoLair = true;
+
+            await nucleoExecucao.executarLinhas(['var a = 42']);
+            const resultado = await nucleoExecucao.executarLinhas(['a']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            expect(resultado.resultado[0]).toHaveProperty('valorRetornado');
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('valor', 42);
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('tipo', 'número');
+        });
+
+        it('Deve retornar estrutura completa ao inspecionar variável textual', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+            // Ativa modo LAIR para manter contexto entre chamadas
+            (nucleoExecucao.avaliadorSintatico as any).modoLair = true;
+
+            await nucleoExecucao.executarLinhas(['var mensagem = "Olá mundo"']);
+            const resultado = await nucleoExecucao.executarLinhas(['mensagem']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            expect(resultado.resultado[0]).toHaveProperty('valorRetornado');
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('valor', 'Olá mundo');
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('tipo', 'texto');
+        });
+
+        it('Deve retornar estrutura completa ao inspecionar variável lógica', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+            // Ativa modo LAIR para manter contexto entre chamadas
+            (nucleoExecucao.avaliadorSintatico as any).modoLair = true;
+
+            await nucleoExecucao.executarLinhas(['var ativo = falso']);
+            const resultado = await nucleoExecucao.executarLinhas(['ativo']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            expect(resultado.resultado[0]).toHaveProperty('valorRetornado');
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('valor', false);
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('tipo', 'lógico');
+        });
+
+        it('Deve retornar estrutura completa ao inspecionar dicionário', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+            // Ativa modo LAIR para manter contexto entre chamadas
+            (nucleoExecucao.avaliadorSintatico as any).modoLair = true;
+
+            await nucleoExecucao.executarLinhas(['var pessoa = {"nome": "Maria", "idade": 25}']);
+            const resultado = await nucleoExecucao.executarLinhas(['pessoa']);
+
+            expect(resultado.resultado).toBeDefined();
+            expect(resultado.resultado.length).toBeGreaterThan(0);
+            expect(resultado.resultado[0]).toHaveProperty('valorRetornado');
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('valor');
+            expect(resultado.resultado[0].valorRetornado.valor).toHaveProperty('nome', 'Maria');
+            expect(resultado.resultado[0].valorRetornado.valor).toHaveProperty('idade', 25);
+            expect(resultado.resultado[0].valorRetornado).toHaveProperty('tipo', 'dicionário');
+        });
+
+        it('Deve retornar declarações junto com resultado', async () => {
+            const nucleoExecucao = new NucleoExecucao('0.1');
+            nucleoExecucao.configurarDialeto();
+
+            const resultado: any = await nucleoExecucao.executarLinhas(['var x = 10']);
+
+            expect(resultado).toHaveProperty('declaracoes');
+            expect(resultado.declaracoes).toBeDefined();
+            expect(resultado.declaracoes.length).toBeGreaterThan(0);
+        });
+    });
 });