@yancyyu/openhermit 1.5.8

package/src/renderer/utils/syntaxHighlighter.ts

@@ -0,0 +1,158 @@
+/**
+ * Standalone syntax highlighter using highlight.js.
+ *
+ * Highlights code without a full CodeMirror EditorView.
+ * Outputs HTML strings with `hljs-*` CSS classes (already styled in index.css).
+ */
+
+import hljs from 'highlight.js';
+
+// =============================================================================
+// File extension → highlight.js language mapping
+// =============================================================================
+
+const EXT_TO_LANG: Record<string, string> = {
+  '.js': 'javascript',
+  '.mjs': 'javascript',
+  '.cjs': 'javascript',
+  '.jsx': 'javascript',
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.java': 'java',
+  '.kt': 'kotlin',
+  '.swift': 'swift',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.cc': 'cpp',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.sh': 'bash',
+  '.bash': 'bash',
+  '.zsh': 'bash',
+  '.json': 'json',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.xml': 'xml',
+  '.html': 'xml',
+  '.htm': 'xml',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.less': 'less',
+  '.sql': 'sql',
+  '.md': 'markdown',
+  '.toml': 'ini',
+  '.ini': 'ini',
+  '.lua': 'lua',
+  '.r': 'r',
+  '.scala': 'scala',
+  '.dart': 'dart',
+  '.ex': 'elixir',
+  '.exs': 'elixir',
+  '.erl': 'erlang',
+  '.hs': 'haskell',
+  '.pl': 'perl',
+  '.pm': 'perl',
+  '.m': 'objectivec',
+  '.mm': 'objectivec',
+  '.makefile': 'makefile',
+  '.cmake': 'cmake',
+  '.dockerfile': 'dockerfile',
+  '.tf': 'hcl',
+  '.proto': 'protobuf',
+  '.graphql': 'graphql',
+  '.gql': 'graphql',
+  '.vue': 'xml',
+  '.svelte': 'xml',
+};
+
+function getLanguage(fileName: string): string | undefined {
+  const dotIndex = fileName.lastIndexOf('.');
+  if (dotIndex === -1) return undefined;
+  const ext = fileName.slice(dotIndex).toLowerCase();
+
+  // Explicit map first, then try extension as hljs alias (e.g. 'rb', 'py')
+  const mapped = EXT_TO_LANG[ext];
+  if (mapped) return mapped;
+
+  const bare = ext.slice(1); // '.ts' → 'ts'
+  if (bare && hljs.getLanguage(bare)) return bare;
+
+  return undefined;
+}
+
+// =============================================================================
+// HTML line splitting
+// =============================================================================
+
+/** Escape HTML and split into plain-text lines (fallback for unknown languages). */
+function escapeAndSplit(code: string): string[] {
+  const escaped = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return escaped.split('\n');
+}
+
+/**
+ * Split highlight.js HTML output into per-line strings with balanced tags.
+ * Multi-line spans (comments, strings) are properly closed/reopened at line breaks.
+ */
+function splitHtmlByLines(html: string): string[] {
+  const rawLines = html.split('\n');
+  const result: string[] = [];
+  const openTags: string[] = [];
+
+  for (const rawLine of rawLines) {
+    // Prefix with any spans still open from previous lines
+    const prefix = openTags.join('');
+    const fullLine = prefix + rawLine;
+
+    // Update open tags stack by scanning this line's tags
+    const tagRegex = /<span[^>]*>|<\/span>/g;
+    let match;
+    while ((match = tagRegex.exec(rawLine)) !== null) {
+      if (match[0] === '</span>') {
+        if (openTags.length > 0) openTags.pop();
+      } else {
+        openTags.push(match[0]);
+      }
+    }
+
+    // Close any unclosed spans for this line
+    const suffix = '</span>'.repeat(openTags.length);
+    result.push(fullLine + suffix);
+  }
+
+  return result;
+}
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+/**
+ * Highlight code and return per-line HTML strings with `hljs-*` CSS classes.
+ * Uses highlight.js (same library as rehype-highlight in markdown rendering).
+ */
+export function highlightLines(code: string, fileName: string): string[] {
+  if (!code) return [''];
+
+  const lang = getLanguage(fileName);
+
+  let highlighted: string;
+  if (!lang) {
+    // Unknown extension — plain text is safer than unreliable auto-detection
+    return escapeAndSplit(code);
+  }
+
+  try {
+    highlighted = hljs.highlight(code, { language: lang }).value;
+  } catch {
+    return escapeAndSplit(code);
+  }
+
+  return splitHtmlByLines(highlighted);
+}

