@yancyyu/openhermit 1.5.8

package/src/shared/utils/teamMemberColors.ts

@@ -0,0 +1,107 @@
+import {
+  getMemberColorByName,
+  MEMBER_COLOR_PALETTE,
+  normalizeMemberColorName,
+  TEAM_LEAD_MEMBER_COLOR_ID,
+} from '@shared/constants/memberColors';
+import { isLeadMember } from '@shared/utils/leadDetection';
+
+export interface TeamMemberColorInput {
+  name: string;
+  color?: string;
+  removedAt?: number | string | null;
+  agentType?: string;
+}
+
+interface BuildTeamMemberColorMapOptions {
+  preferProvidedColors?: boolean;
+}
+
+/**
+ * Build a deterministic roster color map that optimizes contrast inside a team.
+ * Leads reserve their own color but do not consume the teammate palette order.
+ */
+export function buildTeamMemberColorMap(
+  members: readonly TeamMemberColorInput[],
+  options: BuildTeamMemberColorMapOptions = {}
+): Map<string, string> {
+  const preferProvidedColors = options.preferProvidedColors ?? true;
+  const map = new Map<string, string>();
+  const active = members.filter((member) => !member.removedAt);
+  const removed = members.filter((member) => member.removedAt);
+  const activeLeads = active.filter((member) => isLeadMember(member));
+  const activeTeammates = active.filter((member) => !isLeadMember(member));
+  const usedColors = new Set<string>();
+  let nextPaletteIdx = 0;
+
+  for (const member of activeLeads) {
+    const color =
+      preferProvidedColors && member.color
+        ? normalizeMemberColorName(member.color)
+        : getMemberColorByName(member.name);
+    map.set(member.name, color);
+    usedColors.add(color);
+  }
+
+  for (const member of activeTeammates) {
+    let color =
+      preferProvidedColors && member.color ? normalizeMemberColorName(member.color) : undefined;
+    if (!color || usedColors.has(color)) {
+      while (
+        nextPaletteIdx < MEMBER_COLOR_PALETTE.length &&
+        usedColors.has(MEMBER_COLOR_PALETTE[nextPaletteIdx])
+      ) {
+        nextPaletteIdx += 1;
+      }
+      color =
+        nextPaletteIdx < MEMBER_COLOR_PALETTE.length
+          ? MEMBER_COLOR_PALETTE[nextPaletteIdx]
+          : MEMBER_COLOR_PALETTE[activeTeammates.indexOf(member) % MEMBER_COLOR_PALETTE.length];
+      nextPaletteIdx += 1;
+    }
+    map.set(member.name, color);
+    usedColors.add(color);
+  }
+
+  for (const member of removed) {
+    const color =
+      preferProvidedColors && member.color
+        ? normalizeMemberColorName(member.color)
+        : getMemberColorByName(member.name);
+    map.set(member.name, color);
+  }
+
+  map.set('user', 'user');
+
+  return map;
+}
+
+/**
+ * Resolve the visual color for a standalone member preview by reusing the same
+ * roster color pipeline that powers the team screen.
+ */
+export function resolveTeamMemberColorName(
+  member: TeamMemberColorInput,
+  options: BuildTeamMemberColorMapOptions = {}
+): string {
+  const color = buildTeamMemberColorMap([member], options).get(member.name);
+  if (color) {
+    return color;
+  }
+
+  if (options.preferProvidedColors !== false && member.color) {
+    return normalizeMemberColorName(member.color);
+  }
+
+  return getMemberColorByName(member.name);
+}
+
+export function resolveTeamLeadColorName(): string {
+  return resolveTeamMemberColorName(
+    {
+      name: TEAM_LEAD_MEMBER_COLOR_ID,
+      agentType: TEAM_LEAD_MEMBER_COLOR_ID,
+    },
+    { preferProvidedColors: false }
+  );
+}

package/src/shared/utils/teamMemberName.ts

