github-issue-tower-defence-management 1.89.0 → 1.91.0

package/src/adapter/entry-points/console/ui/src/features/console/lib/markdown.ts

@@ -0,0 +1,73 @@
+import DOMPurify from 'dompurify';
+import { marked } from 'marked';
+
+export const renderMarkdownToSafeHtml = (source: string): string => {
+  const trimmed = source.trim();
+  if (trimmed === '') {
+    return '';
+  }
+  marked.setOptions({ gfm: true, breaks: true });
+  const parsed = marked.parse(source, { async: false });
+  const rawHtml = typeof parsed === 'string' ? parsed : '';
+  return DOMPurify.sanitize(rawHtml);
+};
+
+export type ConsoleMarkdownSegment =
+  | { kind: 'markdown'; key: string; source: string }
+  | { kind: 'mermaid'; key: string; code: string };
+
+const MERMAID_FENCE = /^```mermaid[^\n]*\n([\s\S]*?)\n```$/;
+
+export const splitMarkdownSegments = (
+  source: string,
+): ConsoleMarkdownSegment[] => {
+  const lines = source.split('\n');
+  const segments: ConsoleMarkdownSegment[] = [];
+  let markdownBuffer: string[] = [];
+  let mermaidBuffer: string[] | null = null;
+  let sequence = 0;
+
+  const flushMarkdown = (): void => {
+    if (markdownBuffer.length > 0) {
+      segments.push({
+        kind: 'markdown',
+        key: `markdown:${sequence}`,
+        source: markdownBuffer.join('\n'),
+      });
+      sequence += 1;
+      markdownBuffer = [];
+    }
+  };
+
+  for (const line of lines) {
+    if (mermaidBuffer === null && /^```mermaid\s*$/.test(line.trim())) {
+      flushMarkdown();
+      mermaidBuffer = [];
+      continue;
+    }
+    if (mermaidBuffer !== null) {
+      if (line.trim() === '```') {
+        segments.push({
+          kind: 'mermaid',
+          key: `mermaid:${sequence}`,
+          code: mermaidBuffer.join('\n'),
+        });
+        sequence += 1;
+        mermaidBuffer = null;
+        continue;
+      }
+      mermaidBuffer.push(line);
+      continue;
+    }
+    markdownBuffer.push(line);
+  }
+
+  if (mermaidBuffer !== null) {
+    markdownBuffer.push('```mermaid', ...mermaidBuffer);
+  }
+  flushMarkdown();
+  return segments;
+};
+
+export const hasMermaidFence = (source: string): boolean =>
+  /```mermaid\s*\n/.test(source) || MERMAID_FENCE.test(source.trim());

package/src/adapter/entry-points/console/ui/src/features/console/lib/mermaidLoader.test.ts

@@ -0,0 +1,27 @@
+import { renderMermaidToSvg } from './mermaidLoader';
+
+const initialize = jest.fn();
+const render = jest.fn(async () => ({
+  svg: '<svg><script>alert(1)</script><g></g></svg>',
+}));
+
+describe('renderMermaidToSvg', () => {
+  beforeEach(() => {
+    initialize.mockClear();
+    render.mockClear();
+    (window as unknown as { mermaid: unknown }).mermaid = {
+      initialize,
+      render,
+    };
+  });
+
+  it('initializes mermaid once and returns sanitized svg without scripts', async () => {
+    const first = await renderMermaidToSvg('graph TD; A-->B;');
+    const second = await renderMermaidToSvg('graph TD; C-->D;');
+    expect(initialize).toHaveBeenCalledTimes(1);
+    expect(render).toHaveBeenCalledTimes(2);
+    expect(first).not.toContain('<script>');
+    expect(first).toContain('<svg');
+    expect(second).not.toContain('alert(1)');
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/lib/mermaidLoader.ts

@@ -0,0 +1,71 @@
+import DOMPurify from 'dompurify';
+
+type MermaidModule = {
+  initialize: (config: Record<string, unknown>) => void;
+  render: (id: string, code: string) => Promise<{ svg: string }>;
+};
+
+declare global {
+  interface Window {
+    mermaid?: MermaidModule;
+  }
+}
+
+export const MERMAID_SCRIPT_URL =
+  'https://cdn.jsdelivr.net/npm/mermaid@10.9.6/dist/mermaid.min.js';
+
+let mermaidPromise: Promise<MermaidModule> | null = null;
+let renderSequence = 0;
+
+const initializeMermaid = (mermaid: MermaidModule): MermaidModule => {
+  mermaid.initialize({
+    startOnLoad: false,
+    securityLevel: 'strict',
+    theme: 'dark',
+    themeVariables: {
+      background: '#0d1117',
+      primaryColor: '#161b22',
+      primaryTextColor: '#e6edf3',
+      primaryBorderColor: '#30363d',
+      lineColor: '#8b949e',
+      fontSize: '14px',
+    },
+  });
+  return mermaid;
+};
+
+const loadMermaid = (): Promise<MermaidModule> => {
+  if (mermaidPromise !== null) {
+    return mermaidPromise;
+  }
+  if (window.mermaid !== undefined) {
+    mermaidPromise = Promise.resolve(initializeMermaid(window.mermaid));
+    return mermaidPromise;
+  }
+  mermaidPromise = new Promise<MermaidModule>((resolve, reject) => {
+    const script = document.createElement('script');
+    script.src = MERMAID_SCRIPT_URL;
+    script.async = true;
+    script.onload = () => {
+      if (window.mermaid === undefined) {
+        reject(new Error('mermaid failed to load'));
+        return;
+      }
+      resolve(initializeMermaid(window.mermaid));
+    };
+    script.onerror = () => reject(new Error('mermaid script failed to load'));
+    document.head.appendChild(script);
+  });
+  return mermaidPromise;
+};
+
+export const renderMermaidToSvg = async (code: string): Promise<string> => {
+  const mermaid = await loadMermaid();
+  renderSequence += 1;
+  const id = `console-mermaid-${renderSequence}`;
+  const { svg } = await mermaid.render(id, code);
+  return DOMPurify.sanitize(svg, {
+    USE_PROFILES: { svg: true, svgFilters: true },
+    ADD_TAGS: ['foreignObject'],
+  });
+};

package/src/adapter/entry-points/console/ui/src/features/console/lib/resourceCache.test.ts

@@ -0,0 +1,56 @@
+import { ResourceCache, runWithConcurrency } from './resourceCache';
+
+describe('ResourceCache', () => {
+  it('fetches once and caches the result', async () => {
+    const fetcher = jest.fn(async (url: string) => `value:${url}`);
+    const cache = new ResourceCache(fetcher);
+    expect(await cache.load('k', 'u')).toBe('value:u');
+    expect(await cache.load('k', 'u')).toBe('value:u');
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(cache.peek('k')).toBe('value:u');
+  });
+
+  it('de-duplicates concurrent in-flight requests', async () => {
+    let resolveFetch: (value: string) => void = () => {};
+    const fetcher = jest.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveFetch = resolve;
+        }),
+    );
+    const cache = new ResourceCache(fetcher);
+    const first = cache.load('k', 'u');
+    const second = cache.load('k', 'u');
+    resolveFetch('shared');
+    expect(await first).toBe('shared');
+    expect(await second).toBe('shared');
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('allows a retry after a failed fetch', async () => {
+    const fetcher = jest
+      .fn<Promise<string>, [string]>()
+      .mockRejectedValueOnce(new Error('boom'))
+      .mockResolvedValueOnce('ok');
+    const cache = new ResourceCache(fetcher);
+    await expect(cache.load('k', 'u')).rejects.toThrow('boom');
+    expect(await cache.load('k', 'u')).toBe('ok');
+    expect(fetcher).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('runWithConcurrency', () => {
+  it('never exceeds the concurrency limit', async () => {
+    let active = 0;
+    let maxActive = 0;
+    const makeTask = () => async () => {
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      active -= 1;
+    };
+    const tasks = Array.from({ length: 6 }, makeTask);
+    await runWithConcurrency(tasks, 2);
+    expect(maxActive).toBeLessThanOrEqual(2);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/lib/resourceCache.ts

@@ -0,0 +1,51 @@
+export type ResourceFetcher<T> = (url: string) => Promise<T>;
+
+export class ResourceCache<T> {
+  private readonly cache = new Map<string, T>();
+  private readonly inFlight = new Map<string, Promise<T>>();
+
+  constructor(private readonly fetcher: ResourceFetcher<T>) {}
+
+  peek = (key: string): T | undefined => this.cache.get(key);
+
+  has = (key: string): boolean => this.cache.has(key);
+
+  load = (key: string, url: string): Promise<T> => {
+    const cached = this.cache.get(key);
+    if (cached !== undefined) {
+      return Promise.resolve(cached);
+    }
+    const pending = this.inFlight.get(key);
+    if (pending !== undefined) {
+      return pending;
+    }
+    const promise = this.fetcher(url)
+      .then((value) => {
+        this.cache.set(key, value);
+        return value;
+      })
+      .finally(() => {
+        this.inFlight.delete(key);
+      });
+    this.inFlight.set(key, promise);
+    return promise;
+  };
+}
+
+export const runWithConcurrency = async (
+  tasks: (() => Promise<unknown>)[],
+  limit: number,
+): Promise<void> => {
+  let index = 0;
+  const workers = Array.from(
+    { length: Math.min(limit, tasks.length) },
+    async () => {
+      while (index < tasks.length) {
+        const current = tasks[index];
+        index += 1;
+        await current();
+      }
+    },
+  );
+  await Promise.all(workers);
+};

package/src/adapter/entry-points/console/ui/src/features/console/operations.test.ts

@@ -0,0 +1,37 @@
+import {
+  IN_TMUX_BY_HUMAN_NAME,
+  isTodoByHumanTab,
+  STATUS_BUTTON_NAMES,
+  TOTALLY_WRONG_COMMENT_BODY,
+  UNNECESSARY_COMMENT_BODY,
+} from './operations';
+
+describe('operation constants', () => {
+  it('defines the totally wrong comment body', () => {
+    expect(TOTALLY_WRONG_COMMENT_BODY).toBe('totally wrong');
+  });
+
+  it('defines the unnecessary comment body', () => {
+    expect(UNNECESSARY_COMMENT_BODY).toBe('This pull request is unnecessary.');
+  });
+
+  it('lists the status buttons left to right', () => {
+    expect(STATUS_BUTTON_NAMES).toEqual([
+      'In Tmux by agent',
+      'In Tmux by human',
+      'Todo by human',
+      'Awaiting Workspace',
+    ]);
+  });
+
+  it('names the in-tmux-by-human status', () => {
+    expect(IN_TMUX_BY_HUMAN_NAME).toBe('In Tmux by human');
+  });
+});
+
+describe('isTodoByHumanTab', () => {
+  it('is true only for the todo-by-human tab', () => {
+    expect(isTodoByHumanTab('todo-by-human')).toBe(true);
+    expect(isTodoByHumanTab('prs')).toBe(false);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/operations.ts

@@ -0,0 +1,35 @@
+import type { ConsoleFieldOption, ConsoleTabName } from './types';
+
+export const TOTALLY_WRONG_COMMENT_BODY = 'totally wrong';
+export const UNNECESSARY_COMMENT_BODY = 'This pull request is unnecessary.';
+
+export type ConsoleReviewAction =
+  | 'approve'
+  | 'request_changes'
+  | 'unnecessary'
+  | 'totally_wrong';
+
+export type ConsoleNextActionDateAction = 'snooze_1day' | 'snooze_1week';
+
+export type ConsoleCloseAction = 'close' | 'close_not_planned';
+
+export type ConsoleOperationHandlers = {
+  onReview: (action: ConsoleReviewAction) => void;
+  onSetNextActionDate: (action: ConsoleNextActionDateAction) => void;
+  onSetStory: (option: ConsoleFieldOption) => void;
+  onSetStatus: (option: ConsoleFieldOption) => void;
+  onSetInTmuxByHuman: (option: ConsoleFieldOption) => void;
+  onClose: (action: ConsoleCloseAction) => void;
+};
+
+export const STATUS_BUTTON_NAMES: string[] = [
+  'In Tmux by agent',
+  'In Tmux by human',
+  'Todo by human',
+  'Awaiting Workspace',
+];
+
+export const IN_TMUX_BY_HUMAN_NAME = 'In Tmux by human';
+
+export const isTodoByHumanTab = (tab: ConsoleTabName): boolean =>
+  tab === 'todo-by-human';

package/src/adapter/entry-points/console/ui/src/features/console/overlay.test.ts

@@ -0,0 +1,124 @@
+import {
+  countPendingItems,
+  filterPendingItems,
+  getOverlayEntry,
+  isOverlayEntryActedForMode,
+  isOverlayEntryExpiredForMode,
+  overlayKeyForItem,
+  overlayStorageKey,
+  parseGeneratedAtMs,
+  writeOverlayEntry,
+} from './overlay';
+import type { ConsoleListItem, ConsoleOverlay } from './types';
+
+const item = (number: number): ConsoleListItem => ({
+  number,
+  title: `Item ${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  repo: 'o/r',
+  nameWithOwner: 'o/r',
+  projectItemId: `PVTI_${number}`,
+  itemId: `PVTI_${number}`,
+  isPr: false,
+  story: 'Story',
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+});
+
+describe('overlay helpers', () => {
+  it('builds the per-project storage key', () => {
+    expect(overlayStorageKey('umino')).toBe('pv_overlay_umino');
+  });
+
+  it('uses the projectItemId as the overlay key when present', () => {
+    expect(overlayKeyForItem(item(5))).toBe('PVTI_5');
+  });
+
+  it('parses a generatedAt timestamp', () => {
+    expect(parseGeneratedAtMs('2026-06-10T00:00:00.000Z')).toBe(
+      Date.parse('2026-06-10T00:00:00.000Z'),
+    );
+    expect(parseGeneratedAtMs('not-a-date')).toBe(0);
+  });
+});
+
+describe('mode-aware expiry', () => {
+  it('expires a same-mode entry written before the snapshot', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 100, mode: 'prs', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(true);
+  });
+
+  it('does not expire an entry written in a different mode', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 100, mode: 'triage', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+
+  it('does not expire an entry written after the snapshot', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 300, mode: 'prs', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('counts driven to zero do not revive on tab switch', () => {
+  it('keeps a done item subtracted in its own mode', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const generatedAtMs = 400;
+    expect(countPendingItems([item(1)], overlay, generatedAtMs, 'prs')).toBe(0);
+  });
+
+  it('treats a done entry from another mode as still acted', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'triage', done: true },
+    };
+    expect(isOverlayEntryActedForMode(overlay.PVTI_1, 999, 'prs')).toBe(true);
+    expect(countPendingItems([item(1)], overlay, 999, 'prs')).toBe(0);
+  });
+
+  it('revives the count only when a newer same-mode snapshot supersedes the entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(countPendingItems([item(1)], overlay, 200, 'prs')).toBe(1);
+  });
+});
+
+describe('filterPendingItems', () => {
+  it('drops acted items and keeps the rest', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const result = filterPendingItems([item(1), item(2)], overlay, 400, 'prs');
+    expect(result.map((entry) => entry.number)).toEqual([2]);
+  });
+});
+
+describe('getOverlayEntry and writeOverlayEntry', () => {
+  it('returns null for an expired entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(getOverlayEntry(overlay, item(1), 200, 'prs')).toBeNull();
+  });
+
+  it('stamps the timestamp and mode on write', () => {
+    const next = writeOverlayEntry({}, 'PVTI_1', { done: true }, 'prs', 1234);
+    expect(next.PVTI_1).toEqual({ done: true, ts: 1234, mode: 'prs' });
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/overlay.ts

@@ -0,0 +1,101 @@
+import type {
+  ConsoleListItem,
+  ConsoleOverlay,
+  ConsoleOverlayEntry,
+  ConsoleTabName,
+} from './types';
+
+export const overlayStorageKey = (pjcode: string): string =>
+  `pv_overlay_${pjcode}`;
+
+export const overlayKeyForItem = (item: ConsoleListItem): string =>
+  item.projectItemId !== '' ? item.projectItemId : item.itemId;
+
+export const parseGeneratedAtMs = (generatedAt: string): number => {
+  const parsed = Date.parse(generatedAt);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+
+export const isOverlayEntryExpiredForMode = (
+  entry: ConsoleOverlayEntry,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): boolean =>
+  entry.ts > 0 &&
+  generatedAtMs > 0 &&
+  entry.mode === mode &&
+  entry.ts < generatedAtMs;
+
+export const getOverlayEntry = (
+  overlay: ConsoleOverlay,
+  item: ConsoleListItem,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): ConsoleOverlayEntry | null => {
+  const entry = overlay[overlayKeyForItem(item)];
+  if (entry === undefined) {
+    return null;
+  }
+  if (isOverlayEntryExpiredForMode(entry, generatedAtMs, mode)) {
+    return null;
+  }
+  return entry;
+};
+
+export const isOverlayEntryActedForMode = (
+  entry: ConsoleOverlayEntry | undefined,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): boolean => {
+  if (entry === undefined || entry.done !== true) {
+    return false;
+  }
+  return !isOverlayEntryExpiredForMode(entry, generatedAtMs, mode);
+};
+
+export const countPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): number =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  ).length;
+
+export const filterPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): ConsoleListItem[] =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  );
+
+export const writeOverlayEntry = (
+  overlay: ConsoleOverlay,
+  key: string,
+  patch: Partial<Omit<ConsoleOverlayEntry, 'ts' | 'mode'>>,
+  mode: ConsoleTabName,
+  now: number,
+): ConsoleOverlay => {
+  const existing = overlay[key];
+  const next: ConsoleOverlayEntry = {
+    ...(existing ?? {}),
+    ...patch,
+    ts: now,
+    mode,
+  };
+  return { ...overlay, [key]: next };
+};

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsoleItemDetailContainer.test.tsx

