rulesync 16.0.0 → 16.2.0

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as ErrorCodes, $t as RULESYNC_SKILLS_RELATIVE_DIR_PATH, A as RulesyncMcp, At as RULESYNC_AIIGNORE_RELATIVE_FILE_PATH, B as stringifyFrontmatter, Bt as RULESYNC_IGNORE_RELATIVE_FILE_PATH, C as RulesyncSubagent, Ct as writeFileContent, D as RulesyncRule, Dt as ToolTargetSchema, E as RulesyncSkillFrontmatterSchema, Et as PACKAGING_TOOL_TARGETS, F as parseJsonc, Ft as RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH, G as ConfigFileSchema, Gt as RULESYNC_MCP_SCHEMA_URL, H as SHARED_USER_MANAGED_CONFIG_PATHS, Ht as RULESYNC_MCP_FILE_NAME, I as RulesyncCommand, It as RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH, J as ConsoleLogger, Jt as RULESYNC_PERMISSIONS_LEGACY_FILE_NAME, K as SourceEntrySchema, Kt as RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH, L as RulesyncCommandFrontmatterSchema, Lt as RULESYNC_HOOKS_FILE_NAME, M as RulesyncHooks, Mt as RULESYNC_COMMANDS_RELATIVE_DIR_PATH, N as getRulesyncSourceCandidates, Nt as RULESYNC_CONFIG_RELATIVE_FILE_PATH, O as RulesyncRuleFrontmatterSchema, Ot as MAX_FILE_SIZE, P as resolveRulesyncSourceWritePath, Pt as RULESYNC_CONFIG_SCHEMA_URL, Q as CLIError, Qt as RULESYNC_RULES_RELATIVE_DIR_PATH, R as RulesyncCheck, Rt as RULESYNC_HOOKS_LEGACY_FILE_NAME, S as getLocalSkillDirNames, St as toPosixPath, T as RulesyncSkill, Tt as ALL_TOOL_TARGETS_WITH_WILDCARD, U as SKILL_FILE_NAME$1, Ut as RULESYNC_MCP_LEGACY_FILE_NAME, V as loadYaml, Vt as RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH, W as ConfigResolver, Wt as RULESYNC_MCP_RELATIVE_FILE_PATH, X as fallbackLogger, Xt as RULESYNC_PERMISSIONS_SCHEMA_URL, Y as JsonLogger, Yt as RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH, Z as warnOnConflictingFlags, Zt as RULESYNC_RELATIVE_DIR_PATH, _ as CLAUDECODE_SETTINGS_LOCAL_FILE_NAME, _t as removeFile, a as convertFromTool, at as directoryExists, b as CODEXCLI_BASH_RULES_FILE_NAME, bt as resolvePath, c as SubagentsProcessor, ct as findFilesByGlobs, d as IgnoreProcessor, dt as isSymlink, en as RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH, et as assertDirectoryIfExists, f as HooksProcessor, ft as listDirectoryFiles, g as CLAUDECODE_MEMORIES_DIR_NAME, gt as removeDirectoryStrict, h as CLAUDECODE_LOCAL_RULE_FILE_NAME, ht as removeDirectory, i as getProcessorRegistryEntry, in as formatError, it as createTempDirectory, j as RulesyncIgnore, jt as RULESYNC_CHECKS_RELATIVE_DIR_PATH, k as RulesyncPermissions, kt as RULESYNC_AIIGNORE_FILE_NAME, l as SkillsProcessor, lt as getFileSize, m as CLAUDECODE_DIR, mt as readFileContentOrNull, n as checkRulesyncDirExists, nn as ALL_FEATURES, nt as assertWritablePathInsideRoot, o as isPackagingToolTarget, ot as ensureDir, p as CommandsProcessor, pt as readFileContent, q as findControlCharacter, qt as RULESYNC_PERMISSIONS_FILE_NAME, r as generate, rn as ALL_FEATURES_WITH_WILDCARD, rt as checkPathTraversal, s as RulesProcessor, st as fileExists, t as importFromTool, tn as RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, tt as assertTreeContainsNoSymlinks, u as McpProcessor, ut as getHomeDirectory, v as CLAUDECODE_SKILLS_DIR_PATH, vt as removeFileStrict, w as RulesyncSubagentFrontmatterSchema, wt as ALL_TOOL_TARGETS, x as CODEXCLI_DIR, xt as runWithDirectoryRollback, y as ChecksProcessor, yt as removeTempDirectory, z as RulesyncCheckFrontmatterSchema, zt as RULESYNC_HOOKS_RELATIVE_FILE_PATH } from "../import-BT5KR_K-.js";
+import { $ as ErrorCodes, $t as RULESYNC_SKILLS_RELATIVE_DIR_PATH, A as RulesyncMcp, At as RULESYNC_AIIGNORE_RELATIVE_FILE_PATH, B as stringifyFrontmatter, Bt as RULESYNC_IGNORE_RELATIVE_FILE_PATH, C as RulesyncSubagent, Ct as writeFileContent, D as RulesyncRule, Dt as ToolTargetSchema, E as RulesyncSkillFrontmatterSchema, Et as PACKAGING_TOOL_TARGETS, F as parseJsonc, Ft as RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH, G as ConfigFileSchema, Gt as RULESYNC_MCP_SCHEMA_URL, H as SHARED_USER_MANAGED_CONFIG_PATHS, Ht as RULESYNC_MCP_FILE_NAME, I as RulesyncCommand, It as RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH, J as ConsoleLogger, Jt as RULESYNC_PERMISSIONS_LEGACY_FILE_NAME, K as SourceEntrySchema, Kt as RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH, L as RulesyncCommandFrontmatterSchema, Lt as RULESYNC_HOOKS_FILE_NAME, M as RulesyncHooks, Mt as RULESYNC_COMMANDS_RELATIVE_DIR_PATH, N as getRulesyncSourceCandidates, Nt as RULESYNC_CONFIG_RELATIVE_FILE_PATH, O as RulesyncRuleFrontmatterSchema, Ot as MAX_FILE_SIZE, P as resolveRulesyncSourceWritePath, Pt as RULESYNC_CONFIG_SCHEMA_URL, Q as CLIError, Qt as RULESYNC_RULES_RELATIVE_DIR_PATH, R as RulesyncCheck, Rt as RULESYNC_HOOKS_LEGACY_FILE_NAME, S as getLocalSkillDirNames, St as toPosixPath, T as RulesyncSkill, Tt as ALL_TOOL_TARGETS_WITH_WILDCARD, U as SKILL_FILE_NAME$1, Ut as RULESYNC_MCP_LEGACY_FILE_NAME, V as loadYaml, Vt as RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH, W as ConfigResolver, Wt as RULESYNC_MCP_RELATIVE_FILE_PATH, X as fallbackLogger, Xt as RULESYNC_PERMISSIONS_SCHEMA_URL, Y as JsonLogger, Yt as RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH, Z as warnOnConflictingFlags, Zt as RULESYNC_RELATIVE_DIR_PATH, _ as CLAUDECODE_SETTINGS_LOCAL_FILE_NAME, _t as removeFile, a as convertFromTool, at as directoryExists, b as CODEXCLI_BASH_RULES_FILE_NAME, bt as resolvePath, c as SubagentsProcessor, ct as findFilesByGlobs, d as IgnoreProcessor, dt as isSymlink, en as RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH, et as assertDirectoryIfExists, f as HooksProcessor, ft as listDirectoryFiles, g as CLAUDECODE_MEMORIES_DIR_NAME, gt as removeDirectoryStrict, h as CLAUDECODE_LOCAL_RULE_FILE_NAME, ht as removeDirectory, i as getProcessorRegistryEntry, in as formatError, it as createTempDirectory, j as RulesyncIgnore, jt as RULESYNC_CHECKS_RELATIVE_DIR_PATH, k as RulesyncPermissions, kt as RULESYNC_AIIGNORE_FILE_NAME, l as SkillsProcessor, lt as getFileSize, m as CLAUDECODE_DIR, mt as readFileContentOrNull, n as checkRulesyncDirExists, nn as ALL_FEATURES, nt as assertWritablePathInsideRoot, o as isPackagingToolTarget, ot as ensureDir, p as CommandsProcessor, pt as readFileContent, q as findControlCharacter, qt as RULESYNC_PERMISSIONS_FILE_NAME, r as generate, rn as ALL_FEATURES_WITH_WILDCARD, rt as checkPathTraversal, s as RulesProcessor, st as fileExists, t as importFromTool, tn as RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, tt as assertTreeContainsNoSymlinks, u as McpProcessor, ut as getHomeDirectory, v as CLAUDECODE_SKILLS_DIR_PATH, vt as removeFileStrict, w as RulesyncSubagentFrontmatterSchema, wt as ALL_TOOL_TARGETS, x as CODEXCLI_DIR, xt as runWithDirectoryRollback, y as ChecksProcessor, yt as removeTempDirectory, z as RulesyncCheckFrontmatterSchema, zt as RULESYNC_HOOKS_RELATIVE_FILE_PATH } from "../import-CArKOPG_.js";
 import { Command } from "commander";
 import { nonnegative, optional, refine, z } from "zod/mini";
 import { cp, mkdtemp, realpath, rm } from "node:fs/promises";