package/src/renderer/utils/tabLabelDisambiguation.ts

@@ -0,0 +1,99 @@
+/**
+ * Tab label disambiguation — adds suffix labels when multiple tabs share the same file name.
+ *
+ * Algorithm:
+ * 1. Group tabs by fileName
+ * 2. For groups with >1 tab, find the minimal unique path suffix
+ * 3. Format as "(parent/dir)" — e.g. "(main/utils)", "(renderer/hooks)"
+ * 4. Unique file names get no label (disambiguatedLabel = undefined)
+ */
+
+import { splitPath } from '@shared/utils/platformPath';
+
+import type { EditorFileTab } from '@shared/types/editor';
+
+/**
+ * Compute disambiguated labels for all tabs.
+ * Returns a new array with `disambiguatedLabel` set where needed.
+ */
+export function computeDisambiguatedTabs(tabs: EditorFileTab[]): EditorFileTab[] {
+  if (tabs.length === 0) return tabs;
+
+  // Single tab — just clear any stale label
+  if (tabs.length === 1) {
+    const tab = tabs[0];
+    if (tab.disambiguatedLabel === undefined) return tabs;
+    return [{ ...tab, disambiguatedLabel: undefined }];
+  }
+
+  // Group tabs by fileName
+  const groups = new Map<string, EditorFileTab[]>();
+  for (const tab of tabs) {
+    const existing = groups.get(tab.fileName);
+    if (existing) {
+      existing.push(tab);
+    } else {
+      groups.set(tab.fileName, [tab]);
+    }
+  }
+
+  // Build a map of tabId → disambiguatedLabel
+  const labels = new Map<string, string | undefined>();
+
+  for (const [, group] of groups) {
+    if (group.length <= 1) {
+      // Unique name — no label needed
+      for (const tab of group) {
+        labels.set(tab.id, undefined);
+      }
+      continue;
+    }
+
+    // Split paths into segments for comparison
+    const pathSegments = group.map((tab) => {
+      const parts = splitPath(tab.filePath);
+      // Remove the file name (last segment)
+      parts.pop();
+      return parts;
+    });
+
+    // Find minimal unique suffix depth
+    // Start from depth=1 (immediate parent) and go deeper until all labels are unique
+    let depth = 1;
+    const maxDepth = Math.max(...pathSegments.map((s) => s.length));
+
+    while (depth <= maxDepth) {
+      const suffixes = pathSegments.map((parts) => {
+        const start = Math.max(0, parts.length - depth);
+        return parts.slice(start).join('/');
+      });
+
+      // Check if all suffixes are unique
+      const unique = new Set(suffixes);
+      if (unique.size === suffixes.length) {
+        // All unique — assign labels
+        for (let i = 0; i < group.length; i++) {
+          labels.set(group[i].id, `(${suffixes[i]})`);
+        }
+        break;
+      }
+      depth++;
+    }
+
+    // If we couldn't find unique suffixes (shouldn't happen with different file paths),
+    // use full parent path
+    if (depth > maxDepth) {
+      for (let i = 0; i < group.length; i++) {
+        const fullParent = pathSegments[i].join('/');
+        labels.set(group[i].id, `(${fullParent})`);
+      }
+    }
+  }
+
+  // Apply labels to tabs
+  return tabs.map((tab) => {
+    const label = labels.get(tab.id);
+    if (label === tab.disambiguatedLabel) return tab;
+    return { ...tab, disambiguatedLabel: label };
+  });
+}

package/src/renderer/utils/taskChangePresence.ts

@@ -0,0 +1,19 @@
+export { resolveTaskChangePresenceFromResult } from '@shared/utils/taskChangePresence';
+
+import type { TaskChangeSetV2 } from '@shared/types';
+
+export function shouldBackgroundRevalidateTaskPresence(
+  data: TaskChangeSetV2,
+  sessionStartedAtMs: number
+): boolean {
+  if (data.provenance?.sourceKind === 'ledger' && !!data.provenance.sourceFingerprint) {
+    return false;
+  }
+
+  const computedAtMs = Date.parse(data.computedAt);
+  if (!Number.isFinite(computedAtMs)) {
+    return true;
+  }
+
+  return computedAtMs < sessionStartedAtMs;
+}

package/src/renderer/utils/taskChangeRequest.ts

