rulesync 16.13.0 → 16.14.0

package/dist/{import-Dswkc7Ub.js → import-Ds0QeVp6.js}

@@ -419,7 +419,8 @@ const permissionsProcessorToolTargetTuple = [
 	"takt",
 	"vibe",
 	"warp",
-	"zed"
+	"zed",
+	"zoocode"
 ];
 const checksProcessorToolTargetTuple = [
 	"amp",
@@ -5345,6 +5346,7 @@ const RulesyncRuleFrontmatterSchema = z.object({
 		systemPrompt: z.optional(z.enum(["append"])),
 		contextFile: z.optional(z.enum(["override"]))
 	})),
+	roo: z.optional(z.looseObject({ mode: z.optional(z.string()) })),
 	takt: z.optional(z.looseObject({
 		name: z.optional(z.string()),
 		extends: z.optional(z.string()),
@@ -7786,7 +7788,9 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: [
 				"chat.tools.terminal.autoApprove",
 				"chat.tools.edits.autoApprove",
-				"chat.tools.urls.autoApprove"
+				"chat.tools.urls.autoApprove",
+				"zoo-code.allowedCommands",
+				"zoo-code.deniedCommands"
 			]
 		} }
 	},
@@ -12750,6 +12754,21 @@ const ROO_DIR = ".roo";
 const ROO_COMMANDS_DIR_PATH = join(ROO_DIR, "commands");
 const ROO_SKILLS_DIR_PATH = join(ROO_DIR, "skills");
 const ROO_MCP_FILE_NAME = "mcp.json";
+/**
+* Mode slugs Roo/Zoo Code themselves accept for a `rules-{mode}` directory:
+* the loader builds the directory name by interpolating the active mode slug,
+* and custom-mode slugs are restricted to this alphabet. Validating against it
+* also keeps an authored value from escaping `.roo/` through path separators or
+* `..` segments.
+*/
+const ROO_MODE_SLUG_PATTERN = /^[a-zA-Z0-9-]+$/;
+/**
+* `.roo/rules-{mode}/` — the mode-specific rule directory Roo/Zoo Code load
+* INSTEAD of `.roo/rules/` while that mode is active. The relative path is the
+* same in global scope, where it resolves under `~/.roo/`.
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/core/prompts/sections/custom-instructions.ts
+*/
+const rooModeRulesDirName = (mode) => `rules-${mode}`;
 const ROO_IGNORE_FILE_NAME = ".rooignore";
 /**
 * Roo Code reads project-level custom modes from a single aggregated
@@ -27775,6 +27794,27 @@ const defaultGetFactory$3 = (target) => {
 	if (!factory) throw new Error(`Unsupported tool target: ${target}`);
 	return factory;
 };
+/**
+* Warn about per-server tool filters the target tool cannot express.
+*
+* `enabledTools`/`disabledTools` are canonical fields, so a single
+* `.rulesync/.mcp.json` can carry a filter that only some targets read. The
+* unsupported ones are stripped before generation (writing them would produce a
+* key the tool discards on load), which used to happen silently — the filter
+* simply did not apply and nothing said so. Warning names the servers whose
+* filter is being dropped for this target so the gap is visible at generate
+* time rather than in the tool's behavior.
+*
+* Only fields actually present are reported, so a config that never authored
+* the filter stays quiet.
+*/
+function warnStrippedMcpServerFields({ mcpServers, fields, toolTarget, logger }) {
+	for (const field of fields) {
+		const serverNames = Object.entries(mcpServers ?? {}).filter(([, serverConfig]) => serverConfig[field] !== void 0).map(([serverName]) => serverName);
+		if (serverNames.length === 0) continue;
+		logger.warn(`${toolTarget} does not read the per-server \`${field}\` MCP tool filter; dropping it from ${serverNames.join(", ")}.`);
+	}
+}
 var McpProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
