github-issue-tower-defence-management 1.172.1 → 1.173.0

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -74,6 +74,7 @@ import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueComm
 import { ProjectRequiredFieldCreateUseCase } from '../../../domain/usecases/ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from '../../../domain/usecases/SetupTowerDefenceProjectUseCase';
 import { DailySecurityScanUseCase } from '../../../domain/usecases/DailySecurityScanUseCase';
+import { QualityCheckAdvanceUseCase } from '../../../domain/usecases/QualityCheckAdvanceUseCase';
 import { KyHttpRepository } from '../../repositories/KyHttpRepository';
 import { FileSystemKevReportWatermarkRepository } from '../../repositories/FileSystemKevReportWatermarkRepository';
 import {
@@ -507,6 +508,10 @@ export class HandleScheduledEventUseCaseHandler {
         )
       : null;
 
+    const qualityCheckAdvanceUseCase = new QualityCheckAdvanceUseCase(
+      issueRepository,
+    );
+
     const handleScheduledEventUseCase = new HandleScheduledEventUseCase(
       projectRequiredFieldCreateUseCase,
       setupTowerDefenceProjectUseCase,
@@ -531,6 +536,7 @@ export class HandleScheduledEventUseCaseHandler {
       agentDesignationLabelAdoptUseCase,
       updateRateLimitCacheUseCase,
       dailySecurityScanUseCase,
+      qualityCheckAdvanceUseCase,
       systemDateRepository,
       googleSpreadsheetRepository,
       projectRepository,

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

@@ -29,6 +29,7 @@ import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateU
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 import { DailySecurityScanUseCase } from './DailySecurityScanUseCase';
+import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -128,6 +129,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<AgentDesignationLabelAdoptUseCase>();
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
     const mockDailySecurityScanUseCase = mock<DailySecurityScanUseCase>();
+    const mockAdvanceQualityCheckUseCase = mock<QualityCheckAdvanceUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -157,6 +159,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockAgentDesignationLabelAdoptUseCase,
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
+      mockAdvanceQualityCheckUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,
@@ -1473,5 +1476,118 @@ describe('HandleScheduledEventUseCase', () => {
         expect(lastExecutionWrite).toBeUndefined();
       });
     });
+
+    describe('autoAdvanceQualityCheckEnabled', () => {
+      const baseInput = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+      };
+
+      it('does not call advanceQualityCheckUseCase when autoAdvanceQualityCheckEnabled is absent', async () => {
+        await useCase.run(baseInput);
+
+        expect(mockAdvanceQualityCheckUseCase.run).not.toHaveBeenCalled();
+      });
+
+      it('does not call advanceQualityCheckUseCase when autoAdvanceQualityCheckEnabled is false', async () => {
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: false,
+          },
+        });
+
+        expect(mockAdvanceQualityCheckUseCase.run).not.toHaveBeenCalled();
+      });
+
+      it('calls advanceQualityCheckUseCase when autoAdvanceQualityCheckEnabled is true', async () => {
+        const mockProject = mock<Project>();
+        const mockIssues: Issue[] = [];
+        const fixedNow = new Date('2024-06-15T12:00:00Z');
+        mockDateRepository.now.mockResolvedValue(fixedNow);
+        mockIssueRepository.getAllIssues.mockResolvedValue({
+          issues: mockIssues,
+          project: mockProject,
+          cacheUsed: false,
+        });
+
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: true,
+          },
+        });
+
+        expect(mockAdvanceQualityCheckUseCase.run).toHaveBeenCalledWith(
+          expect.objectContaining({
+            project: mockProject,
+            issues: mockIssues,
+            evaluatedAt: fixedNow,
+          }),
+        );
+      });
+
+      it('passes awaitingQualityCheckStatus to advanceQualityCheckUseCase when configured', async () => {
+        const mockProject = mock<Project>();
+        mockIssueRepository.getAllIssues.mockResolvedValue({
+          issues: [],
+          project: mockProject,
+          cacheUsed: false,
+        });
+
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: true,
+            awaitingQualityCheckStatus: 'Custom Review Status',
+          },
+        });
+
+        expect(mockAdvanceQualityCheckUseCase.run).toHaveBeenCalledWith(
+          expect.objectContaining({
+            awaitingQualityCheckStatusName: 'Custom Review Status',
+          }),
+        );
+      });
+
+      it('continues to startPreparationUseCase when qualityCheckAdvanceUseCase.run rejects', async () => {
+        mockAdvanceQualityCheckUseCase.run.mockRejectedValue(
+          new AggregateError(
+            [new Error('GitHub API rate limit')],
+            'Failed to advance 1 issue(s) from Awaiting Quality Check to Done',
+          ),
+        );
+
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: true,
+          },
+        });
+
+        expect(mockStartPreparationUseCase.run).toHaveBeenCalled();
+      });
+    });
   });
 });

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -37,6 +37,7 @@ import {
   DailySecurityScanConfig,
   DailySecurityScanUseCase,
 } from './DailySecurityScanUseCase';