@@ -0,0 +1,122 @@
+import { deriveTaskSince as deriveSharedTaskSince } from '@shared/utils/taskChangeSince';
+import {
+  getTaskChangeStateBucket,
+  isTaskChangeSummaryCacheable,
+  type TaskChangeStateBucket,
+} from '@shared/utils/taskChangeState';
+
+import type { ReviewAPI } from '@shared/types/api';
+import type { TeamTaskWithKanban } from '@shared/types/team';
+
+export type TaskChangeRequestOptions = NonNullable<Parameters<ReviewAPI['getTaskChanges']>[2]>;
+
+export interface TaskChangeContext {
+  taskId: string;
+  requestOptions: TaskChangeRequestOptions;
+  initialFilePath?: string;
+}
+
+type TaskChangeTaskLike = Pick<
+  TeamTaskWithKanban,
+  | 'id'
+  | 'owner'
+  | 'status'
+  | 'createdAt'
+  | 'updatedAt'
+  | 'workIntervals'
+  | 'historyEvents'
+  | 'reviewState'
+  | 'kanbanColumn'
+>;
+
+export function deriveTaskSince(task: TaskChangeTaskLike | null): string | undefined {
+  return deriveSharedTaskSince(task);
+}
+
+export function buildTaskChangeRequestOptions(
+  task: TaskChangeTaskLike,
+  overrides?: Partial<TaskChangeRequestOptions>
+): TaskChangeRequestOptions {
+  const options: TaskChangeRequestOptions = {
+    owner: task.owner,
+    status: task.status,
+    intervals: task.workIntervals,
+    since: deriveTaskSince(task),
+    stateBucket: getTaskChangeStateBucket(task),
+  };
+
+  return {
+    ...options,
+    ...overrides,
+  };
+}
+
+export function buildTaskChangeContext(
+  task: TaskChangeTaskLike,
+  input?: { initialFilePath?: string; summaryOnly?: boolean }
+): TaskChangeContext {
+  return {
+    taskId: task.id,
+    requestOptions: buildTaskChangeRequestOptions(task, {
+      summaryOnly: input?.summaryOnly,
+    }),
+    initialFilePath: input?.initialFilePath,
+  };
+}
+
+export function buildTaskChangeSignature(options: TaskChangeRequestOptions): string {
+  const owner = typeof options.owner === 'string' ? options.owner.trim() : '';
+  const status = typeof options.status === 'string' ? options.status.trim() : '';
+  const since = typeof options.since === 'string' ? options.since : '';
+  const stateBucket = typeof options.stateBucket === 'string' ? options.stateBucket : 'active';
+  const intervals = Array.isArray(options.intervals)
+    ? options.intervals.map((interval) => ({
+        startedAt: interval.startedAt,
+        completedAt: interval.completedAt ?? '',
+      }))
+    : [];
+
+  return JSON.stringify({
+    owner,
+    status,
+    since,
+    stateBucket,
+    intervals,
+  });
+}
+
+export function buildTaskChangePresenceKey(
+  teamName: string,
+  taskId: string,
+  options: TaskChangeRequestOptions
+): string {
+  return `${teamName}:${taskId}:${buildTaskChangeSignature(options)}`;
+}
+
+export function getTaskChangeStateBucketFromOptions(
+  options: TaskChangeRequestOptions | null | undefined
+): TaskChangeStateBucket {
+  switch (options?.stateBucket) {
+    case 'approved':
+    case 'review':
+    case 'completed':
+      return options.stateBucket;
+    default:
+      return 'active';
+  }
+}
+
+export function isTaskSummaryCacheableForOptions(
+  options: TaskChangeRequestOptions | null | undefined
+): boolean {
+  return isTaskChangeSummaryCacheable(getTaskChangeStateBucketFromOptions(options));
+}
+
+export function canDisplayTaskChangesForOptions(
+  options: TaskChangeRequestOptions | null | undefined
+): boolean {
+  const bucket = getTaskChangeStateBucketFromOptions(options);
+  if (bucket !== 'active') return true;
+  // 'active' bucket includes both pending and in_progress — show for in_progress only
+  return options?.status === 'in_progress';
+}

package/src/renderer/utils/taskCommentPendingReply.ts

