@ucdjs/cli 0.3.0 → 0.3.1-beta.2

package/dist/validate-DVr1TaHK.mjs

@@ -0,0 +1,114 @@
+import { _ as output, c as bold, p as green, t as printHelp, u as dim, v as red, y as yellow } from "./cli.mjs";
+import process from "node:process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { safeJsonParse } from "@ucdjs-internal/shared";
+import { getLockfilePath, validateLockfile } from "@ucdjs/lockfile";
+
+//#region src/cmd/lockfile/validate.ts
+async function runLockfileValidate({ flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Validate lockfile against the expected schema",
+			commandName: "ucd lockfile validate",
+			usage: "[...flags]",
+			description: "Parse and validate the UCD store lockfile, reporting any schema violations or structural issues.",
+			tables: { Flags: [
+				["--store-dir", "Directory where the UCD store is located (defaults to current directory)."],
+				["--json", "Output validation results as JSON."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const { storeDir, json } = flags;
+	const lockfilePath = resolve(storeDir ? resolve(storeDir) : process.cwd(), getLockfilePath());
+	try {
+		let rawContent;
+		try {
+			rawContent = await readFile(lockfilePath, "utf-8");
+		} catch {
+			if (json) output.json({
+				valid: false,
+				lockfilePath,
+				error: "LOCKFILE_NOT_FOUND",
+				message: `Lockfile not found at "${lockfilePath}"`
+			});
+			else {
+				output.error(red(`\n❌ Error: Lockfile not found at "${lockfilePath}".`));
+				output.error(`\n  Run ${green("ucd store init")} to create a new store.`);
+			}
+			return;
+		}
+		const jsonData = safeJsonParse(rawContent);
+		if (!jsonData) {
+			if (json) output.json({
+				valid: false,
+				lockfilePath,
+				error: "INVALID_JSON",
+				message: "Lockfile is not valid JSON"
+			});
+			else {
+				output.error(red(`\n❌ Validation failed: Lockfile is not valid JSON.`));
+				output.error(`  ${dim(`Path: ${lockfilePath}`)}`);
+			}
+			return;
+		}
+		const result = validateLockfile(jsonData);
+		if (!result.valid) {
+			const issues = result.errors ?? [];
+			if (json) output.json({
+				valid: false,
+				lockfilePath,
+				error: "SCHEMA_VALIDATION_FAILED",
+				issues
+			});
+			else {
+				output.error(red(`\n❌ Validation failed: Lockfile does not match expected schema.`));
+				output.error(`  ${dim(`Path: ${lockfilePath}`)}\n`);
+				output.log(`  ${bold("Issues:")}`);
+				for (const issue of issues) output.log(`    ${yellow("•")} ${bold(issue.path || "(root)")}: ${issue.message}`);
+			}
+			return;
+		}
+		const warnings = [];
+		const lockfile = result.data;
+		const versionCount = Object.keys(lockfile.versions).length;
+		if (versionCount === 0) warnings.push("Lockfile has no versions tracked.");
+		for (const [version, entry] of Object.entries(lockfile.versions)) {
+			if (entry.fileCount === 0) warnings.push(`Version "${version}" has 0 files.`);
+			if (entry.totalSize === 0 && entry.fileCount > 0) warnings.push(`Version "${version}" has files but totalSize is 0.`);
+		}
+		if (json) output.json({
+			valid: true,
+			lockfilePath,
+			lockfileVersion: lockfile.lockfileVersion,
+			versionCount,
+			warnings: warnings.length > 0 ? warnings : void 0
+		});
+		else {
+			output.log(green(`\n✅ Lockfile is valid.`));
+			output.log(`  ${dim(`Path: ${lockfilePath}`)}`);
+			output.log(`  ${bold("Lockfile Version:")} ${lockfile.lockfileVersion}`);
+			output.log(`  ${bold("Tracked Versions:")} ${versionCount}`);
+			if (warnings.length > 0) {
+				output.log(`\n  ${yellow(bold("Warnings:"))}`);
+				for (const warning of warnings) output.log(`    ${yellow("•")} ${warning}`);
+			}
+		}
+	} catch (err) {
+		if (json) output.json({
+			valid: false,
+			lockfilePath,
+			error: "UNKNOWN_ERROR",
+			message: err instanceof Error ? err.message : String(err)
+		});
+		else {
+			output.error(red(`\n❌ Validation error:`));
+			if (err instanceof Error) output.error(`  ${err.message}`);
+		}
+	}
+}
+
+//#endregion
+export { runLockfileValidate };

package/dist/verify-ME4bDNIT.mjs

@@ -0,0 +1,114 @@
+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 } from "@ucdjs/lockfile";
+
+//#region src/cmd/store/verify.ts
+const debug = createDebugger("ucdjs:cli:store:verify");
+async function runVerifyStore({ flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Verify UCD Store integrity",
+			commandName: "ucd store verify",
+			usage: "[...versions] [...flags]",
+			tables: { Flags: [
+				...REMOTE_CAPABLE_FLAGS,
+				...SHARED_FLAGS,
+				["--json", "Output verification results in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const { storeDir, remote, baseUrl, include: patterns, exclude: excludePatterns, json } = flags;
+	assertRemoteOrStoreDir(flags);
+	const store = await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote,
+		include: patterns,
+		exclude: excludePatterns,
+		requireExistingStore: true
+	});
+	const lockfilePath = getLockfilePath();
+	const bridge = store.fs;
+	let lockfile;
+	try {
+		lockfile = await readLockfile(bridge, lockfilePath);
+	} catch (err) {
+		debug?.("Error reading lockfile:", err);
+		if (remote) {
+			output.error(red(`\n❌ Error: Could not read lockfile from remote store.`));
+			output.error("Verify operation requires a lockfile. For remote stores, the lockfile must be accessible via the API.");
+		} else {
+			output.error(red(`\n❌ Error: Lockfile not found at ${lockfilePath}`));
+			output.error("Run 'ucd store init' to create a new store.");
+		}
+		return;
+	}
+	const lockfileVersions = Object.keys(lockfile.versions);
+	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.error(red(`\n❌ Error fetching versions: ${apiResult.error.message}`));
+			return;
+		}
+		if (!apiResult.data) {
+			output.error(red(`\n❌ Error: No versions data returned from API.`));
+			return;
+		}
+		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.error(red(`\n❌ Error fetching versions: ${apiResult.error.message}`));
+				return;
+			}
+			if (!apiResult.data) {
+				output.error(red(`\n❌ Error: No versions data returned from API.`));
+				return;
+			}
+			availableVersions = apiResult.data.map(({ version }) => version);
+		}
+	}
+	const availableVersionsSet = new Set(availableVersions);
+	const lockfileVersionsSet = new Set(lockfileVersions);
+	const missingVersions = lockfileVersions.filter((v) => !availableVersionsSet.has(v));
+	const extraVersions = availableVersions.filter((v) => !lockfileVersionsSet.has(v));
+	const validVersions = lockfileVersions.filter((v) => availableVersionsSet.has(v));
+	const isValid = missingVersions.length === 0;
+	if (json) {
+		output.json({
+			valid: isValid,
+			lockfileVersions,
+			availableVersions,
+			missingVersions,
+			extraVersions,
+			validVersions
+		});
+		return;
+	}
+	if (isValid) {
+		output.log(green("\n✓ Store verification passed\n"));
+		output.log(`All ${lockfileVersions.length} version(s) in lockfile are available in API.`);
+	} else {
+		output.error(red("\n❌ Store verification failed\n"));
+		output.error(`Found ${missingVersions.length} version(s) in lockfile that are not available in API:`);
+		for (const version of missingVersions) output.error(`  - ${version}`);
+	}
+	if (extraVersions.length > 0) {
+		output.log(yellow(`\n⚠ Note: ${extraVersions.length} version(s) available in API but not in lockfile:`));
+		for (const version of extraVersions) output.log(`  + ${version}`);
+		output.log("Run 'ucd store sync' to update the lockfile.");
+	}
+}
+
+//#endregion
+export { runVerifyStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/cli",
-  "version": "0.3.0",
+  "version": "0.3.1-beta.2",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -18,12 +18,10 @@
     "url": "https://github.com/ucdjs/ucd/issues"
   },
   "exports": {
-    ".": "./dist/cli.js",
+    ".": "./dist/cli.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/cli.js",
-  "module": "./dist/cli.js",
-  "types": "./dist/cli.d.ts",
+  "types": "./dist/cli.d.mts",
   "bin": {
     "ucd": "bin/ucd.js"
   },
@@ -35,22 +33,28 @@
     "node": ">=22.18"
   },
   "dependencies": {
-    "@clack/prompts": "1.0.0-alpha.5",
-    "@luxass/utils": "2.7.2",
-    "@unicode-utils/core": "0.12.0-beta.18",
+    "@clack/prompts": "1.0.0",
+    "@luxass/utils": "2.7.3",
+    "@unicode-utils/core": "0.12.0-beta.19",
     "farver": "0.4.2",
     "yargs-parser": "22.0.0",
-    "@ucdjs/schema-gen": "0.2.2",
-    "@ucdjs/ucd-store": "0.1.0"
+    "@ucdjs-internal/shared": "0.1.1-beta.2",
+    "@ucdjs/client": "0.1.1-beta.2",
+    "@ucdjs/env": "0.1.1-beta.3",
+    "@ucdjs/lockfile": "0.1.1-beta.2",
+    "@ucdjs/fs-bridge": "0.1.1-beta.2",
+    "@ucdjs/schemas": "0.1.1-beta.2",
+    "@ucdjs/ucd-store": "1.0.1-beta.2",
+    "@ucdjs/schema-gen": "0.2.3-beta.2"
   },
   "devDependencies": {
-    "@luxass/eslint-config": "6.0.1",
+    "@luxass/eslint-config": "7.2.0",
     "@types/yargs-parser": "21.0.3",
-    "eslint": "9.38.0",
-    "publint": "0.3.15",
-    "tsdown": "0.15.9",
+    "eslint": "10.0.0",
+    "publint": "0.3.17",
+    "tsdown": "0.20.3",
     "typescript": "5.9.3",
-    "vitest-testdirs": "4.2.1",
+    "vitest-testdirs": "4.4.2",
     "@ucdjs-tooling/tsconfig": "1.0.0",
     "@ucdjs-tooling/tsdown-config": "1.0.0"
   },
@@ -62,6 +66,6 @@
     "dev": "tsdown --watch",
     "clean": "git clean -xdf dist node_modules",
     "lint": "eslint .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
   }
 }

