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

package/src/adapter/entry-points/console/consoleOperationApi.test.ts

@@ -12,6 +12,7 @@ import {
   handleComment,
   handleCreateIssue,
   handleIntmux,
+  handleReorderStory,
   handleReview,
   handleReviewComment,
   handleTriage,
@@ -110,6 +111,7 @@ describe('consoleOperationApi', () => {
       isPjcodeConfigured: (pjcode: string) => pjcode === 'acme',
       consoleDataOutputDir: baseDir,
       issueAttachmentRepository: null,
+      updateStoryList: null,
     };
   });
 
@@ -122,6 +124,7 @@ describe('consoleOperationApi', () => {
     isPjcodeConfigured: (pjcode: string) => pjcode === 'acme',
     consoleDataOutputDir: baseDir,
     issueAttachmentRepository: null,
+    updateStoryList: null,
   });
 
   afterEach(() => {
@@ -864,6 +867,7 @@ describe('consoleOperationApi', () => {
         isPjcodeConfigured: (pjcode: string) => pjcode === 'acme',
         consoleDataOutputDir: baseDir,
         issueAttachmentRepository: null,
+        updateStoryList: null,
       };
     });
 
@@ -1109,6 +1113,7 @@ describe('consoleOperationApi', () => {
           pjcode === 'acme' || pjcode === 'globex',
         consoleDataOutputDir: baseDir,
         issueAttachmentRepository: null,
+        updateStoryList: null,
       };
       const response = await handleTriage(multiContext, {
         pjcode: 'globex',
@@ -1677,4 +1682,229 @@ describe('consoleOperationApi', () => {
       });
     });
   });
+
+  describe('handleReorderStory', () => {
+    const projectWithOrderedStories = (): Project => ({
+      ...project,
+      story: {
+        name: 'Story',
+        fieldId: 'storyField',
+        databaseId: 1,
+        stories: [
+          { id: 'opt_a', name: 'Alpha', color: 'BLUE', description: '' },
+          { id: 'opt_b', name: 'Beta', color: 'GREEN', description: '' },
+          { id: 'opt_c', name: 'Gamma', color: 'RED', description: '' },
+        ],
+        workflowManagementStory: { id: 'wms', name: 'workflow' },
+      },
+    });
+
+    const contextWithUpdateStoryList = (
+      updateStoryList: ConsoleOperationContext['updateStoryList'],
+      baseProject: Project = projectWithOrderedStories(),
+    ): ConsoleOperationContext => ({
+      ...contextForProject(baseProject),
+      updateStoryList,
+    });
+
+    it('returns 400 when pjcode is missing', async () => {
+      const response = await handleReorderStory(context, {
+        storyOptionId: 'opt_b',
+        direction: 'up',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'pjcode is required' },
+      });
+    });
+
+    it('returns 400 when storyOptionId is missing', async () => {
+      const response = await handleReorderStory(context, {
+        pjcode: 'acme',
+        direction: 'up',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'storyOptionId is required' },
+      });
+    });
+
+    it('returns 400 when direction is not "up" or "down"', async () => {
+      const response = await handleReorderStory(context, {
+        pjcode: 'acme',
+        storyOptionId: 'opt_b',
+        direction: 'left',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'direction must be "up" or "down"' },
+      });
+    });
+
+    it('returns 400 when project is not found', async () => {
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(jest.fn()),
+        {
+          pjcode: 'unknown',
+          storyOptionId: 'opt_b',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'no project configured for pjcode "unknown"' },
+      });
+    });
+
+    it('returns 400 when story option is not found', async () => {
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(jest.fn()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_nonexistent',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'story option not found' },
+      });
+    });
+
+    it('returns 400 when direction is "up" and the option is already first', async () => {
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(jest.fn()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_a',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'cannot move in that direction' },
+      });
+    });
+
+    it('returns 400 when direction is "down" and the option is already last', async () => {
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(jest.fn()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_c',
+          direction: 'down',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'cannot move in that direction' },
+      });
+    });
+
+    it('returns 400 when updateStoryList is not configured', async () => {
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(null),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_b',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'updateStoryList is not configured' },
+      });
+    });
+
+    it('swaps the target option with its neighbor, calls updateStoryList with reordered list, and returns 200', async () => {
+      const updateStoryList = jest.fn().mockResolvedValue([]);
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(updateStoryList),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_b',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({ statusCode: 200, body: { ok: true } });
+      expect(updateStoryList).toHaveBeenCalledTimes(1);
+      expect(updateStoryList).toHaveBeenCalledWith(
+        expect.objectContaining({ id: projectWithOrderedStories().id }),
+        [
+          expect.objectContaining({ id: 'opt_b' }),
+          expect.objectContaining({ id: 'opt_a' }),
+          expect.objectContaining({ id: 'opt_c' }),
+        ],
+      );
+    });
+
+    it('returns 400 when project does not have a story field', async () => {
+      const projectWithoutStory = {
+        ...projectWithOrderedStories(),
+        story: null,
+      };
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(jest.fn(), projectWithoutStory),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_b',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'project does not have a story field' },
+      });
+    });
+
+    it('passes the full story list including GRAY options to updateStoryList', async () => {
+      const projectWithGray = {
+        ...projectWithOrderedStories(),
+        story: {
+          name: 'Story',
+          fieldId: 'storyField',
+          databaseId: 1,
+          stories: [
+            {
+              id: 'opt_a',
+              name: 'Alpha',
+              color: 'BLUE' as const,
+              description: '',
+            },
+            {
+              id: 'opt_gray',
+              name: 'Archived',
+              color: 'GRAY' as const,
+              description: '',
+            },
+            {
+              id: 'opt_b',
+              name: 'Beta',
+              color: 'GREEN' as const,
+              description: '',
+            },
+          ],
+          workflowManagementStory: { id: 'wms', name: 'workflow' },
+        },
+      };
+      const updateStoryList = jest.fn().mockResolvedValue([]);
+      const response = await handleReorderStory(
+        contextWithUpdateStoryList(updateStoryList, projectWithGray),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_b',
+          direction: 'up',
+        },
+      );
+      expect(response).toEqual({ statusCode: 200, body: { ok: true } });
+      expect(updateStoryList).toHaveBeenCalledWith(
+        expect.objectContaining({ id: projectWithGray.id }),
+        [
+          expect.objectContaining({ id: 'opt_a' }),
+          expect.objectContaining({ id: 'opt_b' }),
+          expect.objectContaining({ id: 'opt_gray' }),
+        ],
+      );
+    });
+  });
 });

