@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/renderer/utils/__tests__/workflowCommandSuggestions.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildWorkflowCommandSuggestion } from '../workflowCommandSuggestions';
+
+import type { WorkflowPromptSummary } from '@shared/types/systemManager';
+
+function prompt(overrides: Partial<WorkflowPromptSummary> = {}): WorkflowPromptSummary {
+  return {
+    id: 'prompt-loop-scan',
+    label: 'Loop Scan',
+    filename: 'loop-scan.md',
+    path: '/workspace/.claude/commands/loop-scan.md',
+    folder: '/workspace/.claude/commands',
+    sizeBytes: 100,
+    updatedAt: '2026-06-13T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('buildWorkflowCommandSuggestion', () => {
+  it('derives the command from commandName when present', () => {
+    const suggestion = buildWorkflowCommandSuggestion(prompt({ commandName: '/loop-scan' }));
+    expect(suggestion.command).toBe('/loop-scan');
+    expect(suggestion.name).toBe('loop-scan');
+    expect(suggestion.insertText).toBe('loop-scan');
+  });
+
+  it('falls back to the filename when there is no commandName', () => {
+    const suggestion = buildWorkflowCommandSuggestion(prompt({ commandName: undefined }));
+    expect(suggestion.command).toBe('/loop-scan');
+  });
+
+  it('carries workflowPromptId / workflowPromptFolder for submit-time expansion', () => {
+    const suggestion = buildWorkflowCommandSuggestion(prompt());
+    expect(suggestion.workflowPromptId).toBe('prompt-loop-scan');
+    expect(suggestion.workflowPromptFolder).toBe('/workspace/.claude/commands');
+  });
+
+  it('uses a configurable id prefix', () => {
+    expect(buildWorkflowCommandSuggestion(prompt()).id).toBe('workflow:prompt-loop-scan');
+    expect(buildWorkflowCommandSuggestion(prompt(), 'team-workflow').id).toBe(
+      'team-workflow:prompt-loop-scan'
+    );
+  });
+
+  it('builds a searchable searchText from label/description/category/safety', () => {
+    const suggestion = buildWorkflowCommandSuggestion(
+      prompt({ description: 'Run loop scan', category: 'loop', safety: 'read-only' })
+    );
+    expect(suggestion.searchText).toContain('Loop Scan');
+    expect(suggestion.searchText).toContain('read-only');
+    expect(suggestion.searchText).toContain('/loop-scan');
+  });
+
+  it('falls back to a description from the label', () => {
+    const suggestion = buildWorkflowCommandSuggestion(prompt({ description: undefined }));
+    expect(suggestion.description).toBe('运行 Loop Scan');
+  });
+});

package/src/renderer/utils/bindProjectSlug.ts

