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

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

@@ -0,0 +1,41 @@
+import { act, renderHook } from '@testing-library/react';
+import { useConsoleToken } from './useConsoleToken';
+
+describe('useConsoleToken', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    window.history.replaceState({}, '', '/');
+  });
+
+  it('reads the token from the query string and appends it to data urls', () => {
+    window.history.replaceState({}, '', '/?k=secret');
+    const { result } = renderHook(() => useConsoleToken());
+    expect(result.current.token).toBe('secret');
+    expect(result.current.appendToken('./prs/list.json')).toBe(
+      './prs/list.json?k=secret',
+    );
+    expect(result.current.appendToken('./api/itembody?url=x')).toBe(
+      './api/itembody?url=x&k=secret',
+    );
+  });
+
+  it('persists the token to localStorage', () => {
+    window.history.replaceState({}, '', '/?k=persisted');
+    renderHook(() => useConsoleToken());
+    expect(localStorage.getItem('tdpm-console-token')).toBe('persisted');
+  });
+
+  it('reads a persisted token when no query token exists', () => {
+    localStorage.setItem('tdpm-console-token', 'stored');
+    const { result } = renderHook(() => useConsoleToken());
+    expect(result.current.token).toBe('stored');
+  });
+
+  it('returns the url unchanged when there is no token', () => {
+    const { result } = renderHook(() => useConsoleToken());
+    act(() => {});
+    expect(result.current.appendToken('./prs/list.json')).toBe(
+      './prs/list.json',
+    );
+  });
+});

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

@@ -0,0 +1,97 @@
+import { CONSOLE_ITEM_ICONS, resolveConsoleItemIconKind } from './itemIcons';
+
+describe('resolveConsoleItemIconKind', () => {
+  it('resolves a draft pull request to prDraft', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'open',
+        merged: false,
+        isDraft: true,
+        stateReason: '',
+      }),
+    ).toBe('prDraft');
+  });
+
+  it('resolves a merged pull request to prMerged', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'closed',
+        merged: true,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prMerged');
+  });
+
+  it('resolves a closed pull request to prClosed', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prClosed');
+  });
+
+  it('resolves an open pull request to prOpen', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: true,
+        state: 'open',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('prOpen');
+  });
+
+  it('resolves a completed closed issue to issueClosed', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: 'completed',
+      }),
+    ).toBe('issueClosed');
+  });
+
+  it('resolves a not-planned closed issue to issueClosedNotPlanned', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'closed',
+        merged: false,
+        isDraft: false,
+        stateReason: 'not_planned',
+      }),
+    ).toBe('issueClosedNotPlanned');
+  });
+
+  it('resolves an open issue to issueOpen', () => {
+    expect(
+      resolveConsoleItemIconKind({
+        isPr: false,
+        state: 'open',
+        merged: false,
+        isDraft: false,
+        stateReason: '',
+      }),
+    ).toBe('issueOpen');
+  });
+
+  it('uses the documented colors for each kind', () => {
+    expect(CONSOLE_ITEM_ICONS.prDraft.color).toBe('#8b949e');
+    expect(CONSOLE_ITEM_ICONS.prMerged.color).toBe('#a371f7');
+    expect(CONSOLE_ITEM_ICONS.prClosed.color).toBe('#f85149');
+    expect(CONSOLE_ITEM_ICONS.prOpen.color).toBe('#3fb950');
+    expect(CONSOLE_ITEM_ICONS.issueClosedNotPlanned.color).toBe('#848d97');
+    expect(CONSOLE_ITEM_ICONS.issueClosed.color).toBe('#a371f7');
+    expect(CONSOLE_ITEM_ICONS.issueOpen.color).toBe('#3fb950');
+  });
+});

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

