mimo-lang 1.1.1 → 2.0.6

package/interpreter/stdlib/fs.js

@@ -0,0 +1,161 @@
+import { BuiltinFunction } from "../BuiltinFunction.js";
+
+// --- Helper Functions ---
+function expectString(arg, funcName, interpreter, callNode, argPosition = 1) {
+  if (typeof arg !== "string") {
+    throw interpreter.errorHandler.createRuntimeError(
+      `${funcName}() expects a string path as argument ${argPosition}. Got '${typeof arg}'.`,
+      callNode,
+      "TYPE001",
+      'Provide a string path (e.g., "./my_file.txt").'
+    );
+  }
+}
+
+// --- BuiltinFunction Definitions ---
+
+const fsReadFile = new BuiltinFunction(
+  "read_file",
+  ([filePath], interpreter, callNode) => {
+    expectString(filePath, "fs.read_file", interpreter, callNode);
+    try {
+      return interpreter.adapter.readFileSync(filePath, "utf-8");
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to read file '${filePath}': ${e.message}`,
+        callNode,
+        "FS001",
+        "Ensure the file exists and you have read permissions."
+      );
+    }
+  },
+  1
+);
+
+const fsWriteFile = new BuiltinFunction(
+  "write_file",
+  ([filePath, content], interpreter, callNode) => {
+    expectString(filePath, "fs.write_file", interpreter, callNode, 1);
+    if (typeof content !== "string") {
+      throw interpreter.errorHandler.createRuntimeError(
+        "fs.write_file() expects string content as its second argument.",
+        callNode,
+        "TYPE001",
+        "Provide the string content to write to the file."
+      );
+    }
+    try {
+      interpreter.adapter.writeFileSync(filePath, content, "utf-8");
+      return null;
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to write to file '${filePath}': ${e.message}`,
+        callNode,
+        "FS002",
+        "Ensure you have write permissions for the directory."
+      );
+    }
+  },
+  2
+);
+
+const fsFileExists = new BuiltinFunction(
+  "exists",
+  ([filePath], interpreter, callNode) => {
+    expectString(filePath, "fs.exists", interpreter, callNode);
+    return interpreter.adapter.existsSync(filePath);
+  },
+  1
+);
+
+const fsListDir = new BuiltinFunction(
+  "list_dir",
+  ([dirPath], interpreter, callNode) => {
+    expectString(dirPath, "fs.list_dir", interpreter, callNode);
+    try {
+      return interpreter.adapter.readdirSync(dirPath);
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to list directory '${dirPath}': ${e.message}`,
+        callNode,
+        "FS003",
+        "Ensure the path is a directory and you have read permissions."
+      );
+    }
+  },
+  1
+);
+
+const fsMakeDir = new BuiltinFunction(
+  "make_dir",
+  ([dirPath, recursive], interpreter, callNode) => {
+    expectString(dirPath, "fs.make_dir", interpreter, callNode);
+    const recursiveOption = recursive === true; // Only `true` is recursive
+    try {
+      interpreter.adapter.mkdirSync(dirPath, { recursive: recursiveOption });
+      return true;
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to create directory '${dirPath}': ${e.message}`,
+        callNode,
+        "FS004",
+        "Ensure the parent directory exists and you have write permissions."
+      );
+    }
+  },
+  [1, 2] // dirPath, [recursive: boolean]
+);
+
+const fsRemoveFile = new BuiltinFunction(
+  "remove_file",
+  ([filePath], interpreter, callNode) => {
+    expectString(filePath, "fs.remove_file", interpreter, callNode);
+    try {
+      interpreter.adapter.unlinkSync(filePath);
+      return true;
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to remove file '${filePath}': ${e.message}`,
+        callNode,
+        "FS005",
+        "Ensure the file exists and you have write permissions."
+      );
+    }
+  },
+  1
+);
+
+const fsRemoveDir = new BuiltinFunction(
+  "remove_dir",
+  ([dirPath, recursive], interpreter, callNode) => {
+    expectString(dirPath, "fs.remove_dir", interpreter, callNode);
+    const isRecursive = recursive === true;
+    try {
+      if (isRecursive) {
+        interpreter.adapter.rmSync(dirPath, { recursive: true, force: true });
+      } else {
+        interpreter.adapter.rmdirSync(dirPath);
+      }
+      return true;
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Failed to remove directory '${dirPath}': ${e.message}`,
+        callNode,
+        "FS006",
+        "Ensure the directory exists and you have write permissions. Use the recursive option for non-empty directories."
+      );
+    }
+  },
+  [1, 2] // dirPath, [recursive: boolean]
+);
+
+// --- Module Export ---
+export const fsModule = {
+  read_file: fsReadFile,
+  write_file: fsWriteFile,
+  exists: fsFileExists,
+  list_dir: fsListDir,
+  make_dir: fsMakeDir,
+  remove_file: fsRemoveFile,
+  remove_dir: fsRemoveDir,
+};

