github-issue-tower-defence-management 1.179.0 → 1.180.1

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryReorderPanel.test.tsx

@@ -0,0 +1,111 @@
+import { fireEvent, render, waitFor } from '@testing-library/react';
+import type { ConsoleFieldOption } from '../../logic/types';
+import { ConsoleStoryReorderPanel } from './ConsoleStoryReorderPanel';
+
+const stories: ConsoleFieldOption[] = [
+  { id: 'opt-a', name: 'Alpha story', color: 'BLUE' },
+  { id: 'opt-b', name: 'Beta story', color: 'GREEN' },
+  { id: 'opt-c', name: 'Gamma story', color: 'RED' },
+];
+
+describe('ConsoleStoryReorderPanel', () => {
+  it('renders story names in the given order', () => {
+    const { getAllByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={() => Promise.resolve()}
+      />,
+    );
+    const items = getAllByRole('listitem');
+    expect(items[0]).toHaveTextContent('Alpha story');
+    expect(items[1]).toHaveTextContent('Beta story');
+    expect(items[2]).toHaveTextContent('Gamma story');
+  });
+
+  it('disables up-button for the first story and down-button for the last story', () => {
+    const { getAllByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={() => Promise.resolve()}
+      />,
+    );
+    const upButtons = getAllByRole('button', { name: 'Move up' });
+    const downButtons = getAllByRole('button', { name: 'Move down' });
+    expect(upButtons[0]).toBeDisabled();
+    expect(upButtons[1]).not.toBeDisabled();
+    expect(upButtons[2]).not.toBeDisabled();
+    expect(downButtons[0]).not.toBeDisabled();
+    expect(downButtons[1]).not.toBeDisabled();
+    expect(downButtons[2]).toBeDisabled();
+  });
+
+  it('calls onReorderStory with storyOptionId and "up" when up-button clicked on a non-first story', async () => {
+    const onReorderStory = jest.fn().mockResolvedValue(undefined);
+    const { getAllByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={onReorderStory}
+      />,
+    );
+    const upButtons = getAllByRole('button', { name: 'Move up' });
+    fireEvent.click(upButtons[1]);
+    await waitFor(() => expect(onReorderStory).toHaveBeenCalledTimes(1));
+    expect(onReorderStory).toHaveBeenCalledWith('opt-b', 'up');
+  });
+
+  it('calls onReorderStory with storyOptionId and "down" when down-button clicked on a non-last story', async () => {
+    const onReorderStory = jest.fn().mockResolvedValue(undefined);
+    const { getAllByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={onReorderStory}
+      />,
+    );
+    const downButtons = getAllByRole('button', { name: 'Move down' });
+    fireEvent.click(downButtons[1]);
+    await waitFor(() => expect(onReorderStory).toHaveBeenCalledTimes(1));
+    expect(onReorderStory).toHaveBeenCalledWith('opt-b', 'down');
+  });
+
+  it('disables both buttons while onReorderStory is in progress', async () => {
+    let resolveReorder: (() => void) | undefined;
+    const onReorderStory = jest.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveReorder = resolve;
+        }),
+    );
+    const { getAllByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={onReorderStory}
+      />,
+    );
+    const downButtons = getAllByRole('button', { name: 'Move down' });
+    fireEvent.click(downButtons[1]);
+    await waitFor(() => expect(onReorderStory).toHaveBeenCalledTimes(1));
+    const upButtonsDuring = getAllByRole('button', { name: 'Move up' });
+    const downButtonsDuring = getAllByRole('button', { name: 'Move down' });
+    expect(upButtonsDuring[1]).toBeDisabled();
+    expect(downButtonsDuring[1]).toBeDisabled();
+    resolveReorder?.();
+    await waitFor(() => expect(upButtonsDuring[1]).not.toBeDisabled());
+  });
+
+  it('shows an error message when onReorderStory rejects', async () => {
+    const onReorderStory = jest
+      .fn()
+      .mockRejectedValue(new Error('server error'));
+    const { getAllByRole, getByRole } = render(
+      <ConsoleStoryReorderPanel
+        stories={stories}
+        onReorderStory={onReorderStory}
+      />,
+    );
+    const downButtons = getAllByRole('button', { name: 'Move down' });
+    fireEvent.click(downButtons[0]);
+    await waitFor(() =>
+      expect(getByRole('alert')).toHaveTextContent('server error'),
+    );
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryReorderPanel.tsx

@@ -0,0 +1,91 @@
+import { useState } from 'react';
+import type { ConsoleFieldOption } from '../../logic/types';
+
+export type ConsoleStoryReorderPanelProps = {
+  stories: ConsoleFieldOption[];
+  onReorderStory: (
+    storyOptionId: string,
+    direction: 'up' | 'down',
+  ) => Promise<void>;
+};
+
+type RowState = {
+  inProgress: boolean;
+  error: string | null;
+};
+
+export const ConsoleStoryReorderPanel = ({
+  stories,
+  onReorderStory,
+}: ConsoleStoryReorderPanelProps) => {
+  const [rowStates, setRowStates] = useState<Record<string, RowState>>({});
+
+  const getRowState = (id: string): RowState =>
+    rowStates[id] ?? { inProgress: false, error: null };
+
+  const handleReorder = async (
+    storyOptionId: string,
+    direction: 'up' | 'down',
+  ): Promise<void> => {
+    setRowStates((prev) => ({
+      ...prev,
+      [storyOptionId]: { inProgress: true, error: null },
+    }));
+    try {
+      await onReorderStory(storyOptionId, direction);
+      setRowStates((prev) => ({
+        ...prev,
+        [storyOptionId]: { inProgress: false, error: null },
+      }));
+    } catch (err) {
+      setRowStates((prev) => ({
+        ...prev,
+        [storyOptionId]: {
+          inProgress: false,
+          error: err instanceof Error ? err.message : String(err),
+        },
+      }));
+    }
+  };
+
+  return (
+    <ul className="console-story-reorder-panel">
+      {stories.map((story, index) => {
+        const { inProgress, error } = getRowState(story.id);
+        const isFirst = index === 0;
+        const isLast = index === stories.length - 1;
+        return (
+          <li key={story.id} className="console-story-reorder-row">
+            <button
+              type="button"
+              className="console-op-button"
+              aria-label="Move up"
+              disabled={isFirst || inProgress}
+              onClick={() => void handleReorder(story.id, 'up')}
+            >
+              ↑
+            </button>
+            <button
+              type="button"
+              className="console-op-button"
+              aria-label="Move down"
+              disabled={isLast || inProgress}
+              onClick={() => void handleReorder(story.id, 'down')}
+            >
+              ↓
+            </button>
+            <span className="console-story-reorder-name">{story.name}</span>
+            {inProgress && (
+              <span className="console-story-reorder-progress">…</span>
+            )}
+            {error !== null && (
+              <span role="alert" className="console-story-reorder-error">
+                {error}
+              </span>
+            )}
+          </li>
+        );
+      })}
+    </ul>
+  );
+};

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

@@ -417,3 +417,24 @@ export const postConsoleCreateIssue = async (
   }
   return payload.issueUrl;
 };
+
+export const REORDER_STORY_OPERATION_PATH = '/api/reorderstory';
+
+export type ConsoleReorderStoryRequest = {
+  pjcode: string;
+  storyOptionId: string;
+  direction: 'up' | 'down';
+};
+
+export const postConsoleReorderStory = async (
+  request: ConsoleReorderStoryRequest,
+): Promise<void> => {
+  const response = await fetch(REORDER_STORY_OPERATION_PATH, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) {
+    throw new Error(await readOperationErrorReason(response));
+  }
+};

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

@@ -39,14 +39,36 @@ describe('formatRelativeTime', () => {
     );
   });
 