@@ -17,8 +17,9 @@ import { promisify } from "node:util";
 import { RequestError } from "@octokit/request-error";
 import { Octokit } from "@octokit/rest";
 import { gunzipSync } from "node:zlib";
-import { FastMCP } from "fastmcp";
 import * as fs from "node:fs";
+import { existsSync, watch } from "node:fs";
+import { FastMCP } from "fastmcp";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 //#region src/utils/parse-comma-separated-list.ts
@@ -4374,6 +4375,216 @@ async function fetchCommand(logger, options) {
 		throw error;
 	}
 }
+/**
+* Coalesces file-system change notifications into debounced, non-overlapping
+* runs.
+*
+* Guarantees:
+* - At most one `run` is in flight at any time.
+* - Every notified path is reported to exactly one `run` as a trigger.
+* - Notifications that arrive while a run is in flight schedule exactly one
+*   follow-up run after it finishes, so a change is never lost and never
+*   causes a run per event.
+*/
+var WatchScheduler = class {
+	run;
+	onError;
+	debounceMs;
+	pending = /* @__PURE__ */ new Set();
+	timer;
+	running;
+	closed = false;
+	constructor({ run, onError, debounceMs = 300 }) {
+		this.run = run;
+		this.onError = onError;
+		this.debounceMs = debounceMs;
+	}
+	notify({ path }) {
+		if (this.closed) return;
+		this.pending.add(path);
+		this.schedule();
+	}
+	/**
+	* Stops accepting notifications and waits for an in-flight run to settle.
+	* Pending (not yet started) changes are dropped.
+	*/
+	async close() {
+		this.closed = true;
+		this.clearTimer();
+		this.pending.clear();
+		await this.running;
+	}
+	clearTimer() {
+		if (this.timer !== void 0) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+	}
+	schedule() {
+		this.clearTimer();
+		this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.flush();
+		}, this.debounceMs);
+	}
+	async flush() {
+		if (this.closed || this.running !== void 0 || this.pending.size === 0) return;
+		const triggers = [...this.pending];
+		this.pending.clear();
+		const running = (async () => {
+			try {
+				await this.run({ triggers });
+			} catch (error) {
+				this.onError({
+					error,
+					triggers
+				});
+			}
+		})();
+		this.running = running;
+		await running;
+		this.running = void 0;
+		if (!this.closed && this.pending.size > 0) this.schedule();
+	}
+};
+/**
+* Watches one directory, re-attaching the underlying `fs.watch` if the
+* directory is deleted and later recreated.
+*
+* Without this, a `git checkout` to a branch without `.rulesync/` (or any
+* tool that replaces the directory rather than its contents) would silently
+* kill the watcher: the deleted inode emits no further events and no error,
+* so watch mode would keep running while never regenerating again.
+*
+* The first attach is not guarded — a missing directory at startup is a real
+* configuration error and must surface to the caller.
+*/
+function watchTargetWithRearm({ target, onChange, onError, rearmIntervalMs }) {
+	let watcher;
+	let rearmTimer;
+	let closed = false;
+	const attach = () => {
+		const created = watch(target.directory, {
+			recursive: target.recursive,
+			persistent: true
+		}, (_eventType, filename) => {
+			if (filename === null || filename === void 0) {
+				onChange({ path: target.directory });
+				verifyStillWatching();
+				return;
+			}
+			const relativePath = filename.toString();
+			if (target.include && !target.include(relativePath)) {
+				verifyStillWatching();
+				return;
+			}
+			onChange({ path: join(target.directory, relativePath) });
+			verifyStillWatching();
+		});
+		created.on("error", (error) => {
+			onError({
+				error,
+				directory: target.directory
+			});
+			verifyStillWatching();
+		});
+		watcher = created;
+	};
+	const scheduleRearm = () => {
+		if (closed || rearmTimer !== void 0) return;
+		rearmTimer = setInterval(() => {
+			if (closed || !existsSync(target.directory)) return;
+			clearInterval(rearmTimer);
+			rearmTimer = void 0;
+			try {
+				attach();
+			} catch (error) {
+				onError({
+					error,
+					directory: target.directory
+				});
+				scheduleRearm();
+				return;
+			}
+			onChange({ path: target.directory });
+		}, rearmIntervalMs);
+	};
+	const verifyStillWatching = () => {
+		if (closed || watcher === void 0 || existsSync(target.directory)) return;
+		watcher.close();
+		watcher = void 0;
+		scheduleRearm();
+	};
+	attach();
+	return { close: () => {
+		closed = true;
+		if (rearmTimer !== void 0) {
+			clearInterval(rearmTimer);
+			rearmTimer = void 0;
+		}
+		watcher?.close();
+		watcher = void 0;
+	} };
+}
+/**
+* Starts one watcher per target and forwards matching events to `onChange` as
+* absolute paths. If any target fails to attach, the watchers started so far
+* are closed before the error propagates, so no descriptor is leaked.
+*/
+function watchTargets({ targets, onChange, onError, rearmIntervalMs = 500 }) {
+	const handles = [];
+	const closeAll = () => {
+		for (const handle of handles) handle.close();
+	};
+	try {
+		for (const target of targets) handles.push(watchTargetWithRearm({
+			target,
+			onChange,
+			onError,
+			rearmIntervalMs
+		}));
+	} catch (error) {
+		closeAll();
+		throw error;
+	}
+	return { close: closeAll };
+}
+/**
+* Builds the set of directories watch mode observes: the `.rulesync/` source
+* tree (recursively) and, filtered down to the configuration files themselves,
+* the directory holding `rulesync.jsonc`.
+*
+* Only input paths are watched. Generated output lives outside `.rulesync/`, so
+* a regeneration cannot re-trigger the watcher.
+*/
+function buildWatchTargets({ inputRoot, configFilePath }) {
+	const configFilePaths = buildConfigFilePaths({ configFilePath });
+	return [{
+		directory: join(inputRoot, RULESYNC_RELATIVE_DIR_PATH),
+		recursive: true
+	}, {
+		directory: dirname(configFilePath),
+		recursive: false,
+		include: (relativePath) => configFilePaths.has(join(dirname(configFilePath), relativePath))
+	}];
+}
+/**
+* The absolute paths of the configuration files watch mode observes: the base
+* configuration file and the `rulesync.local.jsonc` sitting next to it, which
+* is exactly what `ConfigResolver` loads.
+*/
+function buildConfigFilePaths({ configFilePath }) {
+	return /* @__PURE__ */ new Set([configFilePath, join(dirname(configFilePath), RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH)]);
+}
+/**
+* Renders trigger paths relative to `baseDir` for logging, truncating long
+* bursts so a `git checkout` does not flood the terminal.
+*/
+function formatTriggerPaths({ triggers, baseDir, max = 5 }) {
+	const displayed = triggers.slice(0, max).map((trigger) => relative(baseDir, trigger) || trigger);
+	const remaining = triggers.length - displayed.length;
+	return remaining > 0 ? `${displayed.join(", ")} (+${remaining} more)` : displayed.join(", ");
+}
 //#endregion
 //#region src/cli/commands/generate.ts
 /**
@@ -4463,7 +4674,20 @@ function buildSummaryParts(result) {
 	return parts;
 }
 async function generateCommand(logger, options) {
-	const config = await ConfigResolver.resolve(options, { logger });
+	if (options.watch) {
+		await generateWatchCommand(logger, options);
+		return;
+	}
+	await generateOnce(logger, options);
+}
+/**
+* Runs one generation. `resolvedConfig` lets a caller that already resolved
+* the configuration (watch mode's startup validation) reuse it instead of
+* paying for a second resolution — and, more importantly, instead of emitting
+* the resolver's warnings twice.
+*/
+async function generateOnce(logger, options, { resolvedConfig } = {}) {
+	const config = resolvedConfig ?? await ConfigResolver.resolve(options, { logger });
 	const check = config.getCheck();
 	const isPreview = config.isPreviewMode();
 	const modePrefix = isPreview ? "[DRY RUN]" : "";
@@ -4558,6 +4782,76 @@ async function generateCommand(logger, options) {
 	if (isPreview) logger.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
 	else logger.success(`🎉 All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
 }
+/**
+* Rejects flag combinations that contradict a long-running watch: `--check`
+* and `--dry-run` are one-shot verification modes (the former is meant to exit
+* non-zero), and `--json` buffers a single result document until the command
+* returns, which never happens while watching.
+*/
+function assertWatchModeCompatible({ isCheck, isDryRun, isJsonMode }) {
+	const conflicts = [
+		isCheck ? "--check" : void 0,
+		isDryRun ? "--dry-run" : void 0,
+		isJsonMode ? "--json" : void 0
+	].filter((flag) => flag !== void 0);
+	if (conflicts.length > 0) throw new CLIError(`--watch cannot be combined with ${conflicts.join(", ")}.`, ErrorCodes.VALIDATION_FAILED);
+}
+async function generateWatchCommand(logger, options) {
+	const config = await ConfigResolver.resolve(options, { logger });
+	assertWatchModeCompatible({
+		isCheck: config.getCheck(),
+		isDryRun: config.getDryRun(),
+		isJsonMode: logger.jsonMode
+	});
+	const inputRoot = config.getInputRoot();
+	const configFilePath = config.getConfigFilePath();
+	const configFilePaths = buildConfigFilePaths({ configFilePath });
+	await generateOnce(logger, options, { resolvedConfig: config });
+	const targets = buildWatchTargets({
+		inputRoot,
+		configFilePath
+	});
+	const scheduler = new WatchScheduler({
+		run: async ({ triggers }) => {
+			logger.info(`\nChange detected: ${formatTriggerPaths({
+				triggers,
+				baseDir: inputRoot
+			})}`);
+			if (triggers.some((trigger) => configFilePaths.has(trigger))) logger.warn("Configuration file changed. The set of watched paths is fixed at startup — restart 'rulesync generate --watch' if you changed 'inputRoot' or the configuration file location.");
+			await generateOnce(logger, options);
+		},
+		onError: ({ error }) => {
+			logger.error(`Generation failed: ${formatError(error)}`);
+			logger.info("Still watching for changes...");
+		}
+	});
+	const handle = watchTargets({
+		targets,
+		onChange: ({ path }) => {
+			scheduler.notify({ path });
+		},
+		onError: ({ error, directory }) => {
+			logger.error(`Watch error on ${directory}: ${formatError(error)}`);
+		}
+	});
+	logger.info(`\nWatching for changes in:\n${targets.map((target) => `    ${target.directory}`).join("\n")}`);
+	logger.info("Press Ctrl+C to stop.");
+	await new Promise((resolveShutdown) => {
+		const shutdown = () => {
+			process.off("SIGINT", shutdown);
+			process.off("SIGTERM", shutdown);
+			handle.close();
+			scheduler.close().catch((error) => {
+				logger.error(`Failed to stop the watcher cleanly: ${formatError(error)}`);
+			}).finally(() => {
+				logger.info("\nStopped watching.");
+				resolveShutdown();
+			});
+		};
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
+	});
+}
 //#endregion
 //#region src/cli/commands/gitignore-derive.ts
 const TARGETS_NOT_DERIVED = /* @__PURE__ */ new Set([
@@ -9002,7 +9296,7 @@ function wrapCommand$1({ name, errorCode, handler, getVersion, loggerFactory = c
 }
 //#endregion
 //#region src/cli/program.ts
-const getVersion = () => "16.0.0";
+const getVersion = () => "16.2.0";
 const FEATURES_HELP = `${ALL_FEATURES.join(",")}; ignore is deprecated, use permissions`;
 function wrapCommand(name, errorCode, handler) {
 	return wrapCommand$1({
@@ -9071,7 +9365,7 @@ function createProgram() {
 			silent: options.silent
 		});
 	}));
-	program.command("generate").description("Generate configuration files for AI tools").option("-t, --targets <tools>", "Comma-separated list of tools to generate for (e.g., 'copilot,cursor,cline' or '*' for all)", parseCommaSeparatedList).option("-f, --features <features>", `Comma-separated list of features to generate (${FEATURES_HELP}) or '*' for all`, parseCommaSeparatedList).option("--delete", "Delete all existing files in output directories before generating").option("-o, --output-roots <paths>", "Output root directories to generate files into (comma-separated for multiple paths)", parseCommaSeparatedList).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-c, --config <path>", "Path to configuration file").option("-g, --global", "Generate for global(user scope) configuration files").option("--simulate-commands", "Generate simulated commands. This feature is only available for copilot, cursor and codexcli.").option("--simulate-subagents", "Generate simulated subagents. This feature is only available for copilot and codexcli.").option("--simulate-skills", "Generate simulated skills. This feature is only available for copilot, cursor and codexcli.").option("--input-root <path>", "Path to the directory containing .rulesync/ (parent of .rulesync/)").option("--dry-run", "Dry run: show changes without writing files").option("--check", "Check if files are up to date (exits with code 1 if changes needed)").action(wrapCommand("generate", "GENERATION_FAILED", async (logger, options) => {
+	program.command("generate").description("Generate configuration files for AI tools").option("-t, --targets <tools>", "Comma-separated list of tools to generate for (e.g., 'copilot,cursor,cline' or '*' for all)", parseCommaSeparatedList).option("-f, --features <features>", `Comma-separated list of features to generate (${FEATURES_HELP}) or '*' for all`, parseCommaSeparatedList).option("--delete", "Delete all existing files in output directories before generating").option("-o, --output-roots <paths>", "Output root directories to generate files into (comma-separated for multiple paths)", parseCommaSeparatedList).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-c, --config <path>", "Path to configuration file").option("-g, --global", "Generate for global(user scope) configuration files").option("--simulate-commands", "Generate simulated commands. This feature is only available for copilot, cursor and codexcli.").option("--simulate-subagents", "Generate simulated subagents. This feature is only available for copilot and codexcli.").option("--simulate-skills", "Generate simulated skills. This feature is only available for copilot, cursor and codexcli.").option("--input-root <path>", "Path to the directory containing .rulesync/ (parent of .rulesync/)").option("--dry-run", "Dry run: show changes without writing files").option("--check", "Check if files are up to date (exits with code 1 if changes needed)").option("-w, --watch", "Keep running and regenerate whenever rulesync source files change (cannot be combined with --check, --dry-run or --json)").action(wrapCommand("generate", "GENERATION_FAILED", async (logger, options) => {
 		await generateCommand(logger, options);
 	}));
 	program.command("update").description("Update rulesync to the latest version").option("--check", "Check for updates without installing").option("--force", "Force update even if already at latest version").option("--token <token>", "GitHub token for API access").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(wrapCommand("update", "UPDATE_FAILED", async (logger, options) => {