@yancyyu/openhermit 1.5.8

package/src/shared/utils/contextMetrics.ts

@@ -0,0 +1,236 @@
+import { inferTeamProviderIdFromModel } from './teamProvider';
+
+import type { TeamProviderId } from '@shared/types/team';
+
+const ANTHROPIC_DEFAULT_CONTEXT_WINDOW = 200_000;
+const ANTHROPIC_EXTENDED_CONTEXT_WINDOW = 1_000_000;
+const OPENAI_COMPACT_CONTEXT_WINDOW = 200_000;
+const OPENAI_DEFAULT_CONTEXT_WINDOW = 400_000;
+const OPENAI_LONG_CONTEXT_WINDOW = 1_050_000;
+
+export interface ContextUsageLike {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+  input_tokens_details?: {
+    cached_tokens?: number;
+  };
+  prompt_tokens_details?: {
+    cached_tokens?: number;
+  };
+  output_tokens_details?: {
+    reasoning_tokens?: number;
+  };
+  completion_tokens_details?: {
+    reasoning_tokens?: number;
+  };
+}
+
+export type PromptInputSource =
+  | 'anthropic_usage'
+  | 'openai_responses_usage'
+  | 'openai_chat_usage'
+  | 'unavailable';
+
+export interface DerivedContextMetrics {
+  providerId: TeamProviderId | undefined;
+  modelName: string | undefined;
+  contextWindowTokens: number | null;
+  promptInputTokens: number | null;
+  outputTokens: number | null;
+  contextUsedTokens: number | null;
+  visibleContextTokens: number;
+  promptInputSource: PromptInputSource;
+  contextUsedSource: PromptInputSource | 'unavailable';
+  promptInputPercentOfContextWindow: number | null;
+  contextUsedPercentOfContextWindow: number | null;
+  visibleContextPercentOfPromptInput: number | null;
+}
+
+interface InferContextWindowTokensParams {
+  providerId?: TeamProviderId;
+  modelName?: string;
+  limitContext?: boolean;
+}
+
+interface DeriveContextMetricsParams extends InferContextWindowTokensParams {
+  usage?: ContextUsageLike | null;
+  contextWindowTokens?: number | null;
+  visibleContextTokens?: number;
+}
+
+function readFiniteNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function readPositiveNumber(value: unknown): number | null {
+  const num = readFiniteNumber(value);
+  return num !== null && num > 0 ? num : null;
+}
+
+function computePercent(tokens: number | null, totalTokens: number | null): number | null {
+  if (tokens === null || totalTokens === null || totalTokens <= 0) {
+    return null;
+  }
+  if (!Number.isFinite(tokens) || tokens <= 0) {
+    return 0;
+  }
+  return Math.min((tokens / totalTokens) * 100, 100);
+}
+
+function isOpenAiLongContextModel(modelName: string | undefined): boolean {
+  const normalized = modelName?.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  return (
+    normalized === 'gpt-5.4' ||
+    normalized.startsWith('gpt-5.4-202') ||
+    normalized === 'gpt-5.4-pro' ||
+    normalized.startsWith('gpt-5.4-pro-202')
+  );
+}
+
+function isOpenAiCompactContextModel(modelName: string | undefined): boolean {
+  const normalized = modelName?.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  return normalized === 'codex-mini-latest' || normalized.startsWith('codex-mini-latest-');
+}
+
+function isAnthropicNativeLongContextModel(modelName: string | undefined): boolean {
+  const normalized = modelName?.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  return (
+    normalized.startsWith('claude-opus-4-7') ||
+    normalized.startsWith('claude-opus-4-6') ||
+    normalized.startsWith('claude-sonnet-4-6') ||
+    normalized.startsWith('claude-mythos')
+  );
+}
+
+function hasOpenAiPromptDetails(usage: ContextUsageLike): boolean {
+  return (
+    readFiniteNumber(usage.input_tokens_details?.cached_tokens) !== null ||
+    readFiniteNumber(usage.prompt_tokens_details?.cached_tokens) !== null
+  );
+}
+
+export function inferContextWindowTokens({
+  providerId,
+  modelName,
+  limitContext,
+}: InferContextWindowTokensParams): number | null {
+  const resolvedProviderId = providerId ?? inferTeamProviderIdFromModel(modelName);
+  const normalizedModel = modelName?.trim().toLowerCase();
+
+  if (resolvedProviderId === 'anthropic') {
+    if (limitContext) {
+      return ANTHROPIC_DEFAULT_CONTEXT_WINDOW;
+    }
+    if (normalizedModel?.includes('[1m]') || isAnthropicNativeLongContextModel(normalizedModel)) {
+      return ANTHROPIC_EXTENDED_CONTEXT_WINDOW;
+    }
+    return ANTHROPIC_DEFAULT_CONTEXT_WINDOW;
+  }
+
+  if (resolvedProviderId === 'codex') {
+    if (isOpenAiCompactContextModel(normalizedModel)) {
+      return OPENAI_COMPACT_CONTEXT_WINDOW;
+    }
+    return isOpenAiLongContextModel(normalizedModel)
+      ? OPENAI_LONG_CONTEXT_WINDOW
+      : OPENAI_DEFAULT_CONTEXT_WINDOW;
+  }
+
+  return null;
+}
+
+export function deriveContextMetrics({
+  usage,
+  providerId,
+  modelName,
+  contextWindowTokens,
+  visibleContextTokens = 0,
+  limitContext,
+}: DeriveContextMetricsParams): DerivedContextMetrics {
+  const resolvedProviderId = providerId ?? inferTeamProviderIdFromModel(modelName);
+  const resolvedContextWindowTokens =
+    readPositiveNumber(contextWindowTokens) ??
+    inferContextWindowTokens({
+      providerId: resolvedProviderId,
+      modelName,
+      limitContext,
+    });
+  const safeVisibleContextTokens =
+    Number.isFinite(visibleContextTokens) && visibleContextTokens > 0 ? visibleContextTokens : 0;
+  const safeUsage = usage ?? {};
+  const outputTokens =
+    readFiniteNumber(safeUsage.output_tokens) ?? readFiniteNumber(safeUsage.completion_tokens);
+  const promptTokens = readFiniteNumber(safeUsage.prompt_tokens);
+  const inputTokens = readFiniteNumber(safeUsage.input_tokens);
+  const cacheReadTokens = readFiniteNumber(safeUsage.cache_read_input_tokens) ?? 0;
+  const cacheCreationTokens = readFiniteNumber(safeUsage.cache_creation_input_tokens) ?? 0;
+
+  let promptInputTokens: number | null = null;
+  let promptInputSource: PromptInputSource = 'unavailable';
+
+  if (promptTokens !== null) {
+    promptInputTokens = promptTokens;
+    promptInputSource = 'openai_chat_usage';
+  } else if (inputTokens !== null) {
+    const shouldUseAnthropicFormula =
+      resolvedProviderId === 'anthropic' || cacheReadTokens > 0 || cacheCreationTokens > 0;
+
+    if (shouldUseAnthropicFormula) {
+      promptInputTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
+      promptInputSource = 'anthropic_usage';
+    } else {
+      const missingOpenAiPromptTelemetry =
+        resolvedProviderId === 'codex' &&
+        inputTokens === 0 &&
+        cacheReadTokens === 0 &&
+        cacheCreationTokens === 0 &&
+        !hasOpenAiPromptDetails(safeUsage);
+
+      if (!missingOpenAiPromptTelemetry) {
+        promptInputTokens = inputTokens;
+        promptInputSource = 'openai_responses_usage';
+      }
+    }
+  }
+
+  const contextUsedTokens =
+    promptInputTokens !== null && outputTokens !== null ? promptInputTokens + outputTokens : null;
+
+  return {
+    providerId: resolvedProviderId,
+    modelName,
+    contextWindowTokens: resolvedContextWindowTokens,
+    promptInputTokens,
+    outputTokens,
+    contextUsedTokens,
+    visibleContextTokens: safeVisibleContextTokens,
+    promptInputSource,
+    contextUsedSource: contextUsedTokens !== null ? promptInputSource : 'unavailable',
+    promptInputPercentOfContextWindow: computePercent(
+      promptInputTokens,
+      resolvedContextWindowTokens
+    ),
+    contextUsedPercentOfContextWindow: computePercent(
+      contextUsedTokens,
+      resolvedContextWindowTokens
+    ),
+    visibleContextPercentOfPromptInput: computePercent(safeVisibleContextTokens, promptInputTokens),
+  };
+}

