@xnoxs/flux-lang 4.0.8 → 4.1.1

package/src/self/cli.js

@@ -1,10 +1,10 @@
-/* compiled from src/self/cli.flux */
-'use strict';
 // ── Flux stdlib ──
 
-function forEach(arr, fn) { arr.forEach(fn); return arr; }
+function map(arr, fn) { return arr.map(fn); }
 
-function find(arr, fn) { return arr.find(fn); }
+function filter(arr, fn) { return arr.filter(fn); }
+
+function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }
 
 function some(arr, fn) { return arr.some(fn); }
 
@@ -14,6 +14,10 @@ function clamp(val, min, max) {
   return Math.min(Math.max(val, min), max);
 }
 
+function sum(arr) {
+  return arr.reduce(function(a, b) { return a + b; }, 0);
+}
+
 function max(arr) {
   if (arguments.length > 1) return Math.max.apply(null, arguments);
   return Math.max.apply(null, arr);
@@ -92,20 +96,32 @@ function showHelp() {
   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 multi-file project into one .js"], ["run     <file.flux>", "Compile and run a single-file script"], ["watch   <file.flux>", "Watch for changes, auto-compile"], ["check   <file.flux>", "Type-check and static analysis"]];
-  compilerCmds.forEach((pair) => console.log(((("  " + green(("flux " + pair[0]).padEnd(36))) + " ") + gray(pair[1]))));
+  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)"]];
-  toolCmds.forEach((pair) => console.log(((("  " + green(("flux " + pair[0]).padEnd(36))) + " ") + gray(pair[1]))));
+  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] [--template]", "Scaffold a new Flux project"], ["add     <pkg[@version]>", "Add a dependency (npm install --save)"], ["remove  <pkg>", "Remove a dependency (npm uninstall)"], ["install", "Install all dependencies (npm install)"], ["list", "List installed packages"], ["search  <query>", "Search the npm registry"], ["info    <pkg>", "Show package details"], ["publish", "Publish package to npm registry"]];
-  pkgCmds.forEach((pair) => console.log(((("  " + cyan(("flux " + pair[0]).padEnd(36))) + " ") + gray(pair[1]))));
+  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"]];
-  selfCmds.forEach((pair) => console.log(((("  " + yellow(("flux " + pair[0]).padEnd(36))) + " ") + gray(pair[1]))));
+  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"));
@@ -115,12 +131,11 @@ function showHelp() {
   console.log((("  " + yellow("--typecheck       ")) + "  Enable type checking"));
   console.log((("  " + yellow("--stdout          ")) + "  Print to terminal"));
   console.log((("  " + yellow("--no-color        ")) + "  Disable colors"));
-  console.log((("  " + yellow("--template        ")) + "  Init template: script, server, webapp"));
   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", template: null };
+  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)) {
@@ -160,10 +175,6 @@ function parseArgs(argv) {
       i = (i + 1);
       opts.jsxTarget = args[i];
     }
-    else if (((a == "--template") || (a == "-t"))) {
-      i = (i + 1);
-      opts.template = args[i];
-    }
     else if (!a.startsWith("--")) {
       positional.push(a);
     }
@@ -232,21 +243,6 @@ function printErrors(errors, source, filePath) {
   }
   console.error();
 }