@@ -0,0 +1,95 @@
+export type ConsoleItemIconKind =
+  | 'issueOpen'
+  | 'issueClosed'
+  | 'issueClosedNotPlanned'
+  | 'prOpen'
+  | 'prMerged'
+  | 'prClosed'
+  | 'prDraft';
+
+export type ConsoleItemIconDefinition = {
+  color: string;
+  paths: string[];
+};
+
+export const CONSOLE_ITEM_ICONS: Record<
+  ConsoleItemIconKind,
+  ConsoleItemIconDefinition
+> = {
+  issueOpen: {
+    color: '#3fb950',
+    paths: [
+      'M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z',
+      'M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z',
+    ],
+  },
+  issueClosed: {
+    color: '#a371f7',
+    paths: [
+      'M11.28 6.78a.75.75 0 0 0-1.06-1.06L7.25 8.69 5.78 7.22a.75.75 0 0 0-1.06 1.06l2 2a.75.75 0 0 0 1.06 0l3.5-3.5Z',
+      'M16 8A8 8 0 1 1 0 8a8 8 0 0 1 16 0Zm-1.5 0a6.5 6.5 0 1 0-13 0 6.5 6.5 0 0 0 13 0Z',
+    ],
+  },
+  issueClosedNotPlanned: {
+    color: '#848d97',
+    paths: [
+      'M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm9.78-2.22-5.5 5.5a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l5.5-5.5a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z',
+    ],
+  },
+  prOpen: {
+    color: '#3fb950',
+    paths: [
+      'M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z',
+    ],
+  },
+  prMerged: {
+    color: '#a371f7',
+    paths: [
+      'M5.45 5.154A4.25 4.25 0 0 0 9.25 7.5h1.378a2.251 2.251 0 1 1 0 1.5H9.25A5.734 5.734 0 0 1 5 7.123v3.505a2.25 2.25 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.95-.218ZM4.25 13.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Zm8.5-4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5ZM5 3.25a.75.75 0 1 0 0 .005V3.25Z',
+    ],
+  },
+  prClosed: {
+    color: '#f85149',
+    paths: [
+      'M3.25 1A2.25 2.25 0 0 1 4 5.372v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.251 2.251 0 0 1 3.25 1Zm9.5 5.5a.75.75 0 0 1 .75.75v3.378a2.251 2.251 0 1 1-1.5 0V7.25a.75.75 0 0 1 .75-.75Zm-2.03-5.273a.75.75 0 0 1 1.06 0l.97.97.97-.97a.748.748 0 0 1 1.265.332.75.75 0 0 1-.205.729l-.97.97.97.97a.751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018l-.97-.97-.97.97a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l.97-.97-.97-.97a.75.75 0 0 1 0-1.06ZM2.5 3.25a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0ZM3.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm9.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z',
+    ],
+  },
+  prDraft: {
+    color: '#8b949e',
+    paths: [
+      'M3.25 1A2.25 2.25 0 0 1 4 5.372v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.251 2.251 0 0 1 3.25 1Zm9.5 14a2.25 2.25 0 1 1 0-4.5 2.25 2.25 0 0 1 0 4.5ZM2.5 3.25a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0ZM3.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm9.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5ZM14 7.5a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0Zm0-4.25a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0Z',
+    ],
+  },
+};
+
+export type ConsoleItemIconInput = {
+  isPr: boolean;
+  state: string;
+  merged: boolean;
+  isDraft: boolean;
+  stateReason: string;
+};
+
+export const resolveConsoleItemIconKind = ({
+  isPr,
+  state,
+  merged,
+  isDraft,
+  stateReason,
+}: ConsoleItemIconInput): ConsoleItemIconKind => {
+  if (isPr) {
+    if (isDraft) {
+      return 'prDraft';
+    }
+    if (merged) {
+      return 'prMerged';
+    }
+    return state === 'closed' ? 'prClosed' : 'prOpen';
+  }
+  if (state === 'closed') {
+    return stateReason === 'not_planned'
+      ? 'issueClosedNotPlanned'
+      : 'issueClosed';
+  }
+  return 'issueOpen';
+};

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