+import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -139,6 +140,7 @@ export class HandleScheduledEventUseCase {
     readonly agentDesignationLabelAdoptUseCase: AgentDesignationLabelAdoptUseCase,
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
+    readonly qualityCheckAdvanceUseCase: QualityCheckAdvanceUseCase,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -177,6 +179,7 @@ export class HandleScheduledEventUseCase {
       awLogDirectoryPath?: string;
       awLogStaleThresholdMinutes?: number;
       awaitingQualityCheckStatus?: string | null;
+      autoAdvanceQualityCheckEnabled?: boolean;
       labelsAsLlmAgentName?: string[] | null;
     } | null;
     thresholdForAutoReject?: number;
@@ -333,6 +336,7 @@ export class HandleScheduledEventUseCase {
         targetDateTimes,
         storyIssues,
         runSlowSweep,
+        now,
       );
       rotationOrder = useCaseResult.rotationOrder;
     } catch (e) {
@@ -392,6 +396,7 @@ ${JSON.stringify(e)}
     targetDateTimes: Date[],
     storyObjectMap: StoryObjectMap,
     runSlowSweep: boolean,
+    now: Date,
   ): Promise<{ rotationOrder: RotationOrderEntry[] | null }> => {
     if (runSlowSweep) {
       await this.runSlowSweepUseCases(
@@ -462,6 +467,22 @@ ${JSON.stringify(e)}
           allowedIssueAuthors,
         });
       }