-function findFluxImports(source) {
-  const found = [];
-  const lines = source.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const m = trimmed.match(/^import\s+.+\s+from\s+["'](\.[^"']+)["']/);
-    if (m) {
-      const src = m[1];
-      if (((!src.endsWith(".js") && !src.endsWith(".json")) && !src.endsWith(".node"))) {
-        found.push(src);
-      }
-    }
-  }
-  return found;
-}
 function cmdCompile(filePath, opts) {
   const { source, abs } = readFluxFile(filePath);
   const cfg = loadConfig(Path.dirname(abs));
@@ -280,21 +276,6 @@ function cmdCompile(filePath, opts) {
 }
 function cmdRun(filePath, opts) {
   const { source, abs } = readFluxFile(filePath);
-  const fluxImports = findFluxImports(source);
-  if ((fluxImports.length > 0)) {
-    const example = fluxImports[0];
-    const entryRel = Path.relative(process.cwd(), abs);
-    const outFile = (Path.basename(abs, ".flux") + ".js");
-    console.error(red("\n✗ Cannot run a multi-file Flux project with `flux run`.\n"));
-    console.error(("  Found: " + yellow((("import ... from \"" + example) + "\""))));
-    console.error();
-    console.error((("  Use " + cyan("flux bundle")) + " to compile all files into one, then run it:\n"));
-    console.error(("    " + yellow(((("flux bundle " + entryRel) + " -o dist/") + outFile))));
-    console.error(("    " + yellow(("node dist/" + outFile))));
-    console.error();
-    console.error((("  Or use " + cyan("flux run")) + " only for single-file scripts (no inter-file .flux imports).\n"));
-    process.exit(1);
-  }
   const result = transpile(source, { jsx: (opts.jsx ?? false), jsxTarget: (opts.jsxTarget ?? "browser"), mangle: false });
   if (!result.success) {
     console.error(red("\n✗ Compile error"));
@@ -462,10 +443,6 @@ function cmdBundle(entryPath, opts) {
     console.log(result.code);
     return;
   }
-  const outDir = Path.dirname(Path.resolve(outFile));
-  if (!Fs.existsSync(outDir)) {
-    Fs.mkdirSync(outDir, { recursive: true });
-  }
   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]"))));
@@ -596,7 +573,6 @@ function cmdRepl(opts) {
 }
 function cmdInit(name, opts) {
   const projectName = (name ?? "my-flux-app");
-  const template = (opts.template ?? "script");
   const dir = Path.resolve(projectName);
   if (Fs.existsSync(dir)) {
     console.error(red(("✗ Directory already exists: " + projectName)));
@@ -605,77 +581,38 @@ function cmdInit(name, opts) {
   Fs.mkdirSync(dir, { recursive: true });
   Fs.mkdirSync(Path.join(dir, "src"), { recursive: true });
   Fs.mkdirSync(Path.join(dir, "tests"), { recursive: true });
-  const gitignore = "node_modules/\ndist/\n*.js.map\n.DS_Store\n";
-  const testFlux = "// Tests for {projectName}\n// Run: flux test tests/\n\nfn add(a, b):\n    return a + b\n\nfn clamp(value, lo, hi):\n    if value < lo: return lo\n    if value > hi: return hi\n    return value\n\nfn test_add():\n    assert(add(1, 2) == 3, \"1+2=3\")\n    assert(add(0, 0) == 0, \"0+0=0\")\n    assert(add(-1, 1) == 0, \"-1+1=0\")\n\nfn test_clamp():\n    assert(clamp(5, 0, 10) == 5, \"within range\")\n    assert(clamp(-1, 0, 10) == 0, \"below min\")\n    assert(clamp(15, 0, 10) == 10, \"above max\")";
-  if ((template == "script")) {
-    const mainFlux = "// {projectName} — a Flux script\n// Run: npm run dev  (or: node_modules/.bin/flux run src/main.flux)\n\nimport Fs   from \"fs\"\nimport Path from \"path\"\n\nfn main():\n    print(\"Hello from Flux!\")\n    print(\"Node version: {process.version}\")\n\nmain()";
-    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux project", main: "dist/main.js", scripts: { dev: "flux run src/main.flux", build: "flux bundle src/main.flux -o dist/main.js", start: "node dist/main.js", test: "flux test tests/" }, flux: { entry: "src/main.flux", outDir: "dist", mangle: false, sourcemap: false }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION) }, devDependencies: {  } };
-    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, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
-    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
-    console.log();
-    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("script")));
-    console.log();
-    console.log(bold("  Next steps:"));
-    console.log(("    " + yellow(("cd " + projectName))));
-    console.log(("    " + yellow("npm install")));
-    console.log(("    " + yellow("npm run dev")));
-    console.log();
-    console.log(gray("  Add packages:"));
-    console.log(("    " + yellow("flux add <package>")));
-    console.log();
-    return;
-  }
-  if ((template == "server")) {
-    const serverFlux = "// {projectName} — Flux HTTP server\n// Run:   npm run dev\n// Build: npm run build && npm start\n\nimport Express from \"express\"\n\nval app  = Express()\nval PORT = process.env.PORT or 3000\n\napp.use(Express.json())\n\napp.get(\"/\", (req, res) ->\n    res.json({ status: \"ok\", message: \"Hello from Flux!\", port: PORT })\n)\n\napp.listen(PORT, -> print(\"Server running at http://localhost:{PORT}\"))";
-    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux HTTP server", main: "dist/server.js", scripts: { dev: "flux run src/server.flux", build: "flux bundle src/server.flux -o dist/server.js", start: "node dist/server.js", test: "flux test tests/" }, flux: { entry: "src/server.flux", outDir: "dist", mangle: false, sourcemap: false }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION), express: "^4.18.0" }, devDependencies: {  } };
-    Fs.writeFileSync(Path.join(dir, "src", "server.flux"), serverFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
-    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
-    console.log();
-    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("server")));
-    console.log();
-    console.log(bold("  Next steps:"));
-    console.log(("    " + yellow(("cd " + projectName))));
-    console.log(("    " + yellow("npm install")));
-    console.log(("    " + yellow("npm run dev")));
-    console.log();
-    console.log(gray("  Build for production:"));
-    console.log(("    " + yellow("npm run build && npm start")));
-    console.log();
-    return;
-  }
-  if ((template == "webapp")) {
-    const utilsFlux = "// Utility functions\nexport fn formatDate(date):\n    val d = new Date(date)\n    return d.toISOString().split(\"T\")[0]\n\nexport fn paginate(items, page, perPage):\n    val start = (page - 1) * perPage\n    return items.slice(start, start + perPage)";
-    const routesFlux = "// Route handlers\nimport { formatDate, paginate } from \"./utils\"    // inter-file .flux import\n\nval items = [\n    { id: 1, name: \"Item A\", date: \"2024-01-01\" },\n    { id: 2, name: \"Item B\", date: \"2024-02-01\" },\n    { id: 3, name: \"Item C\", date: \"2024-03-01\" },\n]\n\nexport fn setupRoutes(app):\n    app.get(\"/items\", (req, res) ->\n        val page    = parseInt(req.query.page or \"1\")\n        val perPage = parseInt(req.query.per_page or \"10\")\n        val data    = paginate(items, page, perPage)\n        res.json({ data, page })\n    )\n\n    app.get(\"/items/:id\", (req, res) ->\n        val item = items.find(i -> i.id == parseInt(req.params.id))\n        if item == null:\n            res.status(404).json({ error: \"Not found\" })\n        else:\n            res.json({ data: item, date: formatDate(item.date) })\n    )";
-    const serverFlux = "// Entry point — MUST be compiled with: npm run build\n// Inter-file .flux imports only work via flux bundle, NOT flux run\nimport Express         from \"express\"\nimport { setupRoutes } from \"./routes\"    // inter-file .flux import\n\nval app  = Express()\nval PORT = process.env.PORT or 3000\n\napp.use(Express.json())\nsetupRoutes(app)\n\napp.listen(PORT, -> print(\"{projectName} running at http://localhost:{PORT}\"))";
-    const pkgJson = { name: projectName, version: "1.0.0", description: "A Flux web app", main: "dist/server.js", scripts: { build: "flux bundle src/server.flux -o dist/server.js", start: "node dist/server.js", dev: "flux bundle src/server.flux -o dist/server.js && node dist/server.js", watch: "flux watch src/server.flux", test: "flux test tests/" }, flux: { entry: "src/server.flux", outDir: "dist", mangle: false, sourcemap: true }, dependencies: { "@xnoxs/flux-lang": ("^" + VERSION), express: "^4.18.0" }, devDependencies: {  } };
-    Fs.writeFileSync(Path.join(dir, "src", "utils.flux"), utilsFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "src", "routes.flux"), routesFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "src", "server.flux"), serverFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "tests", "main.test.flux"), testFlux, "utf8");
-    Fs.writeFileSync(Path.join(dir, "package.json"), (JSON.stringify(pkgJson, null, 2) + "\n"), "utf8");
-    Fs.writeFileSync(Path.join(dir, ".gitignore"), gitignore, "utf8");
-    console.log();
-    console.log((((green("✓ Project ") + bold((projectName + "/"))) + green(" created with template ")) + cyan("webapp")));
-    console.log();
-    console.log(bold("  Next steps:"));
-    console.log(("    " + yellow(("cd " + projectName))));
-    console.log((("    " + yellow("npm install")) + gray("              # install dependencies")));
-    console.log((("    " + yellow("npm run build")) + gray("            # compile all .flux → dist/server.js")));
-    console.log((("    " + yellow("npm start")) + gray("                # run the server")));
-    console.log();
-    console.log((yellow("  Note: ") + gray("This project uses multiple .flux files.")));
-    console.log(((gray("  Always build with ") + yellow("npm run build")) + gray(" (flux bundle) before running.")));
-    console.log(((gray("  Do NOT use ") + red("flux run")) + gray(" on files that import other .flux files.")));
-    console.log();
-    return;
+  const mainFlux = "// {projectName} — built with Flux Lang v{VERSION}\n// Run: flux run src/main.flux\n\n// ── Algebraic Data Types + Pattern Matching ───────────────────\ntype Shape = Circle(radius) | Rect(width, height) | Triangle(base, height)\n\nfn area(shape):\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 describe(shape):\n  match shape:\n    when Circle(r):      return \"Circle(r={r:.2f})\"\n    when Rect(w, h):     return \"Rect({w:.1f}x{h:.1f})\"\n    when Triangle(b, h): return \"Triangle(b={b:.1f}, h={h:.1f})\"\n\n// ── Result type ───────────────────────────────────────────────\ntype Result = Ok(value) | Err(message)\n\nfn safeDivide(a, b):\n  if b == 0: return Err(\"division by zero\")\n  return Ok(a / b)\n\n// ── Utility functions ─────────────────────────────────────────\nfn greet(name): return \"Hello from Flux, {name}!\"\n\nfn formatList(items):\n  if items.length == 0: return \"(empty)\"\n  return \"[\" + items.join(\", \") + \"]\"\n\nfn clamp(value, lo, hi):\n  if value < lo: return lo\n  if value > hi: return hi\n  return value\n\n// ── Pipe operator + stdlib ────────────────────────────────────\nval numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\nval processed = numbers\n  |> filter(n -> n > 3)\n  |> map(n -> n * n)\n  |> sort\n\n// ── Main ──────────────────────────────────────────────────────\nprint(greet(\"{projectName}\"))\nprint(\"Squares > 3: {formatList(processed)}\")\nprint(\"clamp(12, 0, 10) = {clamp(12, 0, 10)}\")\n\nval shapes = [Circle(5.0), Rect(8.0, 3.0), Triangle(6.0, 4.0)]\nfor shape in shapes:\n  val a = area(shape)\n  print(\"{describe(shape)}  area={a:.2f}\")\n\nmatch safeDivide(10.0, 3.0):\n  when Ok(v):  print(\"10 / 3 = {v:.4f}\")\n  when Err(e): print(\"Error: {e}\")";
+  const utilsFlux = "// Utility functions for {projectName}\n// Use with: flux bundle src/main.flux (bundles imports automatically)\n\nexport fn greet(name):\n  return \"Hello from Flux, {name}!\"\n\nexport fn formatList(items):\n  if items.length == 0: return \"(empty)\"\n  return \"[\" + items.join(\", \") + \"]\"\n\nexport fn clamp(value, lo, hi):\n  if value < lo: return lo\n  if value > hi: return hi\n  return value\n\nexport fn sum(nums):\n  return nums.reduce((acc, x) -> acc + x, 0)\n\nexport fn average(nums):\n  if nums.length == 0: return 0\n  return sum(nums) / nums.length";
+  const testFlux = "// Tests for {projectName}\n// Run: flux test tests/\n\n// ── Functions under test ──────────────────────────────────────\nfn add(a, b):\n    return a + b\n\nfn mul(a, b):\n    return a * b\n\nfn clamp(value, lo, hi):\n    if value < lo: return lo\n    if value > hi: return hi\n    return value\n\nfn average(nums):\n    if nums.length == 0: return 0\n    return nums.reduce((s, x) -> s + x, 0) / nums.length\n\ntype Result = Ok(value) | Err(message)\n\nfn safeDivide(a, b):\n    if b == 0: return Err(\"div by zero\")\n    return Ok(a / b)\n\n// ── Test functions ────────────────────────────────────────────\nfn test_add():\n    assert(add(1, 2) == 3, \"1+2=3\")\n    assert(add(0, 0) == 0, \"0+0=0\")\n    assert(add(-1, 1) == 0, \"-1+1=0\")\n\nfn test_mul():\n    assert(mul(3, 4) == 12, \"3*4=12\")\n    assert(mul(0, 5) == 0, \"0*5=0\")\n\nfn test_clamp():\n    assert(clamp(5, 0, 10) == 5, \"within range\")\n    assert(clamp(-1, 0, 10) == 0, \"below min\")\n    assert(clamp(15, 0, 10) == 10, \"above max\")\n\nfn test_average():\n    assert(average([2, 4, 6]) == 4, \"average of 2,4,6\")\n    assert(average([]) == 0, \"empty list\")\n\nfn test_safe_divide():\n    val ok = safeDivide(10, 2)\n    match ok:\n        when Ok(v):  assert(v == 5, \"10/2=5\")\n        when Err(e): assert(false, \"unexpected error\")\n    val err = safeDivide(10, 0)\n    match err:\n        when Ok(v):  assert(false, \"expected error\")\n        when Err(e): assert(e == \"div by zero\", \"error message\")\n\nfn test_pipe_operator():\n    val result = [1, 2, 3, 4, 5] |> filter(n -> n > 2) |> map(n -> n * 2)\n    assert(result.length == 3, \"filter length\")\n    assert(result[0] == 6, \"first element\")\n    assert(result[2] == 10, \"last element\")";
+  const fluxJson = { name: projectName, version: "1.0.0", description: (("A Flux Lang v" + VERSION) + " 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: { "@xnoxs/flux-lang": ("^" + VERSION) } };
+  const gitignore = "node_modules/\ndist/\nflux_modules/\n*.js.map\n.DS_Store\n";
+  const readme = "# {projectName}\n\nA project built with [Flux Lang](https://flux-lang.dev) v{VERSION} — the self-hosted compiler.\n\n## Quick Start\n\n```bash\nflux run src/main.flux\n```\n\n## Project Structure\n\n```\n{projectName}/\n├── src/\n│   ├── main.flux        # Entry point\n│   └── utils.flux       # Utility functions\n├── tests/\n│   └── main.test.flux   # Test suite\n├── flux_modules/        # Packages installed by `flux install` (gitignored)\n├── flux.json            # Project config & dependencies\n└── README.md\n```\n\n## Commands\n\n| Command | Description |\n|---|---|\n| `flux run src/main.flux` | Run the project |\n| `flux bundle src/main.flux -o dist/bundle.js` | Bundle to single file |\n| `flux watch src/main.flux` | Watch mode |\n| `flux check src/main.flux` | Type check + static analysis |\n| `flux test tests/` | Run all tests |\n| `flux fmt src/` | Format source code |\n| `flux lint src/` | Lint for issues |\n| `flux add <package>` | Add a dependency |";
+  const allFiles = [(projectName + "/src/main.flux"), (projectName + "/src/utils.flux"), (projectName + "/tests/main.test.flux"), (projectName + "/flux.json"), (projectName + "/.gitignore"), (projectName + "/README.md")];
+  Fs.writeFileSync(Path.join(dir, "src", "main.flux"), mainFlux, "utf8");
+  Fs.writeFileSync(Path.join(dir, "src", "utils.flux"), utilsFlux, "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:"));
+  for (const f of allFiles) {
+    console.log(("  " + cyan(f)));
   }
-  console.error(red(("✗ Unknown template: " + template)));
-  console.error(gray("  Available templates: script, server, webapp"));
-  process.exit(1);
+  console.log();
+  console.log(bold("  Next steps:"));
+  console.log(("    " + yellow(("cd " + projectName))));
+  console.log(("    " + yellow("flux run src/main.flux")));
+  console.log();
+  console.log(gray("  Add packages (installed into flux_modules/):"));
+  console.log(("    " + yellow("flux add <package>")));
+  console.log(("    " + yellow("flux install")));
+  console.log();
+  console.log(gray("  Or run the test suite:"));
+  console.log(("    " + yellow("flux test tests/")));
+  console.log();
 }
 function cmdSelfHosted(sub, opts) {
   const SELF = Path.join(__dirname, ".");
@@ -840,9 +777,6 @@ function main() {
   else if (cmd === "repl") {
     return cmdRepl(opts);
   }
-  else if (cmd === "test") {
-    return runTests((positional[1] ?? "tests/"), (src) => transpile(src, {  }));
-  }
   else if (cmd === "init") {
     return cmdInit(positional[1], opts);
   }

package/src/self/config.flux

@@ -2,11 +2,10 @@
 //  Flux Self-Hosted Config Reader
 //  src/self/config.flux — written in Flux, compiled by stage-0
 //
-//  Reads config from package.json ("flux" key) or flux.json fallback.
-//  Config file resolution order:
-//    1. package.json → { "flux": { ... } }   ← primary
-//    2. flux.json                              ← legacy fallback
-//    3. default config                         ← if none found
+//  Reads flux.json project config and merges with CLI flags.
+//  Config file locations (searched in order):
+//    ./flux.json
+//    ./flux.config.js
 // ============================================================
 
 import Fs   from "fs"
@@ -25,7 +24,7 @@ export val DEFAULT_CONFIG = {
   watch:      false,
   ignore:     [],
   selfHosted: false,
-  registry:   "https://registry.npmjs.org",
+  registry:   "https://registry.flux-lang.dev",
   pkg: {
     name:        "",
     version:     "1.0.0",
@@ -37,22 +36,11 @@ export val DEFAULT_CONFIG = {
   }
 }
 
-// ── Load config (package.json "flux" key first, flux.json fallback) ──
+// ── Load flux.json ────────────────────────────────────────────
 export fn loadConfig(cwd_):
   val cwd = cwd_ ?? process.cwd()
 
-  // 1. Try package.json → "flux" key (primary)
-  val pkgJsonPath = Path.join(cwd, "package.json")
-  if Fs.existsSync(pkgJsonPath):
-    try:
-      val raw    = Fs.readFileSync(pkgJsonPath, "utf8")
-      val parsed = JSON.parse(raw)
-      if parsed.flux and typeof parsed.flux == "object":
-        return mergeConfig(DEFAULT_CONFIG, parsed.flux)
-    catch(e):
-      throw new Error("Invalid package.json: " + e.message)
-
-  // 2. Try flux.json (legacy fallback)
+  // Try flux.json first
   val jsonPath = Path.join(cwd, "flux.json")
   if Fs.existsSync(jsonPath):
     try:
@@ -62,7 +50,15 @@ export fn loadConfig(cwd_):
     catch(e):
       throw new Error("Invalid flux.json: " + e.message)
 
-  // 3. Default config
+  // Try flux.config.js
+  val jsPath = Path.join(cwd, "flux.config.js")
+  if Fs.existsSync(jsPath):
+    try:
+      val loaded = require(jsPath)
+      return mergeConfig(DEFAULT_CONFIG, loaded)
+    catch(e2):
+      throw new Error("Invalid flux.config.js: " + e2.message)
+
   return { ...DEFAULT_CONFIG }
 
 // ── Deep merge config objects ─────────────────────────────────
@@ -75,16 +71,12 @@ export fn mergeConfig(base, overrides):
       result[key] = val_
   return result
 
-// ── Write flux key into package.json ─────────────────────────
+// ── Write flux.json ───────────────────────────────────────────
 export fn writeConfig(config, cwd_):
-  val cwd      = cwd_ ?? process.cwd()
-  val pkgPath  = Path.join(cwd, "package.json")
-  var pkg      = {}
-  if Fs.existsSync(pkgPath):
-    try: pkg = JSON.parse(Fs.readFileSync(pkgPath, "utf8"))
-    catch(e): pkg = {}
-  pkg.flux = config
-  Fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8")
+  val cwd = cwd_ ?? process.cwd()
+  val jsonPath = Path.join(cwd, "flux.json")
+  val content = JSON.stringify(config, null, 2) + "\n"
+  Fs.writeFileSync(jsonPath, content, "utf8")
 
 // ── Validate config ───────────────────────────────────────────
 export fn validateConfig(config):
@@ -101,20 +93,20 @@ export fn validateConfig(config):
     errors: errors,
   }
 
-// ── Read package info (package.json first, flux.json fallback) ────
+// ── Read flux.json package info ───────────────────────────────
 export fn readPackage(cwd_):
-  val cwd     = cwd_ ?? process.cwd()
-  val pkgJson = Path.join(cwd, "package.json")
+  val cwd = cwd_ ?? process.cwd()
   val fluxJson = Path.join(cwd, "flux.json")
+  val pkgJson  = Path.join(cwd, "package.json")
 
-  if Fs.existsSync(pkgJson):
+  if Fs.existsSync(fluxJson):
     try:
-      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"))
+      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"))
     catch(e): return null
 
-  if Fs.existsSync(fluxJson):
+  if Fs.existsSync(pkgJson):
     try:
-      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"))
+      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"))
     catch(e2): return null
 
   return null

package/src/self/config.js

@@ -1,27 +1,23 @@
-/* compiled from src/self/config.flux */
-'use strict';
-// Generated by Flux Transpiler v3.5.3 (self-hosted)
+// ── Flux stdlib ──
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function includes(arr, val) { return arr.includes(val); }
+
+function keys(obj) { return Object.keys(obj); }
+
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.2.0
 "use strict";
 
 const Fs = require("fs");
 const Path = require("path");
-const DEFAULT_CONFIG = { entry: "src/main.flux", outDir: "dist", sourcemap: false, mangle: false, jsx: false, jsxTarget: "browser", typecheck: true, strict: false, watch: false, ignore: [], selfHosted: false, registry: "https://registry.npmjs.org", pkg: { name: "", version: "1.0.0", description: "", author: "", license: "MIT", deps: {  }, devDeps: {  } } };
+const DEFAULT_CONFIG = { entry: "src/main.flux", outDir: "dist", sourcemap: false, mangle: false, jsx: false, jsxTarget: "browser", typecheck: true, strict: false, watch: false, ignore: [], selfHosted: false, registry: "https://registry.flux-lang.dev", pkg: { name: "", version: "1.0.0", description: "", author: "", license: "MIT", deps: {  }, devDeps: {  } } };
 module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 function loadConfig(cwd_) {
   const cwd = (cwd_ ?? process.cwd());
-  const pkgJsonPath = Path.join(cwd, "package.json");
-  if (Fs.existsSync(pkgJsonPath)) {
-    try {
-      const raw = Fs.readFileSync(pkgJsonPath, "utf8");
-      const parsed = JSON.parse(raw);
-      if ((parsed.flux && (typeof parsed.flux == "object"))) {
-        return mergeConfig(DEFAULT_CONFIG, parsed.flux);
-      }
-    }
-    catch (e) {
-      throw new Error(("Invalid package.json: " + e.message));
-    }
-  }
   const jsonPath = Path.join(cwd, "flux.json");
   if (Fs.existsSync(jsonPath)) {
     try {
@@ -33,6 +29,16 @@ function loadConfig(cwd_) {
       throw new Error(("Invalid flux.json: " + e.message));
     }
   }
+  const jsPath = Path.join(cwd, "flux.config.js");
+  if (Fs.existsSync(jsPath)) {
+    try {
+      const loaded = require(jsPath);
+      return mergeConfig(DEFAULT_CONFIG, loaded);
+    }
+    catch (e2) {
+      throw new Error(("Invalid flux.config.js: " + e2.message));
+    }
+  }
   return { ...DEFAULT_CONFIG };
 }
 module.exports.loadConfig = loadConfig;
@@ -52,18 +58,9 @@ function mergeConfig(base, overrides) {
 module.exports.mergeConfig = mergeConfig;
 function writeConfig(config, cwd_) {
   const cwd = (cwd_ ?? process.cwd());
-  const pkgPath = Path.join(cwd, "package.json");
-  let pkg = {  };
-  if (Fs.existsSync(pkgPath)) {
-    try {
-      pkg = JSON.parse(Fs.readFileSync(pkgPath, "utf8"));
-    }
-    catch (e) {
-      pkg = {  };
-    }
-  }
-  pkg.flux = config;
-  Fs.writeFileSync(pkgPath, (JSON.stringify(pkg, null, 2) + "\n"), "utf8");
+  const jsonPath = Path.join(cwd, "flux.json");
+  const content = (JSON.stringify(config, null, 2) + "\n");
+  Fs.writeFileSync(jsonPath, content, "utf8");
 }
 module.exports.writeConfig = writeConfig;
 function validateConfig(config) {
@@ -79,19 +76,19 @@ function validateConfig(config) {
 module.exports.validateConfig = validateConfig;
 function readPackage(cwd_) {
   const cwd = (cwd_ ?? process.cwd());
-  const pkgJson = Path.join(cwd, "package.json");
   const fluxJson = Path.join(cwd, "flux.json");
-  if (Fs.existsSync(pkgJson)) {
+  const pkgJson = Path.join(cwd, "package.json");
+  if (Fs.existsSync(fluxJson)) {
     try {
-      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"));
+      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"));
     }
     catch (e) {
       return null;
     }
   }
-  if (Fs.existsSync(fluxJson)) {
+  if (Fs.existsSync(pkgJson)) {
     try {
-      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"));
+      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"));
     }
     catch (e2) {
       return null;