github-issue-tower-defence-management 1.60.1 → 1.63.1

package/src/domain/usecases/CreateNewStoryByLabelUseCase.test.ts

@@ -26,27 +26,51 @@ describe('CreateNewStoryByLabelUseCase', () => {
     },
   };
 
-  const issueWithNewStoryLabel = {
+  const issueWithNewStoryLabel: Issue = {
     ...mock<Issue>(),
+    url: 'https://github.com/org/repo/issues/999',
     title: 'New Feature Request',
     number: 999,
+    story: 'Existing Story',
     labels: ['bug', 'new-story', 'priority-high'],
   };
 
-  const issueWithNewStoryLabelVariant = {
+  const issueWithNewStoryLabelVariant: Issue = {
     ...mock<Issue>(),
+    url: 'https://github.com/org/repo/issues/1000',
     title: 'Another New Story',
     number: 1000,
+    story: 'Existing Story',
     labels: ['newstory', 'enhancement'],
   };
 
-  const regularIssue = {
+  const regularIssue: Issue = {
     ...mock<Issue>(),
+    url: 'https://github.com/org/repo/issues/888',
     title: 'Regular Issue',
     number: 888,
+    story: 'Existing Story',
     labels: ['bug', 'priority-low'],
   };
 
+  const unassignedIssueWithNewStoryLabel: Issue = {
+    ...mock<Issue>(),
+    url: 'https://github.com/org/repo/issues/1383',
+    title: 'Unassigned Story Issue',
+    number: 1383,
+    story: null,
+    labels: ['new-story'],
+  };
+
+  const unassignedRegularIssue: Issue = {
+    ...mock<Issue>(),
+    url: 'https://github.com/org/repo/issues/1384',
+    title: 'Unassigned Regular Issue',
+    number: 1384,
+    story: null,
+    labels: ['bug'],
+  };
+
   const storyObjectWithNewStoryIssues: StoryObject = {
     story: {
       ...mock<StoryOption>(),
@@ -85,6 +109,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
         org: 'testOrg',
         repo: 'testRepo',
         storyObjectMap: new Map([['Story 1', storyObjectWithNewStoryIssues]]),
+        issues: [],
       });
 
       expect(mockProjectRepository.updateStoryList).not.toHaveBeenCalled();
@@ -107,6 +132,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
         storyObjectMap: new Map([
           ['Story 1', storyObjectWithoutNewStoryIssues],
         ]),
+        issues: [regularIssue, unassignedRegularIssue],
       });
 
       expect(mockProjectRepository.updateStoryList).not.toHaveBeenCalled();
@@ -141,6 +167,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
         org: 'testOrg',
         repo: 'testRepo',
         storyObjectMap: new Map([['Story 1', storyObjectWithNewStoryIssues]]),
+        issues: [],
       });
 
       expect(mockProjectRepository.updateStoryList).toHaveBeenCalledTimes(1);
@@ -207,11 +234,84 @@ describe('CreateNewStoryByLabelUseCase', () => {
       );
     });
 
