@xnoxs/flux-lang 3.2.1 → 3.2.2

package/bin/flux.js

@@ -1,1397 +1,3 @@
 #!/usr/bin/env node
 'use strict';
-
-const fs   = require('fs');
-const path = require('path');
-// Self-hosted compiler: enable with --self-hosted flag or FLUX_SELF_HOSTED=1
-const USE_SELF_HOSTED = process.argv.includes('--self-hosted') || process.env.FLUX_SELF_HOSTED === '1';
-process.argv = process.argv.filter(a => a !== '--self-hosted');
-
-function loadTranspiler() {
-  if (USE_SELF_HOSTED) {
-    const selfPath = require('path').join(__dirname, '../src/self/transpiler.js');
-    try {
-      const mod = require(selfPath);
-      if (process.env.FLUX_VERBOSE) process.stderr.write('[flux] using self-hosted transpiler\n');
-      return mod;
-    } catch (e) {
-      process.stderr.write('[flux] warning: self-hosted transpiler not available, falling back to stage-0\n');
-      process.stderr.write('[flux] run: node scripts/bootstrap.js  to build the self-hosted compiler\n');
-    }
-  }
-  return require('../src/transpiler');
-}
-
-function loadBundler() {
-  if (USE_SELF_HOSTED) {
-    const selfPath = require('path').join(__dirname, '../src/self/bundler.js');
-    try { return require(selfPath); } catch (_) {}
-  }
-  return require('../src/bundler');
-}
-
-const { transpile } = loadTranspiler();
-const { bundle }    = loadBundler();
-
-const VERSION = require('../package.json').version;
-
-// ── ANSI Colors ──────────────────────────────────────────────────────────────
-const C = {
-  reset:  '\x1b[0m',
-  bold:   '\x1b[1m',
-  dim:    '\x1b[2m',
-  red:    '\x1b[31m',
-  green:  '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue:   '\x1b[34m',
-  cyan:   '\x1b[36m',
-  white:  '\x1b[37m',
-  gray:   '\x1b[90m',
-};
-const colored = (c, s) => `${c}${s}${C.reset}`;
-const noColor  = process.env.NO_COLOR || !process.stdout.isTTY;
-const clr      = (c, s) => noColor ? s : colored(c, s);
-
-// ── Banner ───────────────────────────────────────────────────────────────────
-function banner() {
-  console.log(clr(C.cyan, C.bold + `
-  ███████╗██╗     ██╗   ██╗██╗  ██╗
-  ██╔════╝██║     ██║   ██║╚██╗██╔╝
-  █████╗  ██║     ██║   ██║ ╚███╔╝
-  ██╔══╝  ██║     ██║   ██║ ██╔██╗
-  ██║     ███████╗╚██████╔╝██╔╝ ██╗
-  ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝` + C.reset));
-  console.log(clr(C.gray, `  Flux Lang Transpiler → JavaScript  v${VERSION}\n`));
-}
-
-// ── Help ─────────────────────────────────────────────────────────────────────
-function showHelp() {
-  banner();
-  console.log(clr(C.bold, 'USAGE:'));
-  console.log('  flux <command> [options]\n');
-  console.log(clr(C.bold, 'COMMANDS:'));
-  const cmds = [
-    ['init [name]',                      'Scaffold a new Flux project'],
-    ['compile <file.flux>',              'Compile to a .js file'],
-    ['bundle  <entry.flux>',             'Bundle multiple .flux files into one .js'],
-    ['run <file.flux>',                  'Compile and run immediately'],
-    ['watch <file.flux>',                'Watch for changes and auto-compile'],
-    ['check <file.flux>',                'Type-check and static analysis'],
-    ['lint <file.flux>',                 'Full lint: types + style + immutability'],
-    ['fmt <file.flux>',                  'Format source code in-place'],
-    ['test [dir]',                       'Discover and run *.test.flux files'],
-    ['publish [--patch|minor|major]',    'Bump version, update CHANGELOG, tag & release'],
-    ['tokens <file.flux>',               'Show lexer token list'],
-    ['ast <file.flux>',                  'Show Abstract Syntax Tree (JSON)'],
-    ['repl',                             'Interactive REPL mode'],
-    ['self-hosted [build|verify|on|off]','Self-hosted compiler: status, build & toggle'],
-    ['version',                          'Show version'],
-    ['help',                             'Show this help'],
-  ];
-  for (const [cmd, desc] of cmds) {
-    console.log(`  ${clr(C.green, ('flux ' + cmd).padEnd(38))} ${clr(C.gray, desc)}`);
-  }
-  console.log();
-  console.log(clr(C.bold, 'OPTIONS:'));
-  console.log(`  ${clr(C.yellow, '--out, -o <file>')}   Output file name`);
-  console.log(`  ${clr(C.yellow, '--sourcemap, -m')}     Generate source map (.js.map)`);
-  console.log(`  ${clr(C.yellow, '--stdout')}            Print output to terminal`);
-  console.log(`  ${clr(C.yellow, '--no-color')}          Disable colors`);
-  console.log();
-  console.log(clr(C.bold, 'EXAMPLES:'));
-  console.log(clr(C.gray, '  flux init my-app'));
-  console.log(clr(C.gray, '  flux compile app.flux'));
-  console.log(clr(C.gray, '  flux compile app.flux -o dist/app.js'));
-  console.log(clr(C.gray, '  flux bundle  src/main.flux -o bundle.js'));
-  console.log(clr(C.gray, '  flux run     app.flux'));
-  console.log(clr(C.gray, '  flux watch   app.flux'));
-  console.log(clr(C.gray, '  flux repl'));
-  console.log();
-  console.log(clr(C.bold, "WHAT'S NEW in v3.0.0:"));
-  const news = [
-    'Return type annotations  — fn greet(name: String) -> String:',
-    'Union types              — val x: Int | String | Null',
-    'Nullable shorthand       — String? = String | Null',
-    'Full type checker        — flux check catches type mismatches at compile time',
-    'Interface enforcement    — implements checks all required members',
-    'Generic interfaces       — interface Container<T>: fn get() -> T',
-    'type / ADT               — type Result = Ok(value) | Err(msg)',
-    'when Pattern(x)          — ADT pattern matching with field bindings',
-    'when Pattern if guard    — pattern match guards',
-    'String format specs      — "Pi is {pi:.2f}"  "{n:,}"  "{rate:.1%}"',
-    'async / await            — async functions and promise handling',
-    'try / catch / finally    — structured error handling',
-    'spread / rest  (...)     — spread arrays/objects, rest params',
-    'optional chaining (?.)   — safe property access',
-    'nullish coalescing (??)  — default value for null/undefined',
-    'destructuring            — val { a, b } = obj  /  val [x, y] = arr',
-  ];
-  for (const n of news)
-    console.log('  ' + clr(C.cyan, '⊕') + '  ' + clr(C.gray, n));
-  console.log();
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function readFluxFile(filePath) {
-  const abs = path.resolve(filePath);
-  if (!fs.existsSync(abs)) {
-    console.error(clr(C.red, `[Error] File not found: ${abs}`));
-    process.exit(1);
-  }
-  if (!filePath.endsWith('.flux')) {
-    console.warn(clr(C.yellow, `[Warning] File is not .flux: ${filePath}`));
-  }
-  return { source: fs.readFileSync(abs, 'utf8'), abs };
-}
-
-// ── Error label → friendly prefix ────────────────────────────────────────────
-const ERROR_KIND = {
-  ParseError:     'Syntax error',
-  LexerError:     'Syntax error',
-  CheckError:     'Static error',
-  TypeCheckError: 'Type error',
-  TypeError:      'Type error',
-};
-
-// ── Central error renderer ────────────────────────────────────────────────────
-// Accepts an array of error objects with optional:
-//   { message, name, line, col, len, hint, stage }
-// Also accepts a file path for the header label.
-function printErrors(errors, source, filePath) {
-  const lines = source.split('\n');
-
-  for (const err of errors) {
-    const kind  = ERROR_KIND[err.name] || 'Error';
-    const stage = err.stage ? clr(C.gray, ` [${err.stage}]`) : '';
-
-    // ── header ──────────────────────────────────────────────────────────────
-    console.error();
-    console.error(clr(C.red, C.bold + `${kind}` + C.reset) + stage);
-
-    // ── location ────────────────────────────────────────────────────────────
-    if (err.line) {
-      const fileLabel = filePath ? clr(C.cyan, path.relative(process.cwd(), filePath)) : '';
-      const locLabel  = clr(C.yellow, `${err.line}:${err.col || 1}`);
-      if (fileLabel) console.error(`  ${fileLabel}:${locLabel}`);
-      else           console.error(`  Line ${locLabel}`);
-    }
-
-    // ── message ─────────────────────────────────────────────────────────────
-    console.error(`  ${err.message}`);
-
-    // ── source context (1 line before + error line + 1 line after) ──────────
-    if (err.line && err.line <= lines.length) {
-      const errLineIdx = err.line - 1;
-      const col        = Math.max(0, (err.col || 1) - 1);
-      const tokLen     = Math.max(1, err.len || 1);
-
-      // line before (context)
-      if (errLineIdx > 0 && lines[errLineIdx - 1].trim() !== '') {
-        const prev = String(err.line - 1).padStart(4);
-        console.error(clr(C.gray, `  ${prev} │ ${lines[errLineIdx - 1]}`));
-      }
-
-      // error line (highlighted)
-      const lineNum = String(err.line).padStart(4);
-      console.error(clr(C.gray, `  ${lineNum} │ `) + lines[errLineIdx]);
-
-      // squiggly pointer (^~~~)
-      const squiggle = '^' + '~'.repeat(Math.max(0, tokLen - 1));
-      const pointer  = ' '.repeat(col) + clr(C.red, squiggle);
-      console.error(clr(C.gray, `       │ `) + pointer);
-
-      // line after (context)
-      if (errLineIdx + 1 < lines.length && lines[errLineIdx + 1].trim() !== '') {
-        const next = String(err.line + 1).padStart(4);
-        console.error(clr(C.gray, `  ${next} │ ${lines[errLineIdx + 1]}`));
-      }
-    }
-
-    // ── hint ────────────────────────────────────────────────────────────────
-    if (err.hint) {
-      console.error(clr(C.cyan, `  Hint: `) + clr(C.gray, err.hint));
-    }
-  }
-
-  console.error();
-}
-
-function deriveOutPath(inputPath, outFlag) {
-  if (outFlag) return path.resolve(outFlag);
-  const base = path.basename(inputPath, '.flux');
-  return path.join(path.dirname(path.resolve(inputPath)), base + '.js');
-}
-
-// ── flux init ────────────────────────────────────────────────────────────────
-function cmdInit(name) {
-  const projectName = name || 'my-flux-app';
-  const dir = path.resolve(projectName);
-
-  if (fs.existsSync(dir)) {
-    console.error(clr(C.red, `[Error] Directory already exists: ${projectName}`));
-    process.exit(1);
-  }
-
-  fs.mkdirSync(dir, { recursive: true });
-  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
-
-  // main.flux
-  fs.writeFileSync(path.join(dir, 'src', 'main.flux'), [
-    '// Welcome to Flux Lang v2.0!',
-    '',
-    '// --- Basic ---',
-    'val greeting = "Hello, Flux!"',
-    'print(greeting)',
-    '',
-    '// --- Async / Await ---',
-    'async fn fetchData(url):',
-    '    try:',
-    '        val res  = await fetch(url)',
-    '        val data = await res.json()',
-    '        return data',
-    '    catch(e):',
-    '        print("Fetch error:", e.message)',
-    '        return null',
-    '',
-    '// --- Destructuring ---',
-    'val person = { name: "Budi", age: 25, city: "Jakarta" }',
-    'val { name, age } = person',
-    'print("Name: {name}, Age: {age}")',
-    '',
-    '// --- Optional chaining & nullish coalescing ---',
-    'val user = null',
-    'val displayName = user?.name ?? "Anonymous"',
-    'print("User:", displayName)',
-    '',
-    '// --- Spread ---',
-    'val nums = [1, 2, 3]',
-    'val more = [...nums, 4, 5, 6]',
-    'print("Numbers:", more)',
-    '',
-    '// --- Rest params ---',
-    'fn sum(...args):',
-    '    return args.reduce((acc, x) -> acc + x, 0)',
-    '',
-    'print("Sum:", sum(1, 2, 3, 4, 5))',
-    '',
-    '// --- Default params ---',
-    'fn greet(name = "World") -> "Hello, {name}!"',
-    'print(greet())',
-    'print(greet("Flux"))',
-    '',
-    '// --- Error handling ---',
-    'fn divide(a, b):',
-    '    if b == 0:',
-    '        throw new Error("Division by zero")',
-    '    return a / b',
-    '',
-    'try:',
-    '    print(divide(10, 2))',
-    '    print(divide(10, 0))',
-    'catch(e):',
-    '    print("Error:", e.message)',
-    'finally:',
-    '    print("Done.")',
-    '',
-  ].join('\n'), 'utf8');
-
-  // package.json
-  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({
-    name: projectName,
-    version: '1.0.0',
-    description: `A Flux Lang project`,
-    scripts: {
-      start: `flux run src/main.flux`,
-      build: `flux bundle src/main.flux -o dist/bundle.js`,
-      dev:   `flux watch src/main.flux`,
-      check: `flux check src/main.flux`,
-    },
-    dependencies: {},
-    devDependencies: { 'flux-lang': `^${VERSION}` },
-  }, null, 2), 'utf8');
-
-  // .gitignore
-  fs.writeFileSync(path.join(dir, '.gitignore'), [
-    'node_modules/',
-    'dist/',
-    '*.js.map',
-    '.DS_Store',
-  ].join('\n'), 'utf8');
-
-  // README.md
-  fs.writeFileSync(path.join(dir, 'README.md'), [
-    `# ${projectName}`,
-    '',
-    'A project built with [Flux Lang](https://github.com/flux-lang/flux-lang) v2.',
-    '',
-    '## Getting Started',
-    '',
-    '```bash',
-    'npm install',
-    'flux run src/main.flux',
-    '```',
-    '',
-    '## Commands',
-    '',
-    '| Command | Description |',
-    '|---|---|',
-    '| `npm start` | Run main.flux |',
-    '| `npm run build` | Bundle to dist/ |',
-    '| `npm run dev` | Watch mode |',
-    '| `npm run check` | Check syntax |',
-    '',
-  ].join('\n'), 'utf8');
-
-  console.log();
-  console.log(clr(C.green, `✓ Project created: ${projectName}/`));
-  console.log();
-  console.log(clr(C.gray, '  Files created:'));
-  console.log('  ' + clr(C.cyan,   `${projectName}/src/main.flux`));
-  console.log('  ' + clr(C.cyan,   `${projectName}/package.json`));
-  console.log('  ' + clr(C.cyan,   `${projectName}/.gitignore`));
-  console.log('  ' + clr(C.cyan,   `${projectName}/README.md`));
-  console.log();
-  console.log(clr(C.bold, '  Next steps:'));
-  console.log(`    ${clr(C.yellow, `cd ${projectName}`)}`);
-  console.log(`    ${clr(C.yellow, 'npm install')}`);
-  console.log(`    ${clr(C.yellow, 'flux run src/main.flux')}`);
-  console.log();
-}
-
-// ── Commands ─────────────────────────────────────────────────────────────────
-
-// flux compile <file.flux> [-o out.js] [--stdout] [--sourcemap]
-function cmdCompile(filePath, opts) {
-  const { source, abs } = readFluxFile(filePath);
-  const outPath  = deriveOutPath(filePath, opts.out);
-  const mapPath  = outPath + '.map';
-  const t0       = Date.now();
-
-  const result = transpile(source, {
-    sourcemap:  opts.sourcemap,
-    mangle:     opts.mangle,
-    sourceFile: path.relative(path.dirname(outPath), abs),
-    outputFile: path.basename(outPath),
-  });
-
-  if (!result.success) {
-    console.error(clr(C.red, `\n✗ Compile failed — ${result.errors.length} error(s)`));
-    printErrors(result.errors, source, abs);
-    process.exit(1);
-  }
-
-  const elapsed = Date.now() - t0;
-
-  if (opts.stdout) {
-    console.log(result.output);
-    return;
-  }
-
-  fs.writeFileSync(outPath, result.output, 'utf8');
-
-  let extra = '';
-  if (opts.sourcemap && result.sourceMap) {
-    fs.writeFileSync(mapPath, result.sourceMap, 'utf8');
-    extra = clr(C.gray, ` + ${path.relative(process.cwd(), mapPath)}`);
-  }
-
-  console.log(
-    clr(C.green, `✓ Done`) + clr(C.gray, ` (${elapsed}ms)`) +
-    ` ${clr(C.blue, path.basename(abs))} → ${clr(C.cyan, path.relative(process.cwd(), outPath))}${extra}`
-  );
-}
-
-// flux bundle <entry.flux> [-o output.js] [--stdout]
-function cmdBundle(entryPath, opts) {
-  const abs  = path.resolve(entryPath);
-  if (!fs.existsSync(abs)) {
-    console.error(clr(C.red, `✗ File not found: ${entryPath}`));
-    process.exit(1);
-  }
-
-  const outFile = opts.out
-    || path.join(path.dirname(abs), path.basename(abs, '.flux') + '.bundle.js');
-
-  const t0     = Date.now();
-  const result = bundle(abs);
-
-  if (!result.success) {
-    console.error(clr(C.red, '\n✗ Bundle failed:\n'));
-    for (const e of result.errors) {
-      console.error(clr(C.red, `  ${e.message}`));
-    }
-    process.exit(1);
-  }
-
-  const elapsed = Date.now() - t0;
-
-  if (opts.stdout) {
-    console.log(result.code);
-    return;
-  }
-
-  fs.writeFileSync(outFile, result.code, 'utf8');
-  const kb = (result.code.length / 1024).toFixed(1);
-  console.log(
-    clr(C.green, `✓ Bundle done`) +
-    clr(C.gray,  ` (${elapsed}ms)`) +
-    ` ${path.basename(abs)} + ${result.modules - 1} module(s) → ` +
-    clr(C.cyan,  path.relative(process.cwd(), outFile)) +
-    clr(C.gray,  ` [${kb} KB]`)
-  );
-}
-
-// flux run <file.flux>
-function cmdRun(filePath) {
-  const { source, abs } = readFluxFile(filePath);
-  const result = transpile(source);
-
-  if (!result.success) {
-    console.error(clr(C.red, `\n✗ Compile error`));
-    printErrors(result.errors, source, abs);
-    process.exit(1);
-  }
-
-  const tmpPath = path.join(require('os').tmpdir(), '_flux_run_' + Date.now() + '.js');
-  fs.writeFileSync(tmpPath, result.output, 'utf8');
-
-  console.log(clr(C.gray, `▶ Running ${path.basename(abs)} ...\n`));
-  try {
-    require(tmpPath);
-  } catch (e) {
-    console.error(clr(C.red, `\n[Runtime Error] ${e.message}`));
-    process.exitCode = 1;
-  } finally {
-    try { fs.unlinkSync(tmpPath); } catch (_) {}
-  }
-}
-
-// flux check <file.flux>  — full type check + val-immutability analysis
-function cmdCheck(filePath) {
-  const { source, abs } = readFluxFile(filePath);
-  const baseName = path.basename(abs);
-
-  // Run transpile with both immutability + type checker
-  const result = transpile(source, { check: true, typecheck: true });
-
-  // Parse / compile errors  (includes immutability CheckErrors when check:true)
-  if (!result.success) {
-    const n    = result.errors.length;
-    const kind = result.errors.some(e => e.name === 'CheckError') ? 'static' : 'syntax';
-    console.error(clr(C.red, `\n✗ ${baseName}: ${n} ${kind} error${n > 1 ? 's' : ''}`));
-    printErrors(result.errors, source, abs);
-    process.exit(1);
-  }
-
-  let exitCode = 0;
-
-  // Type errors — use unified printErrors renderer
-  const typeErrors = result.typeErrors || [];
-  if (typeErrors.length > 0) {
-    console.error(clr(C.red, `\n✗ ${baseName}: ${typeErrors.length} type error(s)`));
-    printErrors(typeErrors, source, abs);
-    exitCode = 1;
-  }
-
-  // All warnings
-  const warnings = [...(result.typeWarnings || [])];
-  for (const w of warnings) {
-    const fileRef = clr(C.cyan, baseName) + (w.line ? clr(C.yellow, `:${w.line}`) : '');
-    console.warn(clr(C.yellow, `  ⚠ `) + fileRef + clr(C.gray, `  ${w.message}`));
-    if (w.hint) console.warn(clr(C.cyan, `    Hint: `) + clr(C.gray, w.hint));
-  }
-
-  // Summary
-  const fnRe  = /^(?:async )?function \w/gm;
-  const clsRe = /^class \w/gm;
-  const fns   = (result.output.match(fnRe)  || []).length;
-  const cls   = (result.output.match(clsRe) || []).length;
-  const lines = result.output.split('\n').length;
-  const tw    = typeErrors.length;
-  const ww    = warnings.length;
-
-  console.log();
-  if (exitCode === 0) {
-    console.log(
-      clr(C.green, `✓ ${baseName} — no errors`) +
-      (ww > 0 ? clr(C.yellow, `  (${ww} warning${ww>1?'s':''})`) : '')
-    );
-  } else {
-    console.log(clr(C.red, `✗ ${baseName} — ${tw} type error${tw>1?'s':''}`));
-  }
-  console.log(clr(C.gray, `  Functions: ${fns}  |  Classes: ${cls}  |  JS output: ${lines} lines`));
-  console.log();
-
-  if (exitCode !== 0) process.exit(exitCode);
-}
-
-// flux lint <file.flux>  — comprehensive lint: types + style + AST rules
-function cmdLint(filePath) {
-  const { source, abs } = readFluxFile(filePath);
-  const baseName = path.basename(abs);
-  const { format }    = require('../src/formatter');
-  const { lint }      = require('../src/linter');
-  const { detectUsedSymbols } = require('../src/stdlib');
-
-  console.log(clr(C.cyan, `\n⊛ Linting: ${baseName}\n`));
-
-  let exitCode    = 0;
-  let totalIssues = 0;
-
-  // ── 1. Syntax check ───────────────────────────────────────────────────────
-  const result = transpile(source, { check: true, typecheck: true });
-
-  if (!result.success) {
-    console.error(clr(C.red, `  Syntax error${result.errors.length > 1 ? 's' : ''} (${result.errors.length})`));
-    printErrors(result.errors, source, abs);
-    process.exit(1);
-  }
-
-  const sourceLines = source.split('\n');
-
-  function printIssue(tag, colorFn, msg, hint, line, col) {
-    const loc = line ? `:${line}${col ? ':' + col : ''}` : '';
-    console.log(colorFn(`  ${tag}${loc}  ${msg}`));
-    if (hint) console.log(clr(C.gray, `         hint: ${hint}`));
-    if (line && line <= sourceLines.length) {
-      const lineStr = sourceLines[line - 1] || '';
-      const pointer = ' '.repeat(Math.max(0, (col || 1) - 1)) + '^';
-      console.log(clr(C.gray, `  ${String(line).padStart(4)} │ `) + lineStr);
-      console.log(clr(C.gray, `       │ `) + clr(colorFn === clr.bind(null, C.red) ? C.red : C.yellow, pointer));
-    }
-    console.log();
-  }
-
-  // ── 2. Immutability errors ────────────────────────────────────────────────
-  const staticErrors = result.errors.filter(e => e.name === 'CheckError');
-  for (const e of staticErrors) {
-    totalIssues++; exitCode = 1;
-    printIssue('[E] immutability', clr.bind(null, C.red), e.message, e.hint, e.line, e.col);
-  }
-
-  // ── 3. Type errors ────────────────────────────────────────────────────────
-  for (const e of (result.typeErrors || [])) {
-    totalIssues++; exitCode = 1;
-    printIssue('[E] type', clr.bind(null, C.red), e.message, e.hint, e.line, e.col);
-  }
-
-  // ── 4. Type warnings ─────────────────────────────────────────────────────
-  for (const w of (result.typeWarnings || [])) {
-    totalIssues++;
-    printIssue('[W] type', clr.bind(null, C.yellow), w.message, w.hint, w.line, null);
-  }
-
-  // ── 5. AST lint rules (unused-var / unreachable / shadow-val) ─────────────
-  if (result.ast) {
-    const lintIssues = lint(result.ast);
-    for (const issue of lintIssues) {
-      totalIssues++;
-      const tag      = `[${issue.severity === 'error' ? 'E' : issue.severity === 'warn' ? 'W' : 'I'}] ${issue.rule}`;
-      const colorFn  = issue.severity === 'error'
-        ? clr.bind(null, C.red)
-        : issue.severity === 'warn'
-          ? clr.bind(null, C.yellow)
-          : clr.bind(null, C.gray);
-      if (issue.severity === 'error') exitCode = 1;
-      printIssue(tag, colorFn, issue.message, issue.hint, issue.line, issue.col);
-    }
-  }
-
-  // ── 6. Format check ───────────────────────────────────────────────────────
-  try {
-    const formatted = format(source);
-    if (formatted !== source) {
-      totalIssues++;
-      console.log(clr(C.yellow,
-        `  [W] format  File is not formatted — run: flux fmt ${baseName}\n`));
-    }
-  } catch (_) { /* formatter errors are not lint errors */ }
-
-  // ── 7. Style: long lines & TODO markers ──────────────────────────────────
-  const MAX_LINE = 120;
-  let longLines  = 0;
-  let todoCount  = 0;
-  sourceLines.forEach((line, i) => {
-    if (line.length > MAX_LINE) {
-      longLines++;
-      if (longLines <= 3)
-        console.log(clr(C.yellow,
-          `  [W] style:${i + 1}  Line exceeds ${MAX_LINE} characters (${line.length} chars)\n`));
-    }
-    if (/\/\/\s*(TODO|FIXME|HACK)/i.test(line)) {
-      todoCount++;
-      console.log(clr(C.gray, `  [I] note:${i + 1}  ${line.trim()}\n`));
-    }
-  });
-  if (longLines > 3)
-    console.log(clr(C.yellow, `  [W] style  ... and ${longLines - 3} more long line(s)\n`));
-  totalIssues += longLines + todoCount;
-
-  // ── 8. Stdlib usage info ──────────────────────────────────────────────────
-  const stdlibUsed = detectUsedSymbols(result.output);
-  if (stdlibUsed.length > 0) {
-    console.log(clr(C.gray, `  [I] stdlib  Using: ${stdlibUsed.join(', ')}\n`));
-  }
-
-  // ── Summary ───────────────────────────────────────────────────────────────
-  const lineCount = sourceLines.length;
-  console.log('─'.repeat(50));
-  if (exitCode === 0 && totalIssues === 0) {
-    console.log(
-      clr(C.green, `✓ ${baseName} — no issues`) +
-      clr(C.gray,  ` (${lineCount} lines)`)
-    );
-  } else if (exitCode === 0) {
-    console.log(
-      clr(C.yellow, `⚠ ${baseName} — ${totalIssues} warning(s)`) +
-      clr(C.gray,   ` (${lineCount} lines)`)
-    );
-  } else {
-    console.log(
-      clr(C.red,  `✗ ${baseName} — ${totalIssues} issue(s)`) +
-      clr(C.gray, ` (${lineCount} lines)`)
-    );
-  }
-  console.log();
-  if (exitCode !== 0) process.exit(exitCode);
-}
-
-// flux fmt <file.flux>  — format source in-place
-function cmdFmt(filePath, opts) {
-  const { source, abs } = readFluxFile(filePath);
-  const { format } = require('../src/formatter');
-  const output = format(source);
-
-  if (output === source) {
-    console.log(clr(C.gray, `~ ${path.basename(abs)} — already formatted`));
-    return;
-  }
-
-  if (opts.stdout) {
-    console.log(output);
-    return;
-  }
-
-  fs.writeFileSync(abs, output, 'utf8');
-  const diff = Math.abs(output.split('\n').length - source.split('\n').length);
-  console.log(clr(C.green, `✓ ${path.basename(abs)} — formatted`) +
-    (diff > 0 ? clr(C.gray, `  (${diff} line${diff===1?'':'s'} changed)`) : ''));
-}
-
-// flux test [dir]  — discover and run *.test.flux test files
-function cmdTest(dirOrFile) {
-  const { runTests } = require('../src/test-runner');
-  const target = dirOrFile || 'tests';
-  runTests(target, transpile);
-}
-
-// flux tokens <file.flux>
-function cmdTokens(filePath) {
-  const { source } = readFluxFile(filePath);
-  const { Lexer }  = require('../src/lexer');
-  const tokens     = new Lexer(source).tokenize();
-
-  console.log(clr(C.bold, '\n=== TOKEN LIST ===\n'));
-  const typeW = 20;
-  console.log(clr(C.gray, `${'TYPE'.padEnd(typeW)} VALUE                   LINE:COL`));
-  console.log(clr(C.gray, '─'.repeat(60)));
-  for (const t of tokens) {
-    const val = JSON.stringify(t.value) || '';
-    console.log(
-      clr(C.cyan,  t.type.padEnd(typeW)) +
-      val.substring(0, 24).padEnd(25) +
-      clr(C.gray,  `${t.line}:${t.col}`)
-    );
-  }
-  console.log();
-}
-
-// flux ast <file.flux>
-function cmdAst(filePath) {
-  const { source, abs } = readFluxFile(filePath);
-  const result          = transpile(source);
-
-  if (!result.success) {
-    printErrors(result.errors, source, abs);
-    process.exit(1);
-  }
-
-  console.log(clr(C.bold, '\n=== ABSTRACT SYNTAX TREE ===\n'));
-  console.log(JSON.stringify(result.ast, null, 2));
-  console.log();
-}
-
-// flux watch <file.flux>
-function cmdWatch(filePath, opts) {
-  const abs = path.resolve(filePath);
-  console.log(clr(C.cyan, `\n👁  Watching: ${path.basename(abs)}\n`));
-
-  function doCompile() {
-    try {
-      const source = fs.readFileSync(abs, 'utf8');
-      const result = transpile(source);
-      const ts     = new Date().toLocaleTimeString();
-      if (!result.success) {
-        console.error(clr(C.red, `[${ts}] ✗ Error`));
-        printErrors(result.errors, source, abs);
-      } else {
-        const outPath = deriveOutPath(filePath, opts.out);
-        fs.writeFileSync(outPath, result.output, 'utf8');
-        console.log(clr(C.gray, `[${ts}]`) + clr(C.green, ` ✓ Compiled → ${path.relative(process.cwd(), outPath)}`));
-      }
-    } catch (e) {
-      console.error(clr(C.red, `[Error] ${e.message}`));
-    }
-  }
-
-  doCompile();
-  fs.watch(abs, { persistent: true }, (event) => {
-    if (event === 'change') doCompile();
-  });
-}
-
-// flux repl
-function cmdRepl() {
-  const readline = require('readline');
-  const rl = readline.createInterface({
-    input:  process.stdin,
-    output: process.stdout,
-    prompt: clr(C.cyan, 'flux') + clr(C.gray, '> '),
-  });
-
-  banner();
-  console.log(clr(C.gray, 'Flux REPL — type Flux code and press Enter.'));
-  console.log(clr(C.gray, 'Commands: .exit  .clear  .js  .help\n'));
-
-  let buffer  = '';
-  let showJs  = false;
-
-  rl.prompt();
-
-  rl.on('line', (line) => {
-    const trimmed = line.trim();
-
-    if (trimmed === '.exit' || trimmed === '.quit') {
-      console.log(clr(C.gray, 'Goodbye!'));
-      process.exit(0);
-    }
-    if (trimmed === '.clear')  { buffer = ''; console.clear(); rl.prompt(); return; }
-    if (trimmed === '.js')     { showJs = !showJs; console.log(clr(C.gray, `Show JS: ${showJs ? 'ON' : 'OFF'}`)); rl.prompt(); return; }
-    if (trimmed === '.help')   {
-      console.log(clr(C.gray, '.exit / .quit — exit REPL'));
-      console.log(clr(C.gray, '.clear        — clear screen & buffer'));
-      console.log(clr(C.gray, '.js           — toggle JavaScript output'));
-      rl.prompt(); return;
-    }
-
-    buffer += line + '\n';
-
-    const opens  = (buffer.match(/\{/g) || []).length;
-    const closes = (buffer.match(/\}/g) || []).length;
-
-    if (opens === closes && buffer.trim().length > 0) {
-      const result = transpile(buffer);
-      if (!result.success) {
-        printErrors(result.errors, buffer, null);
-      } else {
-        if (showJs) {
-          console.log(clr(C.gray, '--- JavaScript ---'));
-          console.log(clr(C.dim, result.output));
-          console.log(clr(C.gray, '------------------'));
-        }
-        const tmpPath = require('path').join(require('os').tmpdir(), '_flux_repl_' + Date.now() + '.js');
-        fs.writeFileSync(tmpPath, result.output);
-        try { require(tmpPath); }
-        catch (e) { console.error(clr(C.red, `[Runtime] ${e.message}`)); }
-        finally   { try { fs.unlinkSync(tmpPath); } catch (_) {} }
-      }
-      buffer = '';
-    }
-
-    rl.prompt();
-  });
-
-  rl.on('close', () => { console.log(); process.exit(0); });
-}
-
-// ── flux publish ──────────────────────────────────────────────────────────────
-// Automated release workflow:
-//   1. Validate git working tree is clean
-//   2. Run full test suite
-//   3. Bump version (patch / minor / major / explicit)
-//   4. Update CHANGELOG.md (Unreleased → new version)
-//   5. git commit + tag
-//   6. Optionally: git push --follow-tags
-//   7. Optionally: npm publish
-//
-// Flags:
-//   --patch        bump patch (default)
-//   --minor        bump minor
-//   --major        bump major
-//   --ver <x.y.z>  explicit version
-//   --push         git push origin + tags after tagging
-//   --npm          run npm publish after tagging
-//   --dry-run      print what would happen; no writes or git operations
-//   --skip-tests   skip test suite (faster, risky)
-//   --yes / -y     skip all confirmation prompts
-
-function cmdPublish(publishOpts) {
-  const { execSync, spawnSync } = require('child_process');
-  const readline = require('readline');
-
-  const isDry       = publishOpts.dryRun;
-  const doPush      = publishOpts.push;
-  const doNpm       = publishOpts.npm;
-  const skipTests   = publishOpts.skipTests;
-  const autoYes     = publishOpts.yes;
-  const bumpType    = publishOpts.bump || 'patch';   // 'patch' | 'minor' | 'major' | explicit
-  const explicitVer = publishOpts.ver || null;
-
-  // ── helpers ─────────────────────────────────────────────────────────────────
-  function step(msg)   { console.log(clr(C.cyan,  `\n  ▸ ${msg}`)); }
-  function ok(msg)     { console.log(clr(C.green, `  ✓ ${msg}`)); }
-  function warn(msg)   { console.log(clr(C.yellow,`  ⚠ ${msg}`)); }
-  function fail(msg)   { console.error(clr(C.red,  `  ✗ ${msg}`)); process.exit(1); }
-  function info(msg)   { console.log(clr(C.gray,   `    ${msg}`)); }
-  function dry(msg)    { console.log(clr(C.dim,    `  [dry] ${msg}`)); }
-
-  function run(cmd, opts = {}) {
-    if (isDry) { dry(cmd); return ''; }
-    try {
-      return execSync(cmd, { encoding: 'utf8', stdio: opts.silent ? 'pipe' : 'inherit' });
-    } catch (e) {
-      if (opts.allowFail) return null;
-      fail(`Command failed: ${cmd}\n${e.message}`);
-    }
-  }
-
-  function runSilent(cmd) {
-    try { return execSync(cmd, { encoding: 'utf8', stdio: 'pipe' }); }
-    catch (e) { return null; }
-  }
-
-  // ── bump version logic ───────────────────────────────────────────────────────
-  function bumpVersion(current, type) {
-    if (explicitVer) return explicitVer;
-    const parts = current.split('.').map(Number);
-    if (type === 'major') { parts[0]++; parts[1] = 0; parts[2] = 0; }
-    else if (type === 'minor') { parts[1]++; parts[2] = 0; }
-    else { parts[2]++; }
-    return parts.join('.');
-  }
-
-  // ── update CHANGELOG ────────────────────────────────────────────────────────
-  function updateChangelog(newVersion, changelogPath) {
-    if (!fs.existsSync(changelogPath)) {
-      warn('CHANGELOG.md not found — skipping changelog update');
-      return false;
-    }
-    const content = fs.readFileSync(changelogPath, 'utf8');
-    const date    = new Date().toISOString().slice(0, 10);
-    const marker  = '## [Unreleased]';
-
-    if (!content.includes(marker)) {
-      warn('No [Unreleased] section found in CHANGELOG.md');
-      return false;
-    }
-
-    const updated = content.replace(
-      marker,
-      `${marker}\n\n## [${newVersion}] — ${date}`
-    );
-
-    if (isDry) {
-      dry(`CHANGELOG.md: replace "${marker}" → add "## [${newVersion}] — ${date}"`);
-    } else {
-      fs.writeFileSync(changelogPath, updated, 'utf8');
-    }
-    return true;
-  }
-
-  // ── confirm prompt ───────────────────────────────────────────────────────────
-  function confirm(question) {
-    return new Promise(resolve => {
-      if (autoYes || isDry) { console.log(clr(C.gray, `  ? ${question} → y (auto)`)); return resolve(true); }
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      rl.question(clr(C.yellow, `  ? ${question} [y/N] `), ans => {
-        rl.close();
-        resolve(ans.trim().toLowerCase() === 'y');
-      });
-    });
-  }
-
-  // ── MAIN FLOW (async) ────────────────────────────────────────────────────────
-  async function publish() {
-    banner();
-    console.log(clr(C.bold, `  Release Workflow${isDry ? clr(C.yellow, ' [DRY RUN]') : ''}\n`));
-
-    const pkgPath       = path.resolve('package.json');
-    const changelogPath = path.resolve('CHANGELOG.md');
-
-    // ── 0. Read package.json ─────────────────────────────────────────────────
-    if (!fs.existsSync(pkgPath)) fail('package.json not found');
-    const pkg        = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    const oldVersion = pkg.version;
-    const newVersion = bumpVersion(oldVersion, bumpType);
-
-    step(`Preparing release: ${clr(C.gray, oldVersion)} → ${clr(C.green, newVersion)}`);
-    info(`Package: ${pkg.name}`);
-    info(`Bump:    ${explicitVer ? `explicit (${newVersion})` : bumpType}`);
-    info(`Dry run: ${isDry ? 'YES' : 'no'}`);
-    info(`Push:    ${doPush ? 'yes' : 'no'}`);
-    info(`npm:     ${doNpm ? 'yes' : 'no'}`);
-    console.log();
-
-    // ── 1. Git availability ──────────────────────────────────────────────────
-    step('Checking git');
-    const gitVersion = runSilent('git --version');
-    if (!gitVersion) fail('git is not installed or not in PATH');
-    ok(`git found: ${gitVersion.trim()}`);
-
-    // ── 2. Working tree status ───────────────────────────────────────────────
-    step('Checking working tree');
-    const status = runSilent('git status --porcelain');
-    if (status && status.trim().length > 0) {
-      warn('Working tree has uncommitted changes:');
-      status.trim().split('\n').forEach(l => info(l));
-      const cont = await confirm('Continue anyway? (uncommitted changes will be committed with the release)');
-      if (!cont) fail('Aborted — please commit or stash changes first');
-    } else {
-      ok('Working tree is clean');
-    }
-
-    // ── 3. Check tag doesn't already exist ───────────────────────────────────
-    const tagName    = `v${newVersion}`;
-    const existsTag  = runSilent(`git tag -l ${tagName}`);
-    if (existsTag && existsTag.trim() === tagName) {
-      fail(`Tag ${tagName} already exists — bump the version again or delete the tag first`);
-    }
-
-    // ── 4. Run tests ─────────────────────────────────────────────────────────
-    if (skipTests) {
-      warn('Skipping tests (--skip-tests)');
-    } else {
-      step('Running test suite');
-      const testDir = fs.existsSync(path.resolve('tests')) ? 'tests' : null;
-      if (!testDir) {
-        warn('No tests/ directory found — skipping');
-      } else {
-        if (isDry) {
-          dry('node bin/flux.js test tests/');
-          ok('Tests passed (dry run)');
-        } else {
-          const { runTests } = require('../src/test-runner');
-          const savedExit = process.exitCode;
-          let testsPassed = true;
-          try {
-            // Run tests synchronously via child process so we get exit code
-            execSync('node bin/flux.js test tests/', {
-              encoding: 'utf8',
-              stdio: 'inherit',
-              env: { ...process.env, NO_COLOR: process.env.NO_COLOR },
-            });
-          } catch {
-            testsPassed = false;
-          }
-          if (!testsPassed) fail('Tests failed — fix them before releasing');
-          ok('All tests passed');
-        }
-      }
-    }
-
-    // ── 5. Confirm version ───────────────────────────────────────────────────
-    step('Confirm release');
-    const go = await confirm(`Release ${clr(C.bold, pkg.name + '@' + newVersion)} (${tagName})?`);
-    if (!go) fail('Release cancelled');
-
-    // ── 6. Bump package.json ─────────────────────────────────────────────────
-    step(`Bumping package.json: ${oldVersion} → ${newVersion}`);
-    if (!isDry) {
-      pkg.version = newVersion;
-      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
-    } else {
-      dry(`package.json: "version": "${oldVersion}" → "${newVersion}"`);
-    }
-    ok(`package.json updated`);
-
-    // ── 7. Update CHANGELOG ──────────────────────────────────────────────────
-    step('Updating CHANGELOG.md');
-    const clUpdated = updateChangelog(newVersion, changelogPath);
-    if (clUpdated) ok(`CHANGELOG.md updated — [${newVersion}] section created`);
-
-    // ── 8. Git commit ────────────────────────────────────────────────────────
-    step('Creating git commit');
-    run('git add package.json CHANGELOG.md');
-    run(`git commit -m "chore: release ${tagName}"`);
-    ok(`Committed: chore: release ${tagName}`);
-
-    // ── 9. Git tag ───────────────────────────────────────────────────────────
-    step(`Creating git tag: ${tagName}`);
-    run(`git tag -a ${tagName} -m "Release ${tagName}"`);
-    ok(`Tag created: ${tagName}`);
-
-    // ── 10. Git push ─────────────────────────────────────────────────────────
-    if (doPush) {
-      step('Pushing to origin');
-      run('git push origin HEAD --follow-tags');
-      ok('Pushed branch + tags to origin');
-      if (doNpm) info('→ GitHub Actions publish.yml will now auto-publish to npm');
-    } else {
-      info(`To push: ${clr(C.yellow, 'git push origin HEAD --follow-tags')}`);
-    }
-
-    // ── 11. npm publish ──────────────────────────────────────────────────────
-    if (doNpm) {
-      step('Publishing to npm');
-      const npmWho = runSilent('npm whoami');
-      if (!npmWho) {
-        warn('Not logged in to npm — run: npm login');
-        warn('Skipping npm publish');
-      } else {
-        info(`npm user: ${npmWho.trim()}`);
-        run('npm publish --access public');
-        ok(`Published to npm: ${pkg.name}@${newVersion}`);
-      }
-    } else {
-      info(`To publish: ${clr(C.yellow, 'npm publish --access public')}`);
-    }
-
-    // ── Done ─────────────────────────────────────────────────────────────────
-    console.log();
-    console.log(clr(C.green, C.bold + `  ✓ Released: ${pkg.name}@${newVersion}` + C.reset));
-    console.log();
-    console.log(clr(C.gray, '  Summary:'));
-    console.log(`    ${clr(C.cyan,   `package.json`)}  version → ${newVersion}`);
-    if (clUpdated)
-      console.log(`    ${clr(C.cyan,   `CHANGELOG.md`)}  [${newVersion}] — ${new Date().toISOString().slice(0,10)}`);
-    console.log(`    ${clr(C.cyan,   `git tag`)}       ${tagName}`);
-    if (doPush)
-      console.log(`    ${clr(C.cyan,   `git push`)}      origin + tags`);
-    if (doNpm && !isDry)
-      console.log(`    ${clr(C.cyan,   `npm`)}           ${pkg.name}@${newVersion} published`);
-    console.log();
-
-    if (isDry) {
-      console.log(clr(C.yellow, '  [Dry run] — no files changed, no git operations performed\n'));
-    }
-  }
-
-  publish().catch(e => {
-    console.error(clr(C.red, `\n✗ Publish error: ${e.message}\n`));
-    process.exit(1);
-  });
-}
-
-// ── flux self-hosted ─────────────────────────────────────────────────────────
-// Shows bootstrap status, toggles the active compiler, and lets the user
-// rebuild/verify self-hosting from within the CLI.
-function cmdSelfHosted(subArg) {
-  const SELF_DIR   = path.join(__dirname, '../src/self');
-  const BOOTSTRAP  = path.join(__dirname, '../scripts/bootstrap.js');
-  const { execSync, spawnSync } = require('child_process');
-
-  const SOURCES = [
-    'css-preprocessor', 'checker', 'type-checker', 'jsx',
-    'lexer', 'parser', 'codegen', 'transpiler',
-    'formatter', 'sourcemap', 'stdlib', 'mangler',
-    'linter', 'bundler', 'test-runner',
-  ];
-
-  // ── sub-commands ──────────────────────────────────────────────────────────
-
-  // flux self-hosted build — compile all .flux sources to .js
-  if (subArg === 'build') {
-    console.log(clr(C.cyan, '\n⊛ Building self-hosted compiler (all 15 modules)...\n'));
-    const t0 = Date.now();
-    let ok = 0, fail = 0;
-    for (const name of SOURCES) {
-      const src = path.join(SELF_DIR, name + '.flux');
-      const out = path.join(SELF_DIR, name + '.js');
-      if (!fs.existsSync(src)) {
-        console.log(clr(C.yellow, `  ⚠  ${name}.flux — missing`));
-        fail++;
-        continue;
-      }
-      try {
-        execSync(`node "${path.join(__dirname, 'flux.js')}" compile "${src}" -o "${out}" --no-mangle`, {
-          cwd: path.join(__dirname, '..'),
-          stdio: 'pipe',
-        });
-        console.log(clr(C.green, `  ✓`) + clr(C.gray, `  ${name}.flux → ${name}.js`));
-        ok++;
-      } catch (e) {
-        const msg = e.stderr ? e.stderr.toString().split('\n')[0] : e.message;
-        console.log(clr(C.red, `  ✗  ${name}.flux — ${msg}`));
-        fail++;
-      }
-    }
-    const elapsed = Date.now() - t0;
-    console.log();
-    if (fail === 0) {
-      console.log(clr(C.green, `✓ All ${ok} modules built`) + clr(C.gray, ` in ${elapsed}ms`));
-      console.log(clr(C.gray, `  Run: flux self-hosted on  to activate`));
-    } else {
-      console.log(clr(C.red, `✗ ${fail} module(s) failed`) + clr(C.gray, `, ${ok} succeeded`));
-      process.exitCode = 1;
-    }
-    console.log();
-    return;
-  }
-
-  // flux self-hosted verify — run bootstrap.js (all 3 stages)
-  if (subArg === 'verify') {
-    console.log(clr(C.cyan, '\n⊛ Running full bootstrap verification...\n'));
-    const result = spawnSync('node', [BOOTSTRAP, '--verbose'], {
-      cwd: path.join(__dirname, '..'),
-      stdio: 'inherit',
-    });
-    process.exitCode = result.status || 0;
-    return;
-  }
-
-  // flux self-hosted on — activate self-hosted compiler
-  if (subArg === 'on') {
-    const envFile = path.join(__dirname, '../.env.flux');
-    // Check all .js files exist
-    const missing = SOURCES.filter(n => !fs.existsSync(path.join(SELF_DIR, n + '.js')));
-    if (missing.length > 0) {
-      console.log(clr(C.yellow, '\n⚠  Self-hosted compiler not built yet. Run:\n'));
-      console.log(clr(C.cyan, '    flux self-hosted build\n'));
-      return;
-    }
-    fs.writeFileSync(envFile, 'FLUX_SELF_HOSTED=1\n', 'utf8');
-    console.log();
-    console.log(clr(C.green, '✓ Self-hosted compiler activated'));
-    console.log(clr(C.gray,  '  All flux commands now use src/self/*.js (compiled-from-Flux)'));
-    console.log(clr(C.gray,  '  Deactivate anytime: flux self-hosted off'));
-    console.log(clr(C.gray,  '  Or use per-command: flux --self-hosted compile <file>'));
-    console.log();
-    return;
-  }
-
-  // flux self-hosted off — deactivate self-hosted compiler
-  if (subArg === 'off') {
-    const envFile = path.join(__dirname, '../.env.flux');
-    if (fs.existsSync(envFile)) fs.unlinkSync(envFile);
-    console.log();
-    console.log(clr(C.green, '✓ Self-hosted compiler deactivated'));
-    console.log(clr(C.gray,  '  flux now uses the stage-0 JavaScript compiler (src/*.js)'));
-    console.log();
-    return;
-  }
-
-  // flux self-hosted (no subArg) — show status dashboard
-  console.log(clr(C.cyan, C.bold + '\n  Flux Self-Hosted Compiler Status\n' + C.reset));
-
-  // Detect active mode
-  const isActive = USE_SELF_HOSTED;
-  const activeLabel = isActive
-    ? clr(C.green, '● ACTIVE') + clr(C.gray, '  (using self-hosted compiler)')
-    : clr(C.gray,  '○ INACTIVE') + clr(C.gray, '  (using stage-0 compiler)');
-  console.log(`  Mode:      ${activeLabel}`);
-  console.log(`  Activate:  ${clr(C.yellow, 'flux self-hosted on')}  ${clr(C.gray, '  or  --self-hosted flag')}`);
-  console.log();
-
-  // Module status table
-  const CORE_MODULES = ['css-preprocessor','checker','type-checker','jsx','lexer','parser','codegen','transpiler'];
-  const TOOL_MODULES = ['formatter','sourcemap','stdlib','mangler','linter','bundler','test-runner'];
-
-  function printModuleGroup(label, names) {
-    console.log(clr(C.bold, `  ${label}`));
-    let allBuilt = true;
-    for (const name of names) {
-      const fluxPath = path.join(SELF_DIR, name + '.flux');
-      const jsPath   = path.join(SELF_DIR, name + '.js');
-      const hasFlux  = fs.existsSync(fluxPath);
-      const hasJs    = fs.existsSync(jsPath);
-
-      let status, note = '';
-      if (hasJs && hasFlux) {
-        const fluxMtime = fs.statSync(fluxPath).mtimeMs;
-        const jsMtime   = fs.statSync(jsPath).mtimeMs;
-        if (fluxMtime > jsMtime) {
-          status = clr(C.yellow, '⚡ stale');
-          note   = clr(C.gray, '  (.flux newer than .js — run: flux self-hosted build)');
-          allBuilt = false;
-        } else {
-          const jsKB = (fs.statSync(jsPath).size / 1024).toFixed(1);
-          status = clr(C.green, '✓ built');
-          note   = clr(C.gray, `  ${jsKB} KB`);
-        }
-      } else if (hasFlux && !hasJs) {
-        status   = clr(C.red, '✗ not built');
-        note     = clr(C.gray, '  (.js missing)');
-        allBuilt = false;
-      } else if (!hasFlux) {
-        status   = clr(C.red, '✗ missing');
-        note     = clr(C.gray, '  (.flux source not found)');
-        allBuilt = false;
-      }
-      const padded = (name + '.flux').padEnd(24);
-      console.log(`    ${clr(C.cyan, padded)}  ${status}${note}`);
-    }
-    return allBuilt;
-  }
-
-  const coreOk = printModuleGroup('Core Pipeline (8 modules)', CORE_MODULES);
-  console.log();
-  const toolOk = printModuleGroup('Extended Toolchain (7 modules)', TOOL_MODULES);
-  console.log();
-
-  const allOk = coreOk && toolOk;
-  if (allOk) {
-    console.log(clr(C.green, '  ✓ All 15 modules compiled and up-to-date'));
-  } else {
-    console.log(clr(C.yellow, '  ⚠  Some modules need rebuilding.') + '  Run: ' + clr(C.cyan, 'flux self-hosted build'));
-  }
-
-  // Show stage-2 proof if it exists
-  const stage2 = path.join(SELF_DIR, 'lexer.stage2.js');
-  if (fs.existsSync(stage2)) {
-    const mtime = new Date(fs.statSync(stage2).mtimeMs);
-    const when  = mtime.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
-    console.log(clr(C.gray,  `\n  Stage-2 self-compile proof: lexer.stage2.js  (verified ${when})`));
-  }
-
-  console.log();
-  console.log(clr(C.bold, '  Commands:'));
-  const cmds2 = [
-    ['flux self-hosted build',  'Compile all 15 .flux → .js modules'],
-    ['flux self-hosted verify', 'Full 3-stage bootstrap verification'],
-    ['flux self-hosted on',     'Activate self-hosted compiler globally'],
-    ['flux self-hosted off',    'Revert to stage-0 compiler'],
-  ];
-  for (const [c, d] of cmds2) {
-    console.log(`    ${clr(C.cyan, c.padEnd(32))}  ${clr(C.gray, d)}`);
-  }
-  console.log();
-}
-
-// ── Argument Parser ───────────────────────────────────────────────────────────
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const cmd  = args[0];
-  const file = args[1] && !args[1].startsWith('-') ? args[1] : null;
-
-  // General opts
-  const opts = { stdout: false, out: null, sourcemap: false, mangle: true };
-
-  // Publish-specific opts
-  const publishOpts = {
-    bump:       'patch',
-    ver:        null,
-    push:       false,
-    npm:        false,
-    dryRun:     false,
-    skipTests:  false,
-    yes:        false,
-  };
-
-  for (let i = 0; i < args.length; i++) {
-    // General
-    if (args[i] === '--stdout')                                    opts.stdout    = true;
-    if (args[i] === '--sourcemap' || args[i] === '-m')             opts.sourcemap = true;
-    if (args[i] === '--mangle'    || args[i] === '-M')             opts.mangle    = true;
-    if (args[i] === '--no-mangle' || args[i] === '-nm')            opts.mangle    = false;
-    if ((args[i] === '-o' || args[i] === '--out') && args[i + 1]) opts.out       = args[++i];
-    if (args[i] === '--no-color')                                  process.env.NO_COLOR = '1';
-
-    // Publish
-    if (args[i] === '--patch')                                          publishOpts.bump      = 'patch';
-    if (args[i] === '--minor')                                          publishOpts.bump      = 'minor';
-    if (args[i] === '--major')                                          publishOpts.bump      = 'major';
-    if ((args[i] === '--ver' || args[i] === '--version-explicit') && args[i + 1])
-                                                                        publishOpts.ver       = args[++i];
-    if (args[i] === '--push')                                           publishOpts.push      = true;
-    if (args[i] === '--npm')                                            publishOpts.npm       = true;
-    if (args[i] === '--dry-run' || args[i] === '--dry')                publishOpts.dryRun    = true;
-    if (args[i] === '--skip-tests')                                     publishOpts.skipTests = true;
-    if (args[i] === '--yes' || args[i] === '-y')                       publishOpts.yes       = true;
-  }
-
-  return { cmd, file, opts, publishOpts };
-}
-
-// ── Entry Point ───────────────────────────────────────────────────────────────
-function main() {
-  const { cmd, file, opts, publishOpts } = parseArgs(process.argv);
-
-  switch (cmd) {
-    case 'init': {
-      const name = process.argv[3] && !process.argv[3].startsWith('-') ? process.argv[3] : null;
-      cmdInit(name);
-      break;
-    }
-    case 'compile': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux compile <file.flux>')); process.exit(1); }
-      cmdCompile(file, opts);
-      break;
-    }
-    case 'bundle': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux bundle <entry.flux>')); process.exit(1); }
-      cmdBundle(file, opts);
-      break;
-    }
-    case 'run': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux run <file.flux>')); process.exit(1); }
-      cmdRun(file);
-      break;
-    }
-    case 'check': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux check <file.flux>')); process.exit(1); }
-      cmdCheck(file);
-      break;
-    }
-    case 'lint': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux lint <file.flux>')); process.exit(1); }
-      cmdLint(file);
-      break;
-    }
-    case 'tokens': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux tokens <file.flux>')); process.exit(1); }
-      cmdTokens(file);
-      break;
-    }
-    case 'ast': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux ast <file.flux>')); process.exit(1); }
-      cmdAst(file);
-      break;
-    }
-    case 'watch': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux watch <file.flux>')); process.exit(1); }
-      cmdWatch(file, opts);
-      break;
-    }
-    case 'fmt': {
-      if (!file) { console.error(clr(C.red, 'Specify a file: flux fmt <file.flux>')); process.exit(1); }
-      cmdFmt(file, opts);
-      break;
-    }
-    case 'test': {
-      cmdTest(file || process.argv[3]);
-      break;
-    }
-    case 'publish': {
-      cmdPublish(publishOpts);
-      break;
-    }
-    case 'self-hosted': {
-      const subArg = process.argv[3] && !process.argv[3].startsWith('-') ? process.argv[3] : undefined;
-      cmdSelfHosted(subArg);
-      break;
-    }
-    case 'repl':
-    case undefined:
-      if (!cmd) { showHelp(); }
-      else       { cmdRepl(); }
-      break;
-    case 'version':
-      console.log(`flux-lang v${VERSION}`);
-      break;
-    case 'help':
-    default:
-      showHelp();
-  }
-}
-
-main();
+require('../dist/flux-cli.js');