github-issue-tower-defence-management 1.181.1 → 1.182.0

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

@@ -0,0 +1,59 @@
+import { renderHook } from '@testing-library/react';
+import { useConsoleProjectTimer } from './useConsoleProjectTimer';
+
+describe('useConsoleProjectTimer', () => {
+  beforeEach(() => {
+    jest.spyOn(Date, 'now');
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns false before the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(1000);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(1000 + 4 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(false);
+  });
+
+  it('returns true once the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(5 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(true);
+  });
+
+  it('returns true after more than the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(true);
+  });
+
+  it('returns false when minutes is 0 regardless of elapsed time', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(0)).toBe(false);
+  });
+
+  it('returns false when minutes is negative', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(-1)).toBe(false);
+  });
+
+  it('resets the start time when pjcode changes', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result, rerender } = renderHook(
+      ({ pjcode }: { pjcode: string | null }) => useConsoleProjectTimer(pjcode),
+      { initialProps: { pjcode: 'alpha' } },
+    );
+    (Date.now as jest.Mock).mockReturnValue(4 * 60 * 1000);
+    rerender({ pjcode: 'beta' });
+    (Date.now as jest.Mock).mockReturnValue(4 * 60 * 1000 + 30 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(false);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { useCallback, useRef } from 'react';
+
+export type ConsoleProjectTimerState = {
+  isTimerExpired: (minutes: number) => boolean;
+};
+
+export const useConsoleProjectTimer = (
+  pjcode: string | null,
+): ConsoleProjectTimerState => {
+  const pjcodeRef = useRef(pjcode);
+  const startRef = useRef<number>(Date.now());
+
+  if (pjcodeRef.current !== pjcode) {
+    pjcodeRef.current = pjcode;
+    startRef.current = Date.now();
+  }
+
+  const isTimerExpired = useCallback((minutes: number): boolean => {
+    if (minutes <= 0) {
+      return false;
+    }
+    return Date.now() - startRef.current >= minutes * 60 * 1000;
+  }, []);
+
+  return { isTimerExpired };
+};

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

@@ -0,0 +1,110 @@
+import { act, renderHook } from '@testing-library/react';
+import { TIMER_SETTINGS_KEY } from '../logic/timerSettings';
+import { useConsoleTimerSettings } from './useConsoleTimerSettings';
+
+describe('useConsoleTimerSettings', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('initialises with timer mode off and empty project minutes when localStorage is empty', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    expect(result.current.timerMode).toBe(false);
+    expect(result.current.projectMinutes).toEqual({});
+    expect(result.current.isOpen).toBe(false);
+  });
+
+  it('openSettings resets draft to the current saved settings, not the previous draft', () => {
+    localStorage.setItem(
+      TIMER_SETTINGS_KEY,
+      JSON.stringify({ timerMode: true, projectMinutes: { acme: 30 } }),
+    );
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 99);
+    });
+    act(() => {
+      result.current.closeSettings();
+    });
+    act(() => {
+      result.current.openSettings();
+    });
+    expect(result.current.draftTimerMode).toBe(true);
+    expect(result.current.draftProjectMinutes).toEqual({ acme: 30 });
+  });
+
+  it('openSettings sets isOpen to true', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    expect(result.current.isOpen).toBe(true);
+  });
+
+  it('changeDraftMinutes mutates draft but does not change saved or localStorage', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 45);
+    });
+    expect(result.current.draftProjectMinutes).toEqual({ acme: 45 });
+    expect(result.current.projectMinutes).toEqual({});
+    expect(localStorage.getItem(TIMER_SETTINGS_KEY)).toBeNull();
+  });
+
+  it('saveSettings writes to localStorage with key tdpm-timer-settings and closes the dialog', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.toggleDraftTimerMode(true);
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 20);
+    });
+    act(() => {
+      result.current.saveSettings();
+    });
+    expect(result.current.isOpen).toBe(false);
+    const stored = localStorage.getItem(TIMER_SETTINGS_KEY);
+    expect(stored).not.toBeNull();
+    const parsed = JSON.parse(stored as string) as unknown;
+    expect(parsed).toEqual({ timerMode: true, projectMinutes: { acme: 20 } });
+    expect(result.current.timerMode).toBe(true);
+    expect(result.current.projectMinutes).toEqual({ acme: 20 });
+  });
+
+  it('closeSettings discards draft without writing to localStorage', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 60);
+    });
+    act(() => {
+      result.current.closeSettings();
+    });
+    expect(result.current.isOpen).toBe(false);
+    expect(localStorage.getItem(TIMER_SETTINGS_KEY)).toBeNull();
+    expect(result.current.projectMinutes).toEqual({});
+  });
+
+  it('toggleDraftTimerMode updates draftTimerMode without affecting saved timerMode', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.toggleDraftTimerMode(true);
+    });
+    expect(result.current.draftTimerMode).toBe(true);
+    expect(result.current.timerMode).toBe(false);
+  });
+});

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

