rulesync 14.0.0 → 14.1.0

package/dist/{import-Dh9PCQKq.cjs → import-CDKxRD_F.cjs}

@@ -55,6 +55,7 @@ const ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 const FeatureSchema = zod_mini.z.enum(ALL_FEATURES);
 zod_mini.z.array(FeatureSchema);
 const GitignoreDestinationSchema = zod_mini.z.enum(["gitignore", "gitattributes"]);
+const FlattenedCommandNamingSchema = zod_mini.z.enum(["basename", "path"]);
 const FeatureOptionsSchema = zod_mini.z.record(zod_mini.z.string(), zod_mini.z.unknown());
 const FeatureValueSchema = zod_mini.z.union([
 	zod_mini.z.boolean(),
@@ -116,26 +117,26 @@ function formatError(error) {
 }
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$257 } = node_path.posix;
+const { join: join$258 } = node_path.posix;
 const RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
 const RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH = "rulesync.local.jsonc";
 const RULESYNC_RELATIVE_DIR_PATH = ".rulesync";
-const RULESYNC_RULES_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
-const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_MCP_JSONC_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_JSONC_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_JSONC_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
 const RULESYNC_IGNORE_RELATIVE_FILE_PATH = ".rulesyncignore";
 const RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
-const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$257(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$257(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$258(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$258(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
 const RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync.lock";
 const RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH = "rulesync-npm.lock.json";
 const RULESYNC_MCP_FILE_NAME = "mcp.json";
@@ -347,6 +348,7 @@ const hooksProcessorToolTargetTuple = [
 	"copilot",
 	"copilotcli",
 	"opencode",
+	"pi",
 	"factorydroid",
 	"goose",
 	"hermesagent",
@@ -720,16 +722,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
@@ -786,7 +781,6 @@ var JsonLogger = class extends BaseLogger {
 		this._commandName = command;
 		this._version = version;
 	}
-	onConflictingFlags() {}
 	get jsonMode() {
 		return true;
 	}
@@ -834,17 +828,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
@@ -912,6 +921,7 @@ const ConfigParamsSchema = zod_mini.z.object({
 	simulateCommands: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSubagents: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	simulateSkills: (0, zod_mini.optional)(zod_mini.z.boolean()),
+	flattenedCommandNaming: (0, zod_mini.optional)(FlattenedCommandNamingSchema),
 	gitignoreTargetsOnly: (0, zod_mini.optional)(zod_mini.z.boolean()),
 	gitignoreDestination: (0, zod_mini.optional)(GitignoreDestinationSchema),
 	dryRun: (0, zod_mini.optional)(zod_mini.z.boolean()),
@@ -989,13 +999,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
@@ -1022,6 +1033,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;
@@ -1190,6 +1202,9 @@ var Config = class Config {
 	getSimulateCommands() {
 		return this.simulateCommands;
 	}
+	getFlattenedCommandNaming() {
+		return this.flattenedCommandNaming;
+	}
 	getSimulateSubagents() {
 		return this.simulateSubagents;
 	}
@@ -1242,6 +1257,7 @@ const getDefaults = () => ({
 	simulateCommands: false,
 	simulateSubagents: false,
 	simulateSkills: false,
+	flattenedCommandNaming: "basename",
 	gitignoreTargetsOnly: true,
 	gitignoreDestination: "gitignore",
 	dryRun: false,
@@ -1271,6 +1287,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,
@@ -1349,6 +1366,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,
@@ -1365,11 +1402,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,
@@ -1384,11 +1417,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,
@@ -1426,6 +1455,7 @@ var ConfigResolver = class {
 			}),
 			inputRoot: resolvedInputRoot !== void 0 ? (0, node_path.resolve)(resolvedInputRoot) : cwd,
 			sources: configByFile.sources ?? getDefaults().sources,
+			flattenedCommandNaming: configByFile.flattenedCommandNaming ?? getDefaults().flattenedCommandNaming,
 			configFileTargets: extractConfigFileTargets(configByFile.targets)
 		});
 	}
@@ -5258,12 +5288,15 @@ var OpenCodeCommand = class OpenCodeCommand extends ToolCommand {
 	}
 };
 const PI_AGENT_DIR = (0, node_path.join)(".pi", "agent");
+const PI_AGENT_EXTENSIONS_DIR_PATH = (0, node_path.join)(PI_AGENT_DIR, "extensions");
 const PI_AGENT_PROMPTS_DIR_PATH = (0, node_path.join)(PI_AGENT_DIR, "prompts");
 const PI_AGENT_SKILLS_DIR_PATH = (0, node_path.join)(PI_AGENT_DIR, "skills");
+const PI_EXTENSIONS_DIR_PATH = (0, node_path.join)(".pi", "extensions");
 const PI_PROMPTS_DIR_PATH = (0, node_path.join)(".pi", "prompts");
 const PI_SKILLS_DIR_PATH = (0, node_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
 /**
@@ -6441,7 +6474,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,
@@ -6453,6 +6487,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);
@@ -6489,8 +6524,9 @@ var CommandsProcessor = class extends FeatureProcessor {
 		});
 	}
 	flattenRelativeFilePath(rulesyncCommand) {
-		const flatPath = (0, node_path.basename)(rulesyncCommand.getRelativeFilePath());
-		if (flatPath === rulesyncCommand.getRelativeFilePath()) return rulesyncCommand;
+		const relativeFilePath = rulesyncCommand.getRelativeFilePath();
+		const flatPath = this.flattenedCommandNaming === "path" ? toPosixPath(relativeFilePath).split("/").join("-") : (0, node_path.basename)(relativeFilePath);
+		if (flatPath === relativeFilePath) return rulesyncCommand;
 		return rulesyncCommand.withRelativeFilePath(flatPath);
 	}
 	safeRelativePath(basePath, fullPath) {
@@ -6816,6 +6852,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`:
@@ -7215,6 +7271,7 @@ const HooksConfigSchema = zod_mini.z.looseObject({
 	copilotcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	opencode: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	kilo: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
+	pi: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	factorydroid: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	codexcli: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
 	goose: zod_mini.z.optional(zod_mini.z.looseObject({ hooks: zod_mini.z.optional(hooksRecordSchema) })),
@@ -7395,6 +7452,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 = {
@@ -10825,6 +10907,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((0, node_path.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.
@@ -11594,6 +11846,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: {
@@ -19347,7 +19610,7 @@ function convertAntigravityIdeToRulesyncPermissions(params) {
 }
 //#endregion
 //#region src/features/permissions/augmentcode-permissions.ts
-const moduleLogger$1 = new ConsoleLogger();
+const moduleLogger$1 = fallbackLogger;
 zod_mini.z.enum([
 	"allow",
 	"deny",
@@ -23152,7 +23415,7 @@ const QwenSettingsPermissionsSchema = zod_mini.z.looseObject({
 	deny: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
 const QwenSettingsSchema = zod_mini.z.looseObject({ permissions: zod_mini.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).
@@ -40559,7 +40822,8 @@ function buildCommandsStrategy(ctx) {
 			toolTarget,
 			global,
 			dryRun,
-			logger
+			logger,
+			flattenedCommandNaming: config.getFlattenedCommandNaming()
 		}),
 		loadSource: (p) => p.loadToolFiles(),
 		toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
@@ -41399,6 +41663,7 @@ async function generateCommandsCore(params) {
 			toolTarget,
 			global: config.getGlobal(),
 			dryRun: config.isPreviewMode(),
+			flattenedCommandNaming: config.getFlattenedCommandNaming(),
 			logger
 		});
 		const result = await processFeatureWithRulesyncFiles({
@@ -42372,6 +42637,12 @@ Object.defineProperty(exports, "ensureDir", {
 		return ensureDir;
 	}
 });
+Object.defineProperty(exports, "fallbackLogger", {
+	enumerable: true,
+	get: function() {
+		return fallbackLogger;
+	}
+});
 Object.defineProperty(exports, "fileExists", {
 	enumerable: true,
 	get: function() {
@@ -42486,6 +42757,12 @@ Object.defineProperty(exports, "toPosixPath", {
 		return toPosixPath;
 	}
 });
+Object.defineProperty(exports, "warnOnConflictingFlags", {
+	enumerable: true,
+	get: function() {
+		return warnOnConflictingFlags;
+	}
+});
 Object.defineProperty(exports, "writeFileContent", {
 	enumerable: true,
 	get: function() {

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_import = require("./import-Dh9PCQKq.cjs");
+const require_import = require("./import-CDKxRD_F.cjs");
 //#region src/index.ts
 async function generate(options = {}) {
 	const { silent = true, verbose = false, ...rest } = options;

package/dist/index.d.cts

@@ -15,7 +15,7 @@ declare const FeatureSchema: z.ZodMiniEnum<{
 type Feature = z.infer<typeof FeatureSchema>;
 //#endregion
 //#region src/types/tool-target-tuples.d.ts
-declare const ALL_TOOL_TARGET_TUPLES: readonly [readonly ["agentsmd", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "augmentcode", "augmentcode-legacy", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "replit", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["aiassistant", "antigravity-cli", "augmentcode", "claudecode", "claudecode-legacy", "cline", "cursor", "goose", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "qwencode", "roo", "devin", "vibe", "warp", "zed"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kilo", "kiro", "kiro-cli", "kiro-ide", "junie", "opencode", "qwencode", "reasonix", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["agentsmd", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "cursor", "factorydroid", "goose", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "rovodev", "takt", "devin"], readonly ["kilo", "agentsmd", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "roo", "rovodev", "takt", "vibe"], readonly ["agentsmd", "agentsskills", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "replit", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["antigravity-cli", "antigravity-ide", "kilo", "cursor", "claudecode", "codexcli", "copilot", "copilotcli", "opencode", "factorydroid", "goose", "hermesagent", "deepagents", "kiro", "kiro-cli", "kiro-ide", "devin", "augmentcode", "junie", "vibe", "qwencode", "reasonix", "grokcli"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "cline", "codexcli", "copilot", "cursor", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "rovodev", "takt", "vibe", "warp", "zed"], readonly ["amp"]];
+declare const ALL_TOOL_TARGET_TUPLES: readonly [readonly ["agentsmd", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "augmentcode", "augmentcode-legacy", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "replit", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["aiassistant", "antigravity-cli", "augmentcode", "claudecode", "claudecode-legacy", "cline", "cursor", "goose", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "qwencode", "roo", "devin", "vibe", "warp", "zed"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "kilo", "kiro", "kiro-cli", "kiro-ide", "junie", "opencode", "qwencode", "reasonix", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["agentsmd", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "cursor", "factorydroid", "goose", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "roo", "rovodev", "takt", "devin"], readonly ["kilo", "agentsmd", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "roo", "rovodev", "takt", "vibe"], readonly ["agentsmd", "agentsskills", "aiassistant", "amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "claudecode-legacy", "cline", "codexcli", "copilot", "copilotcli", "cursor", "deepagents", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "pi", "qwencode", "reasonix", "replit", "roo", "rovodev", "takt", "vibe", "warp", "devin", "zed"], readonly ["antigravity-cli", "antigravity-ide", "kilo", "cursor", "claudecode", "codexcli", "copilot", "copilotcli", "opencode", "pi", "factorydroid", "goose", "hermesagent", "deepagents", "kiro", "kiro-cli", "kiro-ide", "devin", "augmentcode", "junie", "vibe", "qwencode", "reasonix", "grokcli"], readonly ["amp", "antigravity-cli", "antigravity-ide", "augmentcode", "claudecode", "cline", "codexcli", "copilot", "cursor", "devin", "factorydroid", "goose", "grokcli", "hermesagent", "junie", "kilo", "kiro", "kiro-cli", "kiro-ide", "opencode", "qwencode", "reasonix", "rovodev", "takt", "vibe", "warp", "zed"], readonly ["amp"]];
 //#endregion
 //#region src/types/tool-targets.d.ts
 type AllToolTarget = (typeof ALL_TOOL_TARGET_TUPLES)[number][number];

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types/features.ts","../src/types/tool-target-tuples.ts","../src/types/tool-targets.ts","../src/lib/convert.ts","../src/types/ai-dir.ts","../src/features/skills/rulesync-skill.ts","../src/lib/generate.ts","../src/lib/import.ts","../src/index.ts"],"mappings":";;cAEa;cAcP,eAAa,EAAA;;;;;;;;;;;KAEP,UAAU,EAAE,aAAa;;;cC6OxB;;;KCrPR,wBAAwB;cAEhB,4BAA4B,kBAAkB;cAM9C,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjB,aAAa,EAAE,aAAa;;;KCN5B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCnBU;EAEN;EACA;;EAGA;EACA,OAAO;;KAGD;EACV;EACA,YAAY;;KAGF;EACV;EACA;EACA;EACA;IACE;IACA;IACA,cAAc;;EAEhB,aAAa;EACb;;KAGU,qBAAqB,KAC/B;uBAIoB;;;;qBAID;;;;qBAKA;;;;qBAKA;;;;YAKT;IACR;IACA;IACA,cAAc;;;;;YAMN,YAAY;;;;qBAKH;EAEnB,cACE,YACA,iBACA,SACA,UACA,YACA,UACC;SAcU,QAAQ,SAAS,qBAAqB,QAAQ;EAI3D;EAIA;EAIA;EAIA;EAqBA;IAEM;IACA;IACA,cAAc;;EAMpB,iBAAiB;;;;EAOjB;EAIA;EAIA,YAAY,cAAc,cAAc,cAAc;;;;;;;;;;;mBAc/B,kBACrB,oBACA,yBACA,iBACA,0BACC,QAAQ;WAmBF,YAAY;;;;cCrLjB,wCAAsC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8LhC;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;MACE;MACA;MACA;MACA;MACA;MACA;;IAEF;MACE;;IAEF;MACE,QAAQ;QACN;QACA;QACA;QACA;QACA;;;;EAIN;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,gBAAgB;IAChB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,gBAAgB;IAChB,WAAW;;EAEb,MAAM;EACN,QAAQ;EACR;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA,WAAW;;EAEb;IACE;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;IACA;;EAEF;IACE;IACA;;;KAKQ,2BAA2B,EAAE,aAAa;KAO1C;EACV;EACA;EACA;EACA,aAAa;EACb;EACA,aAAa;EACb;EACA;;KAGU;EACV;;KAGU;EACV;EACA;EACA;EACA;;;;;;cAOW,sBAAsB;EACjC,cACE,YACA,iBACA,SACA,aACA,MACA,YACA,UACA,UACC;SAsBI,oBAAoB;EAU3B,kBAAkB;EAQlB;EAIA,YAAY;SAcC,UACX,YACA,iBACA,SACA,UACC,6BAA6B,QAAQ;;;;KChZ9B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;;;;KCPU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCjCG;EACH;EACA;EACA;EACA;;KAGU,kBAAkB;EAC5B,UAAU;EACV,WAAW;EACX;;;;;;;EAOA;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU,gBAAgB;EAC1B,QAAQ;EACR,WAAW;;KAGD,iBAAiB;EAC3B,MAAM;EACN,IAAI;EACJ,WAAW;EACX;;iBAGoB,SAAS,UAAS,kBAAuB,QAAQ;iBAqBjD,eAAe,SAAS,gBAAgB,QAAQ;iBAehD,gBAAgB,SAAS,iBAAiB,QAAQ"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types/features.ts","../src/types/tool-target-tuples.ts","../src/types/tool-targets.ts","../src/lib/convert.ts","../src/types/ai-dir.ts","../src/features/skills/rulesync-skill.ts","../src/lib/generate.ts","../src/lib/import.ts","../src/index.ts"],"mappings":";;cAEa;cAcP,eAAa,EAAA;;;;;;;;;;;KAEP,UAAU,EAAE,aAAa;;;cC8OxB;;;KCtPR,wBAAwB;cAEhB,4BAA4B,kBAAkB;cAM9C,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjB,aAAa,EAAE,aAAa;;;KCN5B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCnBU;EAEN;EACA;;EAGA;EACA,OAAO;;KAGD;EACV;EACA,YAAY;;KAGF;EACV;EACA;EACA;EACA;IACE;IACA;IACA,cAAc;;EAEhB,aAAa;EACb;;KAGU,qBAAqB,KAC/B;uBAIoB;;;;qBAID;;;;qBAKA;;;;qBAKA;;;;YAKT;IACR;IACA;IACA,cAAc;;;;;YAMN,YAAY;;;;qBAKH;EAEnB,cACE,YACA,iBACA,SACA,UACA,YACA,UACC;SAcU,QAAQ,SAAS,qBAAqB,QAAQ;EAI3D;EAIA;EAIA;EAIA;EAqBA;IAEM;IACA;IACA,cAAc;;EAMpB,iBAAiB;;;;EAOjB;EAIA;EAIA,YAAY,cAAc,cAAc,cAAc;;;;;;;;;;;mBAc/B,kBACrB,oBACA,yBACA,iBACA,0BACC,QAAQ;WAmBF,YAAY;;;;cCrLjB,wCAAsC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8LhC;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,QAAQ;IACR;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;MACE;MACA;MACA;MACA;MACA;MACA;;IAEF;MACE;;IAEF;MACE,QAAQ;QACN;QACA;QACA;QACA;QACA;;;;EAIN;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,gBAAgB;IAChB,WAAW;;EAEb;IACE;;EAEF;IACE;IACA;IACA,gBAAgB;IAChB,WAAW;;EAEb,MAAM;EACN,QAAQ;EACR;IACE;IACA;IACA,yBAAyB;IACzB,WAAW;;EAEb;IACE;IACA;IACA,WAAW;;EAEb;IACE;IACA;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;;EAEF;IACE;IACA,yBAAyB;IACzB,WAAW;IACX;IACA;;EAEF;IACE;IACA;;;KAKQ,2BAA2B,EAAE,aAAa;KAO1C;EACV;EACA;EACA;EACA,aAAa;EACb;EACA,aAAa;EACb;EACA;;KAGU;EACV;;KAGU;EACV;EACA;EACA;EACA;;;;;;cAOW,sBAAsB;EACjC,cACE,YACA,iBACA,SACA,aACA,MACA,YACA,UACA,UACC;SAsBI,oBAAoB;EAU3B,kBAAkB;EAQlB;EAIA,YAAY;SAcC,UACX,YACA,iBACA,SACA,UACC,6BAA6B,QAAQ;;;;KChZ9B;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;;;;KCPU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;KCjCG;EACH;EACA;EACA;EACA;;KAGU,kBAAkB;EAC5B,UAAU;EACV,WAAW;EACX;;;;;;;EAOA;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU,gBAAgB;EAC1B,QAAQ;EACR,WAAW;;KAGD,iBAAiB;EAC3B,MAAM;EACN,IAAI;EACJ,WAAW;EACX;;iBAGoB,SAAS,UAAS,kBAAuB,QAAQ;iBAqBjD,eAAe,SAAS,gBAAgB,QAAQ;iBAehD,gBAAgB,SAAS,iBAAiB,QAAQ"}