@intentius/chant 0.124.12 → 0.124.14

package/dist/workspace/lineage-vendor.js

@@ -0,0 +1,171 @@
+/**
+ * `chant vendor` over the lineage lock (#2540, ws-038).
+ *
+ * A vendored target is one lineage scope of kind `vendor`: copied, with no
+ * parameters. `pull` updates it file by file through {@link applyUpstream}, so
+ * local edits survive and a file both sides changed becomes a manual step.
+ * `check` reports edits and fails on open manual steps.
+ *
+ * `vendor.json` is still read. A project whose lock has no vendor scopes and
+ * which never ran `chant vendor migrate` keeps today's `vendor.json` behaviour
+ * byte for byte (#2525 rule 2): this module loads only when a lock exists or
+ * `migrate` runs.
+ */
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { MANIFEST_FILE, contentHash, loadManifest, readTarget, resolveVendorSource, } from "../cli/commands/vendor.js";
+import { LOCK_FILE, LockError, declaredFilesAt, emptyLock, fileEntries, readLock, scopeKey, scopeStatus, writeLock } from "./lineage-lock.js";
+import { applyUpstream } from "./lineage-update.js";
+/** The template id a vendor source is known by. */
+function vendorTemplateId(source) {
+    if (source.type === "local")
+        return `local:${source.path}`;
+    return source.subpath ? `${source.url}#${source.subpath}` : source.url;
+}
+/** Vendor scopes in the lock, by scope key. */
+export function vendorScopes(lock) {
+    return Object.entries(lock.scopes).filter(([, l]) => l.kind === "vendor");
+}
+function vendorSource(lineage) {
+    const s = lineage.source;
+    if (s.type === "local" || s.type === "archive")
+        return s;
+    throw new LockError(`vendor scope "${lineage.name}" has a ${s.type} source; vendor scopes take local or archive sources`);
+}
+/** Pull the lock's vendor scopes (or just `only`). Writes the lock. */
+export async function pullLockedScopes(root, only) {
+    const lock = readLock(root) ?? emptyLock();
+    const pulled = [];
+    for (const [scope, lineage] of vendorScopes(lock)) {
+        if (only && lineage.name !== only)
+            continue;
+        const files = await resolveVendorSource(vendorSource(lineage), root);
+        const result = applyUpstream(resolve(root, scope), lineage, files);
+        pulled.push({
+            name: lineage.name ?? scope,
+            target: scope,
+            digest: lineage.address.digest,
+            fileCount: files.size,
+            written: result.written.length,
+            kept: result.kept.length,
+            removed: result.removed.length,
+            manualSteps: result.manualSteps,
+        });
+    }
+    if (pulled.length > 0)
+        writeLock(root, lock);
+    return pulled;
+}
+export function formatLockedPull(p) {
+    const lines = [`  ${p.name} → ${p.target} (${p.fileCount} file(s), ${p.digest.slice(0, 19)}…)`];
+    if (p.kept > 0)
+        lines.push(`    kept ${p.kept} locally edited file(s)`);
+    for (const s of p.manualSteps)
+        lines.push(`    manual step: ${s.path} (${s.reason})`);
+    return lines.join("\n");
+}
+/** Check each vendor scope in the lock against the tree. */
+export function checkLockedScopes(root) {
+    const lock = readLock(root);
+    if (!lock)
+        return [];
+    const out = [];
+    for (const [scope, lineage] of vendorScopes(lock)) {
+        const name = lineage.name ?? scope;
+        if (!lineage.address) {
+            out.push({ name, status: "unpinned", customised: [], manualSteps: [] });
+            continue;
+        }
+        if (!existsSync(resolve(root, scope))) {
+            out.push({ name, status: "missing", customised: [], manualSteps: [] });
+            continue;
+        }
+        const st = scopeStatus(root, scope, lineage);
+        const customised = [...st.customised, ...st.missing].sort();
+        const status = lineage.manualSteps.length > 0 ? "manual" : customised.length > 0 ? "customised" : "ok";
+        out.push({ name, status, customised, manualSteps: lineage.manualSteps });
+    }
+    return out;
+}
+export function formatLockedCheck(c) {
+    switch (c.status) {
+        case "ok":
+            return `  ${c.name}: ok`;
+        case "customised":
+            return `  ${c.name}: ok, ${c.customised.length} file(s) edited locally`;
+        case "manual":
+            return [
+                `  ${c.name}: ${c.manualSteps.length} manual step(s) open`,
+                ...c.manualSteps.map((s) => `    ${s.path} (${s.reason})`),
+            ].join("\n");
+        case "unpinned":
+            return `  ${c.name}: unpinned — run \`chant vendor pull\` to record it`;
+        case "missing":
+            return `  ${c.name}: MISSING — target not found; run \`chant vendor pull\``;
+    }
+}
+/** Whether a check result fails the check the way drift does for `vendor.json`. */
+export function lockedCheckFails(c) {
+    return c.status === "manual" || c.status === "missing";
+}
+/**
+ * Move every `vendor.json` entry into the lock as a vendor scope, then delete
+ * `vendor.json`. An entry's checksum becomes the scope's digest.
+ *
+ * Per-file merge bases come from the target when it still matches the
+ * checksum. When it has been edited, they come from the source instead, which
+ * must still hash to the checksum; otherwise the pinned content is gone and the
+ * entry is refused. Nothing is written unless every entry migrates.
+ */
+export async function migrateVendorManifest(root) {
+    const { manifest, path: manifestPath } = loadManifest(root);
+    const existing = readLock(root);
+    const lock = existing ?? emptyLock();
+    const migrated = [];
+    const names = new Set(vendorScopes(lock).map(([, l]) => l.name));
+    for (const entry of manifest.vendored) {
+        const scope = scopeKey(entry.target);
+        if (scope === ".")
+            throw new LockError(`vendor entry "${entry.name}" targets the project root; a vendor scope must be a subdirectory`);
+        if (lock.scopes[scope])
+            throw new LockError(`vendor entry "${entry.name}": ${LOCK_FILE} already has a scope at ${scope}`);
+        if (names.has(entry.name))
+            throw new LockError(`vendor entry "${entry.name}": ${LOCK_FILE} already has a vendor scope with that name`);
+        names.add(entry.name);
+        let files = {};
+        if (entry.checksum) {
+            const targetAbs = resolve(root, entry.target);
+            const local = readTarget(targetAbs);
+            if (local.size > 0 && contentHash(local) === entry.checksum) {
+                files = fileEntries(local, declaredFilesAt(targetAbs));
+            }
+            else {
+                const source = await resolveVendorSource(entry.source, root);
+                if (contentHash(source) !== entry.checksum) {
+                    throw new LockError(`vendor entry "${entry.name}": ${entry.target} has been edited and its source no longer matches the recorded checksum, so the pinned files cannot be recovered. Run \`chant vendor pull ${entry.name}\` first (it overwrites ${entry.target}), or restore the pinned content.`);
+                }
+                files = fileEntries(source, declaredFilesAt(targetAbs));
+            }
+        }
+        lock.scopes[scope] = {
+            kind: "vendor",
+            name: entry.name,
+            template: vendorTemplateId(entry.source),
+            source: entry.source,
+            ...(entry.ref !== undefined ? { ref: entry.ref } : {}),
+            address: entry.checksum ? { digest: entry.checksum } : null,
+            parameters: {},
+            migrations: [],
+            files,
+            manualSteps: [],
+        };
+        migrated.push({ name: entry.name, target: scope, files: Object.keys(files).length, pinned: !!entry.checksum });
+    }
+    writeLock(root, lock);
+    rmSync(manifestPath);
+    return { migrated, lockCreated: existing === null };
+}
+/** Whether `vendor.json` sits next to the lock. */
+export function manifestPresent(root) {
+    return existsSync(join(root, MANIFEST_FILE));
+}