@@ -0,0 +1,70 @@
+import { useCallback, useState } from 'react';
+import {
+  readTimerSettings,
+  type TimerSettings,
+  writeTimerSettings,
+} from '../logic/timerSettings';
+
+export type ConsoleTimerSettingsState = {
+  timerMode: boolean;
+  projectMinutes: Record<string, number>;
+  isOpen: boolean;
+  draftTimerMode: boolean;
+  draftProjectMinutes: Record<string, number>;
+  openSettings: () => void;
+  closeSettings: () => void;
+  saveSettings: () => void;
+  toggleDraftTimerMode: (enabled: boolean) => void;
+  changeDraftMinutes: (pjcode: string, minutes: number) => void;
+};
+
+export const useConsoleTimerSettings = (): ConsoleTimerSettingsState => {
+  const [saved, setSaved] = useState<TimerSettings>(readTimerSettings);
+  const [isOpen, setIsOpen] = useState(false);
+  const [draft, setDraft] = useState<TimerSettings>(saved);
+
+  const openSettings = useCallback(() => {
+    setSaved((currentSaved) => {
+      setDraft(currentSaved);
+      return currentSaved;
+    });
+    setIsOpen(true);
+  }, []);
+
+  const closeSettings = useCallback(() => {
+    setIsOpen(false);
+  }, []);
+
+  const saveSettings = useCallback(() => {
+    setDraft((currentDraft) => {
+      writeTimerSettings(currentDraft);
+      setSaved(currentDraft);
+      return currentDraft;
+    });
+    setIsOpen(false);
+  }, []);
+
+  const toggleDraftTimerMode = useCallback((enabled: boolean) => {
+    setDraft((prev) => ({ ...prev, timerMode: enabled }));
+  }, []);
+
+  const changeDraftMinutes = useCallback((pjcode: string, minutes: number) => {
+    setDraft((prev) => ({
+      ...prev,
+      projectMinutes: { ...prev.projectMinutes, [pjcode]: minutes },
+    }));
+  }, []);
+
+  return {
+    timerMode: saved.timerMode,
+    projectMinutes: saved.projectMinutes,
+    isOpen,
+    draftTimerMode: draft.timerMode,
+    draftProjectMinutes: draft.projectMinutes,
+    openSettings,
+    closeSettings,
+    saveSettings,
+    toggleDraftTimerMode,
+    changeDraftMinutes,
+  };
+};

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

@@ -438,3 +438,25 @@ export const postConsoleReorderStory = async (
     throw new Error(await readOperationErrorReason(response));
   }
 };
+
+export const fetchProjectList = async (): Promise<string[]> => {
+  const response = await fetch('/api/projects');
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const payload: unknown = await response.json();
+  if (
+    payload === null ||
+    typeof payload !== 'object' ||
+    Array.isArray(payload)
+  ) {
+    return [];
+  }
+  const record = payload as Record<string, unknown>;
+  if (!Array.isArray(record.pjcodes)) {
+    return [];
+  }
+  return record.pjcodes.filter(
+    (entry): entry is string => typeof entry === 'string',
+  );
+};

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

@@ -0,0 +1,7 @@
+export const navigateReplace = (url: string): void => {
+  window.location.replace(url);
+};
+
+export const navigateAssign = (url: string): void => {
+  window.location.assign(url);
+};

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