@@ -0,0 +1,57 @@
+/**
+ * Project-identifier (bindProject) generation for the create-digital-worker
+ * dialog. Extracted from CreateTeamDialog so the slug rules can be unit-tested.
+ */
+
+/** Validate bindProject: ASCII lowercase alphanumeric, hyphens, underscores. */
+export function isValidBindProject(value: string): boolean {
+  return /^[a-z0-9][a-z0-9_-]*$/.test(value);
+}
+
+/** Reduce a display name to an ASCII slug base (empty when there's no ASCII). */
+function slugBase(displayName: string): string {
+  return displayName
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+/**
+ * Deterministic 4-char suffix derived from the name. Replaces the old
+ * `Math.random()` suffix so the identifier stops reshuffling on every keystroke
+ * — same name (+ same collision context) always yields the same candidate.
+ */
+function hashSuffix(input: string): string {
+  let hash = 0;
+  for (let i = 0; i < input.length; i += 1) {
+    hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+  }
+  return hash.toString(36).slice(0, 4).padStart(4, '0');
+}
+
+/**
+ * Generate a unique ASCII project identifier from a display name.
+ *
+ * The result is deterministic for a given (name, existing) pair and is
+ * guaranteed NOT to collide with any id in `existing`. Together those two
+ * properties kill the old flickering false-"已存在" red box: the auto-generated
+ * identifier is stable while typing and is never flagged as a duplicate.
+ */
+export function generateBindProject(displayName: string, existing: ReadonlySet<string>): string {
+  const trimmed = displayName.trim();
+  if (!trimmed) return '';
+  const base = slugBase(trimmed) || 'team';
+
+  // Primary candidate: base + deterministic suffix.
+  const candidate = `${base}-${hashSuffix(trimmed)}`;
+  if (!existing.has(candidate)) return candidate;
+
+  // Collision (another worker already took the deterministic id): walk a numeric
+  // counter until we find a free slot. Bounded by existing size + 2.
+  let counter = 2;
+  while (existing.has(`${base}-${counter}`)) counter += 1;
+  return `${base}-${counter}`;
+}

package/src/renderer/utils/capabilityCommandExecution.ts

@@ -0,0 +1,113 @@
+import { api } from '@renderer/api';
+import { parseStandaloneSlashCommand } from '@shared/utils/slashCommands';
+
+import { resolveSlashCommand } from './slashCommandRegistry';
+
+import type { RegisteredSlashCommand, CapabilityScope } from '@shared/types/extensions';
+import type { SlashCommandMeta } from '@shared/types/team';
+
+export interface SelectedCapabilityCommandRef {
+  commandRef: string;
+  command: `/${string}`;
+}
+
+export interface ResolvedCapabilityCommandInput {
+  command: RegisteredSlashCommand;
+  raw: string;
+  args?: string;
+}
+
+export interface ExpandedCapabilityCommand {
+  text: string;
+  summary: string;
+  slashCommand: SlashCommandMeta;
+  registered: RegisteredSlashCommand;
+}
+
+export interface ResolveCapabilityCommandInputOptions {
+  shadowedAliases?: ReadonlySet<string>;
+}
+
+export interface ResolveCapabilityCommandInputResult {
+  status: 'not-found' | 'resolved' | 'conflict';
+  resolved?: ResolvedCapabilityCommandInput;
+  conflictLabel?: string;
+}
+
+function selectedCommandStillMatches(
+  parsedCommand: `/${string}`,
+  selected?: SelectedCapabilityCommandRef | null
+): boolean {
+  return Boolean(
+    selected?.commandRef && selected.command.toLowerCase() === parsedCommand.toLowerCase()
+  );
+}
+
+function appendArgsToPrompt(prompt: string, args?: string): string {
+  const trimmedPrompt = prompt.trim();
+  const trimmedArgs = args?.trim();
+  if (!trimmedArgs) return trimmedPrompt;
+  return `${trimmedPrompt}\n\nUser arguments:\n${trimmedArgs}`;
+}
+
+export function resolveCapabilityCommandInput(
+  registry: readonly RegisteredSlashCommand[],
+  text: string,
+  selected?: SelectedCapabilityCommandRef | null,
+  options: ResolveCapabilityCommandInputOptions = {}
+): ResolveCapabilityCommandInputResult {
+  const parsed = parseStandaloneSlashCommand(text);
+  if (!parsed) return { status: 'not-found' };
+
+  const selectedRef = selectedCommandStillMatches(parsed.command, selected)
+    ? selected?.commandRef
+    : undefined;
+  if (!selectedRef && options.shadowedAliases?.has(parsed.name)) {
+    return { status: 'not-found' };
+  }
+  const result = resolveSlashCommand(registry, parsed.command, selectedRef);
+  if (result.status === 'resolved' && result.command) {
+    return {
+      status: 'resolved',
+      resolved: {
+        command: result.command,
+        raw: parsed.raw,
+        args: parsed.args,
+      },
+    };
+  }
+  if (result.status === 'conflict') {
+    return {
+      status: 'conflict',
+      conflictLabel: '能力包命令存在冲突，请从菜单选择带 namespace 的命令。',
+    };
+  }
+  return { status: 'not-found' };
+}
+
+export async function expandCapabilityCommand(
+  resolved: ResolvedCapabilityCommandInput,
+  scope: CapabilityScope
+): Promise<ExpandedCapabilityCommand> {
+  if (!api.capabilityPacks) {
+    throw new Error('Capability packs API is unavailable');
+  }
+
+  const result = await api.capabilityPacks.getCommandPrompt({
+    canonicalId: resolved.command.canonicalId,
+    scope,
+  });
+  const command = result.command;
+  const slashCommand: SlashCommandMeta = {
+    name: command.alias,
+    command: command.namespacedSlash,
+    args: resolved.args,
+    knownDescription: command.command.description ?? command.command.title,
+  };
+  return {
+    text: appendArgsToPrompt(result.prompt, resolved.args),
+    summary: command.command.title,
+    slashCommand,
+    registered: command,
+  };
+}

package/src/renderer/utils/initialRoute.ts

@@ -0,0 +1,89 @@
+/**
+ * Initial route restoration.
+ *
+ * Restores the active tab from the URL path SYNCHRONOUSLY, before React's first
+ * render (called from main.tsx). Running this pre-render means the store already
+ * holds the correct tab on the first paint — there is no blank content area
+ * while a post-mount effect catches up, and the fallback view never double-mounts.
+ */
+
+import type { AppState } from '@renderer/store/types';
+
+function safeDecodeURIComponent(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * Map the current URL path to the matching tab action. Idempotent: every action
+ * dedupes against already-open tabs, so calling this more than once (e.g. HMR)
+ * is safe.
+ */
+export function restoreInitialRoute(state: AppState, pathname: string): void {
+  const segments = pathname
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter((segment) => segment.length > 0)
+    .map(safeDecodeURIComponent);
+
+  if (segments.length === 0) return;
+
+  const [route, arg1, arg2] = segments;
+  switch (route) {
+    case 'team':
+      if (arg1) state.openTeamTab(arg1);
+      break;
+    case 'teams':
+      state.openTeamsTab();
+      break;
+    case 'system-manager':
+      void state.openSystemManager();
+      break;
+    case 'settings':
+      state.openSettingsTab();
+      break;
+    case 'extensions':
+      state.openExtensionsTab();
+      break;
+    case 'schedules':
+      state.openSchedulesTab();
+      break;
+    case 'tasks':
+      state.openTasksTab();
+      break;
+    case 'dashboard':
+      state.openDashboard();
+      break;
+    case 'society':
+      state.openSocietyTab();
+      break;
+    case 'session':
+      if (arg1 && arg2) {
+        state.navigateToSession(arg1, arg2);
+      }
+      break;
+    case 'notifications':
+      state.openTab({ type: 'notifications', label: '通知' });
+      break;
+    case 'graph':
+      if (arg1) {
+        state.openTab({ type: 'graph', label: arg1, teamName: arg1 });
+      }
+      break;
+    case 'report':
+      if (arg1 && arg2) {
+        state.openTab({
+          type: 'report',
+          label: 'Session Report',
+          projectId: arg1,
+          sessionId: arg2,
+        });
+      }
+      break;
+    default:
+      break;
+  }
+}

package/src/renderer/utils/leadToolActivity.ts

@@ -0,0 +1,117 @@
+/**
+ * Lead tool-activity extraction.
+ *
+ * The Loop console message stream only carries team/group messages — agent tool
+ * invocations (Bash/Read/Edit/…) live in the parsed session detail. These helpers
+ * flatten recent tool calls out of a parsed session so the console can surface
+ * "what the lead agent actually did" alongside the message feed.
+ *
+ * The input is typed structurally (not as the full `ParsedMessage`) so the pure
+ * extraction logic can be unit-tested without constructing an entire parsed
+ * session, while still accepting real `ParsedMessage[]` at the call site.
+ */
+
+/** Minimal shape of a single tool call we care about for display. */
+export interface ToolActivityCall {
+  name: string;
+  input: Record<string, unknown>;
+  id?: string;
+}
+
+/** Minimal message shape carrying tool calls. `ParsedMessage` satisfies this. */
+export interface ToolActivityMessage {
+  timestamp: Date | string;
+  toolCalls: readonly ToolActivityCall[];
+}
+
+/** A display-ready tool-activity entry for the Loop console. */
+export interface LeadToolActivity {
+  /** Tool name, e.g. "Bash", "Read", "Edit". */
+  name: string;
+  /** Human-readable preview derived from the tool input. */
+  preview: string;
+  /** Runtime tool_use identifier when available. */
+  toolUseId?: string;
+  /** ISO timestamp inherited from the owning message. */
+  timestamp: string;
+}
+
+/**
+ * Build a short human-readable preview from a tool's input args. Mirrors the
+ * high-signal fields Claude Code users actually scan for (file paths, commands,
+ * patterns) without dumping raw JSON.
+ */
+export function formatToolPreview(name: string, input: Record<string, unknown>): string {
+  const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+  switch (name) {
+    case 'Bash':
+      return str(input.command).trim();
+    case 'Read':
+    case 'Write':
+    case 'Edit':
+    case 'MultiEdit':
+    case 'NotebookEdit':
+      return str(input.file_path).trim();
+    case 'Grep':
+    case 'Glob': {
+      const pattern = str(input.pattern).trim();
+      const path = str(input.path).trim();
+      return pattern ? (path ? `${pattern}  (in ${path})` : pattern) : path;
+    }
+    case 'Task':
+    case 'Agent': {
+      const description = str(input.description).trim();
+      const subagent = str(input.subagent_type).trim();
+      return description || subagent ? `${subagent ? `[${subagent}] ` : ''}${description}` : '';
+    }
+    case 'WebFetch':
+      return str(input.url).trim();
+    case 'WebSearch':
+      return str(input.query).trim();
+    case 'TodoWrite': {
+      const todos = Array.isArray(input.todos) ? input.todos : [];
+      return todos.length ? `${todos.length} todos` : '';
+    }
+    default: {
+      // Fall back to the first string-valued arg, if any.
+      for (const value of Object.values(input)) {
+        const text = str(value).trim();
+        if (text) return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+      }
+      return '';
+    }
+  }
+}
+
+/**
+ * Flatten the most recent tool calls from a parsed session, newest first.
+ *
+ * Tool calls inherit their owning message's timestamp (the wire format does not
+ * attach one per call), so ordering is stable at message granularity.
+ */
+export function extractRecentToolActivity(
+  messages: readonly ToolActivityMessage[],
+  limit: number
+): LeadToolActivity[] {
+  if (limit <= 0) return [];
+
+  const activities: LeadToolActivity[] = [];
+  for (const message of messages) {
+    const timestamp =
+      message.timestamp instanceof Date
+        ? message.timestamp.toISOString()
+        : String(message.timestamp);
+    for (const call of message.toolCalls) {
+      activities.push({
+        name: call.name,
+        preview: formatToolPreview(call.name, call.input),
+        toolUseId: call.id,
+        timestamp,
+      });
+    }
+  }
+
+  if (activities.length <= limit) return activities.slice().reverse();
+  return activities.slice(activities.length - limit).reverse();
+}

package/src/renderer/utils/loopShortcutSuggestions.ts

@@ -0,0 +1,106 @@
+import type { MentionSuggestion } from '@renderer/types/mention';
+
+export interface LoopCommandShortcut {
+  id: string;
+  name: string;
+  command: `/${string}`;
+  insertText: string;
+  description: string;
+  searchText: string;
+  category: 'monitoring' | 'summary' | 'hygiene' | 'diagnostic' | 'workflow';
+}
+
+// NOTE: the native `/loop` shortcuts were removed from the command palette —
+// in the team console `/loop` is not a native command (it falls through to a
+// plain lead message and never replies), so offering it caused confusion. The
+// real loop feature will be reintroduced later. Only the `/hermit:*` workflows
+// below remain as quick commands.
+const LOOP_COMMAND_SHORTCUTS: LoopCommandShortcut[] = [
+  {
+    id: 'ops-workflow:doctor',
+    name: 'hermit:doctor',
+    command: '/hermit:doctor',
+    insertText: 'hermit:doctor 检查 Hermit 安装、运行时、cc-connect、MCP 和常见配置问题',
+    description: '诊断 Hermit / runtime / cc-connect 健康状态',
+    searchText: 'doctor hermit diagnose health runtime cc-connect mcp 诊断 健康 配置',
+    category: 'diagnostic',
+  },
+  {
+    id: 'ops-workflow:loop-scan',
+    name: 'hermit:loop-scan',
+    command: '/hermit:loop-scan',
+    insertText: 'hermit:loop-scan 扫描 Loop 资产、推荐循环和可自动化的团队运维动作',
+    description: '扫描 Loop assets 和推荐运维循环',
+    searchText: 'loop scan hermit assets workflows recommended loops 扫描 推荐 循环',
+    category: 'workflow',
+  },
+  {
+    id: 'ops-workflow:summary',
+    name: 'hermit:summary',
+    command: '/hermit:summary',
+    insertText: 'hermit:summary 总结当前团队进展、阻塞、风险和下一步建议',
+    description: '生成团队/会话摘要和下一步建议',
+    searchText: 'summary hermit status progress blockers risks next steps 摘要 进展 阻塞 风险',
+    category: 'summary',
+  },
+  {
+    id: 'ops-workflow:daily-folder-hygiene',
+    name: 'hermit:daily-folder-hygiene',
+    command: '/hermit:daily-folder-hygiene',
+    insertText: 'hermit:daily-folder-hygiene 只读检查临时文件、陈旧报告、脏 worktree 和可清理产物',
+    description: '只读检查工作区卫生和可清理项',
+    searchText: 'daily folder hygiene hermit temp stale reports dirty worktree cleanup 工作区 清理',
+    category: 'hygiene',
+  },
+  {
+    id: 'ops-workflow:daily-memory-conflict-check',
+    name: 'hermit:daily-memory-conflict-check',
+    command: '/hermit:daily-memory-conflict-check',
+    insertText:
+      'hermit:daily-memory-conflict-check 检查 CLAUDE、AGENTS、memory、settings 的重复或冲突指令',
+    description: '检查记忆/配置/指令冲突',
+    searchText:
+      'daily memory conflict hermit claude agents settings duplicate instructions 记忆 冲突',
+    category: 'hygiene',
+  },
+  {
+    id: 'ops-workflow:daily-workflow-extraction',
+    name: 'hermit:daily-workflow-extraction',
+    command: '/hermit:daily-workflow-extraction',
+    insertText:
+      'hermit:daily-workflow-extraction 从近期工作中提炼可复用 workflow、prompt 和自动化建议',
+    description: '提炼可复用 workflow/prompt',
+    searchText: 'daily workflow extraction hermit reusable prompt automation 提炼 复用 自动化',
+    category: 'workflow',
+  },
+  {
+    id: 'ops-workflow:worktree-scan',
+    name: 'hermit:worktree-scan',
+    command: '/hermit:worktree-scan',
+    insertText: 'hermit:worktree-scan 只读检查脏 worktree、陈旧分支和需要用户确认的清理项',
+    description: '只读检查 worktree/分支清理风险',
+    searchText: 'worktree scan hermit dirty stale branch cleanup readonly worktree 分支 清理',
+    category: 'diagnostic',
+  },
+];
+
+export function getLoopCommandShortcuts(): LoopCommandShortcut[] {
+  return LOOP_COMMAND_SHORTCUTS;
+}
+
+export function getLoopShortcutMentionSuggestions(): MentionSuggestion[] {
+  return LOOP_COMMAND_SHORTCUTS.map((shortcut) => ({
+    id: shortcut.id,
+    name: shortcut.name,
+    type: 'command',
+    command: shortcut.command,
+    insertText: shortcut.insertText,
+    description: shortcut.description,
+    subtitle: shortcut.description,
+    searchText: `${shortcut.searchText} ${shortcut.category}`,
+  }));
+}
+
+export function getLoopShortcutSuggestions(): MentionSuggestion[] {
+  return getLoopShortcutMentionSuggestions();
+}

package/src/renderer/utils/mentionSuggestions.ts

@@ -8,7 +8,7 @@ export function getSuggestionTriggerChar(suggestion: MentionSuggestion): '@' | '
 
 export function getSuggestionInsertionText(suggestion: MentionSuggestion): string {
   if (suggestion.type === 'command' || suggestion.type === 'skill') {
-    return suggestion.command?.slice(1) ?? suggestion.insertText ?? suggestion.name;
+    return suggestion.insertText ?? suggestion.command?.slice(1) ?? suggestion.name;
   }
   return suggestion.insertText ?? suggestion.name;
 }