@yancyyu/openhermit 1.5.8

package/src/renderer/components/team/members/TeamRosterEditorSection.tsx

@@ -0,0 +1,153 @@
+import React from 'react';
+
+import { LeadModelRow } from './LeadModelRow';
+import { MembersEditorSection } from './MembersEditorSection';
+
+import type { MemberDraft } from './membersEditorTypes';
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { EffortLevel, TeamProviderId } from '@shared/types';
+
+interface TeamRosterEditorSectionProps {
+  members: MemberDraft[];
+  onMembersChange: (members: MemberDraft[]) => void;
+  fieldError?: string;
+  validateMemberName?: (name: string) => string | null;
+  showWorkflow?: boolean;
+  showJsonEditor?: boolean;
+  draftKeyPrefix?: string;
+  projectPath?: string | null;
+  taskSuggestions?: MentionSuggestion[];
+  teamSuggestions?: MentionSuggestion[];
+  hideMembersContent?: boolean;
+  existingMembers?: readonly { name: string; color?: string; removedAt?: number | string | null }[];
+  defaultProviderId?: TeamProviderId;
+  inheritedProviderId: TeamProviderId;
+  inheritedModel: string;
+  inheritedEffort?: EffortLevel;
+  inheritModelSettingsByDefault?: boolean;
+  forceInheritedModelSettings?: boolean;
+  lockProviderModel?: boolean;
+  modelLockReason?: string;
+  providerId: TeamProviderId;
+  model: string;
+  effort?: EffortLevel;
+  limitContext: boolean;
+  onProviderChange: (providerId: TeamProviderId) => void;
+  onModelChange: (model: string) => void;
+  onEffortChange: (effort: string) => void;
+  onLimitContextChange: (value: boolean) => void;
+  syncModelsWithTeammates: boolean;
+  onSyncModelsWithTeammatesChange: (value: boolean) => void;
+  headerTop?: React.ReactNode;
+  headerBottom?: React.ReactNode;
+  softDeleteMembers?: boolean;
+  leadWarningText?: string | null;
+  memberWarningById?: Record<string, string | null | undefined>;
+  disableGeminiOption?: boolean;
+  leadModelIssueText?: string | null;
+  memberModelIssueById?: Record<string, string | null | undefined>;
+  hideLeadProviderTabs?: boolean;
+  showWorktreeIsolationControls?: boolean;
+  teammateWorktreeDefault?: boolean;
+  onTeammateWorktreeDefaultChange?: (enabled: boolean) => void;
+}
+
+export const TeamRosterEditorSection = ({
+  members,
+  onMembersChange,
+  fieldError,
+  validateMemberName,
+  showWorkflow = false,
+  showJsonEditor = true,
+  draftKeyPrefix,
+  projectPath,
+  taskSuggestions,
+  teamSuggestions,
+  hideMembersContent = false,
+  existingMembers,
+  defaultProviderId = 'anthropic',
+  inheritedProviderId,
+  inheritedModel,
+  inheritedEffort,
+  inheritModelSettingsByDefault = false,
+  forceInheritedModelSettings = false,
+  lockProviderModel = false,
+  modelLockReason,
+  providerId,
+  model,
+  effort,
+  limitContext,
+  onProviderChange,
+  onModelChange,
+  onEffortChange,
+  onLimitContextChange,
+  syncModelsWithTeammates,
+  onSyncModelsWithTeammatesChange,
+  headerTop,
+  headerBottom,
+  softDeleteMembers = false,
+  leadWarningText,
+  memberWarningById,
+  disableGeminiOption = false,
+  leadModelIssueText,
+  memberModelIssueById,
+  hideLeadProviderTabs = false,
+  showWorktreeIsolationControls = false,
+  teammateWorktreeDefault = false,
+  onTeammateWorktreeDefaultChange,
+}: TeamRosterEditorSectionProps): React.JSX.Element => {
+  return (
+    <MembersEditorSection
+      members={members}
+      onChange={onMembersChange}
+      fieldError={fieldError}
+      validateMemberName={validateMemberName}
+      showWorkflow={showWorkflow}
+      showJsonEditor={showJsonEditor}
+      draftKeyPrefix={draftKeyPrefix}
+      projectPath={projectPath}
+      taskSuggestions={taskSuggestions}
+      teamSuggestions={teamSuggestions}
+      hideContent={hideMembersContent}
+      existingMembers={existingMembers}
+      defaultProviderId={defaultProviderId}
+      inheritedProviderId={inheritedProviderId}
+      inheritedModel={inheritedModel}
+      inheritedEffort={inheritedEffort}
+      limitContext={limitContext}
+      inheritModelSettingsByDefault={inheritModelSettingsByDefault}
+      lockProviderModel={lockProviderModel}
+      forceInheritedModelSettings={forceInheritedModelSettings}
+      modelLockReason={modelLockReason}
+      softDeleteMembers={softDeleteMembers}
+      disableGeminiOption={disableGeminiOption}
+      memberModelIssueById={memberModelIssueById}
+      showWorktreeIsolationControls={showWorktreeIsolationControls}
+      teammateWorktreeDefault={teammateWorktreeDefault}
+      onTeammateWorktreeDefaultChange={onTeammateWorktreeDefaultChange}
+      headerExtra={
+        <div className="space-y-3">
+          {headerTop}
+          <LeadModelRow
+            providerId={providerId}
+            model={model}
+            effort={effort}
+            limitContext={limitContext}
+            onProviderChange={onProviderChange}
+            onModelChange={onModelChange}
+            onEffortChange={onEffortChange}
+            onLimitContextChange={onLimitContextChange}
+            syncModelsWithTeammates={syncModelsWithTeammates}
+            onSyncModelsWithTeammatesChange={onSyncModelsWithTeammatesChange}
+            warningText={leadWarningText}
+            disableGeminiOption={disableGeminiOption}
+            modelIssueText={leadModelIssueText}
+            hideProviderTabs={hideLeadProviderTabs}
+          />
+          {headerBottom}
+        </div>
+      }
+      memberWarningById={memberWarningById}
+    />
+  );
+};

