@xnoxs/flux-lang 4.0.3 → 4.0.5

package/src/self/cli.flux

@@ -73,13 +73,14 @@ fn showHelp():
   console.log(bold("COMPILER:"))
   val compilerCmds = [
     ["compile <file.flux>",            "Compile .flux → .js"],
-    ["bundle  <entry.flux>",           "Bundle multiple files into one .js"],
-    ["run     <file.flux>",            "Compile and run immediately"],
+    ["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"],
   ]
-  for [cmd, desc] in compilerCmds:
-    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc))
+  compilerCmds.forEach(pair ->
+    console.log("  " + green(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
+  )
 
   console.log()
   console.log(bold("TOOLING:"))
@@ -91,23 +92,25 @@ fn showHelp():
     ["tokens  <file.flux>",            "Show lexer token list"],
     ["ast     <file.flux>",            "Show Abstract Syntax Tree (JSON)"],
   ]
-  for [cmd, desc] in toolCmds:
-    console.log("  " + green(("flux " + cmd).padEnd(36)) + " " + gray(desc))
+  toolCmds.forEach(pair ->
+    console.log("  " + green(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
+  )
 
   console.log()
   console.log(bold("PACKAGE MANAGER:"))
   val pkgCmds = [
-    ["init    [name]",                 "Scaffold a new Flux project"],
-    ["add     <pkg[@version]>",        "Add a dependency"],
-    ["remove  <pkg>",                  "Remove a dependency"],
-    ["install",                        "Install all dependencies"],
+    ["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 package registry"],
+    ["search  <query>",                "Search the npm registry"],
     ["info    <pkg>",                  "Show package details"],
-    ["publish",                        "Publish package to registry"],
+    ["publish",                        "Publish package to npm registry"],
   ]
-  for [cmd, desc] in pkgCmds:
-    console.log("  " + cyan(("flux " + cmd).padEnd(36)) + " " + gray(desc))
+  pkgCmds.forEach(pair ->
+    console.log("  " + cyan(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
+  )
 
   console.log()
   console.log(bold("SELF-HOSTED:"))
@@ -116,8 +119,9 @@ fn showHelp():
     ["self-hosted build",              "Bootstrap: compile compiler with itself"],
     ["self-hosted verify",             "Verify self-hosted output matches stage-0"],
   ]
-  for [cmd, desc] in selfCmds:
-    console.log("  " + yellow(("flux " + cmd).padEnd(36)) + " " + gray(desc))
+  selfCmds.forEach(pair ->
+    console.log("  " + yellow(("flux " + pair[0]).padEnd(36)) + " " + gray(pair[1]))
+  )
 
   console.log()
   console.log(bold("OPTIONS:"))
@@ -128,6 +132,7 @@ 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 ────────────────────────────────────────────
@@ -145,6 +150,7 @@ fn parseArgs(argv):
     verbose:   false,
     jsx:       false,
     jsxTarget: "browser",
+    template:  null,
   }
   val positional = []
   var i = 0
@@ -174,6 +180,9 @@ 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
@@ -236,6 +245,22 @@ 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
 // ══════════════════════════════════════════════════════════════
@@ -290,6 +315,23 @@ 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",
@@ -446,6 +488,11 @@ 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(
@@ -578,7 +625,8 @@ fn cmdRepl(opts):
 // ── flux init ────────────────────────────────────────────────
 fn cmdInit(name, opts):
   val projectName = name ?? "my-flux-app"
-  val dir = Path.resolve(projectName)
+  val template    = opts.template ?? "script"
+  val dir         = Path.resolve(projectName)
 
   if Fs.existsSync(dir):
     console.error(red("✗ Directory already exists: " + projectName))
@@ -588,246 +636,251 @@ fn cmdInit(name, opts):
   Fs.mkdirSync(Path.join(dir, "src"), { recursive: true })
   Fs.mkdirSync(Path.join(dir, "tests"), { recursive: true })
 
-  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 gitignore = "node_modules/\ndist/\n*.js.map\n.DS_Store\n"
 
   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 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")
+fn main():
+    print("Hello from Flux!")
+    print("Node version: {process.version}")
+
+main()
 `
 
-  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 },
-  }
+    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
 
-  val gitignore = "node_modules/\ndist/\nflux_modules/\n*.js.map\n.DS_Store\n"
+  // ── 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 readme = `# {projectName}
+import Express from "express"
 
-A project built with [Flux Lang](https://flux-lang.dev) v{VERSION} — the self-hosted compiler.
+val app  = Express()
+val PORT = process.env.PORT or 3000
 
-## Quick Start
+app.use(Express.json())
 
-\`\`\`bash
-flux run src/main.flux
-\`\`\`
+app.get("/", (req, res) ->
+    res.json({ status: "ok", message: "Hello from Flux!", port: PORT })
+)
 
-## Project Structure
+app.listen(PORT, -> print("Server running at http://localhost:{PORT}"))
+`
+
+    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")
 
-\`\`\`
-{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
-\`\`\`
+    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
 
-## Commands
+  // ── 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]
 
-| 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 |
+export fn paginate(items, page, perPage):
+    val start = (page - 1) * perPage
+    return items.slice(start, start + perPage)
 `
 
-  val allFiles = [
-    projectName + "/src/main.flux",
-    projectName + "/src/utils.flux",
-    projectName + "/tests/main.test.flux",
-    projectName + "/flux.json",
-    projectName + "/.gitignore",
-    projectName + "/README.md",
-  ]
+    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 })
+    )
 
-  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")
+    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) })
+    )
+`
 
-  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()
+    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 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
+
+  // Unknown template
+  console.error(red("✗ Unknown template: " + template))
+  console.error(gray("  Available templates: script, server, webapp"))
+  process.exit(1)
 
 // ── flux self-hosted ──────────────────────────────────────────
 fn cmdSelfHosted(sub, opts):
@@ -975,6 +1028,7 @@ fn main():
     when "tokens":    cmdTokens(positional[1], opts)
     when "ast":       cmdAst(positional[1], opts)
     when "repl":      cmdRepl(opts)
+    when "test":      runTests(positional.slice(1), opts)
     when "init":      cmdInit(positional[1], opts)
     when "add":       cmdAdd(positional.slice(1), opts)
     when "remove":    cmdRemove(positional.slice(1), opts)