package/interpreter/stdlib/http.js

@@ -0,0 +1,92 @@
+import { BuiltinFunction } from "../BuiltinFunction.js";
+
+// --- Helper Functions ---
+function expectString(arg, funcName, interpreter, callNode, argPosition = 1) {
+  if (typeof arg !== "string") {
+    throw interpreter.errorHandler.createRuntimeError(
+      `${funcName}() expects a string as argument ${argPosition}. Got '${typeof arg}'.`,
+      callNode,
+      "TYPE001",
+      "Provide a URL string.",
+    );
+  }
+}
+
+function expectObject(arg, funcName, interpreter, callNode, argPosition = 1) {
+  if (typeof arg !== "object" || arg === null || Array.isArray(arg)) {
+    throw interpreter.errorHandler.createRuntimeError(
+      `${funcName}() expects an object as argument ${argPosition}.`,
+      callNode,
+      "TYPE001",
+    );
+  }
+}
+
+// --- BuiltinFunction Definitions ---
+
+const httpGet = new BuiltinFunction(
+  "get",
+  (args, interpreter, callNode) => {
+    const [url] = args;
+    expectString(url, "http.get", interpreter, callNode, 1);
+
+    try {
+      // Call the adapter's synchronous fetch
+      return interpreter.adapter.fetchSync(url, { method: "GET" });
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `HTTP GET request failed: ${e.message}`,
+        callNode,
+        "HTTP001",
+      );
+    }
+  },
+  1, // Arity: 1 argument (url)
+);
+
+const httpPost = new BuiltinFunction(
+  "post",
+  (args, interpreter, callNode) => {
+    const [url, body, headers] = args;
+    expectString(url, "http.post", interpreter, callNode, 1);
+
+    // Mimo allows sending string bodies directly.
+    // If the user has an object, they should use json.stringify() first.
+    if (typeof body !== "string") {
+      throw interpreter.errorHandler.createRuntimeError(
+        `http.post() body must be a string. Use json.stringify(data) first.`,
+        callNode,
+        "TYPE001",
+      );
+    }
+
+    let requestHeaders = { "Content-Type": "application/json" };
+
+    if (headers !== undefined) {
+      expectObject(headers, "http.post", interpreter, callNode, 3);
+      // Merge defaults with user headers
+      requestHeaders = { ...requestHeaders, ...headers };
+    }
+
+    try {
+      return interpreter.adapter.fetchSync(url, {
+        method: "POST",
+        body: body,
+        headers: requestHeaders,
+      });
+    } catch (e) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `HTTP POST request failed: ${e.message}`,
+        callNode,
+        "HTTP002",
+      );
+    }
+  },
+  [2, 3], // Arity: url, body, [headers]
+);
+
+// --- Module Export ---
+export const httpModule = {
+  get: httpGet,
+  post: httpPost,
+};

package/interpreter/stdlib/json.js

