@vistta/cli 1.1.0 → 1.2.0

package/tests/project.test.js

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function project(report = {}) {
+  const cwd = mkdtempSync(join(tmpdir(), "vistta-project-"));
+  const files = {
+    "package.json": { name: "fixture", version: "1.0.0", dependencies: { latest: "^1.0.0" } },
+    "package-lock.json": { packages: {} },
+    "packages/first/package.json": { name: "first", dependencies: { shared: "^1.0.0", untouched: "^1.0.0" } },
+    "packages/second/package.json": { name: "second", devDependencies: { shared: "^2.0.0" } },
+  };
+  for (const [path, content] of Object.entries(files)) {
+    mkdirSync(dirname(join(cwd, path)), { recursive: true });
+    writeFileSync(join(cwd, path), JSON.stringify(content));
+  }
+  const npm = join(cwd, "npm.cjs");
+  writeFileSync(
+    npm,
+    `process.stdout.write(${JSON.stringify(JSON.stringify(report))}); process.exit(${Object.keys(report).length ? 1 : 0});`,
+  );
+  return {
+    cwd,
+    read: (path) => JSON.parse(readFileSync(join(cwd, path), "utf8")),
+    invoke: (...args) =>
+      spawnSync(process.execPath, [fileURLToPath(new URL("../bin.js", import.meta.url)), "project", ...args], {
+        cwd,
+        encoding: "utf8",
+        env: { ...process.env, npm_execpath: npm },
+      }),
+    clean: () => rmSync(cwd, { recursive: true, force: true }),
+  };
+}
+
+const report = {
+  shared: [
+    { current: "1.0.0", wanted: "1.5.0", latest: "3.0.0", type: "dependencies", dependedByLocation: "packages/first" },
+    { current: "2.0.0", wanted: "2.8.0", latest: "3.0.0", type: "devDependencies", dependedByLocation: "packages/second" },
+  ],
+  latest: { current: "1.0.0", wanted: "1.0.0", latest: "2.0.0", type: "dependencies" },
+};
+
+suite("Project command", () => {
+  test("shows consistent help and metadata and rejects unknown commands and arguments", () => {
+    const fixture = project();
+    try {
+      assert.match(fixture.invoke().stdout, /Project metadata and dependency maintenance/);
+      assert.match(fixture.invoke("update", "--help").stdout, /may include major upgrades/);
+      assert.match(fixture.invoke("help", "patch").stdout, /not patch-only/);
+      assert.match(fixture.invoke("name").stdout, /fixture/);
+      assert.match(fixture.invoke("version").stdout, /1\.0\.0/);
+      assert.equal(fixture.invoke("version", "patch").status, 0);
+      assert.equal(fixture.read("package.json").version, "1.0.1");
+      assert.notEqual(fixture.invoke("typo").status, 0);
+      assert.notEqual(fixture.invoke("update", "--typo").status, 0);
+      assert.notEqual(fixture.invoke("name", "extra").status, 0);
+    } finally {
+      fixture.clean();
+    }
+  });
+
+  test("reports versions and manifests and preserves informational-only exit status", () => {
+    const fixture = project(report);
+    try {
+      const result = fixture.invoke("outdated");
+      assert.equal(result.status, 1);
+      assert.match(result.stdout, /Current\s+Wanted\s+Latest/);
+      assert.match(result.stdout, /1\.5\.0/);
+      assert.match(result.stdout, /packages[\\/]second[\\/]package\.json/);
+      assert.match(result.stdout, /2 compatible update/);
+      const informational = fixture.invoke("outdated", "latest");
+      assert.equal(informational.status, 0);
+      assert.doesNotMatch(informational.stdout, /shared/);
+      assert.match(fixture.invoke("outdated", "absent").stdout, /No outdated dependency/);
+    } finally {
+      fixture.clean();
+    }
+  });
+
+  test("previews compatible changes and writes each workspace's own target version", () => {
+    const fixture = project(report);
+    try {
+      const preview = fixture.invoke("update", "shared", "--compatible", "--dry-run");
+      assert.equal(preview.status, 0, preview.stdout + preview.stderr);
+      assert.match(preview.stdout, /Dry run: no files changed/);
+      assert.equal(fixture.read("packages/first/package.json").dependencies.shared, "^1.0.0");
+      assert.equal(fixture.read("packages/second/package.json").devDependencies.shared, "^2.0.0");
+      const updated = fixture.invoke("patch", "shared");
+      assert.equal(updated.status, 0, updated.stdout + updated.stderr);
+      assert.equal(fixture.read("packages/first/package.json").dependencies.shared, "^1.5.0");
+      assert.equal(fixture.read("packages/first/package.json").dependencies.untouched, "^1.0.0");
+      assert.equal(fixture.read("packages/second/package.json").devDependencies.shared, "^2.8.0");
+      assert.equal(fixture.read("package.json").dependencies.latest, "^1.0.0");
+      assert.match(updated.stdout, /Run npm install/);
+      assert.match(fixture.invoke("patch", "shared").stdout, /No compatible dependency range changes needed/);
+    } finally {
+      fixture.clean();
+    }
+  });
+
+  test("keeps latest update behavior explicit and reports missing installed dependencies", () => {
+    const fixture = project({ ...report, missing: { wanted: "1.0.0", latest: "1.0.0", type: "dependencies" } });
+    try {
+      assert.equal(fixture.invoke("outdated", "missing").status, 1);
+      assert.match(fixture.invoke("outdated", "missing").stdout, /MISSING/);
+      assert.equal(fixture.invoke("update", "shared").status, 0);
+      assert.equal(fixture.read("packages/first/package.json").dependencies.shared, "^3.0.0");
+      assert.equal(fixture.read("packages/second/package.json").devDependencies.shared, "^3.0.0");
+    } finally {
+      fixture.clean();
+    }
+  });
+});