package/dist/workspace/lineage-version.js

@@ -0,0 +1,128 @@
+/**
+ * Template versions and version ranges, for migration chains (#2550, D9).
+ *
+ * A template's version is read from the ref it was pinned at: `v1.4.0`,
+ * `1.4`, or a prefixed release tag such as `chant-v0.80.0`. Missing minor and
+ * patch numbers read as 0. A ref that is not a version (a branch, a commit)
+ * has none, and a chain of migrations cannot be planned from it.
+ *
+ * Ranges use the familiar npm subset: comparators (`>=1.0.0 <2.0.0`), `^`,
+ * `~`, `x` wildcards, a bare version for an exact match, `*` for any, and
+ * `||` between alternatives. Pre-release tags compare below their release,
+ * and a range matches a pre-release only through an exact comparator.
+ */
+const VERSION_TAIL = /(?:^|[-_/@])v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+/** The version a ref names, or null when it names none. */
+export function parseVersion(ref) {
+    if (!ref)
+        return null;
+    const m = VERSION_TAIL.exec(ref.trim());
+    if (!m)
+        return null;
+    return { major: Number(m[1]), minor: Number(m[2] ?? 0), patch: Number(m[3] ?? 0), pre: m[4] ?? "" };
+}
+export function formatVersion(v) {
+    return `${v.major}.${v.minor}.${v.patch}${v.pre ? `-${v.pre}` : ""}`;
+}
+export function compareVersions(a, b) {
+    for (const k of ["major", "minor", "patch"]) {
+        if (a[k] !== b[k])
+            return a[k] < b[k] ? -1 : 1;
+    }
+    if (a.pre === b.pre)
+        return 0;
+    if (!a.pre)
+        return 1;
+    if (!b.pre)
+        return -1;
+    return a.pre < b.pre ? -1 : 1;
+}
+export class VersionRangeError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "VersionRangeError";
+    }
+}
+function partial(text, range) {
+    const m = /^v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?$/.exec(text);
+    if (!m)
+        throw new VersionRangeError(`"${range}" is not a version range: cannot read "${text}"`);
+    const nums = [m[1], m[2], m[3]];
+    let parts = 0;
+    for (const n of nums) {
+        if (n === undefined || /^[xX*]$/.test(n))
+            break;
+        parts++;
+    }
+    const at = (i) => (i < parts ? Number(nums[i]) : 0);
+    return { v: { major: at(0), minor: at(1), patch: at(2), pre: parts === 3 ? (m[4] ?? "") : "" }, parts };
+}
+function bump(v, part) {
+    if (part === 0)
+        return { major: v.major + 1, minor: 0, patch: 0, pre: "" };
+    if (part === 1)
+        return { major: v.major, minor: v.minor + 1, patch: 0, pre: "" };
+    return { major: v.major, minor: v.minor, patch: v.patch + 1, pre: "" };
+}
+/** The comparators of one `||` alternative. */
+function comparators(alt, range) {
+    const out = [];
+    const tokens = alt.trim().replace(/(>=|<=|>|<|=|\^|~)\s+/g, "$1").split(/\s+/).filter(Boolean);
+    for (const token of tokens) {
+        if (token === "*" || /^[xX]$/.test(token))
+            continue;
+        const m = /^(>=|<=|>|<|=|\^|~)?(.*)$/.exec(token);
+        const op = m[1] ?? "";
+        const { v, parts } = partial(m[2], range);
+        if (op === "^") {
+            const upper = v.major > 0 || parts === 1 ? bump(v, 0) : v.minor > 0 || parts === 2 ? bump(v, 1) : bump(v, 2);
+            out.push({ op: ">=", v }, { op: "<", v: upper });
+        }
+        else if (op === "~") {
+            out.push({ op: ">=", v }, { op: "<", v: bump(v, parts >= 2 ? 1 : 0) });
+        }
+        else if (op === "" || op === "=") {
+            if (parts === 3)
+                out.push({ op: "=", v });
+            else if (parts > 0)
+                out.push({ op: ">=", v }, { op: "<", v: bump(v, parts - 1) });
+        }
+        else if (parts < 3 && (op === ">" || op === "<=")) {
+            // `>1.2` means past every 1.2.x; `<=1.2` includes every 1.2.x.
+            out.push({ op: op === ">" ? ">=" : "<", v: bump(v, parts - 1) });
+        }
+        else {
+            out.push({ op: op, v });
+        }
+    }
+    return out;
+}
+function test(v, c) {
+    const d = compareVersions(v, c.v);
+    switch (c.op) {
+        case "<":
+            return d < 0;
+        case "<=":
+            return d <= 0;
+        case ">":
+            return d > 0;
+        case ">=":
+            return d >= 0;
+        case "=":
+            return d === 0;
+    }
+}
+/** Check a range's syntax, throwing {@link VersionRangeError} when it cannot be read. */
+export function validateRange(range) {
+    for (const alt of range.split("||"))
+        comparators(alt, range);
+}
+/** Whether `version` falls in `range`. */
+export function satisfies(version, range) {
+    return range.split("||").some((alt) => {
+        const cs = comparators(alt, range);
+        if (version.pre && !cs.some((c) => c.op === "=" && compareVersions(c.v, version) === 0))
+            return false;
+        return cs.every((c) => test(version, c));
+    });
+}