@@ -0,0 +1,61 @@
+import { findNextPjcodeWithMinutes } from './timerSettings';
+
+describe('findNextPjcodeWithMinutes', () => {
+  const pjcodes = ['alpha', 'beta', 'gamma'];
+
+  it('returns the next pjcode after the current one with minutes > 0', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBe('beta');
+    expect(findNextPjcodeWithMinutes(pjcodes, 'beta', minutes)).toBe('gamma');
+  });
+
+  it('wraps around to the first pjcode after the last one', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'gamma', minutes)).toBe('alpha');
+  });
+
+  it('returns null when all projects have zero minutes', () => {
+    const minutes = { alpha: 0, beta: 0, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBeNull();
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBeNull();
+  });
+
+  it('skips projects with zero minutes', () => {
+    const minutes = { alpha: 5, beta: 0, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBe('gamma');
+  });
+
+  it('skips consecutive zero-minute projects and wraps around', () => {
+    const minutes = { alpha: 5, beta: 0, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBeNull();
+
+    const minutes2 = { alpha: 0, beta: 5, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'gamma', minutes2)).toBe('beta');
+  });
+
+  it('returns the first pjcode with minutes > 0 when currentPjcode is null', () => {
+    const minutes = { alpha: 0, beta: 5, gamma: 3 };
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBe('beta');
+  });
+
+  it('returns the first pjcode when currentPjcode is null and first has minutes > 0', () => {
+    const minutes = { alpha: 10, beta: 5, gamma: 3 };
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBe('alpha');
+  });
+
+  it('treats missing projectMinutes entry as zero', () => {
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', {})).toBeNull();
+  });
+
+  it('returns null for an empty pjcodes list', () => {
+    expect(findNextPjcodeWithMinutes([], null, {})).toBeNull();
+    expect(findNextPjcodeWithMinutes([], 'alpha', {})).toBeNull();
+  });
+
+  it('handles currentPjcode not found in the list like null-origin', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'unknown', minutes)).toBe(
+      'alpha',
+    );
+  });
+});

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

@@ -0,0 +1,77 @@
+export type TimerSettings = {
+  timerMode: boolean;
+  projectMinutes: Record<string, number>;
+};
+
+export const TIMER_SETTINGS_KEY = 'tdpm-timer-settings';
+
+const defaultSettings = (): TimerSettings => ({
+  timerMode: false,
+  projectMinutes: {},
+});
+
+export const readTimerSettings = (): TimerSettings => {
+  if (typeof localStorage === 'undefined') {
+    return defaultSettings();
+  }
+  const raw = localStorage.getItem(TIMER_SETTINGS_KEY);
+  if (raw === null) {
+    return defaultSettings();
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (
+      parsed === null ||
+      typeof parsed !== 'object' ||
+      Array.isArray(parsed)
+    ) {
+      return defaultSettings();
+    }
+    const record = parsed as Record<string, unknown>;
+    const timerMode =
+      typeof record.timerMode === 'boolean' ? record.timerMode : false;
+    const projectMinutesRaw = record.projectMinutes;
+    const projectMinutes: Record<string, number> =
+      projectMinutesRaw !== null &&
+      typeof projectMinutesRaw === 'object' &&
+      !Array.isArray(projectMinutesRaw)
+        ? Object.fromEntries(
+            Object.entries(projectMinutesRaw as Record<string, unknown>)
+              .filter(([, v]) => typeof v === 'number')
+              .map(([k, v]) => [k, v as number]),
+          )
+        : {};
+    return { timerMode, projectMinutes };
+  } catch {
+    return defaultSettings();
+  }
+};
+
+export const writeTimerSettings = (settings: TimerSettings): void => {
+  if (typeof localStorage !== 'undefined') {
+    localStorage.setItem(TIMER_SETTINGS_KEY, JSON.stringify(settings));
+  }
+};
+
+export const findNextPjcodeWithMinutes = (
+  pjcodes: string[],
+  currentPjcode: string | null,
+  projectMinutes: Record<string, number>,
+): string | null => {
+  if (pjcodes.length === 0) {
+    return null;
+  }
+  const currentIndex =
+    currentPjcode !== null ? pjcodes.indexOf(currentPjcode) : -1;
+  const startIndex =
+    currentIndex === -1 ? 0 : (currentIndex + 1) % pjcodes.length;
+  const count = currentIndex === -1 ? pjcodes.length : pjcodes.length - 1;
+  for (let i = 0; i < count; i++) {
+    const index = (startIndex + i) % pjcodes.length;
+    const pjcode = pjcodes[index];
+    if ((projectMinutes[pjcode] ?? 0) > 0) {
+      return pjcode;
+    }
+  }
+  return null;
+};

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

@@ -19,6 +19,11 @@ jest.mock('../lib/mermaidLoader', () => ({
   renderMermaidToSvg: jest.fn(async () => '<svg></svg>'),
 }));
 