package/tools.js

@@ -0,0 +1,210 @@
+import { spawn } from "node:child_process";
+import { existsSync, globSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, matchesGlob, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export async function projectTool(name, cwd) {
+  const require = createRequire(resolve(cwd, "package.json"));
+  let entry;
+  try {
+    entry = require.resolve(name);
+  } catch {
+    throw new Error(`Missing project tool "${name}". Install it locally: npm install --save-dev ${name}`);
+  }
+  const module = await import(pathToFileURL(entry).href);
+  return module.default || module;
+}
+
+export function toolFiles(project, name, patterns = [], cwd = process.cwd()) {
+  const section = project.config.cli?.[name] || {};
+  const explicit = patterns.length > 0;
+  const source = project.sources[`cli.${name}.include`] || project.sources.include || project.file;
+  const base = explicit ? cwd : source ? dirname(source) : cwd;
+  const defaults = name === "lint" ? ["**/*.{js,jsx,mjs,cjs,ts,tsx}"] : ["**/*"];
+  const include = explicit ? patterns : section.include || project.config.include || (project.config.files ? [] : defaults);
+  const excluded = ["**/node_modules", "**/node_modules/**", "**/.git", "**/.git/**"];
+  for (const pattern of section.exclude || project.config.exclude || []) {
+    const source = project.sources[`cli.${name}.exclude`] || project.sources.exclude || project.file;
+    const path = resolve(source ? dirname(source) : cwd, pattern).replaceAll("\\", "/");
+    excluded.push(path, path + "/**");
+  }
+  const output = project.config.compilerOptions?.outDir;
+  if (output) {
+    const source = project.sources["compilerOptions.outDir"] || project.file;
+    excluded.push(resolve(source ? dirname(source) : cwd, output).replaceAll("\\", "/") + "/**");
+  }
+  const isExcluded = (entry) => {
+    const path = resolve(base, entry).replaceAll("\\", "/");
+    return (
+      path.split("/").some((part) => part === "node_modules" || part === ".git") ||
+      excluded.some((pattern) => matchesGlob(path, pattern))
+    );
+  };
+  const files = globSync(
+    include.map((pattern) => resolve(base, pattern).replaceAll("\\", "/")),
+    {
+      cwd: base,
+      exclude: isExcluded,
+    },
+  );
+  if (!explicit && !section.include) {
+    for (const file of project.config.files || []) files.push(resolve(dirname(project.sources.files || project.file), file));
+  }
+  return [...new Set(files)].filter((file) => !isExcluded(file) && statSync(file).isFile()).sort();
+}
+
+async function lint(project, patterns, fix, cwd) {
+  const section = project.config.cli?.lint || {};
+  const { ESLint } = await projectTool("eslint", cwd);
+  const external = section.config ? (await import(section.config)).default : undefined;
+  const inline = section.rules || section.languageOptions || section.options;
+  const override = {
+    ...section.options,
+    ...(section.rules ? { rules: section.rules } : {}),
+    ...(section.languageOptions ? { languageOptions: section.languageOptions } : {}),
+  };
+  const probe = new ESLint({ cwd });
+  const hasConfig = await probe.findConfigFile();
+  const eslint = new ESLint({
+    cwd,
+    fix,
+    ...(external || inline
+      ? { overrideConfig: [...(external ? (Array.isArray(external) ? external : [external]) : []), override] }
+      : {}),
+    ...(external || (!hasConfig && inline) ? { overrideConfigFile: true } : {}),
+  });
+  const files = [];
+  for (const file of toolFiles(project, "lint", patterns, cwd)) if (!(await eslint.isPathIgnored(file))) files.push(file);
+  if (!files.length) return 0;
+  const results = await eslint.lintFiles(files);
+  if (fix) await ESLint.outputFixes(results);
+  const formatted = await (await eslint.loadFormatter("stylish")).format(results);
+  if (formatted) console.log(formatted);
+  return results.some((result) => result.errorCount || result.warningCount) ? 1 : 0;
+}
+
+async function format(project, patterns, write, cwd) {
+  const prettier = await projectTool("prettier", cwd);
+  const section = project.config.cli?.format || {};
+  const external = section.config ? (await import(section.config)).default : undefined;
+  let failed = false;
+  const ignorePath = resolve(cwd, ".prettierignore");
+  for (const file of toolFiles(project, "format", patterns, cwd)) {
+    const info = await prettier.getFileInfo(file, {
+      ...(existsSync(ignorePath) ? { ignorePath } : {}),
+      withNodeModules: false,
+    });
+    if (info.ignored || !info.inferredParser) continue;
+    const options = { ...(external || (await prettier.resolveConfig(file))), ...section.options, filepath: file };
+    const original = readFileSync(file, "utf8");
+    if (await prettier.check(original, options)) continue;
+    if (write) writeFileSync(file, await prettier.format(original, options));
+    else failed = true;
+    console.log(`${write ? "Formatted" : "Needs formatting"}: ${file}`);
+  }
+  return failed ? 1 : 0;
+}
+
+async function types(project, cwd) {
+  if (!project.file) throw new Error("Type checking requires tsconfig.json or jsconfig.json");
+  const ts = await projectTool("typescript", cwd);
+  const diagnostics = [];
+  const host = { ...ts.sys, onUnRecoverableConfigFileDiagnostic: (error) => diagnostics.push(error) };
+  const parsed = ts.getParsedCommandLineOfConfigFile(project.file, { noEmit: true }, host);
+  if (parsed) {
+    diagnostics.push(...parsed.errors);
+    if (!parsed.errors.length) {
+      const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: parsed.options,
+        projectReferences: parsed.projectReferences,
+      });
+      diagnostics.push(...ts.getPreEmitDiagnostics(program));
+    }
+  }
+  if (diagnostics.length)
+    console.log(
+      ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+        getCanonicalFileName: (file) => file,
+        getCurrentDirectory: () => cwd,
+        getNewLine: () => "\n",
+      }),
+    );
+  return diagnostics.some((error) => error.category === ts.DiagnosticCategory.Error) ? 1 : 0;
+}
+
+export async function runChecks(names, project, { patterns = [], fix = false, cwd = process.cwd() } = {}) {
+  const results = [];
+  const runners = { format, lint, types };
+  for (const name of names) {
+    try {
+      const code = name === "types" ? await types(project, cwd) : await runners[name](project, patterns, fix, cwd);
+      results.push({ name, code });
+      console.log(`${name}: ${code ? "failed" : "passed"}`);
+    } catch (error) {
+      results.push({ name, code: 1 });
+      console.error(`${name}: ${error.message}`);
+    }
+  }
+  console.log(`Checks: ${results.filter((result) => !result.code).length}/${results.length} passed`);
+  return results.some((result) => result.code) ? 1 : 0;
+}
+
+export function planTasks(name, tasks = {}, scripts = {}, commands = ["check", "lint", "fmt", "types", "test", "bundle"]) {
+  const result = [];
+  const visited = new Set();
+  const active = new Set();
+  function visit(name) {
+    if (active.has(name)) throw new Error(`Circular task dependency: ${[...active, name].join(" -> ")}`);
+    if (visited.has(name)) return;
+    const task = Object.hasOwn(tasks, name) ? tasks[name] : undefined;
+    if (!task && !Object.hasOwn(scripts, name) && !commands.includes(name))
+      throw new Error(`Unknown task or package script "${name}"`);
+    active.add(name);
+    for (const dependency of task?.dependsOn || []) visit(dependency);
+    active.delete(name);
+    visited.add(name);
+    if (task?.script && !Object.hasOwn(scripts, task.script))
+      throw new Error(`Unknown package script "${task.script}" for task "${name}"`);
+    result.push({
+      name,
+      ...(task ? { script: task.script } : Object.hasOwn(scripts, name) ? { script: name } : { command: name }),
+    });
+  }
+  visit(name);
+  return result;
+}
+
+export function executeNode(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, args, { cwd, stdio: "inherit", windowsHide: true });
+    const stop = () => child.kill("SIGINT");
+    process.on("SIGINT", stop);
+    child.on("error", (error) => {
+      process.removeListener("SIGINT", stop);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      process.removeListener("SIGINT", stop);
+      resolve(code ?? 1);
+    });
+  });
+}
+
+export async function runTasks(plan, cwd, args = [], execute = executeNode) {
+  const bin = fileURLToPath(new URL("./bin.js", import.meta.url));
+  for (const task of plan) {
+    if (!task.script && !task.command) continue;
+    console.log(`Task: ${task.name}`);
+    const forwarded = task === plan.at(-1) ? args : [];
+    const code = await execute(
+      task.script
+        ? ["--run", task.script, ...(forwarded.length ? ["--", ...forwarded] : [])]
+        : [bin, task.command, ...forwarded],
+      cwd,
+    );
+    if (code) return code;
+  }
+  return 0;
+}

