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

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

@@ -0,0 +1,37 @@
+import {
+  IN_TMUX_BY_HUMAN_NAME,
+  isTodoByHumanTab,
+  STATUS_BUTTON_NAMES,
+  TOTALLY_WRONG_COMMENT_BODY,
+  UNNECESSARY_COMMENT_BODY,
+} from './operations';
+
+describe('operation constants', () => {
+  it('defines the totally wrong comment body', () => {
+    expect(TOTALLY_WRONG_COMMENT_BODY).toBe('totally wrong');
+  });
+
+  it('defines the unnecessary comment body', () => {
+    expect(UNNECESSARY_COMMENT_BODY).toBe('This pull request is unnecessary.');
+  });
+
+  it('lists the status buttons left to right', () => {
+    expect(STATUS_BUTTON_NAMES).toEqual([
+      'In Tmux by agent',
+      'In Tmux by human',
+      'Todo by human',
+      'Awaiting Workspace',
+    ]);
+  });
+
+  it('names the in-tmux-by-human status', () => {
+    expect(IN_TMUX_BY_HUMAN_NAME).toBe('In Tmux by human');
+  });
+});
+
+describe('isTodoByHumanTab', () => {
+  it('is true only for the todo-by-human tab', () => {
+    expect(isTodoByHumanTab('todo-by-human')).toBe(true);
+    expect(isTodoByHumanTab('prs')).toBe(false);
+  });
+});

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

@@ -0,0 +1,35 @@
+import type { ConsoleFieldOption, ConsoleTabName } from './types';
+
+export const TOTALLY_WRONG_COMMENT_BODY = 'totally wrong';
+export const UNNECESSARY_COMMENT_BODY = 'This pull request is unnecessary.';
+
+export type ConsoleReviewAction =
+  | 'approve'
+  | 'request_changes'
+  | 'unnecessary'
+  | 'totally_wrong';
+
+export type ConsoleNextActionDateAction = 'snooze_1day' | 'snooze_1week';
+
+export type ConsoleCloseAction = 'close' | 'close_not_planned';
+
+export type ConsoleOperationHandlers = {
+  onReview: (action: ConsoleReviewAction) => void;
+  onSetNextActionDate: (action: ConsoleNextActionDateAction) => void;
+  onSetStory: (option: ConsoleFieldOption) => void;
+  onSetStatus: (option: ConsoleFieldOption) => void;
+  onSetInTmuxByHuman: (option: ConsoleFieldOption) => void;
+  onClose: (action: ConsoleCloseAction) => void;
+};
+
+export const STATUS_BUTTON_NAMES: string[] = [
+  'In Tmux by agent',
+  'In Tmux by human',
+  'Todo by human',
+  'Awaiting Workspace',
+];
+
+export const IN_TMUX_BY_HUMAN_NAME = 'In Tmux by human';
+
+export const isTodoByHumanTab = (tab: ConsoleTabName): boolean =>
+  tab === 'todo-by-human';

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

