yukigo 0.2.2 → 0.3.1

package/.mocharc.json

@@ -1,4 +1,4 @@
-{
-  "extension": ["ts"],
-  "spec": "tests/**/*.spec.ts"
+{
+  "extension": ["ts"],
+  "spec": "tests/**/*.spec.ts"
 }

package/CHANGELOG.md

@@ -1,60 +1,121 @@
-## 0.2.2 (2026-05-01)
-
-### 🩹 Fixes
-
-- **yukigo:** MulangAdapter handle v1 and v2 inspections ([872558f](https://github.com/miyukiproject/yukigo/commit/872558f))
+## 0.3.1 (2026-08-01)
 
 ### 🧱 Updated Dependencies
 
-- Updated yukigo-ast to 0.2.1
+- Updated yukigo-ast to 0.3.1
 
-### ❤️ Thank You
-
-- noiseArch
-
-## 0.2.1 (2026-05-01)
-
-### 🩹 Fixes
-
-- **yukigo:** MulangAdapter handle v1 and v2 inspections ([872558f](https://github.com/miyukiproject/yukigo/commit/872558f))
-
-### 🧱 Updated Dependencies
-
-- Updated yukigo-ast to 0.2.0
-
-### ❤️ Thank You
-
-- noiseArch
-
-## 0.2.0 (2026-04-11)
+## 0.3.0 (2026-08-01)
 
 ### 🚀 Features
 
-- **yukigo:** agrego `clone` a `RuntimeContext` para clonar el entorno ([ee8e0af](https://github.com/miyukiproject/yukigo/commit/ee8e0af))
+- Interpreter NativeBody support & YukigoHooks ([0b854b4](https://github.com/miyukiproject/yukigo/commit/0b854b4))
+- **interpreter:** implement semantic error handling and stack traces ([b61768f](https://github.com/miyukiproject/yukigo/commit/b61768f))
+- **interpreter:** integrate Kernel as the primary execution engine ([503af3d](https://github.com/miyukiproject/yukigo/commit/503af3d))
+- **interpreter:** introduce YukigoKernel and command-based infrastructure ([9380892](https://github.com/miyukiproject/yukigo/commit/9380892))
+- **yukigo:** implement and test YukigoKernel ([3d42ac4](https://github.com/miyukiproject/yukigo/commit/3d42ac4))
 
 ### 🩹 Fixes
 
-- **yukigo:** permitir a las inspections tener args undefined ([4f36ebe](https://github.com/miyukiproject/yukigo/commit/4f36ebe))
-- **yukigo:** Evaluar `Equal` y `NotEqual` fuera de `processBinary` ([31eca15](https://github.com/miyukiproject/yukigo/commit/31eca15))
-- **yukigo:** delegue logica de deepEqual a LazyRuntime ([8496113](https://github.com/miyukiproject/yukigo/commit/8496113))
-- **yukigo:** evaluateConcatLazy permite eager y lazy evaluation ([3faf646](https://github.com/miyukiproject/yukigo/commit/3faf646))
-- **yukigo:** corrijo `isEqual` para que compare strings con listas ([d6225c9](https://github.com/miyukiproject/yukigo/commit/d6225c9))
-- **yukigo:** corrijo manejo de entorno en `applyArguments` y `visitApplication` ([5c7ab1f](https://github.com/miyukiproject/yukigo/commit/5c7ab1f))
-- **yukigo:** capturar correctamente el entorno en `evaluateCons` ([a1bc7a4](https://github.com/miyukiproject/yukigo/commit/a1bc7a4))
-- **yukigo:** `popEnv` no tiene que esperar el `env` por parametro ([575bacf](https://github.com/miyukiproject/yukigo/commit/575bacf))
-- **yukigo:** agrego metodo visitTypeCast faltante ([61c9984](https://github.com/miyukiproject/yukigo/commit/61c9984))
+- **yukigo-e2e:** fixes to pass E2E tests ([02d895f](https://github.com/miyukiproject/yukigo/commit/02d895f))
+- **yukigo:** allow concatenation with Plus operator ([7799416](https://github.com/miyukiproject/yukigo/commit/7799416))
+- **yukigo:** fix circular dependency ([64534a8](https://github.com/miyukiproject/yukigo/commit/64534a8))
+- **yukigo:** failed test didnt throw bc now it handles 1 + "a" ([23ebeb6](https://github.com/miyukiproject/yukigo/commit/23ebeb6))
+- **yukigo:** zero-arity functions and Wollok bugs ([995dad4](https://github.com/miyukiproject/yukigo/commit/995dad4))
+- **yukigo:** ObjectRuntime error should return RaiseCommand not FailCommand ([ccb31fa](https://github.com/miyukiproject/yukigo/commit/ccb31fa))
+- **yukigo:** method registration with arity to allow overload ([8ffcb36](https://github.com/miyukiproject/yukigo/commit/8ffcb36))
+- TypeSignature is not a Binding ([13c2c5a](https://github.com/miyukiproject/yukigo/commit/13c2c5a))
+- **yukigo:** support If and Call nodes in LogicEngine ([a0f4086](https://github.com/miyukiproject/yukigo/commit/a0f4086))
+- **yukigo:** fixed functional tester was evaluating logic tests ([914310e](https://github.com/miyukiproject/yukigo/commit/914310e))
+- **yukigo:** solved scope leak at logical binary operations ([8779899](https://github.com/miyukiproject/yukigo/commit/8779899))
+- ToString operator ([f5284ab](https://github.com/miyukiproject/yukigo/commit/f5284ab))
+- **yukigo:** fix pattern matching in FunctionRuntime ([467cdf7](https://github.com/miyukiproject/yukigo/commit/467cdf7))
+- **yukigo:** fix bitwise negation ([b13ef4d](https://github.com/miyukiproject/yukigo/commit/b13ef4d))
+- **yukigo:** fix asynchronous logic unification and parameter resolution ([e467068](https://github.com/miyukiproject/yukigo/commit/e467068))
+- **yukigo:** arreglo operaciones y sustitucion logica ([c95f33f](https://github.com/miyukiproject/yukigo/commit/c95f33f))
+- fix parsers grammar compilation to export to .cjs ([ef59727](https://github.com/miyukiproject/yukigo/commit/ef59727))
+- **yukigo:** fix tests to reflect correct representations ([76b1512](https://github.com/miyukiproject/yukigo/commit/76b1512))
+- **yukigo:** fix Visitor and LazyRuntime to use new correct methods from context ([0eb9168](https://github.com/miyukiproject/yukigo/commit/0eb9168))
+- **yukigo:** arreglos en logicengine ([0604555](https://github.com/miyukiproject/yukigo/commit/0604555))
+- **yukigo:** fix mini error in oop test ([b9fd07e](https://github.com/miyukiproject/yukigo/commit/b9fd07e))
+- **yukigo:** removed unwanted error handling ([0d1ff15](https://github.com/miyukiproject/yukigo/commit/0d1ff15))
+- **yukigo:** replace instanceof with .is method in analyzer ([d953413](https://github.com/miyukiproject/yukigo/commit/d953413))
+- **yukigo:** add InterpreterConfig as export ([280146c](https://github.com/miyukiproject/yukigo/commit/280146c))
 
 ### 🧱 Updated Dependencies
 
-- Updated yukigo-ast to 0.2.0
+- Updated yukigo-ast to 0.3.0
 
 ### ❤️ Thank You
 
 - noiseArch
 
-## 0.1.0 (2025-12-09)
-
-### 🧱 Updated Dependencies
-
-- Updated yukigo-prolog-parser to 0.1.0
+## 0.2.3 (2026-05-02)
+
+### 🩹 Fixes
+
+- **yukigo:** fix bugs on MulangAdapter ([7fc193d](https://github.com/miyukiproject/yukigo/commit/7fc193d))
+
+### ❤️ Thank You
+
+- noiseArch
+
+## 0.2.2 (2026-05-01)
+
+### 🩹 Fixes
+
+- **yukigo:** MulangAdapter handle v1 and v2 inspections ([872558f](https://github.com/miyukiproject/yukigo/commit/872558f))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.2.1
+
+### ❤️ Thank You
+
+- noiseArch
+
+## 0.2.1 (2026-05-01)
+
+### 🩹 Fixes
+
+- **yukigo:** MulangAdapter handle v1 and v2 inspections ([872558f](https://github.com/miyukiproject/yukigo/commit/872558f))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.2.0
+
+### ❤️ Thank You
+
+- noiseArch
+
+## 0.2.0 (2026-04-11)
+
+### 🚀 Features
+
+- **yukigo:** agrego `clone` a `RuntimeContext` para clonar el entorno ([ee8e0af](https://github.com/miyukiproject/yukigo/commit/ee8e0af))
+
+### 🩹 Fixes
+
+- **yukigo:** permitir a las inspections tener args undefined ([4f36ebe](https://github.com/miyukiproject/yukigo/commit/4f36ebe))
+- **yukigo:** Evaluar `Equal` y `NotEqual` fuera de `processBinary` ([31eca15](https://github.com/miyukiproject/yukigo/commit/31eca15))
+- **yukigo:** delegue logica de deepEqual a LazyRuntime ([8496113](https://github.com/miyukiproject/yukigo/commit/8496113))
+- **yukigo:** evaluateConcatLazy permite eager y lazy evaluation ([3faf646](https://github.com/miyukiproject/yukigo/commit/3faf646))
+- **yukigo:** corrijo `isEqual` para que compare strings con listas ([d6225c9](https://github.com/miyukiproject/yukigo/commit/d6225c9))
+- **yukigo:** corrijo manejo de entorno en `applyArguments` y `visitApplication` ([5c7ab1f](https://github.com/miyukiproject/yukigo/commit/5c7ab1f))
+- **yukigo:** capturar correctamente el entorno en `evaluateCons` ([a1bc7a4](https://github.com/miyukiproject/yukigo/commit/a1bc7a4))
+- **yukigo:** `popEnv` no tiene que esperar el `env` por parametro ([575bacf](https://github.com/miyukiproject/yukigo/commit/575bacf))
+- **yukigo:** agrego metodo visitTypeCast faltante ([61c9984](https://github.com/miyukiproject/yukigo/commit/61c9984))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.2.0
+
+### ❤️ Thank You
+
+- noiseArch
+
+## 0.1.0 (2025-12-09)
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-prolog-parser to 0.1.0
 - Updated yukigo-ast to 0.1.0

package/README.md

@@ -1,193 +1,193 @@
-# ❄️ Yukigo
-A universal, multi-language, multi-paradigm code analyzer highly inspired in [mulang](https://github.com/mumuki/mulang)
-
-## Components
-
-### **Abstract Semantic Tree:**
-
-This is the intermediate representation of any language. Allows us to analyse the semantics of the code independently of the paradigm or the language.
-
-### **Analyzer:**
-
-The Analyzer is the component that traverses the AST and runs the specified inspections.
-
-### **Interpreter:**
-
-The Interpreter is the component that evaluates provided Expression nodes and returns the resultant PrimitiveValue 
-
-# Usage
-
-## Installation
-
-We will be using Haskell as the target language in this example.
-
-```
-npm install yukigo yukigo-haskell-parser
-```
-
-or
-
-```
-yarn add yukigo yukigo-haskell-parser
-```
-
-## Example
-
-```ts
-import { Analyzer } from "yukigo";
-import { YukigoHaskellParser } from "yukigo-haskell-parser";
-
-const code = "doble num = num * 2";
-const expectations = [
-  {
-    inspection: "HasBinding",
-    args: { name: "minimoEntre" },
-    expected: false,
-  },
-  {
-    inspection: "HasBinding",
-    args: { name: "doble" },
-    expected: true,
-  },
-];
-
-const parser = new YukigoHaskellParser();
-const ast = parser.parse(code);
-
-const analyzer = new ASTAnalyzer(ast);
-const result = analyzer.analyse(expectations);
-
-console.log(results);
-// [
-//   {
-//     rule: {
-//       inspection: "HasBinding",
-//       args: { name: "minimoEntre" },
-//       expected: false,
-//     },
-//     passed: true,
-//     actual: false,
-//   },
-//   {
-//     rule: {
-//       inspection: "HasBinding",
-//       args: { name: "doble" },
-//       expected: true,
-//     },
-//     passed: true,
-//     actual: true,
-//   },
-// ];
-```
-
-## Example with Mulang's Inspections (in a YAML file)
-
-```ts
-import { Analyzer, translateMulangToInspectionRules } from "yukigo";
-import { YukigoHaskellParser } from "yukigo-haskell-parser";
-
-const code = `
-squareList :: [Int] -> [Int]
-squareList xs = map (\n -> n * n) xs
-
-square :: Int -> Int
-square n = n * n
-
-squareList2 :: [Int] -> [Int]
-squareList2 = map square
-`;
-
-// Assuming the expectations are in a yaml file. Implement a way to load the actual file.
-const mulangInspections = `
-expectations:
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList
-  inspection: HasBinding
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList
-  inspection: HasLambdaExpression
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: square
-  inspection: HasArithmetic
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: doble
-  inspection: Not:HasBinding
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: square
-  inspection: Uses:n
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList2
-  inspection: Uses:map
-`;
-
-const expectations = translateMulangToInspectionRules(mulangInspections);
-
-const parser = new YukigoHaskellParser();
-const ast = parser.parse(code);
-
-const analyzer = new Analyzer(ast);
-const result = analyzer.analyse(expectations);
-
-console.log(results);
-// [
-//   {
-//     rule: { inspection: "HasBinding", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: {
-//       inspection: "HasLambdaExpression",
-//       args: [Object],
-//       expected: true,
-//     },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "HasArithmetic", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "HasBinding", args: [Object], expected: false },
-//     passed: true,
-//     actual: false,
-//   },
-//   {
-//     rule: { inspection: "Uses", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "Uses", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-// ];
-```
-
-# Relevant tools
-- yukigo-ast: A library of AST node definitions and utilities for making yukigo parsers
-  
-## Tools
-- [CLI](https://github.com/noiseArch/yukigo-cli)
-- create-yukigo-parser: A scaffolding tool to quickstart a yukigo parser with recommended configuration
-
-## Parsers
-- Haskell
-- Prolog
-- Wollok
-
-# How to make a parser
-
-A yukigo's parser is a class that implements the interface `YukigoParser` which exposes a public method called `parse` and an `errors` array like this:
-```ts
-errors: string[];
-parse: (code: string) => AST;
-```
-
-The package `yukigo-ast` has all the current supported AST nodes.
-For the grammar, you can use a tool like Jison or Nearley.
-
-Here's a [tutorial](https://miyukiproject.github.io/yukigo/guides/making-a-parser.html) for implementing a small custom language.
+# ❄️ Yukigo
+A universal, multi-language, multi-paradigm code analyzer highly inspired in [mulang](https://github.com/mumuki/mulang)
+
+## Components
+
+### **Abstract Semantic Tree:**
+
+This is the intermediate representation of any language. Allows us to analyse the semantics of the code independently of the paradigm or the language.
+
+### **Analyzer:**
+
+The Analyzer is the component that traverses the AST and runs the specified inspections.
+
+### **Interpreter:**
+
+The Interpreter is the component that evaluates provided Expression nodes and returns the resultant PrimitiveValue 
+
+# Usage
+
+## Installation
+
+We will be using Haskell as the target language in this example.
+
+```
+npm install yukigo yukigo-haskell-parser
+```
+
+or
+
+```
+yarn add yukigo yukigo-haskell-parser
+```
+
+## Example
+
+```ts
+import { Analyzer } from "yukigo";
+import { YukigoHaskellParser } from "yukigo-haskell-parser";
+
+const code = "doble num = num * 2";
+const expectations = [
+  {
+    inspection: "HasBinding",
+    args: { name: "minimoEntre" },
+    expected: false,
+  },
+  {
+    inspection: "HasBinding",
+    args: { name: "doble" },
+    expected: true,
+  },
+];
+
+const parser = new YukigoHaskellParser();
+const ast = parser.parse(code);
+
+const analyzer = new ASTAnalyzer(ast);
+const result = analyzer.analyse(expectations);
+
+console.log(results);
+// [
+//   {
+//     rule: {
+//       inspection: "HasBinding",
+//       args: { name: "minimoEntre" },
+//       expected: false,
+//     },
+//     passed: true,
+//     actual: false,
+//   },
+//   {
+//     rule: {
+//       inspection: "HasBinding",
+//       args: { name: "doble" },
+//       expected: true,
+//     },
+//     passed: true,
+//     actual: true,
+//   },
+// ];
+```
+
+## Example with Mulang's Inspections (in a YAML file)
+
+```ts
+import { Analyzer, translateMulangToInspectionRules } from "yukigo";
+import { YukigoHaskellParser } from "yukigo-haskell-parser";
+
+const code = `
+squareList :: [Int] -> [Int]
+squareList xs = map (\n -> n * n) xs
+
+square :: Int -> Int
+square n = n * n
+
+squareList2 :: [Int] -> [Int]
+squareList2 = map square
+`;
+
+// Assuming the expectations are in a yaml file. Implement a way to load the actual file.
+const mulangInspections = `
+expectations:
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList
+  inspection: HasBinding
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList
+  inspection: HasLambdaExpression
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: square
+  inspection: HasArithmetic
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: doble
+  inspection: Not:HasBinding
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: square
+  inspection: Uses:n
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList2
+  inspection: Uses:map
+`;
+
+const expectations = translateMulangToInspectionRules(mulangInspections);
+
+const parser = new YukigoHaskellParser();
+const ast = parser.parse(code);
+
+const analyzer = new Analyzer(ast);
+const result = analyzer.analyse(expectations);
+
+console.log(results);
+// [
+//   {
+//     rule: { inspection: "HasBinding", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: {
+//       inspection: "HasLambdaExpression",
+//       args: [Object],
+//       expected: true,
+//     },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "HasArithmetic", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "HasBinding", args: [Object], expected: false },
+//     passed: true,
+//     actual: false,
+//   },
+//   {
+//     rule: { inspection: "Uses", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "Uses", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+// ];
+```
+
+# Relevant tools
+- yukigo-ast: A library of AST node definitions and utilities for making yukigo parsers
+  
+## Tools
+- [CLI](https://github.com/noiseArch/yukigo-cli)
+- create-yukigo-parser: A scaffolding tool to quickstart a yukigo parser with recommended configuration
+
+## Parsers
+- Haskell
+- Prolog
+- Wollok
+
+# How to make a parser
+
+A yukigo's parser is a class that implements the interface `YukigoParser` which exposes a public method called `parse` and an `errors` array like this:
+```ts
+errors: string[];
+parse: (code: string) => AST;
+```
+
+The package `yukigo-ast` has all the current supported AST nodes.
+For the grammar, you can use a tool like Jison or Nearley.
+
+Here's a [tutorial](https://miyukiproject.github.io/yukigo/guides/making-a-parser.html) for implementing a small custom language.

package/dist/analyzer/GraphBuilder.d.ts

@@ -25,5 +25,6 @@ export declare class GraphBuilder extends TraverseVisitor {
     visitApplication(node: Application): void;
     visitNew(node: New): void;
     visitExist(node: Exist): void;
+    fallback(node: ASTNode): void;
 }
 export {};

package/dist/analyzer/GraphBuilder.js

@@ -79,7 +79,7 @@ export class GraphBuilder extends TraverseVisitor {
         if (!this.scope)
             return;
         const arr = this.calls.get(this.scope) || [];
-        if (node.functionExpr instanceof SymbolPrimitive)
+        if (node.functionExpr.is(SymbolPrimitive))
             this.calls.set(this.scope, [node.functionExpr.value, ...arr]);
         else
             node.functionExpr.accept(this);
@@ -96,4 +96,5 @@ export class GraphBuilder extends TraverseVisitor {
         const arr = this.calls.get(this.scope) || [];
         this.calls.set(this.scope, [node.identifier.value, ...arr]);
     }
+    fallback(node) { }
 }

package/dist/analyzer/index.d.ts

@@ -6,18 +6,11 @@ export type AnalysisResult = {
     actual: boolean;
     error?: string;
 };
-export type TargetSuffix = "named" | "like" | "except";
-export type InspectionMatcher = {
-    type: string;
-    value?: string;
-};
 export type InspectionRule = {
     inspection: string;
     binding?: string;
     args?: string[];
     expected: boolean;
-    targetSuffix?: TargetSuffix;
-    matcher?: InspectionMatcher;
 };
 export declare const DefaultInspectionSet: InspectionMap;
 export declare const DefaultSmellsSet: InspectionMap;

package/dist/analyzer/index.js

@@ -104,7 +104,7 @@ export class Analyzer {
                 const visited = new Set();
                 while (workList.length > 0) {
                     const currentBinding = workList.shift();
-                    if (visited.has(currentBinding))
+                    if (!currentBinding || visited.has(currentBinding))
                         continue;
                     visited.add(currentBinding);
                     const node = defs.get(currentBinding);
@@ -117,7 +117,7 @@ export class Analyzer {
                 }
             }
             let actual = false;
-            let error;
+            let error = undefined;
             // Execution Loop
             const isGlobalVisitor = !rule.binding || rule.binding === "*";
             const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
@@ -125,7 +125,7 @@ export class Analyzer {
             const visitor = new InspectionClass(...args, normalizedBinding);
             for (const { node, binding } of targets) {
                 try {
-                    if (!isGlobalVisitor && visitor.setBinding) {
+                    if (!isGlobalVisitor && visitor.setBinding && binding) {
                         visitor.setBinding(binding);
                     }
                     node.accept(visitor);

package/dist/analyzer/inspections/functional/functional.d.ts

@@ -14,7 +14,7 @@ export declare class UsesComprehension extends ScopedVisitor {
 }
 export declare class UsesGuards extends ScopedVisitor {
     constructor(scope?: string);
-    visitGuardedBody(node: Yu.GuardedBody): void;
+    visitGuardedExpression(node: Yu.GuardedExpression): void;
 }
 export declare class UsesOtherwise extends ScopedVisitor {
     constructor(scope?: string);

package/dist/analyzer/inspections/functional/functional.js

@@ -46,7 +46,7 @@ let UsesGuards = class UsesGuards extends ScopedVisitor {
     constructor(scope) {
         super(scope);
     }
-    visitGuardedBody(node) {
+    visitGuardedExpression(node) {
         throw new Yu.StopTraversalException();
     }
 };