github-issue-tower-defence-management 1.172.2 → 1.173.1

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/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -40,6 +40,7 @@ import {
   fetchWithGitHubRateLimitRetry,
   computeRateLimitResetIso,
   hasRateLimitSignals,
+  GitHubRateLimitError,
 } from './githubRateLimitRetry';
 
 export const FULL_ISSUE_FETCH_INTERVAL_MS = 60 * 60 * 1000;
@@ -593,6 +594,24 @@ export class ApiV3CheerioRestIssueRepository
     request: () => Promise<Response>,
   ): Promise<Response> => fetchWithGitHubRateLimitRetry(request, this.sleep);
 
+  private throwGitHubError = async (
+    prefix: string,
+    response: Response,
+  ): Promise<never> => {
+    const bodyText = await response.clone().text();
+    const isRateLimit = hasRateLimitSignals(
+      response.status,
+      response.headers,
+      bodyText,
+    );
+    const formatted = await this.formatGitHubErrorWithStatus(response);
+    const message = `${prefix}: ${formatted}`;
+    if (isRateLimit) {
+      throw new GitHubRateLimitError(message);
+    }
+    throw new Error(message);
+  };
+
   updateStatus: (
     project: Project,
     issue: Issue,
@@ -1786,8 +1805,9 @@ export class ApiV3CheerioRestIssueRepository
       );
 
       if (!response.ok) {
-        throw new Error(
-          `Failed to fetch issue timeline from GitHub GraphQL API: HTTP ${response.status}`,
+        await this.throwGitHubError(
+          'Failed to fetch issue timeline from GitHub GraphQL API',
+          response,
         );
       }
 
@@ -1992,9 +2012,9 @@ export class ApiV3CheerioRestIssueRepository
         return null;
       }
       if (!response.ok) {
-        const reason = await this.formatGitHubErrorWithStatus(response);
-        throw new Error(
-          `Failed to fetch pull request status for ${prUrl}: ${reason}`,
+        await this.throwGitHubError(
+          `Failed to fetch pull request status for ${prUrl}`,
+          response,
         );
       }
       const body: unknown = await response.json();
@@ -2747,8 +2767,7 @@ export class ApiV3CheerioRestIssueRepository
   getIssueOrPullRequestBody = async (url: string): Promise<string> => {
     const response = await this.fetchIssueBodyResponse(url);
     if (!response.ok) {
-      const reason = await this.formatGitHubErrorWithStatus(response);
-      throw new Error(`Failed to fetch body for ${url}: ${reason}`);
+      await this.throwGitHubError(`Failed to fetch body for ${url}`, response);
     }
     return this.parseIssueBodyResponse(url, response);
   };
@@ -2787,8 +2806,10 @@ export class ApiV3CheerioRestIssueRepository
         ),
       );
       if (!response.ok) {
-        const reason = await this.formatGitHubErrorWithStatus(response);
-        throw new Error(`Failed to fetch comments for ${url}: ${reason}`);
+        await this.throwGitHubError(
+          `Failed to fetch comments for ${url}`,
+          response,
+        );
       }
       const body: unknown = await response.json();
       if (!isIssueCommentsResponse(body)) {
@@ -2837,8 +2858,10 @@ export class ApiV3CheerioRestIssueRepository
       ),
     );
     if (!detailResponse.ok) {
-      const reason = await this.formatGitHubErrorWithStatus(detailResponse);
-      throw new Error(`Failed to fetch detail for PR ${prUrl}: ${reason}`);
+      await this.throwGitHubError(
+        `Failed to fetch detail for PR ${prUrl}`,
+        detailResponse,
+      );
     }
     const detailBody: unknown = await detailResponse.json();
     if (!isPullRequestDetailResponse(detailBody)) {
@@ -2891,8 +2914,10 @@ export class ApiV3CheerioRestIssueRepository
         ),
       );
       if (!response.ok) {
-        const reason = await this.formatGitHubErrorWithStatus(response);
-        throw new Error(`Failed to fetch files for PR ${prUrl}: ${reason}`);
+        await this.throwGitHubError(
+          `Failed to fetch files for PR ${prUrl}`,
+          response,
+        );
       }
       const body: unknown = await response.json();
       if (!isPullRequestDetailFilesResponse(body)) {
@@ -2952,8 +2977,10 @@ export class ApiV3CheerioRestIssueRepository
         ),
       );
       if (!response.ok) {
-        const reason = await this.formatGitHubErrorWithStatus(response);
-        throw new Error(`Failed to fetch commits for PR ${prUrl}: ${reason}`);
+        await this.throwGitHubError(
+          `Failed to fetch commits for PR ${prUrl}`,
+          response,
+        );
       }
       const body: unknown = await response.json();
       if (!isPullRequestCommitsResponse(body)) {
@@ -3001,8 +3028,10 @@ export class ApiV3CheerioRestIssueRepository
         ),
       );
       if (!response.ok) {
-        const reason = await this.formatGitHubErrorWithStatus(response);
-        throw new Error(`Failed to fetch state for ${url}: ${reason}`);
+        await this.throwGitHubError(
+          `Failed to fetch state for ${url}`,
+          response,
+        );
       }
       const body: unknown = await response.json();
       if (!isPullRequestDetailResponse(body)) {
@@ -3030,8 +3059,7 @@ export class ApiV3CheerioRestIssueRepository
       ),
     );
     if (!response.ok) {
-      const reason = await this.formatGitHubErrorWithStatus(response);
-      throw new Error(`Failed to fetch state for ${url}: ${reason}`);
+      await this.throwGitHubError(`Failed to fetch state for ${url}`, response);
     }
     const body: unknown = await response.json();
     if (!isIssueOrPullRequestStateResponse(body)) {

package/src/adapter/repositories/issue/githubRateLimitRetry.ts

@@ -1,3 +1,7 @@
+export class GitHubRateLimitError extends Error {
+  readonly name = 'GitHubRateLimitError';
+}
+
 export const RATE_LIMIT_MAX_RETRIES = 3;
 export const RATE_LIMIT_TOTAL_BACKOFF_CAP_MS = 5000;
 export const RATE_LIMIT_BASE_BACKOFF_MS = 250;

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,