rulesync 32.0.0 → 33.0.0

package/dist/{import-DgKWnDni.js → import-5-Uennl1.js}

@@ -21744,22 +21744,29 @@ function mergeOpencodeV2Entries({ config, legacyKey, pluralKey, lower }) {
 		const entry = asOpencodeEntries(value);
 		const lowered = entry === null ? null : lower(entry);
 		if (Object.hasOwn(merged, name) || lowered === null) continue;
-		Object.defineProperty(merged, name, {
-			value: lowered,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		});
+		setOwnEntry(merged, name, lowered);
 	}
 	return Object.keys(merged).length > 0 ? merged : legacy;
 }
 /**
+* Sets `target[key]` as an own, enumerable property. A plain assignment to a
+* key named `__proto__` would set the prototype instead.
+*/
+function setOwnEntry(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
+/**
 * Returns the inline agent entries of an OpenCode config in the V1 `agent`
 * shape. Since v1.18.24 OpenCode V1 also reads the V2 `agents` spelling and
 * lowers it, so a layout that does so (`readsV2ConfigSpellings`) gets those
 * entries too.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeAgentEntries({ config, layout = OPENCODE_LAYOUT }) {
 	if (!layout.readsV2ConfigSpellings) return asOpencodeEntries(config.agent);
@@ -21778,7 +21785,7 @@ function getOpencodeAgentEntries({ config, layout = OPENCODE_LAYOUT }) {
 * Other fields are kept: V1 drops a V2 `subagent`, but rulesync reads it as
 * `subtask` everywhere (as V2 does), so it is left for the command importer.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeCommandEntries({ config, layout = OPENCODE_LAYOUT }) {
 	if (!layout.readsV2ConfigSpellings) return asOpencodeEntries(config.command);
@@ -21801,7 +21808,7 @@ function getOpencodeCommandEntries({ config, layout = OPENCODE_LAYOUT }) {
 * reads V2 spellings, a flat V2 `skills` array is accepted too: its entries
 * that are not `http(s)://` URLs are the paths, as OpenCode V1 lowers them.
 *
-* @see https://github.com/anomalyco/opencode/blob/v1.18.34/packages/opencode/src/config/v2-compat.ts
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
 */
 function getOpencodeSkillPaths({ config, layout = OPENCODE_LAYOUT }) {
 	if (Array.isArray(config.skills)) {
@@ -21811,6 +21818,160 @@ function getOpencodeSkillPaths({ config, layout = OPENCODE_LAYOUT }) {
 	const skills = asOpencodeEntries(config.skills);
 	return skills !== null && Array.isArray(skills.paths) ? skills.paths : [];
 }
+/**
+* Whether a record is itself an MCP server entry rather than a V2 container
+* (`mcp.servers`, `mcp.timeout`): a server — or a server literally named
+* `type` / `enabled` — carries a scalar `type` or `enabled`. Mirrors OpenCode
+* V1's `isDirectServer`.
+*/
+function isDirectOpencodeMcpServer(value) {
+	return ["type", "enabled"].some((key) => Object.hasOwn(value, key) && (value[key] === null || typeof value[key] !== "object" || Array.isArray(value[key])));
+}
+const OPENCODE_V2_TIMEOUT_KEYS = [
+	"startup",
+	"catalog",
+	"execution"
+];
+/**
+* Whether an MCP server entry uses a V2-only per-server spelling, so that
+* OpenCode V1 lowers it: `disabled`, `codemode`, an object `timeout`, or a
+* snake_case `oauth` key.
+*/
+function isOpencodeV2NativeServer(value) {
+	const oauth = value.oauth;
+	return Object.hasOwn(value, "disabled") || Object.hasOwn(value, "codemode") || isRecord$1(value.timeout) || isRecord$1(oauth) && [
+		"client_id",
+		"client_secret",
+		"callback_port",
+		"redirect_uri"
+	].some((key) => Object.hasOwn(oauth, key));
+}
+/**
+* Lowers a V2 timeout object (`{ startup, catalog, execution }`) to V1's single
+* number, the way OpenCode V1 does: only a `catalog` equal to `execution`, with
+* no `startup`, has a V1 equivalent. Anything else — including a value that is
+* not a positive integer — is `undefined` (dropped).
+*/
+function lowerOpencodeV2Timeout(value) {
+	if (!hasPositiveIntegerTimeouts(value) || value.startup !== void 0 || typeof value.catalog !== "number") return;
+	return value.catalog === value.execution ? value.catalog : void 0;
+}
+const OPENCODE_V2_OAUTH_KEYS = /* @__PURE__ */ new Map([
+	["client_id", "clientId"],
+	["client_secret", "clientSecret"],
+	["callback_port", "callbackPort"],
+	["redirect_uri", "redirectUri"]
+]);
+/**
+* V2 `oauth` keys that have no V1 spelling. OpenCode V1 drops them when it
+* lowers a server, so they are dropped (and reported) here too rather than
+* being written back as a snake_case key among camelCase ones.
+*/
+const OPENCODE_V2_UNSUPPORTED_OAUTH_KEYS = /* @__PURE__ */ new Set(["auth_server_metadata_url"]);
+function lowerOpencodeV2OAuth(oauth, path, onDropped) {
+	const lowered = {};
+	for (const [key, value] of Object.entries(oauth)) {
+		if (OPENCODE_V2_UNSUPPORTED_OAUTH_KEYS.has(key)) {
+			onDropped?.(`${path}.${key}`, "unsupported");
+			continue;
+		}
+		setOwnEntry(lowered, OPENCODE_V2_OAUTH_KEYS.get(key) ?? key, value);
+	}
+	return lowered;
+}
+/**
+* Lowers one V2-spelled MCP server entry to V1's shape, as OpenCode V1 does:
+* `disabled` becomes `enabled` (an explicit `enabled` wins), an object
+* `timeout` becomes a number or is dropped, and snake_case `oauth` keys become
+* camelCase. `codemode` is kept: Rulesync passes it through where V1 drops it.
+*
+* Like V1, only an entry that is a local or remote server is lowered, and one
+* whose `enabled` or `disabled` is not a boolean is left as it is. Unlike V1,
+* such an entry is not dropped but passed on, so the schema rejects it loudly.
+*/
+function lowerOpencodeV2Server(value, path, onDropped) {
+	if (!isRecord$1(value) || value.type !== "local" && value.type !== "remote" || Object.hasOwn(value, "enabled") && typeof value.enabled !== "boolean" || Object.hasOwn(value, "disabled") && typeof value.disabled !== "boolean") return value;
+	const { disabled, timeout, ...rest } = value;
+	const lowered = { ...rest };
+	if (!Object.hasOwn(value, "enabled")) lowered.enabled = disabled !== true;
+	else if (value.enabled === disabled) onDropped?.(`${path}.disabled`, "conflict");
+	const lowTimeout = isRecord$1(timeout) ? lowerOpencodeV2Timeout(timeout) : timeout;
+	if (lowTimeout !== void 0) lowered.timeout = lowTimeout;
+	else if (isRecord$1(timeout) && Object.keys(timeout).length > 0) onDropped?.(`${path}.timeout`, "unsupported");
+	if (isRecord$1(value.oauth)) lowered.oauth = lowerOpencodeV2OAuth(value.oauth, `${path}.oauth`, onDropped);
+	return lowered;
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+/** Whether each V2 timeout value a record carries is a positive integer. */
+function hasPositiveIntegerTimeouts(value) {
+	return OPENCODE_V2_TIMEOUT_KEYS.every((key) => value[key] === void 0 || isPositiveInteger(value[key]));
+}
+/**
+* Whether `mcp.timeout` is V2's global timeout object rather than a server
+* named `timeout`. As in OpenCode V1, each of its values must be a positive
+* integer; anything else is read as a server, which the schema then rejects.
+*/
+function isOpencodeV2GlobalTimeout(value) {
+	return isRecord$1(value) && !isDirectOpencodeMcpServer(value) && (Object.keys(value).length === 0 || OPENCODE_V2_TIMEOUT_KEYS.some((key) => Object.hasOwn(value, key))) && hasPositiveIntegerTimeouts(value);
+}
+function getOpencodeV2McpEnvelope(mcp) {
+	const nested = mcp.servers;
+	return isRecord$1(nested) && !isDirectOpencodeMcpServer(nested) ? nested : null;
+}
+/**
+* Returns the paths of the V2-only containers in an OpenCode `mcp` value that
+* a write in V1's flat shape does not keep: a non-empty `mcp.servers`
+* envelope, and a non-empty global `mcp.timeout`.
+*/
+function findOpencodeV2McpContainers(mcp) {
+	if (!isRecord$1(mcp)) return [];
+	const envelope = getOpencodeV2McpEnvelope(mcp);
+	return [...envelope !== null && Object.keys(envelope).length > 0 ? ["mcp.servers"] : [], ...isOpencodeV2GlobalTimeout(mcp.timeout) && Object.keys(mcp.timeout).length > 0 ? ["mcp.timeout"] : []];
+}
+/**
+* Lowers OpenCode V2 `mcp` spellings found in a V1 config to the flat V1 map,
+* the way OpenCode V1 itself does since v1.18.24 (`normalizeMcp`):
+*
+* - entries of the `mcp.servers` envelope are merged into the map, a flat entry
+*   of the same name winning;
+* - V2-spelled server entries (`disabled`, an object `timeout`, snake_case
+*   `oauth` keys) are lowered by {@link lowerOpencodeV2Server};
+* - the global `mcp.timeout` object is skipped. V1 moves it to
+*   `experimental.mcp_timeout`, a default request timeout that has no
+*   canonical counterpart, so it is not read as a server either.
+*
+* Unlike V1, an envelope entry that is not a valid server is not dropped: it
+* is passed on, so the schema rejects it loudly rather than it vanishing
+* without a word. Each value that is dropped — a non-empty global timeout, a
+* per-server timeout object or `oauth` key with no V1 equivalent, or an
+* envelope entry shadowed by a different flat entry — is reported through
+* `onDropped`.
+*
+* @see https://github.com/anomalyco/opencode/blob/v1.18.35/packages/opencode/src/config/v2-compat.ts
+* @see https://opencode.ai/v2/docs/mcp-servers/
+*/
+function lowerOpencodeV2Mcp(mcp, onDropped) {
+	if (!isRecord$1(mcp)) return mcp;
+	const envelope = getOpencodeV2McpEnvelope(mcp);
+	const globalTimeout = isOpencodeV2GlobalTimeout(mcp.timeout);
+	if (findOpencodeV2McpContainers(mcp).includes("mcp.timeout")) onDropped?.("mcp.timeout", "unsupported");
+	const servers = {};
+	for (const [name, value] of Object.entries(mcp)) {
+		if (name === "servers" && envelope !== null || name === "timeout" && globalTimeout) continue;
+		setOwnEntry(servers, name, isRecord$1(value) && isOpencodeV2NativeServer(value) ? lowerOpencodeV2Server(value, `mcp.${name}`, onDropped) : value);
+	}
+	for (const [name, value] of Object.entries(envelope ?? {})) {
+		const path = `mcp.servers.${name}`;
+		if (Object.hasOwn(servers, name)) {
+			if (!isDeepStrictEqual(servers[name], value)) onDropped?.(path, "conflict");
+			continue;
+		}
+		setOwnEntry(servers, name, lowerOpencodeV2Server(value, path, onDropped));
+	}
+	return servers;
+}
 /** Matches a string whose entire value is an OpenCode `{file:...}` reference. */
 const OPENCODE_FILE_TEMPLATE_PATTERN = /^\s*\{file:(.+?)\}\s*$/;
 /**
@@ -45559,18 +45720,21 @@ var KiroMcp = class KiroMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/opencode-mcp.ts
+const OpencodeMcpV2DisabledSchema = z.optional(z.boolean());
 const OpencodeMcpLocalServerSchema = z.looseObject({
 	type: z.literal("local"),
 	command: z.array(z.string()),
 	environment: z.optional(z.record(z.string(), z.string())),
 	enabled: z._default(z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema,
 	cwd: z.optional(z.string())
 });
 const OpencodeMcpRemoteServerSchema = z.looseObject({
 	type: z.literal("remote"),
 	url: z.string(),
 	headers: z.optional(z.record(z.string(), z.string())),
-	enabled: z._default(z.boolean(), true)
+	enabled: z._default(z.boolean(), true),
+	disabled: OpencodeMcpV2DisabledSchema
 });
 const OPENCODE_PASSTHROUGH_SERVER_FIELDS = [
 	"timeout",
@@ -45582,7 +45746,7 @@ const OPENCODE_MCP_TRANSPORT_KEYS = [
 	...Object.keys(OpencodeMcpLocalServerSchema.def.shape),
 	...Object.keys(OpencodeMcpRemoteServerSchema.def.shape),
 	...OPENCODE_PASSTHROUGH_SERVER_FIELDS
-].filter((key) => key !== "enabled");
+].filter((key) => key !== "enabled" && key !== "disabled");
 /**
 * A bare toggle entry: `{"enabled": <bool>}` with no transport of its own,
 * disabling a server another config layer defines. It is the third member of
@@ -45710,7 +45874,7 @@ const OPENCODE_TOGGLE_KEPT_KEYS = /* @__PURE__ */ new Set([
 function warnAboutToggleDroppedKeys(serverName, serverConfig, logger) {
 	const dropped = Object.keys(serverConfig).filter((key) => !OPENCODE_TOGGLE_KEPT_KEYS.has(key));
 	if (dropped.length === 0) return;
-	logger?.warn(`OpenCode MCP: "${serverName}" declares no transport, so it is written as a toggle entry and ${dropped.toSorted().join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
+	logger?.warn(`OpenCode MCP: ${quoteValueForWarning(serverName)} declares no transport, so it is written as a toggle entry and ${dropped.toSorted().map(quoteValueForWarning).join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped.`);
 }
 /**
 * Convert standard MCP format to OpenCode native format
@@ -45790,9 +45954,35 @@ var OpencodeMcp = class extends ToolMcp {
 	/** Directory layout; OpenCode forks (MiMo Code) override it. */
 	static layout = OPENCODE_LAYOUT;
 	json;
-	constructor(params) {
+	/**
+	* With a `logger`, the V2 values that lowering the content drops are warned
+	* about (see {@link OpencodeMcp.lowerConfig}); `fromFile` passes one so the
+	* warnings come from the lowering that builds the parsed view rather than
+	* from an extra pass of their own. (`validate()`, which the parent
+	* constructor calls before this view exists, lowers separately and silently.)
+	*/
+	constructor({ logger, ...params }) {
 		super(params);
-		this.json = OpencodeConfigSchema.parse(parse$1(this.fileContent || "{}"));
+		this.json = OpencodeConfigSchema.parse(this.constructor.lowerConfig(parse$1(this.fileContent || "{}"), logger));
+	}
+	/**
+	* Lowers the OpenCode V2 `mcp` spellings of a parsed config for a layout
+	* that reads them (see {@link lowerOpencodeV2Mcp}), so every reader — import,
+	* the toggle lookup on generate, and the rules feature's `instructions`
+	* write to the same file — accepts a V2-shaped `mcp`. Only the parsed view
+	* is lowered; content written back keeps whatever `mcp` a feature that does
+	* not own the key found there. With a `logger`, each V2 value the lowering
+	* drops is warned about.
+	*/
+	static lowerConfig(json, logger) {
+		if (!this.layout.readsV2ConfigSpellings || !isRecord$1(json) || json.mcp === void 0) return json;
+		return {
+			...json,
+			mcp: lowerOpencodeV2Mcp(json.mcp, (path, reason) => {
+				const quoted = quoteValueForWarning(path);
+				logger?.warn(reason === "conflict" ? `OpenCode MCP: ${quoted} conflicts with a V1 value that takes precedence (the flat "mcp" entry of the same name, or "enabled"), so it is dropped on import.` : `OpenCode MCP: ${quoted} has no Rulesync equivalent, so it is dropped on import.`);
+			})
+		};
 	}
 	getJson() {
 		return this.json;
@@ -45809,7 +45999,7 @@ var OpencodeMcp = class extends ToolMcp {
 			relativeFilePath: this.layout.jsonFileName
 		};
 	}
-	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false, logger }) {
 		const basePaths = this.getSettablePaths({ global });
 		const jsonDir = join(outputRoot, basePaths.relativeDirPath);
 		let fileContent = null;
@@ -45831,7 +46021,8 @@ var OpencodeMcp = class extends ToolMcp {
 			relativeDirPath: basePaths.relativeDirPath,
 			relativeFilePath,
 			fileContent: JSON.stringify(newJson, null, 2),
-			validate
+			validate,
+			logger
 		});
 	}
 	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
@@ -45850,7 +46041,12 @@ var OpencodeMcp = class extends ToolMcp {
 			mcpServers: rulesyncMcp.getMcpServers(),
 			replacement: "{env:$1}"
 		});
-		const existingMcp = OpencodeConfigSchema.safeParse(parse$1(fileContent || "{}"));
+		const existingJson = parse$1(fileContent || "{}");
+		const existingMcp = OpencodeConfigSchema.safeParse(this.lowerConfig(existingJson));
+		if (this.layout.readsV2ConfigSpellings && isRecord$1(existingJson)) {
+			const containers = findOpencodeV2McpContainers(existingJson.mcp);
+			if (containers.length > 0) logger?.warn(`OpenCode MCP: the whole "mcp" key is rewritten in the flat V1 shape, so ${containers.map(quoteValueForWarning).join(" and ")} ${containers.length === 1 ? "is" : "are"} not kept.`);
+		}
 		const { mcp: convertedMcp, tools: mcpTools } = convertToOpencodeFormat(transformedServers, (existingMcp.success ? existingMcp.data.mcp : void 0) ?? {}, logger);
 		return new this({
 			outputRoot,
@@ -45950,7 +46146,7 @@ var OpencodeMcp = class extends ToolMcp {
 	}
 	validate() {
 		const json = parseJsonc(this.fileContent || "{}");
-		const result = OpencodeConfigSchema.safeParse(json);
+		const result = OpencodeConfigSchema.safeParse(this.constructor.lowerConfig(json));
 		if (!result.success) return {
 			success: false,
 			error: result.error
@@ -101732,4 +101928,4 @@ async function importChecksCore(params) {
 //#endregion
 export { RulesyncHooks as $, removeFile as $t, groupSpellingsByCaseFoldedIdentity as A, RULESYNC_RELATIVE_DIR_PATH as An, applyFileMode as At, QWENCODE_LOCAL_RULE_FILE_NAME as B, DEPRECATED_FEATURE_REPLACEMENTS as Bn, getFileSize as Bt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as C, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Cn, fallbackLogger as Ct, FACTORYDROID_DIR as D, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, withWarnOnceScope as Dt, ChecksProcessor as E, RULESYNC_MCP_SCHEMA_URL as En, resetRunWarningState as Et, CLAUDECODE_LOCAL_RULE_FILE_NAME as F, RULESYNC_USER_CONFIG_DIR_NAME as Fn, createTempDirectory as Ft, RulesyncSubagentFrontmatterSchema as G, quoteForLog as Gn, listDirectoryEntryNames as Gt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as H, truncateText as Hn, isFileNotFoundError as Ht, CLAUDECODE_MEMORIES_DIR_NAME as I, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as In, directoryExists as It, RulesyncRule as J, stripHiddenCharacters as Jn, pathEscapesRoot as Jt, RulesyncSkill as K, stripControlCharacters as Kn, listFilePathsRecursively as Kt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as L, parseCommaSeparatedList as Ln, ensureDir as Lt, CODEXCLI_DIR as M, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Mn, assertTreeContainsNoSymlinks as Mt, CLAUDECODE_AGENT_MEMORY_LOCAL_DIR_NAME as N, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Nn, assertWritablePathInsideRoot as Nt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as O, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as On, CLIError as Ot, CLAUDECODE_DIR as P, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Pn, checkPathTraversal as Pt, RulesyncIgnore as Q, removeDirectoryStrict as Qt, CLAUDECODE_SKILLS_DIR_PATH as R, ALL_FEATURES as Rn, fileExists as Rt, COMMANDCODE_DIR as S, RULESYNC_HOOKS_RELATIVE_FILE_PATH as Sn, WarningCollectingLogger as St, CODEBUDDY_LOCAL_RULE_FILE_NAME as T, RULESYNC_MCP_RELATIVE_FILE_PATH as Tn, withFallbackLoggerTarget as Tt, getLocalSkillDirNames as U, hasDeceptiveHiddenCharacters as Un, isFileSystemError as Ut, AUGMENTCODE_DIR as V, formatError as Vn, getHomeDirectory as Vt, RulesyncSubagent as W, hasEnclosingMarkOutsideKeycap as Wn, isSymlink as Wt, RulesyncPermissions as X, readFileContentOrNull as Xt, RulesyncRuleFrontmatterSchema as Y, readFileContent as Yt, RulesyncMcp as Z, removeDirectory as Zt, LETTACODE_DIR as _, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as _n, SourceEntrySchema as _t, getProcessorRegistryEntry as a, toPosixPath as an, RulesyncCheck as at, CommandsProcessor as b, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as bn, ConsoleLogger as bt, RulesProcessor as c, ALL_TOOL_TARGETS as cn, loadYaml as ct, ELLIPSIS_WIDTH as d, ToolTargetSchema as dn, ConfigResolver as dt, removeFileStrict as en, getRulesyncSourceCandidates as et, displayWidthOf as f, CURATED_RULES_FEATURE_SUBDIR as fn, mergeInputRootConfigs as ft, HooksProcessor as g, RULESYNC_CHECKS_RELATIVE_DIR_PATH as gn, GITIGNORE_DESTINATION_KEY as gt, IgnoreProcessor as h, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as hn, ConfigFileSchema as ht, inspectInputRoots as i, splitPathSegments as in, RulesyncCommandFrontmatterSchema as it, CODEXCLI_BASH_RULES_FILE_NAME as j, RULESYNC_RULES_RELATIVE_DIR_PATH as jn, assertDirectoryIfExists as jt, caseFoldIdentity as k, RULESYNC_PERMISSIONS_SCHEMA_URL as kn, ErrorCodes as kt, SubagentsProcessor as l, ALL_TOOL_TARGETS_WITH_WILDCARD as ln, SHARED_USER_MANAGED_CONFIG_PATHS as lt, McpProcessor as m, MAX_FILE_SIZE as mn, CONFLICTING_TARGET_PAIRS as mt, formatSourceLoadFailure as n, resolvePath as nn, parseJsonc as nt, convertFromTool as o, writeFileBuffer as on, RulesyncCheckFrontmatterSchema as ot, shortenToWidth as p, FEATURE_SOURCE_TREE_ENTRIES as pn, resolveEffectiveInputRoots as pt, RulesyncSkillFrontmatterSchema as q, stripControlCharactersKeepingLineFeeds as qn, listSubdirectoryNames as qt, generate as r, runWithDirectoryRollback as rn, RulesyncCommand as rt, isPackagingToolTarget as s, writeFileContent as sn, stringifyFrontmatter as st, importFromTool as t, removeTempDirectory as tn, resolveRulesyncSourceWritePath as tt, SkillsProcessor as u, PACKAGING_TOOL_TARGETS as un, SKILL_FILE_NAME as ut, LETTACODE_SETTINGS_LOCAL_FILE_NAME as v, RULESYNC_CONFIG_RELATIVE_FILE_PATH as vn, assertTargetsFeaturesExclusive as vt, CODEBUDDY_DIR as w, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as wn, warnOnConflictingFlags as wt, REASONIX_LOCAL_RULE_FILE_NAME as x, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as xn, JsonLogger as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_CONFIG_SCHEMA_URL as yn, findControlCharacter as yt, QWENCODE_DIR as z, ALL_FEATURES_WITH_WILDCARD as zn, findFilesByGlobs as zt };
 
-//# sourceMappingURL=import-DgKWnDni.js.map
+//# sourceMappingURL=import-5-Uennl1.js.map