@xnoxs/flux-lang 3.3.3 → 3.4.0

package/src/self/cli.js

@@ -0,0 +1,818 @@
+// ── Flux stdlib ──
+
+function some(arr, fn) { return arr.some(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function max(arr) {
+  if (arguments.length > 1) return Math.max.apply(null, arguments);
+  return Math.max.apply(null, arr);
+}
+
+function padStart(s, len, char) {
+  return String(s).padStart(len, char || ' ');
+}
+
+function padEnd(s, len, char) {
+  return String(s).padEnd(len, char || ' ');
+}
+
+function trim(s) { return String(s).trim(); }
+
+function trimEnd(s) { return String(s).trimEnd(); }
+
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }
+
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }
+
+function repeat(s, n) { return String(s).repeat(n); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.2.0
+"use strict";
+
+const Fs = require("fs");
+const Path = require("path");
+const Os = require("os");
+const { transpile, FLUX_VERSION, FLUX_STAGE } = require("./transpiler");
+const { bundle } = require("./bundler");
+const { format } = require("./formatter");
+const { lint } = require("./linter");
+const { runTests } = require("./test-runner");
+const { loadConfig } = require("./config");
+const { cmdAdd, cmdRemove, cmdInstall, cmdList, cmdSearch, cmdInfo, cmdPublish } = require("./pkg");
+const VERSION = (FLUX_VERSION ?? "3.0.0");
+const STAGE = (FLUX_STAGE ?? "self-hosted");
+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", magenta: "\\x1b[35m" };
+const noColor = (process.env.NO_COLOR || !process.stdout.isTTY);
+function clr(c, s) {
+  return (noColor ? s : ((c + s) + C.reset));
+}
+function bold(s) {
+  return clr(C.bold, s);
+}
+function gray(s) {
+  return clr(C.gray, s);
+}
+function green(s) {
+  return clr(C.green, s);
+}
+function red(s) {
+  return clr(C.red, s);
+}
+function cyan(s) {
+  return clr(C.cyan, s);
+}
+function yellow(s) {
+  return clr(C.yellow, s);
+}
+function blue(s) {
+  return clr(C.blue, s);
+}
+function showBanner() {
+  if (noColor) {
+    console.log((((("Flux Lang " + VERSION) + " [") + STAGE) + "]"));
+    return;
+  }
+  console.log(cyan(bold("███████╗██╗     ██╗   ██╗██╗  ██╗\n██╔════╝██║     ██║   ██║╚██╗██╔╝\n█████╗  ██║     ██║   ██║ ╚███╔╝\n██╔══╝  ██║     ██║   ██║ ██╔██╗\n██║     ███████╗╚██████╔╝██╔╝ ██╗\n╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝")));
+  console.log(gray((((("  Flux Lang v" + VERSION) + "  [") + STAGE) + "]  → JavaScript\n")));
+}
+function showHelp() {
+  showBanner();
+  console.log(bold("USAGE:"));
+  console.log("  flux <command> [options]\n");
+  console.log(bold("COMPILER:"));
+  const compilerCmds = [["compile <file.flux>", "Compile .flux → .js"], ["bundle  <entry.flux>", "Bundle multiple files into one .js"], ["run     <file.flux>", "Compile and run immediately"], ["watch   <file.flux>", "Watch for changes, auto-compile"], ["check   <file.flux>", "Type-check and static analysis"]];
+  for (const __item__ of compilerCmds) {
+    const [cmd, desc] = __item__;
+    console.log(((("  " + green(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
+  }
+  console.log();
+  console.log(bold("TOOLING:"));
+  const toolCmds = [["lint    <file.flux>", "Full lint: types + style + immutability"], ["fmt     <file.flux>", "Format source code in-place"], ["test    [dir]", "Run *.test.flux files"], ["repl", "Interactive REPL mode"], ["tokens  <file.flux>", "Show lexer token list"], ["ast     <file.flux>", "Show Abstract Syntax Tree (JSON)"]];
+  for (const __item__ of toolCmds) {
+    const [cmd, desc] = __item__;
+    console.log(((("  " + green(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
+  }
+  console.log();
+  console.log(bold("PACKAGE MANAGER:"));
+  const pkgCmds = [["init    [name]", "Scaffold a new Flux project"], ["add     <pkg[@version]>", "Add a dependency"], ["remove  <pkg>", "Remove a dependency"], ["install", "Install all dependencies"], ["list", "List installed packages"], ["search  <query>", "Search the package registry"], ["info    <pkg>", "Show package details"], ["publish", "Publish package to registry"]];
+  for (const __item__ of pkgCmds) {
+    const [cmd, desc] = __item__;
+    console.log(((("  " + cyan(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
+  }
+  console.log();
+  console.log(bold("SELF-HOSTED:"));
+  const selfCmds = [["self-hosted", "Show self-hosted compiler status"], ["self-hosted build", "Bootstrap: compile compiler with itself"], ["self-hosted verify", "Verify self-hosted output matches stage-0"]];
+  for (const __item__ of selfCmds) {
+    const [cmd, desc] = __item__;
+    console.log(((("  " + yellow(("flux " + cmd).padEnd(36))) + " ") + gray(desc)));
+  }
+  console.log();
+  console.log(bold("OPTIONS:"));
+  console.log((("  " + yellow("--out, -o <file>  ")) + "  Output file"));
+  console.log((("  " + yellow("--sourcemap, -m   ")) + "  Generate .js.map"));
+  console.log((("  " + yellow("--watch, -w       ")) + "  Watch mode"));
+  console.log((("  " + yellow("--mangle          ")) + "  Minify identifiers"));
+  console.log((("  " + yellow("--typecheck       ")) + "  Enable type checking"));
+  console.log((("  " + yellow("--stdout          ")) + "  Print to terminal"));
+  console.log((("  " + yellow("--no-color        ")) + "  Disable colors"));
+  console.log();
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = { out: null, sourcemap: false, mangle: false, typecheck: false, strict: false, stdout: false, watch: false, dev: false, verbose: false, jsx: false, jsxTarget: "browser" };
+  const positional = [];
+  let i = 0;
+  while ((i < args.length)) {
+    const a = args[i];
+    if (((a == "--out") || (a == "-o"))) {
+      i = (i + 1);
+      opts.out = args[i];
+    }
+    else if (((a == "--sourcemap") || (a == "-m"))) {
+      opts.sourcemap = true;
+    }
+    else if ((a == "--mangle")) {
+      opts.mangle = true;
+    }
+    else if (((a == "--typecheck") || (a == "-t"))) {
+      opts.typecheck = true;
+    }
+    else if ((a == "--strict")) {
+      opts.strict = true;
+    }
+    else if ((a == "--stdout")) {
+      opts.stdout = true;
+    }
+    else if (((a == "--watch") || (a == "-w"))) {
+      opts.watch = true;
+    }
+    else if ((a == "--dev")) {
+      opts.dev = true;
+    }
+    else if (((a == "--verbose") || (a == "-v"))) {
+      opts.verbose = true;
+    }
+    else if ((a == "--jsx")) {
+      opts.jsx = true;
+    }
+    else if ((a == "--jsx-target")) {
+      i = (i + 1);
+      opts.jsxTarget = args[i];
+    }
+    else if (!a.startsWith("--")) {
+      positional.push(a);
+    }
+    i = (i + 1);
+  }
+  return { positional, opts };
+}
+function readFluxFile(filePath) {
+  const abs = Path.resolve(filePath);
+  if (!Fs.existsSync(abs)) {
+    console.error(red(("✗ File not found: " + abs)));
+    process.exit(1);
+  }
+  if (!filePath.endsWith(".flux")) {
+    console.warn(yellow(("⚠  Not a .flux file: " + filePath)));
+  }
+  return { source: Fs.readFileSync(abs, "utf8"), abs };
+}
+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"));
+}
+const ERROR_KIND = { ParseError: "Syntax error", LexerError: "Syntax error", CheckError: "Static error", TypeCheckError: "Type error", TypeError: "Type error" };
+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 ? gray(((" [" + err.stage) + "]")) : "");
+    console.error();
+    console.error((red(bold(kind)) + stage));
+    if (err.line) {
+      const fileLabel = (filePath ? cyan(Path.relative(process.cwd(), filePath)) : "");
+      const locLabel = yellow(((err.line + ":") + (err.col ?? 1)));
+      if (fileLabel) {
+        console.error(((("  " + fileLabel) + ":") + locLabel));
+      }
+      else {
+        console.error(("  Line " + locLabel));
+      }
+    }
+    console.error(("  " + err.message));
+    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));
+      if (((errLineIdx > 0) && (lines[(errLineIdx - 1)].trim() != ""))) {
+        const prev = String((err.line - 1)).padStart(4);
+        console.error(gray(((("  " + prev) + " │ ") + lines[(errLineIdx - 1)])));
+      }
+      const lineNum = String(err.line).padStart(4);
+      console.error((gray((("  " + lineNum) + " │ ")) + lines[errLineIdx]));
+      const squiggle = ("^" + "~".repeat(Math.max(0, (tokLen - 1))));
+      const pointer = (" ".repeat(col) + red(squiggle));
+      console.error((gray("       │ ") + pointer));
+      if ((((errLineIdx + 1) < lines.length) && (lines[(errLineIdx + 1)].trim() != ""))) {
+        const next = String((err.line + 1)).padStart(4);
+        console.error(gray(((("  " + next) + " │ ") + lines[(errLineIdx + 1)])));
+      }
+    }
+    if (err.hint) {
+      console.error((cyan("  Hint: ") + gray(err.hint)));
+    }
+  }
+  console.error();
+}
+function cmdCompile(filePath, opts) {
+  const { source, abs } = readFluxFile(filePath);
+  const cfg = loadConfig(Path.dirname(abs));
+  const outPath = deriveOutPath(filePath, opts.out);
+  const mapPath = (outPath + ".map");
+  const t0 = Date.now();
+  const result = transpile(source, { sourcemap: (opts.sourcemap ?? cfg.sourcemap), mangle: (opts.mangle ?? cfg.mangle), typecheck: (opts.typecheck ?? cfg.typecheck), jsx: (opts.jsx ?? cfg.jsx), jsxTarget: (opts.jsxTarget ?? cfg.jsxTarget), sourceFile: Path.relative(Path.dirname(outPath), abs), outputFile: Path.basename(outPath) });
+  if (!result.success) {
+    console.error(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 = gray((" + " + Path.relative(process.cwd(), mapPath)));
+  }
+  const rel = Path.relative(process.cwd(), abs);
+  const relO = Path.relative(process.cwd(), outPath);
+  console.log((((((green("✓ ") + gray((("(" + elapsed) + "ms) "))) + blue(rel)) + gray(" → ")) + cyan(relO)) + extra));
+  if ((result.typeErrors && (result.typeErrors.length > 0))) {
+    console.warn(yellow((("\n⚠  " + result.typeErrors.length) + " type warning(s)")));
+    printErrors(result.typeErrors, source, abs);
+  }
+}
+function cmdRun(filePath, opts) {
+  const { source, abs } = readFluxFile(filePath);
+  const result = transpile(source, { jsx: (opts.jsx ?? false), jsxTarget: (opts.jsxTarget ?? "browser"), mangle: false });
+  if (!result.success) {
+    console.error(red("\n✗ Compile error"));
+    printErrors(result.errors, source, abs);
+    process.exit(1);
+  }
+  const tmpPath = Path.join(Os.tmpdir(), (("_flux_run_" + Date.now()) + ".js"));
+  Fs.writeFileSync(tmpPath, result.output, "utf8");
+  console.log(gray((("▶ Running " + Path.basename(abs)) + " ...\n")));
+  try {
+    require(tmpPath);
+  }
+  catch (e) {
+    console.error(red(("\n[Runtime Error] " + e.message)));
+    process.exitCode = 1;
+  }
+  finally {
+    try {
+      Fs.unlinkSync(tmpPath);
+    }
+    catch (e2) {
+      null;
+    }
+  }
+}
+function runCheck(abs) {
+  const source = Fs.readFileSync(abs, "utf8");
+  const baseName = Path.basename(abs);
+  const result = transpile(source, { check: true, typecheck: true });
+  if (!result.success) {
+    const n = result.errors.length;
+    const kind = (result.errors.some((e) => (e.name == "CheckError")) ? "static" : "syntax");
+    console.error(red((((((("\n✗ " + baseName) + ": ") + n) + " ") + kind) + " error(s)")));
+    printErrors(result.errors, source, abs);
+    return { ok: false, typeErrors: 0, warnings: 0 };
+  }
+  let allOk = true;
+  const typeErrors = (result.typeErrors ?? []);
+  if ((typeErrors.length > 0)) {
+    console.error(red((((("\n✗ " + baseName) + ": ") + typeErrors.length) + " type error(s)")));
+    printErrors(typeErrors, source, abs);
+    allOk = false;
+  }
+  const warnings = (result.typeWarnings ?? []);
+  for (const w of warnings) {
+    const fileRef = (cyan(baseName) + (w.line ? yellow((":" + w.line)) : ""));
+    console.warn(((yellow("  ⚠ ") + fileRef) + gray(("  " + w.message))));
+    if (w.hint) {
+      console.warn((cyan("    Hint: ") + gray(w.hint)));
+    }
+  }
+  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;
+  if (allOk) {
+    console.log((((green("✓ ") + cyan(baseName)) + gray(" — no errors")) + gray((((((("  Functions: " + fns) + "  |  Classes: ") + cls) + "  |  JS output: ") + result.output.split("\n").length) + " lines"))));
+  }
+  return { ok: allOk, typeErrors: typeErrors.length, warnings: warnings.length };
+}
+function cmdCheck(filePaths, opts) {
+  if ((filePaths.length == 0)) {
+    console.error(red("✗ No files specified"));
+    process.exit(1);
+  }
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const filePath of filePaths) {
+    const abs = Path.resolve(filePath);
+    if (!Fs.existsSync(abs)) {
+      console.error(red(("✗ File not found: " + filePath)));
+      totalErrors = (totalErrors + 1);
+      continue;
+    }
+    const r = runCheck(abs);
+    if (!r.ok) {
+      totalErrors = (totalErrors + 1);
+    }
+    totalWarnings = (totalWarnings + r.warnings);
+  }
+  console.log();
+  if ((totalErrors > 0)) {
+    console.error(red((("✗ " + totalErrors) + " file(s) with errors")));
+    process.exit(1);
+  }
+  else {
+    console.log((green("✓ All files OK") + ((totalWarnings > 0) ? yellow((("  (" + totalWarnings) + " warning(s))")) : "")));
+  }
+}
+function cmdFmt(filePaths, opts) {
+  let changed = 0;
+  for (const filePath of filePaths) {
+    const abs = Path.resolve(filePath);
+    if (!Fs.existsSync(abs)) {
+      console.error(red(("✗ Not found: " + filePath)));
+      continue;
+    }
+    const source = Fs.readFileSync(abs, "utf8");
+    const formatted = format(source);
+    if ((formatted != source)) {
+      if (!opts.stdout) {
+        Fs.writeFileSync(abs, formatted, "utf8");
+        console.log(((green("✓ ") + gray("Formatted ")) + cyan(Path.relative(process.cwd(), abs))));
+        changed = (changed + 1);
+      }
+      else {
+        console.log(formatted);
+      }
+    }
+    else {
+      console.log(((gray("○ ") + gray("No changes: ")) + Path.relative(process.cwd(), abs)));
+    }
+  }
+  if ((!opts.stdout && (changed > 0))) {
+    console.log();
+    console.log(green((("✓ " + changed) + " file(s) formatted")));
+  }
+}
+function cmdLint(filePaths, opts) {
+  let hasErrors = false;
+  for (const filePath of filePaths) {
+    const abs = Path.resolve(filePath);
+    if (!Fs.existsSync(abs)) {
+      console.error(red(("✗ Not found: " + filePath)));
+      continue;
+    }
+    const source = Fs.readFileSync(abs, "utf8");
+    const result = lint(source);
+    const name = Path.relative(process.cwd(), abs);
+    if (((result.errors.length == 0) && (result.warnings.length == 0))) {
+      console.log(((green("✓ ") + cyan(name)) + gray("  —  clean")));
+    }
+    else {
+      for (const e of result.errors) {
+        console.error((((red("  error ") + cyan(((name + ":") + (e.line ?? "?")))) + "  ") + e.message));
+        hasErrors = true;
+      }
+      for (const w of result.warnings) {
+        console.warn((((yellow("  warn  ") + cyan(((name + ":") + (w.line ?? "?")))) + "  ") + w.message));
+      }
+    }
+  }
+  if (hasErrors) {
+    process.exit(1);
+  }
+}
+function cmdBundle(entryPath, opts) {
+  const abs = Path.resolve(entryPath);
+  if (!Fs.existsSync(abs)) {
+    console.error(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(red("\n✗ Bundle failed:\n"));
+    for (const e of result.errors) {
+      console.error(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((((((green("✓ Bundle done") + gray(((" (" + elapsed) + "ms) "))) + Path.basename(abs)) + gray(((" + " + (result.modules - 1)) + " module(s) → "))) + cyan(Path.relative(process.cwd(), outFile))) + gray(((" [" + kb) + " KB]"))));
+}
+function cmdWatch(filePath, opts) {
+  const abs = Path.resolve(filePath);
+  if (!Fs.existsSync(abs)) {
+    console.error(red(("✗ File not found: " + filePath)));
+    process.exit(1);
+  }
+  console.log(((cyan("◉ Watching ") + Path.relative(process.cwd(), abs)) + gray(" (Ctrl+C to stop)\n")));
+  cmdCompile(filePath, opts);
+  let timer = null;
+  function onDebounce() {
+    console.log((gray((("\n" + new Date().toLocaleTimeString()) + " — ")) + blue("change detected")));
+    cmdCompile(filePath, opts);
+  }
+  function onChange() {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(onDebounce, 80);
+  }
+  Fs.watch(abs, onChange);
+}
+function cmdTokens(filePath, opts) {
+  const { source } = readFluxFile(filePath);
+  const { Lexer } = require(Path.join(__dirname, "lexer.js"));
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  console.log(gray((("Tokens (" + tokens.length) + "):\n")));
+  for (const tok of tokens) {
+    const loc = (tok.line ? gray((((" " + tok.line) + ":") + (tok.col ?? 1))) : "");
+    const val_ = ((tok.value != null) ? cyan(("  " + JSON.stringify(tok.value))) : "");
+    console.log(((("  " + yellow(tok.type.padEnd(16))) + val_) + loc));
+  }
+}
+function cmdAst(filePath, opts) {
+  const { source } = readFluxFile(filePath);
+  const result = transpile(source, {  });
+  if (!result.success) {
+    printErrors(result.errors, source, filePath);
+    process.exit(1);
+  }
+  console.log(JSON.stringify(result.ast, null, 2));
+}
+function cmdRepl(opts) {
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true, prompt: (cyan("flux") + gray("> ")) });
+  console.log();
+  console.log((bold("Flux Lang Interactive REPL") + gray((((("  v" + VERSION) + "  [") + STAGE) + "]"))));
+  console.log(gray("Type Flux code to compile and run it. Ctrl+C or .exit to quit.\n"));
+  rl.prompt();
+  let multiLine = "";
+  let inBlock = false;
+  function onLine(rawLine) {
+    const line = rawLine;
+    if (((line.trim() == ".exit") || (line.trim() == ".quit"))) {
+      console.log(gray("\nBye!"));
+      process.exit(0);
+    }
+    if ((line.trim() == ".help")) {
+      console.log(gray("  .exit  — quit"));
+      console.log(gray("  .clear — clear screen"));
+      console.log(gray("  .help  — this message"));
+      rl.prompt();
+      return;
+    }
+    if ((line.trim() == ".clear")) {
+      console.clear();
+      rl.prompt();
+      return;
+    }
+    const needsContinue = (line.trimEnd().endsWith(":") || inBlock);
+    if ((needsContinue && (line.trim() != ""))) {
+      multiLine = ((multiLine + line) + "\n");
+      inBlock = true;
+      process.stdout.write(gray("... "));
+      return;
+    }
+    const src = (inBlock ? multiLine : line);
+    multiLine = "";
+    inBlock = false;
+    if (!src.trim()) {
+      rl.prompt();
+      return;
+    }
+    try {
+      const result = transpile(src, { check: false });
+      if (result.success) {
+        const tmpPath = Path.join(Os.tmpdir(), (("_flux_repl_" + Date.now()) + ".js"));
+        Fs.writeFileSync(tmpPath, result.output, "utf8");
+        try {
+          const out = require(tmpPath);
+          if ((out != undefined)) {
+            console.log((green("← ") + JSON.stringify(out)));
+          }
+        }
+        catch (e) {
+          console.error((red("Runtime: ") + e.message));
+        }
+        finally {
+          try {
+            Fs.unlinkSync(tmpPath);
+          }
+          catch (e2) {
+            null;
+          }
+        }
+      }
+      else {
+        for (const e of result.errors) {
+          console.error((red("✗ ") + e.message));
+        }
+      }
+    }
+    catch (e3) {
+      console.error((red("Error: ") + e3.message));
+    }
+    rl.prompt();
+  }
+  function onClose() {
+    console.log(gray("\nBye!"));
+    process.exit(0);
+  }
+  rl.on("line", onLine);
+  rl.on("close", onClose);
+}
+function cmdInit(name, opts) {
+  const projectName = (name ?? "my-flux-app");
+  const dir = Path.resolve(projectName);
+  if (Fs.existsSync(dir)) {
+    console.error(red(("✗ Directory already exists: " + projectName)));
+    process.exit(1);
+  }
+  Fs.mkdirSync(dir, { recursive: true });
+  Fs.mkdirSync(Path.join(dir, "src"), { recursive: true });
+  Fs.mkdirSync(Path.join(dir, "tests"), { recursive: true });
+  const mainFlux = "// {projectName} — written in Flux Lang v{VERSION}\n\ntype Shape =\n  | Circle(radius: Float)\n  | Rect(width: Float, height: Float)\n  | Triangle(base: Float, height: Float)\n\nfn area(shape: Shape) -> Float:\n  match shape:\n    when Circle(r):              return Math.PI * r * r\n    when Rect(w, h):             return w * h\n    when Triangle(b, h):         return 0.5 * b * h\n\nfn greet(name: String) -> String:\n  return \"Hello from Flux, {name}!\"\n\nval shapes = [\n  Circle(5.0),\n  Rect(10.0, 4.0),\n  Triangle(6.0, 8.0),\n]\n\nfor shape in shapes:\n  val a = area(shape)\n  print(\"Area: {a:.2f}\")\n\nprint(greet(\"{projectName}\"))";
+  const testFlux = "// {projectName} tests\n\nfn add(a: Int, b: Int) -> Int: return a + b\nfn mul(a: Int, b: Int) -> Int: return a * b\n\ntest \"add works\":\n  assert add(1, 2) == 3\n  assert add(0, 0) == 0\n  assert add(-1, 1) == 0\n\ntest \"mul works\":\n  assert mul(3, 4) == 12\n  assert mul(0, 5) == 0";
+  const fluxJson = { name: projectName, version: "1.0.0", description: "A Flux Lang project", author: "", license: "MIT", entry: "src/main.flux", outDir: "dist", sourcemap: false, typecheck: true, 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", test: "flux test tests/", fmt: "flux fmt src/", lint: "flux lint src/" }, dependencies: {  }, devDependencies: {  } };
+  const gitignore = "node_modules/\ndist/\nflux_modules/\n*.js.map\n.DS_Store";
+  const readme = "# {projectName}\n\nA project built with [Flux Lang](https://flux-lang.dev) v{VERSION}.\n\n## Getting Started\n\n```bash\nflux run src/main.flux\n```\n\n## Commands\n\n| Command | Description |\n|---|---|\n| `flux run src/main.flux` | Run main file |\n| `flux build` | Bundle to dist/ |\n| `flux watch src/main.flux` | Watch mode |\n| `flux check src/main.flux` | Type check |\n| `flux test tests/` | Run tests |\n| `flux fmt src/` | Format code |";
+  Fs.writeFileSync(Path.join(dir, "src", "main.flux"), mainFlux, "utf8");
+  Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
+  Fs.writeFileSync(Path.join(dir, "flux.json"), (JSON.stringify(fluxJson, null, 2) + "\n"), "utf8");
+  Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
+  Fs.writeFileSync(Path.join(dir, "README.md"), readme, "utf8");
+  console.log();
+  console.log((green("✓ Created: ") + bold((projectName + "/"))));
+  console.log();
+  console.log(gray("  Files:"));
+  console.log(("  " + cyan((projectName + "/src/main.flux"))));
+  console.log(("  " + cyan((projectName + "/tests/main.test.flux"))));
+  console.log(("  " + cyan((projectName + "/flux.json"))));
+  console.log(("  " + cyan((projectName + "/.gitignore"))));
+  console.log(("  " + cyan((projectName + "/README.md"))));
+  console.log();
+  console.log(bold("  Next steps:"));
+  console.log(("    " + yellow(("cd " + projectName))));
+  console.log(("    " + yellow("flux run src/main.flux")));
+  console.log();
+}
+function cmdSelfHosted(sub, opts) {
+  const SELF = Path.join(__dirname, ".");
+  const coreModules = ["css-preprocessor", "checker", "type-checker", "jsx", "lexer", "parser", "codegen", "transpiler"];
+  const extModules = ["formatter", "sourcemap", "stdlib", "mangler", "linter", "bundler", "test-runner"];
+  const newModules = ["config", "pkg", "cli"];
+  const allModules = [...coreModules, ...extModules, ...newModules];
+  if ((sub == "build")) {
+    const { execSync } = require("child_process");
+    const BIN = Path.join(__dirname, "../../bin/flux.js");
+    console.log();
+    console.log(bold("⚡ Flux Bootstrap — Stage 0"));
+    console.log(gray("  Compiling self-hosted sources with stage-0 compiler...\n"));
+    let ok = 0;
+    let failed = 0;
+    for (const name of allModules) {
+      const src = Path.join(SELF, (name + ".flux"));
+      const out = Path.join(SELF, (name + ".js"));
+      if (!Fs.existsSync(src)) {
+        console.log(gray((("  ○ " + name) + ".flux  (skipped — not found)")));
+        continue;
+      }
+      try {
+        const cmd = "node \"${BIN}\" compile \"${src}\" -o \"${out}\" --no-mangle";
+        execSync(cmd, { cwd: Path.join(__dirname, "../.."), stdio: "pipe" });
+        console.log((((green("  ✓ ") + name) + ".flux → ") + gray((name + ".js"))));
+        ok = (ok + 1);
+      }
+      catch (e) {
+        console.error((((red("  ✗ ") + name) + ".flux — ") + e.message.split("\n")[0]));
+        failed = (failed + 1);
+      }
+    }
+    console.log();
+    if ((failed == 0)) {
+      console.log((green("✓ Bootstrap complete! ") + gray((ok + " modules compiled"))));
+      console.log();
+      console.log("  Activate self-hosted mode:");
+      console.log(("    " + yellow("FLUX_SELF_HOSTED=1 flux <command>")));
+    }
+    else {
+      console.log(red((((("✗ " + failed) + " module(s) failed, ") + ok) + " succeeded")));
+    }
+    console.log();
+    return;
+  }
+  if ((sub == "verify")) {
+    console.log(cyan("\n  Verifying self-hosted compiler output...\n"));
+    try {
+      const selfMod = require(Path.join(SELF, "transpiler.js"));
+      const stage0Mod = require(Path.join(__dirname, "../transpiler.js"));
+      const testSrc = "fn greet(name): return \"Hello, {name}!\"\nval msg = greet(\"Flux\")";
+      const r0 = stage0Mod.transpile(testSrc, {  });
+      const r1 = selfMod.transpile(testSrc, {  });
+      function norm(s) {
+        return s.replace(/\/\/.*/g, "").replace(/\s+/g, " ").trim();
+      }
+      if ((norm(r0.output) == norm(r1.output))) {
+        console.log(green("✓ Self-hosted output matches stage-0!"));
+        console.log(green("✓ Flux is fully self-hosting."));
+      }
+      else {
+        console.log(yellow("⚠  Outputs differ (minor differences are OK)"));
+        console.log((gray("  Stage-0:    ") + r0.output.split("\n")[0]));
+        console.log((gray("  Self-hosted:") + r1.output.split("\n")[0]));
+      }
+    }
+    catch (e) {
+      console.error(red(("✗ Verify failed: " + e.message)));
+    }
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(bold("  Flux Self-Hosted Compiler Status\n"));
+  const selfActive = (process.env.FLUX_SELF_HOSTED == "1");
+  if (selfActive) {
+    console.log((("  Mode:    " + green("● ACTIVE")) + gray("  (using self-hosted compiler)")));
+  }
+  else {
+    console.log(((("  Mode:    " + gray("○ INACTIVE")) + "  ") + gray("(using stage-0 compiler)")));
+    console.log(("  Toggle:  " + yellow("FLUX_SELF_HOSTED=1 flux <command>")));
+    console.log(("  Build:   " + yellow("flux self-hosted build")));
+  }
+  console.log();
+  console.log(bold((("  Core Pipeline (" + coreModules.length) + " modules)")));
+  for (const name of coreModules) {
+    const jsPath = Path.join(SELF, (name + ".js"));
+    const flxPath = Path.join(SELF, (name + ".flux"));
+    const hasJs = Fs.existsSync(jsPath);
+    const hasFlx = Fs.existsSync(flxPath);
+    const kb = (hasJs ? (Fs.statSync(jsPath).size / 1024).toFixed(1) : "?");
+    const sym = (hasJs ? green("✓") : red("✗"));
+    const note = (!hasFlx ? gray("  (no .flux source)") : "");
+    console.log(((((("    " + sym) + " ") + (name + ".flux").padEnd(26)) + gray((kb + " KB"))) + note));
+  }
+  console.log();
+  console.log(bold((("  Extended Toolchain (" + extModules.length) + " modules)")));
+  for (const name of extModules) {
+    const jsPath = Path.join(SELF, (name + ".js"));
+    const flxPath = Path.join(SELF, (name + ".flux"));
+    const hasJs = Fs.existsSync(jsPath);
+    const hasFlx = Fs.existsSync(flxPath);
+    const kb = (hasJs ? (Fs.statSync(jsPath).size / 1024).toFixed(1) : "?");
+    const sym = (hasJs ? green("✓") : red("✗"));
+    const note = (!hasFlx ? gray("  (no .flux source)") : "");
+    console.log(((((("    " + sym) + " ") + (name + ".flux").padEnd(26)) + gray((kb + " KB"))) + note));
+  }
+  console.log();
+  console.log(bold((("  Ecosystem (" + newModules.length) + " modules)")));
+  for (const name of newModules) {
+    const jsPath = Path.join(SELF, (name + ".js"));
+    const flxPath = Path.join(SELF, (name + ".flux"));
+    const hasJs = Fs.existsSync(jsPath);
+    const hasFlx = Fs.existsSync(flxPath);
+    const kb = (hasJs ? (Fs.statSync(jsPath).size / 1024).toFixed(1) : "?");
+    const sym = (hasJs ? green("✓") : yellow("○"));
+    console.log((((("    " + sym) + " ") + (name + ".flux").padEnd(26)) + (hasJs ? gray((kb + " KB")) : yellow("not built"))));
+  }
+  console.log();
+}
+function cmdVersion(opts) {
+  if (noColor) {
+    console.log(("flux-lang v" + VERSION));
+    return;
+  }
+  console.log((cyan(bold("⚡ Flux Lang")) + gray(((((" v" + VERSION) + "  [") + STAGE) + "]"))));
+}
+function main() {
+  const { positional, opts } = parseArgs(process.argv);
+  const cmd = (positional[0] ?? "help");
+  if (cmd === "compile") {
+    return cmdCompile(positional[1], opts);
+  }
+  else if (cmd === "run") {
+    return cmdRun(positional[1], opts);
+  }
+  else if (cmd === "check") {
+    return cmdCheck(positional.slice(1), opts);
+  }
+  else if (cmd === "fmt") {
+    return cmdFmt(positional.slice(1), opts);
+  }
+  else if (cmd === "format") {
+    return cmdFmt(positional.slice(1), opts);
+  }
+  else if (cmd === "lint") {
+    return cmdLint(positional.slice(1), opts);
+  }
+  else if (cmd === "bundle") {
+    return cmdBundle(positional[1], opts);
+  }
+  else if (cmd === "watch") {
+    return cmdWatch(positional[1], opts);
+  }
+  else if (cmd === "tokens") {
+    return cmdTokens(positional[1], opts);
+  }
+  else if (cmd === "ast") {
+    return cmdAst(positional[1], opts);
+  }
+  else if (cmd === "repl") {
+    return cmdRepl(opts);
+  }
+  else if (cmd === "init") {
+    return cmdInit(positional[1], opts);
+  }
+  else if (cmd === "add") {
+    return cmdAdd(positional.slice(1), opts);
+  }
+  else if (cmd === "remove") {
+    return cmdRemove(positional.slice(1), opts);
+  }
+  else if (cmd === "rm") {
+    return cmdRemove(positional.slice(1), opts);
+  }
+  else if (cmd === "install") {
+    return cmdInstall(opts);
+  }
+  else if (cmd === "i") {
+    return cmdInstall(opts);
+  }
+  else if (cmd === "list") {
+    return cmdList(opts);
+  }
+  else if (cmd === "ls") {
+    return cmdList(opts);
+  }
+  else if (cmd === "search") {
+    return cmdSearch(positional[1], opts);
+  }
+  else if (cmd === "info") {
+    return cmdInfo(positional[1], opts);
+  }
+  else if (cmd === "publish") {
+    return cmdPublish(opts);
+  }
+  else if (cmd === "self-hosted") {
+    return cmdSelfHosted(positional[1], opts);
+  }
+  else if (cmd === "version") {
+    return cmdVersion(opts);
+  }
+  else if (cmd === "-v") {
+    return cmdVersion(opts);
+  }
+  else if (cmd === "--version") {
+    return cmdVersion(opts);
+  }
+  else if (cmd === "help") {
+    return showHelp();
+  }
+  else if (cmd === "--help") {
+    return showHelp();
+  }
+  else if (cmd === "-h") {
+    return showHelp();
+  }
+  else {
+    console.error(red(("✗ Unknown command: " + cmd)));
+    console.error(gray("  Run: flux help"));
+    process.exit(1);
+  }
+}
+main();