@xnoxs/flux-lang 3.4.8 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "3.4.8",
+  "version": "3.5.0",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "dist/flux.cjs.js",
   "module": "dist/flux.esm.js",

package/src/self/bundler.js

@@ -8,6 +8,8 @@ function includes(arr, val) { return arr.includes(val); }
 
 function trim(s) { return String(s).trim(); }
 
+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); }
@@ -120,10 +122,8 @@ class Bundler {
       lines.push("\"use strict\";");
       lines.push("");
     }
-    // flux_modules resolver: patches Module._resolveFilename so require() looks in
-    // flux_modules/node_modules/ first (packages installed via `flux install`).
     lines.push("// flux_modules resolver");
-    lines.push("(function(){var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('node:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();");
+    lines.push(`(function()${var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('node:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();`);
     lines.push("");
     lines.push("(function() {");
     lines.push("");

package/src/self/cli.js

@@ -57,7 +57,7 @@ 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 C = { reset: "\\u001b[0m", bold: "\\u001b[1m", dim: "\\u001b[2m", red: "\\u001b[31m", green: "\\u001b[32m", yellow: "\\u001b[33m", blue: "\\u001b[34m", cyan: "\\u001b[36m", white: "\\u001b[37m", gray: "\\u001b[90m", magenta: "\\u001b[35m" };
 const noColor = (process.env.NO_COLOR || !process.stdout.isTTY);
 function clr(c, s) {
   return (noColor ? s : ((c + s) + C.reset));

package/src/self/pkg.flux

@@ -36,11 +36,33 @@ val C = {
   gray:   "\u001b[90m",
 }
 
-fn clr(c, s): return c + s + C.reset
+val hasColor = process.env.COLORTERM or process.env.FORCE_COLOR or (process.stdout.isTTY and process.env.TERM != "dumb")
+val noColor  = process.env.NO_COLOR or not hasColor
+
+fn clr(c, s): return noColor ? s : c + s + C.reset
 fn ok(msg):   console.log(clr(C.green, "✓ ") + msg)
 fn err(msg):  console.error(clr(C.red, "✗ ") + msg)
 fn info(msg): console.log(clr(C.cyan, "  ") + msg)
 
+// ── Spinner animation ─────────────────────────────────────────
+fn createSpinner(msg):
+  if noColor:
+    process.stdout.write("  " + msg + " ...\n")
+    fn _stop(ok_, done):
+      process.stdout.write("  " + (ok_ ? "✓" : "✗") + " " + done + "\n")
+    return { stop: _stop }
+  val frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+  var fi = 0
+  fn tick():
+    process.stdout.write("\r  " + clr(C.cyan, frames[fi % frames.length]) + " " + msg + "   ")
+    fi = fi + 1
+  val timer = setInterval(tick, 80)
+  fn stop(ok_, done):
+    clearInterval(timer)
+    val icon = ok_ ? clr(C.green, "✓") : clr(C.red, "✗")
+    process.stdout.write("\r  " + icon + " " + done + "                              \n")
+  return { stop: stop }
+
 // ── HTTP fetch (Node built-in, no dependencies) ───────────────
 async fn fetchJson(url):
   val mod = url.startsWith("https") ? Https : Http
@@ -100,10 +122,12 @@ export async fn cmdAdd(specs, opts):
   val isDev = opts?.dev ?? false
   val cwd   = process.cwd()
   val pkg   = ensureFluxJson(cwd)
+  var addedCount = 0
 
+  console.log()
   for spec in specs:
     val { name, version } = parsePackageSpec(spec)
-    console.log(clr(C.cyan, "\n  Adding ") + clr(C.bold, name) + clr(C.gray, "@" + version) + " ...")
+    val spinner = createSpinner(clr(C.bold, name) + clr(C.gray, "@" + version))
 
     try:
       val info_ = await fetchJson(REGISTRY_URL + "/" + name)
@@ -111,25 +135,25 @@ export async fn cmdAdd(specs, opts):
 
       val versionInfo = info_.versions?.[resolvedVersion]
       if not versionInfo:
-        err("Version " + resolvedVersion + " not found for " + name)
+        spinner.stop(false, clr(C.bold, name) + clr(C.gray, "@" + resolvedVersion) + " — version not found")
         continue
 
       val depKey = isDev ? "devDependencies" : "dependencies"
       if not pkg[depKey]: pkg[depKey] = {}
       pkg[depKey][name] = "^" + resolvedVersion
-
       saveFluxJson(pkg, cwd)
 
-      val desc = versionInfo.description ? clr(C.gray, " — " + versionInfo.description) : ""
-      ok(name + clr(C.green, "@" + resolvedVersion) + desc)
-      info("Added to " + (isDev ? "devDependencies" : "dependencies"))
+      val shortDesc = versionInfo.description ? clr(C.gray, " — " + versionInfo.description.slice(0, 55)) : ""
+      spinner.stop(true, clr(C.bold, name) + clr(C.green, "@" + resolvedVersion) + shortDesc)
+      addedCount = addedCount + 1
 
     catch(e):
-      err("Failed to fetch " + name + ": " + e.message)
+      spinner.stop(false, clr(C.bold, name) + " — " + e.message)
 
   console.log()
-  console.log(clr(C.gray, "  Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install packages"))
-  console.log()
+  if addedCount > 0:
+    console.log("  " + clr(C.gray, "Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install packages"))
+    console.log()
 
 // ── flux remove <pkg> ─────────────────────────────────────────
 export fn cmdRemove(names, opts):
@@ -169,15 +193,19 @@ export async fn cmdInstall(opts):
   val names   = Object.keys(all)
 
   if names.length == 0:
+    console.log()
     info("No dependencies found in flux.json")
+    console.log()
     return
 
-  console.log(clr(C.cyan, "\n  Installing ") + names.length + " package(s) into flux_modules/...\n")
-
+  console.log()
+  console.log("  " + clr(C.bold, pkg.name ?? "project") + clr(C.gray, " — " + names.length + " package(s)"))
+  console.log()
   for name in names:
     val spec = all[name]
-    console.log(clr(C.gray, "  ○ ") + name + clr(C.gray, "@" + spec))
-
+    val isDev_ = Object.prototype.hasOwnProperty.call(devDeps, name)
+    val tag = isDev_ ? clr(C.gray, " dev") : ""
+    console.log("  " + clr(C.gray, "○") + " " + clr(isDev_ ? C.blue : C.green, name) + clr(C.gray, "@" + spec) + tag)
   console.log()
 
   // Ensure flux_modules/ exists with a minimal package.json
@@ -191,27 +219,26 @@ export async fn cmdInstall(opts):
 
   val prodNames = Object.keys(deps)
   val devNames  = Object.keys(devDeps)
+  val spinner   = createSpinner("Installing packages into flux_modules/")
 
   try:
     if prodNames.length > 0:
       val prodPkgs   = prodNames.map(n -> n + "@" + (deps[n] ?? "latest")).join(" ")
       val installCmd = "npm install --prefix " + fluxModDir + " " + prodPkgs
-      info("Running: " + installCmd)
-      execSync(installCmd, { cwd: cwd, stdio: "inherit" })
+      execSync(installCmd, { cwd: cwd, stdio: "pipe" })
 
     if devNames.length > 0:
       val devPkgs = devNames.map(n -> n + "@" + (devDeps[n] ?? "latest")).join(" ")
       val devCmd  = "npm install --prefix " + fluxModDir + " --save-dev " + devPkgs
-      info("Running: " + devCmd)
-      execSync(devCmd, { cwd: cwd, stdio: "inherit" })
+      execSync(devCmd, { cwd: cwd, stdio: "pipe" })
 
+    spinner.stop(true, names.length + " package(s) installed into " + clr(C.gray, "flux_modules/"))
     console.log()
-    ok(names.length + " package(s) installed into flux_modules/node_modules/")
-    info("Packages resolve automatically when using: flux run, flux bundle")
+    console.log("  " + clr(C.gray, "Packages resolve automatically when using: ") + clr(C.yellow, "flux run") + clr(C.gray, ", ") + clr(C.yellow, "flux bundle"))
   catch(e):
+    spinner.stop(false, "Install failed: " + e.message)
     console.log()
-    err("Install failed: " + e.message)
-    info("Try manually: npm install --prefix ./flux_modules <package>")
+    console.log("  " + clr(C.gray, "Try: ") + clr(C.yellow, "npm install --prefix ./flux_modules <package>"))
 
   console.log()
 
@@ -249,58 +276,138 @@ export fn cmdList(opts):
 
 // ── flux search <query> ───────────────────────────────────────
 export async fn cmdSearch(query, opts):
-  console.log(clr(C.cyan, "\n  Searching for ") + clr(C.bold, '"' + query + '"') + " ...\n")
+  console.log()
+  val spinner = createSpinner("Searching for " + clr(C.bold, '"' + query + '"'))
   try:
-    val url     = REGISTRY_URL + "/-/v1/search?text=" + encodeURIComponent(query + " keywords:flux") + "&size=10"
+    val url     = REGISTRY_URL + "/-/v1/search?text=" + encodeURIComponent(query) + "&size=10"
     val results = await fetchJson(url)
     val objects = results.objects ?? []
 
     if objects.length == 0:
-      info("No packages found for: " + query)
+      spinner.stop(false, "No packages found for: " + query)
       console.log()
       return
 
+    spinner.stop(true, "Found " + objects.length + " result(s) for " + clr(C.bold, '"' + query + '"'))
+    console.log()
+
     for obj in objects:
       val p = obj.package
       console.log("  " + clr(C.bold, p.name) + clr(C.gray, " v" + p.version))
       if p.description:
         console.log("  " + clr(C.gray, p.description))
-      console.log("  " + clr(C.blue, p.links?.npm ?? ""))
+      if p.links?.npm:
+        console.log("  " + clr(C.blue, p.links.npm))
       console.log()
 
   catch(e):
-    err("Search failed: " + e.message)
+    spinner.stop(false, "Search failed: " + e.message)
+    console.log()
 
 // ── flux info <pkg> ───────────────────────────────────────────
 export async fn cmdInfo(name, opts):
-  console.log(clr(C.cyan, "\n  Fetching info for ") + clr(C.bold, name) + " ...\n")
+  console.log()
+  val spinner = createSpinner("Fetching info for " + clr(C.bold, name))
   try:
     val info_ = await fetchJson(REGISTRY_URL + "/" + name)
     val latest = info_["dist-tags"]?.latest ?? "unknown"
     val ver    = info_.versions?.[latest] ?? {}
 
-    console.log(clr(C.bold, "  " + name) + clr(C.gray, " v" + latest))
-    if ver.description: console.log("  " + ver.description)
+    spinner.stop(true, clr(C.bold, name) + clr(C.green, "@" + latest))
     console.log()
-    console.log(clr(C.gray, "  license: ") + (ver.license ?? "unknown"))
-    console.log(clr(C.gray, "  author:  ") + (ver.author?.name ?? ver.author ?? "unknown"))
+    if ver.description: console.log("  " + clr(C.gray, ver.description))
+    console.log()
+    console.log("  " + clr(C.gray, "license:") + " " + (ver.license ?? "unknown"))
+    console.log("  " + clr(C.gray, "author: ") + " " + (ver.author?.name ?? ver.author ?? "unknown"))
 
     val homepage = ver.homepage ?? info_.homepage
-    if homepage: console.log(clr(C.gray, "  home:    ") + clr(C.blue, homepage))
+    if homepage: console.log("  " + clr(C.gray, "home:   ") + " " + clr(C.blue, homepage))
 
     val repo = ver.repository?.url ?? info_.repository?.url
-    if repo: console.log(clr(C.gray, "  repo:    ") + clr(C.blue, repo.replace("git+", "").replace(".git", "")))
+    if repo: console.log("  " + clr(C.gray, "repo:   ") + " " + clr(C.blue, repo.replace("git+", "").replace(".git", "")))
 
     val keywords = ver.keywords ?? []
     if keywords.length > 0:
-      console.log(clr(C.gray, "  tags:    ") + keywords.slice(0, 8).join(", "))
+      console.log("  " + clr(C.gray, "tags:   ") + " " + keywords.slice(0, 8).join(", "))
 
     console.log()
-    console.log(clr(C.gray, "  Install: ") + clr(C.yellow, "flux add " + name))
+    console.log("  " + clr(C.gray, "Install: ") + clr(C.yellow, "flux add " + name))
     console.log()
 
   catch(e):
-    err("Could not fetch info for " + name + ": " + e.message)
+    spinner.stop(false, "Could not fetch info for " + name + ": " + e.message)
+    console.log()
+
+// ── flux upgrade [--check] ────────────────────────────────────
+export async fn cmdUpgrade(opts):
+  val isCheck = opts?.check ?? false
+  val cwd     = process.cwd()
+  val pkg     = ensureFluxJson(cwd)
+
+  val deps    = pkg.dependencies ?? {}
+  val devDeps = pkg.devDependencies ?? {}
+  val allKeys = [...Object.keys(deps), ...Object.keys(devDeps)]
+
+  if allKeys.length == 0:
+    console.log()
+    info("No dependencies to upgrade")
+    console.log()
+    return
+
+  console.log()
+  var updated = 0
+
+  for name in Object.keys(deps):
+    val spinner = createSpinner(clr(C.green, name))
+    try:
+      val info_   = await fetchJson(REGISTRY_URL + "/" + name)
+      val latest  = info_["dist-tags"]?.latest ?? null
+      if not latest:
+        spinner.stop(false, clr(C.green, name) + " — could not resolve latest version")
+        continue
+      val current = deps[name].replace("^", "").replace("~", "")
+      if latest == current:
+        spinner.stop(true, clr(C.green, name) + clr(C.gray, "@" + current + " — up to date"))
+      else:
+        spinner.stop(true, clr(C.green, name) + clr(C.gray, "@" + current) + " → " + clr(C.yellow, latest))
+        if not isCheck:
+          pkg.dependencies[name] = "^" + latest
+          updated = updated + 1
+    catch(e):
+      spinner.stop(false, clr(C.green, name) + " — " + e.message)
+
+  for name in Object.keys(devDeps):
+    val spinner = createSpinner(clr(C.blue, name) + clr(C.gray, " (dev)"))
+    try:
+      val info_   = await fetchJson(REGISTRY_URL + "/" + name)
+      val latest  = info_["dist-tags"]?.latest ?? null
+      if not latest:
+        spinner.stop(false, clr(C.blue, name) + " — could not resolve latest version")
+        continue
+      val current = devDeps[name].replace("^", "").replace("~", "")
+      if latest == current:
+        spinner.stop(true, clr(C.blue, name) + clr(C.gray, "@" + current + " — up to date"))
+      else:
+        spinner.stop(true, clr(C.blue, name) + clr(C.gray, "@" + current) + " → " + clr(C.yellow, latest) + clr(C.gray, " (dev)"))
+        if not isCheck:
+          pkg.devDependencies[name] = "^" + latest
+          updated = updated + 1
+    catch(e):
+      spinner.stop(false, clr(C.blue, name) + " — " + e.message)
+
+  console.log()
+
+  if isCheck:
+    ok("Check complete — run " + clr(C.yellow, "flux upgrade") + " to apply upgrades")
+  else:
+    if updated > 0:
+      saveFluxJson(pkg, cwd)
+      ok(updated + " package(s) updated in flux.json")
+      console.log("  " + clr(C.gray, "Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install upgraded packages"))
+    else:
+      ok("All packages are already up to date")
+
+  console.log()
 
 // ── flux publish ──────────────────────────────────────────────
 export fn cmdPublish(opts):