github-issue-tower-defence-management 1.116.9 → 1.117.0

package/src/adapter/entry-points/console/ui/src/features/console/components/detail/ConsolePullRequestStatusBadges.test.tsx

@@ -5,7 +5,7 @@ describe('ConsolePullRequestStatusBadges', () => {
   it('renders a passing CI badge when all CI jobs passed and the CI state is success', () => {
     const { getByText, queryByText } = render(
       <ConsolePullRequestStatusBadges
-        isConflicted={false}
+        mergeableStatus="MERGEABLE"
         isPassedAllCiJob={true}
         isCiStateSuccess={true}
         isBranchOutOfDate={false}
@@ -13,14 +13,13 @@ describe('ConsolePullRequestStatusBadges', () => {
       />,
     );
     expect(getByText('CI passing')).toBeInTheDocument();
-    expect(queryByText('Conflict')).toBeNull();
     expect(queryByText('Out of date')).toBeNull();
   });
 
   it('renders a failing CI badge with missing required checks', () => {
     const { getByText } = render(
       <ConsolePullRequestStatusBadges
-        isConflicted={false}
+        mergeableStatus="MERGEABLE"
         isPassedAllCiJob={false}
         isCiStateSuccess={true}
         isBranchOutOfDate={false}
@@ -31,10 +30,25 @@ describe('ConsolePullRequestStatusBadges', () => {
     expect(getByText(/missing: build, test/)).toBeInTheDocument();
   });
 
-  it('renders the conflict badge when the pull request is conflicted', () => {
-    const { getByText } = render(
+  it('renders the green no-conflict badge when the pull request is mergeable', () => {
+    const { getByText, queryByText } = render(
       <ConsolePullRequestStatusBadges
-        isConflicted={true}
+        mergeableStatus="MERGEABLE"
+        isPassedAllCiJob={true}
+        isCiStateSuccess={true}
+        isBranchOutOfDate={false}
+        missingRequiredCheckNames={[]}
+      />,
+    );
+    expect(getByText('No conflict')).toBeInTheDocument();
+    expect(queryByText('Conflict')).toBeNull();
+    expect(queryByText('Checking merge status')).toBeNull();
+  });
+
+  it('renders the red conflict badge when the pull request is conflicting', () => {
+    const { getByText, queryByText } = render(
+      <ConsolePullRequestStatusBadges
+        mergeableStatus="CONFLICTING"
         isPassedAllCiJob={true}
         isCiStateSuccess={true}
         isBranchOutOfDate={false}
@@ -42,12 +56,28 @@ describe('ConsolePullRequestStatusBadges', () => {
       />,
     );
     expect(getByText('Conflict')).toBeInTheDocument();
+    expect(queryByText('No conflict')).toBeNull();
+  });
+
+  it('renders the gray checking badge when the merge status is unknown', () => {
+    const { getByText, queryByText } = render(
+      <ConsolePullRequestStatusBadges
+        mergeableStatus="UNKNOWN"
+        isPassedAllCiJob={true}
+        isCiStateSuccess={true}
+        isBranchOutOfDate={false}
+        missingRequiredCheckNames={[]}
+      />,
+    );
+    expect(getByText('Checking merge status')).toBeInTheDocument();
+    expect(queryByText('Conflict')).toBeNull();
+    expect(queryByText('No conflict')).toBeNull();
   });
 
   it('renders the out-of-date badge when the branch is behind the base branch', () => {
     const { getByText } = render(
       <ConsolePullRequestStatusBadges
-        isConflicted={false}
+        mergeableStatus="MERGEABLE"
         isPassedAllCiJob={true}
         isCiStateSuccess={true}
         isBranchOutOfDate={true}
@@ -60,7 +90,7 @@ describe('ConsolePullRequestStatusBadges', () => {
   it('treats a successful CI state but unfinished jobs as failing', () => {
     const { getByText } = render(
       <ConsolePullRequestStatusBadges
-        isConflicted={false}
+        mergeableStatus="MERGEABLE"
         isPassedAllCiJob={false}
         isCiStateSuccess={true}
         isBranchOutOfDate={false}

package/src/adapter/entry-points/console/ui/src/features/console/components/detail/ConsolePullRequestStatusBadges.tsx

@@ -1,8 +1,8 @@
 import { colorFromEnum } from '../../logic/colors';
-import type { ConsoleColor } from '../../logic/types';
+import type { ConsoleColor, ConsoleMergeableStatus } from '../../logic/types';
 
 export type ConsolePullRequestStatusBadgesProps = {
-  isConflicted: boolean;
+  mergeableStatus: ConsoleMergeableStatus;
   isPassedAllCiJob: boolean;
   isCiStateSuccess: boolean;
   isBranchOutOfDate: boolean;
@@ -18,8 +18,32 @@ const badgeStyle = (color: ConsoleColor) => {
   };
 };
 
+const MERGEABLE_BADGE: Record<
+  ConsoleMergeableStatus,
+  { color: ConsoleColor; label: string; title: string; modifier: string }
+> = {
+  MERGEABLE: {
+    color: 'GREEN',
+    label: 'No conflict',
+    title: 'This pull request has no merge conflicts',
+    modifier: 'console-detail-mergeable-chip-ok',
+  },
+  CONFLICTING: {
+    color: 'RED',
+    label: 'Conflict',
+    title: 'This pull request has merge conflicts',
+    modifier: 'console-detail-mergeable-chip-conflict',
+  },
+  UNKNOWN: {
+    color: 'GRAY',
+    label: 'Checking merge status',
+    title: 'GitHub has not finished computing the merge status yet',
+    modifier: 'console-detail-mergeable-chip-unknown',
+  },
+};
+
 export const ConsolePullRequestStatusBadges = ({
-  isConflicted,
+  mergeableStatus,
   isPassedAllCiJob,
   isCiStateSuccess,
   isBranchOutOfDate,
@@ -32,6 +56,7 @@ export const ConsolePullRequestStatusBadges = ({
     !ciPassing && missingRequiredCheckNames.length > 0
       ? `missing: ${missingRequiredCheckNames.join(', ')}`
       : null;
+  const mergeableBadge = MERGEABLE_BADGE[mergeableStatus];
 
   return (
     <span className="console-detail-pr-status">
@@ -48,15 +73,13 @@ export const ConsolePullRequestStatusBadges = ({
           </span>
         )}
       </span>
-      {isConflicted && (
-        <span
-          className="console-detail-status-chip console-detail-conflict-chip"
-          style={badgeStyle('RED')}
-          title="This pull request has merge conflicts"
-        >
-          Conflict
-        </span>
-      )}
+      <span
+        className={`console-detail-status-chip console-detail-mergeable-chip ${mergeableBadge.modifier}`}
+        style={badgeStyle(mergeableBadge.color)}
+        title={mergeableBadge.title}
+      >
+        {mergeableBadge.label}
+      </span>
       {isBranchOutOfDate && (
         <span
           className="console-detail-status-chip console-detail-outofdate-chip"

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

@@ -0,0 +1,117 @@
+import { renderHook } from '@testing-library/react';
+import { ResourceCache } from '../lib/resourceCache';
+import type { ConsoleListItem } from '../logic/types';
+import type { ConsoleCaches } from './useConsoleCaches';
+import { useConsoleDetailPrefetch } from './useConsoleDetailPrefetch';
+
+const makeItem = (
+  number: number,
+  overrides: Partial<ConsoleListItem> = {},
+): 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',
+  status: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  dependedIssueUrls: [],
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+  ...overrides,
+});
+
+const buildCaches = (): ConsoleCaches => {
+  const never = () => new Promise<never>(() => {});
+  return {
+    client: {} as ConsoleCaches['client'],
+    body: new ResourceCache<string>(never),
+    comments: new ResourceCache(never),
+    files: new ResourceCache(never),
+    commits: new ResourceCache(never),
+    relatedPrs: new ResourceCache(never),
+    state: new ResourceCache(never),
+    prStatus: new ResourceCache(never),
+  };
+};
+
+describe('useConsoleDetailPrefetch', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    const idleWindow = window as unknown as Record<string, unknown>;
+    idleWindow.requestIdleCallback = undefined;
+    idleWindow.cancelIdleCallback = undefined;
+  });
+
+  afterEach(() => {
+    jest.runAllTimers();
+    jest.useRealTimers();
+  });
+
+  it('prefetches the next items after the idle defer elapses', () => {
+    const caches = buildCaches();
+    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
+    const relatedPrefetch = jest.spyOn(caches.relatedPrs, 'prefetch');
+    const items = [makeItem(1), makeItem(2), makeItem(3)];
+    renderHook(() => useConsoleDetailPrefetch(caches, items[0], items));
+
+    expect(bodyPrefetch).not.toHaveBeenCalled();
+    jest.runAllTimers();
+
+    expect(bodyPrefetch).toHaveBeenCalledWith('o/r#2', items[1].url);
+    expect(bodyPrefetch).toHaveBeenCalledWith('o/r#3', items[2].url);
+    expect(relatedPrefetch).toHaveBeenCalledWith('o/r#2', items[1].url);
+  });
+
+  it('prefetches PR resources for pull request items', () => {
+    const caches = buildCaches();
+    const filesPrefetch = jest.spyOn(caches.files, 'prefetch');
+    const prStatusPrefetch = jest.spyOn(caches.prStatus, 'prefetch');
+    const items = [
+      makeItem(1),
+      makeItem(2, { isPr: true, url: 'https://github.com/o/r/pull/2' }),
+    ];
+    renderHook(() => useConsoleDetailPrefetch(caches, items[0], items));
+    jest.runAllTimers();
+
+    expect(filesPrefetch).toHaveBeenCalledWith('o/r#2', items[1].url);
+    expect(prStatusPrefetch).toHaveBeenCalledWith('o/r#2', items[1].url);
+  });
+
+  it('limits prefetch to the next ten items', () => {
+    const caches = buildCaches();
+    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
+    const items = Array.from({ length: 15 }, (_unused, index) =>
+      makeItem(index + 1),
+    );
+    renderHook(() => useConsoleDetailPrefetch(caches, items[0], items));
+    jest.runAllTimers();
+
+    expect(bodyPrefetch).toHaveBeenCalledTimes(10);
+  });
+
+  it('does nothing when no item is selected', () => {
+    const caches = buildCaches();
+    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
+    const items = [makeItem(1), makeItem(2)];
+    renderHook(() => useConsoleDetailPrefetch(caches, null, items));
+    jest.runAllTimers();
+
+    expect(bodyPrefetch).not.toHaveBeenCalled();
+  });
+
+  it('does not prefetch when the selected item is the last in the list', () => {
+    const caches = buildCaches();
+    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
+    const items = [makeItem(1), makeItem(2)];
+    renderHook(() => useConsoleDetailPrefetch(caches, items[1], items));
+    jest.runAllTimers();
+
+    expect(bodyPrefetch).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,83 @@
+import { useEffect } from 'react';
+import type { ConsoleListItem } from '../logic/types';
+import type { ConsoleCaches } from './useConsoleCaches';
+
+const PREFETCH_AHEAD_COUNT = 10;
+const PREFETCH_DEFER_MS = 500;
+const PREFETCH_IDLE_TIMEOUT_MS = 2000;
+
+type IdleHandle = { cancel: () => void };
+
+const scheduleOnIdle = (task: () => void): IdleHandle => {
+  const idleWindow = window as Window & {
+    requestIdleCallback?: (
+      callback: () => void,
+      options?: { timeout: number },
+    ) => number;
+    cancelIdleCallback?: (handle: number) => void;
+  };
+  if (
+    typeof idleWindow.requestIdleCallback === 'function' &&
+    typeof idleWindow.cancelIdleCallback === 'function'
+  ) {
+    const handle = idleWindow.requestIdleCallback(task, {
+      timeout: PREFETCH_IDLE_TIMEOUT_MS,
+    });
+    return { cancel: () => idleWindow.cancelIdleCallback?.(handle) };
+  }
+  const handle = window.setTimeout(task, 0);
+  return { cancel: () => window.clearTimeout(handle) };
+};
+
+const prefetchItem = (caches: ConsoleCaches, item: ConsoleListItem): void => {
+  const key = `${item.repo}#${item.number}`;
+  caches.body.prefetch(key, item.url);
+  caches.state.prefetch(key, item.url);
+  caches.comments.prefetch(key, item.url);
+  if (item.isPr) {
+    caches.files.prefetch(key, item.url);
+    caches.commits.prefetch(key, item.url);
+    caches.prStatus.prefetch(key, item.url);
+  } else {
+    caches.relatedPrs.prefetch(key, item.url);
+  }
+};
+
+export const useConsoleDetailPrefetch = (
+  caches: ConsoleCaches,
+  selectedItem: ConsoleListItem | null,
+  orderedPendingItems: ConsoleListItem[],
+): void => {
+  useEffect(() => {
+    if (selectedItem === null) {
+      return;
+    }
+    const selectedIndex = orderedPendingItems.findIndex(
+      (item) => item.projectItemId === selectedItem.projectItemId,
+    );
+    if (selectedIndex === -1) {
+      return;
+    }
+    const upcoming = orderedPendingItems.slice(
+      selectedIndex + 1,
+      selectedIndex + 1 + PREFETCH_AHEAD_COUNT,
+    );
+    if (upcoming.length === 0) {
+      return;
+    }
+
+    let idleHandle: IdleHandle | null = null;
+    const deferHandle = window.setTimeout(() => {
+      idleHandle = scheduleOnIdle(() => {
+        for (const item of upcoming) {
+          prefetchItem(caches, item);
+        }
+      });
+    }, PREFETCH_DEFER_MS);
+
+    return () => {
+      window.clearTimeout(deferHandle);
+      idleHandle?.cancel();
+    };
+  }, [caches, selectedItem, orderedPendingItems]);
+};

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

@@ -68,6 +68,7 @@ const buildCaches = (related: ConsoleRelatedPullRequest[]): ConsoleCaches => {
     fetchPullRequestStatus: async (): Promise<ConsolePullRequestStatus> => ({
       found: true,
       isConflicted: true,
+      mergeableStatus: 'CONFLICTING',
       isPassedAllCiJob: false,
       isCiStateSuccess: false,
       isBranchOutOfDate: true,
@@ -117,6 +118,7 @@ describe('useConsoleItemDetailData', () => {
         createdAt: '2026-06-10T00:00:00.000Z',
         isDraft: false,
         isConflicted: false,
+        mergeableStatus: 'MERGEABLE',
         isPassedAllCiJob: true,
         isCiStateSuccess: true,
         isResolvedAllReviewComments: true,

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

@@ -25,6 +25,7 @@ const DEFAULT_STATE: ConsoleIssueState = {
 const DEFAULT_PR_STATUS: ConsolePullRequestStatus = {
   found: false,
   isConflicted: false,
+  mergeableStatus: 'UNKNOWN',
   isPassedAllCiJob: false,
   isCiStateSuccess: false,
   isBranchOutOfDate: false,

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

@@ -1,15 +1,31 @@
 import { act, renderHook } from '@testing-library/react';
+import { ResourceCache } from '../lib/resourceCache';
 import { overlayStorageKey } from '../logic/overlay';
 import {
   consoleListItemsFixture,
   consoleStatusOptionsFixture,
 } from '../testing/fixtures';
+import type { ConsoleCaches } from './useConsoleCaches';
 import { useConsoleOperations } from './useConsoleOperations';
 import { useConsoleOverlay } from './useConsoleOverlay';
 
 const prItem = consoleListItemsFixture[0];
 const issueItem = consoleListItemsFixture[2];
 
+const buildOperationCaches = (): ConsoleCaches => {
+  const never = () => new Promise<never>(() => {});
+  return {
+    client: {} as ConsoleCaches['client'],
+    body: new ResourceCache<string>(never),
+    comments: new ResourceCache(never),
+    files: new ResourceCache(never),
+    commits: new ResourceCache(never),
+    relatedPrs: new ResourceCache(never),
+    state: new ResourceCache(never),
+    prStatus: new ResourceCache(never),
+  };
+};
+
 const captureFetch = (): jest.Mock => {
   const fetchMock = jest.fn(async () => ({
     ok: true,
@@ -256,6 +272,57 @@ describe('useConsoleOperations', () => {
     });
   });
 
+  it('invalidates the operated item body and comments cache on a review', async () => {
+    captureFetch();
+    localStorage.clear();
+    window.history.replaceState({}, '', '/projects/umino/prs?k=token');
+    const caches = buildOperationCaches();
+    const bodyInvalidate = jest.spyOn(caches.body, 'invalidate');
+    const commentsInvalidate = jest.spyOn(caches.comments, 'invalidate');
+    const { result } = renderHook(() => {
+      const overlay = useConsoleOverlay('umino');
+      const operations = useConsoleOperations('umino', 'prs', overlay, caches);
+      return { overlay, operations };
+    });
+    await act(async () => {
+      await result.current.operations.reviewPullRequest(
+        prItem,
+        prItem.url,
+        'approve',
+      );
+    });
+    const key = `${prItem.repo}#${prItem.number}`;
+    expect(bodyInvalidate).toHaveBeenCalledWith(key);
+    expect(commentsInvalidate).toHaveBeenCalledWith(key);
+  });
+
+  it('invalidates the operated item cache after posting a comment', async () => {
+    const fetchMock: jest.Mock = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        ok: true,
+        comment: { author: 'a', body: 'b', createdAt: 'c' },
+      }),
+    }));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    localStorage.clear();
+    window.history.replaceState({}, '', '/projects/umino/prs?k=token');
+    const caches = buildOperationCaches();
+    const commentsInvalidate = jest.spyOn(caches.comments, 'invalidate');
+    const { result } = renderHook(() => {
+      const overlay = useConsoleOverlay('umino');
+      const operations = useConsoleOperations('umino', 'prs', overlay, caches);
+      return { overlay, operations };
+    });
+    await act(async () => {
+      await result.current.operations.addComment(issueItem, 'hello');
+    });
+    expect(commentsInvalidate).toHaveBeenCalledWith(
+      `${issueItem.repo}#${issueItem.number}`,
+    );
+  });
+
   it('rejects an operation and posts nothing when no pjcode is available', async () => {
     const fetchMock = captureFetch();
     localStorage.clear();

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

@@ -22,6 +22,7 @@ import type {
   ConsoleListItem,
   ConsoleTabName,
 } from '../logic/types';
+import type { ConsoleCaches } from './useConsoleCaches';
 import type { ConsoleOverlayState } from './useConsoleOverlay';
 import { useConsoleToken } from './useConsoleToken';
 
@@ -113,15 +114,29 @@ export const useConsoleOperations = (
   pjcode: string | null,
   mode: ConsoleTabName,
   overlayState: ConsoleOverlayState,
+  caches?: ConsoleCaches,
 ): ConsoleOperationsApi => {
   const { appendToken } = useConsoleToken();
   const { patchOverlay } = overlayState;
 
+  const invalidateItemContent = useCallback(
+    (item: ConsoleListItem) => {
+      if (caches === undefined) {
+        return;
+      }
+      const key = `${item.repo}#${item.number}`;
+      caches.body.invalidate(key);
+      caches.comments.invalidate(key);
+    },
+    [caches],
+  );
+
   const markDone = useCallback(
     (item: ConsoleListItem) => {
+      invalidateItemContent(item);
       patchOverlay(overlayKeyForItem(item), { done: true }, mode);
     },
-    [patchOverlay, mode],
+    [invalidateItemContent, patchOverlay, mode],
   );
 
   const reviewPullRequest = useCallback(
@@ -173,13 +188,14 @@ export const useConsoleOperations = (
         storyOptionId: option.id,
       };
       await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      invalidateItemContent(item);
       patchOverlay(
         overlayKeyForItem(item),
         { done: true, story: { name: option.name, color: option.color } },
         mode,
       );
     },
-    [pjcode, appendToken, patchOverlay, mode],
+    [pjcode, appendToken, invalidateItemContent, patchOverlay, mode],
   );
 
   const setStatus = useCallback(
@@ -195,13 +211,14 @@ export const useConsoleOperations = (
         statusName: option.name,
       };
       await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      invalidateItemContent(item);
       patchOverlay(
         overlayKeyForItem(item),
         { done: true, status: { name: option.name, color: option.color } },
         mode,
       );
     },
-    [pjcode, appendToken, patchOverlay, mode],
+    [pjcode, appendToken, invalidateItemContent, patchOverlay, mode],
   );
 
   const setInTmuxByHuman = useCallback(
@@ -216,13 +233,14 @@ export const useConsoleOperations = (
         projectItemId: item.projectItemId,
       };
       await postConsoleOperation(appendToken, INTMUX_OPERATION_PATH, request);
+      invalidateItemContent(item);
       patchOverlay(
         overlayKeyForItem(item),
         { done: true, status: { name: option.name, color: option.color } },
         mode,
       );
     },
-    [pjcode, appendToken, patchOverlay, mode],
+    [pjcode, appendToken, invalidateItemContent, patchOverlay, mode],
   );
 
   const closeIssue = useCallback(
@@ -247,13 +265,15 @@ export const useConsoleOperations = (
       if (pjcode === null) {
         throw missingPjcodeError();
       }
-      return postConsoleComment(appendToken, {
+      const comment = await postConsoleComment(appendToken, {
         pjcode,
         url: item.url,
         body,
       });
+      invalidateItemContent(item);
+      return comment;
     },
-    [pjcode, appendToken],
+    [pjcode, appendToken, invalidateItemContent],
   );
 
   const addInlineReviewComment = useCallback(

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

@@ -191,6 +191,7 @@ describe('createConsoleApiClient', () => {
       found: true,
       status: {
         isConflicted: true,
+        mergeableStatus: 'CONFLICTING',
         isPassedAllCiJob: false,
         isCiStateSuccess: false,
         isBranchOutOfDate: true,
@@ -203,6 +204,7 @@ describe('createConsoleApiClient', () => {
     ).toEqual({
       found: true,
       isConflicted: true,
+      mergeableStatus: 'CONFLICTING',
       isPassedAllCiJob: false,
       isCiStateSuccess: false,
       isBranchOutOfDate: true,
@@ -210,6 +212,24 @@ describe('createConsoleApiClient', () => {
     });
   });
 
+  it('defaults the mergeable status to unknown when the server omits it', async () => {
+    mockFetchOnce({
+      found: true,
+      status: {
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    });
+    const client = createConsoleApiClient(appendToken);
+    const status = await client.fetchPullRequestStatus(
+      'https://github.com/o/r/pull/1',
+    );
+    expect(status.mergeableStatus).toBe('UNKNOWN');
+  });
+
   it('returns a not-found pull request status when the server reports none', async () => {
     mockFetchOnce({ found: false, status: null });
     const client = createConsoleApiClient(appendToken);
@@ -218,6 +238,7 @@ describe('createConsoleApiClient', () => {
     ).toEqual({
       found: false,
       isConflicted: false,
+      mergeableStatus: 'UNKNOWN',
       isPassedAllCiJob: false,
       isCiStateSuccess: false,
       isBranchOutOfDate: false,

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

@@ -3,6 +3,7 @@ import type {
   ConsoleComment,
   ConsoleCommit,
   ConsoleIssueState,
+  ConsoleMergeableStatus,
   ConsolePullRequestStatus,
   ConsoleRelatedPullRequest,
 } from '../logic/types';
@@ -136,6 +137,16 @@ const parseStringArray = (value: unknown): string[] =>
     ? value.filter((name): name is string => typeof name === 'string')
     : [];
 
+const parseMergeableStatus = (value: unknown): ConsoleMergeableStatus => {
+  if (value === 'MERGEABLE') {
+    return 'MERGEABLE';
+  }
+  if (value === 'CONFLICTING') {
+    return 'CONFLICTING';
+  }
+  return 'UNKNOWN';
+};
+
 const parseRelatedPrs = (payload: unknown): ConsoleRelatedPullRequest[] => {
   if (!isRecord(payload) || !Array.isArray(payload.relatedPullRequests)) {
     return [];
@@ -146,6 +157,7 @@ const parseRelatedPrs = (payload: unknown): ConsoleRelatedPullRequest[] => {
     createdAt: getString(pr.createdAt),
     isDraft: getBoolean(pr.isDraft),
     isConflicted: getBoolean(pr.isConflicted),
+    mergeableStatus: parseMergeableStatus(pr.mergeableStatus),
     isPassedAllCiJob: getBoolean(pr.isPassedAllCiJob),
     isCiStateSuccess: getBoolean(pr.isCiStateSuccess),
     isResolvedAllReviewComments: getBoolean(pr.isResolvedAllReviewComments),
@@ -160,6 +172,7 @@ const parsePullRequestStatus = (payload: unknown): ConsolePullRequestStatus => {
     return {
       found: false,
       isConflicted: false,
+      mergeableStatus: 'UNKNOWN',
       isPassedAllCiJob: false,
       isCiStateSuccess: false,
       isBranchOutOfDate: false,
@@ -170,6 +183,7 @@ const parsePullRequestStatus = (payload: unknown): ConsolePullRequestStatus => {
   return {
     found: true,
     isConflicted: getBoolean(status.isConflicted),
+    mergeableStatus: parseMergeableStatus(status.mergeableStatus),
     isPassedAllCiJob: getBoolean(status.isPassedAllCiJob),
     isCiStateSuccess: getBoolean(status.isCiStateSuccess),
     isBranchOutOfDate: getBoolean(status.isBranchOutOfDate),