@fedify/cli 1.8.12 → 2.0.0-dev.1761

package/dist/init/action/patch.js

@@ -0,0 +1,141 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { formatJson, merge, set } from "../../utils.js";
+import { createFile, throwUnlessNotExists } from "../lib.js";
+import { displayFile, noticeFilesToCreate, noticeFilesToInsert } from "./notice.js";
+import { joinDir, stringifyEnvs } from "./utils.js";
+import { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig } from "./configs.js";
+import { getImports, loadFederation, loadLogging } from "./templates.js";
+import { readFile } from "node:fs/promises";
+import { apply, entries, forEach, pipe, pipeLazy, tap } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+
+//#region src/init/action/patch.ts
+/**
+* Main function that initializes the project by creating necessary files and configurations.
+* Handles both dry-run mode (recommending files) and actual file creation.
+* Orchestrates the entire file generation and writing process.
+*
+* @param data - The initialization command data containing project configuration
+* @returns A processed data object with files and JSONs ready for creation
+*/
+const patchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), createFiles);
+const recommendPatchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), recommendFiles);
+/**
+* Generates text-based files (TypeScript, environment files) for the project.
+* Creates federation configuration, logging setup, environment variables, and framework-specific files
+* by processing templates and combining them with project-specific data.
+*
+* @param data - The initialization command data
+* @returns A record of file paths to their string content
+*/
+const getFiles = (data) => ({
+	[data.initializer.federationFile]: loadFederation({
+		imports: getImports(data),
+		...data
+	}),
+	[data.initializer.loggingFile]: loadLogging(data),
+	".env": stringifyEnvs(data.env),
+	...data.initializer.files
+});
+/**
+* Generates JSON configuration files based on the package manager type.
+* Creates different sets of configuration files for Deno vs Node.js/Bun environments,
+* including compiler configs, package manifests, and development tool configurations.
+*
+* @param data - The initialization command data
+* @returns A record of file paths to their JSON object content
+*/
+const getJsons = (data) => data.packageManager === "deno" ? {
+	"deno.json": loadDenoConfig(data).data,
+	[devToolConfigs["vscSetDeno"].path]: devToolConfigs["vscSetDeno"].data,
+	[devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data
+} : {
+	"tsconfig.json": loadTsConfig(data).data,
+	"package.json": loadPackageJson(data).data,
+	[devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
+	[devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
+	[devToolConfigs["vscExt"].path]: devToolConfigs["vscExt"].data
+};
+/**
+* Handles dry-run mode by recommending files to be created without actually creating them.
+* Displays what files would be created and shows their content for user review.
+* This allows users to preview the initialization process before committing to it.
+*
+* @param data - The initialization command data with files and JSONs prepared
+* @returns The processed data with recommendations displayed
+*/
+const recommendFiles = (data) => pipe(data, tap(noticeFilesToCreate), tap(processAllFiles(displayFile)), tap(noticeFilesToInsert), set("files", ({ jsons }) => jsons), tap(processAllFiles(displayFile)));
+/**
+* Actually creates files on the filesystem during normal (non-dry-run) execution.
+* Merges text files and JSON files together and writes them to disk.
+* This performs the actual file system operations to initialize the project.
+*
+* @param data - The initialization command data with files and JSONs prepared
+* @returns The processed data after files have been created
+*/
+const createFiles = (data) => pipe(data, set("files", ({ jsons, files }) => toMerged(files, jsons)), tap(processAllFiles(createFile)));
+/**
+* Higher-order function that processes all files with a given processing function.
+* Takes a processing function (either display or create) and applies it to all files
+* in the target directory, handling path resolution and content patching.
+*
+* @param process - Function to process each file (either display or create)
+* @returns A function that processes all files in the given directory with the provided processor
+*/
+const processAllFiles = (process) => ({ dir, files }) => pipe(files, entries, forEach(pipeLazy(joinDir(dir), apply(patchContent), apply(process))));
+/**
+* Patches file content by either merging JSON objects or appending text content.
+* Handles existing files by reading their current content and intelligently combining
+* it with new content based on the content type (JSON vs text).
+*
+* @param path - The file path to patch
+* @param content - The new content (either string or object)
+* @returns A tuple containing the file path and the final content string
+*/
+async function patchContent(path, content) {
+	const prev = await readFileIfExists(path);
+	const data = typeof content === "object" ? mergeJson(prev, content) : appendText(prev, content);
+	return [path, data];
+}
+/**
+* Merges new JSON data with existing JSON content and formats the result.
+* Parses existing JSON content (if any) and deep merges it with new data,
+* then formats the result for consistent output.
+*
+* @param prev - The previous JSON content as string
+* @param data - The new data object to merge
+* @returns Formatted JSON string with merged content
+*/
+const mergeJson = (prev, data) => pipe(prev ? JSON.parse(prev) : {}, merge(data), formatJson);
+/**
+* Appends new text content to existing text content line by line.
+* Concatenates new content lines with existing content lines,
+* preserving line structure and formatting.
+*
+* @param prev - The previous text content
+* @param data - The new text content to append
+* @returns Combined text content as a single string
+*/
+const appendText = (prev, data) => prev ? `${prev}\n${data}` : data;
+/**
+* Safely reads a file if it exists, returns empty string if it doesn't exist.
+* Provides error handling to distinguish between "file not found" and other
+* file system errors, throwing only for unexpected errors.
+*
+* @param path - The file path to read
+* @returns The file content as string, or empty string if file doesn't exist
+* @throws Error if file access fails for reasons other than file not existing
+*/
+async function readFileIfExists(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (e) {
+		throwUnlessNotExists(e);
+		return "";
+	}
+}
+
+//#endregion
+export { patchFiles, recommendPatchFiles };

package/dist/init/action/precommand.js

@@ -0,0 +1,23 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { exit, runSubCommand } from "../../utils.js";
+
+//#region src/init/action/precommand.ts
+/**
+* Runs the precommand specified in the initializer to set up the project.
+*
+* @param data - The initialization command data containing the initializer command and directory
+* @returns A promise that resolves when the precommand has been executed
+*/
+const runPrecommand = ({ initializer: { command }, dir }) => runSubCommand(command, {
+	cwd: dir,
+	stdio: "inherit"
+}).catch((e) => {
+	console.error("Failed to run the precommand:", e);
+	exit(1);
+});
+var precommand_default = runPrecommand;
+
+//#endregion
+export { precommand_default as default };

package/dist/init/action/recommend.js

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { notEmpty } from "../../utils.js";
+import { noticeDeps, noticeDepsIfExist, noticeDevDepsIfExist } from "./notice.js";
+import { getDependencies, getDevDependencies } from "./deps.js";
+import { isDeno } from "./utils.js";
+import { map, peek, pipeLazy, tap, unless, when } from "@fxts/core";
+
+//#region src/init/action/recommend.ts
+const recommendDeps = pipeLazy(getDependencies, Object.entries, when(notEmpty, tap(noticeDepsIfExist)), peek(noticeDeps));
+const recommendDevDeps = pipeLazy(getDevDependencies, Object.entries, when(notEmpty, tap(noticeDevDepsIfExist)), map(noticeDeps));
+/**
+* Recommends dependencies and devDependencies to be added to package.json.
+* Skips devDependencies recommendation if the package manager is Deno.
+*
+* @param data - The initialization command data
+* @returns An InitCommandIo function that performs the recommendation
+*/
+const recommendDependencies = pipeLazy(tap(recommendDeps), unless(isDeno, tap(recommendDevDeps)));
+var recommend_default = recommendDependencies;
+
+//#endregion
+export { recommend_default as default };

package/dist/init/action/set.js

@@ -0,0 +1,31 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { merge, set } from "../../utils.js";
+import webframeworks_default from "../webframeworks.js";
+import { kvStores, messageQueues } from "../lib.js";
+import { basename, normalize } from "node:path";
+import { realpath } from "node:fs/promises";
+import { pipe } from "@fxts/core";
+import { existsSync } from "node:fs";
+
+//#region src/init/action/set.ts
+/**
+* Set all necessary data for initializing the project.
+* This function orchestrates the setting of project name, initializer,
+* key-value store, message queue, and environment variables by calling
+* individual setter functions for each piece of data.
+*
+* @param data - The initial command options provided by the user
+* @returns A promise resolving to a complete InitCommandData object
+*/
+const setData = (data) => pipe(data, setProjectName, setInitializer, setKv, setMq, setEnv);
+var set_default = setData;
+const setProjectName = set("projectName", async ({ dir }) => basename(existsSync(dir) ? await realpath(dir) : normalize(dir)));
+const setInitializer = set("initializer", ({ webFramework, projectName, packageManager }) => webframeworks_default[webFramework].init(projectName, packageManager));
+const setKv = set("kv", ({ kvStore }) => kvStores[kvStore]);
+const setMq = set("mq", ({ messageQueue }) => messageQueues[messageQueue]);
+const setEnv = set("env", ({ kv, mq }) => merge(kv.env)(mq.env));
+
+//#endregion
+export { set_default as default };

package/dist/init/action/templates.js

@@ -0,0 +1,57 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { replace } from "../../utils.js";
+import { readTemplate } from "../lib.js";
+import { entries, join, map, pipe } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+
+//#region src/init/action/templates.ts
+/**
+* Loads the federation configuration file content from template.
+* Reads the default federation template and replaces placeholders with actual configuration values.
+*
+* @param param0 - Configuration object containing imports, project name, KV store, message queue, and package manager
+* @returns The complete federation configuration file content as a string
+*/
+const loadFederation = ({ imports, projectName, kv, mq, packageManager }) => pipe("defaults/federation.ts", readTemplate, replace(/\/\* imports \*\//, imports), replace(/\/\* logger \*\//, JSON.stringify(projectName)), replace(/\/\* kv \*\//, convertEnv(kv.object, packageManager)), replace(/\/\* queue \*\//, convertEnv(mq.object, packageManager)));
+/**
+* Loads the logging configuration file content from template.
+* Reads the default logging template and replaces the project name placeholder.
+*
+* @param param0 - Destructured object containing the project name
+* @returns The complete logging configuration file content as a string
+*/
+const loadLogging = ({ projectName }) => pipe("defaults/logging.ts", readTemplate, replace(/\/\* project name \*\//, JSON.stringify(projectName)));
+/**
+* Generates import statements for KV store and message queue dependencies.
+* Merges imports from both KV and MQ configurations and creates proper ES module import syntax.
+*
+* @param param0 - Destructured object containing kv and mq configurations
+* @returns A multi-line string containing all necessary import statements
+*/
+const getImports = ({ kv, mq }) => pipe(toMerged(kv.imports, mq.imports), entries, map(([module, { "default": defaultImport = "",...imports }]) => [
+	module,
+	defaultImport,
+	getAlias(imports)
+]), map(([module, defaultImport, namedImports]) => `import ${[defaultImport, namedImports.length > 0 ? `{ ${namedImports} }` : ""].filter((x) => x.length > 0).join(", ")} from ${JSON.stringify(module)};`), join("\n"));
+/**
+* Converts import mappings to named import string with aliases.
+* Creates proper ES module named import syntax, using aliases when the import name differs from the local name.
+*
+* @param imports - A record mapping import names to their local aliases
+* @returns A comma-separated string of named imports with aliases where needed
+*/
+const getAlias = (imports) => pipe(imports, entries, map(([name, alias]) => name === alias ? name : `${name} as ${alias}`), join(", "));
+/**
+* Converts Node.js environment variable access to Deno-compatible syntax when needed.
+* Transforms `process.env.VAR_NAME` to `Deno.env.get("VAR_NAME")` for Deno projects.
+*
+* @param obj - The object string containing potential environment variable references
+* @param pm - The package manager (runtime) being used
+* @returns The converted object string with appropriate environment variable access syntax
+*/
+const convertEnv = (obj, pm) => pm === "deno" && /process\.env\.(\w+)/.test(obj) ? obj.replaceAll(/process\.env\.(\w+)/, (_, g1) => `Deno.env.get("${g1}")`) : obj;
+
+//#endregion
+export { getImports, loadFederation, loadLogging };

package/dist/init/action/utils.js

@@ -0,0 +1,50 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { join } from "node:path";
+
+//#region src/init/action/utils.ts
+const isDry = ({ dryRun }) => dryRun;
+const hasCommand = (data) => !!data.initializer.command;
+const isDeno = ({ packageManager }) => packageManager === "deno";
+const joinDir = (dir) => ([filename, content]) => [join(dir, ...filename.split("/")), content];
+/**
+* Stringify an object into a valid `.env` file format.
+* From `@std/dotenv/stringify`.
+*
+* @example Usage
+* ```ts
+* import { stringifyEnvs } from "./utils.ts";
+* import { assertEquals } from "@std/assert";
+*
+* const object = { GREETING: "hello world" };
+* assertEquals(stringifyEnvs(object), "GREETING='hello world'");
+* ```
+*
+* @param object object to be stringified
+* @returns string of object
+*/
+function stringifyEnvs(object) {
+	const lines = [];
+	for (const [key, value] of Object.entries(object)) {
+		let quote;
+		let escapedValue = value ?? "";
+		if (key.startsWith("#")) {
+			console.warn(`key starts with a '#' indicates a comment and is ignored: '${key}'`);
+			continue;
+		} else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
+			escapedValue = escapedValue.replaceAll("\n", "\\n");
+			quote = `"`;
+		} else if (escapedValue.match(/\W/)) quote = "'";
+		if (quote) {
+			escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
+			escapedValue = `${quote}${escapedValue}${quote}`;
+		}
+		const line = `${key}=${escapedValue}`;
+		lines.push(line);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+export { hasCommand, isDeno, isDry, joinDir, stringifyEnvs };

package/dist/init/ask/dir.js

@@ -0,0 +1,82 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { getCwd, getOsType, runSubCommand } from "../../utils.js";
+import { isDirectoryEmpty, logger } from "../lib.js";
+import { printError } from "@optique/run";
+import { identity, pipe, when } from "@fxts/core";
+import { input } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+import toggle from "inquirer-toggle";
+
+//#region src/init/ask/dir.ts
+/**
+* Fills in the project directory by prompting the user if not provided.
+* If the directory is not empty, asks the user whether to use it anyway.
+* If the user agrees, offers to move existing contents to trash.
+* Else, recursively prompts for a new directory until a valid one is provided.
+*
+* @param options - Initialization options possibly containing a directory
+* @returns A promise resolving to options with a guaranteed directory
+*/
+const fillDir = async (options) => {
+	const dir = options.dir ?? await askDir(getCwd());
+	return await askIfNonEmpty(dir) ? {
+		...options,
+		dir
+	} : await fillDir(options);
+};
+var dir_default = fillDir;
+const askDir = (cwd) => input({
+	message: "Project directory:",
+	default: cwd
+});
+const askIfNonEmpty = async (dir) => {
+	if (await isDirectoryEmpty(dir)) return true;
+	if (await askNonEmpty(dir)) return await moveDirToTrash(dir);
+	return false;
+};
+const askNonEmpty = (dir) => toggle.default({
+	message: `Directory "${dir}" is not empty.
+Do you want to use it anyway?`,
+	default: false
+});
+const moveDirToTrash = (dir) => pipe(dir, askMoveToTrash, when(identity, moveToTrash(dir)));
+const askMoveToTrash = (dir) => toggle.default({
+	message: `Do you want to move the contents of "${dir}" to the trash?
+If you choose "No", you should choose another directory.`,
+	default: false
+});
+const moveToTrash = (dir) => () => pipe(getOsType(), getTrashCommand, (fn) => fn(dir), (cmd) => runSubCommand(cmd, { stdio: "ignore" }), () => true).catch((e) => {
+	logger.error(e);
+	printError(message`Failed to move ${dir} to trash.
+Please move it manually.`);
+	return false;
+});
+const getTrashCommand = (os) => trashCommands[os] ?? trashCommands.linux;
+const trashCommands = {
+	darwin: (dir) => ["trash", dir],
+	win32: (dir) => [
+		"powershell",
+		"-Command",
+		getPowershellTrashCommand(dir)
+	],
+	linux: (dir) => [
+		"rm",
+		"-rf",
+		dir
+	]
+};
+const getPowershellTrashCommand = (dir) => [
+	"Add-Type",
+	"-AssemblyName",
+	"Microsoft.VisualBasic;",
+	"[Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory('",
+	dir,
+	"',",
+	"'OnlyErrorDialogs',",
+	"'SendToRecycleBin')"
+].join(" ");
+
+//#endregion
+export { dir_default as default };

package/dist/init/ask/kv.js

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { KV_STORE } from "../const.js";
+import { kvStores } from "../lib.js";
+import { select } from "@inquirer/prompts";
+
+//#region src/init/ask/kv.ts
+/**
+* Fills in the key-value store by prompting the user if not provided.
+* Ensures the selected KV store is compatible with the chosen package manager.
+*
+* @param options - Initialization options possibly containing a kvStore and packageManager
+* @returns A promise resolving to options with a guaranteed kvStore
+*/
+const fillKvStore = async (options) => ({
+	...options,
+	kvStore: options.kvStore ?? await askKvStore(options.packageManager)
+});
+var kv_default = fillKvStore;
+const askKvStore = (pm) => select({
+	message: "Choose the key-value store to use",
+	choices: KV_STORE.map(choiceKvStore(pm))
+});
+const choiceKvStore = (pm) => (value) => ({
+	name: isKvSupportsPm(value, pm) ? value : `${value} (not supported with ${pm})`,
+	value,
+	disabled: !isKvSupportsPm(value, pm)
+});
+const isKvSupportsPm = (kv, pm) => kvStores[kv].packageManagers.includes(pm);
+
+//#endregion
+export { kv_default as default };

package/dist/init/ask/mod.js

@@ -0,0 +1,16 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import dir_default from "./dir.js";
+import kv_default from "./kv.js";
+import mq_default from "./mq.js";
+import pm_default from "./pm.js";
+import wf_default from "./wf.js";
+import { pipe } from "@fxts/core";
+
+//#region src/init/ask/mod.ts
+const askOptions = (options) => pipe(options, dir_default, wf_default, pm_default, mq_default, kv_default);
+var ask_default = askOptions;
+
+//#endregion
+export { ask_default as default };

package/dist/init/ask/mq.js

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { MESSAGE_QUEUE } from "../const.js";
+import { messageQueues } from "../lib.js";
+import { select } from "@inquirer/prompts";
+
+//#region src/init/ask/mq.ts
+/**
+* Fills in the message queue by prompting the user if not provided.
+* Ensures the selected message queue is compatible with the chosen package manager.
+*
+* @param options - Initialization options possibly containing a messageQueue and packageManager
+* @returns A promise resolving to options with a guaranteed messageQueue
+*/
+const fillMessageQueue = async (options) => ({
+	...options,
+	messageQueue: options.messageQueue ?? await askMessageQueue(options.packageManager)
+});
+var mq_default = fillMessageQueue;
+const askMessageQueue = (pm) => select({
+	message: "Choose the message queue to use",
+	choices: MESSAGE_QUEUE.map(choiceMessageQueue(pm))
+});
+const choiceMessageQueue = (pm) => (value) => ({
+	name: isMqSupportsPm(value, pm) ? value : `${value} (not supported with ${pm})`,
+	value,
+	disabled: !isMqSupportsPm(value, pm)
+});
+const isMqSupportsPm = (mq, pm) => messageQueues[mq].packageManagers.includes(pm);
+
+//#endregion
+export { mq_default as default };

package/dist/init/ask/pm.js

@@ -0,0 +1,49 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { PACKAGE_MANAGER } from "../const.js";
+import webframeworks_default from "../webframeworks.js";
+import { getInstallUrl, getLabel, isPackageManagerAvailable } from "../lib.js";
+import { print } from "@optique/run";
+import { select } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+
+//#region src/init/ask/pm.ts
+/**
+* Fills in the package manager by prompting the user if not provided.
+* Ensures the selected package manager is compatible with the chosen web framework.
+* If the selected package manager is not installed, informs the user and prompts again.
+*
+* @param options - Initialization options possibly containing a packageManager and webFramework
+* @returns A promise resolving to options with a guaranteed packageManager
+*/
+const fillPackageManager = async ({ packageManager,...options }) => {
+	const pm = packageManager ?? await askPackageManager(options.webFramework);
+	if (await isPackageManagerAvailable(pm)) return {
+		...options,
+		packageManager: pm
+	};
+	noticeInstallUrl(pm);
+	return await fillPackageManager(options);
+};
+var pm_default = fillPackageManager;
+const askPackageManager = (wf) => select({
+	message: "Choose the package manager to use",
+	choices: PACKAGE_MANAGER.map(choicePackageManager(wf))
+});
+const choicePackageManager = (wf) => (value) => ({
+	name: isWfSupportsPm(wf, value) ? value : `${value} (not supported with ${webframeworks_default[wf].label})`,
+	value,
+	disabled: !isWfSupportsPm(wf, value)
+});
+const isWfSupportsPm = (wf, pm) => webframeworks_default[wf].packageManagers.includes(pm);
+const noticeInstallUrl = (pm) => {
+	const label = getLabel(pm);
+	const url = getInstallUrl(pm);
+	print(message`  Package manager ${label} is not installed.`);
+	print(message`  You can install it from following link: ${url}`);
+	print(message`  or choose another package manager:`);
+};
+
+//#endregion
+export { pm_default as default };

package/dist/init/ask/wf.js

@@ -0,0 +1,29 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { WEB_FRAMEWORK } from "../const.js";
+import webframeworks_default from "../webframeworks.js";
+import { select } from "@inquirer/prompts";
+
+//#region src/init/ask/wf.ts
+/**
+* Fills in the web framework by prompting the user if not provided.
+*
+* @param options - Initialization options possibly containing a webFramework
+* @returns A promise resolving to options with a guaranteed webFramework
+*/
+const fillWebFramework = async (options) => ({
+	...options,
+	webFramework: options.webFramework ?? await askWebFramework()
+});
+var wf_default = fillWebFramework;
+const askWebFramework = () => select({
+	message: "Choose the web framework to use",
+	choices: WEB_FRAMEWORK.map((value) => ({
+		name: webframeworks_default[value].label,
+		value
+	}))
+});
+
+//#endregion
+export { wf_default as default };

package/dist/init/command.js

@@ -0,0 +1,25 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "./const.js";
+import { argument, choice, command, constant, message, object, option, optional } from "@optique/core";
+import { path } from "@optique/run";
+
+//#region src/init/command.ts
+const joinSep = (str) => str.join(" | ");
+const webFramework = optional(option("-w", "--web-framework", choice(WEB_FRAMEWORK, { metavar: `WEB_FRAMEWORK: ${joinSep(WEB_FRAMEWORK)}` })));
+const packageManager = optional(option("-p", "--package-manager", choice(PACKAGE_MANAGER, { metavar: `PACKAGE_MANAGER: ${joinSep(PACKAGE_MANAGER)}` })));
+const kvStore = optional(option("-k", "--kv-store", choice(KV_STORE, { metavar: `KV_STORE: ${joinSep(KV_STORE)}` })));
+const messageQueue = optional(option("-m", "--message-queue", choice(MESSAGE_QUEUE, { metavar: `MESSAGE_QUEUE: ${joinSep(MESSAGE_QUEUE)}` })));
+const initCommand = command("init", object({
+	command: constant("init"),
+	dir: optional(argument(path({ metavar: "DIRECTORY" }))),
+	webFramework,
+	packageManager,
+	kvStore,
+	messageQueue,
+	dryRun: option("-d", "--dry-run")
+}), { description: message`Initialize a new Fedify project directory.` });
+
+//#endregion
+export { initCommand };

package/dist/init/const.js

@@ -0,0 +1,31 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+//#region src/init/const.ts
+const PACKAGE_MANAGER = [
+	"deno",
+	"pnpm",
+	"bun",
+	"yarn",
+	"npm"
+];
+const WEB_FRAMEWORK = [
+	"hono",
+	"nitro",
+	"next",
+	"express"
+];
+const MESSAGE_QUEUE = [
+	"denokv",
+	"redis",
+	"postgres",
+	"amqp"
+];
+const KV_STORE = [
+	"denokv",
+	"redis",
+	"postgres"
+];
+
+//#endregion
+export { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK };

package/dist/init/json/biome.js

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+//#region src/init/json/biome.json
+var $schema = "https://biomejs.dev/schemas/1.8.3/schema.json";
+var organizeImports = { "enabled": true };
+var formatter = {
+	"enabled": true,
+	"indentStyle": "space",
+	"indentWidth": 2
+};
+var linter = {
+	"enabled": true,
+	"rules": { "recommended": true }
+};
+var biome_default = {
+	$schema,
+	organizeImports,
+	formatter,
+	linter
+};
+
+//#endregion
+export { biome_default as default };