bmad-module-skill-forge 4.0.0 → 5.0.0

package/tools/cli/lib/tool-check.js

@@ -7,12 +7,16 @@
  *
  * Each probe runs a binary resolved on PATH outside the project folder, with
  * no shell and fixed arguments, and never npx, which can download. A .cmd or
- * .bat shim on Windows runs through cmd.exe. A missing, hanging or failing
- * probe reads as unknown: nothing here throws or changes an exit code.
+ * .bat shim on Windows runs through cmd.exe. tessl and skill-check are never
+ * run: tessl's version is read from the name of the binary it installs, and
+ * skill-check's, which has no --version, from its package.json. A missing,
+ * hanging or failing probe reads as unknown: nothing here throws or changes
+ * an exit code.
  */
 
 const { spawn } = require('node:child_process');
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
@@ -27,6 +31,25 @@ const MINIMUM = /^\d+(?:\.\d+)*$/;
 const NPX_TOOLS = new Set(['tessl', 'skill_check']);
 // ccc has no --version: `uv tool list` names each package uv installed, with its version.
 const CCC_PACKAGE = /^cocoindex-code v(\S+)/m;
+// skill-check has no --version either (1.2.0 exits 2 on it). Its version is
+// read from the package.json of the install its binary belongs to. A
+// package.json is looked for at most this many folders above a binary's real
+// path.
+const SKILL_CHECK_PACKAGE = 'skill-check';
+const PACKAGE_DEPTH = 4;
+const MAX_PACKAGE_JSON = 1024 * 1024;
+// tessl is not run either: on a tessl that has never run, any command,
+// --version included, accepts tessl's Terms and turns on usage sharing for
+// the user, and a run can start tessl's own update. tessl's installers name
+// each binary tessl-<version>-<platform> in a tessl/versions folder and point
+// the PATH entry at one: a symlink on Linux and macOS, a copy in tessl\bin on
+// Windows.
+const TESSL_BINARY = /^tessl-(.+)-(?:linux|darwin|win32)-(?:x64|arm64)(?:-musl)?(?:\.exe)?$/;
+// The npm (@tessl/cli) and Homebrew (tessl) packages hold a launcher that
+// runs the binary tessl installed, so their version is not the one that runs.
+// @tessl/cli before 0.63.0 held the CLI itself.
+const TESSL_LAUNCHERS = ['@tessl/cli', 'tessl'];
+const FIRST_TESSL_LAUNCHER = '0.63.0';
 const MAX_OUTPUT = 64 * 1024;
 const STYLES = { ok: chalk.green, upgrade: chalk.yellow, unknown: chalk.yellow, missing: chalk.red, optional: chalk.dim };
 
@@ -172,6 +195,129 @@ async function versionOf(file, args, context) {
   return ok ? findVersion(stdout) : null;
 }
 
