mimo-lang 1.1.1 → 2.0.6

package/tools/linter.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+
+import { Parser } from '../parser/Parser.js';
+import { Lexer } from '../lexer/Lexer.js';
+import { Linter } from './lint/Linter.js';
+import { loadConfig, findConfigFile, mergeRuleConfigs } from './lint/config.js';
+
+const DEFAULT_RULES = {
+    'no-unused-vars':    true,
+    'prefer-const':      true,
+    'no-magic-numbers':  false,
+    'no-empty-function': false,
+    'max-depth':         false,
+    'no-shadow':         false,
+    'consistent-return': false,
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Synchronous fs reader — injected into config helpers so they stay bundler-safe. */
+const fsReadFile = (p) => fs.readFileSync(p, 'utf-8');
+
+/**
+ * Resolve the merged rule config for a given file path.
+ * Priority: DEFAULT_RULES < .mimorc < caller-supplied `rules` overrides.
+ */
+function resolveRules(filePath, callerRules = {}) {
+    const fileDir  = path.dirname(path.resolve(filePath));
+    const rootDir  = path.resolve('/');
+    const pathJoin = path.join.bind(path);
+
+    const configPath = findConfigFile(fileDir, rootDir, fsReadFile, pathJoin);
+    const fileConfig = configPath ? loadConfig(configPath, fsReadFile) : { rules: {} };
+
+    return mergeRuleConfigs(DEFAULT_RULES, fileConfig.rules, callerRules);
+}
+
+/** Parse source into an AST. Throws on syntax errors. */
+function parseSource(source, filePath) {
+    const lexer = new Lexer(source, filePath);
+    const tokens = [];
+    let token;
+    while ((token = lexer.nextToken()) !== null) {
+        tokens.push(token);
+    }
+    const parser = new Parser(tokens, filePath);
+    return parser.parse();
+}
+
+// ---------------------------------------------------------------------------
+// ANSI helpers
+// ---------------------------------------------------------------------------
+const RESET  = '\x1b[0m';
+const CYAN   = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const RED    = '\x1b[31m';
+const DIM    = '\x1b[90m';
+
+function severityLabel(severity) {
+    return severity === 'error'
+        ? `${RED}error${RESET}`
+        : `${YELLOW}warning${RESET}`;
+}
+
+function squiggleColor(severity) {
+    return severity === 'error' ? RED : YELLOW;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function lintFile(filePath, options = {}) {
+    const { quiet = false, rules = {} } = options;
+    const enabledRules = resolveRules(filePath, rules);
+
+    if (!quiet) {
+        console.log(`Linting ${filePath}...`);
+    }
+    try {
+        const source = fs.readFileSync(filePath, 'utf-8');
+        const ast    = parseSource(source, filePath);
+
+        const linter   = new Linter({ rules: enabledRules });
+        const messages = linter.verify(ast, source, filePath);
+
+        const errors   = messages.filter(m => m.severity === 'error');
+        const warnings = messages.filter(m => m.severity !== 'error');
+
+        if (messages.length === 0) {
+            if (!quiet) {
+                console.log('No problems found.');
+            }
+            return { ok: true, messages, errorCount: 0, warningCount: 0, file: filePath };
+        }
+
+        console.log(`\nFound ${messages.length} problem(s) in ${filePath}:`);
+
+        const sourceLines = source.split('\n');
+        messages.forEach(msg => {
+            const color = squiggleColor(msg.severity);
+            console.log(`\n  ${CYAN}${filePath}:${msg.line}:${msg.column}${RESET}`);
+            console.log(`  ${severityLabel(msg.severity)}  ${msg.message}  ${DIM}${msg.ruleId}${RESET}`);
+
+            const line = sourceLines[msg.line - 1];
+            if (line) {
+                console.log(`\n  ${msg.line} | ${line}`);
+                const padding   = ' '.repeat(String(msg.line).length + 3 + msg.column - 1);
+                const squiggles = '^'.repeat(Math.max(1, msg.endColumn - msg.column));
+                console.log(`  ${padding}${color}${squiggles}${RESET}`);
+            }
+        });
+
+        return {
+            ok: true,
+            messages,
+            errorCount:   errors.length,
+            warningCount: warnings.length,
+            file: filePath,
+        };
+
+    } catch (err) {
+        console.error(`\n${RED}Error linting file ${filePath}:${RESET}`);
+        if (err.format) {
+            const snippet = fs.readFileSync(filePath, 'utf-8').split('\n')[err.location?.line - 1] || '';
+            console.error(err.format(snippet));
+        } else {
+            console.error(err.message);
+        }
+        return {
+            ok:           false,
+            messages:     [],
+            errorCount:   0,
+            warningCount: 0,
+            file:         filePath,
+            error: {
+                message: err.message,
+                line:    err.location?.line,
+                column:  err.location?.column,
+            },
+        };
+    }
+}
+
+export function lintFileJson(filePath, options = {}) {
+    const { rules = {} } = options;
+    const enabledRules = resolveRules(filePath, rules);
+
+    try {
+        const source = fs.readFileSync(filePath, 'utf-8');
+        const ast    = parseSource(source, filePath);
+
+        const linter   = new Linter({ rules: enabledRules });
+        const messages = linter.verify(ast, source, filePath);
+
+        return {
+            ok:   true,
+            file: filePath,
+            messages: messages.map(msg => ({
+                line:      msg.line,
+                column:    msg.column,
+                endColumn: msg.endColumn,
+                message:   msg.message,
+                ruleId:    msg.ruleId,
+                severity:  msg.severity,   // use actual severity, not hard-coded 'warning'
+            })),
+        };
+
+    } catch (err) {
+        return {
+            ok:   false,
+            file: filePath,
+            error: {
+                message: err.message,
+                line:    err.location?.line   || 1,
+                column:  err.location?.column || 1,
+            },
+            messages: [],
+        };
+    }
+}
+
+/**
+ * Parse `--rule:name=true|false` flags from a CLI args array.
+ * Supports an optional severity suffix: `--rule:name=error` or `--rule:name=warning`.
+ */
+export function parseRuleFlags(args) {
+    const rules = {};
+    for (const arg of args) {
+        if (arg.startsWith('--rule:')) {
+            const ruleDef  = arg.slice(7);
+            const eqIndex  = ruleDef.indexOf('=');
+            if (eqIndex !== -1) {
+                const ruleName  = ruleDef.slice(0, eqIndex);
+                const ruleValue = ruleDef.slice(eqIndex + 1).toLowerCase();
+                if (ruleValue === 'false' || ruleValue === '0') {
+                    rules[ruleName] = false;
+                } else if (ruleValue === 'true' || ruleValue === '1') {
+                    rules[ruleName] = true;
+                } else if (ruleValue === 'error' || ruleValue === 'warning') {
+                    rules[ruleName] = { severity: ruleValue };
+                } else {
+                    rules[ruleName] = true; // unknown value — treat as enable
+                }
+            }
+        }
+    }
+    return rules;
+}
+
+// ---------------------------------------------------------------------------
+// Main (direct invocation)
+// ---------------------------------------------------------------------------
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const args          = process.argv.slice(2);
+    const quiet         = args.includes('--quiet');
+    const json          = args.includes('--json');
+    const failOnWarning = args.includes('--fail-on-warning');
+    const rules         = parseRuleFlags(args);
+    const filePaths     = args.filter(arg => !arg.startsWith('--'));
+
+    if (filePaths.length === 0) {
+        console.error('Error: No file path provided.');
+        console.log('Usage: node tools/linter.js [--fail-on-warning] [--quiet] [--json] [--rule:name=true|false|error|warning] <file1.mimo> ...');
+        process.exit(1);
+    }
+
+    if (json) {
+        const results = filePaths.map(p => lintFileJson(p, { rules }));
+        console.log(JSON.stringify(results.length === 1 ? results[0] : results));
+        const hasParseErrors = results.some(r => !r.ok);
+        const errorCount     = results.reduce((sum, r) => sum + r.messages.filter(m => m.severity === 'error').length, 0);
+        const warningCount   = results.reduce((sum, r) => sum + r.messages.filter(m => m.severity !== 'error').length, 0);
+        if (hasParseErrors || errorCount > 0 || (failOnWarning && warningCount > 0)) {
+            process.exit(1);
+        }
+    } else {
+        let hasParseErrors = false;
+        let errorCount     = 0;
+        let warningCount   = 0;
+
+        filePaths.forEach(p => {
+            const result = lintFile(p, { quiet, rules });
+            if (!result.ok) {
+                hasParseErrors = true;
+                return;
+            }
+            errorCount   += result.errorCount;
+            warningCount += result.warningCount;
+        });
+
+        if (hasParseErrors || errorCount > 0 || (failOnWarning && warningCount > 0)) {
+            process.exit(1);
+        }
+    }
+}

package/tools/replFormatter.js

@@ -0,0 +1,93 @@
+import { FunctionValue } from '../interpreter/Values.js';
+import { BuiltinFunction } from '../interpreter/BuiltinFunction.js';
+
+/**
+ * Formats a Mimo value for REPL output.
+ * @param {any} value The value to format
+ * @param {boolean} useColors Whether to use ANSI colors
+ * @param {number} indent Current indentation level
+ * @returns {string} Colored or plain string
+ */
+export function formatValue(value, useColors = true, indent = 0) {
+    const spacing = "  ".repeat(indent);
+
+    const colors = {
+        grey: useColors ? "\x1b[90m" : "",
+        cyan: useColors ? "\x1b[36m" : "",
+        green: useColors ? "\x1b[32m" : "",
+        yellow: useColors ? "\x1b[33m" : "",
+        magenta: useColors ? "\x1b[35m" : "",
+        blue: useColors ? "\x1b[34m" : "",
+        reset: useColors ? "\x1b[0m" : ""
+    };
+
+    if (value === null || value === undefined) return `${colors.grey}null${colors.reset}`;
+
+    // Handle Functions specially to avoid printing the AST
+    if (value instanceof FunctionValue || (value && value.constructor && value.constructor.name === "FunctionValue")) {
+        const name = value.name === '<anonymous>' ? 'anonymous' : value.name;
+        return `${colors.cyan}[Function: ${name}]${colors.reset}`;
+    }
+
+    if (value instanceof BuiltinFunction || (value && value.constructor && value.constructor.name === "BuiltinFunction")) {
+        return `${colors.cyan}[BuiltinFunction: ${value.name}]${colors.reset}`;
+    }
+
+    if (value instanceof Date) {
+        return `${colors.green}datetime(${value.toISOString()})${colors.reset}`;
+    }
+
+    const MAX_ITEMS = 20;
+    const MAX_KEYS = 20;
+
+    if (Array.isArray(value)) {
+        if (value.length === 0) return `${colors.grey}Array(0) []${colors.reset}`;
+
+        const shownItems = value.slice(0, MAX_ITEMS).map(v => formatValue(v, useColors, indent + 1));
+        const hiddenCount = Math.max(0, value.length - shownItems.length);
+        const flatItems = shownItems.join(`${colors.grey}, ${colors.reset}`);
+
+        if (flatItems.length < 60 && hiddenCount === 0) {
+            return `${colors.grey}Array(${value.length}) [${colors.reset}${flatItems}${colors.grey}]${colors.reset}`;
+        }
+
+        const multilineItems = [...shownItems];
+        if (hiddenCount > 0) {
+            multilineItems.push(`${colors.grey}... ${hiddenCount} more${colors.reset}`);
+        }
+
+        return `${colors.grey}Array(${value.length}) [${colors.reset}\n${spacing}  ${multilineItems.join(`${colors.grey},${colors.reset}\n` + spacing + "  ")}\n${spacing}${colors.grey}]${colors.reset}`;
+    }
+
+    if (typeof value === "object") {
+        const keys = Object.keys(value);
+        if (keys.length === 0) return `${colors.grey}{}${colors.reset}`;
+
+        const shownKeys = keys.slice(0, MAX_KEYS);
+        const hiddenCount = Math.max(0, keys.length - shownKeys.length);
+
+        const pairs = shownKeys.map(k => {
+            const val = formatValue(value[k], useColors, indent + 1);
+            return `${colors.blue}${k}${colors.reset}${colors.grey}:${colors.reset} ${val}`;
+        });
+        if (hiddenCount > 0) {
+            pairs.push(`${colors.grey}... ${hiddenCount} more${colors.reset}`);
+        }
+
+        const flatPairs = pairs.join(`${colors.grey}, ${colors.reset}`);
+
+        // Use single-line if short enough
+        if (flatPairs.length < 50) {
+            return `${colors.grey}{${colors.reset}${flatPairs}${colors.grey}}${colors.reset}`;
+        }
+
+        // Multi-line for large objects
+        return `${colors.grey}{${colors.reset}\n${spacing}  ${pairs.join(`${colors.grey},${colors.reset}\n` + spacing + "  ")}\n${spacing}${colors.grey}}${colors.reset}`;
+    }
+
+    if (typeof value === "string") return `${colors.green}"${value}"${colors.reset}`;
+    if (typeof value === "number") return `${colors.yellow}${value}${colors.reset}`;
+    if (typeof value === "boolean") return `${colors.magenta}${value}${colors.reset}`;
+
+    return String(value);
+}

package/tools/stamp-version.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+// tools/stamp-version.js
+// Reads the version from package.json and writes it as a static literal into
+// bin/utils/version.js so that `bun build --compile` bakes the correct string
+// into the standalone binary.
+//
+// Run automatically via the `prebuild:mimo` script, or manually:
+//   bun tools/stamp-version.js
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dir, '..');
+
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+const version = pkg.version;
+
+const target = path.join(root, 'bin', 'utils', 'version.js');
+const content = `// bin/utils/version.js
+// This string is stamped by the \`prebuild:mimo\` script (tools/stamp-version.js).
+// It is a static literal so it survives \`bun build --compile\` and global installs.
+export const VERSION = '${version}';
+
+export function getVersion() {
+    return VERSION;
+}
+`;
+
+fs.writeFileSync(target, content, 'utf-8');
+console.log(`Stamped version ${version} into bin/utils/version.js`);

