@vistta/cli 1.0.1

package/loaders/index.js

@@ -0,0 +1,34 @@
+import { Runtime } from "../classes/runtime.js";
+
+let runtime;
+
+export async function initialize({ loaders, resolvers, options, port }) {
+  runtime = new Runtime({ loaders, resolvers, options });
+  if (port) {
+    const shared = {};
+    const events = {};
+    global.main = {
+      send: (event, ...args) => args.port.postMessage(JSON.stringify({ event, args })),
+      on: (event, callback) => (events[event] ? events[event].push(callback) : (events[event] = [callback])),
+      shared: new Proxy(shared, {
+        set(_, prop, value) {
+          port.postMessage(JSON.stringify({ sync: true, prop, value }));
+          return Reflect.set(...arguments);
+        },
+      }),
+    };
+    port.on("message", (msg) => {
+      const { event, sync, args, prop, value } = JSON.parse(msg);
+      if (event) events[event]?.forEach((callback) => callback(...args));
+      else if (sync) shared[prop] = value;
+    });
+  }
+}
+
+export async function resolve(specifier, context, nextResolve, options) {
+  return runtime.resolve(specifier, context, nextResolve, options);
+}
+
+export async function load(url, context, nextLoad) {
+  return runtime.load(url, context, nextLoad);
+}

package/loaders/json.js

@@ -0,0 +1,11 @@
+import { Loader } from "../index.js";
+
+export default class JSONLoader extends Loader {
+  async load(source, { path }) {
+    try {
+      return { code: `export default (${JSON.stringify(JSON.parse(source))});` };
+    } catch (e) {
+      return { errors: [`${path}(0,0): json error: ${e.message}.`] };
+    }
+  }
+}

package/loaders/typescript.js

@@ -0,0 +1,29 @@
+import { transform } from "esbuild";
+import { Loader } from "../index.js";
+
+export default class TypescriptLoader extends Loader {
+  compilerOptions;
+
+  constructor(options) {
+    super(options);
+    this.compilerOptions = options.compiler || {};
+  }
+
+  async load(source) {
+    try {
+      return await transform(source, {
+        format: "esm",
+        treeShaking: true,
+        loader: "ts",
+        tsconfigRaw: {
+          compilerOptions: this.compilerOptions,
+        },
+        jsx: "preserve",
+        sourcemap: false,
+        target: "esnext",
+      });
+    } catch (e) {
+      return { errors: [e] };
+    }
+  }
+}

package/main.js

@@ -0,0 +1 @@
+process.vistta.main();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@vistta/cli",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./config": "./tsconfig.json",
+    "./commands/default": "./commands/default.js",
+    "./commands/bundle": "./commands/bundle.js",
+    "./commands/project": "./commands/project.js",
+    "./commands/test": "./commands/test.js",
+    "./loaders/bundler": "./loaders/bundler.js",
+    "./loaders/file": "./loaders/file.js",
+    "./loaders/json": "./loaders/json.js",
+    "./loaders/typescript": "./loaders/typescript.js"
+  },
+  "bin": {
+    "vistta": "bin.js"
+  },
+  "scripts": {
+    "postinstall": ""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vistta-org/cli.git"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@vistta/console": "latest",
+    "@vistta/fs": "latest",
+    "@vistta/utils": "latest",
+    "esbuild": "^0.25.5",
+    "semver": "^7.7.2"
+  },
+  "author": "Tiago Terenas Almeida",
+  "license": "Apache 2.0 with Commons Clause",
+  "description": "Vistta CLI is a framework for extending the Node.js loader API and building reusable, customizable commands tools"
+}

package/register.js

@@ -0,0 +1,51 @@
+import "@vistta/console/global";
+import { register } from "node:module";
+import { MessageChannel } from "node:worker_threads";
+import { fs, importConfig, saveCrashReport } from "./utils.js";
+
+console.clear();
+console.print(`Vistta CLI v${process.env.CLI_VERSION}\n`);
+
+const { port1, port2 } = new MessageChannel();
+const shared = {};
+const events = {};
+global.loaders = {
+  send: (event, ...args) => port1.postMessage(JSON.stringify({ event, args })),
+  on: (event, callback) => (events[event] ? events[event].push(callback) : (events[event] = [callback])),
+  shared: new Proxy(shared, {
+    set(_, prop, value) {
+      port1.postMessage(JSON.stringify({ sync: true, prop, value }));
+      return Reflect.set(...arguments);
+    },
+  }),
+};
+port1.on("message", (msg) => {
+  const { event, sync, args, prop, value } = JSON.parse(msg);
+  if (event) events[event]?.forEach((callback) => callback(...args));
+  else if (sync) shared[prop] = value;
+});
+port1.unref();
+
+const config = await importConfig({
+  cli: {
+    commands: {
+      default: fs.resolve(import.meta.dirname, "./commands/default.js"),
+      bundle: fs.resolve(import.meta.dirname, "./commands/bundle.js"),
+      project: fs.resolve(import.meta.dirname, "./commands/project.js"),
+      test: fs.resolve(import.meta.dirname, "./commands/test.js"),
+    },
+  },
+});
+const command = new (await import(config.cli.commands[process.argv[2]] || config.cli.commands["default"])).default();
+process.vistta = {
+  loaders: command.loaders,
+  resolvers: command.resolvers,
+  options: config,
+  port: port2,
+};
+register("./loaders/index.js", import.meta.url, { data: process.vistta, transferList: [port2] });
+process.vistta.main = command[process.env.NODE_HELP ? "help" : "main"].bind(command, ...process.argv.slice(2));
+process.on("uncaughtException", (error) => (console.error(error.stack), saveCrashReport(), process.exit(1)));
+process.on("warning", () => {
+  /* Do nothing */
+});