package/src/renderer/components/team/members/memberActivityEntries.ts

@@ -0,0 +1,42 @@
+import { buildInlineActivityEntries } from '@features/agent-graph/renderer';
+import { filterTeamMessages } from '@renderer/utils/teamMessageFiltering';
+import { isLeadMember } from '@shared/utils/leadDetection';
+
+import type { InlineActivityEntry } from '@features/agent-graph/renderer';
+import type { InboxMessage, ResolvedTeamMember, TeamTaskWithKanban } from '@shared/types';
+
+export function buildMemberActivityEntries({
+  teamName,
+  memberName,
+  members,
+  tasks,
+  messages,
+}: {
+  teamName: string;
+  memberName: string;
+  members: ResolvedTeamMember[];
+  tasks: TeamTaskWithKanban[];
+  messages: InboxMessage[];
+}): InlineActivityEntry[] {
+  const filteredMessages = filterTeamMessages(messages, {
+    timeWindow: null,
+    filter: { from: new Set(), to: new Set(), showNoise: true },
+    searchQuery: '',
+  });
+  const leadId = `lead:${teamName}`;
+  const leadName = members.find((candidate) => isLeadMember(candidate))?.name ?? `${teamName}-lead`;
+  const ownerNodeId = memberName === leadName ? leadId : `member:${teamName}:${memberName}`;
+  const ownerNodeIds = new Set([leadId, ownerNodeId]);
+  const entriesByOwner = buildInlineActivityEntries({
+    data: {
+      members,
+      tasks,
+      messages: filteredMessages,
+    },
+    teamName,
+    leadId,
+    leadName,
+    ownerNodeIds,
+  });
+  return entriesByOwner.get(ownerNodeId) ?? [];
+}

package/src/renderer/components/team/members/memberDetailTypes.ts

@@ -0,0 +1,3 @@
+export type MemberDetailTab = 'tasks' | 'workspace' | 'activity' | 'stats';
+
+export type MemberActivityFilter = 'all' | 'messages' | 'comments';

package/src/renderer/components/team/members/memberNameSets.ts

