mimo-lang 1.1.0 → 2.0.6

package/bin/commands/fmt.js

@@ -0,0 +1,109 @@
+// bin/commands/fmt.js
+// Formats .mimo files using the Mimo pretty-printer.
+
+import { formatFile, formatSource } from '../../tools/formatter.js';
+import { collectMimoFiles, readStdin } from '../utils/fs.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo fmt')} — Format Mimo source files
+
+${c.bold('Usage:')}
+  mimo fmt [options] [paths...]
+  echo "code" | mimo fmt
+
+${c.bold('Options:')}
+  --write          Write formatted output back to files (default: preview)
+  --check          Exit with code 1 if any file is not formatted (CI mode)
+  --quiet          Suppress all output except errors
+  --verbose        Show each file's status even when unchanged
+
+${c.bold('Examples:')}
+  mimo fmt src/                       Preview formatting for all files in src/
+  mimo fmt --write src/               Format files in place
+  mimo fmt --check src/               CI check (non-zero exit if unformatted)
+  echo 'show + 1 2' | mimo fmt        Format from STDIN
+`);
+}
+
+export async function run(args) {
+    const shouldWrite   = args.includes('--write');
+    const shouldCheck   = args.includes('--check');
+    const quiet         = args.includes('--quiet');
+    const verbose       = args.includes('--verbose');
+    const targets       = args.filter((a) => !a.startsWith('--'));
+
+    // STDIN mode
+    if (targets.includes('-') || (targets.length === 0 && !process.stdin.isTTY)) {
+        const source = await readStdin();
+        try {
+            process.stdout.write(formatSource(source, 'stdin'));
+        } catch (err) {
+            console.error(c.error(err.message ?? String(err)));
+            process.exit(1);
+        }
+        return;
+    }
+
+    const files = collectMimoFiles(targets);
+    if (files.length === 0) {
+        console.error(c.error('Error: No .mimo files found for formatting.'));
+        process.exit(1);
+    }
+
+    const t0 = Date.now();
+    let hadErrors      = false;
+    let hadUnformatted = false;
+    let changedCount   = 0;
+
+    for (const file of files) {
+        const result = formatFile(file, { write: shouldWrite, check: shouldCheck, quiet: true });
+        if (!result.ok) {
+            hadErrors = true;
+            // formatFile already printed its own error; nothing extra needed
+            continue;
+        }
+
+        if (shouldCheck) {
+            if (result.changed) {
+                hadUnformatted = true;
+                if (!quiet) console.log(`${c.red('✗')} ${file}`);
+            } else if (verbose) {
+                console.log(`${c.green('✓')} ${file}`);
+            }
+        } else if (shouldWrite) {
+            if (result.changed) {
+                changedCount++;
+                if (!quiet) console.log(`${c.green('formatted')} ${file}`);
+            } else if (verbose) {
+                console.log(`${c.dim('unchanged')} ${file}`);
+            }
+        } else {
+            // Preview mode — print formatted output (formatFile already did it in non-quiet mode)
+            // Re-invoke in non-quiet for preview only when verbose or single file
+            if (!quiet) {
+                formatFile(file, { write: false, check: false, quiet: false });
+            }
+        }
+    }
+
+    const ms = Date.now() - t0;
+
+    if (!quiet && !shouldCheck && shouldWrite) {
+        const summary = changedCount > 0
+            ? c.green(`${changedCount} file${changedCount !== 1 ? 's' : ''} formatted`)
+            : c.dim('All files already formatted');
+        console.log(`\n${summary} ${c.dim(`(${ms}ms)`)}`);
+    }
+
+    if (!quiet && shouldCheck) {
+        if (hadUnformatted) {
+            console.log(c.red(`\nSome files are not formatted. Run \`mimo fmt --write\` to fix.`));
+        } else {
+            console.log(c.green(`\nAll files are properly formatted. ${c.dim(`(${ms}ms)`)}`));
+        }
+    }
+
+    if (hadErrors || hadUnformatted) process.exit(1);
+}

package/bin/commands/help.js

