rulesync 14.0.1 → 14.1.0

package/dist/{import-CSnC5vl7.js → import-BN4K49Ta.js}

@@ -30,6 +30,7 @@ const ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 const FeatureSchema = z.enum(ALL_FEATURES);
 z.array(FeatureSchema);
 const GitignoreDestinationSchema = z.enum(["gitignore", "gitattributes"]);
+const FlattenedCommandNamingSchema = z.enum(["basename", "path"]);
 const FeatureOptionsSchema = z.record(z.string(), z.unknown());
 const FeatureValueSchema = z.union([
 	z.boolean(),
@@ -322,6 +323,7 @@ const hooksProcessorToolTargetTuple = [
 	"copilot",
 	"copilotcli",
 	"opencode",
+	"pi",
 	"factorydroid",
 	"goose",
 	"hermesagent",
@@ -695,16 +697,9 @@ var BaseLogger = class {
 		return this._silent;
 	}
 	configure({ verbose, silent }) {
-		if (verbose && silent) {
-			this._silent = false;
-			if (!isEnvTest()) this.onConflictingFlags();
-		}
 		this._silent = silent;
 		this._verbose = verbose && !silent;
 	}
-	onConflictingFlags() {
-		console.warn("Both --verbose and --silent specified; --silent takes precedence");
-	}
 };
 /**
 * ConsoleLogger - human-readable terminal output
@@ -761,7 +756,6 @@ var JsonLogger = class extends BaseLogger {
 		this._commandName = command;
 		this._version = version;
 	}
-	onConflictingFlags() {}
 	get jsonMode() {
 		return true;
 	}
@@ -809,17 +803,32 @@ var JsonLogger = class extends BaseLogger {
 	debug(_message, ..._args) {}
 };
 /**
+* Warn once when both `--verbose` and `--silent` were passed on the command
+* line. Called at CLI-flag parsing time only (`wrapCommand`), so re-configuring
+* a logger from config-file values never re-triggers it. Suppressed in JSON
+* mode to keep non-JSON text off stderr, matching the former JsonLogger
+* behavior.
+*/
+function warnOnConflictingFlags({ verbose, silent, jsonMode }) {
+	if (!verbose || !silent || jsonMode || isEnvTest()) return;
+	console.warn("Both --verbose and --silent specified; --silent takes precedence");
+}
+/**
+* Shared fallback logger for code paths that have no command logger threaded
+* through (module-level translators, `warnWithFallback(undefined, ...)`).
+* `wrapCommand` configures it from CLI flags and `ConfigResolver.resolve`
+* re-configures it from the resolved config, so `silent`/`verbose` settings
+* are honored even on paths where the command logger is not available.
+*/
+const fallbackLogger = new ConsoleLogger();
+/**
 * Emit a warning through `logger.warn` if a logger is supplied, otherwise
-* fall through to `console.warn`. Centralizes the "logger may be optional"
-* pattern so call sites stay terse and `oxlint`'s `no-console` exception
-* lives in exactly one place.
+* fall through to the shared `fallbackLogger`. Centralizes the "logger may
+* be optional" pattern so call sites stay terse and the fallback honors the
+* configured `silent` mode.
 */
 function warnWithFallback(logger, message) {
-	if (logger) {
-		logger.warn(message);
-		return;
-	}
-	console.warn(message);
+	(logger ?? fallbackLogger).warn(message);
 }
 //#endregion
 //#region src/utils/validation.ts
@@ -887,6 +896,7 @@ const ConfigParamsSchema = z.object({
 	simulateCommands: optional(z.boolean()),
 	simulateSubagents: optional(z.boolean()),
 	simulateSkills: optional(z.boolean()),
+	flattenedCommandNaming: optional(FlattenedCommandNamingSchema),
 	gitignoreTargetsOnly: optional(z.boolean()),
 	gitignoreDestination: optional(GitignoreDestinationSchema),
 	dryRun: optional(z.boolean()),
@@ -964,13 +974,14 @@ var Config = class Config {
 	simulateCommands;
 	simulateSubagents;
 	simulateSkills;
+	flattenedCommandNaming;
 	gitignoreTargetsOnly;
 	gitignoreDestination;
 	dryRun;
 	check;
 	inputRoot;
 	sources;
-	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, sources, configFileTargets }) {
+	constructor({ outputRoots, targets, features, verbose, delete: isDelete, global, silent, simulateCommands, simulateSubagents, simulateSkills, flattenedCommandNaming, gitignoreTargetsOnly, gitignoreDestination, dryRun, check, inputRoot, sources, configFileTargets }) {
 		assertTargetsFeaturesExclusive({
 			targets,
 			features
@@ -997,6 +1008,7 @@ var Config = class Config {
 		this.simulateCommands = simulateCommands ?? false;
 		this.simulateSubagents = simulateSubagents ?? false;
 		this.simulateSkills = simulateSkills ?? false;
+		this.flattenedCommandNaming = flattenedCommandNaming ?? "basename";
 		this.gitignoreTargetsOnly = gitignoreTargetsOnly ?? true;
 		this.gitignoreDestination = gitignoreDestination ?? "gitignore";
 		this.dryRun = dryRun ?? false;
@@ -1165,6 +1177,9 @@ var Config = class Config {
 	getSimulateCommands() {
 		return this.simulateCommands;
 	}
+	getFlattenedCommandNaming() {
+		return this.flattenedCommandNaming;
+	}
 	getSimulateSubagents() {
 		return this.simulateSubagents;
 	}
@@ -1217,6 +1232,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
 	gitignoreDestination: "gitignore",
 	dryRun: false,
@@ -1246,6 +1262,7 @@ const mergeConfigs = (baseConfig, localConfig) => {
 		simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
 		simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
 		simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+		flattenedCommandNaming: localConfig.flattenedCommandNaming ?? baseConfig.flattenedCommandNaming,
 		gitignoreTargetsOnly: localConfig.gitignoreTargetsOnly ?? baseConfig.gitignoreTargetsOnly,
 		gitignoreDestination: localConfig.gitignoreDestination ?? baseConfig.gitignoreDestination,
 		dryRun: localConfig.dryRun ?? baseConfig.dryRun,
@@ -1324,6 +1341,26 @@ var ConfigResolver = class {
 			validatedConfigPath,
 			localConfigPath
 		});
+		const resolvedVerbose = pick({
+			cli: verbose,
+			file: configByFile.verbose,
+			fallback: getDefaults().verbose
+		});
+		const resolvedSilent = pick({
+			cli: silent,
+			file: configByFile.silent,
+			fallback: getDefaults().silent
+		});
+		if (logger !== void 0) {
+			logger.configure({
+				verbose: resolvedVerbose,
+				silent: resolvedSilent
+			});
+			fallbackLogger.configure({
+				verbose: resolvedVerbose,
+				silent: resolvedSilent
+			});
+		}
 		const resolvedInputRoot = inputRoot ?? configByFile.inputRoot;
 		const resolvedGlobal = resolveGlobal({
 			logger,
@@ -1340,11 +1377,7 @@ var ConfigResolver = class {
 		return new Config({
 			targets: resolvedTargets,
 			features: resolvedFeatures,
-			verbose: pick({
-				cli: verbose,
-				file: configByFile.verbose,
-				fallback: getDefaults().verbose
-			}),
+			verbose: resolvedVerbose,
 			delete: pick({
 				cli: isDelete,
 				file: configByFile.delete,
@@ -1359,11 +1392,7 @@ var ConfigResolver = class {
 				global: resolvedGlobal
 			}),
 			global: resolvedGlobal,
-			silent: pick({
-				cli: silent,
-				file: configByFile.silent,
-				fallback: getDefaults().silent
-			}),
+			silent: resolvedSilent,
 			simulateCommands: pick({
 				cli: simulateCommands,
 				file: configByFile.simulateCommands,
@@ -1401,6 +1430,7 @@ var ConfigResolver = class {
 			}),
 			inputRoot: resolvedInputRoot !== void 0 ? resolve(resolvedInputRoot) : cwd,
 			sources: configByFile.sources ?? getDefaults().sources,
+			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
 			configFileTargets: extractConfigFileTargets(configByFile.targets)
 		});
 	}
@@ -5232,12 +5262,15 @@ var OpenCodeCommand = class OpenCodeCommand extends ToolCommand {
 	}
 };
 const PI_AGENT_DIR = join(".pi", "agent");
+const PI_AGENT_EXTENSIONS_DIR_PATH = join(PI_AGENT_DIR, "extensions");
 const PI_AGENT_PROMPTS_DIR_PATH = join(PI_AGENT_DIR, "prompts");
 const PI_AGENT_SKILLS_DIR_PATH = join(PI_AGENT_DIR, "skills");
+const PI_EXTENSIONS_DIR_PATH = join(".pi", "extensions");
 const PI_PROMPTS_DIR_PATH = join(".pi", "prompts");
 const PI_SKILLS_DIR_PATH = join(".pi", "skills");
 const PI_RULE_FILE_NAME = "AGENTS.md";
 const PI_APPEND_SYSTEM_FILE_NAME = "APPEND_SYSTEM.md";
+const PI_HOOKS_FILE_NAME = "rulesync-hooks.ts";
 //#endregion
 //#region src/features/commands/pi-command.ts
 /**
@@ -6415,7 +6448,8 @@ var CommandsProcessor = class extends FeatureProcessor {
 	toolTarget;
 	global;
 	getFactory;
-	constructor({ outputRoot = process.cwd(), inputRoot = process.cwd(), toolTarget, global = false, getFactory = defaultGetFactory$5, dryRun = false, logger }) {
+	flattenedCommandNaming;
+	constructor({ outputRoot = process.cwd(), inputRoot = process.cwd(), toolTarget, global = false, getFactory = defaultGetFactory$5, dryRun = false, flattenedCommandNaming = "basename", logger }) {
 		super({
 			outputRoot,
 			inputRoot,
@@ -6427,6 +6461,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 		this.toolTarget = result.data;
 		this.global = global;
 		this.getFactory = getFactory;
+		this.flattenedCommandNaming = flattenedCommandNaming;
 	}
 	async convertRulesyncFilesToToolFiles(rulesyncFiles) {
 		const rulesyncCommands = rulesyncFiles.filter((file) => file instanceof RulesyncCommand);
@@ -6463,8 +6498,9 @@ var CommandsProcessor = class extends FeatureProcessor {
 		});
 	}
 	flattenRelativeFilePath(rulesyncCommand) {
-		const flatPath = basename(rulesyncCommand.getRelativeFilePath());
-		if (flatPath === rulesyncCommand.getRelativeFilePath()) return rulesyncCommand;
+		const relativeFilePath = rulesyncCommand.getRelativeFilePath();
+		const flatPath = this.flattenedCommandNaming === "path" ? toPosixPath(relativeFilePath).split("/").join("-") : basename(relativeFilePath);
+		if (flatPath === relativeFilePath) return rulesyncCommand;
 		return rulesyncCommand.withRelativeFilePath(flatPath);
 	}
 	safeRelativePath(basePath, fullPath) {
@@ -6790,6 +6826,26 @@ const OPENCODE_HOOK_EVENTS = [
 /** Hook events supported by Kilo. (Currently identical to OpenCode) */
 const KILO_HOOK_EVENTS = OPENCODE_HOOK_EVENTS;
 /**
+* Hook events supported by Pi Coding Agent, bridged through a generated
+* TypeScript extension (Pi has no static hook config file; its extension API
+* exposes lifecycle events instead).
+*
+* Only canonical events with a semantically faithful Pi extension event are
+* listed; see CANONICAL_TO_PI_EVENT_NAMES for the mapping.
+*
+* @see https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/extensions.md
+*/
+const PI_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"preToolUse",
+	"postToolUse",
+	"preModelInvocation",
+	"beforeSubmitPrompt",
+	"stop",
+	"preCompact"
+];
+/**
 * Hook events supported by GitHub Copilot (cloud coding agent).
 *
 * GitHub now documents an eight-event surface for `.github/hooks/*.json`:
@@ -7189,6 +7245,7 @@ const HooksConfigSchema = z.looseObject({
 	copilotcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	opencode: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	kilo: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	pi: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	factorydroid: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	codexcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	goose: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
@@ -7369,6 +7426,31 @@ const CANONICAL_TO_OPENCODE_EVENT_NAMES = {
 */
 const CANONICAL_TO_KILO_EVENT_NAMES = CANONICAL_TO_OPENCODE_EVENT_NAMES;
 /**
+* Map canonical camelCase event names to Pi Coding Agent extension event
+* names (snake_case).
+*
+* Mapping notes: `sessionEnd` → `session_shutdown` (fires on session
+* teardown), `beforeSubmitPrompt` → `input` (user input interception),
+* `preModelInvocation` → `context` (fires before each LLM call), and
+* `stop` → `agent_end` (agent finished responding; unlike Claude Code's
+* Stop, this also fires before Pi auto-retries or auto-compacts —
+* `agent_settled` would skip queued follow-ups instead, a pure trade-off).
+* Pi events without a faithful canonical counterpart (e.g. `turn_start`,
+* `agent_settled`) are intentionally unmapped.
+*
+* @see https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/extensions.md
+*/
+const CANONICAL_TO_PI_EVENT_NAMES = {
+	sessionStart: "session_start",
+	sessionEnd: "session_shutdown",
+	preToolUse: "tool_call",
+	postToolUse: "tool_result",
+	preModelInvocation: "context",
+	beforeSubmitPrompt: "input",
+	stop: "agent_end",
+	preCompact: "session_before_compact"
+};
+/**
 * Map canonical camelCase event names to Copilot camelCase.
 */
 const CANONICAL_TO_COPILOT_EVENT_NAMES = {
@@ -10799,6 +10881,176 @@ var OpencodeHooks = class OpencodeHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/features/hooks/pi-extension-generator.ts
+/**
+* Pi extension events fired per tool invocation; handlers for these receive
+* `event.toolName` and honor the canonical hook `matcher` as a regex on it.
+*/
+const PI_TOOL_EVENTS = /* @__PURE__ */ new Set(["tool_call", "tool_result"]);
+/**
+* Validate a hook matcher as a regular expression and return it as a JS
+* string-literal (JSON.stringify quoting) safe to embed in generated code.
+*/
+function matcherToEmbeddedLiteral(matcher) {
+	let sanitized = matcher;
+	for (const char of CONTROL_CHARS) sanitized = sanitized.replaceAll(char, "");
+	if (sanitized === "*") sanitized = ".*";
+	try {
+		new RegExp(sanitized);
+	} catch {
+		throw new Error(`Invalid regex pattern in hook matcher: ${sanitized}`);
+	}
+	return JSON.stringify(sanitized);
+}
+function collectPiHandlers({ effectiveHooks, eventMap }) {
+	const handlerGroups = {};
+	for (const [canonicalEvent, definitions] of Object.entries(effectiveHooks)) {
+		const piEvent = eventMap[canonicalEvent];
+		if (!piEvent) continue;
+		const handlers = [];
+		for (const def of definitions) {
+			if ((def.type ?? "command") !== "command") continue;
+			if (!def.command) continue;
+			handlers.push({
+				command: def.command,
+				matcher: def.matcher ? def.matcher : void 0
+			});
+		}
+		if (handlers.length > 0) {
+			const existing = handlerGroups[piEvent];
+			if (existing) existing.push(...handlers);
+			else handlerGroups[piEvent] = handlers;
+		}
+	}
+	return handlerGroups;
+}
+function buildSubscriptionLines(handlerGroups) {
+	const lines = [];
+	for (const [piEvent, handlers] of Object.entries(handlerGroups)) {
+		const usesToolName = PI_TOOL_EVENTS.has(piEvent) && handlers.some((h) => h.matcher);
+		lines.push(`  pi.on(${JSON.stringify(piEvent)}, async (${usesToolName ? "event" : ""}) => {`);
+		for (const handler of handlers) {
+			const embeddedCommand = JSON.stringify(handler.command);
+			if (usesToolName && handler.matcher) {
+				lines.push(`    if (new RegExp(${matcherToEmbeddedLiteral(handler.matcher)}).test(event.toolName)) {`);
+				lines.push(`      await run(${embeddedCommand});`);
+				lines.push("    }");
+			} else lines.push(`    await run(${embeddedCommand});`);
+		}
+		lines.push("  });");
+	}
+	return lines;
+}
+/**
+* Generate the rulesync-owned Pi extension (a TypeScript module with a
+* default-export factory receiving Pi's ExtensionAPI) that subscribes to the
+* mapped lifecycle events and executes the configured hook commands via the
+* platform shell. The generated extension observes events only: it never
+* blocks or mutates Pi events.
+*
+* @see https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/extensions.md
+*/
+function generatePiExtensionCode({ config, supportedEvents, eventMap }) {
+	const supported = new Set(supportedEvents);
+	const configHooks = {
+		...config.hooks,
+		...config.pi?.hooks
+	};
+	const effectiveHooks = {};
+	for (const [event, defs] of Object.entries(configHooks)) if (supported.has(event)) effectiveHooks[event] = defs;
+	const subscriptionLines = buildSubscriptionLines(collectPiHandlers({
+		effectiveHooks,
+		eventMap
+	}));
+	const lines = ["// Generated by rulesync. Do not edit manually."];
+	if (subscriptionLines.length === 0) {
+		lines.push("export default function () {}");
+		lines.push("");
+		return lines.join("\n");
+	}
+	lines.push("import { exec } from \"node:child_process\";");
+	lines.push("import { promisify } from \"node:util\";");
+	lines.push("");
+	lines.push("import type { ExtensionAPI } from \"@earendil-works/pi-coding-agent\";");
+	lines.push("");
+	lines.push("const run = promisify(exec);");
+	lines.push("");
+	lines.push("export default function (pi: ExtensionAPI) {");
+	lines.push(...subscriptionLines);
+	lines.push("}");
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/features/hooks/pi-hooks.ts
+/**
+* Pi Coding Agent has no static hooks config file; its extension API exposes
+* lifecycle events instead. rulesync bridges canonical hooks by generating a
+* rulesync-owned TypeScript extension in Pi's extension discovery paths:
+* `.pi/extensions/rulesync-hooks.ts` (project) and
+* `~/.pi/agent/extensions/rulesync-hooks.ts` (global).
+*
+* @see https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/extensions.md
+*/
+var PiHooks = class PiHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? ""
+		});
+	}
+	static getSettablePaths(options) {
+		return {
+			relativeDirPath: options?.global ? PI_AGENT_EXTENSIONS_DIR_PATH : PI_EXTENSIONS_DIR_PATH,
+			relativeFilePath: PI_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = PiHooks.getSettablePaths({ global });
+		const fileContent = await readFileContent(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath));
+		return new PiHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false }) {
+		const fileContent = generatePiExtensionCode({
+			config: rulesyncHooks.getJson(),
+			supportedEvents: PI_HOOK_EVENTS,
+			eventMap: CANONICAL_TO_PI_EVENT_NAMES
+		});
+		const paths = PiHooks.getSettablePaths({ global });
+		return new PiHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		throw new Error("Not implemented because Pi hooks are generated as a TypeScript extension file.");
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new PiHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: "",
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/qwencode-hooks.ts
 /**
 * Build a single Qwen Code hook object from a canonical hook definition.
@@ -11568,6 +11820,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
 	}],
+	["pi", {
+		class: PiHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: false
+		},
+		supportedEvents: PI_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
+	}],
 	["factorydroid", {
 		class: FactorydroidHooks,
 		meta: {
@@ -19321,7 +19584,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 }
 //#endregion
 //#region src/features/permissions/augmentcode-permissions.ts
-const moduleLogger$1 = new ConsoleLogger();
+const moduleLogger$1 = fallbackLogger;
 z.enum([
 	"allow",
 	"deny",
@@ -23126,7 +23389,7 @@ const QwenSettingsPermissionsSchema = z.looseObject({
 	deny: z.optional(z.array(z.string()))
 });
 const QwenSettingsSchema = z.looseObject({ permissions: z.optional(QwenSettingsPermissionsSchema) });
-const moduleLogger = new ConsoleLogger();
+const moduleLogger = fallbackLogger;
 /**
 * Mapping from rulesync canonical tool category names (lowercase) to Qwen Code tool names (PascalCase).
 * Unknown names pass through as-is (e.g., mcp__server__tool).
@@ -40533,7 +40796,8 @@ function buildCommandsStrategy(ctx) {
 			toolTarget,
 			global,
 			dryRun,
-			logger
+			logger,
+			flattenedCommandNaming: config.getFlattenedCommandNaming()
 		}),
 		loadSource: (p) => p.loadToolFiles(),
 		toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
@@ -41373,6 +41637,7 @@ async function generateCommandsCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			flattenedCommandNaming: config.getFlattenedCommandNaming(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -41896,6 +42161,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { isSymlink as $, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as A, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as At, findControlCharacter as B, ALL_FEATURES_WITH_WILDCARD as Bt, CommandsProcessor as C, RULESYNC_MCP_FILE_NAME as Ct, CLAUDECODE_DIR as D, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Dt, CODEXCLI_DIR as E, RULESYNC_MCP_SCHEMA_URL as Et, RulesyncCheck as F, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Ft, checkPathTraversal as G, JsonLogger as H, RulesyncCheckFrontmatterSchema as I, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as It, ensureDir as J, createTempDirectory as K, stringifyFrontmatter as L, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Lt, RulesyncCommand as M, RULESYNC_PERMISSIONS_SCHEMA_URL as Mt, RulesyncCommandFrontmatterSchema as N, RULESYNC_RELATIVE_DIR_PATH as Nt, CLAUDECODE_LOCAL_RULE_FILE_NAME as O, RULESYNC_OVERVIEW_FILE_NAME as Ot, ChecksProcessor as P, RULESYNC_RULES_RELATIVE_DIR_PATH as Pt, getHomeDirectory as Q, loadYaml as R, formatError as Rt, RulesyncHooks as S, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as St, CODEXCLI_BASH_RULES_FILE_NAME as T, RULESYNC_MCP_RELATIVE_FILE_PATH as Tt, CLIError as U, ConsoleLogger as V, ErrorCodes as W, findFilesByGlobs as X, fileExists as Y, getFileSize as Z, McpProcessor as _, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as _t, convertFromTool as a, toPosixPath as at, RulesyncIgnore as b, RULESYNC_HOOKS_RELATIVE_FILE_PATH as bt, RulesyncRuleFrontmatterSchema as c, ALL_TOOL_TARGETS_WITH_WILDCARD as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_AIIGNORE_FILE_NAME as dt, listDirectoryFiles as et, SkillsProcessor as f, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ft, RulesyncPermissions as g, RULESYNC_CONFIG_SCHEMA_URL as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, removeTempDirectory as it, CLAUDECODE_SKILLS_DIR_PATH as j, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as jt, CLAUDECODE_MEMORIES_DIR_NAME as k, RULESYNC_PERMISSIONS_FILE_NAME as kt, SubagentsProcessor as l, ToolTargetSchema as lt, RulesyncSkill as m, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as mt, checkRulesyncDirExists as n, removeDirectory as nt, RulesProcessor as o, writeFileContent as ot, getLocalSkillDirNames as p, RULESYNC_CHECKS_RELATIVE_DIR_PATH as pt, directoryExists as q, generate as r, removeFile as rt, RulesyncRule as s, ALL_TOOL_TARGETS as st, importFromTool as t, readFileContent as tt, RulesyncSubagent as u, MAX_FILE_SIZE as ut, RulesyncMcp as v, RULESYNC_HOOKS_FILE_NAME as vt, SKILL_FILE_NAME$1 as w, RULESYNC_MCP_JSONC_FILE_NAME as wt, HooksProcessor as x, RULESYNC_IGNORE_RELATIVE_FILE_PATH as xt, IgnoreProcessor as y, RULESYNC_HOOKS_JSONC_FILE_NAME as yt, ConfigResolver as z, ALL_FEATURES as zt };
+export { getFileSize as $, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as A, RULESYNC_OVERVIEW_FILE_NAME as At, findControlCharacter as B, formatError as Bt, CommandsProcessor as C, RULESYNC_IGNORE_RELATIVE_FILE_PATH as Ct, CLAUDECODE_DIR as D, RULESYNC_MCP_RELATIVE_FILE_PATH as Dt, CODEXCLI_DIR as E, RULESYNC_MCP_JSONC_FILE_NAME as Et, RulesyncCheck as F, RULESYNC_RELATIVE_DIR_PATH as Ft, CLIError as G, JsonLogger as H, ALL_FEATURES_WITH_WILDCARD as Ht, RulesyncCheckFrontmatterSchema as I, RULESYNC_RULES_RELATIVE_DIR_PATH as It, createTempDirectory as J, ErrorCodes as K, stringifyFrontmatter as L, RULESYNC_SKILLS_RELATIVE_DIR_PATH as Lt, RulesyncCommand as M, RULESYNC_PERMISSIONS_JSONC_FILE_NAME as Mt, RulesyncCommandFrontmatterSchema as N, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Nt, CLAUDECODE_LOCAL_RULE_FILE_NAME as O, RULESYNC_MCP_SCHEMA_URL as Ot, ChecksProcessor as P, RULESYNC_PERMISSIONS_SCHEMA_URL as Pt, findFilesByGlobs as Q, loadYaml as R, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Rt, RulesyncHooks as S, RULESYNC_HOOKS_RELATIVE_FILE_PATH as St, CODEXCLI_BASH_RULES_FILE_NAME as T, RULESYNC_MCP_FILE_NAME as Tt, fallbackLogger as U, ConsoleLogger as V, ALL_FEATURES as Vt, warnOnConflictingFlags as W, ensureDir as X, directoryExists as Y, fileExists as Z, McpProcessor as _, RULESYNC_CONFIG_RELATIVE_FILE_PATH as _t, convertFromTool as a, removeFile as at, RulesyncIgnore as b, RULESYNC_HOOKS_FILE_NAME as bt, RulesyncRuleFrontmatterSchema as c, writeFileContent as ct, RulesyncSubagentFrontmatterSchema as d, ToolTargetSchema as dt, getHomeDirectory as et, SkillsProcessor as f, MAX_FILE_SIZE as ft, RulesyncPermissions as g, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_CHECKS_RELATIVE_DIR_PATH as ht, getProcessorRegistryEntry as i, removeDirectory as it, CLAUDECODE_SKILLS_DIR_PATH as j, RULESYNC_PERMISSIONS_FILE_NAME as jt, CLAUDECODE_MEMORIES_DIR_NAME as k, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as kt, SubagentsProcessor as l, ALL_TOOL_TARGETS as lt, RulesyncSkill as m, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, listDirectoryFiles as nt, RulesProcessor as o, removeTempDirectory as ot, getLocalSkillDirNames as p, RULESYNC_AIIGNORE_FILE_NAME as pt, checkPathTraversal as q, generate as r, readFileContent as rt, RulesyncRule as s, toPosixPath as st, importFromTool as t, isSymlink as tt, RulesyncSubagent as u, ALL_TOOL_TARGETS_WITH_WILDCARD as ut, RulesyncMcp as v, RULESYNC_CONFIG_SCHEMA_URL as vt, SKILL_FILE_NAME$1 as w, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as wt, HooksProcessor as x, RULESYNC_HOOKS_JSONC_FILE_NAME as xt, IgnoreProcessor as y, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as yt, ConfigResolver as z, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as zt };
 
-//# sourceMappingURL=import-CSnC5vl7.js.map
+//# sourceMappingURL=import-BN4K49Ta.js.map