@vistta/cli 1.0.1 → 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/tests/runtime.test.js

@@ -0,0 +1,76 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Runtime } from "../classes/runtime.js";
+
+suite("Runtime", () => {
+  test("resolve yields distinct URLs for plain vs bundler imports of the same file", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const file = import.meta.filename || new URL(import.meta.url).pathname.replace(/^\//, "");
+    const captured = [];
+    const next = (url) => {
+      captured.push(url);
+      return url;
+    };
+
+    await runtime.resolve(file, {}, next);
+    await runtime.resolve(file, { importAttributes: { type: "bundler" } }, next);
+    await runtime.resolve(file, { conditions: ["bundler"] }, next);
+
+    expect(captured[0]).not.toEqual(captured[1]);
+    expect(captured[0]).not.toEqual(captured[2]);
+    expect(captured[1]).toEqual(captured[2]);
+    expect(/\?__bundler__$/.test(captured[1])).toEqual(true);
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(false);
+  });
+
+  test("resolve strips bundler suffix from parentURL when resolving relatives", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const here = new URL(".", import.meta.url).href;
+    const parentURL = here + "runtime.test.js?__bundler__";
+    let captured;
+    await runtime.resolve("./runtime.test.js", { parentURL, importAttributes: { type: "bundler" } }, (url) => {
+      captured = url;
+      return url;
+    });
+    expect(captured.includes("?__bundler__?")).toEqual(false);
+    expect(/\?__bundler__$/.test(captured)).toEqual(true);
+  });
+
+  test("resolve detects bundler mode from importAttributes.type even without conditions", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const file = import.meta.filename || new URL(import.meta.url).pathname.replace(/^\//, "");
+    const captured = [];
+    await runtime.resolve(file, { importAttributes: { type: "bundler" } }, (url) => {
+      captured.push(url);
+      return url;
+    });
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(true);
+  });
+
+  test("resolve marks context.file for absolute bundler imports", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const dir = mkdtempSync(join(tmpdir(), "vistta-runtime-"));
+    const file = join(dir, "page.jsx");
+    writeFileSync(file, "export default 1;");
+    const ctx = { importAttributes: { type: "bundler" } };
+    await runtime.resolve(file, ctx, (url) => url);
+    expect(ctx.file).toEqual(true);
+  });
+
+  test("resolve preserves non-bundler query string params", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: ["js"], options: {} });
+    const dir = mkdtempSync(join(tmpdir(), "vistta-runtime-"));
+    const file = join(dir, "data.js");
+    writeFileSync(file, "export default 1;");
+    const here = new URL(import.meta.url);
+    const hereURL = new URL(".", here).href;
+    const captured = [];
+    await runtime.resolve("./data.js?type=json", { parentURL: hereURL }, (url) => {
+      captured.push(url);
+      return url;
+    });
+    expect(captured[0].includes("type=json")).toEqual(true);
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(false);
+  });
+});

package/tests/test-runner.test.js

@@ -0,0 +1,83 @@
+import { TestRunner } from "../classes/test-runner.js";
+
+suite("TestRunner", () => {
+  test("suite().test() registers a passing test", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("t", () => 1);
+    });
+    const results = await runner.run();
+    expect(results[0].name).toEqual("s");
+    expect(results[0].tests[0].name).toEqual("t");
+    expect(results[0].tests[0].status).toEqual("pass");
+    expect(results[0].tests[0].result).toEqual(1);
+  });
+
+  test("failing test reports status=fail with the error", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("boom", () => {
+        throw new Error("kaboom");
+      });
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("fail");
+    expect(results[0].tests[0].error.message).toEqual("kaboom");
+  });
+
+  test("async tests are awaited before status is set", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("async", async () => {
+        await new Promise((r) => setTimeout(r, 10));
+        return "done";
+      });
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("pass");
+    expect(results[0].tests[0].result).toEqual("done");
+  });
+
+  test("test.skip is recorded as 'skip'", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test.skip("skipped", () => {});
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("skip");
+  });
+
+  test("only: option restricts execution to marked tests", async () => {
+    const runner = new TestRunner({ only: true });
+    runner.suite("s", () => {
+      runner.test("not run", () => "x");
+      runner.test.only("run", () => "y");
+    });
+    const results = await runner.run();
+    const names = results[0].tests.map((t) => t.name);
+    expect(names.length).toEqual(1);
+    expect(names[0]).toEqual("run");
+  });
+
+  test("filter option restricts by test name (case-insensitive)", async () => {
+    const runner = new TestRunner({ filter: "MATCH" });
+    runner.suite("s", () => {
+      runner.test("will match", () => {});
+      runner.test("will skip", () => {});
+    });
+    const results = await runner.run();
+    const names = results[0].tests.map((t) => t.name);
+    expect(names.length).toEqual(1);
+    expect(names[0]).toEqual("will match");
+  });
+
+  test("suite errors are swallowed and surfaced via empty tests", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      throw new Error("setup failed");
+    });
+    const results = await runner.run();
+    expect(results.length).toEqual(1);
+    expect(results[0].tests.length).toEqual(0);
+  });
+});

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/tsconfig.json

@@ -3,6 +3,7 @@
     "strict": false,
     "noEmit": true,
     "allowJs": true,
+    "checkJs": true,
     "resolveJsonModule": true,
     "module": "esnext",
     "target": "ESNext",
@@ -10,9 +11,7 @@
     "moduleResolution": "bundler",
     "skipLibCheck": true,
     "jsx": "react",
-    "typeRoots": ["./global.d.ts"],
-    "paths": {
-      "@/*": ["./*"]
-    }
-  }
+    "paths": {}
+  },
+  "include": ["./**/*.js", "./global.d.ts"]
 }