+  it('returns month and day for 30+ days in the same UTC year', () => {
+    expect(formatRelativeTime('2026-05-01T12:00:00.000Z', now)).toBe('May 1');
+  });
+
+  it('includes the UTC year when the date is in a prior year', () => {
+    const result = formatRelativeTime('2025-12-01T12:00:00.000Z', now);
+    expect(result).toContain('2025');
+    expect(result).toContain('Dec');
+  });
+
+  it('uses UTC date boundary for the same-year check', () => {
+    const nowEndOf2025 = Date.parse('2025-12-31T23:59:59.000Z');
+    const result = formatRelativeTime('2025-10-01T00:00:00.000Z', nowEndOf2025);
+    expect(result).toContain('Oct');
+    expect(result).not.toContain('2025');
+  });
+
   it('returns an empty string for an invalid date', () => {
     expect(formatRelativeTime('nonsense', now)).toBe('');
   });
 });
 
 describe('formatFullTimestamp', () => {
-  it('formats a timestamp and returns empty for invalid input', () => {
-    expect(formatFullTimestamp('2026-06-19T12:00:00.000Z')).not.toBe('');
+  it('formats a UTC timestamp in ja-JP locale', () => {
+    expect(formatFullTimestamp('2026-06-19T09:05:00.000Z')).toMatch(
+      /2026.06.19.09.05/,
+    );
+  });
+
+  it('returns empty string for invalid input', () => {
     expect(formatFullTimestamp('nonsense')).toBe('');
   });
 });

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

@@ -28,8 +28,9 @@ export const formatRelativeTime = (iso: string, now: number): string => {
     return `${days} days ago`;
   }
   const date = new Date(then);
-  const sameYear = date.getFullYear() === new Date(now).getFullYear();
+  const sameYear = date.getUTCFullYear() === new Date(now).getUTCFullYear();
   return date.toLocaleDateString('en-US', {
+    timeZone: 'UTC',
     year: sameYear ? undefined : 'numeric',
     month: 'short',
     day: 'numeric',
@@ -42,6 +43,7 @@ export const formatFullTimestamp = (iso: string): string => {
     return '';
   }
   return new Date(then).toLocaleString('ja-JP', {
+    timeZone: 'UTC',
     year: 'numeric',
     month: '2-digit',
     day: '2-digit',

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

@@ -1,7 +1,8 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { ConsoleTabList } from '../components/layout/ConsoleTabList';
 import { ConsoleItemList } from '../components/list/ConsoleItemList';
 import { ConsoleStoryList } from '../components/list/ConsoleStoryList';
+import { ConsoleStoryReorderPanel } from '../components/list/ConsoleStoryReorderPanel';
 import {
   ConsoleErrorToast,
   ConsoleUndoToast,
@@ -15,7 +16,10 @@ import { useConsoleOverlay } from '../hooks/useConsoleOverlay';
 import { useConsolePjcode } from '../hooks/useConsolePjcode';
 import { useConsoleSwipeNavigation } from '../hooks/useConsoleSwipeNavigation';
 import { useConsoleTabData } from '../hooks/useConsoleTabData';
-import { postConsoleCreateIssue } from '../lib/consoleApi';
+import {
+  postConsoleCreateIssue,
+  postConsoleReorderStory,
+} from '../lib/consoleApi';
 import {
   actionAdvances,
   actionToastColor,
@@ -136,6 +140,17 @@ export const ConsolePage = () => {
   const generatedAt = activeSnapshot?.generatedAt ?? null;
   const fromCache = activeSnapshot?.fromCache ?? false;
 
+  const [localStoryOptionsOverride, setLocalStoryOptionsOverride] = useState<{
+    generatedAt: string | undefined;
+    stories: typeof storyOptions;
+  } | null>(null);
+
+  const triageStoryOptions =
+    localStoryOptionsOverride !== null &&
+    localStoryOptionsOverride.generatedAt === activeSnapshot?.generatedAt
+      ? localStoryOptionsOverride.stories
+      : storyOptions.filter((o) => o.color !== 'GRAY');
+
   const selectedItem = useMemo<ConsoleListItem | null>(() => {
     if (selectedItemKey === null || activeSnapshot === null) {
       return null;
@@ -265,6 +280,32 @@ export const ConsolePage = () => {
     [pjcode, defaultNameWithOwner],
   );
 
+  const handleReorderStory = useCallback(
+    async (storyOptionId: string, direction: 'up' | 'down'): Promise<void> => {
+      if (pjcode === null) {
+        throw new Error('No project specified in the URL path.');
+      }
+      await postConsoleReorderStory({ pjcode, storyOptionId, direction });
+      const index = triageStoryOptions.findIndex((o) => o.id === storyOptionId);
+      if (index === -1) {
+        return;
+      }
+      const swapIndex = index + (direction === 'up' ? -1 : 1);
+      if (swapIndex < 0 || swapIndex >= triageStoryOptions.length) {
+        return;
+      }
+      const next = [...triageStoryOptions];
+      const temp = next[index];
+      next[index] = next[swapIndex];
+      next[swapIndex] = temp;
+      setLocalStoryOptionsOverride({
+        generatedAt: activeSnapshot?.generatedAt,
+        stories: next,
+      });
+    },
+    [pjcode, triageStoryOptions, activeSnapshot?.generatedAt],
+  );
+
   return (
     <main className="console-app">
       {actionQueue.pending !== null && (
@@ -299,15 +340,23 @@ export const ConsolePage = () => {
           onCreateIssue={handleCreateIssue}
         />
       ) : selectedItem === null ? (
-        <ConsoleItemList
-          rows={rows}
-          storyColors={storyColors}
-          activeItemId={null}
-          now={now}
-          isLoading={isLoading}
-          error={error}
-          onSelectItem={(item) => navigation.openItem(item.projectItemId)}
-        />
+        <>
+          {activeTab === 'triage' && triageStoryOptions.length > 0 && (
+            <ConsoleStoryReorderPanel
+              stories={triageStoryOptions}
+              onReorderStory={handleReorderStory}
+            />
+          )}
+          <ConsoleItemList
+            rows={rows}
+            storyColors={storyColors}
+            activeItemId={null}
+            now={now}
+            isLoading={isLoading}
+            error={error}
+            onSelectItem={(item) => navigation.openItem(item.projectItemId)}
+          />
+        </>
       ) : (
         <div className="console-detail-screen" ref={detailScreenRef}>
           <ConsoleItemDetailContainer