@yancyyu/openhermit 1.5.8

package/src/renderer/utils/slashCommandExtractor.ts

@@ -0,0 +1,154 @@
+/**
+ * Slash Command Extractor - Handle slash command extraction from AI Group responses
+ *
+ * Extracts and processes slash command invocations and their follow-up instructions.
+ */
+
+import { extractSlashInfo, isCommandContent } from '@shared/utils/contentSanitizer';
+
+import { estimateTokens, toDate } from './aiGroupHelpers';
+
+import type { ParsedMessage } from '@renderer/types/data';
+import type { SlashItem } from '@renderer/types/groups';
+
+/**
+ * Info about the preceding user message's slash invocation.
+ * This is passed from the UserGroup to help link slash outputs to slash names.
+ */
+export interface PrecedingSlashInfo {
+  /** Slash name (e.g., "claude-hud:setup", "isolate-context", "model") */
+  name: string;
+  /** Message content from <command-message> */
+  message?: string;
+  /** Arguments from <command-args> */
+  args?: string;
+  /** UUID of the slash command message */
+  commandMessageUuid: string;
+  /** Timestamp of the slash command message */
+  timestamp: Date;
+}
+
+/**
+ * Extract slash items from AI group responses.
+ *
+ * All slash invocations follow the same format:
+ *   <command-name>/xxx</command-name>
+ *   <command-message>xxx</command-message>
+ *   <command-args>optional</command-args>
+ *
+ * Strategy:
+ * 1. Build a map of follow-up messages (isMeta:true with parentUuid) by their parentUuid
+ * 2. If precedingSlash is provided, create a SlashItem with its follow-up instructions
+ * 3. Also check for any slash invocations in responses (fallback)
+ *
+ * @param responses - All response messages in the AI group
+ * @param precedingSlash - Optional slash info from the preceding UserGroup
+ * @returns Array of SlashItem objects ready for display
+ */
+export function extractSlashes(
+  responses: ParsedMessage[],
+  precedingSlash?: PrecedingSlashInfo
+): SlashItem[] {
+  const slashes: SlashItem[] = [];
+
+  // Build a map of follow-up messages by their parentUuid
+  // These are isMeta:true messages that contain slash instructions/output
+  const followUpsByParentUuid = new Map<
+    string,
+    {
+      text: string;
+      timestamp: Date;
+    }
+  >();
+
+  // Also build a map of potential slash messages from responses (fallback)
+  const slashMessagesById = new Map<
+    string,
+    {
+      uuid: string;
+      name: string;
+      message?: string;
+      args?: string;
+      timestamp: Date;
+    }
+  >();
+
+  for (const msg of responses) {
+    // Look for slash messages (user messages with string content containing <command-name>)
+    // This is a fallback in case the slash invocation is somehow in responses
+    if (msg.type === 'user' && typeof msg.content === 'string' && isCommandContent(msg.content)) {
+      const slashInfo = extractSlashInfo(msg.content);
+      if (slashInfo) {
+        slashMessagesById.set(msg.uuid, {
+          uuid: msg.uuid,
+          name: slashInfo.name,
+          message: slashInfo.message,
+          args: slashInfo.args,
+          timestamp: toDate(msg.timestamp),
+        });
+      }
+    }
+
+    // Look for follow-up isMeta messages with parentUuid
+    if (
+      msg.type === 'user' &&
+      msg.isMeta === true &&
+      msg.parentUuid &&
+      !msg.sourceToolUseID && // Exclude tool-call related messages
+      Array.isArray(msg.content)
+    ) {
+      // Extract text from the message
+      for (const block of msg.content) {
+        if (block.type === 'text' && block.text) {
+          const text = block.text;
+          followUpsByParentUuid.set(msg.parentUuid, {
+            text,
+            timestamp: toDate(msg.timestamp),
+          });
+          break; // Only need the first text block
+        }
+      }
+    }
+  }
+
+  // Strategy 1: If we have precedingSlash info, create a SlashItem with its follow-up
+  if (precedingSlash) {
+    const followUp = followUpsByParentUuid.get(precedingSlash.commandMessageUuid);
+
+    slashes.push({
+      id: `slash-${precedingSlash.commandMessageUuid}`,
+      name: precedingSlash.name,
+      message: precedingSlash.message,
+      args: precedingSlash.args,
+      commandMessageUuid: precedingSlash.commandMessageUuid,
+      instructions: followUp?.text,
+      instructionsTokenCount: followUp ? estimateTokens(followUp.text) : undefined,
+      // Use follow-up timestamp if available (sorts with other AI items),
+      // otherwise fall back to slash invocation timestamp
+      timestamp: followUp?.timestamp ?? precedingSlash.timestamp,
+    });
+  }
+
+  // Strategy 2: Fallback - match slash messages found in responses to their follow-ups
+  for (const [uuid, slashMsg] of slashMessagesById.entries()) {
+    // Skip if we already added this slash via precedingSlash
+    if (uuid === precedingSlash?.commandMessageUuid) {
+      continue;
+    }
+
+    const followUp = followUpsByParentUuid.get(uuid);
+
+    slashes.push({
+      id: `slash-${uuid}`,
+      name: slashMsg.name,
+      message: slashMsg.message,
+      args: slashMsg.args,
+      commandMessageUuid: uuid,
+      instructions: followUp?.text,
+      instructionsTokenCount: followUp ? estimateTokens(followUp.text) : undefined,
+      timestamp: slashMsg.timestamp,
+    });
+  }
+
+  return slashes;
+}