package/tests/index.test.js

@@ -0,0 +1,38 @@
+import { Command } from "../classes/command.js";
+
+suite("CLI", () => {
+  let cmd;
+  test("register adds a loader", () => {
+    cmd = new Command();
+    cmd.register("/path/to/loader.js", { type: "custom", filter: ".*\\.custom" });
+    expect(cmd.loaders.length).toEqual(1);
+    expect(cmd.loaders[0].main).toEqual("/path/to/loader.js");
+    expect(cmd.loaders[0].type).toEqual("custom");
+    expect(cmd.loaders[0].filter).toEqual(".*\\.custom");
+  });
+
+  test("resolve adds new extensions", () => {
+    cmd = new Command();
+    cmd.resolve("ts", "json");
+    expect(cmd.resolvers).toInclude("ts");
+    expect(cmd.resolvers).toInclude("json");
+  });
+
+  test("main throws error if not implemented", () => {
+    cmd = new Command();
+    expect(() => cmd.main()).toThrow("Method 'main' must be implemented.");
+  });
+
+  test("help does not throw by default", () => {
+    cmd = new Command();
+    expect(() => cmd.help()).not.toThrow();
+  });
+
+  test("define sets global and env variables", () => {
+    cmd = new Command();
+    cmd.define("global", "FOO", 123);
+    cmd.define("env", "BAR", "baz");
+    expect(global["FOO"]).toEqual(123);
+    expect(process.env["BAR"]).toEqual("baz");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "strict": false,
+    "noEmit": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "module": "esnext",
+    "target": "ESNext",
+    "esModuleInterop": true,
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "jsx": "react",
+    "typeRoots": ["./global.d.ts"],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  }
+}

package/utils.js

@@ -0,0 +1,208 @@
+import fs from "@vistta/fs";
+import { assign, async, extract, remove } from "@vistta/utils";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { inc, satisfies, valid } from "semver";
+
+export const ENABLED_NODE_OPTIONS = {
+  "-w": "NODE_WATCH",
+  "--watch": "NODE_WATCH",
+  "--node-memory-debug": true,
+  "--tls-cipher-list": true,
+  "--prof": true,
+  "--prof-process": true,
+  "--enable-source-maps": true,
+  "--trace-deprecation": true,
+  "--max-old-space-size": true,
+  "--inspect": true,
+  "--inspect-brk": true,
+};
+
+export async function importJSON(filepath) {
+  try {
+    return JSON.parse(await fs.readFile(filepath));
+  } catch {
+    return {};
+  }
+}
+
+export async function importEnv(filepath) {
+  try {
+    const env = {};
+    const entries = (await fs.readFile(filepath, "utf8")).split("\n");
+    for (let i = 0, len = entries.length; i < len; i++) {
+      const [key, value] = entries[i].split("=");
+      env[key] = value;
+    }
+    return env;
+  } catch {
+    return {};
+  }
+}
+
+export async function importConfig(options = {}) {
+  try {
+    const helper = async (file) => {
+      file = fileURLToPath(import.meta.resolve(file));
+      const {
+        extends: parent,
+        cliOptions: cli = {},
+        compilerOptions: compiler = {},
+        bundlerOptions: bundler = {},
+      } = await importJSON(file);
+      if (cli.commands) {
+        const commands = Object.keys(cli.commands);
+        const dirname = fs.dirname(file);
+        for (let i = 0, len = commands.length; i < len; i++)
+          cli.commands[commands[i]] = fs.resolve(dirname, cli.commands[commands[i]]);
+      }
+      if (parent) return assign(await helper(parent), { cli, compiler, bundler });
+      return { cli, compiler, bundler };
+    };
+    let file = fs.resolve(process.cwd(), "tsconfig.json");
+    if (!fs.existsSync(file)) file = fs.resolve(process.cwd(), "jsconfig.json");
+    if (!fs.existsSync(file)) return options;
+    return assign(options, await helper(file));
+  } catch (e) {
+    console.error(e.trace || e.message);
+    return options;
+  }
+}
+
+export async function getOutdatedPackages(dirname) {
+  const packages = (await getProjectLock(dirname))?.packages || {};
+  const data = {};
+  const promises = [];
+  async function processPackage(filepath, workspace) {
+    if (!fs.existsSync(filepath)) {
+      if (workspace) return;
+      else throw new Error("No Package found");
+    }
+    const { dependencies, devDependencies, workspaces } = await importJSON(filepath);
+    await fetchPackageUpdates(filepath, dependencies);
+    await fetchPackageUpdates(filepath, devDependencies, true);
+    if (!(workspaces?.length > 0)) return;
+    const workspaceDirnames = await resolveWorkspacesDirnames(workspaces);
+    for (let i = 0, len = workspaceDirnames.length; i < len; i++)
+      await processPackage(fs.resolve(workspaceDirnames[i], "package.json"), true);
+  }
+  async function fetchPackageUpdates(path, deps = {}, dev) {
+    const keys = Object.keys(deps);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const packageName = keys[i];
+      const { version, resolved, link } = packages["node_modules/" + packageName] || {};
+      if (link) continue;
+      if (!version) throw new Error(`Module ${packageName} not found `);
+      promises.push(
+        new Promise((resolve, reject) =>
+          fetch(resolved ? resolved.split("/-/")[0] + "/latest" : `https://registry.npmjs.org/${packageName}/latest`)
+            .then((response) => response.json())
+            .then(resolve)
+            .catch(reject),
+        ),
+      );
+      data[packageName] = {
+        package: path,
+        current: version,
+        wanted: deps[packageName],
+        dev,
+      };
+    }
+  }
+  const result = [];
+  await processPackage(fs.resolve(dirname, "package.json"));
+  const values = await Promise.all(promises);
+  for (let i = 0, len = values.length; i < len; i++) {
+    const module = data[values[i]?.name];
+    module.name = values[i]?.name;
+    module.latest = values[i]?.version;
+    if (!module || !module?.latest || !module?.current || !module?.wanted) throw new Error(`Internal Error`);
+    if (module.current === module.latest) continue;
+    module.wanted = satisfies(module.latest, module.wanted) ? module.latest : module.current;
+    result.push(module);
+  }
+  return result;
+}
+
+export async function incrementPackageVersion(filepath, value, id) {
+  const packageJSON = await importJSON(filepath);
+  if (["major", "minor", "patch", "premajor", "preminor", "prepatch", "prerelease"].includes(value))
+    packageJSON.version = inc(packageJSON.version, value, id);
+  else if (valid(value)) packageJSON.version = value;
+  else throw new TypeError("Invalid version or increment type.");
+  await fs.writeFile(filepath, JSON.stringify(packageJSON, null, 2));
+  return packageJSON.version;
+}
+
+export function saveCrashReport() {
+  if (!process.env.NODE_CRASH_REPORT) return;
+  const crashFolder = fs.resolve(process.cwd(), ".logs");
+  if (!fs.existsSync(crashFolder)) fs.mkdir(crashFolder);
+  const logs = console.logs;
+  let output = "";
+  for (let i = 0, len = logs.length; i < len; i++) {
+    output += logs[i].time.toISOString() + " - " + logs[i].toString().replace(/\n/gm, " ") + "\n";
+  }
+  fs.writeFileSync(fs.resolve(crashFolder, Date.now() + ".log"), output);
+}
+
+export function run(script, ...args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", ["--no-warnings", "--run", script, "--", ...args], {
+      stdio: "inherit",
+      shell: true,
+      windowsHide: true,
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code));
+    process.on("SIGINT", () => !child.killed && child.kill("SIGINT"));
+    process.on("SIGTERM", () => !child.killed && child.kill("SIGTERM"));
+  });
+}
+
+/**
+ * Function to parse command line arguments.
+ * @param {string[]} args
+ * @returns
+ */
+export function parseArgs(args) {
+  const result = [[], {}];
+  for (let i = 0, len = args.length; i < len; i++) {
+    const [option, value] = args[i].toLowerCase().split("=");
+    if (option.startsWith("--")) result[1][option.slice(2)] = evaluate(value);
+    else result[0].push(args[i]);
+  }
+  return result;
+}
+
+export { assign, async, extract, fs, remove };
+
+async function getProjectLock(path) {
+  if (fs.existsSync(path + "/package-lock.json")) return await importJSON(fs.resolve(path, "package-lock.json"));
+  const newPath = fs.resolve(path, "..");
+  if (newPath === path) throw new Error("No Package Lock found.");
+  return await getProjectLock(newPath);
+}
+
+async function resolveWorkspacesDirnames(workspaces) {
+  const paths = [];
+  for (let i = 0, len = workspaces.length; i < len; i++) {
+    if (!workspaces[i].includes("*")) {
+      paths.push(workspaces[i]);
+      continue;
+    }
+    const entries = fs.glob(workspaces[i]);
+    let entry = (await entries.next())?.value;
+    while (entry) {
+      paths.push(entry);
+      entry = (await entries.next())?.value;
+    }
+  }
+  return paths;
+}
+
+function evaluate(value) {
+  if (value == null || value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}