@ucdjs/cli 0.3.0 → 0.3.1-beta.1

package/dist/mirror-DLYQGa33.mjs

@@ -0,0 +1,130 @@
+import { _ as output, f as formatDuration, g as list, h as keyValue, l as cyan, m as header, p as green, s as blankLine, t as printHelp, v as red, y as yellow } from "./cli.mjs";
+import { i as assertLocalStore, o as createStoreFromFlags, r as SHARED_FLAGS, t as LOCAL_STORE_FLAGS } from "./_shared-CgcKJJFf.mjs";
+
+//#region src/cmd/store/mirror.ts
+async function runMirrorStore({ flags, versions }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Mirror Unicode data files to local storage",
+			commandName: "ucd store mirror",
+			usage: "[...versions] [...flags]",
+			tables: { Flags: [
+				...LOCAL_STORE_FLAGS,
+				...SHARED_FLAGS,
+				["--concurrency", "Maximum concurrent downloads (default: 5)."],
+				["--json", "Output mirror results in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	assertLocalStore(flags);
+	const { storeDir, baseUrl, include: patterns, exclude: excludePatterns, force, concurrency = 5, json } = flags;
+	const store = await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote: false,
+		include: patterns,
+		exclude: excludePatterns,
+		versions,
+		force,
+		requireExistingStore: true,
+		versionStrategy: "merge"
+	});
+	if (!json) {
+		header("Mirror Operation");
+		keyValue("Store Path", storeDir, { valueColor: cyan });
+		if (versions.length > 0) keyValue("Versions", versions.map((v) => cyan(v)).join(", "));
+		else keyValue("Versions", "all versions in lockfile");
+		blankLine();
+	}
+	const [mirrorResult, mirrorError] = await store.mirror({
+		versions: versions.length > 0 ? versions : void 0,
+		force,
+		concurrency,
+		filters: {
+			include: patterns,
+			exclude: excludePatterns
+		}
+	});
+	if (mirrorError) {
+		if (json) output.errorJson({
+			type: "MIRROR_FAILED",
+			message: "Mirror operation failed",
+			details: { reason: mirrorError.message }
+		});
+		else output.fail("Mirror operation failed", { details: [mirrorError.message] });
+		return;
+	}
+	if (!mirrorResult) {
+		if (json) output.errorJson({
+			type: "NO_RESULT",
+			message: "Mirror operation returned no result"
+		});
+		else output.fail("Mirror operation returned no result");
+		return;
+	}
+	if (json) {
+		const jsonOutput = {
+			success: true,
+			storeDir,
+			versions: versions.length > 0 ? versions : Array.from(mirrorResult.versions.keys())
+		};
+		if (mirrorResult.summary) {
+			const { counts, duration, storage, metrics } = mirrorResult.summary;
+			jsonOutput.summary = {
+				versionsCount: mirrorResult.versions.size,
+				downloaded: counts.success,
+				skipped: counts.skipped,
+				failed: counts.failed,
+				totalSize: storage.totalSize,
+				successRate: metrics.successRate,
+				duration
+			};
+		}
+		if (mirrorResult.versions.size > 0) jsonOutput.versionDetails = Array.from(mirrorResult.versions.entries()).map(([version, report]) => ({
+			version,
+			downloaded: report.counts.success,
+			skipped: report.counts.skipped,
+			failed: report.counts.failed,
+			errors: report.errors.map((e) => ({
+				filePath: e.filePath,
+				reason: e.reason
+			}))
+		}));
+		output.json(jsonOutput);
+		return;
+	}
+	output.success("Mirror operation completed");
+	if (mirrorResult.summary) {
+		const { counts, duration, storage, metrics } = mirrorResult.summary;
+		header("Summary");
+		keyValue("Versions", String(mirrorResult.versions.size));
+		keyValue("Downloaded", `${green(String(counts.success))} files`);
+		keyValue("Skipped", `${yellow(String(counts.skipped))} files`);
+		if (counts.failed > 0) keyValue("Failed", `${red(String(counts.failed))} files`);
+		keyValue("Total Size", storage.totalSize);
+		keyValue("Success Rate", `${metrics.successRate.toFixed(1)}%`);
+		keyValue("Duration", formatDuration(duration));
+	}
+	if (mirrorResult.versions.size > 1) {
+		header("Version Details");
+		for (const [version, report] of mirrorResult.versions) {
+			output.log(`  ${cyan(version)}`);
+			output.log(`    Downloaded: ${green(String(report.counts.success))}, Skipped: ${yellow(String(report.counts.skipped))}`);
+			if (report.counts.failed > 0) {
+				output.log(`    ${red(`Failed: ${report.counts.failed}`)}`);
+				list(report.errors.slice(0, 3).map((e) => `${e.filePath}: ${e.reason}`), {
+					indent: 4,
+					prefix: "-"
+				});
+				if (report.errors.length > 3) output.log(`      ... and ${report.errors.length - 3} more errors`);
+			}
+			blankLine();
+		}
+	}
+	blankLine();
+}
+
+//#endregion
+export { runMirrorStore };

package/dist/root-BnOeYqGP.mjs

@@ -0,0 +1,57 @@
+import { t as printHelp } from "./cli.mjs";
+
+//#region src/cmd/lockfile/root.ts
+const LOCKFILE_SUBCOMMANDS = [
+	"info",
+	"hash",
+	"validate"
+];
+function isValidSubcommand(subcommand) {
+	return LOCKFILE_SUBCOMMANDS.includes(subcommand);
+}
+async function runLockfileRoot(subcommand, { flags }) {
+	const isValidSub = isValidSubcommand(subcommand);
+	const requestsHelp = flags?.help || flags?.h;
+	if (!isValidSub || requestsHelp && !isValidSub) {
+		printHelp({
+			commandName: "ucd lockfile",
+			usage: "[command] [...flags]",
+			tables: {
+				Commands: [
+					["info", "Display lockfile information and summary."],
+					["validate", "Validate lockfile against the expected schema."],
+					["hash", "Compute content hash for a file (useful for debugging)."]
+				],
+				Flags: [
+					["--store-dir", "Directory where the UCD store is located."],
+					["--json", "Output in JSON format."],
+					["--help (-h)", "See all available flags."]
+				]
+			}
+		});
+		return;
+	}
+	if (subcommand === "info") {
+		const { runLockfileInfo } = await import("./info-D2uPOmns.mjs");
+		await runLockfileInfo({ flags });
+		return;
+	}
+	if (subcommand === "hash") {
+		const { runLockfileHash } = await import("./hash-BAViT6QD.mjs");
+		const pathParts = flags._.slice(2);
+		await runLockfileHash({
+			filePath: pathParts.length > 0 ? pathParts.join(" ") : "",
+			flags
+		});
+		return;
+	}
+	if (subcommand === "validate") {
+		const { runLockfileValidate } = await import("./validate-DVr1TaHK.mjs");
+		await runLockfileValidate({ flags });
+		return;
+	}
+	throw new Error(`Invalid subcommand: ${subcommand}`);
+}
+
+//#endregion
+export { runLockfileRoot };

package/dist/root-C_Ycy7kI.mjs

@@ -0,0 +1,88 @@
+import { t as printHelp } from "./cli.mjs";
+
+//#region src/cmd/store/root.ts
+const STORE_SUBCOMMANDS = [
+	"init",
+	"sync",
+	"mirror",
+	"verify",
+	"analyze",
+	"status"
+];
+function isValidSubcommand(subcommand) {
+	return STORE_SUBCOMMANDS.includes(subcommand);
+}
+async function runStoreRoot(subcommand, { flags }) {
+	const isValidSub = isValidSubcommand(subcommand);
+	const requestsHelp = flags?.help || flags?.h;
+	if (!isValidSub || requestsHelp && !isValidSub) {
+		printHelp({
+			commandName: "ucd store",
+			usage: "[command] [...flags]",
+			tables: {
+				"Commands (local store only)": [
+					["init", "Initialize an UCD Store (create lockfile and download files)."],
+					["sync", "Sync files to match lockfile state (download missing, optionally remove orphaned)."],
+					["mirror", "Download Unicode data files to local storage."]
+				],
+				"Commands (local or remote)": [
+					["verify", "Verify store integrity against API."],
+					["analyze", "Analyze store contents and file status."],
+					["status", "Show store status and version information."]
+				],
+				"Flags": [["--force", "Force operation (command-specific behavior)."], ["--help (-h)", "See all available flags."]]
+			}
+		});
+		return;
+	}
+	const versions = flags._.slice(2);
+	if (subcommand === "init") {
+		const { runInitStore } = await import("./init-DilsO33p.mjs");
+		await runInitStore({
+			versions,
+			flags
+		});
+		return;
+	}
+	if (subcommand === "sync") {
+		const { runSyncStore } = await import("./sync-DEtQ-jZc.mjs");
+		await runSyncStore({
+			flags,
+			versions
+		});
+		return;
+	}
+	if (subcommand === "mirror") {
+		const { runMirrorStore } = await import("./mirror-DLYQGa33.mjs");
+		await runMirrorStore({
+			flags,
+			versions
+		});
+		return;
+	}
+	if (subcommand === "verify") {
+		const { runVerifyStore } = await import("./verify-ME4bDNIT.mjs");
+		await runVerifyStore({
+			flags,
+			versions
+		});
+		return;
+	}
+	if (subcommand === "analyze") {
+		const { runAnalyzeStore } = await import("./analyze-D8AeAGDR.mjs");
+		await runAnalyzeStore({
+			flags,
+			versions
+		});
+		return;
+	}
+	if (subcommand === "status") {
+		const { runStatusStore } = await import("./status-DI1HruH0.mjs");
+		await runStatusStore({ flags });
+		return;
+	}
+	throw new Error(`Invalid subcommand: ${subcommand}`);
+}
+
+//#endregion
+export { runStoreRoot };

package/dist/{root-jW0s7hem.js → root-CfALAyOQ.mjs}

@@ -1,4 +1,4 @@
-import { t as printHelp } from "./cli-utils-dAbyq59_.js";
+import { t as printHelp } from "./cli.mjs";
 
 //#region src/cmd/codegen/root.ts
 const CODEGEN_SUBCOMMANDS = ["fields"];
@@ -6,7 +6,9 @@ function isValidSubcommand(subcommand) {
 	return CODEGEN_SUBCOMMANDS.includes(subcommand);
 }
 async function runCodegenRoot(subcommand, { flags }) {
-	if (!isValidSubcommand(subcommand) || !isValidSubcommand(subcommand) && (flags?.help || flags?.h)) {
+	const isValidSub = isValidSubcommand(subcommand);
+	const requestsHelp = flags?.help || flags?.h;
+	if (!isValidSub || requestsHelp && !isValidSub) {
 		printHelp({
 			commandName: "ucd codegen",
 			usage: "[command] [...flags]",
@@ -18,7 +20,7 @@ async function runCodegenRoot(subcommand, { flags }) {
 		return;
 	}
 	if (subcommand === "fields") {
-		const { runFieldCodegen } = await import("./fields-CbRX6M6H.js");
+		const { runFieldCodegen } = await import("./fields-BvLDPLGg.mjs");
 		await runFieldCodegen({
 			inputPath: flags._.slice(4)?.toString() ?? "",
 			flags

package/dist/root-DXVHyPa6.mjs

@@ -0,0 +1,61 @@
+import { t as printHelp } from "./cli.mjs";
+
+//#region src/cmd/files/root.ts
+const FILES_SUBCOMMANDS = [
+	"list",
+	"get",
+	"info"
+];
+function isValidSubcommand(subcommand) {
+	return FILES_SUBCOMMANDS.includes(subcommand);
+}
+async function runFilesRoot(subcommand, { flags }) {
+	const isValidSub = isValidSubcommand(subcommand);
+	const requestsHelp = flags?.help || flags?.h;
+	if (!isValidSub || requestsHelp && !isValidSub) {
+		printHelp({
+			commandName: "ucd files",
+			usage: "[command] [...flags]",
+			tables: {
+				Commands: [
+					["list", "List files and directories from the UCD API."],
+					["get", "Get a specific file from the UCD API."],
+					["info", "Get metadata about a file or directory."]
+				],
+				Flags: [["--base-url", "Base URL for the UCD API (defaults to api.ucdjs.dev)."], ["--help (-h)", "See all available flags."]]
+			}
+		});
+		return;
+	}
+	if (subcommand === "list") {
+		const { runFilesList } = await import("./list-C1bd3Vq4.mjs");
+		const pathParts = flags._.slice(2);
+		await runFilesList({
+			path: pathParts.length > 0 ? pathParts.join(" ") : "",
+			flags
+		});
+		return;
+	}
+	if (subcommand === "get") {
+		const { runFilesGet } = await import("./get-CHw5s5Ab.mjs");
+		const pathParts = flags._.slice(2);
+		await runFilesGet({
+			path: pathParts.length > 0 ? pathParts.join(" ") : "",
+			flags
+		});
+		return;
+	}
+	if (subcommand === "info") {
+		const { runFilesInfo } = await import("./info-ZGysg0N_.mjs");
+		const pathParts = flags._.slice(2);
+		await runFilesInfo({
+			path: pathParts.length > 0 ? pathParts.join(" ") : "",
+			flags
+		});
+		return;
+	}
+	throw new Error(`Invalid subcommand: ${subcommand}`);
+}
+
+//#endregion
+export { runFilesRoot };

package/dist/status-DI1HruH0.mjs

@@ -0,0 +1,136 @@
+import { _ as output, p as green, t as printHelp, v as red, y as yellow } from "./cli.mjs";
+import { a as assertRemoteOrStoreDir, n as REMOTE_CAPABLE_FLAGS, o as createStoreFromFlags, r as SHARED_FLAGS } from "./_shared-CgcKJJFf.mjs";
+import { createUCDClient } from "@ucdjs/client";
+import { UCDJS_API_BASE_URL } from "@ucdjs/env";
+import { createDebugger } from "@ucdjs-internal/shared";
+import { getLockfilePath, readLockfile, readSnapshotOrUndefined } from "@ucdjs/lockfile";
+
+//#region src/cmd/store/status.ts
+const debug = createDebugger("ucdjs:cli:store:status");
+async function runStatusStore({ flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Show UCD Store status and lockfile information",
+			commandName: "ucd store status",
+			usage: "[...flags]",
+			tables: { Flags: [
+				...REMOTE_CAPABLE_FLAGS,
+				...SHARED_FLAGS,
+				["--json", "Output status information in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	assertRemoteOrStoreDir(flags);
+	const { storeDir, remote, baseUrl, json } = flags;
+	const client = await createUCDClient(baseUrl || UCDJS_API_BASE_URL);
+	const configResult = await client.config.get();
+	let availableVersions = [];
+	if (configResult.error || !configResult.data) {
+		const apiResult = await client.versions.list();
+		if (apiResult.error) output.warn(yellow(`Warning: Could not fetch versions from API: ${apiResult.error.message}`));
+		else if (apiResult.data) availableVersions = apiResult.data.map(({ version }) => version);
+	} else {
+		availableVersions = configResult.data.versions ?? [];
+		if (availableVersions.length === 0) {
+			const apiResult = await client.versions.list();
+			if (apiResult.error) output.warn(yellow(`Warning: Could not fetch versions from API: ${apiResult.error.message}`));
+			else if (apiResult.data) availableVersions = apiResult.data.map(({ version }) => version);
+		}
+	}
+	if (remote) {
+		if (json) {
+			output.json({
+				type: "remote",
+				baseUrl: baseUrl || UCDJS_API_BASE_URL,
+				availableVersions,
+				totalVersions: availableVersions.length
+			});
+			return;
+		}
+		output.log(`Store Status: Remote (${baseUrl || UCDJS_API_BASE_URL})`);
+		output.log(`  Available Versions: ${availableVersions.length}`);
+		output.log("");
+		for (const version of availableVersions.sort((a, b) => b.localeCompare(a))) output.log(`  ${green("✓")} ${version}`);
+		return;
+	}
+	if (!storeDir) {
+		output.error(red(`\n❌ Error: Store directory must be specified.`));
+		return;
+	}
+	const store = await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote,
+		requireExistingStore: true
+	});
+	const lockfilePath = getLockfilePath();
+	const bridge = store.fs;
+	let lockfile;
+	try {
+		lockfile = await readLockfile(bridge, lockfilePath);
+	} catch (err) {
+		debug?.("Error reading lockfile:", err);
+		output.error(red(`\n❌ Error: Lockfile not found at ${lockfilePath}`));
+		output.error("Run 'ucd store init' to create a new store.");
+		return;
+	}
+	const availableVersionsSet = new Set(availableVersions);
+	const lockfileVersions = Object.keys(lockfile.versions);
+	const versionStatuses = await Promise.all(lockfileVersions.map(async (version) => {
+		return {
+			version,
+			entry: lockfile.versions[version],
+			hasSnapshot: await readSnapshotOrUndefined(bridge, version) !== void 0,
+			isAvailableInAPI: availableVersionsSet.has(version)
+		};
+	}));
+	const mirroredCount = versionStatuses.filter((s) => s.hasSnapshot).length;
+	const availableCount = versionStatuses.filter((s) => s.isAvailableInAPI).length;
+	if (json) {
+		output.json({
+			storePath: storeDir,
+			lockfilePath,
+			lockfileVersion: lockfile.lockfileVersion,
+			totalVersions: lockfileVersions.length,
+			versions: versionStatuses.map((s) => ({
+				version: s.version,
+				snapshotPath: s.entry?.path,
+				fileCount: s.entry?.fileCount,
+				totalSize: s.entry?.totalSize,
+				mirrored: s.hasSnapshot,
+				availableInAPI: s.isAvailableInAPI
+			})),
+			summary: {
+				mirrored: mirroredCount,
+				availableInAPI: availableCount,
+				total: lockfileVersions.length
+			}
+		});
+		return;
+	}
+	output.log(`Store Status: ${storeDir}`);
+	output.log(`  Lockfile: ${lockfilePath}`);
+	output.log(`  Lockfile Version: ${lockfile.lockfileVersion}`);
+	output.log(`  Total Versions: ${lockfileVersions.length}`);
+	output.log("");
+	for (const status of versionStatuses.sort((a, b) => a.version.localeCompare(b.version))) {
+		const { version, entry, hasSnapshot, isAvailableInAPI } = status;
+		const statusIcon = hasSnapshot ? green("✓") : yellow("⚠");
+		const apiIcon = isAvailableInAPI ? green("✓") : red("✗");
+		output.log(`  Version ${version}:`);
+		output.log(`    Snapshot: ${entry?.path}`);
+		output.log(`    Status: ${statusIcon} ${hasSnapshot ? "Mirrored" : "Not mirrored"}`);
+		output.log(`    Files: ${entry?.fileCount}`);
+		output.log(`    Size: ${((entry?.totalSize ?? 0) / 1024 / 1024).toFixed(2)} MB`);
+		output.log(`    API: ${apiIcon} ${isAvailableInAPI ? "Available" : "Not available"}`);
+		output.log("");
+	}
+	output.log("  Summary:");
+	output.log(`    Mirrored: ${mirroredCount}/${lockfileVersions.length} versions`);
+	output.log(`    Available in API: ${availableCount}/${lockfileVersions.length} versions`);
+}
+
+//#endregion
+export { runStatusStore };

package/dist/sync-DEtQ-jZc.mjs

@@ -0,0 +1,160 @@
+import { _ as output, f as formatDuration, g as list, h as keyValue, l as cyan, m as header, p as green, s as blankLine, t as printHelp, v as red, y as yellow } from "./cli.mjs";
+import { i as assertLocalStore, o as createStoreFromFlags, r as SHARED_FLAGS, t as LOCAL_STORE_FLAGS } from "./_shared-CgcKJJFf.mjs";
+
+//#region src/cmd/store/sync.ts
+async function runSyncStore({ flags, versions }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Sync lockfile with API and mirror files",
+			commandName: "ucd store sync",
+			usage: "[...versions] [...flags]",
+			tables: { Flags: [
+				...LOCAL_STORE_FLAGS,
+				...SHARED_FLAGS,
+				["--concurrency", "Maximum concurrent downloads (default: 5)."],
+				["--remove-unavailable", "Remove versions from lockfile that are not available in API."],
+				["--clean", "Remove orphaned files (files not in expected files list)."],
+				["--json", "Output sync results in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	assertLocalStore(flags);
+	const { storeDir, baseUrl, include: patterns, exclude: excludePatterns, force, concurrency = 5, removeUnavailable, clean, json } = flags;
+	const store = await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote: false,
+		include: patterns,
+		exclude: excludePatterns,
+		versions,
+		force,
+		requireExistingStore: true,
+		versionStrategy: "merge"
+	});
+	if (!json) {
+		header("Sync Operation");
+		keyValue("Store Path", storeDir, { valueColor: cyan });
+		if (versions.length > 0) keyValue("Versions", versions.map((v) => cyan(v)).join(", "));
+		else keyValue("Versions", "all versions in lockfile");
+		blankLine();
+	}
+	const [syncResult, syncError] = await store.sync({
+		versions: versions.length > 0 ? versions : void 0,
+		force,
+		concurrency,
+		removeUnavailable,
+		cleanOrphaned: clean,
+		filters: {
+			include: patterns,
+			exclude: excludePatterns
+		}
+	});
+	if (syncError) {
+		if (json) output.errorJson({
+			type: "SYNC_FAILED",
+			message: "Sync operation failed",
+			details: { reason: syncError.message }
+		});
+		else output.fail("Sync operation failed", { details: [syncError.message] });
+		return;
+	}
+	if (!syncResult) {
+		if (json) output.errorJson({
+			type: "NO_RESULT",
+			message: "Sync operation returned no result"
+		});
+		else output.fail("Sync operation returned no result");
+		return;
+	}
+	if (json) {
+		const jsonOutput = {
+			success: true,
+			storeDir,
+			lockfileChanges: {
+				added: syncResult.added,
+				removed: syncResult.removed,
+				unchanged: syncResult.unchanged,
+				totalVersions: syncResult.versions.length
+			}
+		};
+		if (syncResult.mirrorReport?.summary) {
+			const { counts, duration, storage } = syncResult.mirrorReport.summary;
+			jsonOutput.mirrorSummary = {
+				versionsCount: syncResult.mirrorReport.versions.size,
+				downloaded: counts.success,
+				skipped: counts.skipped,
+				failed: counts.failed,
+				totalSize: storage.totalSize,
+				duration
+			};
+		}
+		if (syncResult.removedFiles.size > 0) jsonOutput.orphanedFilesRemoved = Array.from(syncResult.removedFiles.entries()).map(([version, files]) => ({
+			version,
+			files
+		}));
+		output.json(jsonOutput);
+		return;
+	}
+	output.success("Sync completed");
+	if (syncResult.added.length > 0 || syncResult.removed.length > 0 || syncResult.unchanged.length > 0) {
+		header("Lockfile Changes");
+		if (syncResult.added.length > 0) {
+			keyValue("Added", `${green(String(syncResult.added.length))} version(s)`);
+			list(syncResult.added, {
+				prefix: "+",
+				itemColor: green,
+				indent: 4
+			});
+		}
+		if (syncResult.removed.length > 0) {
+			keyValue("Removed", `${yellow(String(syncResult.removed.length))} version(s)`);
+			list(syncResult.removed, {
+				prefix: "-",
+				itemColor: yellow,
+				indent: 4
+			});
+		}
+		if (syncResult.unchanged.length > 0) keyValue("Unchanged", `${syncResult.unchanged.length} version(s)`);
+	}
+	keyValue("Total Versions", String(syncResult.versions.length));
+	if (syncResult.mirrorReport) {
+		const report = syncResult.mirrorReport;
+		if (report.summary) {
+			const { counts, duration, storage } = report.summary;
+			header("Mirror Summary");
+			keyValue("Versions", String(report.versions.size));
+			keyValue("Downloaded", `${green(String(counts.success))} files`);
+			keyValue("Skipped", `${yellow(String(counts.skipped))} files`);
+			if (counts.failed > 0) keyValue("Failed", `${red(String(counts.failed))} files`);
+			keyValue("Total Size", storage.totalSize);
+			keyValue("Duration", formatDuration(duration));
+		}
+		if (report.versions.size > 1) {
+			header("Version Details");
+			for (const [version, versionReport] of report.versions) {
+				output.log(`  ${cyan(version)}`);
+				output.log(`    Downloaded: ${green(String(versionReport.counts.success))}, Skipped: ${yellow(String(versionReport.counts.skipped))}`);
+				if (versionReport.counts.failed > 0) output.log(`    ${red(`Failed: ${versionReport.counts.failed}`)}`);
+				blankLine();
+			}
+		}
+	}
+	if (syncResult.removedFiles.size > 0) {
+		header("Orphaned Files Removed");
+		for (const [version, removedFiles] of syncResult.removedFiles) if (removedFiles.length > 0) {
+			output.log(`  ${cyan(version)}`);
+			list(removedFiles, {
+				prefix: "-",
+				indent: 4,
+				itemColor: yellow
+			});
+			blankLine();
+		}
+	} else if (clean) output.success("No orphaned files found");
+	blankLine();
+}
+
+//#endregion
+export { runSyncStore };