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

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

@@ -858,6 +858,126 @@ describe('IssueRejectionEvaluator', () => {
       });
     });
 
+    describe('detectConflictEvenIfEvaluationSkipped option', () => {
+      it('should call findRelatedOpenPRs and return PULL_REQUEST_CONFLICTED when relatedOpenPrUrls is null and PR is conflicted', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1', {
+            isConflicted: true,
+          }),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+          'https://github.com/user/repo/issues/1',
+        );
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should call findRelatedOpenPRs and return no rejections when relatedOpenPrUrls is null and no PR is conflicted', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1'),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+          'https://github.com/user/repo/issues/1',
+        );
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should use resolveOpenPrsFromUrls path and not call findRelatedOpenPRs when relatedOpenPrUrls is provided', async () => {
+        mockIssueRepository.getOpenPullRequest.mockResolvedValue(
+          createReadyPr('https://github.com/user/repo/pull/5', {
+            isConflicted: true,
+          }),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: ['https://github.com/user/repo/pull/5'],
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+        expect(mockIssueRepository.getOpenPullRequest).toHaveBeenCalledWith(
+          'https://github.com/user/repo/pull/5',
+        );
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+      });
+
+      it('should emit only PULL_REQUEST_CONFLICTED and not PULL_REQUEST_IS_DRAFT or other types when evaluation is skipped', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1', {
+            isConflicted: true,
+            isDraft: true,
+            isPassedAllCiJob: false,
+            isCiStateSuccess: false,
+          }),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+        expect(result.rejections.map((r) => r.type)).not.toContain(
+          'PULL_REQUEST_IS_DRAFT',
+        );
+        expect(result.rejections.map((r) => r.type)).not.toContain(
+          'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
+        );
+      });
+    });
+
     describe('change-target-must: label behavior', () => {
       const prUrl = 'https://github.com/user/repo/pull/1';
 

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -37,6 +37,7 @@ export type EvaluateOptions = {
   // The agent name treated as the developer agent for PR/CI/conflict checks.
   // When null or undefined, defaults to 'developer'.
   developerAgentName?: string | null;
+  detectConflictEvenIfEvaluationSkipped?: boolean;
 };
 
 export class IssueRejectionEvaluator {
@@ -186,6 +187,26 @@ export class IssueRejectionEvaluator {
           approvedPrUrl = pr.url;
         }
       }
+    } else if (options.detectConflictEvenIfEvaluationSkipped) {
+      let prsToCheck: RelatedPullRequest[];
+      if (options.relatedOpenPrUrls != null) {
+        const resolved = await this.resolveOpenPrsFromUrls(
+          options.relatedOpenPrUrls,
+          options.resolvedOpenPrByUrl ?? null,
+        );
+        prsToCheck = resolved.prs;
+      } else {
+        prsToCheck = await this.issueRepository.findRelatedOpenPRs(issue.url);
+      }
+      for (const pr of prsToCheck) {
+        if (pr.isConflicted) {
+          rejections.push({
+            type: 'PULL_REQUEST_CONFLICTED',
+            detail: `PULL_REQUEST_CONFLICTED: ${pr.url}`,
+          });
+          break;
+        }
+      }
     }
 
     return { rejections, approvedPrUrl };

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

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

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

@@ -238,6 +238,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     author: 'HiromiShikata',
     closingIssueReferenceUrls: [],
     agent: null,
+    stateReason: null,
     ...overrides,
   });
 

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

@@ -35,6 +35,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: '',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 
@@ -67,6 +68,7 @@ const createMergedPr = (
   author: '',
   closingIssueReferenceUrls: [closingIssueUrl],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 
@@ -384,4 +386,36 @@ describe('QualityCheckAdvanceUseCase', () => {
       'done-id',
     );
   });
+
+  it('does not advance an issue with stateReason REOPENED even when it has a merged PR', async () => {
+    const issue = createMockIssue({ stateReason: 'REOPENED' });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('advances an issue whose stateReason is COMPLETED even though it was previously REOPENED', async () => {
+    const issue = createMockIssue({ stateReason: 'COMPLETED' });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue,
+      'done-id',
+    );
+  });
 });