package/dist/workspace/lineage-versions.js

@@ -0,0 +1,275 @@
+/**
+ * `chant workspace versions [<dir>] [--template <id>] [--json]` (#2551, D9,
+ * requirement T9).
+ *
+ * Reports, for a family of workspaces, which template version and which chant
+ * and lexicon versions each one is on. A family is the set of workspaces made
+ * from the same template: each lineage scope belongs to the family of its
+ * template id. The command finds every `.chant/workspace.lock.json` under
+ * `<dir>` (the working directory by default), so pointing it at a directory of
+ * checkouts compares them all. Without `--available` nothing is fetched and no
+ * code runs: it reads lock files and `package.json` files only.
+ *
+ * With `--available`, each family whose template is a git source also lists
+ * the template's version tags (`git ls-remote --tags`, catalogued in
+ * `test/egress-catalogue.ts`), and each member says how many are newer than
+ * the version its lock sits at. That is the list `chant workspace upgrade
+ * --to <tag>` chooses from.
+ *
+ * Per D9 the word "drift" keeps its existing meanings, so a workspace on an
+ * older version than the newest one in its family is reported as `behind`.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { formatError } from "../cli/format.js";
+import { TemplateTags } from "./lineage-hash-index.js";
+import { LockError, LOCK_FILE, readLock } from "./lineage-lock.js";
+import { lineageProvenance } from "./lineage-provenance.js";
+import { compareVersions, formatVersion, parseVersion } from "./lineage-version.js";
+/** How deep under `<dir>` a lock is looked for. */
+export const MAX_DEPTH = 8;
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".chant"]);
+/** Every directory under `dir` that holds a lineage lock, nearest first. */
+export function findLocks(dir, depth = MAX_DEPTH) {
+    const found = [];
+    const walk = (at, level) => {
+        if (existsSync(join(at, LOCK_FILE)))
+            found.push(at);
+        if (level >= depth)
+            return;
+        let names;
+        try {
+            names = readdirSync(at);
+        }
+        catch {
+            return;
+        }
+        for (const name of names.sort()) {
+            if (SKIP_DIRS.has(name) || (name.startsWith(".") && name !== "."))
+                continue;
+            const child = join(at, name);
+            try {
+                if (!statSync(child).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            walk(child, level + 1);
+        }
+    };
+    walk(dir, 0);
+    return found;
+}
+function isPlugin(name) {
+    return name === "@intentius/chant" || name.startsWith("@intentius/chant-lexicon-");
+}
+/** The version of `pkg` that node would resolve from `dir`: the nearest `node_modules/<pkg>` going up. */
+function installedVersion(pkg, dir) {
+    let at = dir;
+    for (;;) {
+        const manifest = join(at, "node_modules", pkg, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                return JSON.parse(readFileSync(manifest, "utf-8")).version ?? null;
+            }
+            catch {
+                return null;
+            }
+        }
+        const up = dirname(at);
+        if (up === at)
+            return null;
+        at = up;
+    }
+}
+/** chant and its lexicons, as the workspace's `package.json` declares them. */
+export function pluginVersions(dir) {
+    const manifest = join(dir, "package.json");
+    if (!existsSync(manifest))
+        return [];
+    let json;
+    try {
+        json = JSON.parse(readFileSync(manifest, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const declared = { ...(json.devDependencies ?? {}), ...(json.dependencies ?? {}) };
+    return Object.keys(declared)
+        .filter(isPlugin)
+        .sort()
+        .map((name) => ({ name, declared: declared[name], installed: installedVersion(name, dir) }));
+}
+/** The default lister: `git ls-remote --tags` through ./lineage-hash-index.ts. */
+function remoteTags(url, member, pattern) {
+    const tags = new TemplateTags(url, member, url);
+    try {
+        return tags.listTags(pattern).map((t) => t.tag);
+    }
+    finally {
+        tags.dispose();
+    }
+}
+/** Build the report for every workspace under `dir`, narrowed to one template's family when `template` is given. */
+export function workspaceVersions(dir, templateOrOptions) {
+    const options = typeof templateOrOptions === "string" ? { template: templateOrOptions } : (templateOrOptions ?? {});
+    const template = options.template;
+    const root = resolve(dir);
+    const workspaces = [];
+    for (const at of findLocks(root)) {
+        const path = relative(root, at).split(sep).join("/") || ".";
+        let scopes = [];
+        let error;
+        try {
+            const lock = readLock(at);
+            scopes = Object.entries(lock.scopes).map(([scope, l]) => {
+                const v = parseVersion(l.ref);
+                return {
+                    scope,
+                    kind: l.kind,
+                    template: l.template,
+                    ref: l.ref ?? null,
+                    version: v ? formatVersion(v) : null,
+                    commit: l.address?.commit ?? null,
+                    migrations: l.migrations.length,
+                    adoption: l.adoption?.by ?? null,
+                    provenance: lineageProvenance(at, l)?.level ?? "unattested",
+                    source: l.source.type === "git" ? { type: "git", url: l.source.url.startsWith(".") ? resolve(at, l.source.url) : l.source.url } : { type: l.source.type },
+                };
+            });
+        }
+        catch (err) {
+            if (!(err instanceof LockError))
+                throw err;
+            error = err.message;
+        }
+        if (template !== undefined && !error && !scopes.some((s) => s.template === template))
+            continue;
+        workspaces.push({ path, scopes, plugins: pluginVersions(at), ...(error ? { error } : {}) });
+    }
+    const byTemplate = new Map();
+    for (const w of workspaces) {
+        for (const s of w.scopes) {
+            if (template !== undefined && s.template !== template)
+                continue;
+            const list = byTemplate.get(s.template) ?? [];
+            list.push({ path: w.path, scope: s.scope, ref: s.ref, version: s.version, behind: false });
+            byTemplate.set(s.template, list);
+        }
+    }
+    const families = [];
+    const pluginSpread = [];
+    for (const [id, members] of [...byTemplate.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        const versions = members.map((m) => (m.version ? parseVersion(m.version) : null)).filter((v) => v !== null);
+        const newest = versions.length > 0 ? versions.reduce((a, b) => (compareVersions(a, b) >= 0 ? a : b)) : null;
+        for (const m of members) {
+            m.behind = newest !== null && m.version !== null && compareVersions(parseVersion(m.version), newest) < 0;
+        }
+        const family = { template: id, newest: newest ? formatVersion(newest) : null, members };
+        if (options.available)
+            family.available = available(id, workspaces, members, options);
+        families.push(family);
+        const paths = new Set(members.map((m) => m.path));
+        const seen = new Map();
+        for (const w of workspaces.filter((w) => paths.has(w.path))) {
+            for (const p of w.plugins) {
+                const v = p.installed ?? `not installed (${p.declared})`;
+                const entry = seen.get(p.name) ?? {};
+                (entry[v] ?? (entry[v] = [])).push(w.path);
+                seen.set(p.name, entry);
+            }
+        }
+        for (const [name, spread] of [...seen.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (Object.keys(spread).length > 1)
+                pluginSpread.push({ template: id, name, versions: spread });
+        }
+    }
+    return { root, workspaces, families, pluginSpread };
+}
+/** The version tags of a family's template, and how far behind them each member is. */
+function available(id, workspaces, members, options) {
+    const scope = workspaces.flatMap((w) => w.scopes).find((s) => s.template === id);
+    if (!scope || scope.source.type !== "git" || !scope.source.url) {
+        for (const m of members)
+            m.newer = null;
+        return { tags: [], newest: null, error: `a ${scope?.source.type ?? "unknown"} source has no version tags to list` };
+    }
+    const member = id.includes("#") ? id.slice(id.lastIndexOf("#") + 1) : undefined;
+    let tags;
+    try {
+        tags = (options.listTags ?? remoteTags)(scope.source.url, member, options.tags);
+    }
+    catch (err) {
+        for (const m of members)
+            m.newer = null;
+        return { tags: [], newest: null, error: err instanceof Error ? err.message : String(err) };
+    }
+    const versions = tags.map((t) => parseVersion(t)).filter((v) => v !== null);
+    for (const m of members) {
+        const v = m.version ? parseVersion(m.version) : null;
+        m.newer = v ? versions.filter((t) => compareVersions(t, v) > 0).length : null;
+    }
+    return { tags, newest: tags.length > 0 ? tags[tags.length - 1] : null };
+}
+/** The report as terminal lines. */
+export function describeVersions(report) {
+    const lines = [];
+    for (const w of report.workspaces) {
+        lines.push(w.path);
+        if (w.error)
+            lines.push(`  unreadable: ${w.error}`);
+        for (const s of w.scopes) {
+            const at = s.commit ? ` (${s.commit.slice(0, 12)})` : "";
+            const adopted = s.adoption === "files" && s.provenance !== "adopted" ? ", adopted range not yet at base" : s.adoption === "lineage" ? ", moved from a directory lineage" : "";
+            lines.push(`  ${s.scope}  ${s.template}@${s.ref ?? "(no ref)"}${at}  ${s.provenance}${adopted}${s.migrations > 0 ? `, ${s.migrations} migration(s)` : ""}`);
+        }
+        if (w.plugins.length > 0) {
+            lines.push(`  plugins: ${w.plugins.map((p) => `${p.name} ${p.installed ?? `not installed (${p.declared})`}`).join(", ")}`);
+        }
+    }
+    for (const f of report.families) {
+        const behind = f.members.filter((m) => m.behind);
+        lines.push(`family ${f.template}: ${f.members.length} scope(s), newest ${f.newest ?? "(no versions)"}${behind.length > 0 ? `; behind: ${behind.map((m) => `${m.path}${m.scope === "." ? "" : `/${m.scope}`} (${m.ref})`).join(", ")}` : ""}`);
+        if (f.available) {
+            if (f.available.error)
+                lines.push(`  available: unknown (${f.available.error})`);
+            else {
+                lines.push(`  available: ${f.available.tags.length} version tag(s), newest ${f.available.newest ?? "(none)"}`);
+                for (const m of f.members) {
+                    if (m.newer === undefined || m.newer === null)
+                        continue;
+                    lines.push(`  ${m.path}${m.scope === "." ? "" : `/${m.scope}`} at ${m.ref}: ${m.newer === 0 ? "on the newest" : `${m.newer} newer`}`);
+                }
+            }
+        }
+        for (const s of report.pluginSpread.filter((p) => p.template === f.template)) {
+            lines.push(`  ${s.name} differs: ${Object.entries(s.versions).map(([v, paths]) => `${v} in ${paths.join(", ")}`).join("; ")}`);
+        }
+    }
+    if (report.workspaces.length === 0)
+        lines.push(`no ${LOCK_FILE} under ${report.root}`);
+    return lines;
+}
+export async function runWorkspaceVersions(ctx) {
+    const { args } = ctx;
+    if (args.extraPositional2) {
+        console.error(formatError({ message: `unexpected argument: ${args.extraPositional2}`, hint: "chant workspace versions [<dir>] [--template <id>] [--available [--tags <glob>]] [--json]" }));
+        return 1;
+    }
+    const dir = resolve(args.extraPositional ?? ".");
+    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        console.error(formatError({ message: `${dir} is not a directory` }));
+        return 1;
+    }
+    const report = workspaceVersions(dir, {
+        template: args.template,
+        available: args.available,
+        tags: args.tags,
+    });
+    if (args.json)
+        console.log(JSON.stringify(report, null, 2));
+    else
+        console.log(describeVersions(report).join("\n"));
+    return 0;
+}