package/web/index.js

@@ -0,0 +1,9 @@
+/**
+ * @file The entry point for the Mimo web bundle.
+ */
+import { Mimo } from '../index.web.js';
+import { browserAdapter } from '../adapters/browserAdapter.js';
+
+// Expose the Mimo class and the browser adapter to the global scope
+window.Mimo = Mimo;
+window.mimoBrowserAdapter = browserAdapter;

package/cli.js

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "fs";
-import path from "path";
-import Mimo from "./index.js";
-
-// Get the directory of the current script
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-
-// Read the package.json file
-const packageJson = JSON.parse(
-  fs.readFileSync(path.join(__dirname, "package.json"), "utf-8")
-);
-const { version } = packageJson;
-
-// Check if the user asked for the version
-if (process.argv.includes("-v") || process.argv.includes("--version")) {
-  console.log(version);
-  process.exit(0);
-}
-
-// Check if the user asked for help
-if (process.argv.includes("-h") || process.argv.includes("--help")) {
-  console.log("Usage: mimo [FILENAME] [-o|--output] [-t|--time] [-h|--help] [-q|--quiet] [-d|--debug] [-v|--version]");
-  console.log("FILENAME: The file to process.");
-  console.log("-o, --output: Generate output file.");
-  console.log("-t, --time: Measure execution time.");
-  console.log("-h, --help: Show this help message.");
-  console.log("-q, --quiet: Suppress all non-essential output.");
-  console.log("-d, --debug: Display additional debug information.");
-  console.log("-v, --version: Display the version number.");
-  process.exit(0);
-}
-
-// Check if a filename was provided
-if (process.argv.length < 3) {
-  console.error("Error: No file name provided.\n");
-  console.log("Usage: mimo [FILENAME] [-o|--output] [-t|--time] [-h|--help] [-q|--quiet] [-d|--debug] [-v|--version]");
-  console.log("Use the --help flag for more information.\n\n");
-  process.exit(1);
-}
-
-const filename = process.argv[2];
-const shouldGenerateOutput = process.argv.includes("-o") || process.argv.includes("--output");
-const shouldMeasureTime = process.argv.includes("-t") || process.argv.includes("--time");
-const shouldSuppressOutput = process.argv.includes("-q") || process.argv.includes("--quiet");
-const shouldDisplayDebugInfo = process.argv.includes("-d") || process.argv.includes("--debug");
-
-// Check if the file exists
-if (!fs.existsSync(filename)) {
-  console.error(`Error: File '${filename}' does not exist.`);
-  process.exit(1);
-}
-
-// Read the file
-let code;
-try {
-  code = fs.readFileSync(filename, "utf-8");
-} catch (err) {
-  console.error(`Error reading file '${filename}':`, err.message);
-  process.exit(1);
-}
-
-// Run the code
-const mimo = new Mimo();
-try {
-  if (shouldMeasureTime) console.time("Execution time");
-  
-  let { program } = await mimo.run(code);
-
-  if (shouldMeasureTime) console.timeEnd("Execution time");
-
-  if (shouldGenerateOutput) {
-    const outputFilename = path.join(
-      path.dirname(filename),
-      path.basename(filename, path.extname(filename)) + ".js"
-    );
-    fs.writeFileSync(outputFilename, mimo.toJS(program), "utf-8");
-    if (!shouldSuppressOutput) console.log(`Output written to: ${outputFilename}`);
-  }
-} catch (err) {
-  if (shouldDisplayDebugInfo) console.error("Error running code:", err);
-  process.exit(1);
-}