@@ -0,0 +1,70 @@
+import { BuiltinFunction } from '../BuiltinFunction.js';
+
+// --- Helper Functions ---
+
+function expectString(arg, funcName, interpreter, callNode) {
+    if (typeof arg !== 'string') {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects a JSON string as its argument.`,
+            callNode, 'TYPE001', 'Provide a string containing valid JSON.'
+        );
+    }
+}
+
+// --- BuiltinFunction Definitions ---
+
+const jsonParse = new BuiltinFunction("parse",
+    ([jsonString], interpreter, callNode) => {
+        expectString(jsonString, "json.parse", interpreter, callNode);
+        try {
+            return JSON.parse(jsonString);
+        } catch (e) {
+            throw interpreter.errorHandler.createRuntimeError(
+                `Failed to parse JSON string: ${e.message}`,
+                callNode, 'JSON001', 'Ensure the string contains valid JSON syntax.'
+            );
+        }
+    },
+    1
+);
+
+const jsonStringify = new BuiltinFunction("stringify",
+    (args, interpreter, callNode) => {
+        const [value, indent] = args;
+        let indentArg = null;
+
+        if (args.length > 1) {
+            if (typeof indent !== "number" && typeof indent !== "string") {
+                throw interpreter.errorHandler.createRuntimeError(
+                    "json.stringify() second argument (indent) must be a number or a string.",
+                    callNode, 'TYPE001', 'Provide a number for spaces or a string for the indent characters.'
+                );
+            }
+            if (typeof indent === "number" && indent < 0) {
+                throw interpreter.errorHandler.createRuntimeError(
+                    "json.stringify() indent number must be non-negative.",
+                    callNode, 'ARG001', 'Provide a non-negative number for indentation.'
+                );
+            }
+            indentArg = indent;
+        }
+
+        try {
+            // The `null` replacer argument is standard for JSON.stringify
+            return JSON.stringify(value, null, indentArg);
+        } catch (e) {
+            throw interpreter.errorHandler.createRuntimeError(
+                `Failed to stringify value to JSON: ${e.message}`,
+                callNode, 'JSON001', 'Ensure the value can be serialized to JSON (e.g., no functions or circular references).'
+            );
+        }
+    },
+    [1, 2] // Arity: value, [indent]
+);
+
+
+// --- Module Export ---
+export const jsonModule = {
+    parse: jsonParse,
+    stringify: jsonStringify,
+};

package/interpreter/stdlib/math.js

@@ -0,0 +1,309 @@
+import { BuiltinFunction } from '../BuiltinFunction.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+
+// --- Constants ---
+const MIMO_PI = Math.PI;
+const MIMO_E = Math.E;
+
+// --- Seeded Randomness ---
+let _currentSeed = null;
+
+function seededRandom() {
+    if (_currentSeed === null) return Math.random();
+    // Park-Miller LCG
+    _currentSeed = (_currentSeed * 16807) % 2147483647;
+    return (_currentSeed - 1) / 2147483646;
+}
+
+
+// --- Helper for type checking ---
+// Helper for type checking --- Updated
+function expectNumber(arg, funcName, interpreter, callNode, argPosition = 1) {
+    if (typeof arg !== 'number') {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects a number as argument ${argPosition}. Got '${typeof arg}'.`,
+            callNode, // Pass callNode
+            'TYPE001',
+            `Ensure argument ${argPosition} for '${funcName}' is a number.`
+        );
+    }
+}
+
+function expectNumbers(args, funcName, expectedCount, interpreter, callNode) {
+    if (args.length < expectedCount) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects at least ${expectedCount} arguments, got ${args.length}.`,
+            callNode, // Pass callNode
+            'BUILTIN001',
+            `Provide at least ${expectedCount} arguments for '${funcName}'.`
+        );
+    }
+    for (let i = 0; i < expectedCount; i++) {
+        if (typeof args[i] !== 'number') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `${funcName}() expects a number as argument ${i + 1}. Got '${typeof args[i]}'.`,
+                callNode, // Pass callNode
+                'TYPE001',
+                `Ensure argument ${i + 1} for '${funcName}' is a number.`
+            );
+        }
+    }
+}
+
+// --- BuiltinFunction Definitions ---
+
+const mathSin = new BuiltinFunction("sin", (args, interpreter, callNode) => {
+    expectNumber(args[0], "sin", interpreter, callNode, 1);
+    return Math.sin(args[0]);
+}, 1);
+
+const mathCos = new BuiltinFunction("cos", (args, interpreter, callNode) => {
+    expectNumber(args[0], "cos", interpreter, callNode, 1);
+    return Math.cos(args[0]);
+}, 1);
+
+const mathTan = new BuiltinFunction("tan", (args, interpreter, callNode) => {
+    expectNumber(args[0], "tan", interpreter, callNode, 1);
+    return Math.tan(args[0]);
+}, 1);
+
+const mathAsin = new BuiltinFunction("asin", (args, interpreter, callNode) => {
+    expectNumber(args[0], "asin", interpreter, callNode, 1);
+    return Math.asin(args[0]);
+}, 1);
+
+const mathAcos = new BuiltinFunction("acos", (args, interpreter, callNode) => {
+    expectNumber(args[0], "acos", interpreter, callNode, 1);
+    return Math.acos(args[0]);
+}, 1);
+
+const mathAtan = new BuiltinFunction("atan", (args, interpreter, callNode) => {
+    expectNumber(args[0], "atan", interpreter, callNode, 1);
+    return Math.atan(args[0]);
+}, 1);
+
+const mathAtan2 = new BuiltinFunction("atan2", (args, interpreter, callNode) => {
+    expectNumbers(args, "atan2", 2, interpreter, callNode);
+    return Math.atan2(args[0], args[1]); // y, x
+}, 2);
+
+const mathLog = new BuiltinFunction("log", (args, interpreter, callNode) => { // Natural logarithm
+    expectNumber(args[0], "log", interpreter, callNode, 1);
+    return Math.log(args[0]);
+}, 1);
+
+const mathLog10 = new BuiltinFunction("log10", (args, interpreter, callNode) => {
+    expectNumber(args[0], "log10", interpreter, callNode, 1);
+    return Math.log10(args[0]);
+}, 1);
+
+const mathLog2 = new BuiltinFunction("log2", (args, interpreter, callNode) => {
+    expectNumber(args[0], "log2", interpreter, callNode, 1);
+    return Math.log2(args[0]);
+}, 1);
+
+const mathExp = new BuiltinFunction("exp", (args, interpreter, callNode) => {
+    expectNumber(args[0], "exp", interpreter, callNode, 1);
+    return Math.exp(args[0]);
+}, 1);
+
+const mathPow = new BuiltinFunction("pow", (args, interpreter, callNode) => {
+    expectNumbers(args, "pow", 2, interpreter, callNode);
+    return Math.pow(args[0], args[1]); // base, exponent
+}, 2);
+
+const mathSqrt = new BuiltinFunction("sqrt", (args, interpreter, callNode) => {
+    expectNumber(args[0], "sqrt", interpreter, callNode, 1);
+    return Math.sqrt(args[0]);
+}, 1);
+
+const mathCbrt = new BuiltinFunction("cbrt", (args, interpreter, callNode) => {
+    expectNumber(args[0], "cbrt", interpreter, callNode, 1);
+    return Math.cbrt(args[0]);
+}, 1);
+
+const mathFloor = new BuiltinFunction("floor", (args, interpreter, callNode) => {
+    expectNumber(args[0], "floor", interpreter, callNode, 1);
+    return Math.floor(args[0]);
+}, 1);
+
+const mathCeil = new BuiltinFunction("ceil", (args, interpreter, callNode) => {
+    expectNumber(args[0], "ceil", interpreter, callNode, 1);
+    return Math.ceil(args[0]);
+}, 1);
+
+const mathRound = new BuiltinFunction("round", (args, interpreter, callNode) => {
+    expectNumber(args[0], "round", interpreter, callNode, 1);
+    return Math.round(args[0]);
+}, 1);
+
+const mathAbs = new BuiltinFunction("abs", (args, interpreter, callNode) => {
+    expectNumber(args[0], "abs", interpreter, callNode, 1);
+    return Math.abs(args[0]);
+}, 1);
+
+const mathClamp = new BuiltinFunction("clamp", (args, interpreter, callNode) => {
+    expectNumbers(args, "clamp", 3, interpreter, callNode);
+    const [value, min, max] = args;
+    if (min > max) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "clamp() expects min <= max.",
+            callNode,
+            "ARG001",
+            "Ensure the second argument is less than or equal to the third."
+        );
+    }
+    return Math.min(Math.max(value, min), max);
+}, 3);
+
+const mathLerp = new BuiltinFunction("lerp", (args, interpreter, callNode) => {
+    expectNumbers(args, "lerp", 3, interpreter, callNode);
+    const [a, b, t] = args;
+    return a + (b - a) * t;
+}, 3);
+
+const mathSum = new BuiltinFunction("sum", (args, interpreter, callNode) => {
+    const [arr] = args;
+    if (!Array.isArray(arr)) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "sum() expects an array of numbers.",
+            callNode,
+            "TYPE001",
+            "Provide an array as the first argument to sum()."
+        );
+    }
+    arr.forEach((n, i) => expectNumber(n, "sum", interpreter, callNode, i + 1));
+    return arr.reduce((acc, value) => acc + value, 0);
+}, 1);
+
+const mathMean = new BuiltinFunction("mean", (args, interpreter, callNode) => {
+    const [arr] = args;
+    if (!Array.isArray(arr)) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "mean() expects an array of numbers.",
+            callNode,
+            "TYPE001",
+            "Provide an array as the first argument to mean()."
+        );
+    }
+    if (arr.length === 0) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "mean() cannot be called on an empty array.",
+            callNode,
+            "ARG001",
+            "Provide a non-empty array to mean()."
+        );
+    }
+    arr.forEach((n, i) => expectNumber(n, "mean", interpreter, callNode, i + 1));
+    return arr.reduce((acc, value) => acc + value, 0) / arr.length;
+}, 1);
+
+// min/max support array argument and variadic numbers
+const mathMax = new BuiltinFunction("max", (args, interpreter, callNode) => {
+    if (args.length === 0) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "max() expects at least one number.",
+            callNode,
+            'BUILTIN001',
+            "Provide at least one number to max()."
+        );
+    }
+    if (args.length === 1 && Array.isArray(args[0])) {
+        const arr = args[0];
+        if (arr.length === 0) {
+            throw interpreter.errorHandler.createRuntimeError(
+                "max() cannot be called on an empty array.",
+                callNode,
+                "ARG001",
+                "Provide a non-empty array to max()."
+            );
+        }
+        arr.forEach((arg, i) => expectNumber(arg, "max", interpreter, callNode, i + 1));
+        return Math.max(...arr);
+    }
+    args.forEach((arg, i) => expectNumber(arg, "max", interpreter, callNode, i + 1));
+    return Math.max(...args);
+}, [1, Infinity]); // Arity: 1 to many
+
+
+
+const mathMin = new BuiltinFunction("min", (args, interpreter, callNode) => {
+    if (args.length === 0) {
+        throw interpreter.errorHandler.createRuntimeError(
+            "min() expects at least one number.",
+            callNode,
+            'BUILTIN001',
+            "Provide at least one number to min()."
+        );
+    }
+    if (args.length === 1 && Array.isArray(args[0])) {
+        const arr = args[0];
+        if (arr.length === 0) {
+            throw interpreter.errorHandler.createRuntimeError(
+                "min() cannot be called on an empty array.",
+                callNode,
+                "ARG001",
+                "Provide a non-empty array to min()."
+            );
+        }
+        arr.forEach((arg, i) => expectNumber(arg, "min", interpreter, callNode, i + 1));
+        return Math.min(...arr);
+    }
+    args.forEach((arg, i) => expectNumber(arg, "min", interpreter, callNode, i + 1));
+    return Math.min(...args);
+}, [1, Infinity]); // Arity: 1 to many
+
+// random
+const mathRandom = new BuiltinFunction("random", (args, interpreter, callNode) => {
+    return seededRandom();
+}, 0); // No arguments, returns a random number between 0 and 1
+
+const mathSeed = new BuiltinFunction("seed", (args, interpreter, callNode) => {
+    expectNumber(args[0], "seed", interpreter, callNode, 1);
+    _currentSeed = Math.abs(Math.floor(args[0])) % 2147483647;
+    if (_currentSeed === 0) _currentSeed = 1; // Seed cannot be 0 for this LCG
+    return null;
+}, 1);
+
+const mathRandInt = new BuiltinFunction("randint", (args, interpreter, callNode) => {
+    expectNumbers(args, "randint", 2, interpreter, callNode);
+    const min = Math.ceil(args[0]);
+    const max = Math.floor(args[1]);
+    return Math.floor(seededRandom() * (max - min + 1)) + min;
+}, 2);
+
+
+
+
+// --- Export the module's contents ---
+export const mathModuleExports = {
+    PI: MIMO_PI,
+    E: MIMO_E,
+    sin: mathSin,
+    cos: mathCos,
+    tan: mathTan,
+    asin: mathAsin,
+    acos: mathAcos,
+    atan: mathAtan,
+    atan2: mathAtan2,
+    log: mathLog,
+    log10: mathLog10,
+    log2: mathLog2,
+    exp: mathExp,
+    pow: mathPow,
+    sqrt: mathSqrt,
+    cbrt: mathCbrt,
+    floor: mathFloor,
+    ceil: mathCeil,
+    round: mathRound,
+    abs: mathAbs,
+    clamp: mathClamp,
+    lerp: mathLerp,
+    sum: mathSum,
+    mean: mathMean,
+    max: mathMax,
+    min: mathMin,
+    random: mathRandom,
+    seed: mathSeed,
+    randint: mathRandInt,
+};