@@ -0,0 +1,72 @@
+// bin/commands/help.js
+// Shows global help, or per-command help when a command name is provided.
+
+import { c }          from '../utils/colors.js';
+import { getVersion } from '../utils/version.js';
+
+// Lazy loaders for each command — mirrors cli.js COMMANDS registry.
+const COMMAND_LOADERS = {
+    run:     () => import('./run.js'),
+    repl:    () => import('./repl.js'),
+    fmt:     () => import('./fmt.js'),
+    lint:    () => import('./lint.js'),
+    test:    () => import('./test.js'),
+    convert: () => import('./convert.js'),
+    doctor:  () => import('./doctor.js'),
+    eval:    () => import('./eval.js'),
+};
+
+export function help() {
+    // `mimo help --help` is a no-op — just show global help
+    run([]);
+}
+
+export async function run(args) {
+    const target = args[0];
+
+    // `mimo help <command>` → delegate to that command's help()
+    if (target && target in COMMAND_LOADERS) {
+        const mod = await COMMAND_LOADERS[target]();
+        mod.help();
+        return;
+    }
+
+    // Unknown sub-command
+    if (target) {
+        console.error(c.error(`Unknown command: ${target}`));
+        console.error(c.dim(`Run ${c.cyan('mimo help')} to see all commands.`));
+        process.exit(1);
+    }
+
+    // Global help
+    console.log(`
+${c.bold('Mimo Language Toolkit')} ${c.dim(`v${getVersion()}`)}
+
+${c.bold('Usage:')}
+  mimo <command> [options]
+  mimo <file>
+
+${c.bold('Commands:')}
+  ${c.cyan('run')} <file>        Execute a Mimo file (also: mimo <file>)
+  ${c.cyan('repl')}              Start the interactive Read-Eval-Print Loop
+  ${c.cyan('fmt')} [paths...]    Format .mimo files
+                   ${c.dim('--write  --check  --quiet  --verbose')}
+  ${c.cyan('lint')} [paths...]   Statically analyse .mimo files
+                   ${c.dim('--fail-on-warning  --quiet  --verbose  --json')}
+  ${c.cyan('test')} [path]       Run test files
+                   ${c.dim('--quiet  --verbose')}
+  ${c.cyan('convert')}           Transpile Mimo to another language
+                   ${c.dim('--in  --out  --to')}
+  ${c.cyan('doctor')}            Validate runtime/tooling environment
+
+${c.bold('Global options:')}
+  ${c.cyan('--version')}, ${c.cyan('-v')}      Show version
+  ${c.cyan('--help')}, ${c.cyan('-h')}         Show this help
+  ${c.cyan('--eval')}, ${c.cyan('-e')} <code>  Evaluate a string of Mimo code
+  ${c.cyan('-')}                  Read and execute Mimo code from STDIN
+
+${c.bold('Per-command help:')}
+  mimo help <command>
+  mimo <command> --help
+`);
+}

package/bin/commands/lint.js

