@yancyyu/openhermit 1.6.41 → 1.6.43

package/src/renderer/components/team/loop-console/loopSendIntent.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseLoopSendIntent, validateLoopSendIntent } from './loopSendIntent';
+
+function messageIntent(text = 'do the thing') {
+  return parseLoopSendIntent({ text, recipient: 'lead', leadRecipient: 'lead' });
+}
+
+describe('validateLoopSendIntent', () => {
+  it('rejects empty text with a generic command prompt (no Loop branding)', () => {
+    const intent = messageIntent('   ');
+    const result = validateLoopSendIntent(intent);
+    expect(result.ok).toBe(false);
+    expect(result.reason).toBeTruthy();
+    // The console accepts more than just loop commands — !runtime, !session,
+    // /workflows, @team dispatch — so the empty-state prompt must be generic
+    // command wording, never branded "Loop 指令".
+    expect(result.reason).toMatch(/指令/);
+    expect(result.reason).not.toMatch(/Loop/i);
+  });
+
+  it('accepts a non-empty message when the team is alive', () => {
+    expect(validateLoopSendIntent(messageIntent('hello'), { isTeamAlive: true }).ok).toBe(true);
+  });
+
+  it('blocks sends while provisioning', () => {
+    const result = validateLoopSendIntent(messageIntent('hello'), { isProvisioning: true });
+    expect(result.ok).toBe(false);
+    expect(result.reason).toMatch(/启动/);
+  });
+
+  it('blocks runtime/session intents when the team is offline', () => {
+    const runtime = parseLoopSendIntent({
+      text: '!runtime do something',
+      recipient: 'lead',
+      leadRecipient: 'lead',
+    });
+    expect(runtime.kind).toBe('runtime');
+    expect(validateLoopSendIntent(runtime, { isTeamAlive: false }).ok).toBe(false);
+
+    const session = parseLoopSendIntent({
+      text: '/loop-scan',
+      recipient: 'lead',
+      leadRecipient: 'lead',
+      slashCommandMode: 'session',
+    });
+    expect(session.kind).toBe('session');
+    expect(validateLoopSendIntent(session, { isTeamAlive: false }).ok).toBe(false);
+  });
+
+  it('allows a runtime intent when the team is alive', () => {
+    const runtime = parseLoopSendIntent({
+      text: '!runtime do something',
+      recipient: 'lead',
+      leadRecipient: 'lead',
+    });
+    expect(runtime.kind).toBe('runtime');
+    expect(validateLoopSendIntent(runtime, { isTeamAlive: true }).ok).toBe(true);
+  });
+});
+
+describe('parseLoopSendIntent /workers', () => {
+  it('resolves /workers to workers-list in session (admin) mode', () => {
+    const intent = parseLoopSendIntent({
+      text: '/workers',
+      recipient: 'lead',
+      leadRecipient: 'lead',
+      slashCommandMode: 'session',
+    });
+    expect(intent.kind).toBe('workers-list');
+  });
+
+  it('resolves /workers to workers-list even in message (team) mode', () => {
+    // /workers is offered in the team console too; it must actually run the
+    // client-side worker listing there, not silently fall through to a plain
+    // lead message that does nothing.
+    const intent = parseLoopSendIntent({
+      text: '/workers',
+      recipient: 'lead',
+      leadRecipient: 'lead',
+      slashCommandMode: 'message',
+    });
+    expect(intent.kind).toBe('workers-list');
+  });
+});

package/src/renderer/components/team/loop-console/loopSendIntent.ts