package/src/renderer/utils/streamJsonParser.ts

@@ -0,0 +1,393 @@
+/**
+ * Stream-JSON Parser
+ *
+ * Parses CLI stream-json stdout lines into AIGroupDisplayItem[] for rich rendering.
+ * Used by CliLogsRichView to replace raw JSON display with beautiful components.
+ */
+
+import { getToolSummary } from '@renderer/utils/toolRendering/toolSummaryHelpers';
+import { summarizeAgentToolInput } from '@shared/utils/toolSummary';
+
+import type { AIGroupDisplayItem, LinkedToolItem } from '@renderer/types/groups';
+
+/**
+ * A group of display items from one or more consecutive assistant messages.
+ */
+export interface StreamJsonGroup {
+  /** Unique group ID */
+  id: string;
+  /** Display items within this group */
+  items: AIGroupDisplayItem[];
+  /** Human-readable summary (e.g. "1 thinking, 2 tool calls") */
+  summary: string;
+  /** Timestamp of first message in group */
+  timestamp: Date;
+  /** If set, this group belongs to a subagent (not the lead). */
+  agentId?: string;
+}
+
+/** A subagent section wrapping consecutive groups from the same agentId. */
+export interface SubagentSection {
+  id: string;
+  agentId: string;
+  /** Human-readable description from the Agent tool_use that spawned this subagent */
+  description: string;
+  groups: StreamJsonGroup[];
+  toolCount: number;
+  timestamp: Date;
+}
+
+/** Union type for the final render list after subagent grouping. */
+export type StreamJsonEntry =
+  | { type: 'group'; group: StreamJsonGroup }
+  | { type: 'subagent-section'; section: SubagentSection };
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+}
+
+/**
+ * Content-based hash for deterministic fallback IDs that survive
+ * line reordering and pagination changes.
+ * Caps input length to avoid hashing huge payloads.
+ */
+function stableHash(s: string): string {
+  let h = 0;
+  const len = Math.min(s.length, 500);
+  for (let i = 0; i < len; i++) {
+    h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+  }
+  return (h >>> 0).toString(36);
+}
+
+/**
+ * Attempts to extract the content array from a parsed stream-json line.
+ * Handles both `{ type: "assistant", content: [...] }` (direct) and
+ * `{ type: "assistant", message: { type: "message", content: [...] } }` (wrapped) formats.
+ */
+function extractContentBlocks(parsed: unknown): ContentBlock[] | null {
+  if (!parsed || typeof parsed !== 'object') return null;
+
+  const obj = parsed as Record<string, unknown>;
+
+  // Only process assistant messages
+  if (obj.type !== 'assistant') return null;
+
+  // Direct format: { type: "assistant", content: [...] }
+  if (Array.isArray(obj.content)) {
+    return obj.content as ContentBlock[];
+  }
+
+  // Wrapped format: { type: "assistant", message: { type: "message", content: [...] } }
+  // The inner message.type is "message" (not "assistant")
+  if (obj.message && typeof obj.message === 'object') {
+    const msg = obj.message as Record<string, unknown>;
+    if (Array.isArray(msg.content)) {
+      return msg.content as ContentBlock[];
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Converts content blocks from a single assistant message into display items.
+ * @param lineIndex - stable line position for deterministic fallback IDs
+ */
+function contentBlocksToDisplayItems(
+  blocks: ContentBlock[],
+  timestamp: Date,
+  lineIndex: number
+): AIGroupDisplayItem[] {
+  const items: AIGroupDisplayItem[] = [];
+
+  for (let blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
+    const block = blocks[blockIdx];
+    switch (block.type) {
+      case 'thinking': {
+        const text = block.thinking ?? '';
+        if (text.trim()) {
+          items.push({ type: 'thinking', content: text, timestamp });
+        }
+        break;
+      }
+
+      case 'text': {
+        const text = block.text ?? '';
+        if (text.trim()) {
+          items.push({ type: 'output', content: text, timestamp });
+        }
+        break;
+      }
+
+      case 'tool_use': {
+        const input = block.input ?? {};
+        const toolName = block.name ?? 'Unknown';
+        const linkedTool: LinkedToolItem = {
+          id: block.id ?? `stream-tool-L${lineIndex}-B${blockIdx}`,
+          name: toolName,
+          input,
+          inputPreview: getToolSummary(toolName, input),
+          startTime: timestamp,
+          isOrphaned: true,
+        };
+        items.push({ type: 'tool', tool: linkedTool });
+        break;
+      }
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Builds a human-readable summary string from display items.
+ */
+function buildGroupSummary(items: AIGroupDisplayItem[]): string {
+  let thinkingCount = 0;
+  let toolCount = 0;
+  let outputCount = 0;
+
+  for (const item of items) {
+    switch (item.type) {
+      case 'thinking':
+        thinkingCount++;
+        break;
+      case 'tool':
+        toolCount++;
+        break;
+      case 'output':
+        outputCount++;
+        break;
+    }
+  }
+
+  const parts: string[] = [];
+  if (thinkingCount > 0) parts.push(`${thinkingCount} thinking`);
+  if (toolCount > 0) parts.push(`${toolCount} tool call${toolCount > 1 ? 's' : ''}`);
+  if (outputCount > 0) parts.push(`${outputCount} output${outputCount > 1 ? 's' : ''}`);
+
+  return parts.join(', ') || 'empty';
+}
+
+function extractAssistantMessageId(parsed: unknown): string | null {
+  if (!parsed || typeof parsed !== 'object') return null;
+  const obj = parsed as Record<string, unknown>;
+  if (obj.type !== 'assistant') return null;
+
+  // Direct format can include id at top-level
+  if (typeof obj.id === 'string' && obj.id.trim()) return obj.id.trim();
+
+  // Wrapped format: { type: "assistant", message: { id, ... } }
+  const msg = obj.message;
+  if (msg && typeof msg === 'object') {
+    const inner = msg as Record<string, unknown>;
+    if (typeof inner.id === 'string' && inner.id.trim()) return inner.id.trim();
+  }
+
+  return null;
+}
+
+/**
+ * Module-level timestamp cache keyed by line content.
+ * Ensures re-parses of the same log lines preserve their original timestamps
+ * instead of getting new Date() each time.
+ */
+const lineTimestampCache = new Map<string, Date>();
+const MAX_TIMESTAMP_CACHE_SIZE = 5000;
+
+/**
+ * Parses stream-json CLI output lines into structured groups for rich rendering.
+ *
+ * Each group represents one or more consecutive assistant messages.
+ * Non-assistant lines (markers, errors, etc.) are silently skipped.
+ */
+export function parseStreamJsonToGroups(cliLogsTail: string): StreamJsonGroup[] {
+  if (!cliLogsTail.trim()) return [];
+
+  const lines = cliLogsTail.split('\n');
+  const groups: StreamJsonGroup[] = [];
+  let currentItems: AIGroupDisplayItem[] = [];
+  let currentTimestamp: Date | null = null;
+  let currentGroupId: string | null = null;
+  let currentAgentId: string | undefined = undefined;
+  // Track how many times each messageId / hash has been seen to disambiguate duplicates
+  const msgIdOccurrences = new Map<string, number>();
+  const hashOccurrences = new Map<string, number>();
+
+  const flushGroup = (): void => {
+    if (currentItems.length > 0 && currentTimestamp) {
+      const id = currentGroupId ?? `stream-group-fallback-${groups.length}`;
+      groups.push({
+        id,
+        items: currentItems,
+        summary: buildGroupSummary(currentItems),
+        timestamp: currentTimestamp,
+        agentId: currentAgentId,
+      });
+      currentItems = [];
+      currentTimestamp = null;
+      currentGroupId = null;
+      currentAgentId = undefined;
+    }
+  };
+
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const trimmed = lines[lineIndex].trim();
+
+    // Skip empty lines; stream markers break groups
+    if (!trimmed) continue;
+    if (trimmed.startsWith('[stdout]') || trimmed.startsWith('[stderr]')) {
+      flushGroup();
+      continue;
+    }
+
+    // Try to parse as JSON
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      // Non-JSON line (stderr debug output, truncated data, etc.)
+      // Show as raw output so the user can see CLI stderr activity.
+      if (trimmed.length > 0) {
+        if (!currentTimestamp) currentTimestamp = new Date();
+        if (!currentGroupId) currentGroupId = `stderr-${groups.length}-${lineIndex}`;
+        currentItems.push({
+          type: 'output',
+          content: trimmed,
+          timestamp: currentTimestamp,
+        });
+      }
+      continue;
+    }
+
+    const blocks = extractContentBlocks(parsed);
+    if (!blocks) {
+      // Valid JSON but not an assistant message — flush and skip
+      flushGroup();
+      continue;
+    }
+
+    // Extract agentId from top-level (subagent messages have it, lead messages don't)
+    const lineAgentId =
+      typeof (parsed as Record<string, unknown>).agentId === 'string'
+        ? ((parsed as Record<string, unknown>).agentId as string)
+        : undefined;
+
+    if (!currentTimestamp) {
+      // Use stable cached timestamp keyed by line content to survive re-parses
+      let ts = lineTimestampCache.get(trimmed);
+      if (!ts) {
+        ts = new Date();
+        if (lineTimestampCache.size >= MAX_TIMESTAMP_CACHE_SIZE) {
+          // Evict oldest entry (first inserted)
+          const firstKey = lineTimestampCache.keys().next().value!;
+          lineTimestampCache.delete(firstKey);
+        }
+        lineTimestampCache.set(trimmed, ts);
+      }
+      currentTimestamp = ts;
+    }
+    if (!currentGroupId) {
+      currentAgentId = lineAgentId;
+      const msgId = extractAssistantMessageId(parsed);
+      if (msgId) {
+        const occurrence = msgIdOccurrences.get(msgId) ?? 0;
+        msgIdOccurrences.set(msgId, occurrence + 1);
+        currentGroupId =
+          occurrence === 0 ? `stream-group-${msgId}` : `stream-group-${msgId}-${occurrence}`;
+      } else {
+        // Content-hash fallback: deterministic and survives line reordering
+        const h = stableHash(trimmed);
+        const occ = hashOccurrences.get(h) ?? 0;
+        hashOccurrences.set(h, occ + 1);
+        currentGroupId = occ === 0 ? `stream-group-H${h}` : `stream-group-H${h}-${occ}`;
+      }
+    }
+
+    const items = contentBlocksToDisplayItems(blocks, currentTimestamp, lineIndex);
+    currentItems.push(...items);
+  }
+
+  // Flush remaining items
+  flushGroup();
+
+  return groups;
+}
+
+/**
+ * Groups consecutive StreamJsonGroups by agentId into SubagentSections.
+ * Lead groups (no agentId) remain as individual entries.
+ * Must be called on chronological (oldest-first) groups.
+ */
+export function groupBySubagent(groups: StreamJsonGroup[]): StreamJsonEntry[] {
+  const result: StreamJsonEntry[] = [];
+  const pendingDescriptions: string[] = [];
+  const agentDescMap = new Map<string, string>();
+  let currentRun: { agentId: string; groups: StreamJsonGroup[] } | null = null;
+
+  const flushRun = (): void => {
+    if (!currentRun) return;
+    const desc = agentDescMap.get(currentRun.agentId) ?? 'Subagent';
+    let toolCount = 0;
+    for (const g of currentRun.groups) {
+      for (const item of g.items) {
+        if (item.type === 'tool') toolCount++;
+      }
+    }
+    // Anchor section ID on first group's stable ID instead of occurrence count
+    const firstGroupId = currentRun.groups[0]?.id ?? '';
+    const sectionId = `subagent-${currentRun.agentId}-${stableHash(firstGroupId)}`;
+    result.push({
+      type: 'subagent-section',
+      section: {
+        id: sectionId,
+        agentId: currentRun.agentId,
+        description: desc,
+        groups: currentRun.groups,
+        toolCount,
+        timestamp: currentRun.groups[0].timestamp,
+      },
+    });
+    currentRun = null;
+  };
+
+  for (const group of groups) {
+    if (!group.agentId) {
+      // Lead group — check for Agent/Task tool_use and extract description
+      for (const item of group.items) {
+        if (item.type === 'tool' && (item.tool.name === 'Agent' || item.tool.name === 'Task')) {
+          const input = item.tool.input as Record<string, unknown> | undefined;
+          const desc =
+            (item.tool.name === 'Agent' && input ? summarizeAgentToolInput(input, 80) : null) ||
+            (typeof input?.description === 'string' && input.description) ||
+            'Subagent';
+          pendingDescriptions.push(desc);
+        }
+      }
+      flushRun();
+      result.push({ type: 'group', group });
+    } else {
+      // Subagent group
+      if (!agentDescMap.has(group.agentId)) {
+        agentDescMap.set(group.agentId, pendingDescriptions.shift() ?? 'Subagent');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- optional chain narrows to `never` in loop body
+      if (currentRun && currentRun.agentId === group.agentId) {
+        currentRun.groups.push(group);
+      } else {
+        flushRun();
+        currentRun = { agentId: group.agentId, groups: [group] };
+      }
+    }
+  }
+
+  flushRun();
+  return result;
+}

package/src/renderer/utils/stringUtils.ts

@@ -0,0 +1,50 @@
+/**
+ * String utilities for display formatting.
+ */
+
+const isMacPlatform =
+  typeof window !== 'undefined' && window.navigator.userAgent.includes('Macintosh');
+
+/** Returns '⌘' on macOS, 'Ctrl' on Windows/Linux. */
+export const modKey = isMacPlatform ? '⌘' : 'Ctrl+';
+
+/** Returns '⇧' on macOS, 'Shift+' on Windows/Linux. */
+export const shiftKey = isMacPlatform ? '⇧' : 'Shift+';
+
+/**
+ * Formats a keyboard shortcut for the current platform.
+ * @example formatShortcut('R') → '⌘R' on Mac, 'Ctrl+R' on Windows/Linux
+ * @example formatShortcut('W', { shift: true }) → '⇧⌘W' on Mac, 'Ctrl+Shift+W' on Windows/Linux
+ */
+export function formatShortcut(key: string, opts?: { shift?: boolean }): string {
+  if (opts?.shift) {
+    return isMacPlatform ? `${shiftKey}${modKey}${key}` : `${modKey}${shiftKey}${key}`;
+  }
+  return `${modKey}${key}`;
+}
+
+/**
+ * Truncates a string in the middle to preserve both the beginning and end.
+ * Useful for branch names where the unique identifier is often at the end.
+ *
+ * @example
+ * truncateMiddle("feature/very-long-branch-name-with-ticket-12345", 25)
+ * // Returns: "feature/ver...ticket-12345"
+ *
+ * @param text - The string to truncate
+ * @param maxLen - Maximum length of the resulting string (default: 25)
+ * @returns The truncated string with "..." in the middle, or original if short enough
+ */
+export function truncateMiddle(text: string, maxLen: number = 25): string {
+  if (!text || text.length <= maxLen) return text;
+
+  // Account for the 3-character ellipsis
+  const availableChars = maxLen - 3;
+  const startLen = Math.ceil(availableChars / 2);
+  const endLen = Math.floor(availableChars / 2);
+
+  const start = text.slice(0, startLen);
+  const end = text.slice(-endLen);
+
+  return `${start}...${end}`;
+}