@yancyyu/openhermit 1.5.8

package/src/renderer/utils/editorBridge.ts

@@ -0,0 +1,90 @@
+/**
+ * Module-level singleton bridging Zustand store ↔ CodeMirror refs.
+ *
+ * CodeMirrorEditor calls register() on mount, unregister() on unmount.
+ * Store actions (saveFile, saveAllFiles, closeEditor) use getContent()/destroy().
+ *
+ * Pattern: analogous to ConfirmDialog.tsx (module-level globalSetState).
+ */
+
+import type { EditorState } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+
+let stateCache: Map<string, EditorState> | null = null;
+let scrollTopCache: Map<string, number> | null = null;
+let activeView: EditorView | null = null;
+
+export const editorBridge = {
+  /** Called by CodeMirrorEditor on mount */
+  register(sc: Map<string, EditorState>, stc: Map<string, number>, view: EditorView): void {
+    stateCache = sc;
+    scrollTopCache = stc;
+    activeView = view;
+  },
+
+  /** Called by CodeMirrorEditor on unmount */
+  unregister(): void {
+    stateCache = null;
+    scrollTopCache = null;
+    activeView = null;
+  },
+
+  /** Check if bridge is registered (HMR guard) */
+  get isRegistered(): boolean {
+    return stateCache !== null;
+  },
+
+  /** Get content for a single file from cached EditorState */
+  getContent(filePath: string): string | null {
+    return stateCache?.get(filePath)?.doc.toString() ?? null;
+  },
+
+  /** Get content for all modified files */
+  getAllModifiedContent(modifiedFiles: Record<string, boolean>): Map<string, string> {
+    const result = new Map<string, string>();
+    for (const fp of Object.keys(modifiedFiles)) {
+      if (!modifiedFiles[fp]) continue;
+      const content = stateCache?.get(fp)?.doc.toString();
+      if (content !== undefined) result.set(fp, content);
+    }
+    return result;
+  },
+
+  /** Remove cached state for a single tab — called by closeTab() */
+  deleteState(tabId: string): void {
+    stateCache?.delete(tabId);
+    scrollTopCache?.delete(tabId);
+  },
+
+  /** Full cleanup — called by closeEditor() */
+  destroy(): void {
+    activeView?.destroy();
+    stateCache?.clear();
+    scrollTopCache?.clear();
+    activeView = null;
+  },
+
+  /** Remap cached state from oldPath to newPath (used by moveFileInTree) */
+  remapState(oldPath: string, newPath: string): void {
+    const state = stateCache?.get(oldPath);
+    if (state) {
+      stateCache!.delete(oldPath);
+      stateCache!.set(newPath, state);
+    }
+    const scroll = scrollTopCache?.get(oldPath);
+    if (scroll !== undefined) {
+      scrollTopCache!.delete(oldPath);
+      scrollTopCache!.set(newPath, scroll);
+    }
+  },
+
+  /** Update view reference (on tab switch, view may be recreated) */
+  updateView(view: EditorView): void {
+    activeView = view;
+  },
+
+  /** Get current EditorView (for undo/redo toolbar) */
+  getView(): EditorView | null {
+    return activeView;
+  },
+};

package/src/renderer/utils/fileTreeBuilder.ts