+    it('should create new story for an unassigned issue with new-story label', async () => {
+      const savedStories: FieldOption[] = [
+        { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
+        {
+          id: 'newStoryId1',
+          name: 'Unassigned Story Issue',
+          description: '',
+          color: 'RED',
+        },
+        { id: 'story2', name: 'Middle Story', color: 'GREEN', description: '' },
+        { id: 'story3', name: 'Last Story', color: 'YELLOW', description: '' },
+      ];
+
+      mockProjectRepository.updateStoryList.mockResolvedValue(savedStories);
+
+      const emptyStoryObjectMap = new Map<string, StoryObject>();
+
+      await useCase.run({
+        project: basicProject,
+        cacheUsed: false,
+        org: 'testOrg',
+        repo: 'testRepo',
+        storyObjectMap: emptyStoryObjectMap,
+        issues: [unassignedIssueWithNewStoryLabel, unassignedRegularIssue],
+      });
+
+      expect(mockProjectRepository.updateStoryList).toHaveBeenCalledTimes(1);
+      expect(mockProjectRepository.updateStoryList).toHaveBeenCalledWith(
+        basicProject,
+        [
+          {
+            id: 'story1',
+            name: 'First Story',
+            color: 'BLUE',
+            description: '',
+          },
+          {
+            id: null,
+            name: 'Unassigned Story Issue',
+            description: '',
+            color: 'RED',
+          },
+          {
+            id: 'story2',
+            name: 'Middle Story',
+            color: 'GREEN',
+            description: '',
+          },
+          {
+            id: 'story3',
+            name: 'Last Story',
+            color: 'YELLOW',
+            description: '',
+          },
+        ],
+      );
+
+      expect(mockIssueRepository.updateStory).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
+        { ...basicProject, story: basicProject.story },
+        unassignedIssueWithNewStoryLabel,
+        'newStoryId1',
+      );
+
+      expect(mockIssueRepository.updateLabels).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateLabels).toHaveBeenCalledWith(
+        unassignedIssueWithNewStoryLabel,
+        [],
+      );
+    });
+
     it('should skip issues when no matching story is found in saved list', async () => {
-      const issueWithUnmatchedTitle = {
+      const issueWithUnmatchedTitle: Issue = {
         ...mock<Issue>(),
+        url: 'https://github.com/org/repo/issues/1001',
         title: 'Unmatched Title',
         number: 1001,
+        story: 'Existing Story',
         labels: ['new-story'],
       };
 
@@ -237,6 +337,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
         org: 'testOrg',
         repo: 'testRepo',
         storyObjectMap: new Map([['Story 1', storyObject]]),
+        issues: [],
       });
 
       expect(mockProjectRepository.updateStoryList).toHaveBeenCalledTimes(1);
@@ -246,24 +347,30 @@ describe('CreateNewStoryByLabelUseCase', () => {
   });
 
   describe('findNewStoryIssues', () => {
-    const issueWithNoHyphen = {
+    const issueWithNoHyphen: Issue = {
       ...mock<Issue>(),
+      url: 'https://github.com/org/repo/issues/1002',
       title: 'No Hyphen Issue',
       number: 1002,
+      story: 'Some Story',
       labels: ['newstory'],
     };
 
-    const issueWithMixedCase = {
+    const issueWithMixedCase: Issue = {
       ...mock<Issue>(),
+      url: 'https://github.com/org/repo/issues/1003',
       title: 'Mixed Case Issue',
       number: 1003,
+      story: 'Some Story',
       labels: ['NEW-STORY'],
     };
 
-    const anotherIssueWithLabel = {
+    const anotherIssueWithLabel: Issue = {
       ...mock<Issue>(),
+      url: 'https://github.com/org/repo/issues/1004',
       title: 'Another Issue',
       number: 1004,
+      story: 'Some Story',
       labels: ['newstory'],
     };
 
@@ -294,6 +401,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
     const testCases: Array<{
       description: string;
       storyObjectMap: Map<string, StoryObject>;
+      issues: Issue[];
       expectedLength: number;
       expectedIssues: Issue[];
     }> = [
@@ -301,24 +409,28 @@ describe('CreateNewStoryByLabelUseCase', () => {
         description:
           'should return empty array when no issues have new-story label',
         storyObjectMap: new Map([['Story 1', storyObjectWithRegularIssue]]),
+        issues: [unassignedRegularIssue],
         expectedLength: 0,
         expectedIssues: [],
       },
       {
         description: 'should find issues with "new-story" label (with hyphen)',
         storyObjectMap: new Map([['Story 1', storyObjectWithNewStoryIssues]]),
+        issues: [],
         expectedLength: 2,
         expectedIssues: [issueWithNewStoryLabel, issueWithNewStoryLabelVariant],
       },
       {
         description: 'should find issues with "newstory" label (no hyphen)',
         storyObjectMap: new Map([['Story 1', storyObjectWithNoHyphen]]),
+        issues: [],
         expectedLength: 1,
         expectedIssues: [issueWithNoHyphen],
       },
       {
         description: 'should find issues with mixed case "NEW-STORY" label',
         storyObjectMap: new Map([['Story 1', storyObjectWithMixedCase]]),
+        issues: [],
         expectedLength: 1,
         expectedIssues: [issueWithMixedCase],
       },
@@ -328,6 +440,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           ['Story 1', storyObjectWithNewStoryIssues],
           ['Story 2', storyObjectWithAnotherIssue],
         ]),
+        issues: [],
         expectedLength: 3,
         expectedIssues: [
           issueWithNewStoryLabel,
@@ -335,12 +448,32 @@ describe('CreateNewStoryByLabelUseCase', () => {
           anotherIssueWithLabel,
         ],
       },
+      {
+        description:
+          'should find unassigned issues with new-story label not present in storyObjectMap',
+        storyObjectMap: new Map<string, StoryObject>(),
+        issues: [unassignedIssueWithNewStoryLabel, unassignedRegularIssue],
+        expectedLength: 1,
+        expectedIssues: [unassignedIssueWithNewStoryLabel],
+      },
+      {
+        description:
+          'should not duplicate issue that appears in both storyObjectMap and issues array',
+        storyObjectMap: new Map([['Story 1', storyObjectWithNewStoryIssues]]),
+        issues: [issueWithNewStoryLabel, unassignedIssueWithNewStoryLabel],
+        expectedLength: 3,
+        expectedIssues: [
+          issueWithNewStoryLabel,
+          issueWithNewStoryLabelVariant,
+          unassignedIssueWithNewStoryLabel,
+        ],
+      },
     ];
 
     test.each(testCases)(
       '$description',
-      ({ storyObjectMap, expectedLength, expectedIssues }) => {
-        const result = useCase.findNewStoryIssues(storyObjectMap);
+      ({ storyObjectMap, issues, expectedLength, expectedIssues }) => {
+        const result = useCase.findNewStoryIssues(storyObjectMap, issues);
 
         expect(result).toHaveLength(expectedLength);
         expectedIssues.forEach((issue) => {
@@ -367,6 +500,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
       description: string;
       projectStory: NonNullable<Project['story']>;
       storyObjectMap: Map<string, StoryObject>;
+      issues: Issue[];
       expected: (Omit<FieldOption, 'id'> & { id: FieldOption['id'] | null })[];
     }> = [
       {
@@ -399,6 +533,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithSingleNewStory]]),
+        issues: [],
         expected: [
           { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
           {
@@ -450,6 +585,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithNewStoryIssues]]),
+        issues: [],
         expected: [
           { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
           {
@@ -488,6 +624,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithSingleNewStory]]),
+        issues: [],
         expected: [
           {
             id: null,
@@ -514,6 +651,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithSingleNewStory]]),
+        issues: [],
         expected: [
           { id: 'story1', name: 'Only Story', color: 'BLUE', description: '' },
           {
@@ -547,6 +685,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithSingleNewStory]]),
+        issues: [],
         expected: [
           { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
           {
@@ -592,6 +731,7 @@ describe('CreateNewStoryByLabelUseCase', () => {
           workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
         },
         storyObjectMap: new Map([['Story 1', storyObjectWithRegularIssueOnly]]),
+        issues: [unassignedRegularIssue],
         expected: [
           { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
           {
@@ -608,12 +748,57 @@ describe('CreateNewStoryByLabelUseCase', () => {
           },
         ],
       },
+      {
+        description:
+          'should include unassigned issue with new-story label in new story list',
+        projectStory: {
+          name: 'Story Field',
+          fieldId: 'storyFieldId',
+          databaseId: 123,
+          stories: [
+            {
+              id: 'story1',
+              name: 'First Story',
+              color: 'BLUE',
+              description: '',
+            },
+            {
+              id: 'story2',
+              name: 'Middle Story',
+              color: 'GREEN',
+              description: '',
+            },
+          ],
+          workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
+        },
+        storyObjectMap: new Map<string, StoryObject>(),
+        issues: [unassignedIssueWithNewStoryLabel],
+        expected: [
+          { id: 'story1', name: 'First Story', color: 'BLUE', description: '' },
+          {
+            id: null,
+            name: 'Unassigned Story Issue',
+            color: 'RED',
+            description: '',
+          },
+          {
+            id: 'story2',
+            name: 'Middle Story',
+            color: 'GREEN',
+            description: '',
+          },
+        ],
+      },
     ];
 
     test.each(testCases)(
       '$description',
-      ({ projectStory, storyObjectMap, expected }) => {
-        const result = useCase.createNewStoryList(projectStory, storyObjectMap);
+      ({ projectStory, storyObjectMap, issues, expected }) => {
+        const result = useCase.createNewStoryList(
+          projectStory,
+          storyObjectMap,
+          issues,
+        );
 
         expect(result).toEqual(expected);
       },

package/src/domain/usecases/CreateNewStoryByLabelUseCase.ts

@@ -19,18 +19,23 @@ export class CreateNewStoryByLabelUseCase {
     org: string;
     repo: string;
     storyObjectMap: StoryObjectMap;
+    issues: Issue[];
   }): Promise<void> => {
     const projectStory = input.project.story;
     if (!projectStory) {
       return;
     }
-    const newStoryIssues = this.findNewStoryIssues(input.storyObjectMap);
+    const newStoryIssues = this.findNewStoryIssues(
+      input.storyObjectMap,
+      input.issues,
+    );
     if (newStoryIssues.length === 0) {
       return;
     }
     const newStoryList = this.createNewStoryList(
       projectStory,
       input.storyObjectMap,
+      input.issues,
     );
     const savedNewStoryList = await this.projectRepository.updateStoryList(
       input.project,
@@ -55,26 +60,38 @@ export class CreateNewStoryByLabelUseCase {
       );
     }
   };
-  findNewStoryIssues = (storyObjectMap: StoryObjectMap): Issue[] => {
-    return Array.from(storyObjectMap.values())
+
+  hasNewStoryLabel = (issue: Issue): boolean =>
+    issue.labels?.some(
+      (label) => label.toLowerCase().replace('-', '') === 'newstory',
+    ) ?? false;
+
+  findNewStoryIssues = (
+    storyObjectMap: StoryObjectMap,
+    issues: Issue[],
+  ): Issue[] => {
+    const issuesInMap = Array.from(storyObjectMap.values())
       .flatMap((storyObject) => storyObject.issues)
-      .filter((issue) =>
-        issue.labels?.some(
-          (label) => label.toLowerCase().replace('-', '') === 'newstory',
-        ),
-      );
+      .filter(this.hasNewStoryLabel);
+    const unassignedIssuesWithLabel = issues
+      .filter((issue) => issue.story === null)
+      .filter(this.hasNewStoryLabel);
+    const seen = new Set<string>();
+    return [...issuesInMap, ...unassignedIssuesWithLabel].filter((issue) => {
+      if (seen.has(issue.url)) {
+        return false;
+      }
+      seen.add(issue.url);
+      return true;
+    });
   };
+
   createNewStoryList = (
     projectStory: NonNullable<Project['story']>,
     storyObjectMap: StoryObjectMap,
+    issues: Issue[],
   ): (Omit<FieldOption, 'id'> & { id: FieldOption['id'] | null })[] => {
-    const newStoryIssues = Array.from(storyObjectMap.values())
-      .flatMap((storyObject) => storyObject.issues)
-      .filter((issue) =>
-        issue.labels?.some(
-          (label) => label.toLowerCase().replace('-', '') === 'newstory',
-        ),
-      );
+    const newStoryIssues = this.findNewStoryIssues(storyObjectMap, issues);
     const newStoryList: (Omit<FieldOption, 'id'> & {
       id: FieldOption['id'] | null;
     })[] = [];

package/src/domain/usecases/HandleScheduledEventUseCase.test.ts

@@ -159,6 +159,9 @@ describe('HandleScheduledEventUseCase', () => {
         ['LastExecutionDateTime'],
         ['2024-01-01T00:00:00Z'],
       ]);
+      mockStartPreparationUseCase.run.mockResolvedValue({
+        rotationOrder: null,
+      });
     });
 
     it('should call AnalyzeProblemByIssueUseCase with correct parameters', async () => {
@@ -377,6 +380,7 @@ describe('HandleScheduledEventUseCase', () => {
       });
       mockStartPreparationUseCase.run.mockImplementation(async () => {
         callOrder.push('startPreparation');
+        return { rotationOrder: null };
       });
 
       const input = {

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -19,7 +19,10 @@ import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
-import { StartPreparationUseCase } from './StartPreparationUseCase';
+import {
+  RotationOrderEntry,
+  StartPreparationUseCase,
+} from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
@@ -96,6 +99,7 @@ export class HandleScheduledEventUseCase {
     cacheUsed: boolean;
     targetDateTimes: Date[];
     storyIssues: StoryObjectMap;
+    rotationOrder: RotationOrderEntry[] | null;
   } | null> => {
     if (input.disabled) {
       return null;
@@ -205,8 +209,9 @@ export class HandleScheduledEventUseCase {
       now,
     );
 
+    let rotationOrder: RotationOrderEntry[] | null = null;
     try {
-      await this.runEachUseCases(
+      const useCaseResult = await this.runEachUseCases(
         input,
         project,
         issues,
@@ -215,6 +220,7 @@ export class HandleScheduledEventUseCase {
         storyIssues,
         runSlowSweep,
       );
+      rotationOrder = useCaseResult.rotationOrder;
     } catch (e) {
       if (!(e instanceof Error)) {
         throw e;
@@ -238,7 +244,14 @@ ${JSON.stringify(e)}
       throw e;
     }
 
-    return { project, issues, cacheUsed, targetDateTimes, storyIssues };
+    return {
+      project,
+      issues,
+      cacheUsed,
+      targetDateTimes,
+      storyIssues,
+      rotationOrder,
+    };
   };
   runEachUseCases = async (
     input: Parameters<HandleScheduledEventUseCase['run']>[0],
@@ -248,7 +261,7 @@ ${JSON.stringify(e)}
     targetDateTimes: Date[],
     storyObjectMap: StoryObjectMap,
     runSlowSweep: boolean,
-  ): Promise<void> => {
+  ): Promise<{ rotationOrder: RotationOrderEntry[] | null }> => {
     if (runSlowSweep) {
       await this.runSlowSweepUseCases(
         input,
@@ -284,7 +297,7 @@ ${JSON.stringify(e)}
             input.startPreparation.awaitingQualityCheckStatus ?? undefined,
         });
       }
-      await this.startPreparationUseCase.run({
+      const preparationResult = await this.startPreparationUseCase.run({
         projectUrl: input.projectUrl,
         defaultAgentName: input.startPreparation.defaultAgentName,
         defaultLlmModelName: input.startPreparation.defaultLlmModelName ?? null,
@@ -298,7 +311,9 @@ ${JSON.stringify(e)}
         codexHomeCandidates: input.startPreparation.codexHomeCandidates ?? null,
         allowIssueCacheMinutes: input.allowIssueCacheMinutes,
       });
+      return { rotationOrder: preparationResult.rotationOrder };
     }
+    return { rotationOrder: null };
   };
   runSlowSweepUseCases = async (
     input: Parameters<HandleScheduledEventUseCase['run']>[0],
@@ -388,6 +403,7 @@ ${JSON.stringify(e)}
       org: input.org,
       repo: input.workingReport.repo,
       storyObjectMap: storyObjectMap,
+      issues: issues,
     });
     await this.assignNoAssigneeIssueToManagerUseCase.run({
       issues,