@yancyyu/openhermit 1.5.8

package/src/shared/utils/logger.ts

@@ -0,0 +1,69 @@
+/**
+ * Centralized logging utility for the application.
+ *
+ * Provides namespace-prefixed logging with environment-based filtering:
+ * - Development: All log levels (DEBUG, INFO, WARN, ERROR)
+ * - Production: Only ERROR logs are shown
+ *
+ * Usage:
+ * ```typescript
+ * import { createLogger } from '@shared/utils/logger';
+ * const logger = createLogger('IPC:config');
+ * logger.info('Config loaded');
+ * logger.error('Failed to load config', error);
+ * ```
+ */
+
+enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4,
+}
+
+class Logger {
+  private static level: LogLevel =
+    process.env.NODE_ENV === 'production' ? LogLevel.ERROR : LogLevel.WARN;
+
+  constructor(private namespace: string) {}
+
+  debug(...args: unknown[]): void {
+    if (Logger.level <= LogLevel.DEBUG) {
+      console.debug(`[${this.namespace}]`, ...args);
+    }
+  }
+
+  info(...args: unknown[]): void {
+    if (Logger.level <= LogLevel.INFO) {
+      console.log(`[${this.namespace}]`, ...args);
+    }
+  }
+
+  warn(...args: unknown[]): void {
+    if (Logger.level <= LogLevel.WARN) {
+      console.warn(`[${this.namespace}]`, ...args);
+    }
+  }
+
+  error(...args: unknown[]): void {
+    if (Logger.level <= LogLevel.ERROR) {
+      console.error(`[${this.namespace}]`, ...args);
+    }
+  }
+
+  /** Allow runtime level changes (for testing/debugging) */
+  static setLevel(level: LogLevel): void {
+    Logger.level = level;
+  }
+
+  static getLevel(): LogLevel {
+    return Logger.level;
+  }
+}
+
+export function createLogger(namespace: string): Logger {
+  return new Logger(namespace);
+}
+
+export type { Logger };

package/src/shared/utils/markdownTextSearch.ts