@@ -27854,6 +27894,12 @@ var McpProcessor = class extends FeatureProcessor {
 			const fieldsToStrip = [];
 			if (!factory.meta.supportsEnabledTools) fieldsToStrip.push("enabledTools");
 			if (!factory.meta.supportsDisabledTools) fieldsToStrip.push("disabledTools");
+			warnStrippedMcpServerFields({
+				mcpServers: targetedRulesyncMcp.getJson().mcpServers,
+				fields: fieldsToStrip,
+				toolTarget: this.toolTarget,
+				logger: this.logger
+			});
 			const filteredRulesyncMcp = targetedRulesyncMcp.stripMcpServerFields(fieldsToStrip);
 			return await factory.class.fromRulesyncMcp({
 				outputRoot: this.outputRoot,
@@ -33507,7 +33553,7 @@ function extractKiroOverride(toolsSettings) {
 	if (Object.keys(overrideToolsSettings).length === 0) return void 0;
 	return { toolsSettings: overrideToolsSettings };
 }
-function asStringArray(value) {
+function asStringArray$1(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 /**
@@ -33517,8 +33563,8 @@ function asStringArray(value) {
 */
 function rulesFromArrays(settings, allowKey, denyKey) {
 	const rules = {};
-	for (const pattern of asStringArray(settings[allowKey])) rules[pattern] = "allow";
-	for (const pattern of asStringArray(settings[denyKey])) rules[pattern] = "deny";
+	for (const pattern of asStringArray$1(settings[allowKey])) rules[pattern] = "allow";
+	for (const pattern of asStringArray$1(settings[denyKey])) rules[pattern] = "deny";
 	return rules;
 }
 //#endregion
@@ -36430,6 +36476,181 @@ var ZedPermissions = class ZedPermissions extends ToolPermissions {
 	}
 };
 //#endregion
+//#region src/constants/zoocode-paths.ts
+/**
+* Zoo Code is a VS Code extension, so its committable command allow/deny lists
+* are workspace settings rather than files in the `.roo/` agent-asset tree that
+* the other Zoo Code features write.
+*
+* `zoo-code.allowedCommands` / `zoo-code.deniedCommands` are contributed with no
+* `scope`, which in VS Code means `window` scope — settable in a workspace's
+* `.vscode/settings.json` — and `ClineProvider.mergeCommandLists()` unions the
+* workspace values into the effective auto-approval lists.
+*
+* The `zoo-code.*` namespace is Zoo-era (the v3.74.0 rebrand); the archived Roo
+* Code lineage spelled the same settings `roo-cline.*`, so this surface is
+* deliberately not shared with the `roo` target.
+*
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/package.json
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/core/webview/ClineProvider.ts
+*/
+const ZOOCODE_VSCODE_SETTINGS_DIR = ".vscode";
+const ZOOCODE_VSCODE_SETTINGS_FILE_NAME = "settings.json";
+const ZOOCODE_ALLOWED_COMMANDS_KEY = "zoo-code.allowedCommands";
+const ZOOCODE_DENIED_COMMANDS_KEY = "zoo-code.deniedCommands";
+//#endregion
+//#region src/features/permissions/zoocode-permissions.ts
+/**
+* The canonical category Zoo Code's command lists correspond to. Zoo Code gates
+* terminal command execution and nothing else through these settings, so only
+* `bash` maps; `read`/`write`/`edit`/`webfetch` have no workspace-settable
+* counterpart in the extension's contributions.
+*/
+const COMMAND_CATEGORY = "bash";
+function asStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string");
+}
+/**
+* Split one canonical category's rules into Zoo Code's two command lists.
+*
+* Zoo Code matches these entries as command **prefixes**: a command runs
+* without a confirmation prompt when it starts with an `allowedCommands` entry,
+* and is refused outright when it starts with a `deniedCommands` entry (deny
+* wins). `ask` is represented by listing the pattern in neither list, which
+* leaves Zoo Code's default approval prompt in charge.
+*
+* Each list is `undefined` when it would be empty, so the key is retracted from
+* the settings file rather than written as an empty array — an empty
+* `allowedCommands` and an absent one mean the same thing to Zoo Code, and the
+* absent form leaves no rulesync residue behind.
+*/
+function buildCommandLists(rules) {
+	const allowed = [];
+	const denied = [];
+	for (const [pattern, action] of Object.entries(rules)) if (action === "allow") allowed.push(pattern);
+	else if (action === "deny") denied.push(pattern);
+	return {
+		allowed: allowed.length > 0 ? allowed : void 0,
+		denied: denied.length > 0 ? denied : void 0
+	};
+}
+/**
+* Permissions generator for Zoo Code.
+*
+* Zoo Code has no policy file in its `.roo/` tree: the committable command
+* allow/deny lists are VS Code workspace settings
+* (`zoo-code.allowedCommands` / `zoo-code.deniedCommands` in
+* `.vscode/settings.json`), which `ClineProvider.mergeCommandLists()` unions
+* into the lists the auto-approval decision reads. That file is a
+* general-purpose workspace settings file with many unrelated keys, so reads
+* and writes merge into the existing JSONC (touching only the two managed keys)
+* and the file is never deleted.
+*
+* Only project scope is modeled: VS Code's user-scope `settings.json` lives at
+* a platform-dependent path outside rulesync's home-relative global model.
+*
+* The `roo` target deliberately does not get this adapter. The settings
+* namespace is Zoo-era (`roo-cline.*` before the v3.74.0 rebrand), and Roo Code
+* is EOL with its repository archived, so emitting `zoo-code.*` keys for a
+* `--targets roo` generate would write settings that Roo itself never reads.
+*
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/package.json
+* @see https://github.com/Zoo-Code-Org/Zoo-Code/blob/main/src/core/auto-approval/commands.ts
+*/
+var ZoocodePermissions = class ZoocodePermissions extends ToolPermissions {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	/**
+	* `.vscode/settings.json` is a user-managed workspace file with unrelated
+	* settings, so it must not be deleted.
+	*/
+	isDeletable() {
+		return false;
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: ZOOCODE_VSCODE_SETTINGS_DIR,
+			relativeFilePath: ZOOCODE_VSCODE_SETTINGS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true }) {
+		const paths = ZoocodePermissions.getSettablePaths();
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{}";
+		return new ZoocodePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions }) {
+		const paths = ZoocodePermissions.getSettablePaths();
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "{}";
+		const rules = rulesyncPermissions.getJson().permission[COMMAND_CATEGORY];
+		const patch = {};
+		if (rules !== void 0) {
+			const { allowed, denied } = buildCommandLists(rules);
+			patch[ZOOCODE_ALLOWED_COMMANDS_KEY] = allowed;
+			patch[ZOOCODE_DENIED_COMMANDS_KEY] = denied;
+		}
+		return new ZoocodePermissions({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "permissions",
+				existingContent,
+				patch,
+				filePath
+			}),
+			validate: true
+		});
+	}
+	toRulesyncPermissions() {
+		let settings;
+		try {
+			settings = parseSharedConfig({
+				format: "jsonc",
+				fileContent: this.getFileContent() || "{}",
+				filePath: join(this.getRelativeDirPath(), this.getRelativeFilePath()),
+				invalidRootPolicy: "error",
+				jsoncParseErrors: "error"
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse Zoo Code VS Code settings in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const rules = {};
+		for (const pattern of asStringArray(settings[ZOOCODE_ALLOWED_COMMANDS_KEY])) rules[pattern] = "allow";
+		for (const pattern of asStringArray(settings[ZOOCODE_DENIED_COMMANDS_KEY])) rules[pattern] = "deny";
+		const permission = {};
+		if (Object.keys(rules).length > 0) permission[COMMAND_CATEGORY] = rules;
+		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify({ permission }, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new ZoocodePermissions({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "{}",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/permissions/permissions-processor.ts
 const PermissionsProcessorToolTargetSchema = z.enum(permissionsProcessorToolTargetTuple);
 const toolPermissionsFactories = /* @__PURE__ */ new Map([
@@ -36672,6 +36893,14 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 			supportsGlobal: true,
 			supportsImport: true
 		}
+	}],
+	["zoocode", {
+		class: ZoocodePermissions,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: false,
+			supportsImport: true
+		}
 	}]
 ]);
 var PermissionsProcessor = class extends FeatureProcessor {
@@ -52051,11 +52280,12 @@ var RooRule = class RooRule extends ToolRule {
 	static getSettablePaths(_options = {}) {
 		return { nonRoot: { relativeDirPath: buildToolPath(ROO_DIR, "rules", _options.excludeToolDir) } };
 	}
-	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, validate = true }) {
-		const fileContent = await readFileContent(join(outputRoot, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath));
+	static async fromFile({ outputRoot = process.cwd(), relativeFilePath, relativeDirPath: overrideDirPath, validate = true }) {
+		const relativeDirPath = overrideDirPath !== void 0 && RooRule.extractModeFromDirPath(overrideDirPath) !== void 0 ? overrideDirPath : this.getSettablePaths().nonRoot.relativeDirPath;
+		const fileContent = await readFileContent(join(outputRoot, relativeDirPath, relativeFilePath));
 		return new RooRule({
 			outputRoot,
-			relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
+			relativeDirPath,
 			relativeFilePath,
 			fileContent,
 			validate,
@@ -52063,12 +52293,16 @@ var RooRule = class RooRule extends ToolRule {
 		});
 	}
 	static fromRulesyncRule({ outputRoot = process.cwd(), rulesyncRule, validate = true }) {
-		return new RooRule(this.buildToolRuleParamsDefault({
+		const params = this.buildToolRuleParamsDefault({
 			outputRoot,
 			rulesyncRule,
 			validate,
 			nonRootPath: this.getSettablePaths().nonRoot
-		}));
+		});
+		const mode = rulesyncRule.getFrontmatter().roo?.mode;
+		if (!params.root && mode !== void 0 && mode !== "") if (!ROO_MODE_SLUG_PATTERN.test(mode)) warnWithFallback(void 0, `Ignoring roo.mode "${mode}" on ${rulesyncRule.getRelativeFilePath()}: a mode slug may contain only letters, digits and hyphens. Writing the rule to ${params.relativeDirPath} instead.`);
+		else params.relativeDirPath = join(dirname(params.relativeDirPath), rooModeRulesDirName(mode));
+		return new RooRule(params);
 	}
 	/**
 	* Extract mode slug from file path for mode-specific rules
@@ -52080,8 +52314,51 @@ var RooRule = class RooRule extends ToolRule {
 		const singleFileMatch = filePath.match(/\.(roo|cline)rules-([a-zA-Z0-9-]+)$/);
 		if (singleFileMatch) return singleFileMatch[2];
 	}
+	/**
+	* The mode slug of a `.roo/rules-{mode}/` directory, or `undefined` for the
+	* generic `.roo/rules/` directory and anything else. Path-shaped input is
+	* rejected by the slug pattern, so a crafted directory name cannot be lifted
+	* back into frontmatter.
+	*/
+	static extractModeFromDirPath(relativeDirPath) {
+		for (const segment of toPosixPath(relativeDirPath).split("/")) {
+			if (!segment.startsWith("rules-")) continue;
+			const mode = segment.slice(6);
+			if (ROO_MODE_SLUG_PATTERN.test(mode)) return mode;
+		}
+	}
 	toRulesyncRule() {
-		return this.toRulesyncRuleDefault();
+		const mode = RooRule.extractModeFromDirPath(this.getRelativeDirPath());
+		if (mode === void 0) return this.toRulesyncRuleDefault();
+		const baseName = this.getRelativeFilePath().replace(/\.md$/, "");
+		const suffix = `-${mode}`;
+		const importedName = baseName.endsWith(suffix) ? baseName : `${baseName}${suffix}`;
+		return new RulesyncRule({
+			outputRoot: this.getOutputRoot(),
+			relativeDirPath: RulesyncRule.getSettablePaths().recommended.relativeDirPath,
+			relativeFilePath: `${importedName}.md`,
+			frontmatter: {
+				root: false,
+				targets: [this.constructor.getToolTargetName()],
+				description: this.description,
+				globs: this.globs ?? [],
+				roo: { mode }
+			},
+			body: this.getFileContent(),
+			validate: true
+		});
+	}
+	/**
+	* Mode-specific rule directories (`.roo/rules-{mode}/`), which Roo/Zoo Code
+	* load instead of `.roo/rules/` while that mode is active. Import-only: the
+	* generic directory is the only one the deletion sweep enumerates, because a
+	* `rules-*` glob would also match mode rules a user wrote by hand.
+	*/
+	static getNestedFilePatterns({ outputRoot }) {
+		return {
+			include: [`${toPosixPath(outputRoot)}/${toPosixPath(ROO_DIR)}/rules-*/**/*.md`],
+			ignore: []
+		};
 	}
 	validate() {
 		return {
@@ -52102,10 +52379,18 @@ var RooRule = class RooRule extends ToolRule {
 	static isTargetedByRulesyncRule(rulesyncRule) {
 		return this.isTargetedByRulesyncRuleDefault({
 			rulesyncRule,
-			toolTarget: "roo"
+			toolTarget: this.getToolTargetName()
 		});
 	}
 	/**
+	* The tool target this class imports as. `ZoocodeRule` narrows the same
+	* `.roo/` adapters to the `zoocode` target, so the name has to come from the
+	* class rather than a literal.
+	*/
+	static getToolTargetName() {
+		return "roo";
+	}
+	/**
 	* Glob for the `separate-local-file` deletion; Roo reads `AGENTS.local.md`
 	* at the project root, not under `.roo/` (mirrors rovodev).
 	*/
@@ -52638,11 +52923,8 @@ var ZedRule = class ZedRule extends ToolRule {
 * @see https://docs.zoocode.dev
 */
 var ZoocodeRule = class extends RooRule {
-	static isTargetedByRulesyncRule(rulesyncRule) {
-		return this.isTargetedByRulesyncRuleDefault({
-			rulesyncRule,
-			toolTarget: "zoocode"
-		});
+	static getToolTargetName() {
+		return "zoocode";
 	}
 };
 //#endregion
@@ -55611,4 +55893,4 @@ async function importChecksCore(params) {
 //#endregion
 export { JsonLogger as $, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as $t, RulesyncRuleFrontmatterSchema as A, ALL_TOOL_TARGETS_WITH_WILDCARD as At, RulesyncCheck as B, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as Bt, CODEXCLI_DIR as C, removeTempDirectory as Ct, RulesyncSkill as D, writeFileBuffer as Dt, RulesyncSubagentFrontmatterSchema as E, toPosixPath as Et, getRulesyncSourceCandidates as F, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as Ft, SKILL_FILE_NAME as G, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Gt, stringifyFrontmatter as H, RULESYNC_HOOKS_FILE_NAME as Ht, resolveRulesyncSourceWritePath as I, RULESYNC_CHECKS_RELATIVE_DIR_PATH as It, ConfigFileSchema as J, RULESYNC_MCP_LEGACY_FILE_NAME as Jt, ConfigResolver as K, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as Kt, parseJsonc as L, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as Lt, RulesyncMcp as M, ToolTargetSchema as Mt, RulesyncIgnore as N, MAX_FILE_SIZE as Nt, RulesyncSkillFrontmatterSchema as O, writeFileContent as Ot, RulesyncHooks as P, RULESYNC_AIIGNORE_FILE_NAME as Pt, ConsoleLogger as Q, RULESYNC_PERMISSIONS_FILE_NAME as Qt, RulesyncCommand as R, RULESYNC_CONFIG_RELATIVE_FILE_PATH as Rt, CODEXCLI_BASH_RULES_FILE_NAME as S, removeFileStrict as St, RulesyncSubagent as T, runWithDirectoryRollback as Tt, loadYaml as U, RULESYNC_HOOKS_LEGACY_FILE_NAME as Ut, RulesyncCheckFrontmatterSchema as V, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as Vt, SHARED_USER_MANAGED_CONFIG_PATHS as W, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Wt, SourceEntrySchema as X, RULESYNC_MCP_SCHEMA_URL as Xt, GITIGNORE_DESTINATION_KEY as Y, RULESYNC_MCP_RELATIVE_FILE_PATH as Yt, findControlCharacter as Z, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Zt, CLAUDECODE_LOCAL_RULE_FILE_NAME as _, readFileContent as _t, convertFromTool as a, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as an, assertTreeContainsNoSymlinks as at, CLAUDECODE_SKILLS_DIR_PATH as b, removeDirectoryStrict as bt, SubagentsProcessor as c, ALL_FEATURES_WITH_WILDCARD as cn, createTempDirectory as ct, IgnoreProcessor as d, fileExists as dt, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as en, fallbackLogger as et, HooksProcessor as f, findFilesByGlobs as ft, CLAUDECODE_DIR as g, listDirectoryFiles as gt, QWENCODE_LOCAL_RULE_FILE_NAME as h, isSymlink as ht, getProcessorRegistryEntry as i, RULESYNC_SKILLS_RELATIVE_DIR_PATH as in, assertDirectoryIfExists as it, RulesyncPermissions as j, PACKAGING_TOOL_TARGETS as jt, RulesyncRule as k, ALL_TOOL_TARGETS as kt, SkillsProcessor as l, DEPRECATED_FEATURE_REPLACEMENTS as ln, directoryExists as lt, QWENCODE_DIR as m, getHomeDirectory as mt, checkRulesyncDirExists as n, RULESYNC_RELATIVE_DIR_PATH as nn, CLIError as nt, isPackagingToolTarget as o, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as on, assertWritablePathInsideRoot as ot, CommandsProcessor as p, getFileSize as pt, CONFLICTING_TARGET_PAIRS as q, RULESYNC_MCP_FILE_NAME as qt, generate as r, RULESYNC_RULES_RELATIVE_DIR_PATH as rn, ErrorCodes as rt, RulesProcessor as s, ALL_FEATURES as sn, checkPathTraversal as st, importFromTool as t, RULESYNC_PERMISSIONS_SCHEMA_URL as tn, warnOnConflictingFlags as tt, McpProcessor as u, formatError as un, ensureDir as ut, CLAUDECODE_MEMORIES_DIR_NAME as v, readFileContentOrNull as vt, getLocalSkillDirNames as w, resolvePath as wt, ChecksProcessor as x, removeFile as xt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as y, removeDirectory as yt, RulesyncCommandFrontmatterSchema as z, RULESYNC_CONFIG_SCHEMA_URL as zt };
 
-//# sourceMappingURL=import-Dswkc7Ub.js.map
+//# sourceMappingURL=import-Ds0QeVp6.js.map