@@ -0,0 +1,74 @@
+import type { TaskComment } from '@shared/types';
+
+export interface AwaitingReplyResult {
+  /** Whether the user is awaiting a reply from task responders. */
+  isAwaiting: boolean;
+  /** Names of responders who haven't replied yet. */
+  awaitingFrom: string[];
+  /** Timestamp (ms) of the last user comment that triggered the awaiting state. */
+  userCommentAtMs: number;
+}
+
+const NO_AWAITING: AwaitingReplyResult = {
+  isAwaiting: false,
+  awaitingFrom: [],
+  userCommentAtMs: 0,
+};
+
+/**
+ * Determines whether the human user is awaiting a reply on task comments.
+ *
+ * Logic:
+ * 1. Find the latest comment authored by "user".
+ * 2. Collect the set of expected responders (task owner + task creator), deduplicated.
+ * 3. If ANY responder posted a comment AFTER the user's latest comment → not awaiting.
+ *    Any comment type counts as a response (regular, review_approved, review_request).
+ * 4. If NO responder has replied → isAwaiting = true, awaitingFrom lists all responders.
+ *
+ * Edge cases:
+ * - No user comments → not awaiting.
+ * - owner/createdBy are undefined or empty → not awaiting (no one to wait for).
+ * - owner === createdBy → single responder.
+ * - User posted multiple comments in a row → still awaiting (based on latest user comment).
+ */
+export function computeAwaitingReply(
+  comments: TaskComment[] | undefined,
+  taskOwner: string | undefined,
+  taskCreatedBy: string | undefined
+): AwaitingReplyResult {
+  if (!comments || comments.length === 0) return NO_AWAITING;
+
+  // Build responder set (deduplicated, non-empty, non-"user")
+  const responders = new Set<string>();
+  if (taskOwner && taskOwner !== 'user') responders.add(taskOwner);
+  if (taskCreatedBy && taskCreatedBy !== 'user') responders.add(taskCreatedBy);
+  if (responders.size === 0) return NO_AWAITING;
+
+  // Find the latest "user" comment by createdAt
+  let latestUserCommentMs = 0;
+  for (const comment of comments) {
+    if (comment.author !== 'user') continue;
+    const ts = Date.parse(comment.createdAt);
+    if (Number.isFinite(ts) && ts > latestUserCommentMs) {
+      latestUserCommentMs = ts;
+    }
+  }
+  if (latestUserCommentMs === 0) return NO_AWAITING;
+
+  // Check if ANY responder has replied after the user's comment.
+  // The indicator hides as soon as at least one responder (owner OR lead) replies.
+  for (const responder of responders) {
+    const hasReplied = comments.some((c) => {
+      if (c.author !== responder) return false;
+      const ts = Date.parse(c.createdAt);
+      return Number.isFinite(ts) && ts > latestUserCommentMs;
+    });
+    if (hasReplied) return NO_AWAITING;
+  }
+
+  return {
+    isAwaiting: true,
+    awaitingFrom: Array.from(responders),
+    userCommentAtMs: latestUserCommentMs,
+  };
+}

package/src/renderer/utils/taskGrouping.ts