@@ -0,0 +1,117 @@
+// bin/commands/lint.js
+// Statically analyses .mimo files using the Mimo linter.
+
+import { lintFile, lintFileJson, parseRuleFlags } from '../../tools/linter.js';
+import { collectMimoFiles } from '../utils/fs.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo lint')} — Statically analyse Mimo source files
+
+${c.bold('Usage:')}
+  mimo lint [options] [paths...]
+
+${c.bold('Options:')}
+  --fail-on-warning    Exit 1 on warnings (not just errors)
+  --quiet              Suppress per-file output; print only summary
+  --verbose            Show rule IDs alongside messages
+  --json               Output results as JSON (for tooling)
+  --rule:<name>=<bool> Override a specific rule (e.g. --rule:no-magic-numbers=true)
+
+${c.bold('Available rules:')}
+  no-unused-vars       (on by default)
+  prefer-const         (on by default)
+  no-magic-numbers
+  no-empty-function
+  max-depth
+  no-shadow
+  consistent-return
+
+${c.bold('Examples:')}
+  mimo lint src/
+  mimo lint --fail-on-warning src/
+  mimo lint --rule:no-magic-numbers=true src/
+  mimo lint --json src/ | jq .
+`);
+}
+
+export async function run(args) {
+    const quiet         = args.includes('--quiet');
+    const verbose       = args.includes('--verbose');
+    const json          = args.includes('--json');
+    const failOnWarning = args.includes('--fail-on-warning');
+    const rules         = parseRuleFlags(args);
+    const targets       = args.filter((a) => !a.startsWith('--'));
+    const files         = collectMimoFiles(targets);
+
+    if (files.length === 0) {
+        console.error(c.error('Error: No .mimo files found for linting.'));
+        process.exit(1);
+    }
+
+    const t0 = Date.now();
+
+    if (json) {
+        const results = files.map((f) => lintFileJson(f, { rules }));
+        console.log(JSON.stringify(results.length === 1 ? results[0] : results, null, 2));
+        const hasParseErrors = results.some((r) => !r.ok);
+        const errorCount     = results.reduce((s, r) => s + r.messages.filter((m) => m.severity === 'error').length, 0);
+        const warningCount   = results.reduce((s, r) => s + r.messages.filter((m) => m.severity !== 'error').length, 0);
+        if (hasParseErrors || errorCount > 0 || (failOnWarning && warningCount > 0)) process.exit(1);
+        return;
+    }
+
+    let hasParseErrors = false;
+    let totalErrors    = 0;
+    let totalWarnings  = 0;
+    let fileCount      = 0;
+
+    for (const file of files) {
+        const result = lintFile(file, { quiet: true, rules, verbose });
+        if (!result.ok) {
+            hasParseErrors = true;
+            if (!quiet) console.error(`${c.red('parse error')} ${file}`);
+            continue;
+        }
+
+        fileCount++;
+        const errors   = result.messages.filter((m) => m.severity === 'error');
+        const warnings = result.messages.filter((m) => m.severity !== 'error');
+        totalErrors   += errors.length;
+        totalWarnings += warnings.length;
+
+        if (quiet) continue;
+
+        const hasIssues = errors.length > 0 || warnings.length > 0;
+        if (!hasIssues) {
+            if (verbose) console.log(`${c.green('✓')} ${file}`);
+            continue;
+        }
+
+        console.log(`\n${c.bold(file)}`);
+        for (const msg of result.messages) {
+            const loc      = msg.line ? `${c.dim(`${msg.line}:${msg.column ?? 1}`)}` : '';
+            const badge    = msg.severity === 'error'
+                ? c.red('error')
+                : c.yellow('warn ');
+            const ruleTag  = verbose ? c.dim(` [${msg.ruleId ?? 'unknown'}]`) : '';
+            console.log(`  ${badge} ${loc.padEnd(8)} ${msg.message}${ruleTag}`);
+        }
+    }
+
+    const ms = Date.now() - t0;
+    const errorLabel   = totalErrors   > 0 ? c.red(`${totalErrors} error${totalErrors   !== 1 ? 's' : ''}`)   : null;
+    const warningLabel = totalWarnings > 0 ? c.yellow(`${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}`) : null;
+    const parts        = [errorLabel, warningLabel].filter(Boolean);
+
+    if (!quiet) {
+        if (parts.length > 0) {
+            console.log(`\n${parts.join(c.dim(', '))} ${c.dim(`in ${fileCount} file${fileCount !== 1 ? 's' : ''} (${ms}ms)`)}`);
+        } else if (!hasParseErrors) {
+            console.log(c.green(`\nNo issues found`) + c.dim(` in ${fileCount} file${fileCount !== 1 ? 's' : ''} (${ms}ms)`));
+        }
+    }
+
+    if (hasParseErrors || totalErrors > 0 || (failOnWarning && totalWarnings > 0)) process.exit(1);
+}

package/bin/commands/repl.js

@@ -0,0 +1,24 @@
+// bin/commands/repl.js
+// Starts the interactive Mimo REPL.
+
+import { runRepl } from '../../repl.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo repl')} — Start the interactive Read-Eval-Print Loop
+
+${c.bold('Usage:')}
+  mimo repl
+
+${c.bold('REPL shortcuts:')}
+  .help        Show REPL help
+  .exit        Exit the REPL
+  Ctrl+C       Abort current input
+  Ctrl+D       Exit
+`);
+}
+
+export async function run(_args) {
+    runRepl();
+}