@@ -0,0 +1,221 @@
+import type { AttachmentPayload, SlashCommandMeta, TaskRef } from '@shared/types';
+import type { WorkflowPromptSummary } from '@shared/types/systemManager';
+
+import { parseTeamMentionDirective } from '@renderer/utils/teamMentionDirective';
+
+export type LoopSendIntentKind =
+  | 'message'
+  | 'runtime'
+  | 'session'
+  | 'cross-team-task'
+  | 'workers-list';
+
+export interface LoopSendIntentBase {
+  kind: LoopSendIntentKind;
+  text: string;
+  summary?: string;
+}
+
+export interface LoopMessageIntent extends LoopSendIntentBase {
+  kind: 'message';
+  recipient: string;
+  attachments?: AttachmentPayload[];
+  taskRefs?: TaskRef[];
+  slashCommand?: SlashCommandMeta;
+}
+
+export interface LoopRuntimeIntent extends LoopSendIntentBase {
+  kind: 'runtime';
+}
+
+export interface LoopSessionIntent extends LoopSendIntentBase {
+  kind: 'session';
+  sessionName?: string;
+  reuse?: boolean;
+  workflowPrompt?: WorkflowPromptSummary;
+}
+
+export interface LoopCrossTeamTaskIntent extends LoopSendIntentBase {
+  kind: 'cross-team-task';
+  toTeam: string;
+  subject: string;
+  taskRefs?: TaskRef[];
+}
+
+export interface LoopWorkersListIntent extends LoopSendIntentBase {
+  kind: 'workers-list';
+}
+
+export type LoopSendIntent =
+  | LoopMessageIntent
+  | LoopRuntimeIntent
+  | LoopSessionIntent
+  | LoopCrossTeamTaskIntent
+  | LoopWorkersListIntent;
+
+export interface LoopSendIntentParseOptions {
+  text: string;
+  recipient: string;
+  leadRecipient: string;
+  teamSlugs?: readonly string[];
+  attachments?: AttachmentPayload[];
+  taskRefs?: TaskRef[];
+  slashCommandMode?: 'message' | 'session';
+  workflowPrompts?: readonly WorkflowPromptSummary[];
+}
+
+export interface LoopSendIntentValidationContext {
+  isTeamAlive?: boolean;
+  isProvisioning?: boolean;
+}
+
+export interface LoopSendIntentValidationResult {
+  ok: boolean;
+  reason?: string;
+}
+
+function normalizeTeamSlug(value: string): string {
+  return value.trim().replace(/^@/, '');
+}
+
+function parseDirective(text: string): { directive: string; rest: string } | null {
+  const match = text.trim().match(/^!(runtime|session|message)\b\s*([\s\S]*)$/i);
+  if (!match) return null;
+  return {
+    directive: match[1].toLowerCase(),
+    rest: match[2]?.trim() ?? '',
+  };
+}
+
+function parseSessionDirective(
+  rest: string
+): Pick<LoopSessionIntent, 'text' | 'sessionName' | 'reuse'> {
+  const reuse = /(?:^|\s)--reuse(?:\s|$)/.test(rest);
+  const withoutReuse = rest.replace(/(?:^|\s)--reuse(?=\s|$)/g, ' ').trim();
+  const nameMatch = withoutReuse.match(/(?:^|\s)--name\s+"([^"]+)"|(?:^|\s)--name\s+([^\s]+)/);
+  const sessionName = (nameMatch?.[1] ?? nameMatch?.[2])?.trim();
+  const text = nameMatch ? withoutReuse.replace(nameMatch[0], ' ').trim() : withoutReuse;
+  return { text, sessionName, reuse };
+}
+
+export function parseLoopSendIntent(options: LoopSendIntentParseOptions): LoopSendIntent {
+  const text = options.text.trim();
+  const directive = parseDirective(text);
+  const attachments =
+    options.attachments && options.attachments.length > 0 ? options.attachments : undefined;
+  const taskRefs = options.taskRefs && options.taskRefs.length > 0 ? options.taskRefs : undefined;
+
+  if (directive?.directive === 'runtime') {
+    return {
+      kind: 'runtime',
+      text: directive.rest,
+      summary: directive.rest,
+    };
+  }
+
+  if (directive?.directive === 'session') {
+    const session = parseSessionDirective(directive.rest);
+    return {
+      kind: 'session',
+      text: session.text,
+      summary: session.text,
+      sessionName: session.sessionName,
+      reuse: session.reuse,
+    };
+  }
+
+  const crossTeamDirective = parseTeamMentionDirective(text);
+  if (crossTeamDirective) {
+    const toTeam = normalizeTeamSlug(crossTeamDirective.mentioned);
+    const knownTeam = options.teamSlugs?.some((team) => normalizeTeamSlug(team) === toTeam);
+    if (knownTeam) {
+      return {
+        kind: 'cross-team-task',
+        toTeam,
+        subject: crossTeamDirective.subject,
+        text,
+        summary: crossTeamDirective.subject,
+        taskRefs,
+      };
+    }
+  }
+
+  const messageText = directive?.directive === 'message' ? directive.rest : text;
+  // /workers lists discoverable workers via a client-side API call, so it works
+  // in any console mode — including the team (message-mode) console, where it's
+  // offered in the command list. Without this it would fall through to a plain
+  // lead message that does nothing.
+  if (/^\/workers(?:\s|$)/i.test(messageText)) {
+    return {
+      kind: 'workers-list',
+      text: messageText,
+      summary: '获取当前数字员工列表',
+    };
+  }
+
+  if (
+    options.slashCommandMode === 'session' &&
+    /^\/[a-z][a-z0-9:-]{0,63}(?:\s|$)/i.test(messageText)
+  ) {
+    const sessionName = messageText.split(/\s+/, 1)[0]?.slice(1) || undefined;
+    return {
+      kind: 'session',
+      text: messageText,
+      summary: messageText,
+      sessionName,
+      reuse: true,
+    };
+  }
+
+  return {
+    kind: 'message',
+    recipient: options.recipient || options.leadRecipient,
+    text: messageText,
+    summary: messageText,
+    attachments,
+    taskRefs,
+  };
+}
+
+export function validateLoopSendIntent(
+  intent: LoopSendIntent,
+  context: LoopSendIntentValidationContext = {}
+): LoopSendIntentValidationResult {
+  if (!intent.text.trim()) {
+    return { ok: false, reason: '请输入要下发的指令。' };
+  }
+
+  if (context.isProvisioning) {
+    return { ok: false, reason: 'Loop runtime 正在启动中，稍后再下发指令。' };
+  }
+
+  if ((intent.kind === 'runtime' || intent.kind === 'session') && context.isTeamAlive === false) {
+    return { ok: false, reason: 'Loop runtime 离线，无法直接注入运行时。' };
+  }
+
+  if (intent.kind === 'message' && intent.attachments && context.isTeamAlive === false) {
+    return { ok: false, reason: 'Loop runtime 离线时不能发送附件。' };
+  }
+
+  if (intent.kind === 'cross-team-task' && !intent.toTeam) {
+    return { ok: false, reason: '请选择目标团队。' };
+  }
+
+  return { ok: true };
+}
+
+export function getLoopSendIntentLabel(intent: LoopSendIntent): string {
+  switch (intent.kind) {
+    case 'runtime':
+      return '注入运行时';
+    case 'session':
+      return intent.reuse ? '复用 Loop 会话' : '新建 Loop 会话';
+    case 'cross-team-task':
+      return `跨团队派单：${intent.toTeam}`;
+    case 'workers-list':
+      return '查看数字员工';
+    case 'message':
+    default:
+      return `发送给 ${intent.recipient}`;
+  }
+}