@@ -0,0 +1,155 @@
+import { createConsoleApiClient, postConsoleOperation } from './consoleApi';
+
+const appendToken = (url: string): string =>
+  url.includes('?') ? `${url}&k=token` : `${url}?k=token`;
+
+const mockFetchOnce = (body: unknown, ok = true): jest.Mock => {
+  const fetchMock = jest.fn().mockResolvedValue({
+    ok,
+    status: ok ? 200 : 500,
+    json: async () => body,
+  });
+  global.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+};
+
+describe('createConsoleApiClient', () => {
+  it('reads the item body and appends the token to the url query', async () => {
+    const fetchMock = mockFetchOnce({ body: '# Title' });
+    const client = createConsoleApiClient(appendToken);
+    const body = await client.fetchItemBody('https://github.com/o/r/issues/1');
+    expect(body).toBe('# Title');
+    const requested = fetchMock.mock.calls[0][0] as string;
+    expect(requested).toContain('./api/itembody?url=');
+    expect(requested).toContain('&k=token');
+  });
+
+  it('parses comments', async () => {
+    mockFetchOnce({
+      comments: [
+        { author: 'a', body: 'hello', createdAt: '2026-06-19T00:00:00.000Z' },
+      ],
+    });
+    const client = createConsoleApiClient(appendToken);
+    const comments = await client.fetchComments(
+      'https://github.com/o/r/issues/1',
+    );
+    expect(comments).toEqual([
+      { author: 'a', body: 'hello', createdAt: '2026-06-19T00:00:00.000Z' },
+    ]);
+  });
+
+  it('parses changed files supporting path and filename keys', async () => {
+    mockFetchOnce({
+      files: [
+        { path: 'a.ts', additions: 3, deletions: 1, status: 'modified' },
+        { filename: 'b.ts', additions: 9, deletions: 0, status: 'added' },
+      ],
+    });
+    const client = createConsoleApiClient(appendToken);
+    const files = await client.fetchPrFiles('https://github.com/o/r/pull/1');
+    expect(files.map((file) => file.path)).toEqual(['a.ts', 'b.ts']);
+  });
+
+  it('returns no files when the response files array is null', async () => {
+    mockFetchOnce({ files: null });
+    const client = createConsoleApiClient(appendToken);
+    expect(await client.fetchPrFiles('https://github.com/o/r/pull/1')).toEqual(
+      [],
+    );
+  });
+
+  it('parses the issue state', async () => {
+    mockFetchOnce({ state: 'closed', merged: true, isPullRequest: true });
+    const client = createConsoleApiClient(appendToken);
+    expect(
+      await client.fetchIssueState('https://github.com/o/r/pull/1'),
+    ).toEqual({ state: 'closed', merged: true, isPullRequest: true });
+  });
+
+  it('parses pull request commits', async () => {
+    mockFetchOnce({
+      commits: [
+        {
+          sha: 'abc1234',
+          message: 'fix: thing',
+          author: 'dev',
+          authoredAt: '2026-06-19T00:00:00.000Z',
+        },
+      ],
+    });
+    const client = createConsoleApiClient(appendToken);
+    const commits = await client.fetchPrCommits(
+      'https://github.com/o/r/pull/1',
+    );
+    expect(commits[0].sha).toBe('abc1234');
+  });
+
+  it('parses related pull requests with summaries', async () => {
+    mockFetchOnce({
+      relatedPullRequests: [
+        {
+          url: 'https://github.com/o/r/pull/9',
+          branchName: 'feat',
+          createdAt: '2026-06-19T00:00:00.000Z',
+          isDraft: false,
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: ['build'],
+          summary: {
+            title: 'Linked',
+            body: 'body',
+            additions: 10,
+            deletions: 2,
+            changedFiles: 3,
+          },
+        },
+      ],
+    });
+    const client = createConsoleApiClient(appendToken);
+    const related = await client.fetchRelatedPrs(
+      'https://github.com/o/r/issues/1',
+    );
+    expect(related[0].url).toBe('https://github.com/o/r/pull/9');
+    expect(related[0].summary?.changedFiles).toBe(3);
+    expect(related[0].missingRequiredCheckNames).toEqual(['build']);
+  });
+
+  it('throws on a non-ok response', async () => {
+    mockFetchOnce({}, false);
+    const client = createConsoleApiClient(appendToken);
+    await expect(
+      client.fetchComments('https://github.com/o/r/issues/1'),
+    ).rejects.toThrow('HTTP 500');
+  });
+});
+
+describe('postConsoleOperation', () => {
+  it('posts a JSON body and appends the token', async () => {
+    const fetchMock = mockFetchOnce({ ok: true });
+    await postConsoleOperation(appendToken, '/api/review', {
+      pjcode: 'umino',
+      action: 'approve',
+      prUrl: 'https://github.com/o/r/pull/1',
+      projectItemId: 'PVTI_1',
+    });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('/api/review?k=token');
+    expect(init).toMatchObject({ method: 'POST' });
+  });
+
+  it('throws on a failed operation', async () => {
+    mockFetchOnce({}, false);
+    await expect(
+      postConsoleOperation(appendToken, '/api/review', {
+        pjcode: 'umino',
+        action: 'approve',
+        prUrl: 'https://github.com/o/r/pull/1',
+        projectItemId: 'PVTI_1',
+      }),
+    ).rejects.toThrow('HTTP 500');
+  });
+});

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

