github-issue-tower-defence-management 1.91.2 → 1.91.4

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

@@ -0,0 +1,111 @@
+import { useCallback, useEffect, useState } from 'react';
+import { CONSOLE_TABS, type ConsoleTabName } from '../logic/types';
+
+const TAB_NAMES = new Set<string>(CONSOLE_TABS.map((tab) => tab.name));
+
+export const parseTabFromPath = (pathname: string): ConsoleTabName | null => {
+  const segments = pathname.split('/').filter((segment) => segment.length > 0);
+  if (segments.length < 3 || segments[0] !== 'projects') {
+    return null;
+  }
+  const candidate = segments[2];
+  return TAB_NAMES.has(candidate) ? (candidate as ConsoleTabName) : null;
+};
+
+export const parseItemKeyFromHash = (hash: string): string | null => {
+  const prefix = '#item/';
+  if (!hash.startsWith(prefix)) {
+    return null;
+  }
+  const encoded = hash.slice(prefix.length);
+  if (encoded.length === 0) {
+    return null;
+  }
+  return decodeURIComponent(encoded);
+};
+
+export type ConsoleNavigation = {
+  activeTab: ConsoleTabName;
+  selectedItemKey: string | null;
+  tabHref: (tab: ConsoleTabName) => string;
+  selectTab: (tab: ConsoleTabName) => void;
+  openItem: (itemKey: string) => void;
+  closeItem: () => void;
+};
+
+export const useConsoleNavigation = (
+  pjcode: string | null,
+): ConsoleNavigation => {
+  const readState = useCallback((): {
+    activeTab: ConsoleTabName;
+    selectedItemKey: string | null;
+  } => {
+    if (typeof window === 'undefined') {
+      return { activeTab: CONSOLE_TABS[0].name, selectedItemKey: null };
+    }
+    return {
+      activeTab:
+        parseTabFromPath(window.location.pathname) ?? CONSOLE_TABS[0].name,
+      selectedItemKey: parseItemKeyFromHash(window.location.hash),
+    };
+  }, []);
+
+  const [state, setState] = useState(readState);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    const sync = (): void => {
+      setState(readState());
+    };
+    window.addEventListener('popstate', sync);
+    window.addEventListener('hashchange', sync);
+    return () => {
+      window.removeEventListener('popstate', sync);
+      window.removeEventListener('hashchange', sync);
+    };
+  }, [readState]);
+
+  const tabHref = useCallback(
+    (tab: ConsoleTabName): string =>
+      pjcode === null ? `#${tab}` : `/projects/${pjcode}/${tab}`,
+    [pjcode],
+  );
+
+  const selectTab = useCallback(
+    (tab: ConsoleTabName): void => {
+      if (typeof window === 'undefined') {
+        setState({ activeTab: tab, selectedItemKey: null });
+        return;
+      }
+      window.history.pushState({}, '', tabHref(tab));
+      setState({ activeTab: tab, selectedItemKey: null });
+    },
+    [tabHref],
+  );
+
+  const openItem = useCallback((itemKey: string): void => {
+    if (typeof window !== 'undefined') {
+      window.location.hash = `#item/${encodeURIComponent(itemKey)}`;
+    }
+    setState((current) => ({ ...current, selectedItemKey: itemKey }));
+  }, []);
+
+  const closeItem = useCallback((): void => {
+    if (typeof window !== 'undefined' && window.location.hash !== '') {
+      const url = `${window.location.pathname}${window.location.search}`;
+      window.history.pushState({}, '', url);
+    }
+    setState((current) => ({ ...current, selectedItemKey: null }));
+  }, []);
+
+  return {
+    activeTab: state.activeTab,
+    selectedItemKey: state.selectedItemKey,
+    tabHref,
+    selectTab,
+    openItem,
+    closeItem,
+  };
+};

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

@@ -177,6 +177,43 @@ describe('useConsoleOperations', () => {
     expect(stored[issueItem.projectItemId].done).toBe(true);
   });
 
+  it('posts a comment to the comment endpoint and returns the created comment', async () => {
+    const fetchMock: jest.Mock = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        ok: true,
+        comment: {
+          author: 'HiromiShikata',
+          body: 'Thanks for the parity fix.',
+          createdAt: '2026-06-18T03:21:00.000Z',
+        },
+      }),
+    }));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { result } = setup();
+    let created: Awaited<
+      ReturnType<typeof result.current.operations.addComment>
+    > | null = null;
+    await act(async () => {
+      created = await result.current.operations.addComment(
+        issueItem,
+        'Thanks for the parity fix.',
+      );
+    });
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/comment?k=token');
+    expect(lastBody(fetchMock)).toMatchObject({
+      pjcode: 'umino',
+      url: issueItem.url,
+      body: 'Thanks for the parity fix.',
+    });
+    expect(created).toEqual({
+      author: 'HiromiShikata',
+      body: 'Thanks for the parity fix.',
+      createdAt: '2026-06-18T03:21:00.000Z',
+    });
+  });
+
   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