package/bin/commands/run.js

@@ -0,0 +1,64 @@
+// bin/commands/run.js
+// Executes a .mimo file (or STDIN) through the Mimo interpreter.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { Mimo } from '../../index.js';
+import { nodeAdapter } from '../../adapters/nodeAdapter.js';
+import { formatError } from '../utils/formatError.js';
+import { readStdin } from '../utils/fs.js';
+import { c } from '../utils/colors.js';
+
+export function help() {
+    console.log(`
+${c.bold('mimo run')} — Execute a Mimo file
+
+${c.bold('Usage:')}
+  mimo run <file>
+  mimo <file>
+  mimo -                     Read from STDIN
+  echo "code" | mimo
+
+${c.bold('Examples:')}
+  mimo hello.mimo
+  mimo run examples/hello.mimo
+  echo 'show + 1 2' | mimo
+`);
+}
+
+export async function run(args) {
+    // args[0] is either the file path or already stripped by cli.js
+    const filePath = args[0];
+
+    // No file given → try STDIN
+    if (!filePath || filePath === '-') {
+        if (process.stdin.isTTY && filePath !== '-') {
+            console.error(c.error('Error: No file specified. Use `mimo --help` for usage.'));
+            process.exit(1);
+        }
+        const source = await readStdin();
+        const mimo = new Mimo(nodeAdapter);
+        try {
+            mimo.run(source, '/stdin');
+        } catch (err) {
+            console.error(formatError(err, source));
+            process.exit(1);
+        }
+        return;
+    }
+
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    if (!fs.existsSync(absolutePath)) {
+        console.error(c.error(`Error: File not found: ${absolutePath}`));
+        process.exit(1);
+    }
+
+    const source = fs.readFileSync(absolutePath, 'utf-8');
+    const mimo = new Mimo(nodeAdapter);
+    try {
+        mimo.run(source, absolutePath);
+    } catch (err) {
+        console.error(formatError(err, source));
+        process.exit(1);
+    }
+}

package/bin/commands/test.js