@@ -0,0 +1,124 @@
+import {
+  countPendingItems,
+  filterPendingItems,
+  getOverlayEntry,
+  isOverlayEntryActedForMode,
+  isOverlayEntryExpiredForMode,
+  overlayKeyForItem,
+  overlayStorageKey,
+  parseGeneratedAtMs,
+  writeOverlayEntry,
+} from './overlay';
+import type { ConsoleListItem, ConsoleOverlay } from './types';
+
+const item = (number: number): 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',
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+});
+
+describe('overlay helpers', () => {
+  it('builds the per-project storage key', () => {
+    expect(overlayStorageKey('umino')).toBe('pv_overlay_umino');
+  });
+
+  it('uses the projectItemId as the overlay key when present', () => {
+    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);
+  });
+});
+
+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);
+  });
+
+  it('does not expire an entry written in a different mode', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 100, mode: 'triage', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+
+  it('does not expire an entry written after the snapshot', () => {
+    expect(
+      isOverlayEntryExpiredForMode(
+        { ts: 300, mode: 'prs', done: true },
+        200,
+        'prs',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('counts driven to zero do not revive on tab switch', () => {
+  it('keeps a done item subtracted in its own mode', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const generatedAtMs = 400;
+    expect(countPendingItems([item(1)], overlay, generatedAtMs, 'prs')).toBe(0);
+  });
+
+  it('treats a done entry from another mode as still acted', () => {
+    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);
+  });
+
+  it('revives the count only when a newer same-mode snapshot supersedes the entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(countPendingItems([item(1)], overlay, 200, 'prs')).toBe(1);
+  });
+});
+
+describe('filterPendingItems', () => {
+  it('drops acted items and keeps the rest', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'prs', done: true },
+    };
+    const result = filterPendingItems([item(1), item(2)], overlay, 400, 'prs');
+    expect(result.map((entry) => entry.number)).toEqual([2]);
+  });
+});
+
+describe('getOverlayEntry and writeOverlayEntry', () => {
+  it('returns null for an expired entry', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 100, mode: 'prs', done: true },
+    };
+    expect(getOverlayEntry(overlay, item(1), 200, 'prs')).toBeNull();
+  });
+
+  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' });
+  });
+});

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

@@ -0,0 +1,101 @@
+import type {
+  ConsoleListItem,
+  ConsoleOverlay,
+  ConsoleOverlayEntry,
+  ConsoleTabName,
+} from './types';
+
+export const overlayStorageKey = (pjcode: string): string =>
+  `pv_overlay_${pjcode}`;
+
+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 = (
+  entry: ConsoleOverlayEntry | undefined,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): boolean => {
+  if (entry === undefined || entry.done !== true) {
+    return false;
+  }
+  return !isOverlayEntryExpiredForMode(entry, generatedAtMs, mode);
+};
+
+export const countPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): number =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  ).length;
+
+export const filterPendingItems = (
+  items: ConsoleListItem[],
+  overlay: ConsoleOverlay,
+  generatedAtMs: number,
+  mode: ConsoleTabName,
+): ConsoleListItem[] =>
+  items.filter(
+    (item) =>
+      !isOverlayEntryActedForMode(
+        overlay[overlayKeyForItem(item)],
+        generatedAtMs,
+        mode,
+      ),
+  );
+
+export const writeOverlayEntry = (
+  overlay: ConsoleOverlay,
+  key: string,
+  patch: Partial<Omit<ConsoleOverlayEntry, 'ts' | 'mode'>>,
+  mode: ConsoleTabName,
+  now: number,
+): ConsoleOverlay => {
+  const existing = overlay[key];
+  const next: ConsoleOverlayEntry = {
+    ...(existing ?? {}),
+    ...patch,
+    ts: now,
+    mode,
+  };
+  return { ...overlay, [key]: next };
+};

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

