@ucdjs/cli 0.2.2 → 0.3.1-beta.1

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.2.2",
+  "version": "0.3.1-beta.1",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -17,6 +17,11 @@
   "bugs": {
     "url": "https://github.com/ucdjs/ucd/issues"
   },
+  "exports": {
+    ".": "./dist/cli.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/cli.d.mts",
   "bin": {
     "ucd": "bin/ucd.js"
   },
@@ -24,32 +29,43 @@
     "bin",
     "dist"
   ],
+  "engines": {
+    "node": ">=22.18"
+  },
   "dependencies": {
-    "@luxass/unicode-utils": "^0.9.0",
-    "@luxass/utils": "^2.2.1",
-    "farver": "^0.4.2",
-    "micromatch": "^4.0.8",
-    "p-limit": "^6.2.0",
-    "yargs-parser": "^21.1.1",
-    "@ucdjs/schema-gen": "0.2.1"
+    "@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-internal/shared": "0.1.1-beta.1",
+    "@ucdjs/client": "0.1.1-beta.1",
+    "@ucdjs/schema-gen": "0.2.3-beta.1",
+    "@ucdjs/env": "0.1.1-beta.1",
+    "@ucdjs/lockfile": "0.1.1-beta.1",
+    "@ucdjs/fs-bridge": "0.1.1-beta.1",
+    "@ucdjs/ucd-store": "1.0.1-beta.1",
+    "@ucdjs/schemas": "0.1.1-beta.1"
   },
   "devDependencies": {
-    "@luxass/eslint-config": "^4.18.1",
-    "@types/micromatch": "^4.0.9",
-    "@types/yargs-parser": "^21.0.3",
-    "eslint": "^9.27.0",
-    "publint": "^0.3.12",
-    "tsdown": "v0.9.3",
-    "typescript": "^5.8.3",
-    "vitest-testdirs": "^4.0.0"
+    "@luxass/eslint-config": "7.2.0",
+    "@types/yargs-parser": "21.0.3",
+    "eslint": "10.0.0",
+    "publint": "0.3.17",
+    "tsdown": "0.20.3",
+    "typescript": "5.9.3",
+    "vitest-testdirs": "4.4.2",
+    "@ucdjs-tooling/tsdown-config": "1.0.0",
+    "@ucdjs-tooling/tsconfig": "1.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown --tsconfig=./tsconfig.build.json",
+    "dev": "tsdown --watch",
     "clean": "git clean -xdf dist node_modules",
     "lint": "eslint .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
   }
 }

package/dist/cli-utils-DY82m2wz.js

@@ -1,195 +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 name = "@ucdjs/cli";
-var version = "0.2.2";
-var type = "module";
-var author = {
-	"name": "Lucas Nørgård",
-	"email": "lucasnrgaard@gmail.com",
-	"url": "https://luxass.dev"
-};
-var packageManager = "pnpm@10.11.0";
-var license = "MIT";
-var homepage = "https://github.com/ucdjs/ucd";
-var repository = {
-	"type": "git",
-	"url": "git+https://github.com/ucdjs/ucd.git",
-	"directory": "packages/cli"
-};
-var bugs = { "url": "https://github.com/ucdjs/ucd/issues" };
-var bin = { "ucd": "bin/ucd.js" };
-var files = ["bin", "dist"];
-var scripts = {
-	"build": "tsdown",
-	"clean": "git clean -xdf dist node_modules",
-	"lint": "eslint .",
-	"typecheck": "tsc --noEmit"
-};
-var dependencies = {
-	"@luxass/unicode-utils": "catalog:prod",
-	"@luxass/utils": "catalog:prod",
-	"@ucdjs/schema-gen": "workspace:*",
-	"farver": "catalog:prod",
-	"micromatch": "catalog:prod",
-	"p-limit": "catalog:prod",
-	"yargs-parser": "catalog:prod"
-};
-var devDependencies = {
-	"@luxass/eslint-config": "catalog:dev",
-	"@types/micromatch": "catalog:dev",
-	"@types/yargs-parser": "catalog:dev",
-	"eslint": "catalog:dev",
-	"publint": "catalog:dev",
-	"tsdown": "catalog:dev",
-	"typescript": "catalog:dev",
-	"vitest-testdirs": "catalog:dev"
-};
-var publishConfig = { "access": "public" };
-var package_default = {
-	name,
-	version,
-	type,
-	author,
-	packageManager,
-	license,
-	homepage,
-	repository,
-	bugs,
-	bin,
-	files,
-	scripts,
-	dependencies,
-	devDependencies,
-	publishConfig
-};
-
-//#endregion
-//#region src/cli-utils.ts
-const SUPPORTED_COMMANDS = new Set(["codegen", "download"]);
-/**
-* 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._[2];
-	if (SUPPORTED_COMMANDS.has(cmd)) return cmd;
-	return "help";
-}
-function printHelp({ commandName, headline, usage, tables, description }) {
-	const terminalWidth = process.stdout.columns || 80;
-	const isTinyTerminal = terminalWidth < 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${package_default.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${package_default.version ?? "x.y.z"}`)}`);
-			break;
-		case "codegen": {
-			const { runCodegenRoot } = await import("./root-oHWSp_5G.js");
-			const subcommand = flags._[3]?.toString() ?? "";
-			await runCodegenRoot(subcommand, { flags });
-			break;
-		}
-		case "download": {
-			const { runDownload } = await import("./download-CCx2vdOj.js");
-			const versions = flags._.slice(3);
-			await runDownload({
-				versions,
-				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"
-		],
-		string: [
-			"output-dir",
-			"input-dir",
-			"output-file"
-		]
-	});
-}
-async function runCLI(args) {
-	try {
-		const flags = parseFlags(args);
-		const cmd = resolveCommand(flags);
-		await runCommand(cmd, flags);
-	} catch (err) {
-		console.error(err);
-		process.exit(1);
-	}
-}
-
-//#endregion
-export { printHelp, runCLI };

package/dist/cli.js

@@ -1,7 +0,0 @@
-import { runCLI } from "./cli-utils-DY82m2wz.js";
-import process from "node:process";
-
-//#region src/cli.ts
-runCLI(process.argv);
-
-//#endregion