@@ -0,0 +1,187 @@
+import type {
+  ConsoleChangedFile,
+  ConsoleComment,
+  ConsoleCommit,
+  ConsoleIssueState,
+  ConsoleRelatedPullRequest,
+} from '../types';
+
+export type ConsoleApiClient = {
+  fetchItemBody: (url: string) => Promise<string>;
+  fetchComments: (url: string) => Promise<ConsoleComment[]>;
+  fetchPrFiles: (url: string) => Promise<ConsoleChangedFile[]>;
+  fetchPrCommits: (url: string) => Promise<ConsoleCommit[]>;
+  fetchRelatedPrs: (url: string) => Promise<ConsoleRelatedPullRequest[]>;
+  fetchIssueState: (url: string) => Promise<ConsoleIssueState>;
+};
+
+export type ConsoleReviewRequest = {
+  pjcode: string;
+  action: string;
+  prUrl: string;
+  projectItemId: string;
+  commentBody?: string;
+  changedFilePath?: string;
+};
+
+export type ConsoleTriageRequest = {
+  pjcode: string;
+  action: string;
+  issueUrl: string;
+  projectItemId: string;
+  statusName?: string;
+  storyOptionId?: string;
+  commentBody?: string;
+};
+
+export type ConsoleIntmuxRequest = {
+  pjcode: string;
+  action: 'set_intmux';
+  issueUrl: string;
+  projectItemId: string;
+};
+
+type AppendToken = (url: string) => string;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const getString = (value: unknown): string =>
+  typeof value === 'string' ? value : '';
+
+const getNumber = (value: unknown): number =>
+  typeof value === 'number' ? value : 0;
+
+const getBoolean = (value: unknown): boolean => value === true;
+
+const requestJson = async (
+  appendToken: AppendToken,
+  apiPath: string,
+  resourceUrl: string,
+): Promise<unknown> => {
+  const target = appendToken(
+    `${apiPath}?url=${encodeURIComponent(resourceUrl)}`,
+  );
+  const response = await fetch(target);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return response.json();
+};
+
+const parseComments = (payload: unknown): ConsoleComment[] => {
+  if (!isRecord(payload) || !Array.isArray(payload.comments)) {
+    return [];
+  }
+  return payload.comments.filter(isRecord).map((comment) => ({
+    author: getString(comment.author),
+    body: getString(comment.body),
+    createdAt: getString(comment.createdAt),
+  }));
+};
+
+const parseFiles = (payload: unknown): ConsoleChangedFile[] => {
+  if (!isRecord(payload) || !Array.isArray(payload.files)) {
+    return [];
+  }
+  return payload.files.filter(isRecord).map((file) => ({
+    path: getString(file.path) || getString(file.filename),
+    additions: getNumber(file.additions),
+    deletions: getNumber(file.deletions),
+    status: getString(file.status),
+    patch: typeof file.patch === 'string' ? file.patch : null,
+  }));
+};
+
+const parseCommits = (payload: unknown): ConsoleCommit[] => {
+  if (!isRecord(payload) || !Array.isArray(payload.commits)) {
+    return [];
+  }
+  return payload.commits.filter(isRecord).map((commit) => ({
+    sha: getString(commit.sha),
+    message: getString(commit.message),
+    author: getString(commit.author),
+    authoredAt: getString(commit.authoredAt),
+  }));
+};
+
+const parseSummary = (value: unknown): ConsoleRelatedPullRequest['summary'] => {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return {
+    title: getString(value.title),
+    body: getString(value.body),
+    additions: getNumber(value.additions),
+    deletions: getNumber(value.deletions),
+    changedFiles: getNumber(value.changedFiles),
+  };
+};
+
+const parseRelatedPrs = (payload: unknown): ConsoleRelatedPullRequest[] => {
+  if (!isRecord(payload) || !Array.isArray(payload.relatedPullRequests)) {
+    return [];
+  }
+  return payload.relatedPullRequests.filter(isRecord).map((pr) => ({
+    url: getString(pr.url),
+    branchName: typeof pr.branchName === 'string' ? pr.branchName : null,
+    createdAt: getString(pr.createdAt),
+    isDraft: getBoolean(pr.isDraft),
+    isConflicted: getBoolean(pr.isConflicted),
+    isPassedAllCiJob: getBoolean(pr.isPassedAllCiJob),
+    isCiStateSuccess: getBoolean(pr.isCiStateSuccess),
+    isResolvedAllReviewComments: getBoolean(pr.isResolvedAllReviewComments),
+    isBranchOutOfDate: getBoolean(pr.isBranchOutOfDate),
+    missingRequiredCheckNames: Array.isArray(pr.missingRequiredCheckNames)
+      ? pr.missingRequiredCheckNames.filter(
+          (name): name is string => typeof name === 'string',
+        )
+      : [],
+    summary: parseSummary(pr.summary),
+  }));
+};
+
+const parseState = (payload: unknown): ConsoleIssueState => {
+  if (!isRecord(payload)) {
+    return { state: 'open', merged: false, isPullRequest: false };
+  }
+  return {
+    state: getString(payload.state) || 'open',
+    merged: getBoolean(payload.merged),
+    isPullRequest: getBoolean(payload.isPullRequest),
+  };
+};
+
+export const createConsoleApiClient = (
+  appendToken: AppendToken,
+): ConsoleApiClient => ({
+  fetchItemBody: async (url) => {
+    const payload = await requestJson(appendToken, './api/itembody', url);
+    return isRecord(payload) ? getString(payload.body) : '';
+  },
+  fetchComments: async (url) =>
+    parseComments(await requestJson(appendToken, './api/comments', url)),
+  fetchPrFiles: async (url) =>
+    parseFiles(await requestJson(appendToken, './api/prfiles', url)),
+  fetchPrCommits: async (url) =>
+    parseCommits(await requestJson(appendToken, './api/prcommits', url)),
+  fetchRelatedPrs: async (url) =>
+    parseRelatedPrs(await requestJson(appendToken, './api/relatedprs', url)),
+  fetchIssueState: async (url) =>
+    parseState(await requestJson(appendToken, './api/issuetitle', url)),
+});
+
+export const postConsoleOperation = async (
+  appendToken: AppendToken,
+  apiPath: string,
+  body: ConsoleReviewRequest | ConsoleTriageRequest | ConsoleIntmuxRequest,
+): Promise<void> => {
+  const response = await fetch(appendToken(apiPath), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+};

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

@@ -0,0 +1,76 @@
+import {
+  type ConsoleMarkdownSegment,
+  hasMermaidFence,
+  renderMarkdownToSafeHtml,
+  splitMarkdownSegments,
+} from './markdown';
+
+const stripKey = (segment: ConsoleMarkdownSegment): Record<string, unknown> => {
+  if (segment.kind === 'mermaid') {
+    return { kind: segment.kind, code: segment.code };
+  }
+  return { kind: segment.kind, source: segment.source };
+};
+
+describe('renderMarkdownToSafeHtml', () => {
+  it('renders headings and lists', () => {
+    const html = renderMarkdownToSafeHtml('# Title\n\n- one\n- two');
+    expect(html).toContain('<h1');
+    expect(html).toContain('<li>one</li>');
+  });
+
+  it('strips script tags via DOMPurify', () => {
+    const html = renderMarkdownToSafeHtml(
+      'before <script>alert(1)</script> after',
+    );
+    expect(html).not.toContain('<script>');
+    expect(html).not.toContain('alert(1)');
+  });
+
+  it('strips event-handler attributes', () => {
+    const html = renderMarkdownToSafeHtml('<img src="x" onerror="alert(1)">');
+    expect(html).not.toContain('onerror');
+  });
+
+  it('returns an empty string for blank input', () => {
+    expect(renderMarkdownToSafeHtml('   ')).toBe('');
+  });
+});
+
+describe('splitMarkdownSegments', () => {
+  it('separates a mermaid fence from surrounding markdown', () => {
+    const segments = splitMarkdownSegments(
+      'intro\n\n```mermaid\ngraph TD; A-->B;\n```\n\noutro',
+    );
+    expect(segments.map(stripKey)).toEqual([
+      { kind: 'markdown', source: 'intro\n' },
+      { kind: 'mermaid', code: 'graph TD; A-->B;' },
+      { kind: 'markdown', source: '\noutro' },
+    ]);
+    expect(new Set(segments.map((segment) => segment.key)).size).toBe(3);
+  });
+
+  it('keeps plain markdown as a single segment', () => {
+    const segments = splitMarkdownSegments('just text');
+    expect(segments.map(stripKey)).toEqual([
+      { kind: 'markdown', source: 'just text' },
+    ]);
+  });
+
+  it('keeps an unterminated mermaid fence as markdown', () => {
+    const segments = splitMarkdownSegments('```mermaid\ngraph TD; A-->B;');
+    expect(segments.map(stripKey)).toEqual([
+      { kind: 'markdown', source: '```mermaid\ngraph TD; A-->B;' },
+    ]);
+  });
+});
+
+describe('hasMermaidFence', () => {
+  it('detects a mermaid fence', () => {
+    expect(hasMermaidFence('```mermaid\ngraph TD; A-->B;\n```')).toBe(true);
+  });
+
+  it('returns false without a mermaid fence', () => {
+    expect(hasMermaidFence('```ts\nconst a = 1;\n```')).toBe(false);
+  });
+});