package/src/adapter/entry-points/console/consoleOperationApi.ts

@@ -3,7 +3,7 @@ import {
   PullRequestReviewCommentSide,
 } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { IssueAttachmentRepository } from '../../../domain/usecases/adapter-interfaces/IssueAttachmentRepository';
-import { Project } from '../../../domain/entities/Project';
+import { FieldOption, Project } from '../../../domain/entities/Project';
 import { Issue } from '../../../domain/entities/Issue';
 import {
   recordDoneProjectItemIdAcrossTabs,
@@ -38,6 +38,9 @@ export type ConsoleOperationContext = {
   isPjcodeConfigured: ConsolePjcodeValidator;
   consoleDataOutputDir: string | null;
   issueAttachmentRepository: IssueAttachmentRepository | null;
+  updateStoryList:
+    | ((project: Project, stories: FieldOption[]) => Promise<FieldOption[]>)
+    | null;
 };
 
 export type ConsoleOperationResponse = {
@@ -722,3 +725,47 @@ export const handleIntmux = async (
   recordDoneForStatusChange(context, pjcode, projectItemId);
   return ok();
 };
+
+export const handleReorderStory = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const pjcode = body.pjcode;
+  const storyOptionId = body.storyOptionId;
+  const direction = body.direction;
+  if (!isNonEmptyString(pjcode)) {
+    return badRequest('pjcode is required');
+  }
+  if (!isNonEmptyString(storyOptionId)) {
+    return badRequest('storyOptionId is required');
+  }
+  if (direction !== 'up' && direction !== 'down') {
+    return badRequest('direction must be "up" or "down"');
+  }
+  const binding = await context.resolveProject(pjcode);
+  if (binding === null) {
+    return badRequest(`no project configured for pjcode "${pjcode}"`);
+  }
+  const { project } = binding;
+  if (project.story === null) {
+    return badRequest('project does not have a story field');
+  }
+  if (context.updateStoryList === null) {
+    return badRequest('updateStoryList is not configured');
+  }
+  const stories = project.story.stories;
+  const index = stories.findIndex((s) => s.id === storyOptionId);
+  if (index === -1) {
+    return badRequest('story option not found');
+  }
+  const swapIndex = index + (direction === 'up' ? -1 : 1);
+  if (swapIndex < 0 || swapIndex >= stories.length) {
+    return badRequest('cannot move in that direction');
+  }
+  const reordered = [...stories];
+  const temp = reordered[index];
+  reordered[index] = reordered[swapIndex];
+  reordered[swapIndex] = temp;
+  await context.updateStoryList(project, reordered);
+  return ok();
+};

package/src/adapter/entry-points/console/ui/e2e/consoleScenario.spec.ts

@@ -395,3 +395,39 @@ test('creates an issue for a story when the add-task button and form are used',
     'npm-cli-github-issue-tower-defence-management',
   );
 });