package/dist/_shared-DlzCE5mE.js

@@ -1,59 +0,0 @@
-import { createHTTPUCDStore, createNodeUCDStore } from "@ucdjs/ucd-store";
-import { isCancel, multiselect } from "@clack/prompts";
-import { UNICODE_VERSION_METADATA } from "@unicode-utils/core";
-
-//#region src/cmd/store/_shared.ts
-const SHARED_FLAGS = [
-	["--remote", "Use a Remote UCD Store."],
-	["--store-dir", "Directory where the UCD files are stored."],
-	["--include", "Patterns to include files in the store."],
-	["--exclude", "Patterns to exclude files from the store."],
-	["--base-url", "Base URL for the UCD Store."]
-];
-function assertRemoteOrStoreDir(flags) {
-	if (!flags.remote && !flags.storeDir) throw new Error("Either --remote or --store-dir must be specified.");
-}
-/**
-* Creates a UCD store instance based on the provided CLI flags.
-*
-* @param {CLIStoreCmdSharedFlags} flags - Configuration flags for creating the store
-* @returns {Promise<UCDStore | null>} A promise that resolves to a UCDStore instance or null
-* @throws {Error} When store directory is not specified for local stores
-*/
-async function createStoreFromFlags(flags) {
-	const { storeDir, remote, baseUrl, include, exclude } = flags;
-	if (remote) return createHTTPUCDStore({
-		baseUrl,
-		globalFilters: {
-			include,
-			exclude
-		}
-	});
-	if (!storeDir) throw new Error("Store directory must be specified when not using remote store.");
-	return createNodeUCDStore({
-		basePath: storeDir,
-		baseUrl,
-		globalFilters: {
-			include,
-			exclude
-		},
-		versions: flags.versions || []
-	});
-}
-async function runVersionPrompt({ input, output } = {}) {
-	const selectedVersions = await multiselect({
-		options: UNICODE_VERSION_METADATA.map(({ version }) => ({
-			value: version,
-			label: version
-		})),
-		message: "Select Unicode versions to initialize the store with:",
-		required: true,
-		input,
-		output
-	});
-	if (isCancel(selectedVersions)) return [];
-	return selectedVersions;
-}
-
-//#endregion
-export { runVersionPrompt as i, assertRemoteOrStoreDir as n, createStoreFromFlags as r, SHARED_FLAGS as t };