+jest.mock('../lib/navigation', () => ({
+  navigateReplace: jest.fn(),
+  navigateAssign: jest.fn(),
+}));
+
 const listPayload = (tab: string) => ({
   pjcode: 'acme',
   generatedAt: '2026-06-19T00:00:00.000Z',
@@ -81,6 +86,13 @@ const installFetch = (): void => {
         json: async () => listPayload(listMatch[1]),
       };
     }
+    if (url === '/api/projects') {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ pjcodes: ['acme'] }),
+      };
+    }
     return { ok: true, status: 200, json: async () => ({ body: '# body' }) };
   });
   global.fetch = fetchMock as unknown as typeof fetch;
@@ -862,4 +874,108 @@ describe('ConsolePage auto-advance tab', () => {
       jest.useRealTimers();
     }
   });
+
+  it('renders the gear button in the tab bar', async () => {
+    const { getByText, getByRole } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    const gearBtn = getByRole('button', { name: 'Console Settings' });
+    expect(gearBtn).toBeInTheDocument();
+    expect(gearBtn.closest('nav.console-tabbar')).not.toBeNull();
+  });
+
+  it('opens the settings dialog when the gear button is clicked', async () => {
+    const { getByText, getByRole, queryByRole } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    expect(queryByRole('dialog')).toBeNull();
+    fireEvent.click(getByRole('button', { name: 'Console Settings' }));
+    expect(getByRole('dialog')).toBeInTheDocument();
+    expect(getByRole('dialog')).toHaveAttribute(
+      'aria-label',
+      'Console Settings',
+    );
+  });
+
+  it('saves timer settings to localStorage and closes the dialog when Save and Close is clicked', async () => {
+    const { getByText, getByRole, queryByRole, getByLabelText } = render(
+      <ConsolePage />,
+    );
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+    fireEvent.click(getByRole('button', { name: 'Console Settings' }));
+    fireEvent.click(getByLabelText('Timer Mode'));
+    fireEvent.click(getByText('Save and Close'));
+    expect(queryByRole('dialog')).toBeNull();
+    const stored = localStorage.getItem('tdpm-timer-settings');
+    expect(stored).not.toBeNull();
+    const parsed: unknown = JSON.parse(stored as string);
+    expect(parsed).toMatchObject({ timerMode: true });
+  });
+
+  it('redirects to the first project with minutes > 0 when timer mode is on and pjcode is null', async () => {
+    localStorage.setItem(
+      'tdpm-timer-settings',
+      JSON.stringify({ timerMode: true, projectMinutes: { acme: 30 } }),
+    );
+    window.history.replaceState({}, '', '/');
+    const { navigateReplace } = jest.requireMock<{
+      navigateReplace: jest.Mock;
+    }>('../lib/navigation');
+    navigateReplace.mockClear();
+    render(<ConsolePage />);
+    await waitFor(() => {
+      expect(navigateReplace).toHaveBeenCalledWith('/projects/acme');
+    });
+  });
+
+  it('navigates to the next project when a completing action fires after the project timer elapses', async () => {
+    localStorage.setItem(
+      'tdpm-timer-settings',
+      JSON.stringify({ timerMode: true, projectMinutes: { acme: 1, beta: 5 } }),
+    );
+    global.fetch = 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]),
+        };
+      }
+      if (url === '/api/projects') {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ pjcodes: ['acme', 'beta'] }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({ body: '# body' }) };
+    }) as unknown as typeof fetch;
+    jest.useFakeTimers({ now: 0 });
+    try {
+      const { getByText, findByText } = render(<ConsolePage />);
+      await waitFor(() => {
+        expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+      });
+      jest.setSystemTime(61 * 1000);
+      fireEvent.click(getByText('Add serveConsole subcommand'));
+      expect(await findByText('Approve & Merge')).toBeInTheDocument();
+      fireEvent.click(getByText('Approve & Merge'));
+      act(() => {
+        jest.advanceTimersByTime(5100);
+      });
+      const { navigateAssign } = jest.requireMock<{
+        navigateAssign: jest.Mock;
+      }>('../lib/navigation');
+      await waitFor(() => {
+        expect(navigateAssign).toHaveBeenCalledWith('/projects/beta');
+      });
+    } finally {
+      jest.useRealTimers();
+    }
+  });
 });