+/**
+ * The package.json at `file` as an object, or null when there is none, it is
+ * not a regular file under MAX_PACKAGE_JSON (a FIFO would block the check
+ * past its timeout) or it cannot be read.
+ */
+function readPackage(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MAX_PACKAGE_JSON) return null;
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The package.json of the package named one of `names` that installed
+ * `file`, the binary `bin` on PATH, or null: the shim folder's
+ * node_modules/<name>/package.json (npm's global layout on Windows), else the
+ * first package.json with a name above the binary's real path, when it is
+ * one of `names` and declares that file as its `bin` (npm, yarn, bun and
+ * Homebrew link the binary into its package on Linux and macOS). null for
+ * any other layout, such as pnpm's or Volta's shims.
+ */
+function packageOf(file, bin, names) {
+  for (const name of names) {
+    const shim = readPackage(path.join(path.dirname(file), 'node_modules', ...name.split('/'), 'package.json'));
+    if (shim?.name === name) return shim;
+  }
+  const target = realpath(file);
+  const declares = (data, dir) => {
+    const entry = typeof data.bin === 'string' ? data.bin : data.bin?.[bin];
+    return typeof entry === 'string' && realpath(path.resolve(dir, entry)) === target;
+  };
+  let dir = path.dirname(target);
+  for (let depth = 0; depth < PACKAGE_DEPTH; depth++) {
+    const data = readPackage(path.join(dir, 'package.json'));
+    if (typeof data?.name === 'string') return names.includes(data.name) && declares(data, dir) ? data : null;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** A file's stat, or null when it cannot be read (a dangling link, say). */
+function statOf(file) {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+}
+
+/** The last part of `file`, in lower case on Windows, where names ignore case. */
+function nameOf(file) {
+  return process.platform === 'win32' ? path.basename(file).toLowerCase() : path.basename(file);
+}
+
+/**
+ * The version of the tessl binary `file`, from its name: tessl-<version>-
+ * <platform> once its real path is resolved, or, for a copy at
+ * tessl/bin/tessl or tessl.exe (tessl's layout on Windows), the name of the
+ * one file of tessl/versions that has its size. null when there is no such
+ * file, or more than one.
+ */
+function tesslBinaryVersion(file) {
+  const target = realpath(file);
+  const named = TESSL_BINARY.exec(nameOf(target));
+  if (named) return findVersion(named[1]);
+  const bin = path.dirname(target);
+  if (!/^tessl(?:\.exe)?$/.test(nameOf(target)) || nameOf(bin) !== 'bin' || nameOf(path.dirname(bin)) !== 'tessl') return null;
+  const size = statOf(target)?.size;
+  const versions = path.join(path.dirname(bin), 'versions');
+  let names;
+  try {
+    names = fs.readdirSync(versions);
+  } catch {
+    return null;
+  }
+  const copied = names.filter((name) => {
+    const stat = TESSL_BINARY.test(nameOf(name)) ? statOf(path.join(versions, name)) : null;
+    return stat?.isFile() && stat.size === size;
+  });
+  return size !== undefined && copied.length === 1 ? findVersion(TESSL_BINARY.exec(nameOf(copied[0]))[1]) : null;
+}
+
+/**
+ * The binary tessl's launchers run: ~/.local/bin/tessl, or
+ * %LOCALAPPDATA%\tessl\bin\tessl.exe on Windows. null when the home folder
+ * is not an absolute path, which would be read from the project folder.
+ */
+function tesslLauncherTarget(env) {
+  const target =
+    process.platform === 'win32'
+      ? path.join(
+          envValue(env, 'LOCALAPPDATA') ?? path.join(envValue(env, 'USERPROFILE') || os.homedir(), 'AppData', 'Local'),
+          'tessl',
+          'bin',
+          'tessl.exe',
+        )
+      : path.join(env.HOME || os.homedir(), '.local', 'bin', 'tessl');
+  return path.isAbsolute(target) ? target : null;
+}
+
+/**
+ * tessl's version, read without running it: from the binary on PATH (see
+ * tesslBinaryVersion), or, when that is the npm or Homebrew launcher, from
+ * the binary the launcher runs. An @tessl/cli older than the first launcher
+ * is the CLI itself, so its package.json has the version.
+ */
+function tesslVersion(file, env) {
+  const own = tesslBinaryVersion(file);
+  if (own) return own;
+  const launcher = packageOf(file, 'tessl', TESSL_LAUNCHERS);
+  if (!launcher) return null;
+  const packaged = findVersion(launcher.version);
+  if (launcher.name === '@tessl/cli' && packaged && compareVersions(packaged, FIRST_TESSL_LAUNCHER)) return packaged;
+  const target = tesslLauncherTarget(env);
+  return target ? tesslBinaryVersion(target) : null;
+}
+
 /** One tool: { found, version }, the version null when it cannot be read. */
 async function probe(key, tool, context) {
   if (key === 'node') return { found: true, version: process.versions.node };
@@ -190,6 +336,16 @@ async function probe(key, tool, context) {
     const match = ok ? CCC_PACKAGE.exec(stdout) : null;
     return { found: true, version: match ? findVersion(match[1]) : null };
   }
+  if (key === 'skill_check') {
+    const file = resolveOutsideProject(SKILL_CHECK_PACKAGE, context);
+    return file
+      ? { found: true, version: findVersion(packageOf(file, SKILL_CHECK_PACKAGE, [SKILL_CHECK_PACKAGE])?.version) }
+      : { found: false };
+  }
+  if (key === 'tessl') {
+    const file = resolveOutsideProject('tessl', context);
+    return file ? { found: true, version: tesslVersion(file, context.env) } : { found: false };
+  }
   const [name, ...args] = Array.isArray(tool.version_command) ? tool.version_command.map(String) : [];
   const file = name ? resolveOutsideProject(name, context) : null;
   if (!file) return { found: false };