@digigov/cli 2.2.4-platform-262.04-06-26-10-20 → 2.3.0

package/commands/packages/doctor.js

@@ -1,22 +1,24 @@
-import fs from 'fs-extra';
-import path from 'path';
-import chalk from 'chalk';
-import { DigigovCommand } from '../../lib/command.js';
-import { logger } from '../../lib/logger.js';
-import { findPackageJson } from '../../lib/project-utils.cjs';
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { DigigovCommand } from "../../lib/command.js";
+import { logger } from "../../lib/logger.js";
+import { findPackageJson } from "../../lib/project-utils.cjs";
 import {
   getScopedDependencies,
   getInstalledVersion,
-} from '../../lib/scope-scan.js';
+} from "../../lib/scope-scan.js";
 
 export function createDoctorCommand() {
-  const cmd = new DigigovCommand('doctor');
+  const cmd = new DigigovCommand("doctor");
   cmd
-    .description('Verify every installed @digigov package shares the same version')
+    .description(
+      "Verify every installed @digigov package shares the same version",
+    )
     .action(async () => {
       const pkgPath = findPackageJson();
       if (!pkgPath) {
-        logger.warn('No package.json found in the current directory tree.');
+        logger.warn("No package.json found in the current directory tree.");
         process.exitCode = 1;
         return;
       }
@@ -25,7 +27,7 @@ export function createDoctorCommand() {
       const pkg = await fs.readJSON(pkgPath);
       const scoped = getScopedDependencies(pkg);
       if (scoped.length === 0) {
-        logger.warn('No @digigov/* dependencies declared. Nothing to check.');
+        logger.warn("No @digigov/* dependencies declared. Nothing to check.");
         return;
       }
 
@@ -38,13 +40,13 @@ export function createDoctorCommand() {
         .map((r) => r.installed)
         .filter(
           /** @type {(v: string | null) => v is string} */ (
-            (v) => typeof v === 'string'
+            (v) => typeof v === "string"
           ),
         );
 
       if (installedVersions.length === 0) {
         logger.warn(
-          'No @digigov packages are actually installed in node_modules. Run install first.',
+          "No @digigov packages are actually installed in node_modules. Run install first.",
         );
         process.exitCode = 1;
         return;
@@ -59,20 +61,20 @@ export function createDoctorCommand() {
         return;
       }
 
-      logger.error('Version drift detected across @digigov packages:');
+      logger.error("Version drift detected across @digigov packages:");
       const longest = rows.reduce((n, r) => Math.max(n, r.name.length), 0);
       for (const r of rows) {
         const pad = r.name.padEnd(longest);
         const installed = r.installed
           ? chalk.red(r.installed)
-          : chalk.dim('(not installed)');
+          : chalk.dim("(not installed)");
         console.log(
           `  ${pad}  declared: ${chalk.dim(r.range)}  installed: ${installed}  ${chalk.dim(`(${r.kind})`)}`,
         );
       }
       console.log(
         chalk.yellow(
-          '\nRun `digigov packages update` to realign your packages.',
+          "\nRun `digigov packages update` to realign your packages.",
         ),
       );
       process.exitCode = 1;

package/commands/packages/init.js

@@ -1,19 +1,18 @@
-import { execa } from 'execa';
-import * as p from '@clack/prompts';
-import ora from 'ora';
-import chalk from 'chalk';
-import { DigigovCommand } from '../../lib/command.js';
-import { logger } from '../../lib/logger.js';
-import { detectPackageManager, buildAddArgs } from '../../lib/pm-detect.js';
-import { fetchScopeManifest } from '../../lib/manifest.js';
-import { RegistryError } from '../../lib/registry.js';
+import { execa } from "execa";
+import * as p from "@clack/prompts";
+import ora from "ora";
+import { DigigovCommand } from "../../lib/command.js";
+import { logger } from "../../lib/logger.js";
+import { detectPackageManager, buildAddArgs } from "../../lib/pm-detect.js";
+import { fetchScopeManifest } from "../../lib/manifest.js";
+import { RegistryError } from "../../lib/registry.js";
 
 export function createInitCommand() {
-  const cmd = new DigigovCommand('init');
+  const cmd = new DigigovCommand("init");
   cmd
-    .description('Interactively install one or more @digigov packages')
-    .option('--tag <tag>', 'Skip the tag prompt and use this dist-tag', '')
-    .option('-y, --yes', 'Install every package without prompting', false)
+    .description("Interactively install one or more @digigov packages")
+    .option("--tag <tag>", "Skip the tag prompt and use this dist-tag", "")
+    .option("-y, --yes", "Install every package without prompting", false)
     .action(
       /**
        * @param {{ tag: string, yes: boolean }} opts
@@ -33,37 +32,30 @@ export function createInitCommand() {
           : await promptForPackages(manifest);
 
         if (!selected || selected.length === 0) {
-          logger.warn('No packages selected. Nothing to install.');
+          logger.warn("No packages selected. Nothing to install.");
           return;
         }
 
-        const tag =
-          opts.tag ||
-          (opts.yes
-            ? 'latest'
-            : await promptForTag());
+        const tag = opts.tag || (opts.yes ? "latest" : await promptForTag());
 
         if (!tag) {
-          logger.warn('No version stream chosen. Aborting.');
+          logger.warn("No version stream chosen. Aborting.");
           return;
         }
 
         const specs = selected.map((name) => `${name}@${tag}`);
-        const spinner = ora({
-          text: `Installing ${selected.length} package(s) via ${pm}…`,
-        }).start();
+
+        logger.log(`Installing ${selected.length} package(s) via ${pm}…`);
         try {
           await execa(pm, buildAddArgs(pm, specs), {
             cwd: root,
-            stdio: 'inherit',
+            stdio: "inherit",
           });
-          spinner.succeed(
-            chalk.green(
-              `Installed ${selected.length} @digigov package(s) at tag "${tag}".`,
-            ),
+          logger.success(
+            `Installed ${selected.length} @digigov package(s) at tag "${tag}".`,
           );
         } catch (err) {
-          spinner.fail('Install failed.');
+          logger.error("Install failed.");
           throw err;
         }
       },
@@ -72,11 +64,11 @@ export function createInitCommand() {
 }
 
 async function loadManifest() {
-  const spinner = ora({ text: 'Fetching @digigov package catalog…' }).start();
+  const spinner = ora({ text: "Fetching @digigov package catalog…" }).start();
   try {
     const manifest = await fetchScopeManifest();
     if (manifest.length === 0) {
-      spinner.warn('Registry returned no @digigov packages.');
+      spinner.warn("Registry returned no @digigov packages.");
       return null;
     }
     spinner.succeed(`Found ${manifest.length} @digigov package(s).`);
@@ -86,17 +78,25 @@ async function loadManifest() {
       spinner.fail(err.message);
       return null;
     }
-    spinner.fail('Failed to fetch the package catalog.');
+    spinner.fail("Failed to fetch the package catalog.");
     throw err;
   }
 }
 
+function checkCancel(result) {
+  if (p.isCancel(result)) {
+    p.cancel("Aborted.");
+    return null;
+  }
+  return result;
+}
+
 /**
  * @param {{ name: string, description: string }[]} manifest
  */
 async function promptForPackages(manifest) {
   const result = await p.multiselect({
-    message: 'Select packages to install',
+    message: "Select packages to install",
     options: manifest.map((m) => ({
       value: m.name,
       label: m.name,
@@ -104,25 +104,21 @@ async function promptForPackages(manifest) {
     })),
     required: false,
   });
-  if (p.isCancel(result)) {
-    p.cancel('Aborted.');
-    return null;
-  }
-  return /** @type {string[]} */ (result);
+  const selection = checkCancel(result);
+  if (selection === null) return null;
+  return /** @type {string[]} */ (selection);
 }
 
 async function promptForTag() {
   const result = await p.select({
-    message: 'Which release stream?',
+    message: "Which release stream?",
     options: [
-      { value: 'latest', label: 'Stable (latest)' },
-      { value: 'next', label: 'Pre-release (next)' },
+      { value: "latest", label: "Stable (latest)" },
+      { value: "next", label: "Pre-release (next)" },
     ],
-    initialValue: 'latest',
+    initialValue: "latest",
   });
-  if (p.isCancel(result)) {
-    p.cancel('Aborted.');
-    return null;
-  }
-  return /** @type {string} */ (result);
+  const selection = checkCancel(result);
+  if (selection === null) return null;
+  return /** @type {string} */ (selection);
 }

package/commands/packages/update.js

@@ -1,22 +1,34 @@
-import fs from 'fs-extra';
-import { execa } from 'execa';
-import * as p from '@clack/prompts';
-import ora from 'ora';
-import chalk from 'chalk';
-import { DigigovCommand } from '../../lib/command.js';
-import { logger } from '../../lib/logger.js';
-import { findPackageJson } from '../../lib/project-utils.cjs';
-import { detectPackageManager, buildInstallArgs } from '../../lib/pm-detect.js';
-import { getDistTags, RegistryError } from '../../lib/registry.js';
-import { getScopedDependencies } from '../../lib/scope-scan.js';
-import { VERSION_ORACLE_PACKAGE } from '../../lib/manifest.js';
+import fs from "fs-extra";
+import { execa } from "execa";
+import * as p from "@clack/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { DigigovCommand } from "../../lib/command.js";
+import { logger } from "../../lib/logger.js";
+import { findPackageJson } from "../../lib/project-utils.cjs";
+import { detectPackageManager, buildInstallArgs } from "../../lib/pm-detect.js";
+import {
+  getDistTags,
+  getPackageInfo,
+  RegistryError,
+} from "../../lib/registry.js";
+import { getScopedDependencies } from "../../lib/scope-scan.js";
+import { VERSION_ORACLE_PACKAGE } from "../../lib/manifest.js";
 
 export function createUpdateCommand() {
-  const cmd = new DigigovCommand('update');
+  const cmd = new DigigovCommand("update");
   cmd
-    .description('Bulk-realign every installed @digigov package to one version')
-    .option('--tag <tag>', 'Skip the prompt and use this dist-tag or version', '')
-    .option('--dry-run', 'Print the planned changes without writing or installing', false)
+    .description("Bulk-realign every installed @digigov package to one version")
+    .option(
+      "--tag <tag>",
+      "Skip the prompt and use this dist-tag or version",
+      "",
+    )
+    .option(
+      "--dry-run",
+      "Print the planned changes without writing or installing",
+      false,
+    )
     .action(
       /**
        * @param {{ tag: string, dryRun: boolean }} opts
@@ -25,14 +37,14 @@ export function createUpdateCommand() {
         const { pm, root } = detectPackageManager();
         const pkgPath = findPackageJson(root);
         if (!pkgPath) {
-          logger.warn('No package.json found in the project root.');
+          logger.warn("No package.json found in the project root.");
           return;
         }
         /** @type {Record<string, unknown>} */
         const pkg = await fs.readJSON(pkgPath);
         const scoped = getScopedDependencies(pkg);
         if (scoped.length === 0) {
-          logger.warn('No @digigov/* dependencies found. Nothing to update.');
+          logger.warn("No @digigov/* dependencies found. Nothing to update.");
           return;
         }
 
@@ -61,26 +73,24 @@ export function createUpdateCommand() {
         printDiffTable(diff);
 
         if (opts.dryRun) {
-          logger.info('Dry run — no files written.');
+          logger.info("Dry run — no files written.");
           return;
         }
 
         rewritePackageJson(pkg, diff, targetVersion);
         await fs.writeJSON(pkgPath, pkg, { spaces: 2 });
 
-        const spinner = ora({ text: `Reinstalling via ${pm}…` }).start();
+        logger.log(`Reinstalling via ${pm}…`);
         try {
-          await execa(pm, buildInstallArgs(pm), {
+          await execa(pm, buildInstallArgs(), {
             cwd: root,
-            stdio: 'inherit',
+            stdio: "inherit",
           });
-          spinner.succeed(
-            chalk.green(
-              `All @digigov packages now aligned on v${targetVersion}.`,
-            ),
+          logger.success(
+            `All @digigov packages now aligned on v${targetVersion}.`,
           );
         } catch (err) {
-          spinner.fail('Install failed.');
+          logger.error("Install failed.");
           throw err;
         }
       },
@@ -88,6 +98,22 @@ export function createUpdateCommand() {
   return cmd;
 }
 
+function handleRegistryError(err) {
+  if (err instanceof RegistryError) {
+    logger.error(err.message);
+    return null;
+  }
+  throw err;
+}
+
+function checkCancel(result) {
+  if (p.isCancel(result)) {
+    p.cancel("Aborted.");
+    return null;
+  }
+  return result;
+}
+
 async function resolveTagOrVersion(/** @type {string} */ input) {
   if (/^\d/.test(input)) return input;
   try {
@@ -95,54 +121,86 @@ async function resolveTagOrVersion(/** @type {string} */ input) {
     const v = tags[input];
     if (!v) {
       logger.error(
-        `Unknown dist-tag "${input}". Known: ${Object.keys(tags).join(', ') || '<none>'}`,
+        `Unknown dist-tag "${input}". Known: ${Object.keys(tags).join(", ") || "<none>"}`,
       );
       return null;
     }
     return v;
   } catch (err) {
-    if (err instanceof RegistryError) {
-      logger.error(err.message);
-      return null;
-    }
-    throw err;
+    return handleRegistryError(err);
   }
 }
 
+const VERSION_LIMIT = 20;
+
 async function promptForTarget() {
-  let tags;
+  let info;
+  const spinner = ora({
+    text: `Fetching ${VERSION_LIMIT} most recent versions from the registry…`,
+  }).start();
   try {
-    tags = await getDistTags(VERSION_ORACLE_PACKAGE);
+    info = await getPackageInfo(VERSION_ORACLE_PACKAGE);
+    spinner.stop();
   } catch (err) {
-    if (err instanceof RegistryError) {
-      logger.error(err.message);
-      return null;
-    }
-    throw err;
-  }
-  const options = [];
-  if (tags['latest']) {
-    options.push({
-      value: tags['latest'],
-      label: `v${tags['latest']} (Latest Release)`,
-    });
+    spinner.fail("Failed to fetch versions.");
+    return handleRegistryError(err);
   }
-  if (tags['next']) {
-    options.push({
-      value: tags['next'],
-      label: `v${tags['next']} (Next Pre-release)`,
-    });
-  }
-  if (options.length === 0) {
-    logger.error('Registry returned no usable dist-tags.');
+  if (info.versions.length === 0) {
+    logger.error("Registry returned no versions for the oracle package.");
     return null;
   }
-  const result = await p.select({ message: 'Which version target?', options });
-  if (p.isCancel(result)) {
-    p.cancel('Aborted.');
-    return null;
+  const taggedLatest = info.distTags["latest"];
+  const taggedNext = info.distTags["next"];
+
+  const recent = info.versions.slice(0, VERSION_LIMIT);
+  const ordered = [...recent];
+  for (const tagged of [taggedLatest, taggedNext]) {
+    if (tagged && !ordered.includes(tagged)) ordered.push(tagged);
   }
-  return /** @type {string} */ (result);
+
+  const options = ordered.map((version) => {
+    const hints = [];
+
+    if (version === taggedLatest) hints.push("latest");
+    if (version === taggedNext) hints.push("next");
+
+    const issue = extractIssueId(version);
+    if (issue) hints.push(issue);
+
+    return {
+      value: version,
+      label: `v${version}`,
+      hint: hints.join(", ") || undefined,
+    };
+  });
+
+  const initialValue = taggedLatest ?? options[0]?.value;
+  const result = await p.select({
+    message: `Pick a target version`,
+    options,
+    initialValue,
+  });
+  const selection = checkCancel(result);
+  if (selection === null) return null;
+  return /** @type {string} */ (selection);
+}
+
+/**
+ * Beachball pre-release tags ship with custom identifiers like
+ * `2.2.4-platform-262.04-06-26-10-20`: the first dot-segment of the
+ * pre-release tail carries the issue id (`platform-262`). Surface it as a
+ * hint so users can pick the right build at a glance.
+ *
+ * @param {string} v
+ */
+function extractIssueId(v) {
+  const dashIdx = v.indexOf("-");
+  if (dashIdx === -1) return null;
+  const tail = v.slice(dashIdx + 1);
+  const firstSegment = tail.split(".")[0];
+  if (!firstSegment) return null;
+  if (/^\d+(\.\d+)*$/.test(firstSegment)) return null;
+  return firstSegment;
 }
 
 /**
@@ -152,9 +210,11 @@ function printDiffTable(diff) {
   const longest = diff.reduce((n, d) => Math.max(n, d.name.length), 0);
   for (const d of diff) {
     const pad = d.name.padEnd(longest);
-    const arrow = d.changed ? chalk.yellow('→') : chalk.dim('=');
+    const arrow = d.changed ? chalk.yellow("→") : chalk.dim("=");
     const to = d.changed ? chalk.green(d.to) : chalk.dim(d.to);
-    console.log(`  ${pad}  ${d.from}  ${arrow}  ${to}  ${chalk.dim(`(${d.kind})`)}`);
+    console.log(
+      `  ${pad}  ${d.from}  ${arrow}  ${to}  ${chalk.dim(`(${d.kind})`)}`,
+    );
   }
 }
 
@@ -165,7 +225,9 @@ function printDiffTable(diff) {
  */
 function rewritePackageJson(pkg, diff, version) {
   for (const d of diff) {
-    const block = /** @type {Record<string, string> | undefined} */ (pkg[d.kind]);
+    const block = /** @type {Record<string, string> | undefined} */ (
+      pkg[d.kind]
+    );
     if (block && d.name in block) {
       block[d.name] = version;
     }

package/lib/pm-detect.js

@@ -47,7 +47,6 @@ export function detectPackageManager(startDir = process.cwd()) {
 export function buildAddArgs(pm, specs) {
   switch (pm) {
     case 'pnpm':
-      return ['add', ...specs];
     case 'yarn':
       return ['add', ...specs];
     case 'npm':
@@ -59,16 +58,8 @@ export function buildAddArgs(pm, specs) {
  * Build the package manager argv for a plain reinstall after the local
  * `package.json` has already been rewritten.
  *
- * @param {PackageManager} pm
  * @returns {string[]}
  */
-export function buildInstallArgs(pm) {
-  switch (pm) {
-    case 'pnpm':
-      return ['install'];
-    case 'yarn':
-      return ['install'];
-    case 'npm':
-      return ['install'];
-  }
+export function buildInstallArgs() {
+  return ['install'];
 }

package/lib/registry.js

@@ -40,14 +40,15 @@ function encodeName(name) {
 
 /**
  * @param {string} url
+ * @param {Record<string, string>} [headers]
  * @returns {Promise<unknown>}
  */
-async function fetchJson(url) {
+async function fetchJson(url, headers = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
     const res = await fetch(url, {
-      headers: { accept: 'application/json' },
+      headers: { accept: 'application/json', ...headers },
       signal: controller.signal,
     });
     if (!res.ok) {
@@ -161,3 +162,125 @@ export async function searchScope(scope, opts = {}) {
   result.sort((a, b) => a.name.localeCompare(b.name));
   return result;
 }
+
+/**
+ * @typedef {{ distTags: DistTags, versions: string[] }} PackageInfo
+ */
+
+/**
+ * Fetch the package manifest. Returns the dist-tags and a list of every
+ * published version sorted newest-first.
+ *
+ * Sort key is the registry's `time` map (ISO 8601 timestamps), which is
+ * format-independent — important because we use Beachball pre-release tags
+ * with custom identifiers like `2.2.4-platform-262.04-06-26-10-20` whose
+ * lexical order does not match chronological order. Falls back to
+ * `compareVersions` when the registry omits `time` entries.
+ *
+ * @param {string} packageName
+ * @returns {Promise<PackageInfo>}
+ */
+export async function getPackageInfo(packageName) {
+  const url = `${getRegistryUrl()}/${encodeName(packageName)}`;
+  const data = /** @type {unknown} */ (await fetchJson(url));
+  if (!data || typeof data !== 'object') {
+    throw new RegistryError(`Malformed package response for ${packageName}`);
+  }
+  const rawTags = /** @type {{ 'dist-tags'?: unknown }} */ (data)['dist-tags'];
+  /** @type {DistTags} */
+  const distTags = {};
+  if (rawTags && typeof rawTags === 'object') {
+    for (const [tag, value] of Object.entries(rawTags)) {
+      if (typeof value === 'string') distTags[tag] = value;
+    }
+  }
+  const rawVersions = /** @type {{ versions?: unknown }} */ (data).versions;
+  /** @type {string[]} */
+  let versions = [];
+  if (rawVersions && typeof rawVersions === 'object') {
+    versions = Object.keys(rawVersions);
+  }
+
+  const rawTime = /** @type {{ time?: unknown }} */ (data).time;
+  /** @type {Record<string, string>} */
+  const timeMap = {};
+  if (rawTime && typeof rawTime === 'object') {
+    for (const [version, value] of Object.entries(rawTime)) {
+      if (typeof value === 'string') timeMap[version] = value;
+    }
+  }
+
+  versions.sort((a, b) => {
+    const ta = timeMap[a];
+    const tb = timeMap[b];
+    if (ta && tb) return tb.localeCompare(ta);
+    if (ta) return -1;
+    if (tb) return 1;
+    return compareVersions(b, a);
+  });
+  return { distTags, versions };
+}
+
+/**
+ * Compare two semver-ish version strings. Returns negative when `a < b`,
+ * positive when `a > b`, zero when equal. Pre-release tail sorts below the
+ * matching release (`1.0.0-next.0` < `1.0.0`). Numeric pre-release
+ * identifiers compare numerically; alphanumeric ones compare lexically.
+ *
+ * @param {string} a
+ * @param {string} b
+ */
+export function compareVersions(a, b) {
+  const [coreA, preA = ''] = a.split('-');
+  const [coreB, preB = ''] = b.split('-');
+  const coreCmp = compareCore(coreA ?? '', coreB ?? '');
+  if (coreCmp !== 0) return coreCmp;
+  if (preA === preB) return 0;
+  if (preA === '') return 1;
+  if (preB === '') return -1;
+  return comparePrerelease(preA, preB);
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ */
+function compareCore(a, b) {
+  const partsA = a.split('.').map((n) => parseInt(n, 10) || 0);
+  const partsB = b.split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const ai = partsA[i] ?? 0;
+    const bi = partsB[i] ?? 0;
+    if (ai !== bi) return ai - bi;
+  }
+  return 0;
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ */
+function comparePrerelease(a, b) {
+  const partsA = a.split('.');
+  const partsB = b.split('.');
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const ai = partsA[i];
+    const bi = partsB[i];
+    if (ai === bi) continue;
+    if (ai === undefined) return -1;
+    if (bi === undefined) return 1;
+    const ni = Number(ai);
+    const nj = Number(bi);
+    const aIsNum = !Number.isNaN(ni);
+    const bIsNum = !Number.isNaN(nj);
+    if (aIsNum && bIsNum) {
+      if (ni !== nj) return ni - nj;
+      continue;
+    }
+    if (aIsNum) return -1;
+    if (bIsNum) return 1;
+    const cmp = ai.localeCompare(bi);
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@digigov/cli",
   "description": "CLI for Digigov apps and libs with plugin support",
-  "version": "2.2.4-platform-262.04-06-26-10-20",
+  "version": "2.3.0",
   "author": "GRNET Devs <devs@lists.grnet.gr>",
   "type": "module",
   "bin": {