@xelauvas/xela-cli 0.1.0

package/src/components/messageActions.tsx

@@ -0,0 +1,450 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import type { RefObject } from 'react';
+import React, { useCallback, useMemo, useRef } from 'react';
+import { Box, Text } from '../ink.js';
+import { useKeybindings } from '../keybindings/useKeybinding.js';
+import { logEvent } from '../services/analytics/index.js';
+import type { NormalizedUserMessage, RenderableMessage } from '../types/message.js';
+import { isEmptyMessageText, SYNTHETIC_MESSAGES } from '../utils/messages.js';
+const NAVIGABLE_TYPES = ['user', 'assistant', 'grouped_tool_use', 'collapsed_read_search', 'system', 'attachment'] as const;
+export type NavigableType = (typeof NAVIGABLE_TYPES)[number];
+export type NavigableOf<T extends NavigableType> = Extract<RenderableMessage, {
+  type: T;
+}>;
+export type NavigableMessage = RenderableMessage;
+
+// Tier-2 blocklist (tier-1 is height > 0) — things that render but aren't actionable.
+export function isNavigableMessage(msg: NavigableMessage): boolean {
+  switch (msg.type) {
+    case 'assistant':
+      {
+        const b = msg.message.content[0];
+        // Text responses (minus AssistantTextMessage's return-null cases — tier-1
+        // misses unmeasured virtual items), or tool calls with extractable input.
+        return b?.type === 'text' && !isEmptyMessageText(b.text) && !SYNTHETIC_MESSAGES.has(b.text) || b?.type === 'tool_use' && b.name in PRIMARY_INPUT;
+      }
+    case 'user':
+      {
+        if (msg.isMeta || msg.isCompactSummary) return false;
+        const b = msg.message.content[0];
+        if (b?.type !== 'text') return false;
+        // Interrupt etc. — synthetic, not user-authored.
+        if (SYNTHETIC_MESSAGES.has(b.text)) return false;
+        // Same filter as VirtualMessageList sticky-prompt: XML-wrapped (command
+        // expansions, bash-stdout, etc.) aren't real prompts.
+        return !stripSystemReminders(b.text).startsWith('<');
+      }
+    case 'system':
+      // biome-ignore lint/nursery/useExhaustiveSwitchCases: blocklist — fallthrough return-true is the design
+      switch (msg.subtype) {
+        case 'api_metrics':
+        case 'stop_hook_summary':
+        case 'turn_duration':
+        case 'memory_saved':
+        case 'agents_killed':
+        case 'away_summary':
+        case 'thinking':
+          return false;
+      }
+      return true;
+    case 'grouped_tool_use':
+    case 'collapsed_read_search':
+      return true;
+    case 'attachment':
+      switch (msg.attachment.type) {
+        case 'queued_command':
+        case 'diagnostics':
+        case 'hook_blocking_error':
+        case 'hook_error_during_execution':
+          return true;
+      }
+      return false;
+  }
+}
+type PrimaryInput = {
+  label: string;
+  extract: (input: Record<string, unknown>) => string | undefined;
+};
+const str = (k: string) => (i: Record<string, unknown>) => typeof i[k] === 'string' ? i[k] : undefined;
+const PRIMARY_INPUT: Record<string, PrimaryInput> = {
+  Read: {
+    label: 'path',
+    extract: str('file_path')
+  },
+  Edit: {
+    label: 'path',
+    extract: str('file_path')
+  },
+  Write: {
+    label: 'path',
+    extract: str('file_path')
+  },
+  NotebookEdit: {
+    label: 'path',
+    extract: str('notebook_path')
+  },
+  Bash: {
+    label: 'command',
+    extract: str('command')
+  },
+  Grep: {
+    label: 'pattern',
+    extract: str('pattern')
+  },
+  Glob: {
+    label: 'pattern',
+    extract: str('pattern')
+  },
+  WebFetch: {
+    label: 'url',
+    extract: str('url')
+  },
+  WebSearch: {
+    label: 'query',
+    extract: str('query')
+  },
+  Task: {
+    label: 'prompt',
+    extract: str('prompt')
+  },
+  Agent: {
+    label: 'prompt',
+    extract: str('prompt')
+  },
+  Tmux: {
+    label: 'command',
+    extract: i => Array.isArray(i.args) ? `tmux ${i.args.join(' ')}` : undefined
+  }
+};
+
+// Only AgentTool has renderGroupedToolUse — Edit/Bash/etc. stay as assistant tool_use blocks.
+export function toolCallOf(msg: NavigableMessage): {
+  name: string;
+  input: Record<string, unknown>;
+} | undefined {
+  if (msg.type === 'assistant') {
+    const b = msg.message.content[0];
+    if (b?.type === 'tool_use') return {
+      name: b.name,
+      input: b.input as Record<string, unknown>
+    };
+  }
+  if (msg.type === 'grouped_tool_use') {
+    const b = msg.messages[0]?.message.content[0];
+    if (b?.type === 'tool_use') return {
+      name: msg.toolName,
+      input: b.input as Record<string, unknown>
+    };
+  }
+  return undefined;
+}
+export type MessageActionCaps = {
+  copy: (text: string) => void;
+  edit: (msg: NormalizedUserMessage) => Promise<void>;
+};
+
+// Identity builder — preserves tuple type so `run`'s param narrows (array literal widens without this).
+function action<const T extends NavigableType, const K extends string>(a: {
+  key: K;
+  label: string | ((s: MessageActionsState) => string);
+  types: readonly T[];
+  applies?: (s: MessageActionsState) => boolean;
+  stays?: true;
+  run: (m: NavigableOf<T>, caps: MessageActionCaps) => void;
+}) {
+  return a;
+}
+export const MESSAGE_ACTIONS = [action({
+  key: 'enter',
+  label: s => s.expanded ? 'collapse' : 'expand',
+  types: ['grouped_tool_use', 'collapsed_read_search', 'attachment', 'system'],
+  stays: true,
+  // Empty — `stays` handled inline by dispatch.
+  run: () => {}
+}), action({
+  key: 'enter',
+  label: 'edit',
+  types: ['user'],
+  run: (m, c) => void c.edit(m)
+}), action({
+  key: 'c',
+  label: 'copy',
+  types: NAVIGABLE_TYPES,
+  run: (m, c) => c.copy(copyTextOf(m))
+}), action({
+  key: 'p',
+  // `!` safe: applies() guarantees toolName ∈ PRIMARY_INPUT.
+  label: s => `copy ${PRIMARY_INPUT[s.toolName!]!.label}`,
+  types: ['grouped_tool_use', 'assistant'],
+  applies: s => s.toolName != null && s.toolName in PRIMARY_INPUT,
+  run: (m, c) => {
+    const tc = toolCallOf(m);
+    if (!tc) return;
+    const val = PRIMARY_INPUT[tc.name]?.extract(tc.input);
+    if (val) c.copy(val);
+  }
+})] as const;
+function isApplicable(a: (typeof MESSAGE_ACTIONS)[number], c: MessageActionsState): boolean {
+  if (!(a.types as readonly string[]).includes(c.msgType)) return false;
+  return !a.applies || a.applies(c);
+}
+export type MessageActionsState = {
+  uuid: string;
+  msgType: NavigableType;
+  expanded: boolean;
+  toolName?: string;
+};
+export type MessageActionsNav = {
+  enterCursor: () => void;
+  navigatePrev: () => void;
+  navigateNext: () => void;
+  navigatePrevUser: () => void;
+  navigateNextUser: () => void;
+  navigateTop: () => void;
+  navigateBottom: () => void;
+  getSelected: () => NavigableMessage | null;
+};
+export const MessageActionsSelectedContext = React.createContext(false);
+export const InVirtualListContext = React.createContext(false);
+
+// bg must go on the Box that HAS marginTop (margin stays outside paint) — that's inside each consumer.
+export function useSelectedMessageBg() {
+  return React.useContext(MessageActionsSelectedContext) ? "messageActionsBackground" : undefined;
+}
+
+// Can't call useKeybindings here — hook runs outside <KeybindingSetup> provider. Returns handlers instead.
+export function useMessageActions(cursor: MessageActionsState | null, setCursor: React.Dispatch<React.SetStateAction<MessageActionsState | null>>, navRef: RefObject<MessageActionsNav | null>, caps: MessageActionCaps): {
+  enter: () => void;
+  handlers: Record<string, () => void>;
+} {
+  // Refs keep handlers stable — no useKeybindings re-register per message append.
+  const cursorRef = useRef(cursor);
+  cursorRef.current = cursor;
+  const capsRef = useRef(caps);
+  capsRef.current = caps;
+  const handlers = useMemo(() => {
+    const h: Record<string, () => void> = {
+      'messageActions:prev': () => navRef.current?.navigatePrev(),
+      'messageActions:next': () => navRef.current?.navigateNext(),
+      'messageActions:prevUser': () => navRef.current?.navigatePrevUser(),
+      'messageActions:nextUser': () => navRef.current?.navigateNextUser(),
+      'messageActions:top': () => navRef.current?.navigateTop(),
+      'messageActions:bottom': () => navRef.current?.navigateBottom(),
+      'messageActions:escape': () => setCursor(c => c?.expanded ? {
+        ...c,
+        expanded: false
+      } : null),
+      // ctrl+c skips the collapse step — from expanded-during-streaming, two-stage
+      // would mean 3 presses to interrupt (collapse→null→cancel).
+      'messageActions:ctrlc': () => setCursor(null)
+    };
+    for (const key of new Set(MESSAGE_ACTIONS.map(a_1 => a_1.key))) {
+      h[`messageActions:${key}`] = () => {
+        const c_0 = cursorRef.current;
+        if (!c_0) return;
+        const a_0 = MESSAGE_ACTIONS.find(a => a.key === key && isApplicable(a, c_0));
+        if (!a_0) return;
+        if (a_0.stays) {
+          setCursor(c_1 => c_1 ? {
+            ...c_1,
+            expanded: !c_1.expanded
+          } : null);
+          return;
+        }
+        const m = navRef.current?.getSelected();
+        if (!m) return;
+        (a_0.run as (m: NavigableMessage, c_0: MessageActionCaps) => void)(m, capsRef.current);
+        setCursor(null);
+      };
+    }
+    return h;
+  }, [setCursor, navRef]);
+  const enter = useCallback(() => {
+    logEvent('tengu_message_actions_enter', {});
+    navRef.current?.enterCursor();
+  }, [navRef]);
+  return {
+    enter,
+    handlers
+  };
+}
+
+// Must mount inside <KeybindingSetup>.
+export function MessageActionsKeybindings(t0) {
+  const $ = _c(2);
+  const {
+    handlers,
+    isActive
+  } = t0;
+  let t1;
+  if ($[0] !== isActive) {
+    t1 = {
+      context: "MessageActions",
+      isActive
+    };
+    $[0] = isActive;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  useKeybindings(handlers, t1);
+  return null;
+}
+
+// borderTop-only Box matches PromptInput's ─── line for stable footer height.
+export function MessageActionsBar(t0) {
+  const $ = _c(28);
+  const {
+    cursor
+  } = t0;
+  let T0;
+  let T1;
+  let t1;
+  let t2;
+  let t3;
+  let t4;
+  let t5;
+  let t6;
+  let t7;
+  if ($[0] !== cursor) {
+    const applicable = MESSAGE_ACTIONS.filter(a => isApplicable(a, cursor));
+    T1 = Box;
+    t4 = "column";
+    t5 = 0;
+    t6 = 1;
+    if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+      t7 = <Box borderStyle="single" borderTop={true} borderBottom={false} borderLeft={false} borderRight={false} borderDimColor={true} />;
+      $[10] = t7;
+    } else {
+      t7 = $[10];
+    }
+    T0 = Box;
+    t1 = 2;
+    t2 = 1;
+    t3 = applicable.map((a_0, i) => {
+      const label = typeof a_0.label === "function" ? a_0.label(cursor) : a_0.label;
+      return <React.Fragment key={a_0.key}>{i > 0 && <Text dimColor={true}> · </Text>}<Text bold={true} dimColor={false}>{a_0.key}</Text><Text dimColor={true}> {label}</Text></React.Fragment>;
+    });
+    $[0] = cursor;
+    $[1] = T0;
+    $[2] = T1;
+    $[3] = t1;
+    $[4] = t2;
+    $[5] = t3;
+    $[6] = t4;
+    $[7] = t5;
+    $[8] = t6;
+    $[9] = t7;
+  } else {
+    T0 = $[1];
+    T1 = $[2];
+    t1 = $[3];
+    t2 = $[4];
+    t3 = $[5];
+    t4 = $[6];
+    t5 = $[7];
+    t6 = $[8];
+    t7 = $[9];
+  }
+  let t10;
+  let t11;
+  let t12;
+  let t8;
+  let t9;
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = <Text dimColor={true}> · </Text>;
+    t9 = <Text bold={true} dimColor={false}>{figures.arrowUp}{figures.arrowDown}</Text>;
+    t10 = <Text dimColor={true}> navigate · </Text>;
+    t11 = <Text bold={true} dimColor={false}>esc</Text>;
+    t12 = <Text dimColor={true}> back</Text>;
+    $[11] = t10;
+    $[12] = t11;
+    $[13] = t12;
+    $[14] = t8;
+    $[15] = t9;
+  } else {
+    t10 = $[11];
+    t11 = $[12];
+    t12 = $[13];
+    t8 = $[14];
+    t9 = $[15];
+  }
+  let t13;
+  if ($[16] !== T0 || $[17] !== t1 || $[18] !== t2 || $[19] !== t3) {
+    t13 = <T0 paddingX={t1} paddingY={t2}>{t3}{t8}{t9}{t10}{t11}{t12}</T0>;
+    $[16] = T0;
+    $[17] = t1;
+    $[18] = t2;
+    $[19] = t3;
+    $[20] = t13;
+  } else {
+    t13 = $[20];
+  }
+  let t14;
+  if ($[21] !== T1 || $[22] !== t13 || $[23] !== t4 || $[24] !== t5 || $[25] !== t6 || $[26] !== t7) {
+    t14 = <T1 flexDirection={t4} flexShrink={t5} paddingY={t6}>{t7}{t13}</T1>;
+    $[21] = T1;
+    $[22] = t13;
+    $[23] = t4;
+    $[24] = t5;
+    $[25] = t6;
+    $[26] = t7;
+    $[27] = t14;
+  } else {
+    t14 = $[27];
+  }
+  return t14;
+}
+export function stripSystemReminders(text: string): string {
+  const CLOSE = '</system-reminder>';
+  let t = text.trimStart();
+  while (t.startsWith('<system-reminder>')) {
+    const end = t.indexOf(CLOSE);
+    if (end < 0) break;
+    t = t.slice(end + CLOSE.length).trimStart();
+  }
+  return t;
+}
+export function copyTextOf(msg: NavigableMessage): string {
+  switch (msg.type) {
+    case 'user':
+      {
+        const b = msg.message.content[0];
+        return b?.type === 'text' ? stripSystemReminders(b.text) : '';
+      }
+    case 'assistant':
+      {
+        const b = msg.message.content[0];
+        if (b?.type === 'text') return b.text;
+        const tc = toolCallOf(msg);
+        return tc ? PRIMARY_INPUT[tc.name]?.extract(tc.input) ?? '' : '';
+      }
+    case 'grouped_tool_use':
+      return msg.results.map(toolResultText).filter(Boolean).join('\n\n');
+    case 'collapsed_read_search':
+      return msg.messages.flatMap(m => m.type === 'user' ? [toolResultText(m)] : m.type === 'grouped_tool_use' ? m.results.map(toolResultText) : []).filter(Boolean).join('\n\n');
+    case 'system':
+      if ('content' in msg) return msg.content;
+      if ('error' in msg) return String(msg.error);
+      return msg.subtype;
+    case 'attachment':
+      {
+        const a = msg.attachment;
+        if (a.type === 'queued_command') {
+          const p = a.prompt;
+          return typeof p === 'string' ? p : p.flatMap(b => b.type === 'text' ? [b.text] : []).join('\n');
+        }
+        return `[${a.type}]`;
+      }
+  }
+}
+function toolResultText(r: NormalizedUserMessage): string {
+  const b = r.message.content[0];
+  if (b?.type !== 'tool_result') return '';
+  const c = b.content;
+  if (typeof c === 'string') return c;
+  if (!c) return '';
+  return c.flatMap(x => x.type === 'text' ? [x.text] : []).join('\n');
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","RefObject","React","useCallback","useMemo","useRef","Box","Text","useKeybindings","logEvent","NormalizedUserMessage","RenderableMessage","isEmptyMessageText","SYNTHETIC_MESSAGES","NAVIGABLE_TYPES","const","NavigableType","NavigableOf","Extract","type","T","NavigableMessage","isNavigableMessage","msg","b","message","content","text","has","name","PRIMARY_INPUT","isMeta","isCompactSummary","stripSystemReminders","startsWith","subtype","attachment","PrimaryInput","label","extract","input","Record","str","k","i","undefined","Read","Edit","Write","NotebookEdit","Bash","Grep","Glob","WebFetch","WebSearch","Task","Agent","Tmux","Array","isArray","args","join","toolCallOf","messages","toolName","MessageActionCaps","copy","edit","Promise","action","a","key","K","s","MessageActionsState","types","applies","stays","run","m","caps","MESSAGE_ACTIONS","expanded","c","copyTextOf","tc","val","isApplicable","includes","msgType","uuid","MessageActionsNav","enterCursor","navigatePrev","navigateNext","navigatePrevUser","navigateNextUser","navigateTop","navigateBottom","getSelected","MessageActionsSelectedContext","createContext","InVirtualListContext","useSelectedMessageBg","useContext","useMessageActions","cursor","setCursor","Dispatch","SetStateAction","navRef","enter","handlers","cursorRef","current","capsRef","h","messageActions:prev","messageActions:next","messageActions:prevUser","messageActions:nextUser","messageActions:top","messageActions:bottom","messageActions:escape","messageActions:ctrlc","Set","map","find","MessageActionsKeybindings","t0","$","_c","isActive","t1","context","MessageActionsBar","T0","T1","t2","t3","t4","t5","t6","t7","applicable","filter","Symbol","for","a_0","t10","t11","t12","t8","t9","arrowUp","arrowDown","t13","t14","CLOSE","t","trimStart","end","indexOf","slice","length","results","toolResultText","Boolean","flatMap","String","error","p","prompt","r","x"],"sources":["messageActions.tsx"],"sourcesContent":["import figures from 'figures'\nimport type { RefObject } from 'react'\nimport React, { useCallback, useMemo, useRef } from 'react'\nimport { Box, Text } from '../ink.js'\nimport { useKeybindings } from '../keybindings/useKeybinding.js'\nimport { logEvent } from '../services/analytics/index.js'\nimport type {\n  NormalizedUserMessage,\n  RenderableMessage,\n} from '../types/message.js'\nimport { isEmptyMessageText, SYNTHETIC_MESSAGES } from '../utils/messages.js'\n\nconst NAVIGABLE_TYPES = [\n  'user',\n  'assistant',\n  'grouped_tool_use',\n  'collapsed_read_search',\n  'system',\n  'attachment',\n] as const\nexport type NavigableType = (typeof NAVIGABLE_TYPES)[number]\n\nexport type NavigableOf<T extends NavigableType> = Extract<\n  RenderableMessage,\n  { type: T }\n>\nexport type NavigableMessage = RenderableMessage\n\n// Tier-2 blocklist (tier-1 is height > 0) — things that render but aren't actionable.\nexport function isNavigableMessage(msg: NavigableMessage): boolean {\n  switch (msg.type) {\n    case 'assistant': {\n      const b = msg.message.content[0]\n      // Text responses (minus AssistantTextMessage's return-null cases — tier-1\n      // misses unmeasured virtual items), or tool calls with extractable input.\n      return (\n        (b?.type === 'text' &&\n          !isEmptyMessageText(b.text) &&\n          !SYNTHETIC_MESSAGES.has(b.text)) ||\n        (b?.type === 'tool_use' && b.name in PRIMARY_INPUT)\n      )\n    }\n    case 'user': {\n      if (msg.isMeta || msg.isCompactSummary) return false\n      const b = msg.message.content[0]\n      if (b?.type !== 'text') return false\n      // Interrupt etc. — synthetic, not user-authored.\n      if (SYNTHETIC_MESSAGES.has(b.text)) return false\n      // Same filter as VirtualMessageList sticky-prompt: XML-wrapped (command\n      // expansions, bash-stdout, etc.) aren't real prompts.\n      return !stripSystemReminders(b.text).startsWith('<')\n    }\n    case 'system':\n      // biome-ignore lint/nursery/useExhaustiveSwitchCases: blocklist — fallthrough return-true is the design\n      switch (msg.subtype) {\n        case 'api_metrics':\n        case 'stop_hook_summary':\n        case 'turn_duration':\n        case 'memory_saved':\n        case 'agents_killed':\n        case 'away_summary':\n        case 'thinking':\n          return false\n      }\n      return true\n    case 'grouped_tool_use':\n    case 'collapsed_read_search':\n      return true\n    case 'attachment':\n      switch (msg.attachment.type) {\n        case 'queued_command':\n        case 'diagnostics':\n        case 'hook_blocking_error':\n        case 'hook_error_during_execution':\n          return true\n      }\n      return false\n  }\n}\n\ntype PrimaryInput = {\n  label: string\n  extract: (input: Record<string, unknown>) => string | undefined\n}\nconst str = (k: string) => (i: Record<string, unknown>) =>\n  typeof i[k] === 'string' ? i[k] : undefined\nconst PRIMARY_INPUT: Record<string, PrimaryInput> = {\n  Read: { label: 'path', extract: str('file_path') },\n  Edit: { label: 'path', extract: str('file_path') },\n  Write: { label: 'path', extract: str('file_path') },\n  NotebookEdit: { label: 'path', extract: str('notebook_path') },\n  Bash: { label: 'command', extract: str('command') },\n  Grep: { label: 'pattern', extract: str('pattern') },\n  Glob: { label: 'pattern', extract: str('pattern') },\n  WebFetch: { label: 'url', extract: str('url') },\n  WebSearch: { label: 'query', extract: str('query') },\n  Task: { label: 'prompt', extract: str('prompt') },\n  Agent: { label: 'prompt', extract: str('prompt') },\n  Tmux: {\n    label: 'command',\n    extract: i =>\n      Array.isArray(i.args) ? `tmux ${i.args.join(' ')}` : undefined,\n  },\n}\n\n// Only AgentTool has renderGroupedToolUse — Edit/Bash/etc. stay as assistant tool_use blocks.\nexport function toolCallOf(\n  msg: NavigableMessage,\n): { name: string; input: Record<string, unknown> } | undefined {\n  if (msg.type === 'assistant') {\n    const b = msg.message.content[0]\n    if (b?.type === 'tool_use')\n      return { name: b.name, input: b.input as Record<string, unknown> }\n  }\n  if (msg.type === 'grouped_tool_use') {\n    const b = msg.messages[0]?.message.content[0]\n    if (b?.type === 'tool_use')\n      return { name: msg.toolName, input: b.input as Record<string, unknown> }\n  }\n  return undefined\n}\n\nexport type MessageActionCaps = {\n  copy: (text: string) => void\n  edit: (msg: NormalizedUserMessage) => Promise<void>\n}\n\n// Identity builder — preserves tuple type so `run`'s param narrows (array literal widens without this).\nfunction action<const T extends NavigableType, const K extends string>(a: {\n  key: K\n  label: string | ((s: MessageActionsState) => string)\n  types: readonly T[]\n  applies?: (s: MessageActionsState) => boolean\n  stays?: true\n  run: (m: NavigableOf<T>, caps: MessageActionCaps) => void\n}) {\n  return a\n}\n\nexport const MESSAGE_ACTIONS = [\n  action({\n    key: 'enter',\n    label: s => (s.expanded ? 'collapse' : 'expand'),\n    types: [\n      'grouped_tool_use',\n      'collapsed_read_search',\n      'attachment',\n      'system',\n    ],\n    stays: true,\n    // Empty — `stays` handled inline by dispatch.\n    run: () => {},\n  }),\n  action({\n    key: 'enter',\n    label: 'edit',\n    types: ['user'],\n    run: (m, c) => void c.edit(m),\n  }),\n  action({\n    key: 'c',\n    label: 'copy',\n    types: NAVIGABLE_TYPES,\n    run: (m, c) => c.copy(copyTextOf(m)),\n  }),\n  action({\n    key: 'p',\n    // `!` safe: applies() guarantees toolName ∈ PRIMARY_INPUT.\n    label: s => `copy ${PRIMARY_INPUT[s.toolName!]!.label}`,\n    types: ['grouped_tool_use', 'assistant'],\n    applies: s => s.toolName != null && s.toolName in PRIMARY_INPUT,\n    run: (m, c) => {\n      const tc = toolCallOf(m)\n      if (!tc) return\n      const val = PRIMARY_INPUT[tc.name]?.extract(tc.input)\n      if (val) c.copy(val)\n    },\n  }),\n] as const\n\nfunction isApplicable(\n  a: (typeof MESSAGE_ACTIONS)[number],\n  c: MessageActionsState,\n): boolean {\n  if (!(a.types as readonly string[]).includes(c.msgType)) return false\n  return !a.applies || a.applies(c)\n}\n\nexport type MessageActionsState = {\n  uuid: string\n  msgType: NavigableType\n  expanded: boolean\n  toolName?: string\n}\n\nexport type MessageActionsNav = {\n  enterCursor: () => void\n  navigatePrev: () => void\n  navigateNext: () => void\n  navigatePrevUser: () => void\n  navigateNextUser: () => void\n  navigateTop: () => void\n  navigateBottom: () => void\n  getSelected: () => NavigableMessage | null\n}\n\nexport const MessageActionsSelectedContext = React.createContext(false)\nexport const InVirtualListContext = React.createContext(false)\n\n// bg must go on the Box that HAS marginTop (margin stays outside paint) — that's inside each consumer.\nexport function useSelectedMessageBg(): 'messageActionsBackground' | undefined {\n  return React.useContext(MessageActionsSelectedContext)\n    ? 'messageActionsBackground'\n    : undefined\n}\n\n// Can't call useKeybindings here — hook runs outside <KeybindingSetup> provider. Returns handlers instead.\nexport function useMessageActions(\n  cursor: MessageActionsState | null,\n  setCursor: React.Dispatch<React.SetStateAction<MessageActionsState | null>>,\n  navRef: RefObject<MessageActionsNav | null>,\n  caps: MessageActionCaps,\n): {\n  enter: () => void\n  handlers: Record<string, () => void>\n} {\n  // Refs keep handlers stable — no useKeybindings re-register per message append.\n  const cursorRef = useRef(cursor)\n  cursorRef.current = cursor\n  const capsRef = useRef(caps)\n  capsRef.current = caps\n\n  const handlers = useMemo(() => {\n    const h: Record<string, () => void> = {\n      'messageActions:prev': () => navRef.current?.navigatePrev(),\n      'messageActions:next': () => navRef.current?.navigateNext(),\n      'messageActions:prevUser': () => navRef.current?.navigatePrevUser(),\n      'messageActions:nextUser': () => navRef.current?.navigateNextUser(),\n      'messageActions:top': () => navRef.current?.navigateTop(),\n      'messageActions:bottom': () => navRef.current?.navigateBottom(),\n      'messageActions:escape': () =>\n        setCursor(c => (c?.expanded ? { ...c, expanded: false } : null)),\n      // ctrl+c skips the collapse step — from expanded-during-streaming, two-stage\n      // would mean 3 presses to interrupt (collapse→null→cancel).\n      'messageActions:ctrlc': () => setCursor(null),\n    }\n    for (const key of new Set(MESSAGE_ACTIONS.map(a => a.key))) {\n      h[`messageActions:${key}`] = () => {\n        const c = cursorRef.current\n        if (!c) return\n        const a = MESSAGE_ACTIONS.find(a => a.key === key && isApplicable(a, c))\n        if (!a) return\n        if (a.stays) {\n          setCursor(c => (c ? { ...c, expanded: !c.expanded } : null))\n          return\n        }\n        const m = navRef.current?.getSelected()\n        if (!m) return\n        ;(a.run as (m: NavigableMessage, c: MessageActionCaps) => void)(\n          m,\n          capsRef.current,\n        )\n        setCursor(null)\n      }\n    }\n    return h\n  }, [setCursor, navRef])\n\n  const enter = useCallback(() => {\n    logEvent('tengu_message_actions_enter', {})\n    navRef.current?.enterCursor()\n  }, [navRef])\n\n  return { enter, handlers }\n}\n\n// Must mount inside <KeybindingSetup>.\nexport function MessageActionsKeybindings({\n  handlers,\n  isActive,\n}: {\n  handlers: Record<string, () => void>\n  isActive: boolean\n}): null {\n  useKeybindings(handlers, { context: 'MessageActions', isActive })\n  return null\n}\n\n// borderTop-only Box matches PromptInput's ─── line for stable footer height.\nexport function MessageActionsBar({\n  cursor,\n}: {\n  cursor: MessageActionsState\n}): React.ReactNode {\n  const applicable = MESSAGE_ACTIONS.filter(a => isApplicable(a, cursor))\n  return (\n    <Box flexDirection=\"column\" flexShrink={0} paddingY={1}>\n      <Box\n        borderStyle=\"single\"\n        borderTop\n        borderBottom={false}\n        borderLeft={false}\n        borderRight={false}\n        borderDimColor\n      />\n      <Box paddingX={2} paddingY={1}>\n        {applicable.map((a, i) => {\n          const label =\n            typeof a.label === 'function' ? a.label(cursor) : a.label\n          return (\n            <React.Fragment key={a.key}>\n              {i > 0 && <Text dimColor> · </Text>}\n              {/* dimColor={false} forces SGR 22 — borderDimColor sibling bleeds dim into first cell */}\n              <Text bold dimColor={false}>\n                {a.key}\n              </Text>\n              <Text dimColor> {label}</Text>\n            </React.Fragment>\n          )\n        })}\n        <Text dimColor> · </Text>\n        <Text bold dimColor={false}>\n          {figures.arrowUp}\n          {figures.arrowDown}\n        </Text>\n        <Text dimColor> navigate · </Text>\n        <Text bold dimColor={false}>\n          esc\n        </Text>\n        <Text dimColor> back</Text>\n      </Box>\n    </Box>\n  )\n}\n\nexport function stripSystemReminders(text: string): string {\n  const CLOSE = '</system-reminder>'\n  let t = text.trimStart()\n  while (t.startsWith('<system-reminder>')) {\n    const end = t.indexOf(CLOSE)\n    if (end < 0) break\n    t = t.slice(end + CLOSE.length).trimStart()\n  }\n  return t\n}\n\nexport function copyTextOf(msg: NavigableMessage): string {\n  switch (msg.type) {\n    case 'user': {\n      const b = msg.message.content[0]\n      return b?.type === 'text' ? stripSystemReminders(b.text) : ''\n    }\n    case 'assistant': {\n      const b = msg.message.content[0]\n      if (b?.type === 'text') return b.text\n      const tc = toolCallOf(msg)\n      return tc ? (PRIMARY_INPUT[tc.name]?.extract(tc.input) ?? '') : ''\n    }\n    case 'grouped_tool_use':\n      return msg.results.map(toolResultText).filter(Boolean).join('\\n\\n')\n    case 'collapsed_read_search':\n      return msg.messages\n        .flatMap(m =>\n          m.type === 'user'\n            ? [toolResultText(m)]\n            : m.type === 'grouped_tool_use'\n              ? m.results.map(toolResultText)\n              : [],\n        )\n        .filter(Boolean)\n        .join('\\n\\n')\n    case 'system':\n      if ('content' in msg) return msg.content\n      if ('error' in msg) return String(msg.error)\n      return msg.subtype\n    case 'attachment': {\n      const a = msg.attachment\n      if (a.type === 'queued_command') {\n        const p = a.prompt\n        return typeof p === 'string'\n          ? p\n          : p.flatMap(b => (b.type === 'text' ? [b.text] : [])).join('\\n')\n      }\n      return `[${a.type}]`\n    }\n  }\n}\n\nfunction toolResultText(r: NormalizedUserMessage): string {\n  const b = r.message.content[0]\n  if (b?.type !== 'tool_result') return ''\n  const c = b.content\n  if (typeof c === 'string') return c\n  if (!c) return ''\n  return c.flatMap(x => (x.type === 'text' ? [x.text] : [])).join('\\n')\n}\n"],"mappings":"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","ignoreList":[]}