@@ -0,0 +1,79 @@
+import { fireEvent, render, waitFor } from '@testing-library/react';
+import {
+  consoleListItemsFixture,
+  consoleStatusOptionsFixture,
+  consoleStoryColorsFixture,
+  consoleStoryOptionsFixture,
+} from '../fixtures';
+import type { ConsoleCaches } from '../hooks/useConsoleCaches';
+import type { ConsoleOperationsApi } from '../hooks/useConsoleOperations';
+import { ResourceCache } from '../lib/resourceCache';
+import { ConsoleItemDetailContainer } from './ConsoleItemDetailContainer';
+
+jest.mock('../lib/mermaidLoader', () => ({
+  renderMermaidToSvg: jest.fn(async () => '<svg></svg>'),
+}));
+
+const prItem = consoleListItemsFixture[0];
+
+const buildCaches = (): ConsoleCaches => {
+  const client = {
+    fetchItemBody: async () => '# body',
+    fetchComments: async () => [],
+    fetchPrFiles: async () => [],
+    fetchPrCommits: async () => [],
+    fetchRelatedPrs: async () => [],
+    fetchIssueState: async () => ({
+      state: 'open',
+      merged: false,
+      isPullRequest: true,
+    }),
+  };
+  return {
+    client,
+    body: new ResourceCache(client.fetchItemBody),
+    comments: new ResourceCache(client.fetchComments),
+    files: new ResourceCache(client.fetchPrFiles),
+    commits: new ResourceCache(client.fetchPrCommits),
+    relatedPrs: new ResourceCache(client.fetchRelatedPrs),
+    state: new ResourceCache(client.fetchIssueState),
+  };
+};
+
+const buildOperations = (): ConsoleOperationsApi => ({
+  reviewPullRequest: jest.fn(async () => {}),
+  setNextActionDate: jest.fn(async () => {}),
+  setStory: jest.fn(async () => {}),
+  setStatus: jest.fn(async () => {}),
+  setInTmuxByHuman: jest.fn(async () => {}),
+  closeIssue: jest.fn(async () => {}),
+});
+
+describe('ConsoleItemDetailContainer', () => {
+  it('wires the review action to the operations api for a PR item', async () => {
+    const operations = buildOperations();
+    const { getByText } = render(
+      <ConsoleItemDetailContainer
+        tab="prs"
+        item={prItem}
+        caches={buildCaches()}
+        operations={operations}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        storyColors={consoleStoryColorsFixture}
+        storyName="TDPM Console port"
+        overlayStatus={null}
+        now={Date.parse('2026-06-19T12:00:00.000Z')}
+      />,
+    );
+    await waitFor(() => {
+      expect(getByText('Approve')).toBeInTheDocument();
+    });
+    fireEvent.click(getByText('Approve'));
+    expect(operations.reviewPullRequest).toHaveBeenCalledWith(
+      prItem,
+      prItem.url,
+      'approve',
+    );
+  });
+});

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

@@ -0,0 +1,109 @@
+import { ConsoleItemDetail } from '../components/ConsoleItemDetail';
+import { ConsoleOperationBar } from '../components/ConsoleOperationBar';
+import { resolveStoryColorEnum } from '../grouping';
+import type { ConsoleCaches } from '../hooks/useConsoleCaches';
+import { useConsoleItemDetailData } from '../hooks/useConsoleItemDetailData';
+import type { ConsoleOperationsApi } from '../hooks/useConsoleOperations';
+import type { ConsoleOperationHandlers } from '../operations';
+import type {
+  ConsoleColor,
+  ConsoleFieldOption,
+  ConsoleListItem,
+  ConsoleOverlayStatus,
+  ConsoleStoryColorSource,
+  ConsoleTabName,
+} from '../types';
+
+export type ConsoleItemDetailContainerProps = {
+  tab: ConsoleTabName;
+  item: ConsoleListItem;
+  caches: ConsoleCaches;
+  operations: ConsoleOperationsApi;
+  statusOptions: ConsoleFieldOption[];
+  storyOptions: ConsoleFieldOption[];
+  storyColors: ConsoleStoryColorSource;
+  storyName: string | null;
+  overlayStatus: ConsoleOverlayStatus | null;
+  now: number;
+};
+
+export const ConsoleItemDetailContainer = ({
+  tab,
+  item,
+  caches,
+  operations,
+  statusOptions,
+  storyOptions,
+  storyColors,
+  storyName,
+  overlayStatus,
+  now,
+}: ConsoleItemDetailContainerProps) => {
+  const detail = useConsoleItemDetailData(caches, item);
+  const hasPullRequest = item.isPr || detail.relatedPullRequests.length > 0;
+
+  const handlers: ConsoleOperationHandlers = {
+    onReview: (action) => {
+      const prUrl = item.isPr
+        ? item.url
+        : (detail.relatedPullRequests[0]?.pullRequest.url ?? item.url);
+      void operations.reviewPullRequest(item, prUrl, action);
+    },
+    onSetNextActionDate: (action) => {
+      void operations.setNextActionDate(item, action);
+    },
+    onSetStory: (option: ConsoleFieldOption) => {
+      void operations.setStory(item, option);
+    },
+    onSetStatus: (option: ConsoleFieldOption) => {
+      void operations.setStatus(item, option);
+    },
+    onSetInTmuxByHuman: (option: ConsoleFieldOption) => {
+      void operations.setInTmuxByHuman(item, option);
+    },
+    onClose: (action) => {
+      void operations.closeIssue(item, action);
+    },
+  };
+
+  const resolvedStoryName =
+    storyName ?? (item.story.trim() !== '' ? item.story : null);
+  const storyColorEnum: ConsoleColor | null =
+    resolvedStoryName !== null
+      ? resolveStoryColorEnum(storyColors, resolvedStoryName)
+      : null;
+
+  return (
+    <ConsoleItemDetail
+      item={item}
+      storyName={resolvedStoryName}
+      storyColorEnum={storyColorEnum}
+      overlayStatus={overlayStatus}
+      state={detail.state}
+      body={detail.body}
+      bodyIsLoading={detail.bodyIsLoading}
+      bodyError={detail.bodyError}
+      comments={detail.comments}
+      commentsAreLoading={detail.commentsAreLoading}
+      commentsError={detail.commentsError}
+      files={detail.files}
+      filesAreLoading={detail.filesAreLoading}
+      filesError={detail.filesError}
+      commits={detail.commits}
+      commitsAreLoading={detail.commitsAreLoading}
+      commitsError={detail.commitsError}
+      relatedPullRequests={detail.relatedPullRequests}
+      now={now}
+      operationBar={
+        <ConsoleOperationBar
+          tab={tab}
+          item={item}
+          hasPullRequest={hasPullRequest}
+          statusOptions={statusOptions}
+          storyOptions={storyOptions}
+          handlers={handlers}
+        />
+      }
+    />
+  );
+};

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