package/src/renderer/components/team/loop-console/useLeadSessionToolActivity.ts

@@ -0,0 +1,74 @@
+import { useEffect, useMemo } from 'react';
+
+import { useStore } from '@renderer/store';
+import { resolveProjectIdByPath } from '@renderer/utils/projectLookup';
+import { extractRecentToolActivity, type LeadToolActivity } from '@renderer/utils/leadToolActivity';
+import { useShallow } from 'zustand/react/shallow';
+
+const POLL_INTERVAL_MS = 10_000;
+
+export interface UseLeadSessionToolActivityOptions {
+  teamName: string;
+  /** Lead/loop session id to surface tool activity for. */
+  sessionId?: string | null;
+  /** Workspace path used to resolve the project id that owns the session file. */
+  projectPath?: string | null;
+  /** When false, the session is treated as offline and polling pauses. */
+  isAlive?: boolean;
+  /** Max number of recent tool calls to return (newest first). */
+  limit?: number;
+}
+
+/**
+ * Surface the lead agent's recent tool calls (Bash/Read/Edit/…) for the Loop
+ * console. Tool activity lives in the parsed session detail, not the team
+ * message feed, so this fetches the lead session (idempotently, into a
+ * loop-console-scoped tab slot) and polls while the team is alive.
+ *
+ * Works for both the team Loop console (TeamDetailView) and the admin Loop
+ * console (SystemManagerView) since it only needs teamName + a session id +
+ * the workspace path.
+ */
+export function useLeadSessionToolActivity({
+  teamName,
+  sessionId,
+  projectPath,
+  isAlive,
+  limit = 8,
+}: UseLeadSessionToolActivityOptions): LeadToolActivity[] {
+  const tabId = `loop-tools:${teamName}`;
+
+  const { projects, repositoryGroups, fetchSessionDetail, sessionDetail } = useStore(
+    useShallow((s) => ({
+      projects: s.projects,
+      repositoryGroups: s.repositoryGroups,
+      fetchSessionDetail: s.fetchSessionDetail,
+      sessionDetail: tabId ? (s.tabSessionData[tabId]?.sessionDetail ?? null) : null,
+    }))
+  );
+
+  const projectId = useMemo(
+    () => resolveProjectIdByPath(projectPath ?? null, projects, repositoryGroups),
+    [projectPath, projects, repositoryGroups]
+  );
+
+  useEffect(() => {
+    if (!projectId || !sessionId) return;
+    void fetchSessionDetail(projectId, sessionId, tabId, { silent: true });
+    if (!isAlive) return undefined;
+    const handle = window.setInterval(() => {
+      void fetchSessionDetail(projectId, sessionId, tabId, { silent: true });
+    }, POLL_INTERVAL_MS);
+    return () => window.clearInterval(handle);
+  }, [fetchSessionDetail, isAlive, projectId, sessionId, tabId]);
+
+  // Only use the detail when it actually matches the requested session, so a
+  // stale detail from a previous session never leaks into the timeline.
+  const matchedDetail =
+    sessionId && sessionDetail?.session?.id === sessionId ? sessionDetail : null;
+
+  return useMemo(
+    () => extractRecentToolActivity(matchedDetail?.messages ?? [], limit),
+    [matchedDetail, limit]
+  );
+}