package/dist/analyze-C7RthxQg.js

@@ -1,78 +0,0 @@
-import { t as printHelp } from "./cli-utils-dAbyq59_.js";
-import { n as assertRemoteOrStoreDir, r as createStoreFromFlags, t as SHARED_FLAGS } from "./_shared-DlzCE5mE.js";
-import { green, red } from "farver/fast";
-import { UCDStoreUnsupportedFeature } from "@ucdjs/ucd-store";
-
-//#region src/cmd/store/analyze.ts
-async function runAnalyzeStore({ flags, versions }) {
-	if (flags?.help || flags?.h) {
-		printHelp({
-			headline: "Analyze UCD Store",
-			commandName: "ucd store analyze",
-			usage: "[...versions] [...flags]",
-			tables: { Flags: [
-				...SHARED_FLAGS,
-				["--check-orphaned", "Check for orphaned files in the store."],
-				["--json", "Output analyze information in JSON format."],
-				["--help (-h)", "See all available flags."]
-			] }
-		});
-		return;
-	}
-	if (!versions || versions.length === 0) console.info("No specific versions provided. Analyzing all versions in the store.");
-	const { storeDir, json, remote, baseUrl, include: patterns, checkOrphaned } = flags;
-	try {
-		assertRemoteOrStoreDir(flags);
-		const store = await createStoreFromFlags({
-			baseUrl,
-			storeDir,
-			remote,
-			include: patterns
-		});
-		if (store == null) {
-			console.error("Error: Failed to create UCD store.");
-			return;
-		}
-		const [analyzeData, analyzeError] = await store.analyze({
-			checkOrphaned: !!checkOrphaned,
-			versions: versions || []
-		});
-		if (analyzeError != null) {
-			console.error(red(`\n❌ Error analyzing store:`));
-			console.error(`  ${analyzeError.message}`);
-			return;
-		}
-		if (json) {
-			console.info(JSON.stringify(analyzeData, null, 2));
-			return;
-		}
-		for (const { version, fileCount, isComplete, missingFiles, orphanedFiles, expectedFileCount } of analyzeData) {
-			console.info(`Version: ${version}`);
-			if (isComplete) console.info(`  Status: ${green("complete")}`);
-			else console.warn(`  Status: ${red("incomplete")}`);
-			console.info(`  Files: ${fileCount}`);
-			if (missingFiles && missingFiles.length > 0) console.warn(`  Missing files: ${missingFiles.length}`);
-			if (orphanedFiles && orphanedFiles.length > 0) console.warn(`  Orphaned files: ${orphanedFiles.length}`);
-			if (expectedFileCount) console.info(`  Total files expected: ${expectedFileCount}`);
-		}
-	} catch (err) {
-		if (err instanceof UCDStoreUnsupportedFeature) {
-			console.error(red(`\n❌ Error: Unsupported feature:`));
-			console.error(`  ${err.message}`);
-			console.error("");
-			console.error("This store does not support the analyze operation.");
-			console.error("Please check the store capabilities or use a different store type.");
-			return;
-		}
-		let message = "Unknown error";
-		if (err instanceof Error) message = err.message;
-		else if (typeof err === "string") message = err;
-		console.error(red(`\n❌ Error analyzing store:`));
-		console.error(`  ${message}`);
-		console.error("Please check the store configuration and try again.");
-		console.error("If you believe this is a bug, please report it at https://github.com/ucdjs/ucd/issues");
-	}
-}
-
-//#endregion
-export { runAnalyzeStore };

