rulesync 16.0.0 → 16.2.0

package/README.md

@@ -96,8 +96,8 @@ The tables below show whether each tool supports a given feature (✅ = supporte
 | GitHub Copilot CLI        |  ✅   |        | ✅  |          |    ✅     |   ✅   |  ✅   |             |        |
 | Goose                     |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Hermes Agent              |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |   ✅   |
-| Grok CLI                  |  ✅   |        | ✅  |          |    ✅     |   ✅   |  ✅   |     ✅      |        |
-| Cursor                    |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
+| Grok CLI                  |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
+| Cursor                    |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |   ✅   |
 | deepagents-cli            |  ✅   |        | ✅  |          |    ✅     |   ✅   |  ✅   |             |        |
 | Factory Droid             |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | OpenCode                  |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
@@ -105,17 +105,17 @@ The tables below show whether each tool supports a given feature (✅ = supporte
 | Kilo Code                 |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Kimi Code                 |  ✅   |        | ✅  |          |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Roo Code                  |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |       |             |        |
-| Rovodev (Atlassian)       |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |       |     ✅      |        |
+| Rovodev (Atlassian)       |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |       |     ✅      |   ✅   |
 | Takt                      |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |       |     ✅      |   ✅   |
 | Vibe Code                 |  ✅   |   ✅   | ✅  |          |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Qwen Code                 |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
-| Reasonix                  |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
+| Reasonix                  |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Kiro ⚠️                   |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Kiro CLI                  |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | Kiro IDE                  |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
-| Google Antigravity IDE    |  ✅   |        | ✅  |    ✅    |           |   ✅   |  ✅   |     ✅      |        |
-| Google Antigravity CLI    |  ✅   |   ✅   | ✅  |    ✅    |           |   ✅   |  ✅   |     ✅      |        |
-| Google Antigravity plugin |  ✅   |        | ✅  |          |           |   ✅   |  ✅   |             |        |
+| Google Antigravity IDE    |  ✅   |        | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
+| Google Antigravity CLI    |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
+| Google Antigravity plugin |  ✅   |        | ✅  |          |    ✅     |   ✅   |  ✅   |             |        |
 | JetBrains AI Assistant    |  ✅   |   ✅   | ✅  |          |           |   ✅   |       |             |        |
 | JetBrains Junie           |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |
 | AugmentCode               |  ✅   |   ✅   | ✅  |    ✅    |    ✅     |   ✅   |  ✅   |     ✅      |        |

package/dist/cli/index.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_import = require("../import-Dyo6JaHg.cjs");
+const require_import = require("../import-DNfxS6QZ.cjs");
 let commander = require("commander");
 let zod_mini = require("zod/mini");
 let node_fs_promises = require("node:fs/promises");
@@ -18,9 +18,9 @@ let node_util = require("node:util");
 let _octokit_request_error = require("@octokit/request-error");
 let _octokit_rest = require("@octokit/rest");
 let node_zlib = require("node:zlib");
-let fastmcp = require("fastmcp");
 let node_fs = require("node:fs");
 node_fs = require_import.__toESM(node_fs, 1);
+let fastmcp = require("fastmcp");
 let node_stream = require("node:stream");
 let node_stream_promises = require("node:stream/promises");
 //#region src/utils/parse-comma-separated-list.ts
@@ -4376,6 +4376,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 = (0, node_fs.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: (0, node_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 || !(0, node_fs.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 || (0, node_fs.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: (0, node_path.join)(inputRoot, require_import.RULESYNC_RELATIVE_DIR_PATH),
+		recursive: true
+	}, {
+		directory: (0, node_path.dirname)(configFilePath),
+		recursive: false,
+		include: (relativePath) => configFilePaths.has((0, node_path.join)((0, node_path.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, (0, node_path.join)((0, node_path.dirname)(configFilePath), require_import.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) => (0, node_path.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
 /**
@@ -4465,7 +4675,20 @@ function buildSummaryParts(result) {
 	return parts;
 }
 async function generateCommand(logger, options) {
-	const config = await require_import.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 require_import.ConfigResolver.resolve(options, { logger });
 	const check = config.getCheck();
 	const isPreview = config.isPreviewMode();
 	const modePrefix = isPreview ? "[DRY RUN]" : "";
@@ -4560,6 +4783,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 require_import.CLIError(`--watch cannot be combined with ${conflicts.join(", ")}.`, require_import.ErrorCodes.VALIDATION_FAILED);
+}
+async function generateWatchCommand(logger, options) {
+	const config = await require_import.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: ${require_import.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}: ${require_import.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: ${require_import.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([
@@ -9004,7 +9297,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 = `${require_import.ALL_FEATURES.join(",")}; ignore is deprecated, use permissions`;
 function wrapCommand(name, errorCode, handler) {
 	return wrapCommand$1({
@@ -9073,7 +9366,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) => {