@@ -0,0 +1,126 @@
+// bin/commands/test.js
+// Runs .mimo test files and reports results.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { Mimo } from '../../index.js';
+import { nodeAdapter } from '../../adapters/nodeAdapter.js';
+import { formatError } from '../utils/formatError.js';
+import { c } from '../utils/colors.js';
+
+function collectTestFiles(dir, out = []) {
+    for (const entry of fs.readdirSync(dir)) {
+        const full = path.join(dir, entry);
+        if (fs.statSync(full).isDirectory()) {
+            collectTestFiles(full, out);
+        } else if (
+            entry.endsWith('.mimo') &&
+            (entry.includes('.test.') || dir.includes('test'))
+        ) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+
+export function help() {
+    console.log(`
+${c.bold('mimo test')} — Run Mimo test files
+
+${c.bold('Usage:')}
+  mimo test [path]
+
+${c.bold('Options:')}
+  --verbose      Show captured output even for passing tests
+  --quiet        Only print the final summary line
+
+${c.bold('Arguments:')}
+  path           File or directory to test. Defaults to current directory.
+                 Discovers all .mimo files inside directories named 'test'
+                 or files with '.test.' in their name.
+
+${c.bold('Examples:')}
+  mimo test
+  mimo test test/source/
+  mimo test test/source/strings.mimo
+`);
+}
+
+export async function run(args) {
+    const verbose = args.includes('--verbose');
+    const quiet   = args.includes('--quiet');
+    const targets = args.filter((a) => !a.startsWith('--'));
+    const target  = targets[0] ?? '.';
+
+    const absoluteTarget = path.resolve(process.cwd(), target);
+    let filesToTest = [];
+
+    if (!fs.existsSync(absoluteTarget)) {
+        console.error(c.error(`Error: Path not found: ${target}`));
+        process.exit(1);
+    }
+
+    if (fs.statSync(absoluteTarget).isFile()) {
+        filesToTest.push(absoluteTarget);
+    } else {
+        filesToTest = collectTestFiles(absoluteTarget);
+    }
+
+    if (filesToTest.length === 0) {
+        console.log(c.yellow('No test files found.'));
+        return;
+    }
+
+    if (!quiet) console.log(`\n${c.bold('Mimo Test Runner')}\n`);
+
+    let passed = 0;
+    let failed = 0;
+    const t0   = Date.now();
+
+    for (const file of filesToTest) {
+        const relName = path.relative(process.cwd(), file);
+        if (!quiet) process.stdout.write(`  ${c.dim(relName)} ... `);
+
+        const source = fs.readFileSync(file, 'utf-8');
+        const logs   = [];
+
+        const testAdapter = {
+            ...nodeAdapter,
+            log:   (...a) => logs.push(a.join(' ')),
+            error: (...a) => logs.push(c.dim('[stderr] ') + a.join(' ')),
+        };
+
+        const mimo = new Mimo(testAdapter);
+
+        try {
+            mimo.run(source, file);
+            if (!quiet) console.log(c.green('PASS'));
+            passed++;
+            if (verbose && logs.length > 0) {
+                console.log(c.dim('  --- output ---'));
+                for (const l of logs) console.log('  ' + l);
+            }
+        } catch (err) {
+            if (!quiet) console.log(c.red('FAIL'));
+            failed++;
+            if (!quiet) {
+                if (logs.length > 0) {
+                    console.log(c.dim('  --- output ---'));
+                    for (const l of logs) console.log('  ' + l);
+                }
+                console.log(c.dim('  --- error ---'));
+                console.log('  ' + formatError(err, source).replace(/\n/g, '\n  '));
+                console.log();
+            }
+        }
+    }
+
+    const ms      = ((Date.now() - t0) / 1000).toFixed(2);
+    const summary = failed > 0
+        ? `${c.green(`${passed} passed`)}, ${c.red(`${failed} failed`)}`
+        : c.green(`${passed} passed`);
+
+    console.log(`\nTest Result: ${summary}. ${c.dim(`(Time: ${ms}s)`)}`);
+
+    if (failed > 0) process.exit(1);
+}

package/bin/utils/colors.js

@@ -0,0 +1,38 @@
+// bin/utils/colors.js
+// Tiny zero-dependency ANSI color helper.
+// Colors are suppressed automatically when:
+//   - stdout is not a TTY (pipe / redirect)
+//   - NO_COLOR env var is set (https://no-color.org)
+
+const enabled = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const code = (n) => enabled ? `\x1b[${n}m` : '';
+const reset = code(0);
+const wrap  = (n, s) => `${code(n)}${s}${reset}`;
+
+export const c = {
+    // Foreground colours
+    green:   (s) => wrap(32, s),
+    red:     (s) => wrap(31, s),
+    yellow:  (s) => wrap(33, s),
+    blue:    (s) => wrap(34, s),
+    cyan:    (s) => wrap(36, s),
+    magenta: (s) => wrap(35, s),
+    white:   (s) => wrap(37, s),
+
+    // Styles
+    bold:    (s) => wrap(1,  s),
+    dim:     (s) => wrap(2,  s),
+    italic:  (s) => wrap(3,  s),
+
+    // Semantic aliases
+    success: (s) => wrap(32, s),   // green
+    error:   (s) => wrap(31, s),   // red
+    warn:    (s) => wrap(33, s),   // yellow
+    info:    (s) => wrap(36, s),   // cyan
+    muted:   (s) => wrap(2,  s),   // dim
+
+    // Raw reset (useful for building multi-segment strings)
+    reset,
+    enabled,
+};

package/bin/utils/formatError.js

@@ -0,0 +1,47 @@
+// bin/utils/formatError.js
+// Renders a Mimo parse error as a source snippet with a caret pointer.
+// Only structured errors (those with a `.location` object) get the snippet;
+// plain strings / runtime errors are printed as-is.
+
+import { c } from './colors.js';
+
+/**
+ * Format a Mimo error for terminal output.
+ *
+ * @param {unknown}  err     The caught value (MimoError, Error, or string)
+ * @param {string}   [src]   Raw source text (used to extract the snippet line)
+ * @returns {string}         The formatted string, ready for console.error()
+ */
+export function formatError(err, src) {
+    // Structured Mimo error with location info
+    if (err && typeof err === 'object' && err.location) {
+        const { line, column } = err.location;
+        const tag   = c.bold(c.red(`[${err.code ?? 'Error'}]`));
+        const label = c.bold(err.message ?? String(err));
+        let out = `${tag} ${label}`;
+
+        if (src && line) {
+            const lines  = src.split('\n');
+            const srcLine = lines[line - 1] ?? '';
+            const lineNo  = String(line).padStart(4);
+            const col     = Math.max(0, (column ?? 1) - 1);
+
+            out += `\n${c.dim(`${lineNo} │`)} ${srcLine}`;
+            out += `\n     ${' '.repeat(col)}${c.red('^')}`;
+        }
+
+        if (err.file) {
+            out += `\n${c.dim(`     at ${err.file}:${line ?? '?'}:${column ?? '?'}`)}`;
+        }
+
+        return out;
+    }
+
+    // Plain string (Mimo.run() sometimes throws formatted strings)
+    if (typeof err === 'string') {
+        return c.red(err);
+    }
+
+    // Standard Error or anything else
+    return c.red(err?.message ?? String(err));
+}

package/bin/utils/fs.js

@@ -0,0 +1,57 @@
+// bin/utils/fs.js
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Recursively collect all .mimo files from a list of file/directory targets.
+ * Deduplicates by absolute path. Warns on missing paths.
+ * @param {string[]} targets
+ * @returns {string[]} Absolute paths to .mimo files, in discovery order
+ */
+export function collectMimoFiles(targets) {
+    const resolvedTargets = targets.length === 0 ? ['.'] : targets;
+    const seen = new Set();
+    const files = [];
+
+    function visit(targetPath) {
+        const absolutePath = path.resolve(process.cwd(), targetPath);
+        if (!fs.existsSync(absolutePath)) {
+            console.error(`Warning: Path not found: ${targetPath}`);
+            return;
+        }
+
+        const stat = fs.statSync(absolutePath);
+        if (stat.isDirectory()) {
+            for (const entry of fs.readdirSync(absolutePath)) {
+                visit(path.join(absolutePath, entry));
+            }
+            return;
+        }
+
+        if (!absolutePath.endsWith('.mimo')) return;
+
+        if (!seen.has(absolutePath)) {
+            seen.add(absolutePath);
+            files.push(absolutePath);
+        }
+    }
+
+    for (const target of resolvedTargets) {
+        visit(target);
+    }
+
+    return files;
+}
+
+/**
+ * Read all of STDIN as a UTF-8 string.
+ * @returns {Promise<string>}
+ */
+export function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => { resolve(data); });
+    });
+}

package/bin/utils/version.js

@@ -0,0 +1,8 @@
+// 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 = '2.0.6';
+
+export function getVersion() {
+    return VERSION;
+}

package/build.js

@@ -0,0 +1,18 @@
+import * as esbuild from 'esbuild';
+import fs from 'node:fs';
+
+console.log("Bundling Mimo for the web...");
+
+// Create the 'dist' directory if it doesn't exist
+if (!fs.existsSync('./dist')) {
+    fs.mkdirSync('./dist');
+}
+
+esbuild.build({
+    entryPoints: ['web/index.js'],
+    bundle: true,
+    outfile: 'dist/mimo.web.js',
+    format: 'iife', 
+    globalName: 'mimoBundle',
+    minify: true,
+}).catch(() => process.exit(1));