@@ -0,0 +1,77 @@
+export function parseNumericSuffixName(name: string): { base: string; suffix: number } | null {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  const match = /^(.+)-(\d+)$/.exec(trimmed);
+  if (!match?.[1] || !match[2]) return null;
+  const suffix = Number(match[2]);
+  if (!Number.isFinite(suffix)) return null;
+  return { base: match[1], suffix };
+}
+
+export function validateTeamMemberNameFormat(name: string): string | null {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  if (trimmed.length < 1 || trimmed.length > 128) {
+    return '名称需以字母/数字开头，可使用中文、字母、数字、._-，最长 128 字符';
+  }
+  if (!/^[\p{L}\p{N}]/u.test(trimmed)) {
+    return '名称需以字母/数字开头，可使用中文、字母、数字、._-，最长 128 字符';
+  }
+  if (!/^[\p{L}\p{N}._-]+$/u.test(trimmed)) {
+    return '名称需以字母/数字开头，可使用中文、字母、数字、._-，最长 128 字符';
+  }
+  return null;
+}
+
+/**
+ * Claude CLI auto-suffixes teammate names when a name already exists in config.json
+ * (e.g. "alice" → "alice-2"). We treat "-2+" as an auto-suffix only when the base
+ * name also exists among the current set of names.
+ *
+ * Important: do NOT treat "-1" as auto-suffix; it's commonly intentional ("dev-1").
+ */
+export function createCliAutoSuffixNameGuard(
+  allNames: Iterable<string>
+): (name: string) => boolean {
+  const trimmed: string[] = [];
+  const seen = new Set<string>();
+  for (const n of allNames) {
+    if (typeof n !== 'string') continue;
+    const t = n.trim();
+    if (!t) continue;
+    if (seen.has(t)) continue;
+    seen.add(t);
+    trimmed.push(t);
+  }
+
+  const allLower = new Set(trimmed.map((n) => n.toLowerCase()));
+
+  return (name: string): boolean => {
+    const info = parseNumericSuffixName(name);
+    if (!info) return true;
+    if (info.suffix < 2) return true;
+    return !allLower.has(info.base.toLowerCase());
+  };
+}
+
+const PROVISIONER_SUFFIX = '-provisioner';
+
+/**
+ * Claude CLI creates temporary "{name}-provisioner" agents during team provisioning
+ * to spawn real teammates. These are always internal artifacts — never real teammates.
+ *
+ * Unlike numeric suffixes (alice-2) which can be intentional, "-provisioner" is a
+ * hardcoded CLI pattern that should never be exposed to the user. We unconditionally
+ * hide any name ending with "-provisioner" regardless of whether the base name exists.
+ */
+export function createCliProvisionerNameGuard(
+  _allNames: Iterable<string>
+): (name: string) => boolean {
+  return (name: string): boolean => {
+    const lower = name.trim().toLowerCase();
+    if (!lower.endsWith(PROVISIONER_SUFFIX)) return true;
+    const base = lower.slice(0, -PROVISIONER_SUFFIX.length);
+    // Keep bare "-provisioner" (no base) — that's not a CLI artifact pattern
+    return !base;
+  };
+}

package/src/shared/utils/teamProvider.ts

