github-issue-tower-defence-management 1.90.0 → 1.91.1

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 '../logic/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);
+  });
+});

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/logic/colors.test.ts

@@ -0,0 +1,34 @@
+import { CONSOLE_COLOR_PALETTE, colorFromEnum } from './colors';
+
+describe('colorFromEnum', () => {
+  it('returns the exact palette entry for a known enum', () => {
+    expect(colorFromEnum('GREEN')).toEqual({
+      dot: '#3fb950',
+      bg: 'rgba(46,160,67,0.15)',
+      fg: '#3fb950',
+      border: 'rgba(46,160,67,0.4)',
+    });
+  });
+
+  it('is case insensitive', () => {
+    expect(colorFromEnum('purple')).toBe(CONSOLE_COLOR_PALETTE.PURPLE);
+  });
+
+  it('falls back to GRAY for an unknown enum', () => {
+    expect(colorFromEnum('MAGENTA')).toBe(CONSOLE_COLOR_PALETTE.GRAY);
+  });
+
+  it('falls back to GRAY for null', () => {
+    expect(colorFromEnum(null)).toBe(CONSOLE_COLOR_PALETTE.GRAY);
+  });
+
+  it('uses the documented dot colors for every enum', () => {
+    expect(CONSOLE_COLOR_PALETTE.GRAY.dot).toBe('#848d97');
+    expect(CONSOLE_COLOR_PALETTE.BLUE.dot).toBe('#4493f8');
+    expect(CONSOLE_COLOR_PALETTE.YELLOW.dot).toBe('#d29922');
+    expect(CONSOLE_COLOR_PALETTE.ORANGE.dot).toBe('#db6d28');
+    expect(CONSOLE_COLOR_PALETTE.RED.dot).toBe('#f85149');
+    expect(CONSOLE_COLOR_PALETTE.PINK.dot).toBe('#db61a2');
+    expect(CONSOLE_COLOR_PALETTE.PURPLE.dot).toBe('#a371f7');
+  });
+});

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

@@ -0,0 +1,73 @@
+import type { ConsoleColor } from './types';
+
+export type ConsolePaletteEntry = {
+  dot: string;
+  bg: string;
+  fg: string;
+  border: string;
+};
+
+export const CONSOLE_COLOR_PALETTE: Record<ConsoleColor, ConsolePaletteEntry> =
+  {
+    GRAY: {
+      dot: '#848d97',
+      bg: 'rgba(110,118,129,0.1)',
+      fg: '#8b949e',
+      border: 'rgba(110,118,129,0.4)',
+    },
+    BLUE: {
+      dot: '#4493f8',
+      bg: 'rgba(56,139,253,0.1)',
+      fg: '#388bfd',
+      border: 'rgba(56,139,253,0.4)',
+    },
+    GREEN: {
+      dot: '#3fb950',
+      bg: 'rgba(46,160,67,0.15)',
+      fg: '#3fb950',
+      border: 'rgba(46,160,67,0.4)',
+    },
+    YELLOW: {
+      dot: '#d29922',
+      bg: 'rgba(187,128,9,0.15)',
+      fg: '#d29922',
+      border: 'rgba(187,128,9,0.4)',
+    },
+    ORANGE: {
+      dot: '#db6d28',
+      bg: 'rgba(219,109,40,0.1)',
+      fg: '#db6d28',
+      border: 'rgba(219,109,40,0.4)',
+    },
+    RED: {
+      dot: '#f85149',
+      bg: 'rgba(248,81,73,0.1)',
+      fg: '#f85149',
+      border: 'rgba(248,81,73,0.4)',
+    },
+    PINK: {
+      dot: '#db61a2',
+      bg: 'rgba(219,97,162,0.1)',
+      fg: '#db61a2',
+      border: 'rgba(219,97,162,0.4)',
+    },
+    PURPLE: {
+      dot: '#a371f7',
+      bg: 'rgba(163,113,247,0.1)',
+      fg: '#a371f7',
+      border: 'rgba(163,113,247,0.4)',
+    },
+  };
+
+export const colorFromEnum = (
+  colorEnum: string | null,
+): ConsolePaletteEntry => {
+  if (colorEnum === null) {
+    return CONSOLE_COLOR_PALETTE.GRAY;
+  }
+  const key = colorEnum.toUpperCase();
+  if (key in CONSOLE_COLOR_PALETTE) {
+    return CONSOLE_COLOR_PALETTE[key as ConsoleColor];
+  }
+  return CONSOLE_COLOR_PALETTE.GRAY;
+};

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

@@ -0,0 +1,35 @@
+import { fileStatusBadge } from './fileStatus';
+
+describe('fileStatusBadge', () => {
+  it('maps added to a green A badge', () => {
+    expect(fileStatusBadge('added')).toEqual({ label: 'A', color: '#3fb950' });
+  });
+
+  it('maps modified to a yellow M badge', () => {
+    expect(fileStatusBadge('modified')).toEqual({
+      label: 'M',
+      color: '#d29922',
+    });
+  });
+
+  it('maps removed to a red D badge', () => {
+    expect(fileStatusBadge('removed')).toEqual({
+      label: 'D',
+      color: '#f85149',
+    });
+  });
+
+  it('maps renamed to a purple R badge', () => {
+    expect(fileStatusBadge('renamed')).toEqual({
+      label: 'R',
+      color: '#a371f7',
+    });
+  });
+
+  it('maps an unknown status to a gray question badge', () => {
+    expect(fileStatusBadge('whatever')).toEqual({
+      label: '?',
+      color: '#8b949e',
+    });
+  });
+});