mimo-lang 1.1.0 → 2.0.6

package/.gitattributes

@@ -0,0 +1,24 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Source code
+*.js text eol=lf
+*.mimo text eol=lf linguist-language=Mimo
+
+# Config files
+*.json text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+
+# Shell scripts
+*.sh text eol=lf
+
+# Binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.woff binary
+*.woff2 binary

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bethropolis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,15 +1,100 @@
-# mimo
+<p align="center">
+  <img src="playground/src/lib/assets/mascot.png" alt="Mimo mascot" width="120">
+</p>
 
-To install dependencies:
+<p align="center">
+  <a href="https://www.npmjs.com/package/mimo-lang">
+    <img src="https://img.shields.io/npm/v/mimo-lang?color=%23a855f7&label=npm&logo=npm" alt="npm version">
+  </a>
+  <a href="https://github.com/bethropolis/mimo/releases">
+    <img src="https://img.shields.io/github/v/release/bethropolis/mimo?color=%236366f1&label=github&logo=github" alt="GitHub release">
+  </a>
+  <a href="https://github.com/bethropolis/mimo/blob/main/LICENSE">
+    <img src="https://img.shields.io/github/license/bethropolis/mimo?color=%2310b981" alt="License">
+  </a>
+  <a href="https://bethropolis.github.io/mimo/">
+    <img src="https://img.shields.io/badge/docs-online-%23f59e0b?logo=book" alt="Documentation">
+  </a>
+</p>
+
+<p align="center">
+  <strong>A minimal prefix-notation programming language</strong>
+</p>
+
+---
+
+## Installation
 
 ```bash
-bun install
+bun install -g mimo-lang
+```
+
+## Usage
+
+### Run Programs
+
+```bash
+mimo path/to/program.mimo
+mimo -e "+ 1 2"
+echo "+ 1 2" | mimo
+```
+
+### REPL
+
+```bash
+mimo repl
 ```
 
-To run:
+### CLI Commands
 
 ```bash
-bun run index.js
+mimo run <file>           # Run a file
+mimo repl                 # Start REPL
+mimo fmt <path> --write   # Format files
+mimo lint <path>          # Lint files
+mimo test <path>          # Run tests
 ```
 