+
+test('reorders stories on the triage tab with up/down buttons', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Triage').click();
+
+  const reorderPanel = page.locator('.console-story-reorder-panel');
+  await expect(reorderPanel).toBeVisible();
+
+  const rows = reorderPanel.locator('.console-story-reorder-row');
+  await expect(rows).toHaveCount(3);
+
+  await expect(rows.nth(0)).toContainText('TDPM Console port');
+  await expect(rows.nth(1)).toContainText('Publish product documentation site');
+  await expect(rows.nth(2)).toContainText('regular / WORKFLOW BLOCKER');
+
+  await rows.nth(0).locator('[aria-label="Move down"]').click();
+
+  await expect
+    .poll(() => harness.reorderStoryCalls.length, { timeout: 5000 })
+    .toBe(1);
+
+  await expect(rows.nth(0)).toContainText('Publish product documentation site');
+  await expect(rows.nth(1)).toContainText('TDPM Console port');
+
+  await rows.nth(1).locator('[aria-label="Move up"]').click();
+
+  await expect
+    .poll(() => harness.reorderStoryCalls.length, { timeout: 5000 })
+    .toBe(2);
+
+  await expect(rows.nth(0)).toContainText('TDPM Console port');
+  await expect(rows.nth(1)).toContainText('Publish product documentation site');
+});

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -3,7 +3,10 @@ import type * as http from 'node:http';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import type { Issue } from '../../../../../domain/entities/Issue';
-import type { Project } from '../../../../../domain/entities/Project';
+import type {
+  FieldOption,
+  Project,
+} from '../../../../../domain/entities/Project';
 import type {
   IssueComment,
   IssueRepository,
@@ -611,6 +614,10 @@ const createStubIssueRepository = (
   setIssueAgentField: async (): Promise<void> => undefined,
 });
 
+export type ConsoleE2eReorderStoryCall = {
+  storyOptionIds: string[];
+};
+
 export type ConsoleE2eHarness = {
   baseUrl: string;
   appUrl: string;
@@ -619,6 +626,7 @@ export type ConsoleE2eHarness = {
   reviewCommentCalls: ConsoleE2eReviewCommentCall[];
   requestChangesCalls: ConsoleE2eRequestChangesCall[];
   createIssueCalls: ConsoleE2eCreateIssueCall[];
+  reorderStoryCalls: ConsoleE2eReorderStoryCall[];
   stop: () => Promise<void>;
 };
 
@@ -640,6 +648,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
   const reviewCommentCalls: ConsoleE2eReviewCommentCall[] = [];
   const requestChangesCalls: ConsoleE2eRequestChangesCall[] = [];
   const createIssueCalls: ConsoleE2eCreateIssueCall[] = [];
+  const reorderStoryCalls: ConsoleE2eReorderStoryCall[] = [];
 
   const server = await startWebServer({
     accessToken: CONSOLE_E2E_TOKEN,
@@ -650,6 +659,20 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
       requestChangesCalls,
       createIssueCalls,
     ),
+    projectRepository: {
+      updateStoryList: async (_updatedProject, stories) => {
+        reorderStoryCalls.push({
+          storyOptionIds: stories
+            .map((s) => s.id)
+            .filter((id): id is string => id !== null),
+        });
+        const result = stories as FieldOption[];
+        if (project.story !== null) {
+          project.story.stories = result;
+        }
+        return result;
+      },
+    },
     resolveProject,
     isPjcodeConfigured,
     issueTitleStateCache: new IssueTitleStateCache(),
@@ -679,6 +702,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     reviewCommentCalls,
     requestChangesCalls,
     createIssueCalls,
+    reorderStoryCalls,
     stop: async (): Promise<void> => {
       await closeServer(server);
       fs.rmSync(tmpRoot, { recursive: true, force: true });

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

@@ -0,0 +1,30 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { ConsoleStoryReorderPanel } from './ConsoleStoryReorderPanel';
+
+const stories = [
+  { id: '1491051e', name: 'TDPM Console port', color: 'BLUE' as const },
+  {
+    id: 'f7cd5cbc',
+    name: 'Publish product documentation site',
+    color: 'GREEN' as const,
+  },
+  { id: 'a3b9c4d2', name: 'regular / WORKFLOW BLOCKER', color: 'RED' as const },
+];
+
+const meta: Meta<typeof ConsoleStoryReorderPanel> = {
+  title: 'Console/ConsoleStoryReorderPanel',
+  component: ConsoleStoryReorderPanel,
+  args: { onReorderStory: () => Promise.resolve() },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleStoryReorderPanel>;
+
+export const Default: Story = {
+  args: { stories },
+};
+
+export const SingleStory: Story = {
+  args: { stories: [stories[0]] },
+};

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>
+  );
+};