@@ -3,6 +3,7 @@ import {
   type ConsoleIntmuxRequest,
   type ConsoleReviewRequest,
   type ConsoleTriageRequest,
+  postConsoleComment,
   postConsoleOperation,
 } from '../lib/consoleApi';
 import {
@@ -14,6 +15,7 @@ import {
 } from '../logic/operations';
 import { overlayKeyForItem } from '../logic/overlay';
 import type {
+  ConsoleComment,
   ConsoleFieldOption,
   ConsoleListItem,
   ConsoleTabName,
@@ -51,6 +53,7 @@ export type ConsoleOperationsApi = {
     item: ConsoleListItem,
     action: ConsoleCloseAction,
   ) => Promise<void>;
+  addComment: (item: ConsoleListItem, body: string) => Promise<ConsoleComment>;
 };
 
 const reviewRequest = (
@@ -232,6 +235,20 @@ export const useConsoleOperations = (
     [pjcode, appendToken, markDone],
   );
 
+  const addComment = useCallback(
+    async (item: ConsoleListItem, body: string) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      return postConsoleComment(appendToken, {
+        pjcode,
+        url: item.url,
+        body,
+      });
+    },
+    [pjcode, appendToken],
+  );
+
   return {
     reviewPullRequest,
     setNextActionDate,
@@ -239,5 +256,6 @@ export const useConsoleOperations = (
     setStatus,
     setInTmuxByHuman,
     closeIssue,
+    addComment,
   };
 };

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 (
@@ -185,3 +185,37 @@ export const postConsoleOperation = async (
     throw new Error(`HTTP ${response.status}`);
   }
 };
+
+export const COMMENT_OPERATION_PATH = '/api/comment';
+
+export type ConsoleCommentRequest = {
+  pjcode: string;
+  url: string;
+  body: string;
+};
+
+const parsePostedComment = (payload: unknown): ConsoleComment => {
+  if (!isRecord(payload) || !isRecord(payload.comment)) {
+    throw new Error('comment was not returned');
+  }
+  return {
+    author: getString(payload.comment.author),
+    body: getString(payload.comment.body),
+    createdAt: getString(payload.comment.createdAt),
+  };
+};
+
+export const postConsoleComment = async (
+  appendToken: AppendToken,
+  request: ConsoleCommentRequest,
+): Promise<ConsoleComment> => {
+  const response = await fetch(appendToken(COMMENT_OPERATION_PATH), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return parsePostedComment(await response.json());
+};

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

@@ -47,6 +47,11 @@ const buildOperations = (): ConsoleOperationsApi => ({
   setStatus: jest.fn(async () => {}),
   setInTmuxByHuman: jest.fn(async () => {}),
   closeIssue: jest.fn(async () => {}),
+  addComment: jest.fn(async () => ({
+    author: 'HiromiShikata',
+    body: 'comment body',
+    createdAt: '2026-06-19T11:58:00.000Z',
+  })),
 });
 
 describe('ConsoleItemDetailContainer', () => {

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

@@ -1,3 +1,4 @@
+import { ConsoleCommentComposer } from '../components/detail/ConsoleCommentComposer';
 import { ConsoleItemDetail } from '../components/detail/ConsoleItemDetail';
 import { ConsoleOperationMenu } from '../components/operations/ConsoleOperationMenu';
 import type { ConsoleCaches } from '../hooks/useConsoleCaches';
@@ -94,6 +95,13 @@ export const ConsoleItemDetailContainer = ({
       commitsError={detail.commitsError}
       relatedPullRequests={detail.relatedPullRequests}
       now={now}
+      commentComposer={
+        <ConsoleCommentComposer
+          isPr={item.isPr}
+          now={now}
+          onSubmit={(body) => operations.addComment(item, body)}
+        />
+      }
       operationBar={
         <ConsoleOperationMenu
           tab={tab}

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

@@ -84,8 +84,17 @@ describe('ConsolePage', () => {
       expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
     });
     fireEvent.click(getByText('Add serveConsole subcommand'));
-    expect(await findByText('← Back to list')).toBeInTheDocument();
-    expect(getByText('Approve')).toBeInTheDocument();
+    expect(await findByText('Approve')).toBeInTheDocument();
+    expect(window.location.hash).toBe('#item/PVTI_1');
+  });
+
+  it('renders the per-tab count sub-heading and snapshot time', async () => {
+    const { getByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    expect(getByText('1 items awaiting quality check')).toBeInTheDocument();
+    expect(getByText('snapshot: 2026-06-19T00:00:00.000Z')).toBeInTheDocument();
   });
 
   it('keeps a tab driven to zero at zero and does not revive its badge after switching tabs', async () => {
@@ -95,18 +104,18 @@ describe('ConsolePage', () => {
     });
     expect(
       getByText('Awaiting Quality Check')
-        .closest('button')
+        .closest('a')
         ?.querySelector('.console-tab-badge')?.textContent,
     ).toBe('1');
 
     fireEvent.click(getByText('Add serveConsole subcommand'));
-    expect(await findByText('← Back to list')).toBeInTheDocument();
+    expect(await findByText('Approve')).toBeInTheDocument();
     fireEvent.click(getByText('Approve'));
 
     await waitFor(() => {
       expect(
         getByText('Awaiting Quality Check')
-          .closest('button')
+          .closest('a')
           ?.querySelector('.console-tab-badge')?.textContent,
       ).toBe('0');
     });
@@ -118,11 +127,19 @@ describe('ConsolePage', () => {
       ).toBeInTheDocument();
     });
 
-    const prsTabButton = queryByText('Awaiting Quality Check')?.closest(
-      'button',
-    );
+    const prsTabLink = queryByText('Awaiting Quality Check')?.closest('a');
     const prsBadge =
-      prsTabButton?.querySelector('.console-tab-badge')?.textContent ?? '0';
+      prsTabLink?.querySelector('.console-tab-badge')?.textContent ?? '0';
     expect(prsBadge).toBe('0');
   });
+
+  it('shows every tab even when its count is zero', async () => {
+    const { getByText, queryByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    expect(queryByText('Triage')).not.toBeNull();
+    expect(queryByText('Failed Preparation')).not.toBeNull();
+    expect(queryByText('Todo by human')).not.toBeNull();
+  });
 });

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

@@ -1,8 +1,9 @@
-import { useMemo, useState } from 'react';
+import { useMemo } from 'react';
 import { ConsoleProjectSummary } from '../components/layout/ConsoleProjectSummary';
 import { ConsoleTabList } from '../components/layout/ConsoleTabList';
 import { ConsoleItemList } from '../components/list/ConsoleItemList';
 import { useConsoleCaches } from '../hooks/useConsoleCaches';
+import { useConsoleNavigation } from '../hooks/useConsoleNavigation';
 import { useConsoleOperations } from '../hooks/useConsoleOperations';
 import { useConsoleOverlay } from '../hooks/useConsoleOverlay';
 import { useConsolePjcode } from '../hooks/useConsolePjcode';
@@ -34,12 +35,8 @@ const OVERLAY_NAMESPACE_FALLBACK = 'console';
 export const ConsolePage = () => {
   const pjcode = useConsolePjcode();
   const { snapshots, isLoading, error } = useConsoleTabData(pjcode);
-  const [activeTab, setActiveTab] = useState<ConsoleTabName>(
-    CONSOLE_TABS[0].name,
-  );
-  const [selectedItem, setSelectedItem] = useState<ConsoleListItem | null>(
-    null,
-  );
+  const navigation = useConsoleNavigation(pjcode);
+  const { activeTab, selectedItemKey } = navigation;
 
   const overlayState = useConsoleOverlay(pjcode ?? OVERLAY_NAMESPACE_FALLBACK);
   const caches = useConsoleCaches();
@@ -77,11 +74,18 @@ export const ConsolePage = () => {
   const storyColors = activeSnapshot?.storyColors ?? {};
   const statusOptions = activeSnapshot?.statusOptions ?? [];
   const storyOptions = activeSnapshot?.storyOptions ?? [];
+  const generatedAt = activeSnapshot?.generatedAt ?? null;
 
-  const selectTab = (tab: ConsoleTabName): void => {
-    setActiveTab(tab);
-    setSelectedItem(null);
-  };
+  const selectedItem = useMemo<ConsoleListItem | null>(() => {
+    if (selectedItemKey === null || activeSnapshot === null) {
+      return null;
+    }
+    return (
+      activeSnapshot.items.find(
+        (item) => item.projectItemId === selectedItemKey,
+      ) ?? null
+    );
+  }, [selectedItemKey, activeSnapshot]);
 
   const overlayStatusForSelected = ((): ConsoleOverlayStatus | null => {
     if (selectedItem === null) {
@@ -102,26 +106,23 @@ export const ConsolePage = () => {
       <ConsoleTabList
         activeTab={activeTab}
         counts={counts}
-        onSelectTab={selectTab}
+        pjcode={pjcode}
+        generatedAt={generatedAt}
+        tabHref={navigation.tabHref}
+        onSelectTab={navigation.selectTab}
       />
       {selectedItem === null ? (
         <ConsoleItemList
           rows={rows}
           storyColors={storyColors}
           activeItemId={null}
+          now={now}
           isLoading={isLoading}
           error={error}
-          onSelectItem={setSelectedItem}
+          onSelectItem={(item) => navigation.openItem(item.projectItemId)}
         />
       ) : (
         <div className="console-detail-screen">
-          <button
-            type="button"
-            className="console-back-button"
-            onClick={() => setSelectedItem(null)}
-          >
-            ← Back to list
-          </button>
           <ConsoleItemDetailContainer
             tab={activeTab}
             item={selectedItem}