package/src/domain/usecases/QualityCheckAdvanceUseCase.ts

@@ -45,6 +45,7 @@ export class QualityCheckAdvanceUseCase {
       (issue) =>
         issue.status === qualityCheckStatusName &&
         !issue.isClosed &&
+        issue.stateReason !== 'REOPENED' &&
         issue.dependedIssueUrls.length === 0 &&
         !issueReactivationTriggerIsPending(issue, evaluatedAt) &&
         issueUrlsWithMergedPr.has(issue.url),

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

@@ -0,0 +1,188 @@
+import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import {
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'user/repo',
+  number: 1,
+  title: 'Test Issue',
+  state: 'OPEN',
+  status: DONE_STATUS_NAME,
+  story: 'Default Story',
+  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(),
+  author: '',
+  closingIssueReferenceUrls: [],
+  agent: null,
+  stateReason: 'REOPENED',
+  ...overrides,
+});
+
+const createMockProject = (): 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: [
+      {
+        id: 'awaiting-workspace-id',
+        name: AWAITING_WORKSPACE_STATUS_NAME,
+        color: 'BLUE',
+        description: '',
+      },
+      {
+        id: 'preparation-id',
+        name: 'Preparation',
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'done-id',
+        name: DONE_STATUS_NAME,
+        color: 'PURPLE',
+        description: '',
+      },
+    ],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+  agent: null,
+});
+
+describe('ReopenedDoneIssueRevertUseCase', () => {
+  let useCase: ReopenedDoneIssueRevertUseCase;
+  let mockIssueRepository: Mocked<Pick<IssueRepository, 'updateStatus'>>;
+
+  beforeEach(() => {
+    mockIssueRepository = {
+      updateStatus: jest.fn(),
+    };
+    useCase = new ReopenedDoneIssueRevertUseCase(mockIssueRepository);
+  });
+
+  it('resets a Done issue with stateReason REOPENED to Awaiting Workspace', async () => {
+    const issue = createMockIssue();
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue,
+      'awaiting-workspace-id',
+    );
+  });
+
+  it('does not reset a Done issue with stateReason COMPLETED', async () => {
+    const issue = createMockIssue({ stateReason: 'COMPLETED' });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset a Done issue with stateReason null', async () => {
+    const issue = createMockIssue({ stateReason: null });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset a PR item even when Done and stateReason is REOPENED', async () => {
+    const prIssue = createMockIssue({
+      isPr: true,
+      url: 'https://github.com/user/repo/pull/10',
+    });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [prIssue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset an issue that is not in Done status', async () => {
+    const issue = createMockIssue({ status: 'Awaiting Workspace' });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('logs an error and returns 0 when Awaiting Workspace status option is missing', async () => {
+    const issue = createMockIssue();
+    const project = createMockProject();
+    project.status.statuses = project.status.statuses.filter(
+      (s) => s.name !== AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    const consoleSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    const result = await useCase.run({ project, issues: [issue] });
+
+    expect(result).toBe(0);
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+
+  it('collects updateStatus failures and re-throws as AggregateError after processing all items', async () => {
+    const issue1 = createMockIssue({
+      number: 1,
+      url: 'https://github.com/user/repo/issues/1',
+      itemId: 'item-1',
+    });
+    const issue2 = createMockIssue({
+      number: 2,
+      url: 'https://github.com/user/repo/issues/2',
+      itemId: 'item-2',
+    });
+    const project = createMockProject();
+    const updateError = new Error('updateStatus failed for issue1');
+    mockIssueRepository.updateStatus
+      .mockRejectedValueOnce(updateError)
+      .mockResolvedValueOnce(undefined);
+
+    await expect(
+      useCase.run({ project, issues: [issue1, issue2] }),
+    ).rejects.toBeInstanceOf(AggregateError);
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue2,
+      'awaiting-workspace-id',
+    );
+  });
+});

package/src/domain/usecases/ReopenedDoneIssueRevertUseCase.ts

@@ -0,0 +1,57 @@
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import {
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+export class ReopenedDoneIssueRevertUseCase {
+  constructor(
+    private readonly issueRepository: Pick<IssueRepository, 'updateStatus'>,
+  ) {}
+
+  run = async (params: {
+    project: Project;
+    issues: Issue[];
+  }): Promise<number> => {
+    const awaitingWorkspaceStatusOption = params.project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatusOption) {
+      console.error(
+        `Awaiting Workspace status option '${AWAITING_WORKSPACE_STATUS_NAME}' not found in project.`,
+      );
+      return 0;
+    }
+
+    const itemsToRevert = params.issues.filter(
+      (issue) =>
+        issue.status === DONE_STATUS_NAME &&
+        issue.stateReason === 'REOPENED' &&
+        !issue.isPr,
+    );
+
+    let revertedCount = 0;
+    const errors: unknown[] = [];
+    for (const issue of itemsToRevert) {
+      try {
+        await this.issueRepository.updateStatus(
+          params.project,
+          issue,
+          awaitingWorkspaceStatusOption.id,
+        );
+        revertedCount++;
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(
+        errors,
+        `Failed to revert ${errors.length} issue(s) from ${DONE_STATUS_NAME} to ${AWAITING_WORKSPACE_STATUS_NAME}`,
+      );
+    }
+    return revertedCount;
+  };
+}

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

@@ -78,6 +78,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: 'owner',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 
@@ -249,6 +250,49 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
+    it('should revert chore agent issue to Awaiting Workspace when its linked PR is conflicted', async () => {
+      const issue = createMockIssue({
+        status: 'Awaiting Quality Check',
+        agent: 'chore',
+      });
+      linkRelatedOpenPrsToIssue(mockIssueRepository, issue, [
+        { ...createReadyPr(), isConflicted: true },
+      ]);
+
+      await useCase.run({
+        manager: 'manager-user',
+        projectUrl: 'https://github.com/users/user/projects/1',
+        allowedIssueAuthors: ['owner'],
+      });
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        issue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        issue,
+        expect.stringContaining('PULL_REQUEST_CONFLICTED'),
+      );
+    });
+
+    it('should not revert chore agent issue when its linked PR is not conflicted', async () => {
+      const issue = createMockIssue({
+        status: 'Awaiting Quality Check',
+        agent: 'chore',
+      });
+      linkRelatedOpenPrsToIssue(mockIssueRepository, issue, [createReadyPr()]);
+
+      await useCase.run({
+        manager: 'manager-user',
+        projectUrl: 'https://github.com/users/user/projects/1',
+        allowedIssueAuthors: ['owner'],
+      });
+
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    });
+
     it('should revert Awaiting Quality Check issue with developer agent field and no linked PR', async () => {
       const issue = createMockIssue({
         status: 'Awaiting Quality Check',

package/src/domain/usecases/RevertNotReadyReviewQueueIssueUseCase.ts

@@ -98,22 +98,13 @@ export class RevertNotReadyReviewQueueIssueUseCase {
 
     const labelsNotRequiringPullRequest =
       resolveLabelsNotRequiringPullRequest(params);
-    const willBeEvaluated = (item: Issue): boolean =>
-      isAuthorAuthorizedForAutoStatusCheck(item.author, allowedIssueAuthors) &&
-      this.issueRejectionEvaluator.requiresPullRequestEvaluation(
-        item,
-        labelsNotRequiringPullRequest,
-        params.developerAgentName,
-      );
 
     const resolvedOpenPrByUrl = await this.issueRepository.getOpenPullRequests(
       Array.from(
         new Set([
-          ...awaitingQualityCheckIssues
-            .filter(willBeEvaluated)
-            .flatMap(
-              (issue) => relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [],
-            ),
+          ...awaitingQualityCheckIssues.flatMap(
+            (issue) => relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [],
+          ),
         ]),
       ),
     );
@@ -135,6 +126,7 @@ export class RevertNotReadyReviewQueueIssueUseCase {
                 relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? null,
               resolvedOpenPrByUrl,
               developerAgentName: params.developerAgentName,
+              detectConflictEvenIfEvaluationSkipped: true,
             },
           );
         if (

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

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

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

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

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

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