github-issue-tower-defence-management 1.185.1 → 1.186.1

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

@@ -22,6 +22,7 @@ import {
   handleReview,
   handleReviewComment,
   handleStoryAdd,
+  handleStoryColor,
   handleTriage,
 } from './consoleOperationApi';
 
@@ -115,6 +116,7 @@ describe('consoleOperationApi', () => {
       updateStoryList: null,
       resolveProjectRepository: null,
       invalidateProject: null,
+      updateProjectCacheEntry: null,
     };
   });
 
@@ -130,6 +132,7 @@ describe('consoleOperationApi', () => {
     updateStoryList: null,
     resolveProjectRepository: null,
     invalidateProject: null,
+    updateProjectCacheEntry: null,
   });
 
   afterEach(() => {
@@ -875,6 +878,7 @@ describe('consoleOperationApi', () => {
         updateStoryList: null,
         resolveProjectRepository: null,
         invalidateProject: null,
+        updateProjectCacheEntry: null,
       };
     });
 
@@ -1123,6 +1127,7 @@ describe('consoleOperationApi', () => {
         updateStoryList: null,
         resolveProjectRepository: null,
         invalidateProject: null,
+        updateProjectCacheEntry: null,
       };
       const response = await handleTriage(multiContext, {
         pjcode: 'globex',
@@ -2114,6 +2119,7 @@ describe('consoleOperationApi', () => {
           updateStoryList: consecutiveUpdateStoryList,
         })),
         invalidateProject,
+        updateProjectCacheEntry: null,
       };
 
       await handleStoryAdd(consecutiveContext, {
@@ -2137,4 +2143,197 @@ describe('consoleOperationApi', () => {
       );
     });
   });
+
+  describe('handleStoryColor', () => {
+    const projectWithStory = (): Project => ({
+      ...project,
+      story: {
+        name: 'Story',
+        fieldId: 'storyField',
+        databaseId: 1,
+        stories: [
+          {
+            id: 'opt_blue',
+            name: 'Portal redesign',
+            color: 'BLUE',
+            description: '',
+          },
+          {
+            id: 'opt_green',
+            name: 'Move to Okinawa',
+            color: 'GREEN',
+            description: '',
+          },
+        ],
+        workflowManagementStory: { id: 'wms', name: 'workflow' },
+      },
+    });
+
+    beforeEach(() => {
+      issueRepository.updateStoryOptionColor.mockResolvedValue(undefined);
+    });
+
+    it('calls updateStoryOptionColor with the correct project, storyOptionId, and newColor', async () => {
+      const storyProject = projectWithStory();
+      const response = await handleStoryColor(contextForProject(storyProject), {
+        pjcode: 'acme',
+        storyOptionId: 'opt_blue',
+        newColor: 'RED',
+        nameWithOwner: 'acme-labs/portal',
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.updateStoryOptionColor).toHaveBeenCalledWith(
+        expect.objectContaining({ story: storyProject.story }),
+        'opt_blue',
+        'RED',
+      );
+    });
+
+    it('resolves the issue repository from a proxy url of the target repo', async () => {
+      const resolvedUrls: string[] = [];
+      const recordingContext: ConsoleOperationContext = {
+        ...contextForProject(projectWithStory()),
+        resolveIssueRepository: (url: string) => {
+          resolvedUrls.push(url);
+          return issueRepository;
+        },
+      };
+
+      await handleStoryColor(recordingContext, {
+        pjcode: 'acme',
+        storyOptionId: 'opt_blue',
+        newColor: 'GREEN',
+        nameWithOwner: 'acme-labs/portal',
+      });
+
+      expect(resolvedUrls).toContain(
+        'https://github.com/acme-labs/portal/issues/0',
+      );
+    });
+
+    it('rejects when storyOptionId is missing', async () => {
+      const response = await handleStoryColor(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          newColor: 'RED',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'storyOptionId is required' },
+      });
+    });
+
+    it('rejects when newColor is not a valid ConsoleColor', async () => {
+      const response = await handleStoryColor(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_blue',
+          newColor: 'MAGENTA',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: {
+          error:
+            'newColor must be one of GRAY, BLUE, GREEN, YELLOW, ORANGE, RED, PINK, PURPLE',
+        },
+      });
+    });
+
+    it('rejects when nameWithOwner is missing', async () => {
+      const response = await handleStoryColor(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_blue',
+          newColor: 'RED',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'nameWithOwner is required' },
+      });
+    });
+
+    it('rejects when the project has no story field', async () => {
+      const projectWithoutStory: Project = { ...project, story: null };
+
+      const response = await handleStoryColor(
+        contextForProject(projectWithoutStory),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_blue',
+          newColor: 'RED',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'project does not have a story field' },
+      });
+    });
+
+    it('rejects when storyOptionId is not found in project.story.stories', async () => {
+      const response = await handleStoryColor(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_nonexistent',
+          newColor: 'RED',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'story option "opt_nonexistent" not found in project' },
+      });
+      expect(issueRepository.updateStoryOptionColor).not.toHaveBeenCalled();
+    });
+
+    it('calls updateProjectCacheEntry with the updated project after a successful color change', async () => {
+      const storyProject = projectWithStory();
+      const updatedEntries: { pjcode: string; project: Project }[] = [];
+      const contextWithCache: ConsoleOperationContext = {
+        ...contextForProject(storyProject),
+        updateProjectCacheEntry: (pjcode, updatedProject) => {
+          updatedEntries.push({ pjcode, project: updatedProject });
+        },
+      };
+
+      await handleStoryColor(contextWithCache, {
+        pjcode: 'acme',
+        storyOptionId: 'opt_blue',
+        newColor: 'RED',
+        nameWithOwner: 'acme-labs/portal',
+      });
+
+      expect(updatedEntries).toHaveLength(1);
+      expect(updatedEntries[0].pjcode).toBe('acme');
+      expect(updatedEntries[0].project.story?.stories).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 'opt_blue', color: 'RED' }),
+          expect.objectContaining({ id: 'opt_green', color: 'GREEN' }),
+        ]),
+      );
+    });
+
+    it('does not call updateProjectCacheEntry when updateProjectCacheEntry is null', async () => {
+      const response = await handleStoryColor(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          storyOptionId: 'opt_blue',
+          newColor: 'RED',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response.statusCode).toBe(200);
+    });
+  });
 });

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