@@ -0,0 +1,73 @@
+import { parseOpenCodeQualifiedModelRef } from './opencodeModelRef';
+
+import type { TeamProviderId } from '@shared/types';
+
+export function isTeamProviderId(value: unknown): value is TeamProviderId {
+  return value === 'anthropic' || value === 'codex' || value === 'gemini' || value === 'opencode';
+}
+
+export function normalizeOptionalTeamProviderId(value: unknown): TeamProviderId | undefined {
+  return isTeamProviderId(value) ? value : undefined;
+}
+
+export function normalizeTeamProviderId(
+  value: unknown,
+  fallback: TeamProviderId = 'anthropic'
+): TeamProviderId {
+  return normalizeOptionalTeamProviderId(value) ?? fallback;
+}
+
+export function inferTeamProviderIdFromModel(
+  model: string | undefined
+): TeamProviderId | undefined {
+  const normalized = model?.trim().toLowerCase();
+  if (!normalized) {
+    return undefined;
+  }
+  const normalizedWithoutExtendedContextSuffix = normalized.replace(/(?:\[1m\])+$/, '');
+
+  if (
+    normalized.startsWith('opencode/') ||
+    normalizedWithoutExtendedContextSuffix.startsWith('opencode/')
+  ) {
+    return 'opencode';
+  }
+
+  if (
+    normalized.startsWith('gpt-') ||
+    normalized.startsWith('codex') ||
+    normalizedWithoutExtendedContextSuffix.startsWith('gpt-') ||
+    normalizedWithoutExtendedContextSuffix.startsWith('codex')
+  ) {
+    return 'codex';
+  }
+
+  if (
+    normalized.startsWith('gemini') ||
+    normalizedWithoutExtendedContextSuffix.startsWith('gemini')
+  ) {
+    return 'gemini';
+  }
+
+  if (
+    normalized.startsWith('claude') ||
+    normalizedWithoutExtendedContextSuffix.startsWith('claude') ||
+    normalized === 'opus' ||
+    normalizedWithoutExtendedContextSuffix === 'opus' ||
+    normalized === 'sonnet' ||
+    normalizedWithoutExtendedContextSuffix === 'sonnet' ||
+    normalized === 'haiku' ||
+    normalizedWithoutExtendedContextSuffix === 'haiku'
+  ) {
+    return 'anthropic';
+  }
+
+  if (
+    parseOpenCodeQualifiedModelRef(normalized) ||
+    parseOpenCodeQualifiedModelRef(normalizedWithoutExtendedContextSuffix)
+  ) {
+    return 'opencode';
+  }
+
+  return undefined;
+}

package/src/shared/utils/teamStableOwnerId.ts

@@ -0,0 +1,12 @@
+export interface StableTeamOwnerLike {
+  name: string;
+  agentId?: string | null;
+}
+
+export function getStableTeamOwnerId(member: StableTeamOwnerLike): string {
+  const agentId = member.agentId?.trim();
+  if (agentId) {
+    return agentId;
+  }
+  return member.name.trim();
+}

package/src/shared/utils/teammateMessageParser.ts

@@ -0,0 +1,52 @@
+/**
+ * Teammate Message Parser
+ *
+ * Parses <teammate-message> XML content into structured data.
+ * Handles single or multiple blocks in one message.
+ * Pure function for cross-process use (renderer needs it in displayItemBuilder).
+ */
+
+export interface ParsedTeammateContent {
+  teammateId: string;
+  color: string;
+  summary: string;
+  content: string;
+}
+
+/**
+ * Regex to match a single <teammate-message> block (non-greedy content).
+ * Captures: [1] teammate_id, [2] remaining attributes string, [3] inner content
+ */
+const TEAMMATE_BLOCK_RE =
+  /<teammate-message\s+teammate_id="([^"]+)"([^>]*)>([\s\S]*?)<\/teammate-message>/g;
+
+const COLOR_RE = /color="([^"]*)"/;
+const SUMMARY_RE = /summary="([^"]*)"/;
+
+/**
+ * Parse all <teammate-message> blocks from raw content.
+ * Returns an array of parsed blocks (may be 0, 1, or many).
+ */
+export function parseAllTeammateMessages(rawContent: string): ParsedTeammateContent[] {
+  const results: ParsedTeammateContent[] = [];
+  const regex = new RegExp(TEAMMATE_BLOCK_RE.source, TEAMMATE_BLOCK_RE.flags);
+
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(rawContent)) !== null) {
+    const teammateId = match[1];
+    const attrs = match[2];
+    const content = match[3].trim();
+
+    const colorMatch = COLOR_RE.exec(attrs);
+    const summaryMatch = SUMMARY_RE.exec(attrs);
+
+    results.push({
+      teammateId,
+      color: colorMatch?.[1] ?? '',
+      summary: summaryMatch?.[1] ?? '',
+      content,
+    });
+  }
+
+  return results;
+}

package/src/shared/utils/tokenFormatting.ts