package/compiler/execute/interpreter.js

@@ -1,68 +0,0 @@
-import { interpretBinary } from "./interpreters/binary.js";
-import { interpretCall } from "./interpreters/call.js";
-import { interpretIf } from "./interpreters/if.js";
-import { interpretTryCatch } from "./interpreters/try-catch.js";
-import { interpretWhile } from "./interpreters/while.js";
-import { createFunction } from "./utils/createfunction.js";
-import { evaluate } from "./utils/evaluate.js";
-
-export async function interpretStatement(statement, env) {
-  if (Array.isArray(statement)) {
-    for (let i = 0; i < statement.length; i++) {
-      if (await interpretStatement(statement[i], env)) return true;
-    }
-    return;
-  }
-
-  if (typeof statement === "object") {
-    if (statement.type === "try-catch") {
-      await interpretTryCatch(statement, env);
-    } else {
-      await interpretObjectStatement(statement, env);
-    }
-  }
-}
-
-async function interpretObjectStatement(statement, env) {
-  switch (statement.type) {
-    case "assignment":
-      env[statement.target] = evaluate(statement.value, env);
-      break;
-    case "binary":
-      await interpretBinary(statement, env);
-      break;
-    case "if":
-      await interpretIf(statement, env);
-      break;
-    case "while":
-      await interpretWhile(statement, env);
-      break;
-    case "function":
-      env[statement.name] = createFunction(
-        statement.params,
-        statement.body,
-        env
-      );
-      break;
-    case "return":
-      env["return"] = evaluate(statement.expression, env);
-      return true;
-    case "call":
-      await interpretCall(statement, env);
-      break;
-    case "print":
-      console.log(evaluate(statement.value, env));
-      break;
-    default:
-      console.log("Unknown statement type", statement.type);
-      break;
-  }
-}
-
-export async function interpret(program, env = {}) {
-  let index = 0;
-  while (index < program.length) {
-    if (await interpretStatement(program[index++], env)) break;
-  }
-  return env;
-}