-This project was created using `bun init` in bun v1.0.35. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+## Syntax
+
+```mimo
+function add(a, b)
+  return + a b
+end
+
+call add(4, 8) -> result
+show result
+```
+
+More examples in [`test/source/`](./test/source).
+
+## Development
+
+```bash
+bun install
+bun run check
+```
+
+## Playground
+
+<p>
+  <img src="docs/assets/playground.jpg" alt="Mimo playground" width="600">
+</p>
+
+The playground is a web application that allows you to run Mimo code in your browser.
+
+## About
+this is just a simple language i created to learn more about how programing languages work.
+contributions are welcome.
+
+## Links
+
+- [Documentation](https://bethropolis.github.io/mimo/)
+- [Playground](https://bethropolis.github.io/mimo/playground)
+- [GitHub](https://github.com/bethropolis/mimo)
+
+## License
+
+Released under [MIT](./LICENSE)
+
+<p align="center">happy coding 💜</p>

package/adapters/browserAdapter.js

@@ -0,0 +1,86 @@
+/**
+ * @file An adapter for running Mimo in a web browser environment.
+ * It provides browser-compatible implementations for system interactions.
+ * File system operations are disabled and will throw errors.
+ */
+
+function fsUnavailable() {
+  throw new Error(
+    "File system access is not available in the browser environment.",
+  );
+}
+
+const baseBrowserAdapter = {
+  // --- File System (Disabled by default) ---
+  readFileSync: fsUnavailable,
+  readdirSync: fsUnavailable,
+  existsSync: () => false, // Always return false, as no real file system exists
+  writeFileSync: fsUnavailable,
+  mkdirSync: fsUnavailable,
+  unlinkSync: fsUnavailable,
+  rmdirSync: fsUnavailable,
+  rmSync: fsUnavailable,
+
+  // --- Path (Simplified for URL/string-based paths) ---
+  resolvePath: (...segments) => segments.join("/").replace(/\/+/g, "/"),
+  dirname: (filePath) => {
+    const lastSlash = filePath.lastIndexOf("/");
+    return lastSlash === -1 ? "." : filePath.substring(0, lastSlash);
+  },
+  isAbsolutePath: (filePath) => filePath.startsWith("/"),
+  joinPath: (...segments) => segments.join("/"),
+  basename: (filePath) => {
+    const lastSlash = filePath.lastIndexOf("/");
+    return filePath.substring(lastSlash + 1);
+  },
+  extname: (filePath) => {
+    const base = filePath.substring(filePath.lastIndexOf("/") + 1);
+    const dot = base.lastIndexOf(".");
+    return dot > 0 ? base.substring(dot) : "";
+  },
+
+  // http
+  fetchSync: (url, options = {}) => {
+    try {
+      const xhr = new XMLHttpRequest();
+      // The 3rd argument 'false' makes the request Synchronous
+      xhr.open(options.method || "GET", url, false);
+
+      if (options.headers) {
+        for (const [key, value] of Object.entries(options.headers)) {
+          xhr.setRequestHeader(key, value);
+        }
+      }
+
+      xhr.send(options.body || null);
+
+      return {
+        status: xhr.status,
+        body: xhr.responseText,
+      };
+    } catch (e) {
+      throw new Error("HTTP request failed: " + e.message);
+    }
+  },
+
+  // --- Process (Mocked) ---
+  getArguments: () => [], // No command-line arguments in the browser
+  getEnvVariable: () => null, // No environment variables
+  getEnvAll: () => ({}),
+  exit: (code) => {
+    console.warn(
+      `Mimo script called exit(${code}), but exit is disabled in the browser.`,
+    );
+  },
+  cwd: () => "/", // The "root" in a browser context
+
+  // --- Console (Direct Mapping) ---
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+};
+
+export function createBrowserAdapter(overrides = {}) {
+  return { ...baseBrowserAdapter, ...overrides };
+}
+
+export const browserAdapter = createBrowserAdapter();

package/adapters/nodeAdapter.js

@@ -0,0 +1,101 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+export const nodeAdapter = {
+  readFileSync: (filePath, encoding = "utf-8") =>
+    fs.readFileSync(filePath, encoding),
+
+  readdirSync: (filePath) => fs.readdirSync(filePath),
+
+  existsSync: (filePath) => fs.existsSync(filePath),
+
+  writeFileSync: (filePath, data, encoding = "utf-8") =>
+    fs.writeFileSync(filePath, data, encoding),
+
+  mkdirSync: (filePath, options) => {
+    if (!fs.existsSync(filePath)) {
+      fs.mkdirSync(filePath, options);
+    }
+  },
+  unlinkSync: (filePath) => fs.unlinkSync(filePath),
+  rmdirSync: (filePath) => fs.rmdirSync(filePath),
+
+  rmSync: (filePath, options) => fs.rmSync(filePath, options),
+
+  resolvePath: (...segments) => path.resolve(...segments),
+
+  dirname: (filePath) => path.dirname(filePath),
+
+  isAbsolutePath: (filePath) => path.isAbsolute(filePath),
+
+  joinPath: (...segments) => path.join(...segments),
+
+  basename: (filePath, ext) => path.basename(filePath, ext),
+  extname: (filePath) => path.extname(filePath),
+
+  getArguments: () => process.argv.slice(2),
+
+  getEnvVariable: (variableName) => process.env[variableName],
+  getEnvAll: () => ({ ...process.env }),
+
+  exit: (code) => process.exit(code),
+
+  cwd: () => process.cwd(),
+
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+
+  // --- HTTP Implementation ---
+  fetchSync: (url, options = {}) => {
+    const method = options.method || "GET";
+    const headers = options.headers || {};
+    const body = options.body || null;
+
+    const args = ["-s", "-i", "-X", method];
+
+    for (const [key, value] of Object.entries(headers)) {
+      args.push("-H", `${key}: ${value}`);
+    }
+
+    if (body) {
+      args.push("-d", body);
+    }
+
+    args.push(url);
+
+    const result = spawnSync("curl", args, { encoding: "utf-8" });
+
+    if (result.error) {
+      throw new Error(
+        `HTTP Request failed: ${result.error.message}. Ensure 'curl' is installed.`,
+      );
+    }
+
+    if (result.status !== 0) {
+      throw new Error(
+        `HTTP Connection failed: ${result.stderr || "Unknown error"}`,
+      );
+    }
+
+    const output = result.stdout;
+    const separator = "\r\n\r\n";
+    let splitIndex = output.indexOf(separator);
+    if (splitIndex === -1) splitIndex = output.indexOf("\n\n");
+
+    const headerPart = splitIndex !== -1 ? output.substring(0, splitIndex) : "";
+    const bodyPart =
+      splitIndex !== -1
+        ? output.substring(splitIndex + separator.length)
+        : output;
+
+    const statusLine = headerPart.split("\n")[0] || "";
+    const statusMatch = statusLine.match(/HTTP\/\d(\.\d)?\s+(\d+)/);
+    const statusCode = statusMatch ? parseInt(statusMatch[2], 10) : 0;
+
+    return {
+      status: statusCode,
+      body: bodyPart,
+    };
+  },
+};

package/bin/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+// bin/cli.js — Mimo Language Toolkit entry point
+// This file is intentionally thin: it parses the top-level command and
+// delegates to the appropriate module in bin/commands/.
+
+import { c }          from './utils/colors.js';
+import { getVersion } from './utils/version.js';
+
+// ── Command registry ──────────────────────────────────────────────────────────
+
+const COMMANDS = {
+    help:    () => import('./commands/help.js'),
+    run:     () => import('./commands/run.js'),
+    repl:    () => import('./commands/repl.js'),
+    fmt:     () => import('./commands/fmt.js'),
+    lint:    () => import('./commands/lint.js'),
+    test:    () => import('./commands/test.js'),
+    convert: () => import('./commands/convert.js'),
+    doctor:  () => import('./commands/doctor.js'),
+};
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+    const args    = process.argv.slice(2);
+    const command = args[0];
+    const rest    = args.slice(1);
+
+    // No args → global help
+    if (!command) {
+        const { run } = await import('./commands/help.js');
+        await run([]);
+        return;
+    }
+
+    // Version
+    if (command === '--version' || command === '-v') {
+        console.log(getVersion());
+        return;
+    }
+
+    // Help flags → same as `mimo help`
+    if (command === '--help' || command === '-h' || command === 'help') {
+        const { run } = await import('./commands/help.js');
+        await run(rest);
+        return;
+    }
+
+    // --eval / -e
+    if (command === '--eval' || command === '-e') {
+        const { run, help } = await import('./commands/eval.js');
+        if (rest.includes('--help')) { help(); return; }
+        await run(rest);
+        return;
+    }
+
+    // STDIN shorthand: `mimo -`
+    if (command === '-') {
+        const { run } = await import('./commands/run.js');
+        await run(['-']);
+        return;
+    }
+
+    // Named commands
+    if (command in COMMANDS) {
+        const { run, help } = await COMMANDS[command]();
+        if (rest.includes('--help')) { help(); return; }
+        await run(rest);
+        return;
+    }
+
+    // Default: treat the argument as a file path
+    const { run } = await import('./commands/run.js');
+    await run(args);
+}
+
+main().catch((err) => {
+    console.error(c.error('Unexpected error: ') + (err?.message ?? String(err)));
+    process.exit(1);
+});

package/bin/commands/convert.js

@@ -0,0 +1,27 @@
+// bin/commands/convert.js
+// Converts Mimo source to another language (JavaScript, Python, Alya, …).
+
+import { runConverter } from '../../tools/convert.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo convert')} — Transpile Mimo code to another language
+
+${c.bold('Usage:')}
+  mimo convert --in <file> --out <file> --to <target>
+
+${c.bold('Options:')}
+  --in <file>     Input .mimo file
+  --out <file>    Output file path
+  --to <target>   Target language: javascript, python, alya
+
+${c.bold('Examples:')}
+  mimo convert --in app.mimo --out app.js --to javascript
+  mimo convert --in app.mimo --out app.py --to python
+`);
+}
+
+export async function run(args) {
+    await runConverter(args);
+}

package/bin/commands/doctor.js

@@ -0,0 +1,139 @@
+// bin/commands/doctor.js
+// Validates the Mimo runtime environment, adapter API, and stdlib availability.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { Mimo } from '../../index.js';
+import { nodeAdapter } from '../../adapters/nodeAdapter.js';
+import { c } from '../utils/colors.js';
+
+const REQUIRED_ADAPTER_METHODS = [
+    'readFileSync',
+    'writeFileSync',
+    'existsSync',
+    'dirname',
+    'resolvePath',
+    'joinPath',
+    'basename',
+    'extname',
+    'getEnvVariable',
+    'getEnvAll',
+    'fetchSync',
+];
+
+const STDLIB_MODULES = [
+    'array', 'assert', 'datetime', 'env', 'fs',
+    'http', 'json', 'math', 'object', 'path', 'regex', 'string',
+];
+
+export function help() {
+    console.log(`
+${c.bold('mimo doctor')} — Validate the Mimo runtime environment
+
+${c.bold('Usage:')}
+  mimo doctor
+
+${c.bold('Checks performed:')}
+  - Node adapter API completeness
+  - Bun runtime detection
+  - Filesystem read/write access in current directory
+  - curl availability (required by the http stdlib module)
+  - Interpreter smoke test (evaluates \`+ 1 2\`)
+  - Stdlib module registry (all built-in modules resolve)
+`);
+}
+
+export function run(_args) {
+    const checks = [];
+    const pass = (name, detail) => checks.push({ status: 'PASS', name, detail });
+    const warn = (name, detail) => checks.push({ status: 'WARN', name, detail });
+    const fail = (name, detail) => checks.push({ status: 'FAIL', name, detail });
+
+    // 1. Adapter API
+    const missing = REQUIRED_ADAPTER_METHODS.filter((m) => typeof nodeAdapter[m] !== 'function');
+    if (missing.length === 0) {
+        pass('Adapter API', 'All required adapter methods are present.');
+    } else {
+        fail('Adapter API', `Missing: ${missing.join(', ')}. Add them to adapters/nodeAdapter.js.`);
+    }
+
+    // 2. Bun runtime
+    if (process.versions?.bun) {
+        pass('Bun runtime', `Detected Bun ${process.versions.bun}.`);
+    } else {
+        warn('Bun runtime', 'Bun version could not be detected.');
+    }
+
+    // 3. Filesystem access
+    try {
+        const probe = path.join(process.cwd(), '.mimo_doctor_tmp');
+        fs.writeFileSync(probe, 'ok', 'utf-8');
+        fs.unlinkSync(probe);
+        pass('Filesystem access', 'Read/write operations in current directory work.');
+    } catch (err) {
+        fail('Filesystem access', `Failed RW check in cwd: ${err.message}`);
+    }
+
+    // 4. curl (needed by http stdlib)
+    {
+        const curl = spawnSync('curl', ['--version'], { encoding: 'utf-8' });
+        if (curl.status === 0) {
+            pass('HTTP dependency', 'curl is installed (required by http module).');
+        } else {
+            warn('HTTP dependency', 'curl not found — `http.get/post` will fail until curl is installed.');
+        }
+    }
+
+    // 5. Interpreter smoke test
+    {
+        const mimo = new Mimo(nodeAdapter);
+        try {
+            const result = mimo.run('+ 1 2', '/doctor_smoke.mimo');
+            pass('Interpreter smoke test', `Basic evaluation works (result: ${result}).`);
+        } catch (err) {
+            fail('Interpreter smoke test', String(err));
+        }
+    }
+
+    // 6. Stdlib module registry
+    {
+        const mimo = new Mimo(nodeAdapter);
+        const unresolved = [];
+        for (const mod of STDLIB_MODULES) {
+            try {
+                mimo.interpreter.moduleLoader.loadModule(mod, process.cwd());
+            } catch {
+                unresolved.push(mod);
+            }
+        }
+        if (unresolved.length === 0) {
+            pass('Stdlib module registry', 'All built-in stdlib modules resolved.');
+        } else {
+            fail('Stdlib module registry', `Failed to resolve: ${unresolved.join(', ')}.`);
+        }
+    }
+
+    // ── Report ────────────────────────────────────────────────────────────────
+
+    const statusColor = { PASS: c.green, WARN: c.yellow, FAIL: c.red };
+
+    console.log(`\n${c.bold('Mimo Doctor Report')} ${c.dim(`(${new Date().toISOString()})`)}\n`);
+    for (const item of checks) {
+        const badge = statusColor[item.status](`[${item.status}]`);
+        console.log(`${badge} ${c.bold(item.name)}: ${item.detail}`);
+    }
+
+    const hasFail = checks.some((ch) => ch.status === 'FAIL');
+    const hasWarn = checks.some((ch) => ch.status === 'WARN');
+
+    if (hasFail) {
+        console.log(`\n${c.red(c.bold('Doctor result: FAILED'))}`);
+        process.exit(1);
+    }
+    if (hasWarn) {
+        console.log(`\n${c.yellow(c.bold('Doctor result: PASS WITH WARNINGS'))}`);
+        return;
+    }
+    console.log(`\n${c.green(c.bold('Doctor result: PASS'))}`);
+}

package/bin/commands/eval.js

@@ -0,0 +1,39 @@
+// bin/commands/eval.js
+// Evaluates a string of Mimo code passed directly on the command line.
+
+import { Mimo } from '../../index.js';
+import { nodeAdapter } from '../../adapters/nodeAdapter.js';
+import { formatError } from '../utils/formatError.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo --eval')} — Evaluate a string of Mimo code
+
+${c.bold('Usage:')}
+  mimo --eval <code>
+  mimo -e <code>
+
+${c.bold('Examples:')}
+  mimo -e "show + 1 2"
+  mimo -e 'set x 10 \\n show * x 2'
+`);
+}
+
+export async function run(args) {
+    const code = args[0];
+    if (!code) {
+        console.error(c.error('Error: No code provided to --eval.'));
+        process.exit(1);
+    }
+    const mimo = new Mimo(nodeAdapter);
+    try {
+        const result = mimo.run(code, '/eval');
+        if (result !== undefined && result !== null) {
+            console.log(result);
+        }
+    } catch (err) {
+        console.error(formatError(err, code));
+        process.exit(1);
+    }
+}