@@ -0,0 +1,91 @@
+/**
+ * Shared token formatting utilities.
+ *
+ * This module consolidates all token-related formatting functions across the codebase.
+ * Use these functions instead of implementing token formatting inline.
+ */
+
+/**
+ * Formats token count for compact display.
+ * Shows full number under 1k, uses 'k' suffix for thousands, 'M' suffix for millions.
+ *
+ * Examples:
+ * - 500 -> "500"
+ * - 1500 -> "1.5k"
+ * - 50000 -> "50.0k"
+ * - 1500000 -> "1.5M"
+ */
+export function formatTokensCompact(tokens: number): string {
+  if (tokens >= 1000000) {
+    return `${(tokens / 1000000).toFixed(1)}M`;
+  }
+  if (tokens >= 1000) {
+    return `${(tokens / 1000).toFixed(1)}k`;
+  }
+  return tokens.toString();
+}
+
+/**
+ * Formats token count with smart precision.
+ * Uses one decimal for 1k-10k range, whole numbers above 10k.
+ *
+ * Examples:
+ * - 500 -> "500"
+ * - 1500 -> "1.5k"
+ * - 15000 -> "15k"
+ */
+export function formatTokens(tokens: number): string {
+  if (tokens < 1000) {
+    return `${tokens}`;
+  }
+  if (tokens < 10000) {
+    return `${(tokens / 1000).toFixed(1)}k`;
+  }
+  return `${Math.round(tokens / 1000)}k`;
+}
+
+/**
+ * Formats token count with locale-aware separators.
+ * Used for detailed views where exact numbers matter.
+ *
+ * Examples:
+ * - 1500 -> "1,500" (in en-US locale)
+ * - 1000000 -> "1,000,000"
+ */
+export function formatTokensDetailed(tokens: number): string {
+  return tokens.toLocaleString();
+}
+
+/**
+ * Estimates token count from text content.
+ * Uses the rough heuristic of ~4 characters per token, which is a
+ * reasonable average for English text and code.
+ *
+ * This is faster than using a real tokenizer and accurate enough
+ * for display purposes.
+ */
+export function estimateTokens(text: string | undefined | null): number {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Estimates tokens for content that may be a string, array, or object.
+ * Arrays and objects are stringified before counting.
+ */
+export function estimateContentTokens(
+  content: string | unknown[] | Record<string, unknown> | undefined | null
+): number {
+  if (!content) {
+    return 0;
+  }
+
+  if (typeof content === 'string') {
+    return estimateTokens(content);
+  }
+
+  // For array/object content, stringify and count
+  return estimateTokens(JSON.stringify(content));
+}

package/src/shared/utils/toolSummary.ts

@@ -0,0 +1,279 @@
+import type { ToolCallMeta } from '@shared/types';
+
+export interface ToolSummaryData {
+  total: number;
+  byName: Record<string, number>;
+}
+
+export type AgentToolDuplicateSkipReason = 'already_running' | 'bootstrap_pending';
+
+export interface ParsedAgentToolResultStatus {
+  status: 'duplicate_skipped';
+  reason?: AgentToolDuplicateSkipReason;
+  rawReason?: string;
+  name?: string;
+  teamName?: string;
+}
+
+export function buildToolSummary(content: Record<string, unknown>[]): string | undefined {
+  const counts = new Map<string, number>();
+  for (const block of content) {
+    if (
+      block &&
+      typeof block === 'object' &&
+      block.type === 'tool_use' &&
+      typeof block.name === 'string'
+    ) {
+      counts.set(block.name, (counts.get(block.name) ?? 0) + 1);
+    }
+  }
+  const total = Array.from(counts.values()).reduce((a, b) => a + b, 0);
+  if (total === 0) return undefined;
+  return `${total} ${total === 1 ? 'tool' : 'tools'}`;
+}
+
+export function parseToolSummary(summary: string | undefined): ToolSummaryData | null {
+  if (!summary) return null;
+  // Support new format: "3 tools"
+  const simpleMatch = /^(\d+)\s+tools?$/.exec(summary);
+  if (simpleMatch) {
+    return { total: parseInt(simpleMatch[1], 10), byName: {} };
+  }
+  // Support legacy format: "3 tools (Read, 2 Edit)"
+  const match = /^(\d+)\s+tools?\s+\(([^)]+)\)$/.exec(summary);
+  if (!match) return null;
+  const byName: Record<string, number> = {};
+  for (const part of match[2].split(', ')) {
+    const m =
+      // eslint-disable-next-line security/detect-unsafe-regex -- part from split, bounded by summary
+      /^(\d+)\s+(\S+(?:\s+\S+)*)$/.exec(part);
+    if (m) {
+      byName[m[2]] = parseInt(m[1], 10);
+    } else {
+      byName[part] = 1;
+    }
+  }
+  return { total: parseInt(match[1], 10), byName };
+}
+
+export function formatToolSummary(data: ToolSummaryData): string {
+  return `${data.total} ${data.total === 1 ? 'tool' : 'tools'}`;
+}
+
+/** Format tool summary directly from a Map<toolName, count>. */
+export function formatToolSummaryFromMap(counts: Map<string, number>): string | undefined {
+  const total = Array.from(counts.values()).reduce((a, b) => a + b, 0);
+  if (total === 0) return undefined;
+  return `${total} ${total === 1 ? 'tool' : 'tools'}`;
+}
+
+/** Format tool summary from an array of ToolCallMeta. */
+export function formatToolSummaryFromCalls(calls: ToolCallMeta[]): string | undefined {
+  if (calls.length === 0) return undefined;
+  const counts = new Map<string, number>();
+  for (const c of calls) counts.set(c.name, (counts.get(c.name) ?? 0) + 1);
+  return formatToolSummaryFromMap(counts);
+}
+
+function baseName(filePath: string): string {
+  return filePath.split(/[/\\]/).pop() ?? filePath;
+}
+
+function truncateStr(str: string, max: number): string {
+  return str.length <= max ? str : str.slice(0, max) + '...';
+}
+
+function formatProviderName(providerId: string): string {
+  switch (providerId.trim().toLowerCase()) {
+    case 'anthropic':
+      return 'Anthropic';
+    case 'codex':
+      return 'Codex';
+    case 'gemini':
+      return 'Gemini';
+    case 'opencode':
+      return 'OpenCode';
+    default:
+      return providerId;
+  }
+}
+
+function formatEffortName(effort: string): string {
+  const trimmed = effort.trim();
+  return trimmed ? trimmed.charAt(0).toUpperCase() + trimmed.slice(1) : trimmed;
+}
+
+export interface AgentToolDisplayDetails {
+  action: string;
+  teammateName?: string;
+  teamName?: string;
+  runtime?: string;
+  subagentType?: string;
+}
+
+export function getAgentToolDisplayDetails(
+  input: Record<string, unknown>
+): AgentToolDisplayDetails {
+  const teammateName = typeof input.name === 'string' ? input.name.trim() || undefined : undefined;
+  const teamName =
+    typeof input.team_name === 'string' ? input.team_name.trim() || undefined : undefined;
+  const description =
+    typeof input.description === 'string' ? input.description.trim() || undefined : undefined;
+  const provider =
+    typeof input.provider === 'string'
+      ? formatProviderName(input.provider)
+      : typeof input.providerId === 'string'
+        ? formatProviderName(input.providerId)
+        : undefined;
+  const model = typeof input.model === 'string' ? input.model.trim() || undefined : undefined;
+  const effort = typeof input.effort === 'string' ? formatEffortName(input.effort) : undefined;
+  const subagentType =
+    typeof input.subagent_type === 'string'
+      ? input.subagent_type.trim() || undefined
+      : typeof input.subagentType === 'string'
+        ? input.subagentType.trim() || undefined
+        : undefined;
+
+  const runtimeParts = [provider, model, effort].filter(
+    (part): part is string => typeof part === 'string' && part.length > 0
+  );
+  const runtime = runtimeParts.length > 0 ? runtimeParts.join(' · ') : undefined;
+
+  return {
+    action: description ?? (teammateName ? `Spawn teammate ${teammateName}` : 'Spawn subagent'),
+    teammateName,
+    teamName,
+    runtime,
+    subagentType,
+  };
+}
+
+export function summarizeAgentToolInput(input: Record<string, unknown>, max = 60): string {
+  const details = getAgentToolDisplayDetails(input);
+  const text = details.runtime ? `${details.action} · ${details.runtime}` : details.action;
+  return truncateStr(text, max);
+}
+
+/** Extract a short human-readable preview from tool_use input arguments. */
+export function extractToolPreview(
+  name: string,
+  input: Record<string, unknown>
+): string | undefined {
+  switch (name) {
+    case 'Read':
+    case 'Edit':
+    case 'Write':
+      return typeof input.file_path === 'string' ? baseName(input.file_path) : undefined;
+    case 'Bash':
+      return typeof input.description === 'string'
+        ? truncateStr(input.description, 60)
+        : typeof input.command === 'string'
+          ? truncateStr(input.command, 60)
+          : undefined;
+    case 'Grep':
+    case 'Glob':
+      return typeof input.pattern === 'string' ? truncateStr(input.pattern, 40) : undefined;
+    case 'Agent':
+    case 'Task':
+    case 'TaskCreate':
+      if (name === 'Agent') {
+        return summarizeAgentToolInput(input, 80);
+      }
+      return typeof input.description === 'string'
+        ? input.description
+        : typeof input.prompt === 'string'
+          ? truncateStr(input.prompt, 80)
+          : undefined;
+    case 'WebFetch':
+      if (typeof input.url === 'string') {
+        try {
+          return new URL(input.url).hostname;
+        } catch {
+          return truncateStr(input.url, 40);
+        }
+      }
+      return undefined;
+    case 'WebSearch':
+      return typeof input.query === 'string' ? truncateStr(input.query, 40) : undefined;
+    default: {
+      const v =
+        input.subject ??
+        input.name ??
+        input.description ??
+        input.prompt ??
+        input.path ??
+        input.file ??
+        input.query ??
+        input.command;
+      return typeof v === 'string' ? truncateStr(v, 50) : undefined;
+    }
+  }
+}
+
+function flattenToolResultContent(content: unknown): string[] {
+  if (typeof content === 'string') {
+    return [content];
+  }
+
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  const parts: string[] = [];
+  for (const item of content) {
+    if (!item || typeof item !== 'object') continue;
+    const block = item as Record<string, unknown>;
+    if (typeof block.text === 'string') {
+      parts.push(block.text);
+      continue;
+    }
+    if (typeof block.content === 'string') {
+      parts.push(block.content);
+    }
+  }
+  return parts;
+}
+
+/** Extract a short human-readable preview from tool_result content. */
+export function extractToolResultPreview(content: unknown, max = 80): string | undefined {
+  const joined = flattenToolResultContent(content).join(' ').replace(/\s+/g, ' ').trim();
+  if (!joined) return undefined;
+  return truncateStr(joined, max);
+}
+
+/**
+ * Parse machine-readable Agent tool_result status lines from the raw tool_result content.
+ * Returns null for any non-Agent or non-duplicate result.
+ */
+export function parseAgentToolResultStatus(content: unknown): ParsedAgentToolResultStatus | null {
+  const joined = flattenToolResultContent(content).join('\n').trim();
+  if (!joined) return null;
+
+  const fields = new Map<string, string>();
+  for (const rawLine of joined.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex <= 0) continue;
+    const key = line.slice(0, separatorIndex).trim().toLowerCase();
+    const value = line.slice(separatorIndex + 1).trim();
+    if (!value) continue;
+    fields.set(key, value);
+  }
+
+  if (fields.get('status') !== 'duplicate_skipped') {
+    return null;
+  }
+
+  const rawReason = fields.get('reason');
+  const reason =
+    rawReason === 'already_running' || rawReason === 'bootstrap_pending' ? rawReason : undefined;
+
+  return {
+    status: 'duplicate_skipped',
+    reason,
+    ...(rawReason ? { rawReason } : {}),
+    name: fields.get('name'),
+    teamName: fields.get('team_name'),
+  };
+}