@xnoxs/flux-lang 4.0.8 → 4.0.9

package/src/self/checker.js

@@ -1,3 +1,5 @@
+/* compiled from src/self/checker.flux by Flux Lang */
+'use strict';
 // Generated by Flux Transpiler v3.2.0
 "use strict";
 

package/src/self/cli.flux

@@ -73,14 +73,13 @@ fn showHelp():
   console.log(bold("COMPILER:"))
   val 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"],
+    ["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"],
   ]
-  compilerCmds.forEach(pair ->
-    console.log("  " + green(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
-  )
+  for [cmd, desc] in compilerCmds:
+    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc))
 
   console.log()
   console.log(bold("TOOLING:"))
@@ -92,25 +91,23 @@ fn showHelp():
     ["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 [cmd, desc] in toolCmds:
+    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc))
 
   console.log()
   console.log(bold("PACKAGE MANAGER:"))
   val 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)"],
+    ["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 npm registry"],
+    ["search  <query>",                "Search the package registry"],
     ["info    <pkg>",                  "Show package details"],
-    ["publish",                        "Publish package to npm registry"],
+    ["publish",                        "Publish package to registry"],
   ]
-  pkgCmds.forEach(pair ->
-    console.log("  " + cyan(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
-  )
+  for [cmd, desc] in pkgCmds:
+    console.log("  " + cyan(("flux " + cmd).padEnd(36)) + " " + gray(desc))
 
   console.log()
   console.log(bold("SELF-HOSTED:"))
@@ -119,9 +116,8 @@ fn showHelp():
     ["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 [cmd, desc] in selfCmds:
+    console.log("  " + yellow(("flux " + cmd).padEnd(36)) + " " + gray(desc))
 
   console.log()
   console.log(bold("OPTIONS:"))
@@ -132,7 +128,6 @@ fn 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()
 
 // ── Parse CLI args ────────────────────────────────────────────
@@ -150,7 +145,6 @@ fn parseArgs(argv):
     verbose:   false,
     jsx:       false,
     jsxTarget: "browser",
-    template:  null,
   }
   val positional = []
   var i = 0
@@ -180,9 +174,6 @@ fn parseArgs(argv):
     else if a == "--jsx-target":
       i = i + 1
       opts.jsxTarget = args[i]
-    else if a == "--template" or a == "-t":
-      i = i + 1
-      opts.template = args[i]
     else if not a.startsWith("--"):
       positional.push(a)
     i = i + 1
@@ -245,22 +236,6 @@ fn printErrors(errors, source, filePath):
       console.error(cyan("  Hint: ") + gray(err.hint))
   console.error()
 
-// ── Detect inter-file .flux imports in source ─────────────────
-fn findFluxImports(source):
-  val found = []
-  val lines = source.split("\n")
-  for line in lines:
-    val trimmed = line.trim()
-    // Match: import ... from "./something" or import ... from "../something"
-    // where the path is relative (starts with ./ or ../)
-    val m = trimmed.match(/^import\s+.+\s+from\s+["'](\.[^"']+)["']/)
-    if m:
-      val src = m[1]
-      // Relative import to a .flux file (explicit or implicit extension)
-      if not src.endsWith(".js") and not src.endsWith(".json") and not src.endsWith(".node"):
-        found.push(src)
-  return found
-
 // ══════════════════════════════════════════════════════════════
 //  Commands
 // ══════════════════════════════════════════════════════════════
@@ -315,23 +290,6 @@ fn cmdCompile(filePath, opts):
 // ── flux run ──────────────────────────────────────────────────
 fn cmdRun(filePath, opts):
   val { source, abs } = readFluxFile(filePath)
-
-  // Detect inter-file .flux imports — flux run cannot handle them
-  val fluxImports = findFluxImports(source)
-  if fluxImports.length > 0:
-    val example = fluxImports[0]
-    val entryRel = Path.relative(process.cwd(), abs)
-    val 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)
-
   val result = transpile(source, {
     jsx:       opts.jsx       ?? false,
     jsxTarget: opts.jsxTarget ?? "browser",
@@ -488,11 +446,6 @@ fn cmdBundle(entryPath, opts):
     console.log(result.code)
     return
 
-  // Ensure output directory exists
-  val outDir = Path.dirname(Path.resolve(outFile))
-  if not Fs.existsSync(outDir):
-    Fs.mkdirSync(outDir, { recursive: true })
-
   Fs.writeFileSync(outFile, result.code, "utf8")
   val kb = (result.code.length / 1024).toFixed(1)
   console.log(
@@ -625,8 +578,7 @@ fn cmdRepl(opts):
 // ── flux init ────────────────────────────────────────────────
 fn cmdInit(name, opts):
   val projectName = name ?? "my-flux-app"
-  val template    = opts.template ?? "script"
-  val dir         = Path.resolve(projectName)
+  val dir = Path.resolve(projectName)
 
   if Fs.existsSync(dir):
     console.error(red("✗ Directory already exists: " + projectName))
@@ -636,251 +588,246 @@ fn cmdInit(name, opts):
   Fs.mkdirSync(Path.join(dir, "src"), { recursive: true })
   Fs.mkdirSync(Path.join(dir, "tests"), { recursive: true })
 
-  val gitignore = "node_modules/\ndist/\n*.js.map\n.DS_Store\n"
+  val mainFlux = `// {projectName} — built with Flux Lang v{VERSION}
+// Run: flux run src/main.flux
+
+// ── Algebraic Data Types + Pattern Matching ───────────────────
+type Shape = Circle(radius) | Rect(width, height) | Triangle(base, height)
+
+fn area(shape):
+  match shape:
+    when Circle(r):      return Math.PI * r * r
+    when Rect(w, h):     return w * h
+    when Triangle(b, h): return 0.5 * b * h
+
+fn describe(shape):
+  match shape:
+    when Circle(r):      return "Circle(r={r:.2f})"
+    when Rect(w, h):     return "Rect({w:.1f}x{h:.1f})"
+    when Triangle(b, h): return "Triangle(b={b:.1f}, h={h:.1f})"
+
+// ── Result type ───────────────────────────────────────────────
+type Result = Ok(value) | Err(message)
+
+fn safeDivide(a, b):
+  if b == 0: return Err("division by zero")
+  return Ok(a / b)
+
+// ── Utility functions ─────────────────────────────────────────
+fn greet(name): return "Hello from Flux, {name}!"
+
+fn formatList(items):
+  if items.length == 0: return "(empty)"
+  return "[" + items.join(", ") + "]"
+
+fn clamp(value, lo, hi):
+  if value < lo: return lo
+  if value > hi: return hi
+  return value
+
+// ── Pipe operator + stdlib ────────────────────────────────────
+val numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
+val processed = numbers
+  |> filter(n -> n > 3)
+  |> map(n -> n * n)
+  |> sort
+
+// ── Main ──────────────────────────────────────────────────────
+print(greet("{projectName}"))
+print("Squares > 3: {formatList(processed)}")
+print("clamp(12, 0, 10) = {clamp(12, 0, 10)}")
+
+val shapes = [Circle(5.0), Rect(8.0, 3.0), Triangle(6.0, 4.0)]
+for shape in shapes:
+  val a = area(shape)
+  print("{describe(shape)}  area={a:.2f}")
+
+match safeDivide(10.0, 3.0):
+  when Ok(v):  print("10 / 3 = {v:.4f}")
+  when Err(e): print("Error: {e}")
+`
+
+  val utilsFlux = `// Utility functions for {projectName}
+// Use with: flux bundle src/main.flux (bundles imports automatically)
+
+export fn greet(name):
+  return "Hello from Flux, {name}!"
+
+export fn formatList(items):
+  if items.length == 0: return "(empty)"
+  return "[" + items.join(", ") + "]"
+
+export fn clamp(value, lo, hi):
+  if value < lo: return lo
+  if value > hi: return hi
+  return value
+
+export fn sum(nums):
+  return nums.reduce((acc, x) -> acc + x, 0)
+
+export fn average(nums):
+  if nums.length == 0: return 0
+  return sum(nums) / nums.length
+`
 
   val testFlux = `// Tests for {projectName}
 // Run: flux test tests/
 
+// ── Functions under test ──────────────────────────────────────
 fn add(a, b):
     return a + b
 
+fn mul(a, b):
+    return a * b
+
 fn clamp(value, lo, hi):
     if value < lo: return lo
     if value > hi: return hi
     return value
 
+fn average(nums):
+    if nums.length == 0: return 0
+    return nums.reduce((s, x) -> s + x, 0) / nums.length
+
+type Result = Ok(value) | Err(message)
+
+fn safeDivide(a, b):
+    if b == 0: return Err("div by zero")
+    return Ok(a / b)
+
+// ── Test functions ────────────────────────────────────────────
 fn test_add():
     assert(add(1, 2) == 3, "1+2=3")
     assert(add(0, 0) == 0, "0+0=0")
     assert(add(-1, 1) == 0, "-1+1=0")
 
+fn test_mul():
+    assert(mul(3, 4) == 12, "3*4=12")
+    assert(mul(0, 5) == 0, "0*5=0")
+
 fn test_clamp():
     assert(clamp(5, 0, 10) == 5, "within range")
     assert(clamp(-1, 0, 10) == 0, "below min")
     assert(clamp(15, 0, 10) == 10, "above max")
-`
-
-  // ── Template: script (default) — single file, no inter-file imports ──
-  if template == "script":
-    val mainFlux = `// {projectName} — a Flux script
-// Run: npm run dev  (or: node_modules/.bin/flux run src/main.flux)
-
-import Fs   from "fs"
-import Path from "path"
 
-fn main():
-    print("Hello from Flux!")
-    print("Node version: {process.version}")
-
-main()
+fn test_average():
+    assert(average([2, 4, 6]) == 4, "average of 2,4,6")
+    assert(average([]) == 0, "empty list")
+
+fn test_safe_divide():
+    val ok = safeDivide(10, 2)
+    match ok:
+        when Ok(v):  assert(v == 5, "10/2=5")
+        when Err(e): assert(false, "unexpected error")
+    val err = safeDivide(10, 0)
+    match err:
+        when Ok(v):  assert(false, "expected error")
+        when Err(e): assert(e == "div by zero", "error message")
+
+fn test_pipe_operator():
+    val result = [1, 2, 3, 4, 5] |> filter(n -> n > 2) |> map(n -> n * 2)
+    assert(result.length == 3, "filter length")
+    assert(result[0] == 6, "first element")
+    assert(result[2] == 10, "last element")
 `
 
-    val 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
-
-  // ── Template: server — Express HTTP server, single file ──
-  if template == "server":
-    val serverFlux = `// {projectName} — Flux HTTP server
-// Run:   npm run dev
-// Build: npm run build && npm start
+  val 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 },
+  }
 
-import Express from "express"
+  val gitignore = "node_modules/\ndist/\nflux_modules/\n*.js.map\n.DS_Store\n"
 
-val app  = Express()
-val PORT = process.env.PORT or 3000
+  val readme = `# {projectName}
 
-app.use(Express.json())
+A project built with [Flux Lang](https://flux-lang.dev) v{VERSION} — the self-hosted compiler.
 
-app.get("/", (req, res) ->
-    res.json({ status: "ok", message: "Hello from Flux!", port: PORT })
-)
+## Quick Start
 
-app.listen(PORT, -> print("Server running at http://localhost:{PORT}"))
-`
+\`\`\`bash
+flux run src/main.flux
+\`\`\`
 
-    val 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")
+## Project Structure
 
-    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
+\`\`\`
+{projectName}/
+├── src/
+│   ├── main.flux        # Entry point
+│   └── utils.flux       # Utility functions
+├── tests/
+│   └── main.test.flux   # Test suite
+├── flux_modules/        # Packages installed by \`flux install\` (gitignored)
+├── flux.json            # Project config & dependencies
+└── README.md
+\`\`\`
 
-  // ── Template: webapp — multi-file project, uses flux bundle ──
-  if template == "webapp":
-    val utilsFlux = `// Utility functions
-export fn formatDate(date):
-    val d = new Date(date)
-    return d.toISOString().split("T")[0]
+## Commands
 
-export fn paginate(items, page, perPage):
-    val start = (page - 1) * perPage
-    return items.slice(start, start + perPage)
+| Command | Description |
+|---|---|
+| \`flux run src/main.flux\` | Run the project |
+| \`flux bundle src/main.flux -o dist/bundle.js\` | Bundle to single file |
+| \`flux watch src/main.flux\` | Watch mode |
+| \`flux check src/main.flux\` | Type check + static analysis |
+| \`flux test tests/\` | Run all tests |
+| \`flux fmt src/\` | Format source code |
+| \`flux lint src/\` | Lint for issues |
+| \`flux add <package>\` | Add a dependency |
 `
 
-    val routesFlux = `// Route handlers
-import { formatDate, paginate } from "./utils"    // inter-file .flux import
-
-val items = [
-    { id: 1, name: "Item A", date: "2024-01-01" },
-    { id: 2, name: "Item B", date: "2024-02-01" },
-    { id: 3, name: "Item C", date: "2024-03-01" },
-]
-
-export fn setupRoutes(app):
-    app.get("/items", (req, res) ->
-        val page    = parseInt(req.query.page or "1")
-        val perPage = parseInt(req.query.per_page or "10")
-        val data    = paginate(items, page, perPage)
-        res.json({ data, page })
-    )
-
-    app.get("/items/:id", (req, res) ->
-        val item = items.find(i -> i.id == parseInt(req.params.id))
-        if item == null:
-            res.status(404).json({ error: "Not found" })
-        else:
-            res.json({ data: item, date: formatDate(item.date) })
-    )
-`
-
-    val serverFlux = `// Entry point — MUST be compiled with: npm run build
-// Inter-file .flux imports only work via flux bundle, NOT flux run
-import Express         from "express"
-import { setupRoutes } from "./routes"    // inter-file .flux import
-
-val app  = Express()
-val PORT = process.env.PORT or 3000
-
-app.use(Express.json())
-setupRoutes(app)
-
-app.listen(PORT, -> print("{projectName} running at http://localhost:{PORT}"))
-`
+  val allFiles = [
+    projectName + "/src/main.flux",
+    projectName + "/src/utils.flux",
+    projectName + "/tests/main.test.flux",
+    projectName + "/flux.json",
+    projectName + "/.gitignore",
+    projectName + "/README.md",
+  ]
 
-    val 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")
+  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("✓ 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
-
-  // Unknown template
-  console.error(red("✗ Unknown template: " + template))
-  console.error(gray("  Available templates: script, server, webapp"))
-  process.exit(1)
+  console.log()
+  console.log(green("✓ Created: ") + bold(projectName + "/"))
+  console.log()
+  console.log(gray("  Files:"))
+  for f in allFiles:
+    console.log("  " + cyan(f))
+  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()
 
 // ── flux self-hosted ──────────────────────────────────────────
 fn cmdSelfHosted(sub, opts):
@@ -1028,7 +975,6 @@ fn main():
     when "tokens":    cmdTokens(positional[1], opts)
     when "ast":       cmdAst(positional[1], opts)
     when "repl":      cmdRepl(opts)
-    when "test":      runTests(positional[1] ?? 'tests/', src -> transpile(src, {}))
     when "init":      cmdInit(positional[1], opts)
     when "add":       cmdAdd(positional.slice(1), opts)
     when "remove":    cmdRemove(positional.slice(1), opts)