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

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.91.3](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/compare/v1.91.2...v1.91.3) (2026-06-21)
+
+
+### Bug Fixes
+
+* **console:** anchor read API paths at server root so per-project routes load detail content ([#879](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/879)) ([789e4a1](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/commit/789e4a1da0ec087e061f051de08af7d30e3735ef))
+
+## [1.91.2](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/compare/v1.91.1...v1.91.2) (2026-06-20)
+
+
+### Bug Fixes
+
+* **console:** apply processed-item overlay to all tab badges so a zeroed tab stays zero ([#871](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/871)) ([4eda1ab](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/commit/4eda1ab29cce54969c5fcc2b8a5ff838013978f7)), closes [#868](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/868)
+
 ## [1.91.1](https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/compare/v1.91.0...v1.91.1) (2026-06-20)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.91.1",
+  "version": "1.91.3",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

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

@@ -20,10 +20,38 @@ describe('createConsoleApiClient', () => {
     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('/api/itembody?url=');
     expect(requested).toContain('&k=token');
   });
 
+  it('anchors every read endpoint at the server root regardless of route', async () => {
+    const readers: ((url: string) => Promise<unknown>)[] = [];
+    const client = createConsoleApiClient(appendToken);
+    readers.push((url) => client.fetchItemBody(url));
+    readers.push((url) => client.fetchComments(url));
+    readers.push((url) => client.fetchPrFiles(url));
+    readers.push((url) => client.fetchPrCommits(url));
+    readers.push((url) => client.fetchRelatedPrs(url));
+    readers.push((url) => client.fetchIssueState(url));
+    const expectedPaths = [
+      '/api/itembody',
+      '/api/comments',
+      '/api/prfiles',
+      '/api/prcommits',
+      '/api/relatedprs',
+      '/api/issuetitle',
+    ];
+    for (let index = 0; index < readers.length; index += 1) {
+      const fetchMock = mockFetchOnce({});
+      await readers[index]('https://github.com/o/r/issues/1');
+      const requested = fetchMock.mock.calls[0][0] as string;
+      expect(requested.startsWith(expectedPaths[index])).toBe(true);
+      expect(requested.startsWith('/api/')).toBe(true);
+      expect(requested.startsWith('./')).toBe(false);
+      expect(requested.startsWith('/projects')).toBe(false);
+    }
+  });
+
   it('parses comments', async () => {
     mockFetchOnce({
       comments: [

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

@@ -156,19 +156,19 @@ export const createConsoleApiClient = (
   appendToken: AppendToken,
 ): ConsoleApiClient => ({
   fetchItemBody: async (url) => {
-    const payload = await requestJson(appendToken, './api/itembody', 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)),
+    parseComments(await requestJson(appendToken, '/api/comments', url)),
   fetchPrFiles: async (url) =>
-    parseFiles(await requestJson(appendToken, './api/prfiles', url)),
+    parseFiles(await requestJson(appendToken, '/api/prfiles', url)),
   fetchPrCommits: async (url) =>
-    parseCommits(await requestJson(appendToken, './api/prcommits', url)),
+    parseCommits(await requestJson(appendToken, '/api/prcommits', url)),
   fetchRelatedPrs: async (url) =>
-    parseRelatedPrs(await requestJson(appendToken, './api/relatedprs', url)),
+    parseRelatedPrs(await requestJson(appendToken, '/api/relatedprs', url)),
   fetchIssueState: async (url) =>
-    parseState(await requestJson(appendToken, './api/issuetitle', url)),
+    parseState(await requestJson(appendToken, '/api/issuetitle', url)),
 });
 
 export const postConsoleOperation = async (

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

@@ -1,12 +1,9 @@
 import {
   countPendingItems,
   filterPendingItems,
-  getOverlayEntry,
-  isOverlayEntryActedForMode,
-  isOverlayEntryExpiredForMode,
+  isOverlayEntryActed,
   overlayKeyForItem,
   overlayStorageKey,
-  parseGeneratedAtMs,
   writeOverlayEntry,
 } from './overlay';
 import type { ConsoleListItem, ConsoleOverlay } from './types';
@@ -34,68 +31,71 @@ describe('overlay helpers', () => {
     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);
+  it('falls back to the itemId when the projectItemId is empty', () => {
+    expect(overlayKeyForItem({ ...item(5), projectItemId: '' })).toBe('PVTI_5');
   });
 });
 
-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);
+describe('isOverlayEntryActed', () => {
+  it('treats a done entry as acted', () => {
+    expect(isOverlayEntryActed({ ts: 100, mode: 'prs', done: true })).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('treats a missing entry as not acted', () => {
+    expect(isOverlayEntryActed(undefined)).toBe(false);
   });
 
-  it('does not expire an entry written after the snapshot', () => {
+  it('treats an entry without done as not acted', () => {
     expect(
-      isOverlayEntryExpiredForMode(
-        { ts: 300, mode: 'prs', done: true },
-        200,
-        'prs',
-      ),
+      isOverlayEntryActed({
+        ts: 100,
+        mode: 'prs',
+        story: { name: 'Story', color: 'BLUE' },
+      }),
     ).toBe(false);
   });
+
+  it('treats a done entry as acted regardless of the mode it was written in', () => {
+    expect(isOverlayEntryActed({ ts: 100, mode: 'triage', done: true })).toBe(
+      true,
+    );
+  });
 });
 
 describe('counts driven to zero do not revive on tab switch', () => {
-  it('keeps a done item subtracted in its own mode', () => {
+  it('keeps a done item subtracted in the tab it was processed in', () => {
     const overlay: ConsoleOverlay = {
       PVTI_1: { ts: 500, mode: 'prs', done: true },
     };
-    const generatedAtMs = 400;
-    expect(countPendingItems([item(1)], overlay, generatedAtMs, 'prs')).toBe(0);
+    expect(countPendingItems([item(1)], overlay)).toBe(0);
   });
 
-  it('treats a done entry from another mode as still acted', () => {
+  it('keeps a done item subtracted from every tab regardless of its mode', () => {
     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);
+    expect(countPendingItems([item(1)], overlay)).toBe(0);
+  });
+
+  it('does not revive a done item even when an entry was processed before the snapshot it still appears in', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(countPendingItems([item(1)], overlay)).toBe(0);
   });
 
-  it('revives the count only when a newer same-mode snapshot supersedes the entry', () => {
+  it('does not revive a done item when it appears in a tab other than the one it was processed in', () => {
     const overlay: ConsoleOverlay = {
       PVTI_1: { ts: 100, mode: 'prs', done: true },
     };
-    expect(countPendingItems([item(1)], overlay, 200, 'prs')).toBe(1);
+    expect(countPendingItems([item(1)], overlay)).toBe(0);
+    expect(filterPendingItems([item(1)], overlay)).toEqual([]);
+  });
+
+  it('counts an item that has no done entry', () => {
+    expect(countPendingItems([item(1)], {})).toBe(1);
   });
 });
 
@@ -104,21 +104,43 @@ describe('filterPendingItems', () => {
     const overlay: ConsoleOverlay = {
       PVTI_1: { ts: 500, mode: 'prs', done: true },
     };
-    const result = filterPendingItems([item(1), item(2)], overlay, 400, 'prs');
+    const result = filterPendingItems([item(1), item(2)], overlay);
     expect(result.map((entry) => entry.number)).toEqual([2]);
   });
-});
 
-describe('getOverlayEntry and writeOverlayEntry', () => {
-  it('returns null for an expired entry', () => {
+  it('keeps the badge count and the filtered list consistent', () => {
     const overlay: ConsoleOverlay = {
-      PVTI_1: { ts: 100, mode: 'prs', done: true },
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
     };
-    expect(getOverlayEntry(overlay, item(1), 200, 'prs')).toBeNull();
+    const items = [item(1), item(2)];
+    expect(countPendingItems(items, overlay)).toBe(
+      filterPendingItems(items, overlay).length,
+    );
   });
+});
 
+describe('writeOverlayEntry', () => {
   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' });
   });
+
+  it('merges a patch into an existing entry while refreshing ts and mode', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    const next = writeOverlayEntry(
+      overlay,
+      'PVTI_1',
+      { story: { name: 'New Story', color: 'GREEN' } },
+      'triage',
+      999,
+    );
+    expect(next.PVTI_1).toEqual({
+      done: true,
+      story: { name: 'New Story', color: 'GREEN' },
+      ts: 999,
+      mode: 'triage',
+    });
+  });
 });

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

@@ -11,76 +11,23 @@ export const overlayStorageKey = (pjcode: string): string =>
 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 = (
+export const isOverlayEntryActed = (
   entry: ConsoleOverlayEntry | undefined,
-  generatedAtMs: number,
-  mode: ConsoleTabName,
-): boolean => {
-  if (entry === undefined || entry.done !== true) {
-    return false;
-  }
-  return !isOverlayEntryExpiredForMode(entry, generatedAtMs, mode);
-};
+): boolean => entry !== undefined && entry.done === true;
 
 export const countPendingItems = (
   items: ConsoleListItem[],
   overlay: ConsoleOverlay,
-  generatedAtMs: number,
-  mode: ConsoleTabName,
 ): number =>
-  items.filter(
-    (item) =>
-      !isOverlayEntryActedForMode(
-        overlay[overlayKeyForItem(item)],
-        generatedAtMs,
-        mode,
-      ),
-  ).length;
+  items.filter((item) => !isOverlayEntryActed(overlay[overlayKeyForItem(item)]))
+    .length;
 
 export const filterPendingItems = (
   items: ConsoleListItem[],
   overlay: ConsoleOverlay,
-  generatedAtMs: number,
-  mode: ConsoleTabName,
 ): ConsoleListItem[] =>
   items.filter(
-    (item) =>
-      !isOverlayEntryActedForMode(
-        overlay[overlayKeyForItem(item)],
-        generatedAtMs,
-        mode,
-      ),
+    (item) => !isOverlayEntryActed(overlay[overlayKeyForItem(item)]),
   );
 
 export const writeOverlayEntry = (

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

@@ -28,7 +28,23 @@ const listPayload = (tab: string) => ({
             createdAt: '2026-06-17T00:00:00.000Z',
           },
         ]
-      : [],
+      : tab === 'unread'
+        ? [
+            {
+              number: 866,
+              title: 'Notify finished issue preparation',
+              url: 'https://github.com/o/r/issues/866',
+              repo: 'o/r',
+              nameWithOwner: 'o/r',
+              projectItemId: 'PVTI_2',
+              itemId: 'PVTI_2',
+              isPr: false,
+              story: 'TDPM Console port',
+              labels: [],
+              createdAt: '2026-06-18T00:00:00.000Z',
+            },
+          ]
+        : [],
 });
 
 const installFetch = (): void => {
@@ -71,4 +87,42 @@ describe('ConsolePage', () => {
     expect(await findByText('← Back to list')).toBeInTheDocument();
     expect(getByText('Approve')).toBeInTheDocument();
   });
+
+  it('keeps a tab driven to zero at zero and does not revive its badge after switching tabs', async () => {
+    const { getByText, queryByText, findByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    expect(
+      getByText('Awaiting Quality Check')
+        .closest('button')
+        ?.querySelector('.console-tab-badge')?.textContent,
+    ).toBe('1');
+
+    fireEvent.click(getByText('Add serveConsole subcommand'));
+    expect(await findByText('← Back to list')).toBeInTheDocument();
+    fireEvent.click(getByText('Approve'));
+
+    await waitFor(() => {
+      expect(
+        getByText('Awaiting Quality Check')
+          .closest('button')
+          ?.querySelector('.console-tab-badge')?.textContent,
+      ).toBe('0');
+    });
+
+    fireEvent.click(getByText('Unread'));
+    await waitFor(() => {
+      expect(
+        getByText('Notify finished issue preparation'),
+      ).toBeInTheDocument();
+    });
+
+    const prsTabButton = queryByText('Awaiting Quality Check')?.closest(
+      'button',
+    );
+    const prsBadge =
+      prsTabButton?.querySelector('.console-tab-badge')?.textContent ?? '0';
+    expect(prsBadge).toBe('0');
+  });
 });

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

@@ -12,7 +12,6 @@ import {
   countPendingItems,
   filterPendingItems,
   overlayKeyForItem,
-  parseGeneratedAtMs,
 } from '../logic/overlay';
 import type {
   ConsoleListItem,
@@ -57,8 +56,6 @@ export const ConsolePage = () => {
       result[tab.name] = countPendingItems(
         snapshot.items,
         overlayState.overlay,
-        parseGeneratedAtMs(snapshot.generatedAt),
-        tab.name,
       );
     }
     return result;
@@ -69,13 +66,8 @@ export const ConsolePage = () => {
     if (activeSnapshot === null) {
       return [];
     }
-    return filterPendingItems(
-      activeSnapshot.items,
-      overlayState.overlay,
-      parseGeneratedAtMs(activeSnapshot.generatedAt),
-      activeTab,
-    );
-  }, [activeSnapshot, overlayState.overlay, activeTab]);
+    return filterPendingItems(activeSnapshot.items, overlayState.overlay);
+  }, [activeSnapshot, overlayState.overlay]);
 
   const rows = useMemo(
     () => buildConsoleListRows(pendingItems, overlayState.overlay),