@cleocode/caamp 1.8.1 → 1.9.1

package/dist/chunk-J7UN457C.js

@@ -0,0 +1,244 @@
+import {
+  resolveRegistryTemplatePath
+} from "./chunk-TI6WOJDG.js";
+
+// src/core/hooks/types.ts
+var HOOK_CATEGORIES = ["session", "prompt", "tool", "agent", "context"];
+var CANONICAL_HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "PromptSubmit",
+  "ResponseComplete",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "SubagentStart",
+  "SubagentStop",
+  "PreModel",
+  "PostModel",
+  "PreCompact",
+  "PostCompact",
+  "Notification",
+  "ConfigChange"
+];
+
+// src/core/hooks/normalizer.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var _mappings = null;
+function findMappingsPath() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  return join(thisDir, "..", "..", "..", "providers", "hook-mappings.json");
+}
+function loadMappings() {
+  if (_mappings) return _mappings;
+  const raw = readFileSync(findMappingsPath(), "utf-8");
+  _mappings = JSON.parse(raw);
+  return _mappings;
+}
+function resetHookMappings() {
+  _mappings = null;
+}
+function getCanonicalEvent(event) {
+  const data = loadMappings();
+  return data.canonicalEvents[event];
+}
+function getAllCanonicalEvents() {
+  return loadMappings().canonicalEvents;
+}
+function getCanonicalEventsByCategory(category) {
+  const data = loadMappings();
+  return CANONICAL_HOOK_EVENTS.filter(
+    (event) => data.canonicalEvents[event].category === category
+  );
+}
+function getProviderHookProfile(providerId) {
+  const data = loadMappings();
+  return data.providerMappings[providerId];
+}
+function getMappedProviderIds() {
+  return Object.keys(loadMappings().providerMappings);
+}
+function toNative(canonical, providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return null;
+  const mapping = profile.mappings[canonical];
+  return mapping?.supported ? mapping.nativeName : null;
+}
+function toCanonical(nativeName, providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return null;
+  for (const [canonical, mapping] of Object.entries(profile.mappings)) {
+    if (mapping.supported && mapping.nativeName === nativeName) {
+      return canonical;
+    }
+  }
+  return null;
+}
+function toNativeBatch(canonicals, providerId) {
+  const data = loadMappings();
+  const profile = data.providerMappings[providerId];
+  if (!profile) return [];
+  const results = [];
+  for (const canonical of canonicals) {
+    const mapping = profile.mappings[canonical];
+    if (mapping?.supported && mapping.nativeName) {
+      results.push({
+        canonical,
+        native: mapping.nativeName,
+        providerId,
+        category: data.canonicalEvents[canonical].category,
+        canBlock: data.canonicalEvents[canonical].canBlock
+      });
+    }
+  }
+  return results;
+}
+function supportsHook(canonical, providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return false;
+  return profile.mappings[canonical]?.supported ?? false;
+}
+function getHookSupport(canonical, providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) {
+    return { canonical, supported: false, native: null };
+  }
+  const mapping = profile.mappings[canonical];
+  return {
+    canonical,
+    supported: mapping?.supported ?? false,
+    native: mapping?.nativeName ?? null,
+    notes: mapping?.notes
+  };
+}
+function getSupportedEvents(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return [];
+  return CANONICAL_HOOK_EVENTS.filter(
+    (event) => profile.mappings[event]?.supported
+  );
+}
+function getUnsupportedEvents(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return [...CANONICAL_HOOK_EVENTS];
+  return CANONICAL_HOOK_EVENTS.filter(
+    (event) => !profile.mappings[event]?.supported
+  );
+}
+function getProvidersForEvent(canonical) {
+  const data = loadMappings();
+  return Object.entries(data.providerMappings).filter(([, profile]) => profile.mappings[canonical]?.supported).map(([id]) => id);
+}
+function getCommonEvents(providerIds) {
+  if (providerIds.length === 0) return [];
+  return CANONICAL_HOOK_EVENTS.filter(
+    (event) => providerIds.every((id) => supportsHook(event, id))
+  );
+}
+function getProviderSummary(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile) return void 0;
+  const supported = getSupportedEvents(providerId);
+  const unsupported = getUnsupportedEvents(providerId);
+  return {
+    providerId,
+    hookSystem: profile.hookSystem,
+    experimental: profile.experimental,
+    supportedCount: supported.length,
+    totalCanonical: CANONICAL_HOOK_EVENTS.length,
+    supported,
+    unsupported,
+    providerOnly: profile.providerOnlyEvents,
+    coverage: Math.round(supported.length / CANONICAL_HOOK_EVENTS.length * 100)
+  };
+}
+function buildHookMatrix(providerIds) {
+  const data = loadMappings();
+  const ids = providerIds ?? Object.keys(data.providerMappings);
+  const matrix = {};
+  for (const event of CANONICAL_HOOK_EVENTS) {
+    matrix[event] = {};
+    for (const id of ids) {
+      const profile = data.providerMappings[id];
+      matrix[event][id] = profile?.mappings[event] ?? {
+        nativeName: null,
+        supported: false
+      };
+    }
+  }
+  return {
+    events: [...CANONICAL_HOOK_EVENTS],
+    providers: ids,
+    matrix
+  };
+}
+function getHookSystemType(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  return profile?.hookSystem ?? "none";
+}
+function getHookConfigPath(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  if (!profile?.hookConfigPath) return null;
+  return resolveRegistryTemplatePath(profile.hookConfigPath);
+}
+function getProviderOnlyEvents(providerId) {
+  const profile = getProviderHookProfile(providerId);
+  return profile?.providerOnlyEvents ?? [];
+}
+function translateToAll(canonical, providerIds) {
+  const result = {};
+  for (const id of providerIds) {
+    const native = toNative(canonical, id);
+    if (native) {
+      result[id] = native;
+    }
+  }
+  return result;
+}
+function resolveNativeEvent(nativeName) {
+  const data = loadMappings();
+  const results = [];
+  for (const [providerId, profile] of Object.entries(data.providerMappings)) {
+    for (const [canonical, mapping] of Object.entries(profile.mappings)) {
+      if (mapping.supported && mapping.nativeName === nativeName) {
+        results.push({ providerId, canonical });
+      }
+    }
+  }
+  return results;
+}
+function getHookMappingsVersion() {
+  return loadMappings().version;
+}
+
+export {
+  HOOK_CATEGORIES,
+  CANONICAL_HOOK_EVENTS,
+  resetHookMappings,
+  getCanonicalEvent,
+  getAllCanonicalEvents,
+  getCanonicalEventsByCategory,
+  getProviderHookProfile,
+  getMappedProviderIds,
+  toNative,
+  toCanonical,
+  toNativeBatch,
+  supportsHook,
+  getHookSupport,
+  getSupportedEvents,
+  getUnsupportedEvents,
+  getProvidersForEvent,
+  getCommonEvents,
+  getProviderSummary,
+  buildHookMatrix,
+  getHookSystemType,
+  getHookConfigPath,
+  getProviderOnlyEvents,
+  translateToAll,
+  resolveNativeEvent,
+  getHookMappingsVersion
+};
+//# sourceMappingURL=chunk-J7UN457C.js.map