@@ -0,0 +1,65 @@
+const MEMBER_NAME_SETS = [
+  ['atlas', 'nova', 'echo', 'vector', 'ember', 'pixel'],
+  ['scout', 'forge', 'quill', 'signal', 'patch', 'guard'],
+  ['aurora', 'cipher', 'relay', 'kernel', 'beacon', 'sable'],
+  ['orbit', 'flux', 'delta', 'prism', 'comet', 'node'],
+] as const;
+
+function normalizeMemberName(name: string): string {
+  return name.trim().toLowerCase();
+}
+
+function belongsToBaseName(name: string, baseName: string): boolean {
+  const normalized = normalizeMemberName(name);
+  return normalized === baseName || normalized.startsWith(`${baseName}-`);
+}
+
+function getPreferredNameSet(existingNames: readonly string[]): readonly string[] {
+  for (const nameSet of MEMBER_NAME_SETS) {
+    if (
+      nameSet.some((candidate) => existingNames.some((name) => belongsToBaseName(name, candidate)))
+    ) {
+      return nameSet;
+    }
+  }
+
+  return MEMBER_NAME_SETS[0];
+}
+
+function createUniqueName(baseName: string, existingNames: readonly string[]): string {
+  const normalizedExisting = new Set(existingNames.map(normalizeMemberName));
+  if (!normalizedExisting.has(baseName)) {
+    return baseName;
+  }
+
+  let suffix = 2;
+  while (normalizedExisting.has(`${baseName}-${suffix}`)) {
+    suffix += 1;
+  }
+
+  return `${baseName}-${suffix}`;
+}
+
+export function getNextSuggestedMemberName(existingNames: readonly string[]): string {
+  const normalizedExisting = new Set(existingNames.map(normalizeMemberName).filter(Boolean));
+  const preferredSet = getPreferredNameSet(existingNames);
+
+  for (const candidate of preferredSet) {
+    if (!normalizedExisting.has(candidate)) {
+      return candidate;
+    }
+  }
+
+  for (const nameSet of MEMBER_NAME_SETS) {
+    for (const candidate of nameSet) {
+      if (!normalizedExisting.has(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  const fallbackBaseName = preferredSet[existingNames.length % preferredSet.length] ?? 'agent';
+  return createUniqueName(fallbackBaseName, existingNames);
+}
+
+export { MEMBER_NAME_SETS };

package/src/renderer/components/team/members/membersEditorTypes.ts

@@ -0,0 +1,21 @@
+import type { InlineChip } from '@renderer/types/inlineChip';
+import type { EffortLevel, TeamProviderId } from '@shared/types';
+
+export interface MemberDraft {
+  id: string;
+  name: string;
+  originalName?: string;
+  roleSelection: string;
+  customRole: string;
+  workflow?: string;
+  workflowChips?: InlineChip[];
+  isolation?: 'worktree';
+  providerId?: TeamProviderId;
+  model?: string;
+  effort?: EffortLevel;
+  removedAt?: number | string | null;
+}
+
+export interface MembersEditorValue {
+  members: MemberDraft[];
+}

package/src/renderer/components/team/members/membersEditorUtils.ts

@@ -0,0 +1,267 @@
+import { CUSTOM_ROLE, NO_ROLE, PRESET_ROLES } from '@renderer/constants/teamRoles';
+import { serializeChipsWithText } from '@renderer/types/inlineChip';
+import { normalizeCreateLaunchProviderForUi } from '@renderer/utils/claudeCodeOnlyProviders';
+import { normalizeExplicitTeamModelForUi } from '@renderer/utils/teamModelAvailability';
+import { isTeamEffortLevel } from '@shared/utils/effortLevels';
+import { isLeadMember } from '@shared/utils/leadDetection';
+import { buildTeamMemberColorMap } from '@shared/utils/teamMemberColors';
+import { validateTeamMemberNameFormat } from '@shared/utils/teamMemberName';
+import { normalizeOptionalTeamProviderId } from '@shared/utils/teamProvider';
+
+import type { MemberDraft } from './membersEditorTypes';
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { EffortLevel, TeamProviderId, TeamProvisioningMemberInput } from '@shared/types';
+
+export function validateMemberNameInline(name: string): string | null {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  return validateTeamMemberNameFormat(trimmed);
+}
+
+function newDraftId(): string {
+  // eslint-disable-next-line sonarjs/pseudo-random -- Used for generating unique UI keys, not security
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function createMemberDraft(initial?: Partial<MemberDraft>): MemberDraft {
+  const providerId = initial?.providerId;
+  return {
+    id: initial?.id ?? newDraftId(),
+    name: initial?.name ?? '',
+    originalName: initial?.originalName,
+    roleSelection: initial?.roleSelection ?? '',
+    customRole: initial?.customRole ?? '',
+    workflow: initial?.workflow,
+    isolation: initial?.isolation === 'worktree' ? 'worktree' : undefined,
+    providerId,
+    model: normalizeExplicitTeamModelForUi(providerId, initial?.model ?? ''),
+    effort: initial?.effort,
+    removedAt: initial?.removedAt,
+  };
+}
+
+export function createMemberDraftsFromInputs(
+  members: readonly {
+    name: string;
+    agentType?: string;
+    role?: string;
+    workflow?: string;
+    providerId?: TeamProviderId;
+    model?: string;
+    effort?: EffortLevel;
+    isolation?: 'worktree';
+    removedAt?: number | string | null;
+  }[]
+): MemberDraft[] {
+  return members
+    .filter((member) => !member.removedAt)
+    .map((member) => {
+      const role = typeof member.role === 'string' ? member.role.trim() : '';
+      const presetRoles: readonly string[] = PRESET_ROLES;
+      const isPreset = presetRoles.includes(role);
+      return createMemberDraft({
+        name: member.name,
+        originalName: member.name,
+        roleSelection: role ? (isPreset ? role : CUSTOM_ROLE) : '',
+        customRole: role && !isPreset ? role : '',
+        workflow: member.workflow,
+        isolation: member.isolation === 'worktree' ? 'worktree' : undefined,
+        providerId: normalizeOptionalTeamProviderId(member.providerId),
+        model: member.model ?? '',
+        effort: normalizeDraftEffort(member.effort),
+        removedAt: member.removedAt,
+      });
+    });
+}
+
+export function filterEditableMemberInputs<T extends { name?: unknown; agentType?: unknown }>(
+  members: readonly T[]
+): T[] {
+  return members.filter((member) => !isLeadMember(member));
+}
+
+export function clearMemberModelOverrides(member: MemberDraft): MemberDraft {
+  return {
+    ...member,
+    providerId: undefined,
+    model: '',
+    effort: undefined,
+  };
+}
+
+export function normalizeProviderForMode(
+  providerId: TeamProviderId | undefined,
+  multimodelEnabled: boolean
+): TeamProviderId {
+  return normalizeCreateLaunchProviderForUi(providerId, multimodelEnabled);
+}
+
+export function normalizeLeadProviderForMode(
+  providerId: TeamProviderId | undefined,
+  multimodelEnabled: boolean
+): TeamProviderId {
+  const normalizedProviderId = normalizeProviderForMode(providerId, multimodelEnabled);
+  return normalizedProviderId === 'opencode' ? 'anthropic' : normalizedProviderId;
+}
+
+export function normalizeMemberDraftForProviderMode(
+  member: MemberDraft,
+  multimodelEnabled: boolean
+): MemberDraft {
+  const normalizedProviderId =
+    member.providerId == null
+      ? undefined
+      : normalizeCreateLaunchProviderForUi(member.providerId, multimodelEnabled);
+
+  if (normalizedProviderId === member.providerId) {
+    return member;
+  }
+
+  if (
+    member.providerId === 'codex' ||
+    member.providerId === 'gemini' ||
+    normalizedProviderId !== member.providerId
+  ) {
+    return {
+      ...member,
+      providerId: normalizedProviderId,
+      model: '',
+    };
+  }
+  return member;
+}
+
+function normalizeDraftEffort(value: string | undefined): EffortLevel | undefined {
+  return isTeamEffortLevel(value) ? value : undefined;
+}
+
+interface ExistingMemberColorInput {
+  name: string;
+  color?: string;
+  removedAt?: number | string | null;
+}
+
+function getMemberDraftColorSeedKey(member: Pick<MemberDraft, 'id' | 'originalName'>): string {
+  const originalName = member.originalName?.trim();
+  return originalName || `draft:${member.id}`;
+}
+
+export function buildMemberDraftColorMap(
+  members: readonly Pick<MemberDraft, 'id' | 'name' | 'originalName'>[],
+  existingMembers?: readonly ExistingMemberColorInput[],
+  existingColorMap?: ReadonlyMap<string, string>
+): Map<string, string> {
+  const normalizedExistingColorMap = new Map<string, string>(
+    Array.from(existingColorMap?.entries() ?? []).map(([name, color]) => [
+      name.trim().toLowerCase(),
+      color,
+    ])
+  );
+
+  const existingSeedEntries = (existingMembers ?? [])
+    .map((member) => ({
+      ...member,
+      name: member.name.trim(),
+      color:
+        normalizedExistingColorMap.get(member.name.trim().toLowerCase()) ??
+        member.color?.trim() ??
+        undefined,
+    }))
+    .filter((member) => member.name);
+  const existingNames = new Set(existingSeedEntries.map((member) => member.name.toLowerCase()));
+  const uniqueNewDraftEntries = members
+    .filter((member) => {
+      if (member.originalName?.trim()) {
+        return false;
+      }
+      const currentName = member.name.trim();
+      return !currentName || !existingNames.has(currentName.toLowerCase());
+    })
+    .map((member) => ({ name: getMemberDraftColorSeedKey(member) }));
+
+  const fullMap = buildTeamMemberColorMap([...existingSeedEntries, ...uniqueNewDraftEntries], {
+    preferProvidedColors: true,
+  });
+  const fullColorByName = new Map(
+    Array.from(fullMap.entries()).map(([name, color]) => [name.toLowerCase(), color] as const)
+  );
+
+  const draftMap = new Map<string, string>();
+  for (const member of members) {
+    const originalName = member.originalName?.trim();
+    const currentName = member.name.trim();
+    const colorSeedKey = originalName
+      ? originalName
+      : currentName && existingNames.has(currentName.toLowerCase())
+        ? currentName
+        : getMemberDraftColorSeedKey(member);
+    const color = fullColorByName.get(colorSeedKey.toLowerCase());
+    if (color) draftMap.set(member.id, color);
+  }
+  return draftMap;
+}
+
+/** Resolves a MemberDraft's role selection to a display string. */
+export function getMemberDraftRole(member: MemberDraft): string | undefined {
+  return member.roleSelection === CUSTOM_ROLE
+    ? member.customRole.trim() || undefined
+    : member.roleSelection === NO_ROLE
+      ? undefined
+      : member.roleSelection.trim() || undefined;
+}
+
+/** Builds MentionSuggestion[] from MemberDraft[], reusing color map and role resolution. */
+export function buildMemberDraftSuggestions(
+  members: MemberDraft[],
+  colorMap: Map<string, string>
+): MentionSuggestion[] {
+  return members
+    .filter((m) => m.name.trim())
+    .map((m) => ({
+      id: m.id,
+      name: m.name.trim(),
+      subtitle: getMemberDraftRole(m),
+      color: colorMap.get(m.id) ?? undefined,
+    }));
+}
+
+/** Resolves workflow for export (JSON or API): serializes chips when present. */
+export function getWorkflowForExport(member: MemberDraft): string | undefined {
+  const workflowRaw = member.workflow?.trim();
+  if (!workflowRaw) return undefined;
+  const chips = member.workflowChips ?? [];
+  return chips.length > 0 ? serializeChipsWithText(workflowRaw, chips) : workflowRaw;
+}
+
+export function buildMembersFromDrafts(members: MemberDraft[]): TeamProvisioningMemberInput[] {
+  return members
+    .map((member) => {
+      if (member.removedAt) {
+        return null;
+      }
+      const name = member.name.trim();
+      if (!name) {
+        return null;
+      }
+
+      const role = getMemberDraftRole(member);
+      const result: TeamProvisioningMemberInput = { name, role };
+      const workflow = getWorkflowForExport(member);
+      if (workflow) result.workflow = workflow;
+      if (member.isolation === 'worktree') result.isolation = 'worktree';
+      const providerId = normalizeOptionalTeamProviderId(member.providerId);
+      if (providerId) {
+        result.providerId = providerId;
+      }
+      const model = member.model?.trim();
+      if (model) {
+        result.model = normalizeExplicitTeamModelForUi(providerId, model);
+      }
+      const effort = normalizeDraftEffort(member.effort);
+      if (effort) {
+        result.effort = effort;
+      }
+      return result;
+    })
+    .filter((member): member is NonNullable<typeof member> => member !== null);
+}