package/dist/clean-Dm8LIgdA.js

@@ -1,23 +0,0 @@
-import { t as printHelp } from "./cli-utils-dAbyq59_.js";
-import { t as SHARED_FLAGS } from "./_shared-DlzCE5mE.js";
-
-//#region src/cmd/store/clean.ts
-async function runCleanStore({ flags }) {
-	if (flags?.help || flags?.h) {
-		printHelp({
-			headline: "Clean an UCD Store",
-			commandName: "ucd store clean",
-			usage: "[...flags]",
-			tables: { Flags: [
-				...SHARED_FLAGS,
-				["--dry-run", "Show what would be deleted without actually deleting."],
-				["--help (-h)", "See all available flags."]
-			] }
-		});
-		return;
-	}
-	const { storeDir, dryRun, remote, baseUrl, include: patterns } = flags;
-}
-
-//#endregion
-export { runCleanStore };

package/dist/cli-utils-dAbyq59_.js

@@ -1,129 +0,0 @@
-import process from "node:process";
-import { bgGreen, black, bold, dim, green } from "farver/fast";
-import yargs from "yargs-parser";
-
-//#region package.json
-var version = "0.3.0";
-
-//#endregion
-//#region src/cli-utils.ts
-const SUPPORTED_COMMANDS = new Set(["codegen", "store"]);
-/**
-* Resolves the CLI command based on the provided arguments.
-*
-* If the `version` flag is present, it returns the "version" command.
-* Otherwise, it checks if the third argument in the positional arguments (`flags._[2]`)
-* is a supported command. If it is, it returns that command.
-* If no supported command is found, it defaults to the "help" command.
-*
-* @param {Arguments} flags - The parsed arguments from the command line.
-* @returns {CLICommand} The resolved CLI command.
-*/
-function resolveCommand(flags) {
-	if (flags.version) return "version";
-	const cmd = flags._[0];
-	if (SUPPORTED_COMMANDS.has(cmd)) return cmd;
-	return "help";
-}
-function printHelp({ commandName, headline, usage, tables, description }) {
-	const isTinyTerminal = (process.stdout.columns || 80) < 60;
-	const indent = "  ";
-	const linebreak = () => "";
-	const table = (rows, { padding }) => {
-		let raw = "";
-		for (const [command, help] of rows) if (isTinyTerminal) raw += `${indent}${indent}${bold(command)}\n${indent}${indent}${indent}${dim(help)}\n`;
-		else {
-			const paddedCommand = command.padEnd(padding);
-			raw += `${indent}${indent}${bold(paddedCommand)}  ${dim(help)}\n`;
-		}
-		return raw.slice(0, -1);
-	};
-	const message = [];
-	if (headline) message.push(`\n${indent}${bgGreen(black(` ${commandName} `))} ${green(`v${version ?? "0.0.0"}`)}`, `${indent}${dim(headline)}`);
-	if (usage) message.push(linebreak(), `${indent}${bold("USAGE")}`, `${indent}${indent}${green(commandName)} ${usage}`);
-	if (description) message.push(linebreak(), `${indent}${bold("DESCRIPTION")}`, `${indent}${indent}${description}`);
-	if (tables) {
-		function calculateTablePadding(rows) {
-			const maxLength = rows.reduce((val, [first]) => Math.max(val, first.length), 0);
-			return Math.min(maxLength, 30) + 2;
-		}
-		const tableEntries = Object.entries(tables);
-		for (const [tableTitle, tableRows] of tableEntries) {
-			const padding = calculateTablePadding(tableRows);
-			message.push(linebreak(), `${indent}${bold(tableTitle.toUpperCase())}`, table(tableRows, { padding }));
-		}
-	}
-	message.push(linebreak(), `${indent}${dim(`Run with --help for more information on specific commands.`)}`);
-	console.log(`${message.join("\n")}\n`);
-}
-/**
-* Runs a command based on the provided CLI command and flags.
-*
-* @param {CLICommand} cmd - The CLI command to execute.
-* @param {Arguments} flags - The flags passed to the command.
-* @returns {Promise<void>} A promise that resolves when the command has finished executing.
-* @throws An error if the command is not found.
-*/
-async function runCommand(cmd, flags) {
-	switch (cmd) {
-		case "help":
-			printHelp({
-				commandName: "ucd",
-				headline: "A CLI for working with the Unicode Character Database (UCD).",
-				usage: "[command] [...flags]",
-				tables: {
-					"Commands": [["download", "Download Unicode data files."], ["codegen", "Generate TypeScript code from UCD data."]],
-					"Global Flags": [
-						["--force", "Force the operation to run, even if it's not needed."],
-						["--version", "Show the version number and exit."],
-						["--help", "Show this help message."]
-					]
-				}
-			});
-			break;
-		case "version":
-			console.log(`  ${bgGreen(black(` ucd `))} ${green(`v${version ?? "x.y.z"}`)}`);
-			break;
-		case "codegen": {
-			const { runCodegenRoot } = await import("./root-jW0s7hem.js");
-			await runCodegenRoot(flags._[1]?.toString() ?? "", { flags });
-			break;
-		}
-		case "store": {
-			const { runStoreRoot } = await import("./root-D1JJ1qhM.js");
-			await runStoreRoot(flags._[1]?.toString() ?? "", { flags });
-			break;
-		}
-		default: throw new Error(`Error running ${cmd} -- no command found.`);
-	}
-}
-function parseFlags(args) {
-	return yargs(args, {
-		configuration: { "parse-positional-numbers": false },
-		default: { force: false },
-		boolean: [
-			"force",
-			"help",
-			"h",
-			"dry-run"
-		],
-		string: [
-			"output-dir",
-			"input-dir",
-			"output-file"
-		]
-	});
-}
-async function runCLI(args) {
-	try {
-		const flags = parseFlags(args);
-		process.title = "ucd-cli";
-		await runCommand(resolveCommand(flags), flags);
-	} catch (err) {
-		console.error(err);
-		process.exit(1);
-	}
-}
-
-//#endregion
-export { runCLI as n, printHelp as t };