@@ -1,6 +1,7 @@
 import type { Issue } from '../../../domain/entities/Issue';
 import {
   buildStoryListWithNew,
+  FIELD_OPTION_COLORS,
   type FieldOption,
   type Project,
 } from '../../../domain/entities/Project';
@@ -52,6 +53,8 @@ export type ConsoleOperationContext = {
     | null;
   resolveProjectRepository: ConsoleProjectRepositoryResolver | null;
   invalidateProject: ((pjcode: string) => void) | null;
+  updateProjectCacheEntry:
+    ((pjcode: string, updatedProject: Project) => void) | null;
 };
 
 export type ConsoleOperationResponse = {
@@ -138,6 +141,7 @@ const projectItemReference = (
   author: '',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
 });
 
 const recordDone = (
@@ -698,6 +702,67 @@ export const handleReviewComment = async (
   return ok();
 };
 
+const isStoryColor = (value: unknown): value is FieldOption['color'] =>
+  FIELD_OPTION_COLORS.some((c) => c === value);
+
+export const handleStoryColor = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const storyOptionId = body.storyOptionId;
+  const newColor = body.newColor;
+  const nameWithOwner = body.nameWithOwner;
+
+  if (!isNonEmptyString(storyOptionId)) {
+    return badRequest('storyOptionId is required');
+  }
+  if (!isStoryColor(newColor)) {
+    return badRequest(
+      'newColor must be one of GRAY, BLUE, GREEN, YELLOW, ORANGE, RED, PINK, PURPLE',
+    );
+  }
+  if (!isNonEmptyString(nameWithOwner)) {
+    return badRequest('nameWithOwner is required');
+  }
+
+  const binding = await resolveBinding(context, body);
+  if (isOperationResponse(binding)) {
+    return binding;
+  }
+  const { project, pjcode } = binding;
+
+  if (project.story === null) {
+    return badRequest('project does not have a story field');
+  }
+
+  const storyOption = project.story.stories.find((s) => s.id === storyOptionId);
+  if (storyOption === undefined) {
+    return badRequest(`story option "${storyOptionId}" not found in project`);
+  }
+
+  const proxyUrl = `https://github.com/${nameWithOwner}/issues/0`;
+  await context
+    .resolveIssueRepository(proxyUrl)
+    .updateStoryOptionColor(
+      { ...project, story: project.story },
+      storyOptionId,
+      newColor,
+    );
+
+  if (context.updateProjectCacheEntry !== null) {
+    const updatedStories = project.story.stories.map((s) =>
+      s.id === storyOptionId ? { ...s, color: newColor } : s,
+    );
+    const updatedProject: Project = {
+      ...project,
+      story: { ...project.story, stories: updatedStories },
+    };
+    context.updateProjectCacheEntry(pjcode, updatedProject);
+  }
+
+  return ok();
+};
+
 export const handleIntmux = async (
   context: ConsoleOperationContext,
   body: Record<string, unknown>,

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

@@ -127,6 +127,32 @@ describe('createConsoleProjectResolver', () => {
     });
     expect(loadProject).toHaveBeenCalledTimes(2);
   });