package/utils.js

@@ -2,9 +2,10 @@ import fs from "@vistta/fs";
 import { assign, async, extract, remove } from "@vistta/utils";
 import { spawn } from "node:child_process";
 import { platform } from "node:os";
-import { isAbsolute } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { inc, satisfies, valid } from "semver";
+import { relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { inc, valid } from "semver";
+import { loadProjectConfig, mergeConfig } from "./config.js";
 
 export const CWD = process.cwd();
 export const FALLBACK = "*";
@@ -48,95 +49,70 @@ export async function importEnv(filepath) {
 }
 
 export async function importConfig(options = {}) {
-  try {
-    const helper = async (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]] = resolve(dirname, cli.commands[commands[i]]);
-      }
-      if (parent) return assign(await helper(ensurePath(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(ensurePath(file)));
-  } catch (e) {
-    console.error(e.trace || e.message);
-    return options;
-  }
+  const { config } = loadProjectConfig();
+  return mergeConfig(options, {
+    cli: config.cli || {},
+    compiler: config.compilerOptions || {},
+    bundler: config.bundlerOptions || {},
+  });
 }
 
 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) {
-        data[packageName] = {
-          package: path,
-          dev,
-        };
-        promises.push({ name: packageName });
-        continue;
+  const lock = await getProjectLock(dirname);
+  const packages = lock.packages || {};
+  if (!fs.existsSync(fs.resolve(dirname, "package.json"))) throw new Error("No Package found");
+  const output = await new Promise((resolve, reject) => {
+    const npmPath = process.env.npm_execpath;
+    const args = ["outdated", "--json", "--long", "--include=dev"];
+    const windowsShell = !npmPath && platform() === "win32";
+    const command = npmPath ? process.execPath : windowsShell ? process.env.ComSpec || "cmd.exe" : "npm";
+    const child = spawn(
+      command,
+      npmPath ? [npmPath, ...args] : windowsShell ? ["/d", "/s", "/c", "npm " + args.join(" ")] : args,
+      {
+        cwd: dirname,
+        windowsHide: true,
+      },
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (value) => {
+      stdout += value;
+    });
+    child.stderr.on("data", (value) => {
+      stderr += value;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      try {
+        const data = JSON.parse(stdout || "{}");
+        if ((code !== 0 && code !== 1) || data.error)
+          reject(new Error(data.error?.summary || stderr || `npm outdated exited with code ${code}`));
+        else resolve(data);
+      } catch (error) {
+        reject(new Error(stderr || error.message));
       }
-      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.current) {
-      result.push(module);
-      continue;
+  for (const [name, entries] of Object.entries(output)) {
+    for (const entry of Array.isArray(entries) ? entries : [entries]) {
+      const location = entry.location
+        ? relative(lock.dirname, entry.location).replaceAll("\\", "/")
+        : "node_modules/" + name;
+      if (packages[location]?.link || packages["node_modules/" + name]?.link) continue;
+      if (entry.type !== "dependencies" && entry.type !== "devDependencies") continue;
+      const packagePath = fs.resolve(lock.dirname, entry.dependedByLocation || "", "package.json");
+      if (relative(lock.dirname, dirname) && relative(dirname, packagePath) !== "package.json") continue;
+      result.push({
+        name,
+        package: packagePath,
+        current: entry.current,
+        wanted: entry.wanted,
+        latest: entry.latest,
+        dev: entry.type === "devDependencies",
+      });
     }
-    if (!module || !module?.latest || !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;
 }
@@ -232,42 +208,15 @@ export function markAttributes(attrs) {
 export { assign, async, extract, remove };
 
 async function getProjectLock(path) {
-  if (fs.existsSync(path + "/package-lock.json")) return await importJSON(fs.resolve(path, "package-lock.json"));
+  if (fs.existsSync(path + "/package-lock.json"))
+    return { ...(await importJSON(fs.resolve(path, "package-lock.json"))), dirname: path };
   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;
 }
-
-function ensurePath(value) {
-  try {
-    if (isAbsolute(value)) return value;
-    value = import.meta.resolve(value);
-    if (isAbsolute(value)) return value;
-    return fileURLToPath(value);
-  } catch {
-    return value;
-  }
-}