@@ -0,0 +1,79 @@
+import { fireEvent, render, waitFor } from '@testing-library/react';
+import {
+  consoleListItemsFixture,
+  consoleStatusOptionsFixture,
+  consoleStoryColorsFixture,
+  consoleStoryOptionsFixture,
+} from '../fixtures';
+import type { ConsoleCaches } from '../hooks/useConsoleCaches';
+import type { ConsoleOperationsApi } from '../hooks/useConsoleOperations';
+import { ResourceCache } from '../lib/resourceCache';
+import { ConsoleItemDetailContainer } from './ConsoleItemDetailContainer';
+
+jest.mock('../lib/mermaidLoader', () => ({
+  renderMermaidToSvg: jest.fn(async () => '<svg></svg>'),
+}));
+
+const prItem = consoleListItemsFixture[0];
+
+const buildCaches = (): ConsoleCaches => {
+  const client = {
+    fetchItemBody: async () => '# body',
+    fetchComments: async () => [],
+    fetchPrFiles: async () => [],
+    fetchPrCommits: async () => [],
+    fetchRelatedPrs: async () => [],
+    fetchIssueState: async () => ({
+      state: 'open',
+      merged: false,
+      isPullRequest: true,
+    }),
+  };
+  return {
+    client,
+    body: new ResourceCache(client.fetchItemBody),
+    comments: new ResourceCache(client.fetchComments),
+    files: new ResourceCache(client.fetchPrFiles),
+    commits: new ResourceCache(client.fetchPrCommits),
+    relatedPrs: new ResourceCache(client.fetchRelatedPrs),
+    state: new ResourceCache(client.fetchIssueState),
+  };
+};
+
+const buildOperations = (): ConsoleOperationsApi => ({
+  reviewPullRequest: jest.fn(async () => {}),
+  setNextActionDate: jest.fn(async () => {}),
+  setStory: jest.fn(async () => {}),
+  setStatus: jest.fn(async () => {}),
+  setInTmuxByHuman: jest.fn(async () => {}),
+  closeIssue: jest.fn(async () => {}),
+});
+
+describe('ConsoleItemDetailContainer', () => {
+  it('wires the review action to the operations api for a PR item', async () => {
+    const operations = buildOperations();
+    const { getByText } = render(
+      <ConsoleItemDetailContainer
+        tab="prs"
+        item={prItem}
+        caches={buildCaches()}
+        operations={operations}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        storyColors={consoleStoryColorsFixture}
+        storyName="TDPM Console port"
+        overlayStatus={null}
+        now={Date.parse('2026-06-19T12:00:00.000Z')}
+      />,
+    );
+    await waitFor(() => {
+      expect(getByText('Approve')).toBeInTheDocument();
+    });
+    fireEvent.click(getByText('Approve'));
+    expect(operations.reviewPullRequest).toHaveBeenCalledWith(
+      prItem,
+      prItem.url,
+      'approve',
+    );
+  });
+});