@stevenvo780/st-lang 2.0.4 → 2.5.0

package/dist/runtime/interpreter.js

@@ -12,6 +12,7 @@ const fallacies_1 = require("./fallacies");
 // Barrel import: registra todos los perfiles automáticamente
 require("../profiles");
 const compiler_1 = require("../text-layer/compiler");
+const formula_classifier_1 = require("./formula-classifier");
 class Interpreter {
     theory;
     profile = null;
@@ -53,7 +54,7 @@ class Interpreter {
                 name,
                 params: ['arg'],
                 body: [],
-                source: { line: 0, column: 0 }
+                source: { line: 0, column: 0 },
             });
         }
     }
@@ -315,7 +316,8 @@ class Interpreter {
                         const actualInstanceName = resolvedPrefix.name;
                         const scope = this.theories.get(actualInstanceName);
                         if (scope) {
-                            if (scope.privateMembers.has(memberName) && this.currentTheoryName !== actualInstanceName)
+                            if (scope.privateMembers.has(memberName) &&
+                                this.currentTheoryName !== actualInstanceName)
                                 return f;
                             if (scope.letBindings.has(memberName))
                                 return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
@@ -369,8 +371,9 @@ class Interpreter {
         }
         // Recorrer hijos recursivamente
         if (f.args && f.args.length > 0) {
-            const newArgs = f.args.map(a => a ? this.resolveFormula(a, new Set(visited)) : a);
-            const changed = newArgs.some((a, i) => a !== f.args[i]);
+            const newArgs = f.args.map((a) => (a ? this.resolveFormula(a, new Set(visited)) : a));
+            const oldArgs = f.args;
+            const changed = newArgs.some((a, i) => a !== oldArgs[i]);
             if (changed) {
                 return { ...f, args: newArgs };
             }
@@ -583,7 +586,7 @@ class Interpreter {
     }
     execAnalyzeCmd(stmt) {
         const profile = this.requireProfile();
-        const premises = stmt.premises.map(p => this.resolveFormula(p));
+        const premises = stmt.premises.map((p) => this.resolveFormula(p));
         const conclusion = this.resolveFormula(stmt.conclusion);
         const fallacies = (0, fallacies_1.detectFallacies)(premises, conclusion, profile);
         const pStr = premises.map((p) => (0, format_1.formulaToUnicode)(p)).join(', ');
@@ -705,7 +708,6 @@ class Interpreter {
     /** Crea una instancia de una teoría y la registra en this.theories */
     instantiateTheory(node, instanceName, args = []) {
         const theoryName = instanceName || node.name;
-        const templateName = node.name;
         // Crear scope vacío
         const scope = {
             name: theoryName,
@@ -832,19 +834,19 @@ class Interpreter {
         const profile = this.requireProfile();
         for (const branch of stmt.branches) {
             const resolved = this.resolveFormula(branch.formula);
-            let matched = false;
+            let matched;
             if (branch.condition === 'valid' || branch.condition === 'invalid') {
                 const result = profile.checkValid(resolved);
-                matched = branch.condition === 'valid'
-                    ? result.status === 'valid'
-                    : result.status !== 'valid';
+                matched =
+                    branch.condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
             }
             else {
                 // satisfiable / unsatisfiable
                 const result = profile.checkSatisfiable(resolved);
-                matched = branch.condition === 'satisfiable'
-                    ? (result.status === 'satisfiable' || result.status === 'valid')
-                    : (result.status === 'unsatisfiable');
+                matched =
+                    branch.condition === 'satisfiable'
+                        ? result.status === 'satisfiable' || result.status === 'valid'
+                        : result.status === 'unsatisfiable';
             }
             if (matched) {
                 for (const bodyStmt of branch.body) {
@@ -894,18 +896,18 @@ class Interpreter {
                 break;
             iter++;
             const resolved = this.resolveFormula(stmt.formula);
-            let matched = false;
+            let matched;
             if (stmt.condition === 'valid' || stmt.condition === 'invalid') {
                 const result = profile.checkValid(resolved);
-                matched = stmt.condition === 'valid'
-                    ? result.status === 'valid'
-                    : result.status !== 'valid';
+                matched =
+                    stmt.condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
             }
             else {
                 const result = profile.checkSatisfiable(resolved);
-                matched = stmt.condition === 'satisfiable'
-                    ? (result.status === 'satisfiable' || result.status === 'valid')
-                    : (result.status === 'unsatisfiable');
+                matched =
+                    stmt.condition === 'satisfiable'
+                        ? result.status === 'satisfiable' || result.status === 'valid'
+                        : result.status === 'unsatisfiable';
             }
             if (!matched)
                 break;
@@ -962,8 +964,8 @@ class Interpreter {
             }
             const scope = this.theories.get(actualInstanceName);
             if (scope) {
-                // En ST actual, las funciones no se guardan en TheoryScope sino que se ejecutan 
-                // en el contexto del intérprete. Para soportar métodos de instancia, 
+                // En ST actual, las funciones no se guardan en TheoryScope sino que se ejecutan
+                // en el contexto del intérprete. Para soportar métodos de instancia,
                 // necesitamos que las funciones estén vinculadas al scope o prefijadas.
                 // Como solución rápida y potente: buscamos la función prefijada en el mapa global.
                 const internalFnName = `${actualInstanceName}.${methodName}`;
@@ -1088,7 +1090,7 @@ class Interpreter {
                 const isTrue = result.status === 'valid' || result.status === 'satisfiable';
                 return { kind: 'atom', name: `"${isTrue ? 'True' : 'False'}"`, source: arg.source };
             }
-            catch (e) {
+            catch {
                 return { kind: 'atom', name: '"Error"', source: arg.source };
             }
         }
@@ -1097,17 +1099,21 @@ class Interpreter {
             return { kind: 'atom', name: `"{ ${atoms.join(', ')} }"`, source: arg.source };
         }
         if (name === 'input') {
-            const prompt = arg.kind === 'atom' && arg.name?.startsWith('"') ? arg.name.replace(/(^"|"$)/g, '') : (0, propositional_1.formulaToString)(arg);
-            let inputStr = '';
+            const prompt = arg.kind === 'atom' && arg.name?.startsWith('"')
+                ? arg.name.replace(/(^"|"$)/g, '')
+                : (0, propositional_1.formulaToString)(arg);
+            let inputStr;
             try {
                 process.stdout.write(prompt + ' ');
+                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
                 const fs = require('fs');
                 const buf = Buffer.alloc(256);
                 const bytesRead = fs.readSync(process.stdin.fd, buf, 0, 256, null);
                 inputStr = buf.toString('utf8', 0, bytesRead).trim();
+                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
             }
-            catch (e) {
-                inputStr = "interactive_not_supported";
+            catch {
+                inputStr = 'interactive_not_supported';
             }
             return { kind: 'atom', name: `"${inputStr}"`, source: arg.source };
         }
@@ -1127,7 +1133,7 @@ class Interpreter {
         // Intentar leer el archivo (solo funciona en Node.js / CLI)
         let source;
         try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
             const fs = require('fs');
             const path = require('path');
             // Resolver relativo al archivo actual si no es absoluto
@@ -1135,6 +1141,7 @@ class Interpreter {
                 ? filePath
                 : path.resolve(path.dirname(stmt.source.file || '.'), filePath);
             source = fs.readFileSync(resolved, 'utf-8');
+            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         }
         catch {
             throw new Error(`No se pudo importar '${filePath}': archivo no encontrado`);
@@ -1220,30 +1227,146 @@ class Interpreter {
     emit(msg) {
         this.stdoutLines.push(msg);
     }
+    getVerbosity() {
+        const v = this.letBindings.get('verbose');
+        if (v && v.kind === 'atom' && v.name) {
+            const n = v.name.toLowerCase();
+            // Remove quotes if present
+            return n.replace(/(^"|"$)/g, '');
+        }
+        return 'off';
+    }
     emitResult(cmd, result) {
         const statusIcon = this.statusIcon(result.status);
         this.emit(`${statusIcon} [${cmd}] ${result.output || result.status}`);
+        const verbosity = this.getVerbosity();
+        if (result.educationalNote && verbosity === 'on') {
+            this.emit(`  Nota pedagógica: ${result.educationalNote}`);
+        }
+        if (result.paradoxWarning) {
+            this.emit(`  ⚠ PARADOJA: ${result.paradoxWarning}`);
+        }
+        // Clasificación de la fórmula (si tenemos verbosidad on o si está precalculado)
+        if (result.formula && (verbosity === 'on' || result.formulaClassification)) {
+            const cls = (0, formula_classifier_1.classifyFormula)(result.formula);
+            const name = result.formulaClassification || cls.formulaClassification;
+            if (name) {
+                this.emit(`  Identificación: ${name}`);
+            }
+        }
+        if (result.reasoningType) {
+            this.emit(`  Patrón de razonamiento: ${result.reasoningType}`);
+        }
+        if (result.reasoningSchema) {
+            this.emit(`  Esquema: ${result.reasoningSchema}`);
+        }
+        if (result.normalForms && verbosity === 'on') {
+            this.emit(`  Formas Normales:`);
+            if (result.normalForms.nnf)
+                this.emit(`    NNF: ${result.normalForms.nnf}`);
+            if (result.normalForms.cnf)
+                this.emit(`    CNF: ${result.normalForms.cnf}`);
+            if (result.normalForms.dnf)
+                this.emit(`    DNF: ${result.normalForms.dnf}`);
+            if (result.normalForms.pnf)
+                this.emit(`    PNF: ${result.normalForms.pnf}`);
+            if (result.normalForms.skolem)
+                this.emit(`    Skolem: ${result.normalForms.skolem}`);
+        }
+        if (result.formula && (verbosity === 'on' || cmd === 'explain')) {
+            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+            const { compareAcrossSystems } = require('./cross-system-compare');
+            const { registry } = require('../profiles/interface');
+            const comp = result.crossSystemComparison || compareAcrossSystems(result.formula, registry);
+            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+            if (Object.keys(comp).length > 0) {
+                this.emit(`  Comparación entre sistemas:`);
+                for (const [sys, val] of Object.entries(comp)) {
+                    this.emit(`    ${sys.padEnd(30)} ${val}`);
+                }
+            }
+        }
+        const outputFormatRaw = this.letBindings.get('output');
+        const isLatex = outputFormatRaw?.kind === 'atom' &&
+            outputFormatRaw.name?.replace(/['"]/g, '').toLowerCase() === 'latex';
         const proof = result.proof;
-        if (proof && proof.steps.length > 0) {
-            this.emit('  Prueba:');
-            for (const step of proof.steps) {
-                const premisesStr = step.premises.length > 0 ? ` [de ${step.premises.join(', ')}]` : '';
-                this.emit(`    ${step.stepNumber}. ${(0, format_1.formulaToUnicode)(step.formula)}  — ${step.justification}${premisesStr}`);
+        if (proof &&
+            proof.steps.length > 0 &&
+            (verbosity === 'on' || verbosity === 'proof' || cmd === 'derive' || cmd === 'prove')) {
+            if (isLatex) {
+                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+                const { proofToLaTeX } = require('./format');
+                this.emit('  Prueba (LaTeX):');
+                this.emit(proofToLaTeX(proof));
+                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+            }
+            else {
+                this.emit('  Prueba:');
+                for (const step of proof.steps) {
+                    const premisesStr = step.premises.length > 0 ? ` [de ${step.premises.join(', ')}]` : '';
+                    this.emit(`    ${step.stepNumber}. ${(0, format_1.formulaToUnicode)(step.formula)}  — ${step.justification}${premisesStr}`);
+                }
             }
         }
         const model = result.model;
-        if (model && model.valuation) {
-            this.emit('  Modelo:');
-            for (const [k, v] of Object.entries(model.valuation)) {
-                const desc = this.letDescriptions.get(k);
-                const descStr = desc ? ` ("${desc}")` : '';
-                this.emit(`    ${k}${descStr} = ${String(v)}`);
+        if (model &&
+            (verbosity === 'on' ||
+                verbosity === 'model' ||
+                cmd === 'countermodel' ||
+                cmd === 'check_valid' ||
+                cmd === 'check_satisfiable')) {
+            // Display Kripke model with worlds if available
+            if (model.worlds && model.worlds.length > 0) {
+                this.emit('  Contramodelo Kripke:');
+                this.emit(`    Mundos: {${model.worlds.map((w) => w.name).join(', ')}}`);
+                this.emit('    Accesibilidad:');
+                for (const w of model.worlds) {
+                    if (w.accessible.length > 0) {
+                        this.emit(`      ${w.name} R ${w.accessible.join(', ')}`);
+                    }
+                }
+                this.emit('    Valuación:');
+                for (const w of model.worlds) {
+                    const trueAtoms = Object.entries(w.valuation)
+                        .filter(([, val]) => val)
+                        .map(([k]) => k);
+                    const falseAtoms = Object.entries(w.valuation)
+                        .filter(([, val]) => !val)
+                        .map(([k]) => k);
+                    const parts = [];
+                    if (trueAtoms.length > 0)
+                        parts.push(trueAtoms.join(', '));
+                    if (falseAtoms.length > 0)
+                        parts.push(`¬${falseAtoms.join(', ¬')}`);
+                    this.emit(`      V(${w.name}) = {${parts.join(', ')}}`);
+                }
+            }
+            else if (model.valuation) {
+                // Flat propositional model
+                this.emit('  Modelo / Valuación:');
+                for (const [k, v] of Object.entries(model.valuation)) {
+                    const desc = this.letDescriptions.get(k);
+                    const descStr = desc ? ` ("${desc}")` : '';
+                    this.emit(`    ${k}${descStr} = ${String(v)}`);
+                }
+            }
+        }
+        if (result.tableauTrace &&
+            result.tableauTrace.length > 0 &&
+            (verbosity === 'on' ||
+                verbosity === 'proof' ||
+                cmd === 'check_valid' ||
+                cmd === 'check_satisfiable')) {
+            this.emit('  Traza del tableau:');
+            for (let i = 0; i < result.tableauTrace.length; i++) {
+                const step = result.tableauTrace[i];
+                this.emit(`    ${i + 1}. ${step.toString ? step.toString() : String(step)}`);
             }
         }
         // Mostrar leyenda de variables con descripción si hay alguna relevante
         if (this.letDescriptions.size > 0 && result.formula) {
             const atoms = this.collectAtoms(result.formula);
-            const relevantDescs = atoms.filter(a => this.letDescriptions.has(a));
+            const relevantDescs = atoms.filter((a) => this.letDescriptions.has(a));
             if (relevantDescs.length > 0) {
                 this.emit('  Donde:');
                 for (const a of relevantDescs) {
@@ -1291,23 +1414,72 @@ class Interpreter {
         }
     }
     formatTruthTable(formula, tt) {
+        const verbosity = this.getVerbosity();
+        const isVerbose = verbosity === 'on' || verbosity === 'model';
         const lines = [];
-        const header = [...tt.variables, (0, propositional_1.formulaToString)(formula)];
-        const colWidths = header.map((h) => Math.max(h.length, 5));
+        // Detect Belnap (4-valued) table: results are strings like 'T','F','B','N'
+        const isBelnap = tt.rows.length > 0 && typeof tt.rows[0].result === 'string'
+            && ['T', 'F', 'B', 'N'].includes(String(tt.rows[0].result));
+        if (isBelnap) {
+            lines.push(`Tabla de verdad Belnap (4 valores) para: ${(0, propositional_1.formulaToString)(formula)}`);
+            lines.push('');
+        }
         // Header
-        lines.push(header.map((h, i) => h.padEnd(colWidths[i])).join(' | '));
+        const colLabels = [...tt.variables];
+        if (isVerbose && tt.subFormulas) {
+            tt.subFormulas.forEach((sf) => colLabels.push(sf.label));
+        }
+        colLabels.push((0, propositional_1.formulaToString)(formula));
+        const colWidths = colLabels.map((h) => Math.max(h.length, 5));
+        lines.push(colLabels.map((h, i) => h.padEnd(colWidths[i])).join(' | '));
         lines.push(colWidths.map((w) => '-'.repeat(w)).join('-+-'));
         // Rows
-        for (const row of tt.rows) {
-            const vals = tt.variables.map((v) => (row.valuation[v] ? 'T' : 'F'));
-            vals.push(row.result ? 'T' : 'F');
-            lines.push(vals.map((v, i) => v.padEnd(colWidths[i])).join(' | '));
+        const designated = new Set(['T', 'B']);
+        for (let rowIndex = 0; rowIndex < tt.rows.length; rowIndex++) {
+            const row = tt.rows[rowIndex];
+            const vals = tt.variables.map((v) => {
+                const val = row.valuation[v];
+                if (typeof val === 'string')
+                    return val;
+                return val ? 'T' : 'F';
+            });
+            if (isVerbose && tt.subFormulas && tt.subFormulaValues) {
+                const subVals = tt.subFormulaValues[rowIndex];
+                tt.subFormulas.forEach((sf) => {
+                    let v = subVals[sf.label];
+                    if (typeof v === 'boolean')
+                        v = v ? 'T' : 'F';
+                    vals.push(String(v));
+                });
+            }
+            let finalVal = row.result;
+            if (typeof finalVal === 'boolean')
+                finalVal = finalVal ? 'T' : 'F';
+            vals.push(String(finalVal));
+            const isCountermodel = (tt.isTautology === false && !row.result) || (tt.isSatisfiable && row.result);
+            const rowStr = vals.map((v, i) => v.padEnd(colWidths[i])).join(' | ');
+            // Belnap designation marker
+            if (isBelnap && designated.has(String(finalVal))) {
+                lines.push(`${rowStr}   ⊛ Designado`);
+            }
+            else if (isVerbose && isCountermodel) {
+                lines.push(`${rowStr}   ←`);
+            }
+            else {
+                lines.push(rowStr);
+            }
         }
         lines.push('');
+        if (tt.satisfyingCount !== undefined && tt.totalCount !== undefined) {
+            lines.push(`${tt.satisfyingCount}/${tt.totalCount} valuaciones verdaderas`);
+        }
+        if (isBelnap) {
+            lines.push('Valores designados (portadores de verdad): {T, B}');
+        }
         if (tt.isTautology)
-            lines.push('→ Tautologia');
+            lines.push('→ Tautologia ✓');
         else if (tt.isContradiction)
-            lines.push('→ Contradiccion');
+            lines.push('→ Contradiccion ✗');
         else
             lines.push('→ Contingente (satisfacible)');
         return lines.join('\n');