rulesync 43.6.2 → 43.7.0

package/dist/{import-8kSEsosv.cjs → import-CfxyzbvB.cjs}

@@ -9745,11 +9745,9 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 	* `PERMISSION_OVERRIDE_KEY_ALIASES`) is replaced wholesale, and removed when
 	* the import does not produce one: only that tool's import ever writes it, so
 	* a setting removed from the tool's own config has to disappear here too.
-	* Any other tool's override block the import carries (Hermes restores them
-	* from its provenance) merges one level down: an imported field replaces the
-	* existing field, fields the import does not name are kept, and a
-	* `permission` record inside the block merges per category. Every other
-	* top-level key — `$schema` included — is kept unless the import names it.
+	* Every other top-level key — `$schema` included — is kept unless the import
+	* names it, in which case the imported value replaces it. No importer emits
+	* another tool's override block, so those blocks are never touched here.
 	*/
 	static mergeImportedJson({ existing, imported, toolTarget }) {
 		const ownOverrideKey = PERMISSION_OVERRIDE_KEY_ALIASES[toolTarget] ?? toolTarget;
@@ -9761,14 +9759,7 @@ var RulesyncPermissions = class RulesyncPermissions extends RulesyncFile {
 				existing: current,
 				imported: value
 			});
-			else if (isRecord(current) && isRecord(value)) {
-				const block = { ...current };
-				for (const [field, fieldValue] of Object.entries(value)) block[field] = field === "permission" ? mergePermissionCategories({
-					existing: block[field],
-					imported: fieldValue
-				}) : fieldValue;
-				merged[key] = block;
-			} else merged[key] = value;
+			else merged[key] = value;
 		}
 		return merged;
 	}
@@ -29131,11 +29122,7 @@ var ZoocodeSkill = class extends RooSkill {
 	static toolTarget = "zoocode";
 };
 // src/features/skills/skills-processor.ts