package/src/shared/utils/costFormatting.ts

@@ -0,0 +1,45 @@
+/**
+ * Cost formatting utilities
+ */
+
+/**
+ * Format USD cost with appropriate precision
+ * - $0.001 or more: 2 decimal places ($1.23)
+ * - Less than $0.001: 3-4 decimal places for precision ($0.0012)
+ * - Zero: $0.00
+ */
+export function formatCostUsd(cost: number): string {
+  if (cost === 0) {
+    return '$0.00';
+  }
+
+  if (cost >= 0.01) {
+    // Standard currency format for amounts >= 1 cent
+    return `$${cost.toFixed(2)}`;
+  } else if (cost >= 0.001) {
+    // 3 decimal places for sub-cent amounts
+    return `$${cost.toFixed(3)}`;
+  } else {
+    // 4 decimal places for very small amounts
+    return `$${cost.toFixed(4)}`;
+  }
+}
+
+/**
+ * Format cost compactly for display in badges
+ * - Rounds to 2 decimal places
+ * - Omits $ prefix for brevity
+ */
+export function formatCostCompact(cost: number): string {
+  if (cost === 0) {
+    return '0.00';
+  }
+
+  if (cost >= 0.01) {
+    return cost.toFixed(2);
+  } else if (cost >= 0.001) {
+    return cost.toFixed(3);
+  } else {
+    return cost.toFixed(4);
+  }
+}