@@ -0,0 +1,110 @@
+/**
+ * Generic tree builder — converts a flat list of items with paths
+ * into a hierarchical tree structure with single-child directory collapsing.
+ *
+ * Used by ReviewFileTree (FileChangeSummary) and EditorFileTree (FileTreeEntry).
+ */
+
+import { splitPath as splitPathCrossPlatform } from '@shared/utils/platformPath';
+
+export interface TreeNode<T> {
+  name: string;
+  fullPath: string;
+  isFile: boolean;
+  data?: T;
+  children: TreeNode<T>[];
+}
+
+/**
+ * Build a hierarchical tree from a flat list of items.
+ *
+ * @param items - Flat list of items (files/entries)
+ * @param getPath - Extract relative path from item (using '/' separator)
+ * @param options.collapse - Merge single-child intermediate directories (default: true)
+ */
+export function buildTree<T>(
+  items: T[],
+  getPath: (item: T) => string,
+  options?: { collapse?: boolean }
+): TreeNode<T>[] {
+  const root: TreeNode<T> = { name: '', fullPath: '', isFile: false, children: [] };
+
+  for (const item of items) {
+    const parts = splitPathCrossPlatform(getPath(item));
+    let current = root;
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isLast = i === parts.length - 1;
+      const fullPath = parts.slice(0, i + 1).join('/');
+
+      let child = current.children.find((c) => c.name === part);
+      if (!child) {
+        child = {
+          name: part,
+          fullPath,
+          isFile: isLast,
+          data: isLast ? item : undefined,
+          children: [],
+        };
+        current.children.push(child);
+      }
+      current = child;
+    }
+  }
+
+  if (options?.collapse === false) {
+    return root.children;
+  }
+
+  // Collapse children individually — root itself has empty name and must not participate
+  return root.children.map(collapseTree);
+}
+
+/** Merge single-child intermediate directories: a/ → b/ → c becomes a/b/c */
+function collapseTree<T>(node: TreeNode<T>): TreeNode<T> {
+  const collapsed: TreeNode<T> = { ...node, children: node.children.map(collapseTree) };
+  if (!collapsed.isFile && collapsed.children.length === 1 && !collapsed.children[0].isFile) {
+    const child = collapsed.children[0];
+    return {
+      ...child,
+      name: `${collapsed.name}/${child.name}`,
+      children: child.children,
+    };
+  }
+  return collapsed;
+}
+
+/** Sort tree nodes: directories first, then alphabetical */
+export function sortTreeNodes<T>(nodes: TreeNode<T>[]): TreeNode<T>[] {
+  return [...nodes].sort((a, b) => {
+    if (a.isFile !== b.isFile) return a.isFile ? 1 : -1;
+    return a.name.localeCompare(b.name);
+  });
+}
+
+/**
+ * Flatten a sorted tree into a list of leaf items in display order.
+ * Mirrors the visual order of ReviewFileTree (directories first, then alphabetical at each level).
+ */
+function collectLeaves<T>(nodes: TreeNode<T>[], out: T[]): void {
+  for (const node of sortTreeNodes(nodes)) {
+    if (node.isFile && node.data != null) {
+      out.push(node.data);
+    } else {
+      collectLeaves(node.children, out);
+    }
+  }
+}
+
+/**
+ * Sort a flat list of items to match the visual order of the file tree
+ * (directories first, then alphabetical at each level).
+ */
+export function sortItemsAsTree<T>(items: T[], getPath: (item: T) => string): T[] {
+  if (items.length <= 1) return items;
+  const tree = buildTree(items, getPath);
+  const result: T[] = [];
+  collectLeaves(tree, result);
+  return result;
+}

package/src/renderer/utils/formatAgentRole.ts

@@ -0,0 +1,24 @@
+import { getRoleLabel } from '@renderer/constants/teamRoles';
+
+/**
+ * Formats an agent type string into a human-readable role label.
+ *
+ * Returns `null` for the default "general-purpose" type so callers can
+ * conditionally hide the role entirely.
+ */
+export function formatAgentRole(agentType: string | undefined): string | null {
+  if (!agentType || agentType === 'general-purpose') {
+    return null;
+  }
+
+  const presetLabel = getRoleLabel(agentType);
+  if (presetLabel) {
+    return presetLabel;
+  }
+
+  // Capitalise first letter of every word, replace hyphens with spaces.
+  return agentType
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}

package/src/renderer/utils/formatters.ts

@@ -0,0 +1,61 @@
+/**
+ * Formatting utility functions for display values.
+ */
+
+// Re-export token formatting from shared module
+export { formatTokensCompact } from '@shared/utils/tokenFormatting';
+
+/**
+ * Formats a byte count to a human-readable string (e.g. "1.2 MB").
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Formats an ISO timestamp into a relative time string (e.g. "just now", "5m ago", "2h ago").
+ */
+export function formatRelativeTime(isoString: string): string {
+  const date = new Date(isoString);
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  const diffMin = Math.floor(diffMs / 60_000);
+  const diffHours = Math.floor(diffMin / 60);
+
+  if (diffMin < 1) return 'just now';
+  if (diffMin < 60) return `${diffMin}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  return date.toLocaleDateString();
+}
+
+/**
+ * Formats duration in milliseconds to a human-readable string.
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${Math.round(ms)}ms`;
+  }
+  const seconds = ms / 1000;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+/**
+ * Formats a number in compact notation for UI display.
+ * 42 → "42", 1200 → "1.2k", 45300 → "45.3k", 120000 → "120k", 1500000 → "1.5M"
+ */
+export function formatCompactNumber(n: number): string {
+  if (n < 1_000) return String(n);
+  if (n < 1_000_000) {
+    const k = n / 1_000;
+    return k < 10 ? `${k.toFixed(1)}k` : `${Math.round(k)}k`;
+  }
+  const m = n / 1_000_000;
+  return m < 10 ? `${m.toFixed(1)}M` : `${Math.round(m)}M`;
+}