+
+  it('updateEntry replaces the cached project so the next resolve returns the updated project', async () => {
+    const updatedProject: Project = { ...acmeProject, id: 'PVT_acme_updated' };
+    const loadProject = jest.fn(async () => acmeProject);
+    const { resolve, updateEntry } = createConsoleProjectResolver(
+      { acme: 'https://github.com/orgs/acme/projects/1' },
+      loadProject,
+    );
+    await resolve('acme');
+    updateEntry('acme', updatedProject);
+    const result = await resolve('acme');
+    expect(result?.project).toBe(updatedProject);
+    expect(loadProject).toHaveBeenCalledTimes(1);
+  });
+
+  it('updateEntry is a no-op for a pjcode that was never resolved', async () => {
+    const updatedProject: Project = { ...acmeProject, id: 'PVT_acme_updated' };
+    const loadProject = jest.fn(async () => acmeProject);
+    const { resolve, updateEntry } = createConsoleProjectResolver(
+      { acme: 'https://github.com/orgs/acme/projects/1' },
+      loadProject,
+    );
+    updateEntry('acme', updatedProject);
+    const result = await resolve('acme');
+    expect(result?.project).toBe(acmeProject);
+  });
 });
 
 describe('createConsoleProjectLoader', () => {

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

@@ -71,6 +71,7 @@ export const createPjcodeConfigChecker = (
 export type ConsoleProjectResolverBundle = {
   resolve: ConsoleProjectResolver;
   invalidate: (pjcode: string) => void;
+  updateEntry: (pjcode: string, updatedProject: Project) => void;
 };
 
 export const createConsoleProjectResolver = (
@@ -100,5 +101,11 @@ export const createConsoleProjectResolver = (
   const invalidate = (pjcode: string): void => {
     cache.delete(pjcode);
   };
-  return { resolve, invalidate };
+  const updateEntry = (pjcode: string, updatedProject: Project): void => {
+    const existing = cache.get(pjcode);
+    if (existing !== undefined) {
+      cache.set(pjcode, { ...existing, project: updatedProject });
+    }
+  };
+  return { resolve, invalidate, updateEntry };
 };

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

@@ -48,6 +48,7 @@ const makeIssue = (overrides: Partial<Issue>): Issue => {
     author: 'someone',
     closingIssueReferenceUrls: [],
     agent: null,
+    stateReason: null,
     ...overrides,
   };
 };

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

@@ -514,6 +514,46 @@ test('creates a new story when the add-story button and form are used', async ({
   ).toHaveCount(0);
 });
 
+test('changes the color of a story row via the color palette in the stories tab', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Stories').click();
+
+  const tdpmRow = page.locator('.console-story-list-row', {
+    hasText: 'TDPM Console port',
+  });
+  await expect(tdpmRow).toBeVisible();
+
+  const changeColorButton = tdpmRow.locator('.console-op-button', {
+    hasText: 'Change color',
+  });
+  await expect(changeColorButton).toBeVisible();
+
+  await changeColorButton.click();
+
+  const palette = tdpmRow.locator('.console-story-color-palette');
+  await expect(palette).toBeVisible();
+
+  const swatches = palette.locator('.console-story-color-swatch');
+  await expect(swatches).toHaveCount(8);
+
+  const graySwatch = swatches.filter({ hasText: 'disable' });
+  await expect(graySwatch).toHaveCount(1);
+
+  const greenSwatch = palette.locator('[aria-label="GREEN"]');
+  await greenSwatch.click();
+
+  await expect
+    .poll(() => harness.storyColorCalls.length, { timeout: 10000 })
+    .toBe(1);
+  expect(harness.storyColorCalls[0].storyOptionId).toBe('1491051e');
+  expect(harness.storyColorCalls[0].newColor).toBe('GREEN');
+
+  await expect(palette).toHaveCount(0);
+});
+
 test('reorders stories on the triage tab with up/down buttons', async ({
   page,
 }) => {

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

@@ -47,6 +47,11 @@ export type ConsoleE2eCreateIssueCall = {
   title: string;
 };
 
+export type ConsoleE2eStoryColorCall = {
+  storyOptionId: string;
+  newColor: string;
+};
+
 type ConsoleFixtureListItem = {
   number: number;
   title: string;
@@ -391,6 +396,7 @@ const buildIssueForUrl = (url: string): Issue => ({
   author: 'HiromiShikata',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
 });
 
 const notImplemented = (method: string): never => {
@@ -453,6 +459,7 @@ const createStubIssueRepository = (
   reviewCommentCalls: ConsoleE2eReviewCommentCall[],
   requestChangesCalls: ConsoleE2eRequestChangesCall[],
   createIssueCalls: ConsoleE2eCreateIssueCall[],
+  storyColorCalls: ConsoleE2eStoryColorCall[],
 ): IssueRepository => ({
   getAllIssues: () => notImplemented('getAllIssues'),
   getIssueByUrl: async (url: string): Promise<Issue | null> =>
@@ -615,6 +622,13 @@ const createStubIssueRepository = (
         }
       : null,
   setIssueAgentField: async (): Promise<void> => undefined,
+  updateStoryOptionColor: async (
+    _project,
+    storyOptionId: string,
+    newColor: string,
+  ): Promise<void> => {
+    storyColorCalls.push({ storyOptionId, newColor });
+  },
 });
 
 export type ConsoleE2eReorderStoryCall = {
@@ -635,6 +649,7 @@ export type ConsoleE2eHarness = {
   createIssueCalls: ConsoleE2eCreateIssueCall[];
   reorderStoryCalls: ConsoleE2eReorderStoryCall[];
   addStoryCalls: ConsoleE2eAddStoryCall[];
+  storyColorCalls: ConsoleE2eStoryColorCall[];
   stop: () => Promise<void>;
 };
 
@@ -658,6 +673,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
   const createIssueCalls: ConsoleE2eCreateIssueCall[] = [];
   const reorderStoryCalls: ConsoleE2eReorderStoryCall[] = [];
   const addStoryCalls: ConsoleE2eAddStoryCall[] = [];
+  const storyColorCalls: ConsoleE2eStoryColorCall[] = [];
 
   const server = await startWebServer({
     accessToken: CONSOLE_E2E_TOKEN,
@@ -667,6 +683,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
       reviewCommentCalls,
       requestChangesCalls,
       createIssueCalls,
+      storyColorCalls,
     ),
     projectRepository: {
       updateStoryList: async (_updatedProject, stories) => {
@@ -726,6 +743,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     createIssueCalls,
     reorderStoryCalls,
     addStoryCalls,
+    storyColorCalls,
     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/ConsoleStoryList.stories.tsx

@@ -53,6 +53,10 @@ const meta: Meta<typeof ConsoleStoryList> = {
   args: {
     onCreateIssue: () => Promise.resolve(),
     onAddStory: () => Promise.resolve(),
+    onSelectColor: () => undefined,
+    optimisticColors: {},
+    colorChangeInFlight: null,
+    colorErrors: {},
   },
 };