package/compiler/execute/interpreters/binary.js

@@ -1,12 +0,0 @@
-import { evaluate } from "../utils/evaluate.js";
-
-export async function interpretBinary(statement, env) {
-    if (env[statement.target] === undefined) {
-        env[statement.target] = null;
-    }
-    env[statement.target] = await operate(
-        statement.operator,
-        await evaluate(statement.left, env),
-        await evaluate(statement.right, env)
-    );
-}

package/compiler/execute/interpreters/call.js

@@ -1,10 +0,0 @@
-import { evaluate } from "../utils/evaluate.js";
-
-export async function interpretCall(statement, env) {
-    const func = env[statement.name];
-    if (typeof func !== "function") {
-        throw new Error(`${statement.name} is not a function`);
-    }
-    const args = statement.args.map((arg) => evaluate(arg, env));
-    env[statement.target] = await func(...args);
-}

package/compiler/execute/interpreters/if.js

@@ -1,10 +0,0 @@
-import { interpretStatement } from "../interpreter.js";
-import { evaluate } from "../utils/evaluate.js";
-
-export async function interpretIf(statement, env) {
-    if (evaluate(statement.condition, env)) {
-        if (await interpretStatement(statement.consequent, env)) return true;
-    } else if (statement.alternate) {
-        if (await interpretStatement(statement.alternate, env)) return true;
-    }
-}