@@ -0,0 +1,210 @@
+/**
+ * Markdown-aware text search utility.
+ *
+ * Converts markdown through the **same pipeline** as react-markdown:
+ *   remark-parse → remarkGfm → mdast-util-to-hast → HAST tree
+ *
+ * Then collects text nodes only from HAST elements whose corresponding
+ * React components call `hl(children)` (highlightSearchInChildren).
+ * This ensures match counts align exactly with what the renderer produces.
+ *
+ * Key design: segments are collected per-text-node, NOT concatenated.
+ * `highlightSearchText` operates per-React-string-child, so a match
+ * spanning two elements is not valid in either layer.
+ */
+
+import { toHast } from 'mdast-util-to-hast';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+
+import type { Nodes as HastNodes } from 'hast';
+import type { Root as MdastRoot } from 'mdast';
+
+// ---------------------------------------------------------------------------
+// Parser singleton
+// ---------------------------------------------------------------------------
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- inferred type used by MarkdownParser alias
+function createParser() {
+  return unified().use(remarkParse).use(remarkGfm);
+}
+
+type MarkdownParser = ReturnType<typeof createParser>;
+
+let _parser: MarkdownParser | null = null;
+
+function getParser(): MarkdownParser {
+  if (!_parser) {
+    _parser = createParser();
+  }
+  return _parser;
+}
+
+function parseMarkdown(text: string): MdastRoot {
+  return getParser().parse(text);
+}
+
+// ---------------------------------------------------------------------------
+// Segment cache (parse once, search many times per query keystroke)
+// ---------------------------------------------------------------------------
+
+const MAX_CACHE_SIZE = 1000;
+const segmentCache = new Map<string, string[]>();
+
+function getCachedSegments(markdown: string): string[] {
+  const cached = segmentCache.get(markdown);
+  if (cached) return cached;
+
+  const segments = collectTextSegments(markdown);
+
+  // Evict oldest entries when cache is full
+  if (segmentCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = segmentCache.keys().next().value;
+    if (firstKey !== undefined) segmentCache.delete(firstKey);
+  }
+  segmentCache.set(markdown, segments);
+  return segments;
+}
+
+// ---------------------------------------------------------------------------
+// HAST → text segments
+// ---------------------------------------------------------------------------
+
+/**
+ * HTML element tag names whose React component counterparts call
+ * `hl(children)` (highlightSearchInChildren).
+ *
+ * Block-level elements call hl(): p, h1-h6, blockquote, li, th, td, code (block only)
+ * Inline elements do NOT call hl(): strong, em, a, del, code (inline)
+ * The block element's hl() recursively descends into inline children,
+ * processing text in document order — matching this walker's traversal.
+ *
+ * Inline tags are omitted from this set because they are always nested
+ * inside a block-level HL element in standard markdown, so their text
+ * is collected via the inherited `inHlElement` flag.
+ *
+ * Must stay in sync with createMarkdownComponents() in markdownComponents.tsx,
+ * createUserMarkdownComponents() in UserChatGroup.tsx, and
+ * createViewerMarkdownComponents() in MarkdownViewer.tsx.
+ */
+const HL_TAGS = new Set([
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'p',
+  'code',
+  'blockquote',
+  'li',
+  'th',
+  'td',
+]);
+
+/**
+ * Parse markdown → mdast → HAST, then collect text nodes from elements
+ * whose React components call `hl()`. This produces the exact same
+ * text segments that `highlightSearchInChildren` processes at render time.
+ */
+export function collectTextSegments(markdown: string): string[] {
+  const mdast = parseMarkdown(markdown);
+  const hast = toHast(mdast);
+  if (!hast) return [];
+
+  const segments: string[] = [];
+  walkHast(hast, segments, false);
+  return segments;
+}
+
+function walkHast(node: HastNodes, segments: string[], inHlElement: boolean): void {
+  // Raw HTML nodes (e.g. <context>...</context>) are dropped by ReactMarkdown
+  // without rehype-raw, so we must skip them to keep match counts aligned.
+  if (node.type === 'raw') return;
+
+  if (node.type === 'text') {
+    if (inHlElement && node.value) {
+      segments.push(node.value);
+    }
+    return;
+  }
+
+  if (node.type === 'element' || node.type === 'root') {
+    const isHl = node.type === 'element' && HL_TAGS.has(node.tagName);
+    for (const child of node.children) {
+      walkHast(child as HastNodes, segments, inHlElement || isHl);
+    }
+  }
+  // skip comments, doctypes
+}
+
+// ---------------------------------------------------------------------------
+// Search functions
+// ---------------------------------------------------------------------------
+
+export interface MarkdownSearchMatch {
+  matchIndexInItem: number;
+}
+
+/**
+ * Parse markdown into segments and search each segment individually.
+ * Returns per-item match indices that align with what the renderer produces.
+ */
+export function findMarkdownSearchMatches(markdown: string, query: string): MarkdownSearchMatch[] {
+  if (!query || !markdown) return [];
+
+  // Fast pre-filter: skip expensive markdown parsing if query doesn't appear in raw text
+  if (!markdown.toLowerCase().includes(query.toLowerCase())) return [];
+
+  const segments = getCachedSegments(markdown);
+  const lowerQuery = query.toLowerCase();
+  const matches: MarkdownSearchMatch[] = [];
+  let matchIndex = 0;
+
+  for (const segment of segments) {
+    const lowerSegment = segment.toLowerCase();
+    let pos = 0;
+    while ((pos = lowerSegment.indexOf(lowerQuery, pos)) !== -1) {
+      matches.push({ matchIndexInItem: matchIndex });
+      matchIndex++;
+      pos += lowerQuery.length;
+    }
+  }
+
+  return matches;
+}
+
+/**
+ * Count matches (cheaper than allocating match objects when only the count is needed).
+ */
+export function countMarkdownSearchMatches(markdown: string, query: string): number {
+  if (!query || !markdown) return 0;
+
+  // Fast pre-filter: skip expensive markdown parsing if query doesn't appear in raw text
+  if (!markdown.toLowerCase().includes(query.toLowerCase())) return 0;
+
+  const segments = getCachedSegments(markdown);
+  const lowerQuery = query.toLowerCase();
+  let count = 0;
+
+  for (const segment of segments) {
+    const lowerSegment = segment.toLowerCase();
+    let pos = 0;
+    while ((pos = lowerSegment.indexOf(lowerQuery, pos)) !== -1) {
+      count++;
+      pos += lowerQuery.length;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Join all visible text segments with spaces for use in context snippets.
+ */
+export function extractMarkdownPlainText(markdown: string): string {
+  if (!markdown) return '';
+  const segments = getCachedSegments(markdown);
+  return segments.join(' ');
+}

package/src/shared/utils/mcpScopes.ts

@@ -0,0 +1,36 @@
+import type { CliFlavor } from '@shared/types';
+import type { InstalledMcpEntry } from '@shared/types/extensions';
+
+export type McpInstalledScope = InstalledMcpEntry['scope'];
+export type McpSharedScope = Extract<McpInstalledScope, 'user' | 'global'>;
+
+export function getDefaultMcpSharedScope(flavor?: CliFlavor | null): McpSharedScope {
+  return flavor === 'agent_teams_orchestrator' ? 'global' : 'user';
+}
+
+export function isSharedMcpScope(scope?: string): scope is McpSharedScope {
+  return scope === 'user' || scope === 'global';
+}
+
+export function isProjectScopedMcpScope(scope?: string): scope is 'project' | 'local' {
+  return scope === 'project' || scope === 'local';
+}
+
+export function isInstalledMcpScope(scope: unknown): scope is McpInstalledScope {
+  return scope === 'user' || scope === 'global' || scope === 'project' || scope === 'local';
+}
+
+export function getMcpScopeLabel(scope: McpInstalledScope, flavor?: CliFlavor | null): string {
+  switch (scope) {
+    case 'global':
+      return '全局';
+    case 'user':
+      return flavor === 'agent_teams_orchestrator' ? '用户（旧版）' : '用户（全局）';
+    case 'project':
+      return '项目';
+    case 'local':
+      return '本地';
+    default:
+      return scope;
+  }
+}

package/src/shared/utils/modelParser.ts

@@ -0,0 +1,158 @@
+/**
+ * Claude model string parser utility.
+ * Parses model identifiers into friendly display names and metadata.
+ */
+
+/** Fallback context window size when a more exact model-specific window is unavailable. */
+export const DEFAULT_CONTEXT_WINDOW = 200_000;
+
+/** Known model families with specific styling */
+export type KnownModelFamily = 'sonnet' | 'opus' | 'haiku';
+
+/** Model family can be a known family or any arbitrary string for new/unknown models */
+export type ModelFamily = KnownModelFamily | (string & Record<never, never>);
+
+export interface ModelInfo {
+  /** Friendly name like "sonnet4.5" */
+  name: string;
+  /** Model family: sonnet, opus, haiku, or any other string for unknown families */
+  family: ModelFamily;
+  /** Major version like 4 or 3 */
+  majorVersion: number;
+  /** Minor version like 5 or 1 (null if not present) */
+  minorVersion: number | null;
+}
+
+const KNOWN_FAMILIES: KnownModelFamily[] = ['sonnet', 'opus', 'haiku'];
+
+/**
+ * Parses a Claude model string into friendly display info.
+ * Returns null if model string is invalid, synthetic, or empty.
+ *
+ * Supported formats:
+ * - New format: claude-{family}-{major}-{minor}-{date} (e.g., "claude-sonnet-4-5-20250929")
+ * - Old format: claude-{major}-{family}-{date} (e.g., "claude-3-opus-20240229")
+ * - Old format with minor: claude-{major}-{minor}-{family}-{date} (e.g., "claude-3-5-sonnet-20241022")
+ */
+export function parseModelString(model: string | undefined): ModelInfo | null {
+  // Handle null, undefined, empty, or synthetic models
+  if (!model || model.trim() === '' || model === '<synthetic>') {
+    return null;
+  }
+
+  const normalized = model.toLowerCase().trim();
+
+  // Must start with "claude"
+  if (!normalized.startsWith('claude')) {
+    return null;
+  }
+
+  // Split into parts (e.g., ["claude", "sonnet", "4", "5", "20250929"])
+  const parts = normalized.split('-');
+
+  if (parts.length < 3) {
+    return null;
+  }
+
+  // Detect model family - first check known families, then accept any non-numeric string
+  let family: ModelFamily | null = null;
+  let familyIndex = -1;
+
+  // First pass: look for known families
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (KNOWN_FAMILIES.includes(part as KnownModelFamily)) {
+      family = part as KnownModelFamily;
+      familyIndex = i;
+      break;
+    }
+  }
+
+  // Second pass: if no known family found, look for any non-numeric, non-date string as family
+  if (family === null) {
+    for (let i = 1; i < parts.length; i++) {
+      const part = parts[i];
+      // Skip numeric parts and date-like parts (8 digits)
+      if (!/^\d+$/.test(part) && !/^\d{8}$/.test(part) && part.length > 1) {
+        family = part;
+        familyIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (family === null || familyIndex === -1) {
+    return null;
+  }
+
+  let majorVersion: number;
+  let minorVersion: number | null = null;
+
+  // Determine format based on family position
+  if (familyIndex === 1) {
+    // New format: claude-{family}-{major}-{minor}-{date}
+    // e.g., claude-sonnet-4-5-20250929 -> ["claude", "sonnet", "4", "5", "20250929"]
+    if (parts.length < 4) {
+      return null;
+    }
+
+    majorVersion = parseInt(parts[2], 10);
+    if (isNaN(majorVersion)) {
+      return null;
+    }
+
+    // Check if there's a minor version (next part is a number and not a date)
+    if (parts.length >= 4 && parts[3].length <= 2) {
+      const potentialMinor = parseInt(parts[3], 10);
+      if (!isNaN(potentialMinor)) {
+        minorVersion = potentialMinor;
+      }
+    }
+  } else {
+    // Old format: claude-{major}[-{minor}]-{family}-{date}
+    // e.g., claude-3-opus-20240229 -> ["claude", "3", "opus", "20240229"]
+    // e.g., claude-3-5-sonnet-20241022 -> ["claude", "3", "5", "sonnet", "20241022"]
+
+    majorVersion = parseInt(parts[1], 10);
+    if (isNaN(majorVersion)) {
+      return null;
+    }
+
+    // Check if there's a minor version between major and family
+    if (familyIndex > 2) {
+      const potentialMinor = parseInt(parts[2], 10);
+      if (!isNaN(potentialMinor)) {
+        minorVersion = potentialMinor;
+      }
+    }
+  }
+
+  // Build friendly name
+  const versionString =
+    minorVersion !== null ? `${majorVersion}.${minorVersion}` : `${majorVersion}`;
+  const name = `${family}${versionString}`;
+
+  return {
+    name,
+    family,
+    majorVersion,
+    minorVersion,
+  };
+}
+
+/**
+ * Gets the color class for a model family (for Tailwind).
+ * Uses consistent neutral gray styling for a clean, Linear-like design.
+ * All models use the same muted color for visual consistency.
+ */
+export function getModelColorClass(family: ModelFamily): string {
+  // All families use consistent neutral gray for clean design
+  switch (family) {
+    case 'opus':
+    case 'sonnet':
+    case 'haiku':
+      return 'text-zinc-400';
+    default:
+      return 'text-zinc-500';
+  }
+}

package/src/shared/utils/opencodeModelRef.ts

@@ -0,0 +1,78 @@
+export interface OpenCodeQualifiedModelRef {
+  sourceId: string;
+  modelId: string;
+  raw: string;
+}
+
+const OPEN_CODE_MODEL_REF_PATTERN = /^(?<source>[a-z0-9-]+)\/(?<model>\S.*)$/i;
+
+const OPEN_CODE_SOURCE_LABELS: Record<string, string> = {
+  anthropic: 'Anthropic',
+  azure: 'Azure',
+  bedrock: 'Bedrock',
+  deepseek: 'DeepSeek',
+  gemini: 'Gemini',
+  google: 'Google',
+  groq: 'Groq',
+  minimax: 'MiniMax',
+  mistral: 'Mistral',
+  moonshot: 'Moonshot',
+  ollama: 'Ollama',
+  opencode: 'OpenCode',
+  openai: 'OpenAI',
+  'openai-compatible': 'OpenAI Compatible',
+  openrouter: 'OpenRouter',
+  together: 'Together',
+  vertex: 'Vertex',
+  xai: 'xAI',
+  'z-ai': 'Z.AI',
+};
+
+function humanizeOpenCodeSourceId(sourceId: string): string {
+  const normalized = sourceId.trim().toLowerCase();
+  if (!normalized) {
+    return sourceId;
+  }
+
+  const knownLabel = OPEN_CODE_SOURCE_LABELS[normalized];
+  if (knownLabel) {
+    return knownLabel;
+  }
+
+  return normalized
+    .split('-')
+    .filter(Boolean)
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join(' ');
+}
+
+export function parseOpenCodeQualifiedModelRef(
+  model: string | undefined | null
+): OpenCodeQualifiedModelRef | null {
+  const trimmed = model?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const match = OPEN_CODE_MODEL_REF_PATTERN.exec(trimmed);
+  if (!match?.groups?.source || !match.groups.model) {
+    return null;
+  }
+
+  return {
+    raw: trimmed,
+    sourceId: match.groups.source.toLowerCase(),
+    modelId: match.groups.model,
+  };
+}
+
+export function getOpenCodeQualifiedModelSourceLabel(
+  model: string | undefined | null
+): string | null {
+  const parsed = parseOpenCodeQualifiedModelRef(model);
+  if (!parsed) {
+    return null;
+  }
+
+  return humanizeOpenCodeSourceId(parsed.sourceId);
+}

package/src/shared/utils/platformPath.ts

@@ -0,0 +1,103 @@
+/**
+ * Cross-platform path utilities for the renderer process.
+ *
+ * Node's `path` module is unavailable in the renderer, and incoming paths
+ * may originate from any OS (Unix `/` or Windows `\`).  Every helper here
+ * handles both separators transparently.
+ */
+
+const SEP_RE = /[/\\]/;
+
+/** Split a file path on both `/` and `\` separators. */
+export function splitPath(filePath: string): string[] {
+  return filePath.split(SEP_RE).filter(Boolean);
+}
+
+/**
+ * Returns true if the string looks like a Windows path (drive letter or UNC).
+ * Used only to decide case-sensitivity for comparisons.
+ */
+export function isWindowsishPath(filePath: string): boolean {
+  const p = filePath.replace(/\\/g, '/');
+  return /^[A-Za-z]:\//.test(p) || p.startsWith('//');
+}
+
+/**
+ * Normalize for comparisons:
+ * - Convert `\` → `/`
+ * - Lowercase only for Windows-ish paths (Windows is case-insensitive)
+ *
+ * Do NOT use this for filesystem operations; it's for comparisons only.
+ */
+export function normalizePathForComparison(filePath: string): string {
+  const p = filePath.replace(/\\/g, '/');
+  return isWindowsishPath(p) ? p.toLowerCase() : p;
+}
+
+/** Strip trailing path separators (except for root paths like "/" or "C:/"). */
+export function stripTrailingSeparators(filePath: string): string {
+  if (!filePath) return filePath;
+  const p = filePath.replace(/\\/g, '/');
+  if (p === '/' || /^[A-Za-z]:\/$/.test(p)) return filePath;
+  // Trim trailing separators manually to avoid sonarjs/slow-regex
+  let end = filePath.length;
+  while (end > 0 && (filePath[end - 1] === '/' || filePath[end - 1] === '\\')) end--;
+  return end === filePath.length ? filePath : filePath.slice(0, end);
+}
+
+/** Prefer the separator style already present in the path. */
+export function getPreferredSeparator(filePath: string): '/' | '\\' {
+  const hasBackslash = filePath.includes('\\');
+  const hasSlash = filePath.includes('/');
+  if (hasBackslash && !hasSlash) return '\\';
+  return '/';
+}
+
+/** Join base + segments using the base path's preferred separator. */
+export function joinPath(base: string, ...segments: string[]): string {
+  const sep = getPreferredSeparator(base);
+  let out = stripTrailingSeparators(base);
+  for (const seg of segments) {
+    // Trim leading and trailing separators manually to avoid sonarjs/slow-regex
+    let start = 0;
+    while (start < seg.length && (seg[start] === '/' || seg[start] === '\\')) start++;
+    let segEnd = seg.length;
+    while (segEnd > start && (seg[segEnd - 1] === '/' || seg[segEnd - 1] === '\\')) segEnd--;
+    const cleaned = seg.slice(start, segEnd);
+    if (!cleaned) continue;
+    if (!out || out.endsWith('/') || out.endsWith('\\')) {
+      out += cleaned;
+    } else {
+      out += sep + cleaned;
+    }
+  }
+  return out;
+}
+
+/** True if fullPath is equal to prefix or is nested under prefix. */
+export function isPathPrefix(prefix: string, fullPath: string): boolean {
+  const p = stripTrailingSeparators(normalizePathForComparison(prefix));
+  const f = stripTrailingSeparators(normalizePathForComparison(fullPath));
+  if (f === p) return true;
+  // Root prefixes are special: p already ends with "/" ("/" or "c:/").
+  if (p === '/') return f.startsWith('/');
+  if (/^[a-z]:\/$/.test(p)) return f.startsWith(p);
+  return f.startsWith(p + '/');
+}
+
+/** Get the last segment (filename) from a path. */
+export function getBasename(filePath: string): string {
+  const parts = splitPath(filePath);
+  return parts[parts.length - 1] ?? '';
+}
+
+/** Get directory part of a path (everything before the last separator). */
+export function getDirname(filePath: string): string {
+  const lastSep = lastSeparatorIndex(filePath);
+  return lastSep === -1 ? '' : filePath.substring(0, lastSep);
+}
+
+/** Find the last path separator index (handles both `/` and `\`). */
+export function lastSeparatorIndex(filePath: string): number {
+  return Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
+}