package/src/renderer/components/team/loop-console/useLoopCommandSuggestions.ts

@@ -0,0 +1,165 @@
+import { useEffect, useMemo } from 'react';
+
+import { useTaskSuggestions } from '@renderer/hooks/useTaskSuggestions';
+import { useTeamSuggestions } from '@renderer/hooks/useTeamSuggestions';
+import { useProjectWorkflowCommands } from '@renderer/hooks/useProjectWorkflowCommands';
+import { useStore } from '@renderer/store';
+import { buildMemberColorMap } from '@renderer/utils/memberHelpers';
+import { getLoopShortcutMentionSuggestions } from '@renderer/utils/loopShortcutSuggestions';
+import { getSuggestedSlashCommandsForProvider } from '@renderer/utils/providerSlashCommands';
+import {
+  buildCapabilityPackCommandSuggestions,
+  collectSlashSuggestionAliases,
+} from '@renderer/utils/slashCommandRegistry';
+import { buildSlashCommandSuggestions } from '@renderer/utils/skillCommandSuggestions';
+import { CANONICAL_LEAD_MEMBER_NAME, isLeadMember } from '@shared/utils/leadDetection';
+import {
+  inferTeamProviderIdFromModel,
+  normalizeOptionalTeamProviderId,
+} from '@shared/utils/teamProvider';
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { ResolvedTeamMember } from '@shared/types';
+
+interface UseLoopCommandSuggestionsOptions {
+  teamName: string;
+  members: ResolvedTeamMember[];
+  commandSuggestions?: MentionSuggestion[];
+  /** Team project path — used to load that project's .claude/commands workflow commands. */
+  projectPath?: string | null;
+}
+
+interface UseLoopCommandSuggestionsResult {
+  mentionSuggestions: MentionSuggestion[];
+  teamSuggestions: MentionSuggestion[];
+  taskSuggestions: MentionSuggestion[];
+  commandSuggestions: MentionSuggestion[];
+  teamSlugs: string[];
+  leadRecipient: string;
+}
+
+function formatRole(role?: string): string | undefined {
+  const value = role?.trim();
+  if (!value) return undefined;
+  return value;
+}
+
+function isLoopFocusedSuggestion(suggestion: MentionSuggestion): boolean {
+  const haystack = [
+    suggestion.name,
+    suggestion.command,
+    suggestion.description,
+    suggestion.searchText,
+  ]
+    .filter(Boolean)
+    .join(' ')
+    .toLowerCase();
+  return /loop|doctor|summary|hygiene|workflow|worktree|memory|scan|daily|workers|诊断|摘要|循环|运维|清理|记忆|数字员工/.test(
+    haystack
+  );
+}
+
+export function useLoopCommandSuggestions({
+  teamName,
+  members,
+  commandSuggestions: scopedCommandSuggestions,
+  projectPath,
+}: UseLoopCommandSuggestionsOptions): UseLoopCommandSuggestionsResult {
+  const colorMap = useMemo(() => buildMemberColorMap(members), [members]);
+  const mentionSuggestions = useMemo<MentionSuggestion[]>(
+    () =>
+      members.map((member) => ({
+        id: member.name,
+        name: member.name,
+        subtitle: formatRole(member.role) ?? formatRole(member.agentType),
+        color: colorMap.get(member.name),
+      })),
+    [colorMap, members]
+  );
+
+  const leadMember = useMemo(
+    () => members.find((member) => isLeadMember(member)) ?? members[0],
+    [members]
+  );
+  const leadRecipient = leadMember?.name ?? CANONICAL_LEAD_MEMBER_NAME;
+  const leadProviderId = useMemo(
+    () =>
+      normalizeOptionalTeamProviderId(leadMember?.providerId) ??
+      inferTeamProviderIdFromModel(leadMember?.model),
+    [leadMember?.model, leadMember?.providerId]
+  );
+
+  const { suggestions: teamSuggestions } = useTeamSuggestions(teamName);
+  const { suggestions: taskSuggestions } = useTaskSuggestions(teamName);
+  // Load the team project's own .claude/commands so project-specific commands
+  // appear in the team console. Skipped when the caller supplies its own full
+  // suggestion set (e.g. the admin console builds its own).
+  const projectWorkflowSuggestions = useProjectWorkflowCommands(
+    scopedCommandSuggestions ? null : projectPath
+  );
+  const capabilityPacks = useStore((state) => state.capabilityPacks);
+  const fetchCapabilityPacks = useStore((state) => state.fetchCapabilityPacks);
+
+  useEffect(() => {
+    void fetchCapabilityPacks();
+  }, [fetchCapabilityPacks]);
+
+  const commandSuggestions = useMemo<MentionSuggestion[]>(() => {
+    // 指令台命令排序（用户要求）：本项目指令 → hermit 指令 → claude 指令。
+    //   - 本项目：团队项目 .claude/commands（projectWorkflowSuggestions）
+    //   - hermit：loop 快捷指令 + hermit:* 命令 + 能力包（packs）
+    //   - claude：claude 内建 slash 命令（baseSuggestions）
+    // 调用方传入完整集合（admin 控制台）时 projectWorkflowSuggestions 与 packs 均为空，
+    // 退化为 [scoped, claude]，与改动前行为一致。
+    const baseSuggestions = buildSlashCommandSuggestions(
+      getSuggestedSlashCommandsForProvider(leadProviderId),
+      [],
+      [],
+      leadProviderId
+    ).filter(isLoopFocusedSuggestion);
+
+    const hermitBase = scopedCommandSuggestions ?? getLoopShortcutMentionSuggestions();
+    // 能力包归入 hermit 组；别名冲突检测仍覆盖全部已有命令（本项目+hermit+claude），
+    // 与改动前集合等价，仅调整展示顺序。
+    const packSuggestions = scopedCommandSuggestions
+      ? []
+      : buildCapabilityPackCommandSuggestions(capabilityPacks, 'team-loop', {
+          forceNamespacedAliases: collectSlashSuggestionAliases([
+            ...projectWorkflowSuggestions,
+            ...hermitBase,
+            ...baseSuggestions,
+          ]),
+        });
+    // 排序：本项目 → hermit(快捷指令+能力包) → claude。
+    const localSuggestions = [
+      ...projectWorkflowSuggestions,
+      ...hermitBase,
+      ...packSuggestions,
+      ...baseSuggestions,
+    ];
+    const seen = new Set<string>();
+    return localSuggestions.filter((suggestion) => {
+      const key = suggestion.command ?? suggestion.id;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }, [capabilityPacks, leadProviderId, scopedCommandSuggestions]);
+
+  const teamSlugs = useMemo(
+    () =>
+      teamSuggestions.map((suggestion) =>
+        suggestion.id.startsWith('team:') ? suggestion.id.slice('team:'.length) : suggestion.name
+      ),
+    [teamSuggestions]
+  );
+
+  return {
+    mentionSuggestions,
+    teamSuggestions,
+    taskSuggestions,
+    commandSuggestions,
+    teamSlugs,
+    leadRecipient,
+  };
+}