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

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

@@ -130,6 +130,7 @@ describe('ConsoleItemDetail', () => {
         pullRequestStatus={{
           found: true,
           isConflicted: true,
+          mergeableStatus: 'CONFLICTING',
           isPassedAllCiJob: false,
           isCiStateSuccess: false,
           isBranchOutOfDate: true,
@@ -161,6 +162,7 @@ describe('ConsoleItemDetail', () => {
         pullRequestStatus={{
           found: true,
           isConflicted: false,
+          mergeableStatus: 'MERGEABLE',
           isPassedAllCiJob: true,
           isCiStateSuccess: true,
           isBranchOutOfDate: false,
@@ -169,7 +171,7 @@ describe('ConsoleItemDetail', () => {
       />,
     );
     expect(getByText('CI passing')).toBeInTheDocument();
-    expect(queryByText('Conflict')).toBeNull();
+    expect(getByText('No conflict')).toBeInTheDocument();
     expect(queryByText('Out of date')).toBeNull();
   });
 

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

@@ -158,7 +158,7 @@ export const ConsoleItemDetail = ({
       {item.isPr && pullRequestStatus?.found && (
         <div className="console-detail-pr-status-row">
           <ConsolePullRequestStatusBadges
-            isConflicted={pullRequestStatus.isConflicted}
+            mergeableStatus={pullRequestStatus.mergeableStatus}
             isPassedAllCiJob={pullRequestStatus.isPassedAllCiJob}
             isCiStateSuccess={pullRequestStatus.isCiStateSuccess}
             isBranchOutOfDate={pullRequestStatus.isBranchOutOfDate}

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

@@ -62,6 +62,7 @@ describe('ConsolePullRequestDetail', () => {
         pullRequest={{
           ...pullRequest,
           isConflicted: true,
+          mergeableStatus: 'CONFLICTING',
           isPassedAllCiJob: false,
           isCiStateSuccess: false,
           isBranchOutOfDate: true,

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

@@ -64,7 +64,7 @@ export const ConsolePullRequestDetail = ({
           <span className="console-pr-section-state">draft</span>
         )}
         <ConsolePullRequestStatusBadges
-          isConflicted={pullRequest.isConflicted}
+          mergeableStatus={pullRequest.mergeableStatus}
           isPassedAllCiJob={pullRequest.isPassedAllCiJob}
           isCiStateSuccess={pullRequest.isCiStateSuccess}
           isBranchOutOfDate={pullRequest.isBranchOutOfDate}

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

@@ -10,9 +10,9 @@ export default meta;
 
 type Story = StoryObj<typeof ConsolePullRequestStatusBadges>;
 
-export const Passing: Story = {
+export const PassingAndMergeable: Story = {
   args: {
-    isConflicted: false,
+    mergeableStatus: 'MERGEABLE',
     isPassedAllCiJob: true,
     isCiStateSuccess: true,
     isBranchOutOfDate: false,
@@ -22,7 +22,7 @@ export const Passing: Story = {
 
 export const FailingWithMissingChecks: Story = {
   args: {
-    isConflicted: false,
+    mergeableStatus: 'MERGEABLE',
     isPassedAllCiJob: false,
     isCiStateSuccess: false,
     isBranchOutOfDate: false,
@@ -30,12 +30,22 @@ export const FailingWithMissingChecks: Story = {
   },
 };
 
-export const ConflictedAndOutOfDate: Story = {
+export const ConflictingAndOutOfDate: Story = {
   args: {
-    isConflicted: true,
+    mergeableStatus: 'CONFLICTING',
     isPassedAllCiJob: false,
     isCiStateSuccess: false,
     isBranchOutOfDate: true,
     missingRequiredCheckNames: ['build', 'test'],
   },
 };
+
+export const CheckingMergeStatus: Story = {
+  args: {
+    mergeableStatus: 'UNKNOWN',
+    isPassedAllCiJob: true,
+    isCiStateSuccess: true,
+    isBranchOutOfDate: false,
+    missingRequiredCheckNames: [],
+  },
+};

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();