@@ -0,0 +1,151 @@
+import { normalizePath } from '@renderer/utils/pathNormalize';
+import { splitPath } from '@shared/utils/platformPath';
+import { differenceInDays, isToday, isYesterday } from 'date-fns';
+
+import { DATE_CATEGORY_ORDER } from '../types/tabs';
+
+import type { DateCategory } from '../types/tabs';
+import type { GlobalTask } from '@shared/types';
+
+export type DateGroupedTasks = Record<DateCategory, GlobalTask[]>;
+
+export interface ProjectTaskGroup {
+  projectKey: string;
+  projectLabel: string;
+  tasks: GlobalTask[];
+}
+
+/** Returns updatedAt if available, otherwise createdAt. */
+function getEffectiveDate(task: GlobalTask): string | undefined {
+  return task.updatedAt ?? task.createdAt;
+}
+
+function getEffectiveTs(task: GlobalTask): number {
+  const d = getEffectiveDate(task);
+  return d ? new Date(d).getTime() : 0;
+}
+
+/**
+ * Build a map: teamName → max effective timestamp among its tasks.
+ * Used to sort team sub-groups by most recent activity (not alphabetically).
+ */
+function buildTeamMaxTs(tasks: GlobalTask[]): Map<string, number> {
+  const m = new Map<string, number>();
+  for (const t of tasks) {
+    const ts = getEffectiveTs(t);
+    const cur = m.get(t.teamName) ?? 0;
+    if (ts > cur) m.set(t.teamName, ts);
+  }
+  return m;
+}
+
+/**
+ * Sort comparator: teams ordered by most recent task (desc),
+ * within the same team — by individual task date (desc).
+ */
+function compareByTeamFreshness(
+  a: GlobalTask,
+  b: GlobalTask,
+  teamMaxTs: Map<string, number>
+): number {
+  if (a.teamName !== b.teamName) {
+    const teamTsA = teamMaxTs.get(a.teamName) ?? 0;
+    const teamTsB = teamMaxTs.get(b.teamName) ?? 0;
+    return teamTsB - teamTsA;
+  }
+  return getEffectiveTs(b) - getEffectiveTs(a);
+}
+
+function getDateCategory(dateStr: string | undefined): DateCategory {
+  if (!dateStr) return 'Older';
+  const d = new Date(dateStr);
+  if (isNaN(d.getTime())) return 'Older';
+  if (isToday(d)) return 'Today';
+  if (isYesterday(d)) return 'Yesterday';
+  if (differenceInDays(new Date(), d) <= 7) return 'Previous 7 Days';
+  return 'Older';
+}
+
+export function groupTasksByDate(tasks: GlobalTask[]): DateGroupedTasks {
+  const groups: DateGroupedTasks = {
+    Today: [],
+    Yesterday: [],
+    'Previous 7 Days': [],
+    Older: [],
+  };
+
+  for (const task of tasks) {
+    const cat = getDateCategory(getEffectiveDate(task));
+    groups[cat].push(task);
+  }
+
+  for (const cat of DATE_CATEGORY_ORDER) {
+    const teamTs = buildTeamMaxTs(groups[cat]);
+    groups[cat].sort((a, b) => compareByTeamFreshness(a, b, teamTs));
+  }
+
+  return groups;
+}
+
+export function getNonEmptyTaskCategories(groups: DateGroupedTasks): DateCategory[] {
+  return DATE_CATEGORY_ORDER.filter((cat) => groups[cat].length > 0);
+}
+
+export const NO_PROJECT_KEY = '__no_project__';
+export const NO_PROJECT_LABEL = 'No project';
+
+function trimTrailingPathSep(p: string): string {
+  let s = p;
+  while (s.length > 0 && (s.endsWith('/') || s.endsWith('\\'))) s = s.slice(0, -1);
+  return s;
+}
+
+export function projectLabelFromPath(path: string): string {
+  const normalized = trimTrailingPathSep(path);
+  const segments = splitPath(normalized);
+  return segments.length > 0 ? segments[segments.length - 1] : path || NO_PROJECT_LABEL;
+}
+
+/**
+ * Flat sort: newest (by updatedAt/createdAt) first, no grouping.
+ * Within the same team, tasks are ordered by freshness.
+ * Teams with more recent activity appear first.
+ */
+export function sortTasksByFreshness(tasks: GlobalTask[]): GlobalTask[] {
+  const teamTs = buildTeamMaxTs(tasks);
+  return [...tasks].sort((a, b) => compareByTeamFreshness(a, b, teamTs));
+}
+
+export function groupTasksByProject(tasks: GlobalTask[]): ProjectTaskGroup[] {
+  const byKey = new Map<string, { path: string; tasks: GlobalTask[] }>();
+
+  for (const task of tasks) {
+    const path = task.projectPath?.trim() ?? '';
+    const key = path ? normalizePath(trimTrailingPathSep(path)) : NO_PROJECT_KEY;
+    let entry = byKey.get(key);
+    if (!entry) {
+      entry = { path: path || '', tasks: [] };
+      byKey.set(key, entry);
+    }
+    entry.tasks.push(task);
+  }
+
+  for (const entry of byKey.values()) {
+    const teamTs = buildTeamMaxTs(entry.tasks);
+    entry.tasks.sort((a, b) => compareByTeamFreshness(a, b, teamTs));
+  }
+
+  const groups: ProjectTaskGroup[] = [];
+  for (const [key, { path, tasks: list }] of byKey) {
+    const projectLabel = key === NO_PROJECT_KEY ? NO_PROJECT_LABEL : projectLabelFromPath(path);
+    groups.push({ projectKey: key, projectLabel, tasks: list });
+  }
+
+  groups.sort((a, b) => {
+    const tsA = Math.max(...a.tasks.map(getEffectiveTs));
+    const tsB = Math.max(...b.tasks.map(getEffectiveTs));
+    return tsB - tsA;
+  });
+
+  return groups;
+}