package/src/shared/utils/diffContextHash.ts

@@ -0,0 +1,22 @@
+/**
+ * Computes a stable, lightweight hash for diff context matching.
+ *
+ * This is intentionally NON-cryptographic and designed for:
+ * - matching hunks/snippets across processes
+ * - tolerating small differences by using head/tail windows
+ */
+export function computeDiffContextHash(oldString: string, newString: string): string {
+  const take3 = (s: string): string => {
+    const lines = s.split('\n');
+    const head = lines.slice(0, 3).join('\n');
+    const tail = lines.length > 3 ? lines.slice(-3).join('\n') : '';
+    return `${head}|${tail}`;
+  };
+  const raw = `${take3(oldString)}::${take3(newString)}`;
+  // DJB2 variant
+  let hash = 5381;
+  for (let i = 0; i < raw.length; i++) {
+    hash = ((hash << 5) + hash + raw.charCodeAt(i)) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}

package/src/shared/utils/effortLevels.ts

@@ -0,0 +1,73 @@
+import type { EffortLevel, TeamProviderId } from '@shared/types/team';
+
+export const TEAM_EFFORT_LEVELS = [
+  'none',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+] as const satisfies readonly EffortLevel[];
+
+export const LEGACY_TEAM_EFFORT_LEVELS = [
+  'low',
+  'medium',
+  'high',
+] as const satisfies readonly EffortLevel[];
+
+export const CODEX_TEAM_EFFORT_LEVELS = [
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+] as const satisfies readonly EffortLevel[];
+
+export const ANTHROPIC_TEAM_EFFORT_LEVELS = [
+  'low',
+  'medium',
+  'high',
+  'max',
+] as const satisfies readonly EffortLevel[];
+
+const LEGACY_TEAM_EFFORT_LEVEL_SET = new Set<EffortLevel>(LEGACY_TEAM_EFFORT_LEVELS);
+const CODEX_TEAM_EFFORT_LEVEL_SET = new Set<EffortLevel>(CODEX_TEAM_EFFORT_LEVELS);
+const ANTHROPIC_TEAM_EFFORT_LEVEL_SET = new Set<EffortLevel>(ANTHROPIC_TEAM_EFFORT_LEVELS);
+
+export function isTeamEffortLevel(value: unknown): value is EffortLevel {
+  return typeof value === 'string' && TEAM_EFFORT_LEVELS.includes(value as EffortLevel);
+}
+
+export function formatEffortLevelList(): string {
+  return TEAM_EFFORT_LEVELS.join(', ');
+}
+
+export function isTeamEffortLevelForProvider(
+  value: unknown,
+  providerId?: TeamProviderId | null
+): value is EffortLevel {
+  if (!isTeamEffortLevel(value)) {
+    return false;
+  }
+
+  if (providerId === 'codex') {
+    return CODEX_TEAM_EFFORT_LEVEL_SET.has(value);
+  }
+
+  if (providerId === 'anthropic') {
+    return ANTHROPIC_TEAM_EFFORT_LEVEL_SET.has(value);
+  }
+
+  return LEGACY_TEAM_EFFORT_LEVEL_SET.has(value);
+}
+
+export function formatEffortLevelListForProvider(providerId?: TeamProviderId | null): string {
+  if (providerId === 'codex') {
+    return CODEX_TEAM_EFFORT_LEVELS.join(', ');
+  }
+  if (providerId === 'anthropic') {
+    return ANTHROPIC_TEAM_EFFORT_LEVELS.join(', ');
+  }
+  return LEGACY_TEAM_EFFORT_LEVELS.join(', ');
+}

package/src/shared/utils/ephemeralProjectPath.ts

@@ -0,0 +1,41 @@
+const TMP_SEGMENT = 'tmp';
+const POSIX_TMP_ROOT = `/${TMP_SEGMENT}/`;
+const PRIVATE_TMP_ROOT = `/private/${TMP_SEGMENT}/`;
+
+function normalizePathForEphemeralCheck(projectPath: string): string {
+  return projectPath.trim().replace(/\\/g, '/').toLowerCase();
+}
+
+function getBasename(normalizedPath: string): string {
+  const segments = normalizedPath.split('/').filter(Boolean);
+  return segments[segments.length - 1] ?? '';
+}
+
+function isKnownTempRoot(normalizedPath: string): boolean {
+  return (
+    normalizedPath.startsWith('/private/var/folders/') ||
+    normalizedPath.startsWith('/var/folders/') ||
+    normalizedPath.startsWith(PRIVATE_TMP_ROOT) ||
+    normalizedPath.startsWith(POSIX_TMP_ROOT) ||
+    normalizedPath.includes('/appdata/local/temp/') ||
+    normalizedPath.includes('/appdata/locallow/temp/')
+  );
+}
+
+export function isEphemeralProjectPath(projectPath: string | null | undefined): boolean {
+  const normalizedPath = normalizePathForEphemeralCheck(projectPath ?? '');
+  if (!normalizedPath) {
+    return false;
+  }
+
+  if (
+    normalizedPath.includes('rendered_mcp_') ||
+    normalizedPath.includes('rendered_mcp_config') ||
+    normalizedPath.includes('/portable-mcp-live')
+  ) {
+    return true;
+  }
+
+  const basename = getBasename(normalizedPath);
+  return basename.startsWith('codex-agent-teams-appstyle-') && isKnownTempRoot(normalizedPath);
+}

package/src/shared/utils/errorHandling.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared error handling utilities.
+ *
+ * Provides type-safe error message extraction and formatting
+ * for use across both main and renderer processes.
+ */
+
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Handles Error instances, strings, and other types safely.
+ *
+ * @param error - The error value (could be Error, string, or unknown)
+ * @returns A string error message
+ */
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error && typeof error === 'object' && 'message' in error) {
+    return String((error as { message: unknown }).message);
+  }
+  return String(error);
+}