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

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

@@ -0,0 +1,225 @@
+import { mock } from 'jest-mock-extended';
+import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { DateRepository } from './adapter-interfaces/DateRepository';
+import { Project } from '../entities/Project';
+import { StoryObject } from '../entities/StoryObjectMap';
+import { Issue } from '../entities/Issue';
+
+describe('CreateEstimationIssueUseCase', () => {
+  const mockIssueRepository = mock<IssueRepository>();
+  const mockDateRepository = mock<DateRepository>();
+
+  let useCase: CreateEstimationIssueUseCase;
+
+  const projectWithStory: Project = {
+    ...mock<Project>(),
+    story: {
+      name: 'Story',
+      fieldId: 'story-field',
+      databaseId: 1,
+      stories: [],
+      workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
+    },
+    remainingEstimationMinutes: null,
+    completionDate50PercentConfidence: null,
+  };
+
+  const commonInput = {
+    project: projectWithStory,
+    issues: [],
+    cacheUsed: false,
+    manager: 'manager-user',
+    org: 'org',
+    repo: 'repo',
+    urlOfStoryView: 'https://github.com/org/repo',
+    storyObjectMap: new Map<string, StoryObject>(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useCase = new CreateEstimationIssueUseCase(
+      mockIssueRepository,
+      mockDateRepository,
+    );
+  });
+
+  describe('run — UTC 07:00 guard', () => {
+    it('returns early when no targetDate is at UTC 07:00', async () => {
+      const nonMatchingDate = new Date(Date.UTC(2026, 0, 15, 6, 0, 0));
+
+      await useCase.run({ ...commonInput, targetDates: [nonMatchingDate] });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('returns early when targetDates is empty', async () => {
+      await useCase.run({ ...commonInput, targetDates: [] });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('returns early when project has no story field', async () => {
+      const projectWithoutStory: Project = { ...projectWithStory, story: null };
+
+      await useCase.run({
+        ...commonInput,
+        project: projectWithoutStory,
+        targetDates: [new Date(Date.UTC(2026, 0, 15, 7, 0, 0))],
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('run — weekend skip', () => {
+    const projectWithNonRegularStory: Project = {
+      ...projectWithStory,
+      story: {
+        name: 'Story',
+        fieldId: 'story-field',
+        databaseId: 1,
+        stories: [
+          {
+            id: 'story-1',
+            name: 'Feature Story',
+            color: 'BLUE',
+            description: '',
+          },
+        ],
+        workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
+      },
+    };
+
+    it('returns early when the last targetDate falls on Saturday UTC', async () => {
+      const saturdayAt07h = new Date(Date.UTC(2026, 0, 17, 7, 0, 0));
+      expect(saturdayAt07h.getUTCDay()).toBe(6);
+
+      await useCase.run({
+        ...commonInput,
+        project: projectWithNonRegularStory,
+        targetDates: [saturdayAt07h],
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('returns early when the last targetDate falls on Sunday UTC', async () => {
+      const sundayAt07h = new Date(Date.UTC(2026, 0, 18, 7, 0, 0));
+      expect(sundayAt07h.getUTCDay()).toBe(0);
+
+      await useCase.run({
+        ...commonInput,
+        project: projectWithNonRegularStory,
+        targetDates: [sundayAt07h],
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+    });
+
+    it('proceeds past the weekend guard on a weekday UTC 07:00', async () => {
+      const thursdayAt07h = new Date(Date.UTC(2026, 0, 15, 7, 0, 0));
+      expect(thursdayAt07h.getUTCDay()).toBe(4);
+
+      await expect(
+        useCase.run({
+          ...commonInput,
+          project: projectWithNonRegularStory,
+          targetDates: [thursdayAt07h],
+        }),
+      ).rejects.toThrow('Story issue not found: Feature Story');
+    });
+  });
+
+  describe('run — completionDate50PercentConfidence Monday UTC reset', () => {
+    const mondayAt07hUTC = new Date(Date.UTC(2026, 0, 12, 7, 0, 0));
+
+    const featureStory = {
+      id: 'story-feat',
+      name: 'Feature Story',
+      color: 'BLUE' as const,
+      description: '',
+    };
+
+    const projectWithCompletionField: Project = {
+      ...mock<Project>(),
+      story: {
+        name: 'Story',
+        fieldId: 'story-field',
+        databaseId: 1,
+        stories: [featureStory],
+        workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
+      },
+      remainingEstimationMinutes: null,
+      completionDate50PercentConfidence: {
+        name: 'Completion Date',
+        fieldId: 'completion-field',
+      },
+    };
+
+    const storyIssue: Issue = {
+      ...mock<Issue>(),
+      title: 'Feature Story',
+      labels: ['story', 'story:action:schedule-control'],
+      isClosed: false,
+      isPr: false,
+      url: 'https://github.com/org/repo/issues/1',
+    };
+
+    const farFutureDate = new Date(Date.UTC(2026, 5, 1, 0, 0, 0));
+    const issueInStory: Issue = {
+      ...mock<Issue>(),
+      title: 'Task issue',
+      labels: [],
+      isClosed: false,
+      isPr: false,
+      status: null,
+      estimationMinutes: null,
+      completionDate50PercentConfidence: farFutureDate,
+      assignees: ['dev-user'],
+    };
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('clears completionDate50PercentConfidence on UTC Monday even when date is far in future', async () => {
+      expect(mondayAt07hUTC.getUTCDay()).toBe(1);
+
+      mockDateRepository.formatDateWithDayOfWeek.mockReturnValue(
+        'Mon, Jun 01, 2026',
+      );
+
+      const storyObjectMap = new Map<string, StoryObject>([
+        [
+          featureStory.name,
+          { story: featureStory, storyIssue, issues: [issueInStory] },
+        ],
+      ]);
+
+      const runPromise = useCase.run({
+        project: projectWithCompletionField,
+        issues: [storyIssue],
+        cacheUsed: false,
+        manager: 'manager-user',
+        org: 'org',
+        repo: 'repo',
+        urlOfStoryView: 'https://github.com/org/repo',
+        storyObjectMap,
+        targetDates: [mondayAt07hUTC],
+      });
+      await jest.runAllTimersAsync();
+      await runPromise;
+
+      expect(mockIssueRepository.clearProjectField).toHaveBeenCalledWith(
+        projectWithCompletionField,
+        'completion-field',
+        issueInStory,
+      );
+    });
+  });
+});

package/src/domain/usecases/CreateEstimationIssueUseCase.ts

@@ -32,7 +32,7 @@ export class CreateEstimationIssueUseCase {
       !story ||
       !input.targetDates.find(
         (targetDate) =>
-          targetDate.getHours() === 7 && targetDate.getMinutes() === 0,
+          targetDate.getUTCHours() === 7 && targetDate.getUTCMinutes() === 0,
       )
     ) {
       return;
@@ -41,7 +41,7 @@ export class CreateEstimationIssueUseCase {
     if (!targetDate) {
       return;
     }
-    if (targetDate.getDay() === 0 || targetDate.getDay() === 6) {
+    if (targetDate.getUTCDay() === 0 || targetDate.getUTCDay() === 6) {
       return;
     }
 
@@ -91,7 +91,7 @@ export class CreateEstimationIssueUseCase {
           !!issueInStory.completionDate50PercentConfidence &&
           (issueInStory.completionDate50PercentConfidence.getTime() <
             targetDate.getTime() + 7 * 24 * 60 * 60 * 1000 ||
-            targetDate.getDay() === 1)
+            targetDate.getUTCDay() === 1)
         ) {
           await this.issueRepository.createComment(
             issueInStory,

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

@@ -1617,4 +1617,111 @@ describe('HandleScheduledEventUseCase', () => {
       });
     });
   });
+
+  describe('storyIssues', () => {
+    const useCase = new HandleScheduledEventUseCase(
+      mock<ProjectRequiredFieldCreateUseCase>(),
+      mock<SetupTowerDefenceProjectUseCase>(),
+      mock<ActionAnnouncementUseCase>(),
+      mock<SetWorkflowManagementIssueToStoryUseCase>(),
+      mock<ClearPastNextActionDateHourUseCase>(),
+      mock<AnalyzeProblemByIssueUseCase>(),
+      mock<AnalyzeStoriesUseCase>(),
+      mock<ClearDependedIssueURLUseCase>(),
+      mock<SetDependedIssueUrlForOpenTaskPRsUseCase>(),
+      mock<StaleTaskPullRequestCloseUseCase>(),
+      mock<CreateEstimationIssueUseCase>(),
+      mock<ConvertCheckboxToIssueInStoryIssueUseCase>(),
+      mock<ChangeStatusByStoryColorUseCase>(),
+      mock<SetNoStoryIssueToStoryUseCase>(),
+      mock<CreateNewStoryByLabelUseCase>(),
+      mock<AssignNoAssigneeIssueToManagerUseCase>(),
+      mock<UpdateIssueStatusByLabelUseCase>(),
+      mock<StartPreparationUseCase>(),
+      mock<RevertOrphanedPreparationUseCase>(),
+      mock<RevertNotReadyReviewQueueIssueUseCase>(),
+      mock<TriagerApprovalDispatchUseCase>(),
+      mock<AgentDesignationLabelAdoptUseCase>(),
+      null,
+      null,
+      mock<QualityCheckAdvanceUseCase>(),
+      mock<DateRepository>(),
+      mock<SpreadsheetRepository>(),
+      mock<ProjectRepository>(),
+      mock<IssueRepository>(),
+    );
+
+    const storyName = 'my story / feature';
+    const baseProject: Project = {
+      id: 'project-1',
+      url: 'https://github.com/orgs/user/projects/1',
+      databaseId: 1,
+      name: 'Test Project',
+      status: { name: 'Status', fieldId: 'status-field-id', statuses: [] },
+      nextActionDate: null,
+      nextActionHour: null,
+      story: {
+        name: 'Story',
+        fieldId: 'story-field-id',
+        databaseId: 1,
+        stories: [
+          { id: 'story-1', name: storyName, color: 'BLUE', description: '' },
+        ],
+        workflowManagementStory: { id: 'wms-1', name: 'workflow management' },
+      },
+      remainingEstimationMinutes: null,
+      dependedIssueUrlSeparatedByComma: null,
+      completionDate50PercentConfidence: null,
+      agent: null,
+    };
+
+    const baseIssue: Issue = {
+      nameWithOwner: 'user/repo',
+      number: 1,
+      title: storyName,
+      state: 'OPEN',
+      status: null,
+      story: null,
+      nextActionDate: null,
+      nextActionHour: null,
+      estimationMinutes: null,
+      dependedIssueUrls: [],
+      completionDate50PercentConfidence: null,
+      url: 'https://github.com/user/repo/issues/1',
+      assignees: [],
+      labels: [],
+      org: 'user',
+      repo: 'repo',
+      body: '',
+      itemId: 'item-1',
+      isPr: false,
+      isInProgress: false,
+      isClosed: false,
+      createdAt: new Date('2024-01-01T00:00:00Z'),
+      author: '',
+      closingIssueReferenceUrls: [],
+      agent: null,
+    };
+
+    it('should return storyIssue as null when the only matching issue is closed', async () => {
+      const closedIssue: Issue = {
+        ...baseIssue,
+        state: 'CLOSED',
+        isClosed: true,
+      };
+      const result = await useCase.storyIssues({
+        project: baseProject,
+        issues: [closedIssue],
+      });
+      expect(result.get(storyName)?.storyIssue).toBeNull();
+    });
+
+    it('should return the open matching issue as storyIssue', async () => {
+      const result = await useCase.storyIssues({
+        project: baseProject,
+        issues: [baseIssue],
+      });
+      expect(result.get(storyName)?.storyIssue).toBe(baseIssue);
+    });
+  });
 });

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -622,20 +622,20 @@ ${JSON.stringify(e)}
     const targetDateTimes: Date[] = [];
     if (from.getTime() > to.getTime()) {
       const targetDate = new Date(to);
-      targetDate.setSeconds(0);
-      targetDate.setMilliseconds(0);
+      targetDate.setUTCSeconds(0);
+      targetDate.setUTCMilliseconds(0);
       return [targetDate];
     }
     const targetDate = new Date(from);
     targetDate.setTime(targetDate.getTime() + 60 * 1000);
-    targetDate.setSeconds(0);
-    targetDate.setMilliseconds(0);
+    targetDate.setUTCSeconds(0);
+    targetDate.setUTCMilliseconds(0);
     while (
       targetDate.getTime() <= to.getTime() &&
       targetDateTimes.length < 300
     ) {
       targetDateTimes.push(new Date(targetDate));
-      targetDate.setMinutes(targetDate.getMinutes() + 1);
+      targetDate.setUTCMinutes(targetDate.getUTCMinutes() + 1);
     }
     return targetDateTimes;
   };
@@ -816,8 +816,8 @@ ${JSON.stringify(e)}
     const summaryStoryIssue: StoryObjectMap = new Map();
     const targetStory = input.project.story?.stories || [];
     for (const story of targetStory) {
-      const storyIssue = input.issues.find((issue) =>
-        story.name.startsWith(issue.title),
+      const storyIssue = input.issues.find(
+        (issue) => story.name.startsWith(issue.title) && !issue.isClosed,
       );
       summaryStoryIssue.set(story.name, {
         story,

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

@@ -258,6 +258,89 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
     });
 
+    it('should require PR evaluation and reject CI failure when issue agent is pr-reviewer', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/10', {
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+        }),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+        agent: 'pr-reviewer',
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections.map((r) => r.type)).toContain(
+        'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
+      );
+    });
+
+    it('should require PR evaluation and reject conflict when issue agent is pr-reviewer', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/10', {
+          isConflicted: true,
+        }),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+        agent: 'pr-reviewer',
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections.map((r) => r.type)).toContain(
+        'PULL_REQUEST_CONFLICTED',
+      );
+    });
+
+    it('should require PR evaluation and approve when issue agent is pr-reviewer with passing CI and no conflict', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/10'),
+      ]);
+
+      const result = await evaluator.evaluate({
+        url: 'https://github.com/user/repo/issues/1',
+        labels: [],
+        isPr: false,
+        agent: 'pr-reviewer',
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(0);
+      expect(result.approvedPrUrl).toBe('https://github.com/user/repo/pull/10');
+    });
+
+    it('should still require PR evaluation for pr-reviewer when custom developerAgentName is set', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr('https://github.com/user/repo/pull/10', {
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+        }),
+      ]);
+
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'pr-reviewer',
+        },
+        [],
+        { developerAgentName: 'my-developer' },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections.map((r) => r.type)).toContain(
+        'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
+      );
+    });
+
     it('should not reject for draft state when issue has non-e2e category label', async () => {
       const result = await evaluator.evaluate({
         url: 'https://github.com/user/repo/issues/1',

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -204,7 +204,9 @@ export class IssueRejectionEvaluator {
     );
     const effectiveDeveloperAgentName = developerAgentName ?? 'developer';
     const isNonDeveloperAgent =
-      issue.agent != null && issue.agent !== effectiveDeveloperAgentName;
+      issue.agent != null &&
+      issue.agent !== effectiveDeveloperAgentName &&
+      issue.agent !== 'pr-reviewer';
     const hasLabelNotRequiringPullRequest = issue.labels.some((label) =>
       labelsNotRequiringPullRequest.includes(label),
     );

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -453,9 +453,11 @@ export class StartPreparationUseCase {
       }
       if (issueReactivationTriggerIsPending(issue, now)) {
         const startOfTomorrow = new Date(
-          now.getFullYear(),
-          now.getMonth(),
-          now.getDate() + 1,
+          Date.UTC(
+            now.getUTCFullYear(),
+            now.getUTCMonth(),
+            now.getUTCDate() + 1,
+          ),
         );
         if (
           issue.nextActionDate !== null &&