@alessandroraffa/tangyr 0.21.1 → 0.21.2

package/dist/index.js

@@ -25741,8 +25741,8 @@ function compileCursorHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
       sourceEvent
     );
     if (mapping.status === "mapped" && mapping.target_event) {
-      const extracted = extractHookCommand(payload);
-      if (!extracted.command) {
+      const entries = extractHookCommands(payload);
+      if (entries.length === 0) {
         droppedEvents.push(sourceEvent);
         addHookLoss(
           lossReport,
@@ -25755,26 +25755,24 @@ function compileCursorHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
         dropped += 1;
         continue;
       }
-      hooks[mapping.target_event] = { command: extracted.command };
+      const untranslatable = /* @__PURE__ */ new Set();
+      hooks[mapping.target_event] = entries.map((entry) => {
+        const matcher = entry.matcher === void 0 ? void 0 : translateCursorMatcher(entry.matcher, untranslatable);
+        return {
+          type: "command",
+          command: entry.command,
+          ...matcher !== void 0 ? { matcher } : {}
+        };
+      });
       translated += 1;
-      if (extracted.remaining.length > 0) {
-        addHookLoss(
-          lossReport,
-          "cursor",
-          sourceEvent,
-          sourceLabel,
-          "error",
-          `${sourceEvent}: the source registers ${extracted.remaining.length + 1} hooks on this event and Cursor's entry holds one command. Only '${extracted.command}' was written; ${extracted.remaining.map((c) => `'${c}'`).join(", ")} ${extracted.remaining.length === 1 ? "does" : "do"} not run under Cursor. To fix: give this event a single entry point that dispatches to the others, or accept the loss knowingly.`
-        );
-      }
-      if (extracted.matcher) {
+      if (untranslatable.size > 0) {
         addInformational(
           lossReport,
           "cursor",
           "hooks",
           sourceLabel,
           "warning",
-          `${sourceEvent}: the source scopes this hook to '${extracted.matcher}', and Cursor's hook entry carries no matcher. It will run for every tool call on this event, not only the matched ones.`
+          `${sourceEvent}: ${[...untranslatable].map((m) => `'${m}'`).join(", ")} ${untranslatable.size === 1 ? "names a tool" : "name tools"} with no known Cursor equivalent and ${untranslatable.size === 1 ? "was" : "were"} written through unchanged. Cursor matches on its own tool names \u2014 measured: Shell, Read, Write, Grep \u2014 so a hook scoped to a name it does not use will not run. To fix: add the name to CURSOR_TOOL_NAMES in the compiler once its Cursor equivalent has been measured.`
         );
       }
       continue;
@@ -25932,7 +25930,35 @@ function compileCopilotHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
   }
   return { payload: { hooks }, translated, dropped, droppedEvents };
 }
-function extractHookCommand(payload) {
+var CURSOR_TOOL_NAMES = {
+  Bash: "Shell",
+  Edit: "Write",
+  MultiEdit: "Write",
+  // Cursor's own names map to themselves. Without these a kit that already
+  // writes a Cursor matcher — the natural thing to do once this mapping is
+  // documented — would have it reported as untranslatable and warned about,
+  // while it is in fact the only spelling that works.
+  Shell: "Shell",
+  Read: "Read",
+  Write: "Write",
+  Grep: "Grep"
+};
+function translateCursorMatcher(matcher, untranslatable) {
+  const translated = [];
+  for (const token of matcher.split("|")) {
+    const trimmed = token.trim();
+    if (!trimmed) continue;
+    const mapped = CURSOR_TOOL_NAMES[trimmed];
+    if (mapped === void 0) {
+      untranslatable.add(trimmed);
+      if (!translated.includes(trimmed)) translated.push(trimmed);
+      continue;
+    }
+    if (!translated.includes(mapped)) translated.push(mapped);
+  }
+  return translated.join("|");
+}
+function extractHookCommands(payload) {
   const entries = Array.isArray(payload) ? payload : [payload];
   const found = [];
   for (const entry of entries) {
@@ -25949,15 +25975,7 @@ function extractHookCommand(payload) {
       }
     }
   }
-  if (found.length === 0) {
-    return { command: "", remaining: [] };
-  }
-  const [first, ...rest] = found;
-  return {
-    command: first.command,
-    ...first.matcher !== void 0 ? { matcher: first.matcher } : {},
-    remaining: rest.map((r) => r.command)
-  };
+  return found;
 }
 function normalizeHookEventRule(value, target, sourceEvent) {
   if (typeof value === "string") {

package/mappings/hook-events.yaml

@@ -143,81 +143,61 @@ targets:
 
   cursor:
     delivery: native-versioned-object
-    # READ THIS BEFORE TRUSTING THE ENTRIES BELOW.
+    # Measured on 2026-09-06 against cursor-agent 2026.09.02-c22c1a3, by writing a
+    # .cursor/hooks.json, running a real agent turn, and checking whether the hook's
+    # script had run. Every entry below is a result, not a reading of the binary.
     #
-    # On 2026-09-04 the shipped Cursor binary was inspected at
-    # /Applications/Cursor.app/Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js.
-    # Its hook-step enum holds twelve values, all camelCase:
+    # The steps are camelCase and come from a 21-value enum: beforeShellExecution,
+    # beforeMCPExecution, afterShellExecution, afterMCPExecution, beforeReadFile,
+    # afterFileEdit, beforeTabFileRead, afterTabFileEdit, stop, beforeSubmitPrompt,
+    # afterAgentResponse, afterAgentThought, sessionStart, sessionEnd, preCompact,
+    # subagentStart, subagentStop, preToolUse, postToolUse, postToolUseFailure,
+    # workspaceOpen. Every one of this file's source events has an equivalent there.
     #
-    #   afterFileEdit, afterMCPExecution, afterShellExecution, beforeMCPExecution,
-    #   beforeReadFile, beforeShellExecution, postToolUse, postToolUseFailure,
-    #   preCompact, preToolUse, subagentStart, subagentStop
+    # What the 2026-09-04 note above this block got wrong, and how:
     #
-    # The target_event values written below are PascalCase — `PreToolUse`, not `preToolUse` —
-    # and JSON keys are case sensitive. Three consequences follow, none of them verified:
+    #   1. The enum was read from the GUI app and had twelve values. The CLI's has
+    #      twenty-one, sessionStart and beforeSubmitPrompt among them. Two events
+    #      recorded here as having no equivalent do have one.
+    #   2. PascalCase was suspected of being the whole defect. It is not: a file in
+    #      Claude Code's own shape with PascalCase keys and { matcher, hooks: [] }
+    #      entries did not fire either, though the binary carries a detector for
+    #      that shape. Case and shape had to change together.
+    #   3. The entry was thought to hold one command per event, so the compiler
+    #      reported a collapse. It holds an array: three commands on one step all
+    #      ran, in parallel. There is nothing to collapse.
     #
-    #   1. What this CLI writes to .cursor/hooks.json may be inert. The file exists, names real
-    #      scripts, and may match no key Cursor looks up. That is exactly the failure shape this
-    #      mapping is meant to prevent, so it is recorded here rather than left to be discovered.
-    #   2. preCompact, subagentStart and subagentStop ARE in that enum, while the entries below
-    #      say they have "no documented equivalent". That claim is wrong, whatever the case
-    #      question turns out to be.
-    #   3. The same file resolves ~/.claude/settings.json and <project>/.claude/settings.json as
-    #      hook sources alongside ~/.cursor/hooks.json. Cursor may already be reading the
-    #      Claude Code artifact this CLI writes, which would make its own hooks.json redundant.
-    #
-    # Nothing below was changed on this evidence. Minified code read without running it is a
-    # strong hint and not a measurement, and swapping one unverified mapping for another is the
-    # same mistake in the other direction. To settle it: install this kit for cursor, open the
-    # Cursor GUI, run one agent turn that executes a shell command, and check whether the hook
-    # script ran — then repeat with the keys lowercased. Cursor has no CLI on the machine this
-    # was measured on, which is why it stopped here.
+    # One finding has no entry here because it belongs to the compiler: `matcher` is
+    # honoured, alternation included, but against Cursor's tool names. A hook scoped
+    # to "Bash" never runs; "Shell" does. See CURSOR_TOOL_NAMES in compiler/hooks.ts.
     source_to_target:
       SessionStart:
-        status: probe
-        reason: >-
-          Not in the observed enum under any casing, and not probeable without the GUI. See the
-          note above this block.
+        status: mapped
+        target_event: sessionStart
       UserPromptSubmit:
-        status: probe
-        reason: >-
-          Not in the observed enum; the nearest candidate is beforeSubmitPrompt, which is a
-          different contract. See the note above this block.
-      PostToolUseFailure:
-        status: probe
-        reason: >-
-          postToolUseFailure is in the observed enum, camelCased. Unverified. See the note above
-          this block.
+        status: mapped
+        target_event: beforeSubmitPrompt
       PreToolUse:
         status: mapped
-        target_event: PreToolUse
+        target_event: preToolUse
       PostToolUse:
         status: mapped
-        target_event: PostToolUse
+        target_event: postToolUse
+      PostToolUseFailure:
+        status: mapped
+        target_event: postToolUseFailure
       PreCompact:
-        status: probe
-        severity: warning
-        reason: >-
-          preCompact is in the observed enum, camelCased. The previous entry here said there was
-          no documented equivalent, which the enum contradicts. See the note above this block.
+        status: mapped
+        target_event: preCompact
       SubagentStart:
-        status: probe
-        severity: warning
-        reason: >-
-          subagentStart is in the observed enum, camelCased. The previous entry here said there was
-          no documented equivalent, which the enum contradicts. See the note above this block.
+        status: mapped
+        target_event: subagentStart
       SubagentStop:
-        status: probe
-        severity: warning
-        reason: >-
-          subagentStop is in the observed enum, camelCased. The previous entry here said there was
-          no documented equivalent, which the enum contradicts. See the note above this block.
+        status: mapped
+        target_event: subagentStop
       Stop:
-        status: drop
-        severity: warning
-        reason: >-
-          Not in the observed enum. `stop` appears in that file but as an unrelated identifier, so
-          this stays a drop rather than becoming a guess. See the note above this block.
+        status: mapped
+        target_event: stop
 
   # OpenCode and Cline exchange no declarative hook file at all: hooks are
   # plugin code (an OpenCode plugin, a @cline/sdk AgentPlugin), which a kit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alessandroraffa/tangyr",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "CLI for the Tangyr discipline — install and manage operating kits for AI coding tools",
   "license": "MIT",
   "engines": {