@@ -0,0 +1,74 @@
+import { fireEvent, render, waitFor } from '@testing-library/react';
+import { ConsolePage } from './ConsolePage';
+
+jest.mock('../lib/mermaidLoader', () => ({
+  renderMermaidToSvg: jest.fn(async () => '<svg></svg>'),
+}));
+
+const listPayload = (tab: string) => ({
+  pjcode: 'umino',
+  generatedAt: '2026-06-19T00:00:00.000Z',
+  statusOptions: [{ id: 's1', name: 'Awaiting Workspace', color: 'BLUE' }],
+  storyOptions: [{ id: 'st1', name: 'TDPM Console port', color: 'BLUE' }],
+  storyColors: { 'TDPM Console port': { color: 'BLUE' } },
+  items:
+    tab === 'prs'
+      ? [
+          {
+            number: 851,
+            title: 'Add serveConsole subcommand',
+            url: 'https://github.com/o/r/pull/851',
+            repo: 'o/r',
+            nameWithOwner: 'o/r',
+            projectItemId: 'PVTI_1',
+            itemId: 'PVTI_1',
+            isPr: true,
+            story: 'TDPM Console port',
+            labels: [],
+            createdAt: '2026-06-17T00:00:00.000Z',
+          },
+        ]
+      : [],
+});
+
+const installFetch = (): void => {
+  const fetchMock = jest.fn(async (url: string) => {
+    const listMatch = url.match(/\/projects\/[^/]+\/([^/]+)\/list\.json/);
+    if (listMatch !== null) {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => listPayload(listMatch[1]),
+      };
+    }
+    return { ok: true, status: 200, json: async () => ({ body: '# body' }) };
+  });
+  global.fetch = fetchMock as unknown as typeof fetch;
+};
+
+describe('ConsolePage', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    window.history.replaceState({}, '', '/projects/umino/prs?k=token');
+    installFetch();
+  });
+
+  it('renders the tab bar with the active tab and the story-grouped list', async () => {
+    const { getByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    expect(getByText('Awaiting Quality Check')).toBeInTheDocument();
+    expect(getByText('TDPM Console port')).toBeInTheDocument();
+  });
+
+  it('opens the detail view when an item is selected', async () => {
+    const { getByText, findByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    fireEvent.click(getByText('Add serveConsole subcommand'));
+    expect(await findByText('← Back to list')).toBeInTheDocument();
+    expect(getByText('Approve')).toBeInTheDocument();
+  });
+});