feat: display @probitas package versions in --version output

Extend `probitas --version` to show all @probitas dependency versions
alongside the CLI version. This helps users and maintainers understand
which package versions are actually being used, including transitive
dependencies.

Implementation:
- Add getVersionInfo() function that reads from deno.lock
- Extract all @probitas/* package versions from lock file specifiers
- Display packages in alphabetical order for consistent output
- Preserve existing getVersion() for backward compatibility

Example output:
  probitas 0.0.0
    @probitas/builder 0.4.0
    @probitas/client 0.4.1
    @probitas/client-http 0.4.1
    ...

Author: lambdalisue

src/main.ts

@@ -10,7 +10,7 @@ import { EXIT_CODE } from "./constants.ts";
 import { initCommand } from "./commands/init.ts";
 import { listCommand } from "./commands/list.ts";
 import { runCommand } from "./commands/run.ts";
-import { getVersion, readAsset } from "./utils.ts";
+import { getVersionInfo, readAsset } from "./utils.ts";
 
 const logger = getLogger("probitas", "cli");
 
@@ -39,8 +39,15 @@ export async function main(args: string[]): Promise<number> {
 
   // Show version
   if (parsed.version) {
-    const version = await getVersion() ?? "unknown";
-    console.log(`probitas ${version}`);
+    const info = await getVersionInfo();
+    if (info) {
+      console.log(`probitas ${info.version}`);
+      for (const pkg of info.packages) {
+        console.log(`  ${pkg.name} ${pkg.version}`);
+      }
+    } else {
+      console.log("probitas unknown");
+    }
     return EXIT_CODE.SUCCESS;
   }
 

src/utils.ts

@@ -20,6 +20,24 @@ const isDenoJson = is.ObjectOf({
   version: as.Optional(is.String),
 }) satisfies Predicate<DenoJson>;
 
+type DenoLock = {
+  specifiers?: Record<string, string>;
+};
+
+const isDenoLock = is.ObjectOf({
+  specifiers: as.Optional(is.RecordOf(is.String, is.String)),
+}) satisfies Predicate<DenoLock>;
+
+/**
+ * Version information including CLI and dependency versions
+ */
+export type VersionInfo = {
+  /** CLI version */
+  readonly version: string;
+  /** @probitas package versions (sorted by name) */
+  readonly packages: ReadonlyArray<{ name: string; version: string }>;
+};
+
 const reporterMap: Record<string, (opts?: ReporterOptions) => Reporter> = {
   list: (opts) => new ListReporter(opts),
   json: (opts) => new JSONReporter(opts),
@@ -179,3 +197,61 @@ export async function getVersion(): Promise<string | undefined> {
     return undefined;
   }
 }
+
+/**
+ * Get version information including CLI and @probitas package versions
+ *
+ * Reads CLI version from deno.json and package versions from deno.lock.
+ * Package versions are extracted from the specifiers section of deno.lock.
+ *
+ * @returns Version information including CLI and package versions
+ */
+export async function getVersionInfo(): Promise<VersionInfo | undefined> {
+  try {
+    // Get CLI version from deno.json
+    const denoJsonUrl = new URL("../deno.json", import.meta.url);
+    const denoJsonResp = await fetch(denoJsonUrl);
+    const denoJsonContent = await denoJsonResp.text();
+    const denoJson = ensure(JSON.parse(denoJsonContent), isDenoJson);
+
+    const version = denoJson.version ?? "unknown";
+
+    // Get package versions from deno.lock
+    const denoLockUrl = new URL("../deno.lock", import.meta.url);
+    const denoLockResp = await fetch(denoLockUrl);
+    const denoLockContent = await denoLockResp.text();
+    const denoLock = ensure(JSON.parse(denoLockContent), isDenoLock);
+
+    // Extract @probitas package versions from specifiers
+    // Format: "jsr:@probitas/core@^0.2.0": "0.2.0"
+    const packages: { name: string; version: string }[] = [];
+    const seen = new Set<string>();
+
+    if (denoLock.specifiers) {
+      for (
+        const [specifier, resolvedVersion] of Object.entries(
+          denoLock.specifiers,
+        )
+      ) {
+        // Match jsr:@probitas/package-name@version pattern
+        const match = specifier.match(/^jsr:(@probitas\/[^@]+)@/);
+        if (match) {
+          const name = match[1];
+          // Skip duplicates (same package with different version specifiers)
+          if (!seen.has(name)) {
+            seen.add(name);
+            packages.push({ name, version: resolvedVersion });
+          }
+        }
+      }
+    }
+
+    // Sort packages by name for consistent output
+    packages.sort((a, b) => a.name.localeCompare(b.name));
+
+    return { version, packages };
+  } catch (err: unknown) {
+    logger.debug("Failed to read version info", { err });
+    return undefined;
+  }
+}