+      if (input.startPreparation.autoAdvanceQualityCheckEnabled) {
+        try {
+          await this.qualityCheckAdvanceUseCase.run({
+            project,
+            issues,
+            awaitingQualityCheckStatusName:
+              input.startPreparation.awaitingQualityCheckStatus ?? undefined,
+            evaluatedAt: now,
+          });
+        } catch (advanceError) {
+          console.error(
+            `[HandleScheduledEvent] Failed to advance quality check items for project ${project.url}: ${advanceError instanceof Error ? advanceError.message : String(advanceError)}`,
+            advanceError,
+          );
+        }
+      }
       const preparationResult = await this.startPreparationUseCase.run({
         projectUrl: input.projectUrl,
         defaultAgentName: input.startPreparation.defaultAgentName,

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -27,6 +27,7 @@ import {
 import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
+import { extractNextStepAgent } from './extractNextStepAgent';
 import { issueReactivationTriggerIsPending } from './issueReactivationTriggerIsPending';
 
 export class IssueNotFoundError extends Error {
@@ -228,7 +229,7 @@ export class NotifyFinishedIssuePreparationUseCase {
           isTrustedAuthor(c.author) && c.content.startsWith('From: :robot:'),
       );
     const nextStepAgent = lastTrustedBotComment
-      ? this.extractNextStepAgent(lastTrustedBotComment.content)
+      ? extractNextStepAgent(lastTrustedBotComment.content)
       : null;
     if (nextStepAgent !== null) {
       const agentOptionId = await this.ensureAgentOptionAndGetId(
@@ -612,34 +613,6 @@ export class NotifyFinishedIssuePreparationUseCase {
     return null;
   };
 
-  private extractNextStepAgent = (body: string): string | null => {
-    const reportMatch = body.match(/```json\n([\s\S]*?)\n```/);
-    if (!reportMatch || reportMatch.length < 2) {
-      return null;
-    }
-    let reportJson: unknown;
-    try {
-      reportJson = JSON.parse(reportMatch[1]);
-    } catch (error) {
-      console.warn(
-        'Invalid JSON in report body while checking nextStepAgent:',
-        error,
-      );
-      return null;
-    }
-    if (typeof reportJson !== 'object' || reportJson === null) {
-      return null;
-    }
-    if (!('nextStepAgent' in reportJson)) {
-      return null;
-    }
-    const value = Reflect.get(reportJson, 'nextStepAgent');
-    if (typeof value !== 'string' || value.trim() === '') {
-      return null;
-    }
-    return value.trim();
-  };
-
   private ensureAgentOptionAndGetId = async (
     project: Project,
     agentName: string,

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

@@ -0,0 +1,387 @@
+import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import {
+  AWAITING_QUALITY_CHECK_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: AWAITING_QUALITY_CHECK_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,
+  ...overrides,
+});
+
+const createMergedPr = (
+  closingIssueUrl: string,
+  overrides: Partial<Issue> = {},
+): Issue => ({
+  nameWithOwner: 'user/repo',
+  number: 100,
+  title: 'Merged PR',
+  state: 'MERGED',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/user/repo/pull/100',
+  assignees: [],
+  labels: [],
+  org: 'user',
+  repo: 'repo',
+  body: '',
+  itemId: 'pr-item-1',
+  isPr: true,
+  isInProgress: false,
+  isClosed: true,
+  createdAt: new Date(),
+  author: '',
+  closingIssueReferenceUrls: [closingIssueUrl],
+  agent: null,
+  ...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',
+        color: 'GRAY',
+        description: '',
+      },
+      {
+        id: 'preparation-id',
+        name: 'Preparation',
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'awaiting-quality-check-id',
+        name: AWAITING_QUALITY_CHECK_STATUS_NAME,
+        color: 'GREEN',
+        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,
+});
+
+const FIXED_NOW = new Date('2026-01-15T10:00:00Z');
+
+describe('QualityCheckAdvanceUseCase', () => {
+  let useCase: QualityCheckAdvanceUseCase;
+  let mockIssueRepository: Mocked<Pick<IssueRepository, 'updateStatus'>>;
+
+  beforeEach(() => {
+    mockIssueRepository = {
+      updateStatus: jest.fn(),
+    };
+    useCase = new QualityCheckAdvanceUseCase(mockIssueRepository);
+  });
+
+  it('moves an issue in Awaiting Quality Check status to Done when its linked PR is merged', async () => {
+    const issue = createMockIssue();
+    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',
+    );
+  });
+
+  it('moves multiple issues in Awaiting Quality Check status to Done when each has a merged linked PR', async () => {
+    const issue1 = createMockIssue({
+      number: 1,
+      url: 'https://github.com/user/repo/issues/1',
+    });
+    const issue2 = createMockIssue({
+      number: 2,
+      url: 'https://github.com/user/repo/issues/2',
+    });
+    const mergedPr1 = createMergedPr(issue1.url, {
+      number: 101,
+      url: 'https://github.com/user/repo/pull/101',
+      itemId: 'pr-item-101',
+    });
+    const mergedPr2 = createMergedPr(issue2.url, {
+      number: 102,
+      url: 'https://github.com/user/repo/pull/102',
+      itemId: 'pr-item-102',
+    });
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue1, issue2, mergedPr1, mergedPr2],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue1,
+      'done-id',
+    );
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue2,
+      'done-id',
+    );
+  });
+
+  it('does not move issues that are not in Awaiting Quality Check status', async () => {
+    const awaitingWorkspaceIssue = createMockIssue({
+      status: 'Awaiting Workspace',
+    });
+    const mergedPr = createMergedPr(awaitingWorkspaceIssue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [awaitingWorkspaceIssue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not move closed issues', async () => {
+    const closedIssue = createMockIssue({ isClosed: true });
+    const mergedPr = createMergedPr(closedIssue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [closedIssue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('respects a custom awaiting quality check status name', async () => {
+    const customStatusName = 'Custom Review Status';
+    const issue = createMockIssue({ status: customStatusName });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+    project.status.statuses.push({
+      id: 'custom-review-id',
+      name: customStatusName,
+      color: 'BLUE',
+      description: '',
+    });
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      awaitingQualityCheckStatusName: customStatusName,
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue,
+      'done-id',
+    );
+  });
+
+  it('does not call updateStatus when Done status is not found in project', async () => {
+    const issue = createMockIssue();
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+    project.status.statuses = project.status.statuses.filter(
+      (s) => s.name !== DONE_STATUS_NAME,
+    );
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('returns the count of advanced issues', async () => {
+    const issue1 = createMockIssue({ number: 1 });
+    const issue2 = createMockIssue({
+      number: 2,
+      url: 'https://github.com/user/repo/issues/2',
+    });
+    const notAdvancedIssue = createMockIssue({
+      number: 3,
+      url: 'https://github.com/user/repo/issues/3',
+      status: 'Awaiting Workspace',
+    });
+    const mergedPr1 = createMergedPr(issue1.url, {
+      number: 101,
+      url: 'https://github.com/user/repo/pull/101',
+      itemId: 'pr-item-101',
+    });
+    const mergedPr2 = createMergedPr(issue2.url, {
+      number: 102,
+      url: 'https://github.com/user/repo/pull/102',
+      itemId: 'pr-item-102',
+    });
+    const project = createMockProject();
+
+    const count = await useCase.run({
+      project,
+      issues: [issue1, issue2, notAdvancedIssue, mergedPr1, mergedPr2],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(count).toBe(2);
+  });
+
+  it('does not advance an issue when no merged PR is linked to it', async () => {
+    const issue = createMockIssue();
+    const openPr = createMockIssue({
+      number: 100,
+      url: 'https://github.com/user/repo/pull/100',
+      itemId: 'pr-item-1',
+      isPr: true,
+      state: 'OPEN',
+      status: null,
+      isClosed: false,
+      closingIssueReferenceUrls: [issue.url],
+    });
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, openPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not advance an issue with a pending nextActionDate reactivation trigger', async () => {
+    const futureDate = new Date('2099-12-31T00:00:00Z');
+    const issue = createMockIssue({ nextActionDate: futureDate });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not advance an issue with dependedIssueUrls set', async () => {
+    const issue = createMockIssue({
+      dependedIssueUrls: ['https://github.com/user/repo/issues/999'],
+    });
+    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 the remaining items when one updateStatus call fails', async () => {
+    const issue1 = createMockIssue({
+      number: 1,
+      url: 'https://github.com/user/repo/issues/1',
+    });
+    const issue2 = createMockIssue({
+      number: 2,
+      url: 'https://github.com/user/repo/issues/2',
+    });
+    const mergedPr1 = createMergedPr(issue1.url, {
+      number: 101,
+      url: 'https://github.com/user/repo/pull/101',
+      itemId: 'pr-item-101',
+    });
+    const mergedPr2 = createMergedPr(issue2.url, {
+      number: 102,
+      url: 'https://github.com/user/repo/pull/102',
+      itemId: 'pr-item-102',
+    });
+    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, mergedPr1, mergedPr2],
+        evaluatedAt: FIXED_NOW,
+      }),
+    ).rejects.toBeInstanceOf(AggregateError);
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue2,
+      'done-id',
+    );
+  });
+});