-var skills_processor_exports = /* @__PURE__ */ __exportAll({
-	SkillsProcessor: () => SkillsProcessor,
-	SkillsProcessorToolTargetSchema: () => SkillsProcessorToolTargetSchema,
-	toolSkillFactories: () => toolSkillFactories
-});
+var skills_processor_exports = /* @__PURE__ */ __exportAll({ toolSkillFactories: () => toolSkillFactories });
 const SkillsProcessorToolTargetSchema = zod_mini.z.enum(skillsProcessorToolTargetTuple);
 /**
 * Factory Map mapping tool targets to their skill factories.
@@ -52429,6 +52416,29 @@ var AmpHooks = class AmpHooks extends ToolHooks {
 		});
 	}
 };
+// src/features/hooks/hook-matcher-tool-names.ts
+const MATCHER_TOKEN_PATTERN = /\\.|\[(?:\\.|[^\]\\])*\]|(?<=^|[^\w\\]|\\\w)[A-Za-z_]\w*(?!\w)/gs;
+function isMatcherName(token) {
+	return !token.startsWith("\\") && !token.startsWith("[");
+}
+/**
+* The distinct whole names in a matcher that start with a capital letter, for
+* adapters whose runtime tool names are all lowercase: after translation, such
+* a name has no runtime equivalent and can never match.
+*/
+function capitalizedMatcherNames(matcher) {
+	const names = [...matcher.matchAll(MATCHER_TOKEN_PATTERN)].map(([token]) => token).filter((token) => isMatcherName(token) && /^[A-Z]/.test(token));
+	return [...new Set(names)];
+}
+/**
+* Rewrites the whole tool names inside a hook `matcher` regex through `names`,
+* leaving escapes, character classes and unknown names as written. Used by
+* adapters whose runtime tool names differ from the canonical (Claude Code)
+* spelling.
+*/
+function replaceMatcherNames(matcher, names) {
+	return matcher.replace(MATCHER_TOKEN_PATTERN, (token) => isMatcherName(token) && Object.hasOwn(names, token) ? names[token] ?? token : token);
+}
 // src/utils/object.ts
 /**
 * Return a shallow copy of `obj` keeping only the entries whose value is
@@ -54349,6 +54359,48 @@ const ANTIGRAVITY_FLAT_HANDLER_EVENTS = new Set([...ANTIGRAVITY_NO_MATCHER_EVENT
 	record: CANONICAL_TO_ANTIGRAVITY_EVENT_NAMES,
 	key: event
 }) ?? event));
+const CANONICAL_TO_ANTIGRAVITY_TOOL_NAMES = {
+	Bash: "run_command",
+	Read: "(?:read_file|view_file)",
+	Write: "(?:write_file|write_to_file)",
+	Edit: "(?:edit_file|replace_file_content)",
+	WebSearch: "search_web"
+};
+const ANTIGRAVITY_TO_CANONICAL_TOOL_NAMES = {
+	run_command: "Bash",
+	read_file: "Read",
+	view_file: "Read",
+	write_file: "Write",
+	write_to_file: "Write",
+	edit_file: "Edit",
+	replace_file_content: "Edit",
+	search_web: "WebSearch"
+};
+const ANTIGRAVITY_GROUP_TO_CANONICAL_TOOL_NAMES = Object.entries(CANONICAL_TO_ANTIGRAVITY_TOOL_NAMES).filter(([, name]) => name.startsWith("(?:")).map(([canonical, group]) => [group, canonical]);
+const ANTIGRAVITY_DOCUMENTED_TOOL_CANDIDATES = {
+	Grep: "grep_search",
+	Glob: "find_by_name",
+	WebFetch: "read_url_content",
+	MultiEdit: "multi_replace_file_content"
+};
+function canonicalToAntigravityMatcher({ matcher, eventName, warn }) {
+	const translated = replaceMatcherNames(matcher, CANONICAL_TO_ANTIGRAVITY_TOOL_NAMES);
+	const unmatched = capitalizedMatcherNames(translated);
+	if (unmatched.length > 0) {
+		const candidates = unmatched.flatMap((name) => {
+			const candidate = lookupOwn({
+				record: ANTIGRAVITY_DOCUMENTED_TOOL_CANDIDATES,
+				key: name
+			});
+			return candidate ? [`\`${candidate}\` for ${quoteValueForWarning(name)}`] : [];
+		});
+		warn(`Antigravity reports lowercase tool names in the hook payload (\`toolCall.name\`), and ${unmatched.map((name) => quoteValueForWarning(name)).join(", ")} in the "${eventName}" matcher ${quoteValueForWarning(matcher)} has no verified Antigravity equivalent, so it is written as-is and will likely never match. Use the tool name Antigravity reports instead` + (candidates.length > 0 ? ` (the Antigravity hooks docs list ${candidates.join(", ")}, unverified).` : "."));
+	}
+	return translated;
+}
+function antigravityToCanonicalMatcher(matcher) {
+	return replaceMatcherNames(ANTIGRAVITY_GROUP_TO_CANONICAL_TOOL_NAMES.reduce((current, [group, canonical]) => current.split(group).join(canonical), matcher), ANTIGRAVITY_TO_CANONICAL_TOOL_NAMES);
+}
 /**
 * Antigravity uses a Claude-Code-like `hooks.json`. The `PreToolUse` /
 * `PostToolUse` events use the matcher-based group shape, while `SessionStart`,
@@ -54362,7 +54414,11 @@ const ANTIGRAVITY_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: ANTIGRAVITY_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	noMatcherEvents: ANTIGRAVITY_NO_MATCHER_EVENTS,
-	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	matcherTranslation: {
+		toTool: canonicalToAntigravityMatcher,
+		toCanonical: antigravityToCanonicalMatcher
+	}
 };
 /**
 * Turn the shared converter's matcher-group output into Antigravity's shape:
@@ -57395,20 +57451,6 @@ var CopilotcliHooks = class CopilotcliHooks extends ToolHooks {
 		}), null, 2) });
 	}
 };
-// src/features/hooks/hook-matcher-tool-names.ts
-const MATCHER_TOKEN_PATTERN = /\\.|\[(?:\\.|[^\]\\])*\]|(?<=^|[^\w\\]|\\\w)[A-Za-z_]\w*(?!\w)/gs;
-function isMatcherName(token) {
-	return !token.startsWith("\\") && !token.startsWith("[");
-}
-/**
-* Rewrites the whole tool names inside a hook `matcher` regex through `names`,
-* leaving escapes, character classes and unknown names as written. Used by
-* adapters whose runtime tool names differ from the canonical (Claude Code)
-* spelling.
-*/
-function replaceMatcherNames(matcher, names) {
-	return matcher.replace(MATCHER_TOKEN_PATTERN, (token) => isMatcherName(token) && Object.hasOwn(names, token) ? names[token] ?? token : token);
-}
 // src/features/hooks/cortexcode-hooks.ts
 const CORTEXCODE_NO_MATCHER_EVENTS = /* @__PURE__ */ new Set(["beforeSubmitPrompt", "stop"]);
 const CANONICAL_TO_CORTEXCODE_TOOL_NAMES = {
@@ -57422,8 +57464,8 @@ const CANONICAL_TO_CORTEXCODE_TOOL_NAMES = {
 const CORTEXCODE_TO_CANONICAL_TOOL_NAMES = invertRecord(CANONICAL_TO_CORTEXCODE_TOOL_NAMES);
 function canonicalToCortexcodeMatcher({ matcher, eventName, warn }) {
 	const translated = replaceMatcherNames(matcher, CANONICAL_TO_CORTEXCODE_TOOL_NAMES);
-	const unmatched = [...translated.matchAll(MATCHER_TOKEN_PATTERN)].map(([token]) => token).filter((token) => isMatcherName(token) && /^[A-Z]/.test(token));
-	if (unmatched.length > 0) warn(`Cortex Code matches hook matchers case-sensitively against lowercase runtime tool names, and ${[...new Set(unmatched)].map((name) => quoteValueForWarning(name)).join(", ")} in the "${eventName}" matcher ${quoteValueForWarning(matcher)} is not a tool Cortex Code documents a runtime ID for, so it is written as-is and will likely never match. Replace it with the lowercase name Cortex Code uses for that tool, if it has one.`);
+	const unmatched = capitalizedMatcherNames(translated);
+	if (unmatched.length > 0) warn(`Cortex Code matches hook matchers case-sensitively against lowercase runtime tool names, and ${unmatched.map((name) => quoteValueForWarning(name)).join(", ")} in the "${eventName}" matcher ${quoteValueForWarning(matcher)} is not a tool Cortex Code documents a runtime ID for, so it is written as-is and will likely never match. Replace it with the lowercase name Cortex Code uses for that tool, if it has one.`);
 	return translated;
 }
 function cortexcodeToCanonicalMatcher(matcher) {
@@ -79859,6 +79901,39 @@ const MATCH_ALL_PATH_GLOBS = /* @__PURE__ */ new Set([
 ]);
 const DIRECTORY_CONTENTS_SUFFIX = /\/\*\*(?:\/\*)?$/;
 const HOME_OR_VARIABLE_PATH = /^~(?:\/|$)|^\$[A-Za-z_]|\$\{[A-Za-z_]/;
+const LEADING_HOME = /^~(?:\/|$)/;
+/**
+* The home directory as an Antigravity path: forward slashes, no trailing
+* slash. agy accepts `C:/Users/...` on Windows, so one spelling serves both.
+*/
+function toAntigravityHomePath(homeDirectory) {
+	return homeDirectory.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+/**
+* Rewrite a leading `~` or `~/` of a path target to the absolute home
+* directory. agy 1.5.1 matches `~` literally, so a `~/...` rule would never
+* apply (rulesync#3324). Only a file the user's own home holds, such as the
+* global Antigravity CLI settings, may carry a machine-specific path, so the
+* caller passes `homeDirectory` only then. `$HOME`, `${HOME}`, `%VAR%` and
+* `~user/` are left as written (the variable forms are still warned about).
+*/
+function expandLeadingHome(target, homeDirectory) {
+	if (homeDirectory === void 0 || !LEADING_HOME.test(target)) return target;
+	const home = toAntigravityHomePath(homeDirectory);
+	return target === "~" ? home || "/" : `${home}${target.slice(1)}`;
+}
+/**
+* The reverse of {@link expandLeadingHome} on import: an absolute path in the
+* home directory goes back to `~/...`, so `.rulesync/permissions.jsonc` stays
+* the same on every machine.
+*/
+function collapseLeadingHome(target, homeDirectory) {
+	if (homeDirectory === void 0) return target;
+	const home = toAntigravityHomePath(homeDirectory);
+	if (home.length === 0) return target;
+	if (target === home) return "~";
+	return target.startsWith(`${home}/`) ? `~${target.slice(home.length)}` : target;
+}
 const HOSTNAME = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/;
 const DENY_HINTS = {
 	read_file: "deny a directory or file path instead",
@@ -80011,13 +80086,14 @@ function warnHomeOrVariablePath({ action, target, rule, decision, logger, toolLa
 * nothing enforces it, and a widened one is warned about too, because it
 * blocks more than it says.
 */
-function buildAntigravityPermissionEntry({ action: toolAction, category, pattern, decision, logger, toolLabel }) {
+function buildAntigravityPermissionEntry({ action: toolAction, category, pattern, decision, logger, toolLabel, homeDirectory }) {
 	const isMcp = category.startsWith(MCP_CATEGORY_PREFIX);
 	const action = isMcp ? "mcp" : toolAction;
 	const result = isMcp ? toMcpRuleTarget(category, pattern) : pattern === "*" ? { target: "*" } : toTarget(action, pattern);
 	const rule = `${category}: { "${pattern}": "${decision}" }`;
 	if ("skipReason" in result) {
-		const prefix = decision !== "deny" ? void 0 : isMcp ? result.lead : toWidenedDenyTarget(action, pattern);
+		const lead = decision !== "deny" ? void 0 : isMcp ? result.lead : toWidenedDenyTarget(action, pattern);
+		const prefix = lead !== void 0 && PATH_ACTIONS.has(action) ? expandLeadingHome(lead, homeDirectory) : lead;
 		if (prefix !== void 0) {
 			const { entry, scope } = describeWidenedDeny({
 				action,
@@ -80043,22 +80119,23 @@ function buildAntigravityPermissionEntry({ action: toolAction, category, pattern
 		const consequence = decision === "deny" ? ", so the deny also overrides any allow or ask there" : "";
 		logger.warn(`${toolLabel} permissions: ${rule}: ${result.note}${consequence}.`);
 	}
+	const target = PATH_ACTIONS.has(action) ? expandLeadingHome(result.target, homeDirectory) : result.target;
 	warnHomeOrVariablePath({
 		action,
-		target: result.target,
+		target,
 		rule,
 		decision,
 		logger,
 		toolLabel
 	});
-	return result.target === "*" ? action : `${action}(${result.target})`;
+	return target === "*" ? action : `${action}(${target})`;
 }
 /**
 * Convert rulesync permissions config to Antigravity allow/ask/deny arrays,
 * shared by the CLI and IDE generators; `toAction` maps a canonical category to
 * the target's tool or action name.
 */
-function convertRulesyncToAntigravityPermissions({ config, toAction, toolLabel, logger }) {
+function convertRulesyncToAntigravityPermissions({ config, toAction, toolLabel, logger, homeDirectory }) {
 	const allow = [];
 	const ask = [];
 	const deny = [];
@@ -80071,7 +80148,8 @@ function convertRulesyncToAntigravityPermissions({ config, toAction, toolLabel,
 				pattern,
 				decision: permissionAction,
 				logger,
-				toolLabel
+				toolLabel,
+				homeDirectory
 			});
 			if (entry === void 0) continue;
 			switch (permissionAction) {
@@ -80096,7 +80174,7 @@ function convertRulesyncToAntigravityPermissions({ config, toAction, toolLabel,
 * shared by the CLI and IDE adapters; `toCategory` maps the target's tool or
 * action name back to a canonical category.
 */
-function convertAntigravityToRulesyncPermissions({ allow, ask, deny, toCategory, toolLabel, logger }) {
+function convertAntigravityToRulesyncPermissions({ allow, ask, deny, toCategory, toolLabel, logger, homeDirectory }) {
 	const permission = {};
 	const processEntries = (entries, action) => {
 		for (const entry of entries) {
@@ -80108,7 +80186,7 @@ function convertAntigravityToRulesyncPermissions({ allow, ask, deny, toCategory,
 				decision: action,
 				logger,
 				toolLabel
-			}) : target;
+			}) : PATH_ACTIONS.has(toolName) ? collapseLeadingHome(target, homeDirectory) : target;
 			if (isPrototypePollutionKey(canonical) || isPrototypePollutionKey(pattern)) continue;
 			getOrCreateOwn({
 				record: permission,
@@ -80247,7 +80325,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 			config,
 			toAction: toAntigravityCliToolName,
 			toolLabel: "Antigravity CLI",
-			logger
+			logger,
+			homeDirectory: outputRoot
 		});
 		const managedToolNames = new Set(Object.keys(config.permission).map((category) => toAntigravityCliToolName(category)));
 		const isManagedToolName = (toolName) => managedToolNames.has(toolName) || managedToolNames.has("mcp") && toolName.startsWith("mcp__");
@@ -80298,7 +80377,8 @@ var AntigravityCliPermissions = class AntigravityCliPermissions extends ToolPerm
 			deny: permissions.deny ?? [],
 			toCategory: toCanonicalToolName$9,
 			toolLabel: "Antigravity CLI",
-			logger: moduleLogger$4
+			logger: moduleLogger$4,
+			homeDirectory: this.getOutputRoot()
 		});
 		const override = {};
 		const toolPermission = pickDocumentedValue({
@@ -90261,6 +90341,22 @@ function unmanagedMcpAllowlistEntries({ existing, previousPermission, nextPermis
 		return category === null || !Object.hasOwn(previousPermission, category) && !Object.hasOwn(nextPermission, category);
 	});
 }
+/** Hermes's override key in the canonical document (`hermes`). */
+const HERMES_OVERRIDE_KEY = PERMISSION_OVERRIDE_KEY_ALIASES.hermesagent ?? "hermesagent";
+/**
+* The part of a canonical permissions document Hermes keeps as provenance: the
+* `$schema`, the canonical `permission` block, and Hermes's own override.
+*/
+function hermesProvenanceOf(permissions) {
+	const source = permissions;
+	const provenance = {};
+	for (const key of [
+		"$schema",
+		"permission",
+		HERMES_OVERRIDE_KEY
+	]) if (source[key] !== void 0) provenance[key] = source[key];
+	return provenance;
+}
 /** The validated canonical `permission` block of a config's `permissions.rulesync` blob. */
 function canonicalPermissionOf(config) {
 	const parsed = RulesyncPermissionsFileSchema.safeParse({ permission: provenancePermissionOf(config) });
@@ -90428,10 +90524,10 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 			patterns: websiteBlocklist.enabled === true && isStringArray(websiteBlocklist.domains) ? websiteBlocklist.domains : []
 		});
 		removeEmptyCategories(permission);
-		const { permission: _permission, hermes: _hermes, ...otherProvenance } = provenance;
 		const hermes = buildHermesOverride(config, provenance);
+		const { $schema } = provenance;
 		const imported = {
-			...otherProvenance,
+			...$schema !== void 0 && { $schema },
 			permission,
 			...Object.keys(hermes).length > 0 && { hermes }
 		};
@@ -90489,7 +90585,7 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 			base: config,
 			patch: permissions.hermes
 		});
-		config.permissions = { rulesync: permissions };
+		config.permissions = { rulesync: hermesProvenanceOf(permissions) };
 		return new HermesagentPermissions({
 			outputRoot,
 			fileContent: stringifySharedConfig({