package/compiler/execute/interpreters/try-catch.js

@@ -1,10 +0,0 @@
-import { interpretStatement } from "../interpreter.js";
-
-export async function interpretTryCatch(statement, env) {
-    try {
-        await interpretStatement(statement.tryBlock, env);
-    } catch (error) {
-        env[statement.error] = error;
-        await interpretStatement(statement.catchBlock, env);
-    }
-}

package/compiler/execute/interpreters/while.js

@@ -1,8 +0,0 @@
-import { interpretStatement } from "../interpreter.js";
-import { evaluate } from "../utils/evaluate.js";
-
-export async function interpretWhile(statement, env) {
-    while (evaluate(statement.condition, env)) {
-        if (await interpretStatement(statement.body, env)) return true;
-    }
-}

package/compiler/execute/utils/createfunction.js

@@ -1,11 +0,0 @@
-import { interpret } from "../interpreter.js";
-
-export function createFunction(params, body, env) {
-  return async function (...args) {
-    const newEnv = { ...env };
-    params.forEach((param, index) => {
-      newEnv[param] = args[index] ?? undefined;
-    });
-    return (await interpret(body, newEnv))["return"];
-  };
-}

package/compiler/execute/utils/evaluate.js

@@ -1,20 +0,0 @@
-import { operate } from "./operate.js";
-
-export const evaluate = (expression, env) =>
-  expression.type === "literal"
-    ? expression.value
-    : expression.type === "variable"
-    ? env.hasOwnProperty(expression.name)
-      ? env[expression.name]
-      : null
-    : expression.type === "list"
-    ? expression.elements.map((element) => evaluate(element, env))
-    : expression.type === "indexAccess"
-    ? env[expression.name][evaluate(expression.index, env)]
-    : expression.type === "binary"
-    ? operate(
-        expression.operator,
-        evaluate(expression.left, env),
-        evaluate(expression.right, env)
-      )
-    : null;

package/compiler/execute/utils/operate.js

@@ -1,23 +0,0 @@
-const operations = new Map([
-  ["+", (left, right) => left + right],
-  ["-", (left, right) => left - right],
-  ["*", (left, right) => left * right],
-  ["/", (left, right) => left / right],
-  ["%", (left, right) => left % right],
-  ["**", (left, right) => left ** right],
-  [">", (left, right) => left > right],
-  ["<", (left, right) => left < right],
-  [">=", (left, right) => left >= right],
-  ["<=", (left, right) => left <= right],
-  ["==", (left, right) => left == right],
-  ["!=", (left, right) => left != right],
-  ["!", (left) => !left],
-]);
-
-export const operate = (operator, left, right) => {
-  const operation = operations.get(operator);
-  if (!operation) {
-    throw new Error(`Invalid operator: ${operator}`);
-  }
-  return operation(left, right);
-};