package/dist/cli.js

@@ -1,8 +0,0 @@
-import { n as runCLI } from "./cli-utils-dAbyq59_.js";
-import process from "node:process";
-
-//#region src/cli.ts
-runCLI(process.argv.slice(2));
-
-//#endregion
-export {  };

package/dist/init-D0yQAcdC.js

@@ -1,75 +0,0 @@
-import { t as printHelp } from "./cli-utils-dAbyq59_.js";
-import { i as runVersionPrompt, n as assertRemoteOrStoreDir, r as createStoreFromFlags, t as SHARED_FLAGS } from "./_shared-DlzCE5mE.js";
-import { red } from "farver/fast";
-import { UCDStoreUnsupportedFeature } from "@ucdjs/ucd-store";
-
-//#region src/cmd/store/init.ts
-async function runInitStore({ flags, versions }) {
-	if (flags?.help || flags?.h) {
-		printHelp({
-			headline: "Initialize an UCD Store",
-			commandName: "ucd store init",
-			usage: "[...versions] [...flags]",
-			tables: { Flags: [
-				...SHARED_FLAGS,
-				["--force", "Overwrite existing files if they already exist."],
-				["--help (-h)", "See all available flags."]
-			] }
-		});
-		return;
-	}
-	const { storeDir, force, remote, baseUrl, include: patterns, dryRun } = flags;
-	try {
-		assertRemoteOrStoreDir(flags);
-		let selectedVersions = versions;
-		if (!selectedVersions || selectedVersions.length === 0) {
-			const pickedVersions = await runVersionPrompt();
-			if (pickedVersions.length === 0) {
-				console.error("No versions selected. Operation cancelled.");
-				return;
-			}
-			selectedVersions = pickedVersions;
-		}
-		const store = await createStoreFromFlags({
-			baseUrl,
-			storeDir,
-			remote,
-			include: patterns,
-			versions: selectedVersions
-		});
-		await store.init({
-			force,
-			dryRun
-		});
-		if (!store.initialized) {
-			console.error(red(`\n❌ Error: Store initialization failed.`));
-			console.error("Please check the store configuration and try again.");
-			console.error("This output may help you debug the issue:");
-			return;
-		}
-		if (dryRun) {
-			console.info("Store initialized successfully in dry-run mode.");
-			console.info("No files have been written to disk.");
-		} else console.info("Store initialized successfully.");
-	} catch (err) {
-		if (err instanceof UCDStoreUnsupportedFeature) {
-			console.error(red(`\n❌ Error: Unsupported feature:`));
-			console.error(`  ${err.message}`);
-			console.error("");
-			console.error("This store does not support the init operation.");
-			console.error("Please check the store capabilities or use a different store type.");
-			return;
-		}
-		let message = "Unknown error";
-		if (err instanceof Error) message = err.message;
-		else if (typeof err === "string") message = err;
-		console.error(red(`\n❌ Error initializing store:`));
-		console.error(`  ${message}`);
-		console.error("Please check the store configuration and try again.");
-		console.error("If the issue persists, consider running with --dry-run to see more details.");
-		console.error("If you believe this is a bug, please report it at https://github.com/ucdjs/ucd/issues");
-	}
-}
-
-//#endregion
-export { runInitStore };