package/dist/chunk-J7UN457C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/hooks/types.ts","../src/core/hooks/normalizer.ts"],"sourcesContent":["/**\n * CAAMP Hooks Normalizer - Type Definitions\n *\n * Defines the canonical CAAMP hook event taxonomy and provider mapping types.\n * CAAMP provides a unified hook interface across all providers — consumers\n * use canonical event names, and the normalizer translates to/from\n * provider-native names.\n */\n\n// ── Canonical Hook Events ───────────────────────────────────────────\n\n/**\n * All supported hook category names as a readonly tuple.\n *\n * @remarks\n * Categories group related canonical events for filtering and display.\n * Each canonical event belongs to exactly one category. The tuple is\n * `as const` so it can be used to derive the {@link HookCategory} union type.\n *\n * @public\n */\nexport const HOOK_CATEGORIES = [\"session\", \"prompt\", \"tool\", \"agent\", \"context\"] as const;\n\n/**\n * Union type of valid hook category strings derived from {@link HOOK_CATEGORIES}.\n *\n * @remarks\n * Used to classify canonical events into logical groups such as `\"session\"`,\n * `\"prompt\"`, `\"tool\"`, `\"agent\"`, and `\"context\"`.\n *\n * @public\n */\nexport type HookCategory = (typeof HOOK_CATEGORIES)[number];\n\n/**\n * All CAAMP canonical hook event names as a readonly tuple.\n *\n * @remarks\n * This is the single source of truth for the canonical event taxonomy.\n * Provider-native events are mapped to and from these canonical names\n * by the normalizer. The tuple is `as const` so it can derive the\n * {@link CanonicalHookEvent} union type.\n *\n * @public\n */\nexport const CANONICAL_HOOK_EVENTS = [\n  \"SessionStart\",\n  \"SessionEnd\",\n  \"PromptSubmit\",\n  \"ResponseComplete\",\n  \"PreToolUse\",\n  \"PostToolUse\",\n  \"PostToolUseFailure\",\n  \"PermissionRequest\",\n  \"SubagentStart\",\n  \"SubagentStop\",\n  \"PreModel\",\n  \"PostModel\",\n  \"PreCompact\",\n  \"PostCompact\",\n  \"Notification\",\n  \"ConfigChange\",\n] as const;\n\n/**\n * Union type of valid canonical hook event names derived from {@link CANONICAL_HOOK_EVENTS}.\n *\n * @remarks\n * Every provider mapping references these canonical names. Use `toNative()`\n * to translate a canonical event to a provider-specific name, and `toCanonical()`\n * for the reverse direction.\n *\n * @public\n */\nexport type CanonicalHookEvent = (typeof CANONICAL_HOOK_EVENTS)[number];\n\n/**\n * Definition of a canonical hook event including its category and behavior.\n *\n * @remarks\n * Each canonical event has a category for grouping, a human-readable description,\n * and a `canBlock` flag indicating whether a hook handler can prevent the\n * associated action from proceeding.\n *\n * @public\n */\nexport interface CanonicalEventDefinition {\n  /** The lifecycle category this event belongs to (e.g. `\"session\"`, `\"tool\"`). */\n  category: HookCategory;\n  /** Human-readable description of when this event fires. */\n  description: string;\n  /** Whether a hook handler can block or cancel the associated action. */\n  canBlock: boolean;\n}\n\n// ── Provider Hook System Types ──────────────────────────────────────\n\n/**\n * The type of hook system a provider uses.\n *\n * @remarks\n * - `\"config\"` — hooks defined in a configuration file (e.g. Claude Code `.claude/settings.json`)\n * - `\"plugin\"` — hooks implemented via a plugin/extension system\n * - `\"none\"` — provider does not support hooks\n *\n * @public\n */\nexport type HookSystemType = \"config\" | \"plugin\" | \"none\";\n\n/**\n * The mechanism a provider uses to execute hook handlers.\n *\n * @remarks\n * - `\"command\"` — shell command execution\n * - `\"http\"` — HTTP webhook callback\n * - `\"prompt\"` — LLM prompt injection\n * - `\"agent\"` — sub-agent delegation\n * - `\"plugin\"` — native plugin API call\n *\n * @public\n */\nexport type HookHandlerType = \"command\" | \"http\" | \"prompt\" | \"agent\" | \"plugin\";\n\n/**\n * Mapping of a single canonical event to a provider's native representation.\n *\n * @remarks\n * Each entry in a provider's hook profile maps one canonical event to the\n * provider's native event name. If `supported` is `false`, the provider\n * does not fire this event. Optional `notes` capture caveats or limitations.\n *\n * @public\n */\nexport interface HookMapping {\n  /** The provider-native event name, or `null` if the event has no native equivalent. */\n  nativeName: string | null;\n  /** Whether this canonical event is supported by the provider. */\n  supported: boolean;\n  /**\n   * Optional notes about support limitations or behavioral differences.\n   *\n   * @defaultValue `undefined`\n   */\n  notes?: string;\n}\n\n/**\n * Complete hook profile for a single provider.\n *\n * @remarks\n * Describes the provider's hook system type, configuration location, supported\n * handler types, and the full mapping of canonical events to native names.\n * This is the primary data structure loaded from `providers/hook-mappings.json`.\n *\n * @public\n */\nexport interface ProviderHookProfile {\n  /** The type of hook system the provider uses (`\"config\"`, `\"plugin\"`, or `\"none\"`). */\n  hookSystem: HookSystemType;\n  /** Filesystem path template to the provider's hook configuration file, or `null`. */\n  hookConfigPath: string | null;\n  /** The configuration format used for hooks (e.g. `\"json\"`, `\"yaml\"`), or `null`. */\n  hookFormat: string | null;\n  /** The handler execution mechanisms this provider supports. */\n  handlerTypes: HookHandlerType[];\n  /** Whether the provider's hook system is considered experimental or unstable. */\n  experimental: boolean;\n  /** Mapping of every canonical event to this provider's native representation. */\n  mappings: Record<CanonicalHookEvent, HookMapping>;\n  /** Native event names that exist only in this provider with no canonical equivalent. */\n  providerOnlyEvents: string[];\n}\n\n// ── Normalization Result Types ──────────────────────────────────────\n\n/**\n * A fully resolved hook event with both canonical and native names.\n *\n * @remarks\n * Returned by batch translation functions. Contains all the context needed\n * to register or invoke a hook handler: the canonical name for CAAMP logic,\n * the native name for provider-specific calls, and metadata about category\n * and blocking behavior.\n *\n * @public\n */\nexport interface NormalizedHookEvent {\n  /** The CAAMP canonical event name. */\n  canonical: CanonicalHookEvent;\n  /** The provider-native event name. */\n  native: string;\n  /** The provider this event was resolved for. */\n  providerId: string;\n  /** The lifecycle category of this event. */\n  category: HookCategory;\n  /** Whether a handler for this event can block the associated action. */\n  canBlock: boolean;\n}\n\n/**\n * Result of querying whether a provider supports a specific canonical event.\n *\n * @remarks\n * Returned by `getHookSupport()`. Includes the native name translation\n * and any notes about support limitations. When `supported` is `false`,\n * `native` will be `null`.\n *\n * @public\n */\nexport interface HookSupportResult {\n  /** The canonical event that was queried. */\n  canonical: CanonicalHookEvent;\n  /** Whether the provider supports this event. */\n  supported: boolean;\n  /** The provider-native event name, or `null` if unsupported. */\n  native: string | null;\n  /**\n   * Optional notes about support caveats.\n   *\n   * @defaultValue `undefined`\n   */\n  notes?: string;\n}\n\n/**\n * Aggregated hook support summary for a single provider.\n *\n * @remarks\n * Provides a high-level view of a provider's hook capabilities including\n * counts, coverage percentage, and lists of supported/unsupported events.\n * Useful for CLI display and provider comparison features.\n *\n * @public\n */\nexport interface ProviderHookSummary {\n  /** The provider identifier. */\n  providerId: string;\n  /** The type of hook system the provider uses. */\n  hookSystem: HookSystemType;\n  /** Whether the provider's hook system is experimental. */\n  experimental: boolean;\n  /** Number of canonical events this provider supports. */\n  supportedCount: number;\n  /** Total number of canonical events in the taxonomy. */\n  totalCanonical: number;\n  /** List of canonical events this provider supports. */\n  supported: CanonicalHookEvent[];\n  /** List of canonical events this provider does not support. */\n  unsupported: CanonicalHookEvent[];\n  /** Native events unique to this provider with no canonical mapping. */\n  providerOnly: string[];\n  /** Percentage of canonical events supported (0-100). */\n  coverage: number;\n}\n\n/**\n * Cross-provider hook support matrix comparing multiple providers.\n *\n * @remarks\n * Built by `buildHookMatrix()`. Provides a two-dimensional view of which\n * canonical events are supported by which providers, with native name\n * translations. Used to render comparison tables in the CLI.\n *\n * @public\n */\nexport interface CrossProviderMatrix {\n  /** The canonical events included in this matrix (rows). */\n  events: CanonicalHookEvent[];\n  /** The provider IDs included in this matrix (columns). */\n  providers: string[];\n  /** Nested record mapping each canonical event to each provider's hook mapping. */\n  matrix: Record<CanonicalHookEvent, Record<string, HookMapping>>;\n}\n\n// ── Hook Mappings Data File Types ───────────────────────────────────\n\n/**\n * Schema for the `providers/hook-mappings.json` data file.\n *\n * @remarks\n * This interface represents the top-level structure of the hook mappings\n * JSON file that serves as the single source of truth for all provider\n * hook configurations. It is loaded and cached by the normalizer module.\n *\n * @public\n */\nexport interface HookMappingsFile {\n  /** Semver version string of the hook mappings schema. */\n  version: string;\n  /** ISO 8601 date string of the last update to mappings data. */\n  lastUpdated: string;\n  /** Human-readable description of the mappings file purpose. */\n  description: string;\n  /** Definitions for every canonical event in the taxonomy. */\n  canonicalEvents: Record<CanonicalHookEvent, CanonicalEventDefinition>;\n  /** Hook profiles keyed by provider ID. */\n  providerMappings: Record<string, ProviderHookProfile>;\n}\n","/**\n * CAAMP Hooks Normalizer\n *\n * Translates between CAAMP canonical hook events and provider-native\n * event names. Provides query functions for hook support, cross-provider\n * comparison, and event normalization.\n *\n * This module follows the same pattern as `src/core/mcp/transforms.ts` —\n * a translation layer that lets consumers use one canonical interface\n * while CAAMP handles provider-specific differences.\n */\n\nimport { readFileSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { resolveRegistryTemplatePath } from \"../paths/standard.js\";\nimport type {\n  CanonicalEventDefinition,\n  CanonicalHookEvent,\n  CrossProviderMatrix,\n  HookCategory,\n  HookMapping,\n  HookMappingsFile,\n  HookSupportResult,\n  HookSystemType,\n  NormalizedHookEvent,\n  ProviderHookProfile,\n  ProviderHookSummary,\n} from \"./types.js\";\nimport { CANONICAL_HOOK_EVENTS, HOOK_CATEGORIES } from \"./types.js\";\n\n// ── Data Loading ────────────────────────────────────────────────────\n\nlet _mappings: HookMappingsFile | null = null;\n\nfunction findMappingsPath(): string {\n  const thisDir = dirname(fileURLToPath(import.meta.url));\n  // src/core/hooks/ -> providers/hook-mappings.json\n  return join(thisDir, \"..\", \"..\", \"..\", \"providers\", \"hook-mappings.json\");\n}\n\nfunction loadMappings(): HookMappingsFile {\n  if (_mappings) return _mappings;\n  const raw = readFileSync(findMappingsPath(), \"utf-8\");\n  _mappings = JSON.parse(raw) as HookMappingsFile;\n  return _mappings;\n}\n\n/**\n * Reset the cached hook mappings data.\n *\n * @remarks\n * Clears the in-memory cache so the next query function call will\n * re-read `providers/hook-mappings.json` from disk. This is primarily\n * intended for test isolation — production code should not need to call this.\n *\n * @example\n * ```typescript\n * import { resetHookMappings, getHookMappingsVersion } from \"./normalizer.js\";\n *\n * // Force a fresh load from disk\n * resetHookMappings();\n * const version = getHookMappingsVersion();\n * ```\n *\n * @public\n */\nexport function resetHookMappings(): void {\n  _mappings = null;\n}\n\n// ── Core Query Functions ────────────────────────────────────────────\n\n/**\n * Get the canonical event definition (category, description, canBlock).\n *\n * @remarks\n * Looks up the definition from the hook mappings data file. The returned\n * object contains the event's category, human-readable description, and\n * whether handlers can block the associated action.\n *\n * @param event - The canonical event name to look up.\n * @returns The event definition containing category, description, and canBlock flag.\n *\n * @example\n * ```typescript\n * import { getCanonicalEvent } from \"./normalizer.js\";\n *\n * const def = getCanonicalEvent(\"PreToolUse\");\n * console.log(def.category);  // \"tool\"\n * console.log(def.canBlock);  // true\n * ```\n *\n * @public\n */\nexport function getCanonicalEvent(event: CanonicalHookEvent): CanonicalEventDefinition {\n  const data = loadMappings();\n  return data.canonicalEvents[event];\n}\n\n/**\n * Get all canonical event definitions.\n *\n * @remarks\n * Returns the complete map of canonical event names to their definitions.\n * Useful for iterating over the full taxonomy or building UI displays\n * of all available events.\n *\n * @returns A record mapping every canonical event name to its definition.\n *\n * @example\n * ```typescript\n * import { getAllCanonicalEvents } from \"./normalizer.js\";\n *\n * const events = getAllCanonicalEvents();\n * for (const [name, def] of Object.entries(events)) {\n *   console.log(`${name}: ${def.description}`);\n * }\n * ```\n *\n * @public\n */\nexport function getAllCanonicalEvents(): Record<CanonicalHookEvent, CanonicalEventDefinition> {\n  return loadMappings().canonicalEvents;\n}\n\n/**\n * Get canonical events filtered by category.\n *\n * @remarks\n * Filters the canonical event list to only those belonging to the specified\n * category. Useful for displaying events grouped by lifecycle phase\n * (e.g. all `\"tool\"` events or all `\"session\"` events).\n *\n * @param category - The hook category to filter by (e.g. `\"session\"`, `\"tool\"`).\n * @returns Array of canonical event names that belong to the specified category.\n *\n * @example\n * ```typescript\n * import { getCanonicalEventsByCategory } from \"./normalizer.js\";\n *\n * const toolEvents = getCanonicalEventsByCategory(\"tool\");\n * // [\"PreToolUse\", \"PostToolUse\", \"PostToolUseFailure\"]\n * ```\n *\n * @public\n */\nexport function getCanonicalEventsByCategory(category: HookCategory): CanonicalHookEvent[] {\n  const data = loadMappings();\n  return CANONICAL_HOOK_EVENTS.filter(\n    (event) => data.canonicalEvents[event].category === category,\n  );\n}\n\n/**\n * Get the full hook profile for a provider.\n *\n * @remarks\n * Returns the complete hook configuration for a provider including its\n * hook system type, config path, handler types, and all event mappings.\n * Returns `undefined` if the provider has no hook mappings defined.\n *\n * @param providerId - The provider identifier (e.g. `\"claude-code\"`, `\"gemini-cli\"`).\n * @returns The provider's hook profile, or `undefined` if not found.\n *\n * @example\n * ```typescript\n * import { getProviderHookProfile } from \"./normalizer.js\";\n *\n * const profile = getProviderHookProfile(\"claude-code\");\n * if (profile) {\n *   console.log(profile.hookSystem); // \"config\"\n *   console.log(profile.experimental); // false\n * }\n * ```\n *\n * @public\n */\nexport function getProviderHookProfile(providerId: string): ProviderHookProfile | undefined {\n  const data = loadMappings();\n  return data.providerMappings[providerId];\n}\n\n/**\n * Get all provider IDs that have hook mappings.\n *\n * @remarks\n * Returns the list of provider identifiers present in the hook mappings\n * data file. This reflects all providers for which CAAMP has hook\n * translation data, regardless of whether they support any events.\n *\n * @returns Array of provider ID strings.\n *\n * @example\n * ```typescript\n * import { getMappedProviderIds } from \"./normalizer.js\";\n *\n * const ids = getMappedProviderIds();\n * // [\"claude-code\", \"gemini-cli\", \"cursor\", \"kimi\", ...]\n * ```\n *\n * @public\n */\nexport function getMappedProviderIds(): string[] {\n  return Object.keys(loadMappings().providerMappings);\n}\n\n// ── Normalization: Canonical → Native ───────────────────────────────\n\n/**\n * Translate a CAAMP canonical event name to the provider's native name.\n *\n * @remarks\n * This is the primary forward-translation function. Given a canonical\n * event and a provider ID, it returns the provider-specific event name\n * that should be used when configuring hooks for that provider.\n * Returns `null` if the provider is unknown or does not support the event.\n *\n * @param canonical - The CAAMP canonical event name to translate.\n * @param providerId - The target provider identifier.\n * @returns The native event name, or `null` if unsupported.\n *\n * @example\n * ```typescript\n * import { toNative } from \"./normalizer.js\";\n *\n * toNative(\"PreToolUse\", \"claude-code\");   // \"PreToolUse\"\n * toNative(\"PreToolUse\", \"gemini-cli\");    // \"BeforeTool\"\n * toNative(\"PreToolUse\", \"cursor\");        // \"preToolUse\"\n * toNative(\"PreToolUse\", \"kimi\");          // null\n * ```\n *\n * @public\n */\nexport function toNative(\n  canonical: CanonicalHookEvent,\n  providerId: string,\n): string | null {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return null;\n  const mapping = profile.mappings[canonical];\n  return mapping?.supported ? mapping.nativeName : null;\n}\n\n/**\n * Translate a provider-native event name to the CAAMP canonical name.\n *\n * @remarks\n * This is the reverse-translation function. Scans all event mappings\n * for the given provider to find a canonical match for the native name.\n * Returns `null` if no mapping is found or the provider is unknown.\n *\n * @param nativeName - The provider-native event name to look up.\n * @param providerId - The provider identifier to search within.\n * @returns The canonical event name, or `null` if no mapping exists.\n *\n * @example\n * ```typescript\n * import { toCanonical } from \"./normalizer.js\";\n *\n * toCanonical(\"BeforeTool\", \"gemini-cli\");     // \"PreToolUse\"\n * toCanonical(\"stop\", \"cursor\");               // \"ResponseComplete\"\n * toCanonical(\"UserPromptSubmit\", \"claude-code\"); // \"PromptSubmit\"\n * ```\n *\n * @public\n */\nexport function toCanonical(\n  nativeName: string,\n  providerId: string,\n): CanonicalHookEvent | null {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return null;\n\n  for (const [canonical, mapping] of Object.entries(profile.mappings)) {\n    if (mapping.supported && mapping.nativeName === nativeName) {\n      return canonical as CanonicalHookEvent;\n    }\n  }\n  return null;\n}\n\n/**\n * Batch-translate multiple canonical events to native names for a provider.\n *\n * @remarks\n * Translates an array of canonical events in a single call, returning\n * only the events that the provider actually supports. Each result\n * includes category and blocking metadata. Unsupported events are\n * silently excluded from the output.\n *\n * @param canonicals - Array of canonical event names to translate.\n * @param providerId - The target provider identifier.\n * @returns Array of normalized events (only supported ones included).\n *\n * @example\n * ```typescript\n * import { toNativeBatch } from \"./normalizer.js\";\n *\n * const events = toNativeBatch(\n *   [\"PreToolUse\", \"PostToolUse\", \"ConfigChange\"],\n *   \"claude-code\",\n * );\n * // Returns NormalizedHookEvent[] for supported events only\n * ```\n *\n * @public\n */\nexport function toNativeBatch(\n  canonicals: CanonicalHookEvent[],\n  providerId: string,\n): NormalizedHookEvent[] {\n  const data = loadMappings();\n  const profile = data.providerMappings[providerId];\n  if (!profile) return [];\n\n  const results: NormalizedHookEvent[] = [];\n  for (const canonical of canonicals) {\n    const mapping = profile.mappings[canonical];\n    if (mapping?.supported && mapping.nativeName) {\n      results.push({\n        canonical,\n        native: mapping.nativeName,\n        providerId,\n        category: data.canonicalEvents[canonical].category,\n        canBlock: data.canonicalEvents[canonical].canBlock,\n      });\n    }\n  }\n  return results;\n}\n\n// ── Support Queries ─────────────────────────────────────────────────\n\n/**\n * Check if a provider supports a specific canonical hook event.\n *\n * @remarks\n * A quick boolean check that avoids returning the full mapping details.\n * Returns `false` if the provider is unknown or the event is not supported.\n *\n * @param canonical - The canonical event name to check.\n * @param providerId - The provider identifier to check against.\n * @returns `true` if the provider supports this canonical event, `false` otherwise.\n *\n * @example\n * ```typescript\n * import { supportsHook } from \"./normalizer.js\";\n *\n * supportsHook(\"PreToolUse\", \"claude-code\"); // true\n * supportsHook(\"PreToolUse\", \"kimi\");        // false\n * ```\n *\n * @public\n */\nexport function supportsHook(\n  canonical: CanonicalHookEvent,\n  providerId: string,\n): boolean {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return false;\n  return profile.mappings[canonical]?.supported ?? false;\n}\n\n/**\n * Get full hook support details for a canonical event on a provider.\n *\n * @remarks\n * Returns a structured result with the native name translation and any\n * notes about support limitations. Unlike `supportsHook()`, this always\n * returns a result object even when the provider is unknown (with\n * `supported: false`).\n *\n * @param canonical - The canonical event name to query.\n * @param providerId - The provider identifier to query against.\n * @returns Support result including native name and optional notes.\n *\n * @example\n * ```typescript\n * import { getHookSupport } from \"./normalizer.js\";\n *\n * const result = getHookSupport(\"PreToolUse\", \"claude-code\");\n * console.log(result.supported); // true\n * console.log(result.native);    // \"PreToolUse\"\n * ```\n *\n * @public\n */\nexport function getHookSupport(\n  canonical: CanonicalHookEvent,\n  providerId: string,\n): HookSupportResult {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) {\n    return { canonical, supported: false, native: null };\n  }\n  const mapping = profile.mappings[canonical];\n  return {\n    canonical,\n    supported: mapping?.supported ?? false,\n    native: mapping?.nativeName ?? null,\n    notes: mapping?.notes,\n  };\n}\n\n/**\n * Get all supported canonical events for a provider.\n *\n * @remarks\n * Filters the full canonical event list to only those that the provider\n * supports. Returns an empty array if the provider is unknown.\n *\n * @param providerId - The provider identifier to query.\n * @returns Array of canonical event names the provider supports.\n *\n * @example\n * ```typescript\n * import { getSupportedEvents } from \"./normalizer.js\";\n *\n * const events = getSupportedEvents(\"claude-code\");\n * // [\"SessionStart\", \"SessionEnd\", \"PreToolUse\", ...]\n * ```\n *\n * @public\n */\nexport function getSupportedEvents(providerId: string): CanonicalHookEvent[] {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return [];\n  return CANONICAL_HOOK_EVENTS.filter(\n    (event) => profile.mappings[event]?.supported,\n  );\n}\n\n/**\n * Get all unsupported canonical events for a provider.\n *\n * @remarks\n * Returns the complement of `getSupportedEvents()`. If the provider is\n * unknown, all canonical events are returned since none are supported.\n *\n * @param providerId - The provider identifier to query.\n * @returns Array of canonical event names the provider does not support.\n *\n * @example\n * ```typescript\n * import { getUnsupportedEvents } from \"./normalizer.js\";\n *\n * const missing = getUnsupportedEvents(\"kimi\");\n * // Returns all canonical events (kimi has no hook support)\n * ```\n *\n * @public\n */\nexport function getUnsupportedEvents(providerId: string): CanonicalHookEvent[] {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return [...CANONICAL_HOOK_EVENTS];\n  return CANONICAL_HOOK_EVENTS.filter(\n    (event) => !profile.mappings[event]?.supported,\n  );\n}\n\n/**\n * Get providers that support a specific canonical event.\n *\n * @remarks\n * Scans all provider mappings and returns the IDs of those that support\n * the given canonical event. Useful for determining which providers can\n * be targeted when configuring a specific hook.\n *\n * @param canonical - The canonical event name to search for.\n * @returns Array of provider IDs that support this event.\n *\n * @example\n * ```typescript\n * import { getProvidersForEvent } from \"./normalizer.js\";\n *\n * const providers = getProvidersForEvent(\"PreToolUse\");\n * // [\"claude-code\", \"gemini-cli\", \"cursor\"]\n * ```\n *\n * @public\n */\nexport function getProvidersForEvent(canonical: CanonicalHookEvent): string[] {\n  const data = loadMappings();\n  return Object.entries(data.providerMappings)\n    .filter(([, profile]) => profile.mappings[canonical]?.supported)\n    .map(([id]) => id);\n}\n\n/**\n * Get canonical events common to all specified providers.\n *\n * @remarks\n * Computes the intersection of supported events across multiple providers.\n * Returns only events that every listed provider supports. Useful for\n * determining which hooks can be configured uniformly across a set of\n * target providers.\n *\n * @param providerIds - Array of provider IDs to intersect.\n * @returns Array of canonical events supported by all specified providers.\n *\n * @example\n * ```typescript\n * import { getCommonEvents } from \"./normalizer.js\";\n *\n * const common = getCommonEvents([\"claude-code\", \"gemini-cli\"]);\n * // Returns only events both providers support\n * ```\n *\n * @public\n */\nexport function getCommonEvents(providerIds: string[]): CanonicalHookEvent[] {\n  if (providerIds.length === 0) return [];\n  return CANONICAL_HOOK_EVENTS.filter(\n    (event) => providerIds.every((id) => supportsHook(event, id)),\n  );\n}\n\n// ── Summary & Matrix Functions ──────────────────────────────────────\n\n/**\n * Get a summary of hook support for a provider.\n *\n * @remarks\n * Builds an aggregated view of a provider's hook capabilities including\n * counts, coverage percentage, and categorized event lists. Returns\n * `undefined` if the provider has no hook mappings. Used by the CLI\n * `hooks show` command for provider overviews.\n *\n * @param providerId - The provider identifier to summarize.\n * @returns The hook support summary, or `undefined` if the provider is not found.\n *\n * @example\n * ```typescript\n * import { getProviderSummary } from \"./normalizer.js\";\n *\n * const summary = getProviderSummary(\"claude-code\");\n * if (summary) {\n *   console.log(`${summary.coverage}% coverage`);\n *   console.log(`${summary.supportedCount}/${summary.totalCanonical} events`);\n * }\n * ```\n *\n * @public\n */\nexport function getProviderSummary(providerId: string): ProviderHookSummary | undefined {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile) return undefined;\n\n  const supported = getSupportedEvents(providerId);\n  const unsupported = getUnsupportedEvents(providerId);\n\n  return {\n    providerId,\n    hookSystem: profile.hookSystem,\n    experimental: profile.experimental,\n    supportedCount: supported.length,\n    totalCanonical: CANONICAL_HOOK_EVENTS.length,\n    supported,\n    unsupported,\n    providerOnly: profile.providerOnlyEvents,\n    coverage: Math.round((supported.length / CANONICAL_HOOK_EVENTS.length) * 100),\n  };\n}\n\n/**\n * Build a cross-provider hook support matrix.\n *\n * @remarks\n * Constructs a two-dimensional matrix showing which canonical events are\n * supported by which providers, with native name translations. When no\n * provider IDs are specified, all mapped providers are included. Used by\n * the CLI `hooks matrix` command for comparison tables.\n *\n * @param providerIds - Optional array of provider IDs to include. Defaults to all mapped providers.\n * @returns The cross-provider matrix with events, providers, and mapping data.\n *\n * @example\n * ```typescript\n * import { buildHookMatrix } from \"./normalizer.js\";\n *\n * const matrix = buildHookMatrix([\"claude-code\", \"gemini-cli\"]);\n * for (const event of matrix.events) {\n *   for (const provider of matrix.providers) {\n *     console.log(`${event} @ ${provider}: ${matrix.matrix[event][provider].supported}`);\n *   }\n * }\n * ```\n *\n * @public\n */\nexport function buildHookMatrix(providerIds?: string[]): CrossProviderMatrix {\n  const data = loadMappings();\n  const ids = providerIds ?? Object.keys(data.providerMappings);\n\n  const matrix: Record<string, Record<string, HookMapping>> = {};\n  for (const event of CANONICAL_HOOK_EVENTS) {\n    matrix[event] = {};\n    for (const id of ids) {\n      const profile = data.providerMappings[id];\n      matrix[event][id] = profile?.mappings[event] ?? {\n        nativeName: null,\n        supported: false,\n      };\n    }\n  }\n\n  return {\n    events: [...CANONICAL_HOOK_EVENTS],\n    providers: ids,\n    matrix: matrix as CrossProviderMatrix[\"matrix\"],\n  };\n}\n\n/**\n * Get the hook system type for a provider.\n *\n * @remarks\n * Returns the provider's hook system type: `\"config\"` for file-based hooks,\n * `\"plugin\"` for extension-based hooks, or `\"none\"` if the provider does\n * not support hooks. Returns `\"none\"` for unknown providers.\n *\n * @param providerId - The provider identifier to query.\n * @returns The hook system type (`\"config\"`, `\"plugin\"`, or `\"none\"`).\n *\n * @example\n * ```typescript\n * import { getHookSystemType } from \"./normalizer.js\";\n *\n * getHookSystemType(\"claude-code\"); // \"config\"\n * getHookSystemType(\"unknown\");     // \"none\"\n * ```\n *\n * @public\n */\nexport function getHookSystemType(providerId: string): HookSystemType {\n  const profile = getProviderHookProfile(providerId);\n  return profile?.hookSystem ?? \"none\";\n}\n\n/**\n * Get the resolved hook config path for a provider.\n *\n * @remarks\n * Resolves the provider's hook configuration file path by expanding\n * registry template variables (e.g. `~` to the home directory). Returns\n * `null` if the provider has no hook config path defined or is unknown.\n *\n * @param providerId - The provider identifier to query.\n * @returns The resolved filesystem path, or `null` if not available.\n *\n * @example\n * ```typescript\n * import { getHookConfigPath } from \"./normalizer.js\";\n *\n * const path = getHookConfigPath(\"claude-code\");\n * // \"/home/user/.claude/settings.json\" (resolved from template)\n * ```\n *\n * @public\n */\nexport function getHookConfigPath(providerId: string): string | null {\n  const profile = getProviderHookProfile(providerId);\n  if (!profile?.hookConfigPath) return null;\n  return resolveRegistryTemplatePath(profile.hookConfigPath);\n}\n\n/**\n * Get provider-only events (native events with no canonical mapping).\n *\n * @remarks\n * Some providers define hook events that have no equivalent in the CAAMP\n * canonical taxonomy. This function returns those provider-specific event\n * names. Returns an empty array for unknown providers.\n *\n * @param providerId - The provider identifier to query.\n * @returns Array of native event names unique to this provider.\n *\n * @example\n * ```typescript\n * import { getProviderOnlyEvents } from \"./normalizer.js\";\n *\n * const extras = getProviderOnlyEvents(\"claude-code\");\n * // Returns any events specific to Claude Code with no canonical equivalent\n * ```\n *\n * @public\n */\nexport function getProviderOnlyEvents(providerId: string): string[] {\n  const profile = getProviderHookProfile(providerId);\n  return profile?.providerOnlyEvents ?? [];\n}\n\n// ── Multi-Provider Translation ──────────────────────────────────────\n\n/**\n * Translate a canonical event to native names across multiple providers.\n *\n * @remarks\n * Performs a fan-out translation of a single canonical event to all\n * specified providers simultaneously. The result record only includes\n * providers that actually support the event — unsupported providers\n * are silently excluded.\n *\n * @param canonical - The canonical event name to translate.\n * @param providerIds - Array of provider IDs to translate for.\n * @returns Record mapping provider IDs to their native event names (supported only).\n *\n * @example\n * ```typescript\n * import { translateToAll } from \"./normalizer.js\";\n *\n * const result = translateToAll(\"PreToolUse\", [\"claude-code\", \"gemini-cli\", \"kimi\"]);\n * // { \"claude-code\": \"PreToolUse\", \"gemini-cli\": \"BeforeTool\" }\n * // (kimi excluded — unsupported)\n * ```\n *\n * @public\n */\nexport function translateToAll(\n  canonical: CanonicalHookEvent,\n  providerIds: string[],\n): Record<string, string> {\n  const result: Record<string, string> = {};\n  for (const id of providerIds) {\n    const native = toNative(canonical, id);\n    if (native) {\n      result[id] = native;\n    }\n  }\n  return result;\n}\n\n/**\n * Find the best canonical match for a native event name across all providers.\n *\n * @remarks\n * Scans every provider's mappings to find canonical events that match the\n * given native name. Useful when you have a native name but do not know\n * which provider it belongs to. Multiple results are possible if different\n * providers use the same native name for different canonical events.\n *\n * @param nativeName - The provider-native event name to resolve.\n * @returns Array of matches, each containing the provider ID and canonical event name.\n *\n * @example\n * ```typescript\n * import { resolveNativeEvent } from \"./normalizer.js\";\n *\n * const matches = resolveNativeEvent(\"BeforeTool\");\n * // [{ providerId: \"gemini-cli\", canonical: \"PreToolUse\" }]\n * ```\n *\n * @public\n */\nexport function resolveNativeEvent(nativeName: string): Array<{\n  providerId: string;\n  canonical: CanonicalHookEvent;\n}> {\n  const data = loadMappings();\n  const results: Array<{ providerId: string; canonical: CanonicalHookEvent }> = [];\n\n  for (const [providerId, profile] of Object.entries(data.providerMappings)) {\n    for (const [canonical, mapping] of Object.entries(profile.mappings)) {\n      if (mapping.supported && mapping.nativeName === nativeName) {\n        results.push({ providerId, canonical: canonical as CanonicalHookEvent });\n      }\n    }\n  }\n\n  return results;\n}\n\n/**\n * Get the version of the hook mappings data.\n *\n * @remarks\n * Returns the semver version string from the hook mappings JSON file.\n * This can be used to check compatibility or display the data version\n * in diagnostic output.\n *\n * @returns The semver version string of the loaded hook mappings data.\n *\n * @example\n * ```typescript\n * import { getHookMappingsVersion } from \"./normalizer.js\";\n *\n * const version = getHookMappingsVersion();\n * console.log(`Hook mappings v${version}`);\n * ```\n *\n * @public\n */\nexport function getHookMappingsVersion(): string {\n  return loadMappings().version;\n}\n"],"mappings":"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","names":[]}