@stevenvo780/st-lang 2.8.0 → 3.0.1

package/dist/runtime/interpreter.d.ts

@@ -54,6 +54,10 @@ export declare class Interpreter {
     /** Memoización automática para funciones con argumentos numéricos (fibonacci, factorial, etc.) */
     private fnMemoCache;
     private static readonly MEMO_CACHE_MAX;
+    /** v3: Formal definitions (define Name(params?) := body) */
+    private definitions;
+    /** v3: Bibliographic sources */
+    private sources;
     constructor();
     /** Registra funciones nativas (Built-ins) para metaprogramación e interactividad */
     private registerBuiltins;
@@ -115,6 +119,10 @@ export declare class Interpreter {
     private execConfidenceDecl;
     private execContextDecl;
     private execRenderCmd;
+    /** Render glossary in the specified format */
+    private renderGlossary;
+    /** Render full analysis document */
+    private renderAnalysis;
     private execAnalyzeCmd;
     private execProofBlock;
     private execTheoryDecl;
@@ -126,6 +134,22 @@ export declare class Interpreter {
     private execWhileStmt;
     private execFnDecl;
     private execReturnStmt;
+    private execDefineDecl;
+    /** Detect circular definitions (A := ... A ...) */
+    private checkCircularDefinition;
+    /** Expand a definition by name with given arguments */
+    private expandDefinition;
+    /** Recursively substitute parameter names with actual argument formulas */
+    private substituteParams;
+    /** Expand all definitions in a formula (one level) */
+    private expandDefinitionsInFormula;
+    /** Try to fold a formula back into a definition reference */
+    private foldFormula;
+    private execUnfoldCmd;
+    private execFoldCmd;
+    private execSourceDecl;
+    private execInterpretCmd;
+    private execGlossaryCmd;
     private executeFnCall;
     private startFunctionFrame;
     private createFunctionFrame;

package/dist/runtime/interpreter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../src/runtime/interpreter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../src/runtime/interpreter.ts"],"names":[],"mappings":"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"}

package/dist/runtime/interpreter.js

@@ -56,6 +56,10 @@ class Interpreter {
     /** Memoización automática para funciones con argumentos numéricos (fibonacci, factorial, etc.) */
     fnMemoCache = new Map();
     static MEMO_CACHE_MAX = 50000;
+    /** v3: Formal definitions (define Name(params?) := body) */
+    definitions = new Map();
+    /** v3: Bibliographic sources */
+    sources = new Map();
     constructor() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
@@ -120,6 +124,8 @@ class Interpreter {
         this.runtimeStepCount = 0;
         this.runtimeCallCount = 0;
         this.fnMemoCache.clear();
+        this.definitions.clear();
+        this.sources.clear();
     }
     // ── Memoización de funciones ──────────────────────────────
     /** Serializa una fórmula a una cadena para usar como clave de cache */
@@ -159,6 +165,9 @@ class Interpreter {
                     case 'import_decl':
                     case 'export_decl':
                     case 'logic_decl':
+                    case 'glossary_cmd':
+                    case 'unfold_cmd':
+                    case 'fold_cmd':
                         return false;
                     case 'if_stmt': {
                         const ifS = s;
@@ -449,6 +458,18 @@ class Interpreter {
                 return;
             case 'export_decl':
                 return this.execExportDecl(stmt);
+            case 'define_decl':
+                return this.execDefineDecl(stmt);
+            case 'unfold_cmd':
+                return this.execUnfoldCmd(stmt);
+            case 'fold_cmd':
+                return this.execFoldCmd(stmt);
+            case 'source_decl':
+                return this.execSourceDecl(stmt);
+            case 'interpret_cmd':
+                return this.execInterpretCmd(stmt);
+            case 'glossary_cmd':
+                return this.execGlossaryCmd(stmt);
         }
     }
     executeStatementsIterative(statements, fallbackFile) {
@@ -617,6 +638,18 @@ class Interpreter {
                 return;
             case 'export_decl':
                 return this.execExportDecl(stmt);
+            case 'define_decl':
+                return this.execDefineDecl(stmt);
+            case 'unfold_cmd':
+                return this.execUnfoldCmd(stmt);
+            case 'fold_cmd':
+                return this.execFoldCmd(stmt);
+            case 'source_decl':
+                return this.execSourceDecl(stmt);
+            case 'interpret_cmd':
+                return this.execInterpretCmd(stmt);
+            case 'glossary_cmd':
+                return this.execGlossaryCmd(stmt);
         }
     }
     selectIfBody(stmt) {
@@ -734,6 +767,13 @@ class Interpreter {
             case 'theory_decl':
                 this.exportedTheories.set(s.name, this.theories.get(s.name));
                 break;
+            case 'define_decl': {
+                const defEntry = this.definitions.get(s.name);
+                if (defEntry) {
+                    this.exportedBindings.set(s.name, defEntry.body);
+                }
+                break;
+            }
         }
     }
     requireProfile() {
@@ -832,6 +872,32 @@ class Interpreter {
                 visited.delete(f.name);
                 return result;
             }
+            // v3: Expand definitions (no-param definitions referenced as atoms)
+            const def = this.definitions.get(f.name);
+            if (def && (!def.params || def.params.length === 0)) {
+                if (visited.has(f.name))
+                    return f;
+                visited.add(f.name);
+                const result = this.resolveFormulaRecursive(def.body, visited);
+                visited.delete(f.name);
+                return result;
+            }
+        }
+        // v3: Expand parametric definitions used as predicates: F(a, b)
+        if (f.kind === 'predicate' && f.name) {
+            const def = this.definitions.get(f.name);
+            if (def && def.params && def.params.length > 0) {
+                // Predicates store arguments as params (string[]) or args (Formula[])
+                let argFormulas;
+                if (f.args && f.args.length > 0) {
+                    argFormulas = f.args.map((a) => (a ? this.resolveFormulaRecursive(a, visited) : a));
+                }
+                else {
+                    argFormulas = (f.params ?? []).map((p) => ({ kind: 'atom', name: p, source: f.source }));
+                }
+                const expanded = this.substituteParams(def.body, def.params, argFormulas);
+                return this.resolveFormulaRecursive(expanded, visited);
+            }
         }
         // Llamada a función como expresión
         if (f.kind === 'fn_call' && f.name) {
@@ -937,6 +1003,9 @@ class Interpreter {
             let isSatisfiable = false;
             let count = 0;
             let satCount = 0;
+            // Accumulate rows for graphic view (cap at 512 to avoid OOM on huge tables)
+            const MAX_GRAPHIC_ROWS = 512;
+            const rows = [];
             for (const v of (0, propositional_1.generateValuationsLazy)(atoms)) {
                 const res = (0, propositional_1.evaluateClassical)(formula, v);
                 if (res) {
@@ -947,6 +1016,10 @@ class Interpreter {
                     isTautology = false;
                 }
                 count++;
+                // Accumulate rows for the graphic table (capped)
+                if (count <= MAX_GRAPHIC_ROWS) {
+                    rows.push({ valuation: { ...v }, result: res });
+                }
                 // Solo imprimir las primeras 64 filas para no saturar el stdout en tablas masivas
                 if (count <= 64) {
                     const row = atoms.map((a) => (v[a] ? 'V' : 'F')).join(' | ');
@@ -963,13 +1036,14 @@ class Interpreter {
                 output: `Tabla de verdad de ${count} filas procesada.`,
                 truthTable: {
                     variables: atoms,
-                    rows: [],
+                    rows,
                     subFormulas: [],
                     subFormulaValues: [],
                     isTautology,
                     isContradiction: !isSatisfiable,
                     isSatisfiable,
                     satisfyingCount: satCount,
+                    totalCount: count,
                 },
                 diagnostics: [],
                 formula: formula,
@@ -1070,6 +1144,12 @@ class Interpreter {
     execRenderCmd(stmt) {
         const diags = (0, compiler_1.compileClaimsToTheory)(this.textLayer, this.theory);
         this.diagnostics.push(...diags);
+        if (stmt.target === 'glossary') {
+            return this.renderGlossary(stmt.format);
+        }
+        if (stmt.target === 'analysis') {
+            return this.renderAnalysis(stmt.format);
+        }
         if (stmt.target === 'claims' || stmt.target === 'all') {
             this.emit(`── Render: ${stmt.target} (${stmt.format}) ──`);
             for (const [name, claim] of this.theory.claims) {
@@ -1113,6 +1193,98 @@ class Interpreter {
             this.emit(`Render: ${stmt.target} (${stmt.format})`);
         }
     }
+    /** Render glossary in the specified format */
+    renderGlossary(format) {
+        if (format === 'json') {
+            const obj = {};
+            for (const [name, def] of this.definitions) {
+                obj[name] = {
+                    params: def.params ?? [],
+                    body: (0, propositional_1.formulaToString)(def.body),
+                    description: def.description ?? null,
+                };
+            }
+            this.emit(JSON.stringify(obj, null, 2));
+            return;
+        }
+        // markdown or default
+        if (this.definitions.size === 0) {
+            this.emit('(sin definiciones)');
+            return;
+        }
+        for (const [name, def] of this.definitions) {
+            const paramsStr = def.params?.length ? `(${def.params.join(', ')})` : '';
+            const bodyStr = format === 'latex' ? (0, format_1.formulaToLaTeX)(def.body) : (0, format_1.formulaToUnicode)(def.body);
+            if (format === 'latex') {
+                this.emit(`\\newcommand{\\${name}}{${bodyStr}} % ${def.description ?? ''}`);
+            }
+            else {
+                this.emit(`- **${name}${paramsStr}** := ${bodyStr}`);
+                if (def.description)
+                    this.emit(`  > ${def.description}`);
+            }
+        }
+    }
+    /** Render full analysis document */
+    renderAnalysis(format) {
+        const isLatex = format === 'latex';
+        const heading = (level, text) => {
+            if (isLatex)
+                return `${'\\'.repeat(1)}${'sub'.repeat(level - 1)}section{${text}}`;
+            return `${'#'.repeat(level)} ${text}`;
+        };
+        this.emit(heading(1, 'Análisis'));
+        this.emit('');
+        // Sources
+        if (this.sources.size > 0) {
+            this.emit(heading(2, 'Fuentes'));
+            for (const [, src] of this.sources) {
+                const yearStr = src.year ? ` (${src.year})` : '';
+                this.emit(`- ${src.author ?? ''}${yearStr} *${src.work ?? ''}*`);
+            }
+            this.emit('');
+        }
+        // Definitions
+        if (this.definitions.size > 0) {
+            this.emit(heading(2, 'Definiciones'));
+            this.renderGlossary(format);
+            this.emit('');
+        }
+        // Axioms
+        if (this.theory.axioms.size > 0) {
+            this.emit(heading(2, 'Axiomas'));
+            for (const [name, formula] of this.theory.axioms) {
+                this.emit(`- **${name}**: ${(0, format_1.formulaToUnicode)(formula)}`);
+            }
+            this.emit('');
+        }
+        // Theorems
+        if (this.theory.theorems.size > 0) {
+            this.emit(heading(2, 'Teoremas'));
+            for (const [name, formula] of this.theory.theorems) {
+                this.emit(`- **${name}**: ${(0, format_1.formulaToUnicode)(formula)}`);
+            }
+            this.emit('');
+        }
+        // Claims
+        if (this.theory.claims.size > 0) {
+            this.emit(heading(2, 'Claims'));
+            for (const [name, claim] of this.theory.claims) {
+                const fStr = claim.formula ? (0, format_1.formulaToUnicode)(claim.formula) : '(sin fórmula)';
+                this.emit(`- **${name}**: ${fStr}`);
+            }
+            this.emit('');
+        }
+        // Results summary
+        if (this.results.length > 0) {
+            this.emit(heading(2, 'Verificaciones'));
+            for (const r of this.results) {
+                const status = r.status === 'valid' ? '✓' : r.status === 'satisfiable' ? '~' : '✗';
+                const fStr = r.formula ? (0, format_1.formulaToUnicode)(r.formula) : '';
+                this.emit(`- ${fStr}: ${r.status} ${status}`);
+            }
+        }
+    }
     execAnalyzeCmd(stmt) {
         const profile = this.requireProfile();
         const premises = stmt.premises.map((p) => this.resolveFormula(p));
@@ -1341,6 +1513,242 @@ class Interpreter {
             this.returnValue = undefined;
         this.returnSignal = true;
     }
+    // ── v3: Definitions, sources, glossary ──────────────────────────
+    execDefineDecl(stmt) {
+        // Check for circular definitions
+        this.checkCircularDefinition(stmt.name, stmt.body, new Set());
+        const entry = {
+            name: stmt.name,
+            params: stmt.params,
+            body: stmt.body,
+            description: stmt.description,
+        };
+        this.definitions.set(stmt.name, entry);
+        const diags = (0, compiler_1.registerDefinition)(this.textLayer, entry);
+        this.diagnostics.push(...diags);
+        this.invalidateResolveCache();
+        const paramsStr = stmt.params?.length ? `(${stmt.params.join(', ')})` : '';
+        const bodyStr = (0, format_1.formulaToUnicode)(stmt.body);
+        this.emit(`Define ${stmt.name}${paramsStr} := ${bodyStr}`);
+        if (stmt.description) {
+            this.emit(`  → "${stmt.description}"`);
+        }
+    }
+    /** Detect circular definitions (A := ... A ...) */
+    checkCircularDefinition(name, body, visited) {
+        if (!body)
+            return;
+        if (body.kind === 'atom' && body.name) {
+            if (body.name === name) {
+                throw new Error(`Definición circular detectada: '${name}' se refiere a sí mismo`);
+            }
+            if (visited.has(body.name))
+                return;
+            visited.add(body.name);
+            const dep = this.definitions.get(body.name);
+            if (dep) {
+                this.checkCircularDefinition(name, dep.body, visited);
+            }
+        }
+        if (body.args) {
+            for (const arg of body.args) {
+                if (arg)
+                    this.checkCircularDefinition(name, arg, visited);
+            }
+        }
+    }
+    /** Expand a definition by name with given arguments */
+    expandDefinition(name, args) {
+        const def = this.definitions.get(name);
+        if (!def)
+            return null;
+        // If definition has no params, return body directly
+        if (!def.params || def.params.length === 0) {
+            return def.body;
+        }
+        // Substitute params with args
+        const actualArgs = args ?? [];
+        return this.substituteParams(def.body, def.params, actualArgs);
+    }
+    /** Recursively substitute parameter names with actual argument formulas */
+    substituteParams(formula, params, args) {
+        if (!formula)
+            return formula;
+        if (formula.kind === 'atom' && formula.name) {
+            const idx = params.indexOf(formula.name);
+            if (idx >= 0 && idx < args.length) {
+                return args[idx];
+            }
+            return formula;
+        }
+        if (formula.args && formula.args.length > 0) {
+            const newArgs = formula.args.map((a) => (a ? this.substituteParams(a, params, args) : a));
+            let changed = false;
+            for (let i = 0; i < formula.args.length; i++) {
+                if (formula.args[i] !== newArgs[i]) {
+                    changed = true;
+                    break;
+                }
+            }
+            return changed ? { ...formula, args: newArgs } : formula;
+        }
+        return formula;
+    }
+    /** Expand all definitions in a formula (one level) */
+    expandDefinitionsInFormula(f) {
+        if (!f)
+            return f;
+        // If atom matches a definition name (no params), expand it
+        if (f.kind === 'atom' && f.name) {
+            const expanded = this.expandDefinition(f.name);
+            if (expanded)
+                return expanded;
+        }
+        // If it's a predicate-like call (name with args), try to expand parametric definition
+        if (f.kind === 'predicate' && f.name) {
+            const def = this.definitions.get(f.name);
+            if (def && def.params && def.params.length > 0 && f.args) {
+                const expanded = this.expandDefinition(f.name, f.args);
+                if (expanded)
+                    return expanded;
+            }
+        }
+        // Recurse into sub-formulas
+        if (f.args && f.args.length > 0) {
+            const newArgs = f.args.map((a) => (a ? this.expandDefinitionsInFormula(a) : a));
+            let changed = false;
+            for (let i = 0; i < f.args.length; i++) {
+                if (f.args[i] !== newArgs[i]) {
+                    changed = true;
+                    break;
+                }
+            }
+            return changed ? { ...f, args: newArgs } : f;
+        }
+        return f;
+    }
+    /** Try to fold a formula back into a definition reference */
+    foldFormula(f) {
+        const fStr = (0, propositional_1.formulaToString)(f);
+        for (const [name, def] of this.definitions) {
+            if (!def.params || def.params.length === 0) {
+                const defStr = (0, propositional_1.formulaToString)(def.body);
+                if (fStr === defStr) {
+                    return { kind: 'atom', name, source: f.source };
+                }
+            }
+        }
+        return f;
+    }
+    execUnfoldCmd(stmt) {
+        const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
+        const expanded = this.expandDefinitionsInFormula(resolved);
+        const expandedStr = (0, format_1.formulaToUnicode)(expanded);
+        this.emit(`Unfold: ${(0, format_1.formulaToUnicode)(resolved)} → ${expandedStr}`);
+        this.results.push({
+            status: 'valid',
+            output: expandedStr,
+            diagnostics: [],
+            formula: expanded,
+        });
+    }
+    execFoldCmd(stmt) {
+        const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
+        const folded = this.foldFormula(resolved);
+        const foldedStr = (0, format_1.formulaToUnicode)(folded);
+        this.emit(`Fold: ${(0, format_1.formulaToUnicode)(resolved)} → ${foldedStr}`);
+        this.results.push({
+            status: 'valid',
+            output: foldedStr,
+            diagnostics: [],
+            formula: folded,
+        });
+    }
+    execSourceDecl(stmt) {
+        const info = { id: stmt.name };
+        for (const field of stmt.fields) {
+            switch (field.key) {
+                case 'author':
+                    info.author = String(field.value);
+                    break;
+                case 'work':
+                    info.work = String(field.value);
+                    break;
+                case 'year':
+                    info.year = typeof field.value === 'number' ? field.value : parseInt(String(field.value));
+                    break;
+                case 'section':
+                    info.section = String(field.value);
+                    break;
+                case 'edition':
+                    info.edition = String(field.value);
+                    break;
+                case 'url':
+                    info.url = String(field.value);
+                    break;
+            }
+        }
+        this.sources.set(stmt.name, info);
+        const diags = (0, compiler_1.registerSource)(this.textLayer, info);
+        this.diagnostics.push(...diags);
+        const yearStr = info.year ? ` (${info.year})` : '';
+        this.emit(`Source ${stmt.name}: ${info.author ?? ''}${yearStr} — ${info.work ?? ''}`);
+    }
+    execInterpretCmd(stmt) {
+        const formula = this.resolveFormula(stmt.formula);
+        const key = stmt.passageRef ?? stmt.text;
+        const diags = (0, compiler_1.registerInterpretation)(this.textLayer, key, {
+            text: stmt.text,
+            passageRef: stmt.passageRef,
+            formula,
+        });
+        this.diagnostics.push(...diags);
+        // Also register as a let binding so the interpretation is available as a named formula
+        const bindingName = stmt.text.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+        if (bindingName) {
+            this.defineBinding(bindingName, formula);
+        }
+        this.emit(`Interpret: "${stmt.text}" → ${(0, format_1.formulaToUnicode)(formula)}`);
+    }
+    execGlossaryCmd(_stmt) {
+        this.emit('');
+        this.emit('══════════════════════════════════════');
+        this.emit('  GLOSARIO');
+        this.emit('══════════════════════════════════════');
+        if (this.definitions.size === 0) {
+            this.emit('  (sin definiciones registradas)');
+        }
+        else {
+            for (const [name, def] of this.definitions) {
+                const paramsStr = def.params?.length ? `(${def.params.join(', ')})` : '';
+                const bodyStr = (0, format_1.formulaToUnicode)(def.body);
+                this.emit(`  ${name}${paramsStr}  :=  ${bodyStr}`);
+                if (def.description) {
+                    this.emit(`      "${def.description}"`);
+                }
+            }
+        }
+        // Also show sources if any
+        if (this.sources.size > 0) {
+            this.emit('');
+            this.emit('── Fuentes ──');
+            for (const [, src] of this.sources) {
+                const yearStr = src.year ? ` (${src.year})` : '';
+                this.emit(`  ${src.id}: ${src.author ?? ''}${yearStr} — ${src.work ?? ''}`);
+            }
+        }
+        // Show interpretations if any
+        if (this.textLayer.interpretations.size > 0) {
+            this.emit('');
+            this.emit('── Interpretaciones ──');
+            for (const [, interp] of this.textLayer.interpretations) {
+                this.emit(`  "${interp.text}" → ${(0, format_1.formulaToUnicode)(interp.formula)}`);
+            }
+        }
+        this.emit('══════════════════════════════════════');
+        this.emit('');
+    }
+    // ── End v3 ─────────────────────────────────────────────────
     executeFnCall(stmt) {
         // ── Memoización: verificar cache antes de ejecutar ──
         const evaluatedArgs = stmt.args.map((a) => this.evaluateFormulaValue(a));