github-issue-tower-defence-management 1.71.1 → 1.73.0

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

@@ -213,6 +213,16 @@ function isDirectPullRequestResponse(
   return true;
 }
 
+type PullRequestFilesResponseItem = {
+  filename: string;
+};
+
+function isPullRequestFilesResponse(
+  value: unknown,
+): value is PullRequestFilesResponseItem[] {
+  return typia.is<PullRequestFilesResponseItem[]>(value);
+}
+
 const fnmatch = (pattern: string, str: string): boolean => {
   let regexStr = '^';
   let i = 0;
@@ -1095,6 +1105,65 @@ export class ApiV3CheerioRestIssueRepository
     }
   };
 
+  getPullRequestChangedFilePaths = async (prUrl: string): Promise<string[]> => {
+    const { owner, repo, issueNumber: prNumber } = this.parseIssueUrl(prUrl);
+    const perPage = 100;
+    const collectedPaths: string[] = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const response = await fetch(
+        `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/files?per_page=${perPage}&page=${page}`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      );
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch changed files for PR ${prUrl}: HTTP ${response.status}`,
+        );
+      }
+      const body: unknown = await response.json();
+      if (!isPullRequestFilesResponse(body)) {
+        throw new Error(
+          `Unexpected response shape when fetching changed files for PR ${prUrl}`,
+        );
+      }
+      for (const file of body) {
+        collectedPaths.push(file.filename);
+      }
+      if (body.length < perPage) {
+        hasMore = false;
+      } else {
+        page += 1;
+      }
+    }
+    return collectedPaths;
+  };
+
+  approvePullRequest = async (prUrl: string): Promise<void> => {
+    const { owner, repo, issueNumber: prNumber } = this.parseIssueUrl(prUrl);
+    const response = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/reviews`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.ghToken}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/vnd.github+json',
+        },
+        body: JSON.stringify({ event: 'APPROVE' }),
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to approve PR ${prUrl}: HTTP ${response.status}`);
+    }
+  };
+
   deletePullRequestBranch = async (
     prUrl: string,
     branchName: string,

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

@@ -0,0 +1,131 @@
+import { ChangeTargetPullRequestApprover } from './ChangeTargetPullRequestApprover';
+
+describe('ChangeTargetPullRequestApprover', () => {
+  let mockIssueRepository: {
+    getPullRequestChangedFilePaths: jest.Mock;
+    approvePullRequest: jest.Mock;
+  };
+  let approver: ChangeTargetPullRequestApprover;
+  const prUrl = 'https://github.com/user/repo/pull/1';
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    mockIssueRepository = {
+      getPullRequestChangedFilePaths: jest.fn().mockResolvedValue([]),
+      approvePullRequest: jest.fn().mockResolvedValue(undefined),
+    };
+    approver = new ChangeTargetPullRequestApprover(mockIssueRepository);
+  });
+
+  it('should do nothing when approvedPrUrl is null', async () => {
+    await approver.approveIfConfined(['change-target:src/domain'], null);
+
+    expect(
+      mockIssueRepository.getPullRequestChangedFilePaths,
+    ).not.toHaveBeenCalled();
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing when issue has no change-target label', async () => {
+    await approver.approveIfConfined(['category:e2e'], prUrl);
+
+    expect(
+      mockIssueRepository.getPullRequestChangedFilePaths,
+    ).not.toHaveBeenCalled();
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+
+  it('should approve when all files are confined to the labeled path', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'src/domain/entities/Foo.ts',
+      'src/domain/usecases/Bar.ts',
+    ]);
+
+    await approver.approveIfConfined(['change-target:src/domain'], prUrl);
+
+    expect(
+      mockIssueRepository.getPullRequestChangedFilePaths,
+    ).toHaveBeenCalledWith(prUrl);
+    expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(prUrl);
+  });
+
+  it('should not approve when any file is outside the labeled path', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'src/domain/entities/Foo.ts',
+      'src/adapter/Outside.ts',
+    ]);
+
+    await approver.approveIfConfined(['change-target:src/domain'], prUrl);
+
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+
+  it('should approve when files are confined under any of multiple labels', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'src/domain/Foo.ts',
+      'docs/intro.md',
+    ]);
+
+    await approver.approveIfConfined(
+      ['change-target:src/domain', 'change-target:docs'],
+      prUrl,
+    );
+
+    expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(prUrl);
+  });
+
+  it('should match boundary-safely (foo matches foo/bar.ts but not foobar/baz.ts)', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'foo/bar.ts',
+      'foobar/baz.ts',
+    ]);
+
+    await approver.approveIfConfined(['change-target:foo'], prUrl);
+
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+
+  it('should approve when changed file equals the labeled path exactly', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'README.md',
+    ]);
+
+    await approver.approveIfConfined(['change-target:README.md'], prUrl);
+
+    expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(prUrl);
+  });
+
+  it('should not approve when there are zero changed files', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([]);
+
+    await approver.approveIfConfined(['change-target:src/domain'], prUrl);
+
+    expect(
+      mockIssueRepository.getPullRequestChangedFilePaths,
+    ).toHaveBeenCalledWith(prUrl);
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+
+  it('should normalize trailing slashes in change-target label paths', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'src/domain/entities/Foo.ts',
+    ]);
+
+    await approver.approveIfConfined(['change-target:src/domain/'], prUrl);
+
+    expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(prUrl);
+  });
+
+  it('should ignore empty change-target label values', async () => {
+    mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+      'src/domain/Foo.ts',
+    ]);
+
+    await approver.approveIfConfined(['change-target:'], prUrl);
+
+    expect(
+      mockIssueRepository.getPullRequestChangedFilePaths,
+    ).not.toHaveBeenCalled();
+    expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+  });
+});

package/src/domain/usecases/ChangeTargetPullRequestApprover.ts

@@ -0,0 +1,58 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+
+export class ChangeTargetPullRequestApprover {
+  constructor(
+    private readonly issueRepository: Pick<
+      IssueRepository,
+      'getPullRequestChangedFilePaths' | 'approvePullRequest'
+    >,
+  ) {}
+
+  approveIfConfined = async (
+    issueLabels: string[],
+    approvedPrUrl: string | null,
+  ): Promise<void> => {
+    if (approvedPrUrl === null) {
+      return;
+    }
+    const changeTargetPaths = this.extractChangeTargetPaths(issueLabels);
+    if (changeTargetPaths.length === 0) {
+      return;
+    }
+    const changedFilePaths =
+      await this.issueRepository.getPullRequestChangedFilePaths(approvedPrUrl);
+    if (changedFilePaths.length === 0) {
+      return;
+    }
+    const allConfined = changedFilePaths.every((filePath) =>
+      this.isFilePathConfinedToAllowedPaths(filePath, changeTargetPaths),
+    );
+    if (!allConfined) {
+      return;
+    }
+    await this.issueRepository.approvePullRequest(approvedPrUrl);
+  };
+
+  private extractChangeTargetPaths = (labels: string[]): string[] => {
+    const prefix = 'change-target:';
+    const paths: string[] = [];
+    for (const label of labels) {
+      if (!label.startsWith(prefix)) continue;
+      const raw = label.slice(prefix.length).trim();
+      if (raw.length === 0) continue;
+      const normalized = raw.replace(/\/+$/, '');
+      if (normalized.length === 0) continue;
+      paths.push(normalized);
+    }
+    return paths;
+  };
+
+  private isFilePathConfinedToAllowedPaths = (
+    filePath: string,
+    allowedPaths: string[],
+  ): boolean =>
+    allowedPaths.some(
+      (allowedPath) =>
+        filePath === allowedPath || filePath.startsWith(`${allowedPath}/`),
+    );
+}

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

@@ -94,6 +94,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     findRelatedOpenPRs: jest.Mock;
     getStoryObjectMap: jest.Mock;
     getOpenPullRequest: jest.Mock;
+    getPullRequestChangedFilePaths: jest.Mock;
+    approvePullRequest: jest.Mock;
     setDependedIssueUrl: jest.Mock;
   };
   let mockIssueCommentRepository: {
@@ -126,6 +128,8 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       updateStatus: jest.fn(),
       findRelatedOpenPRs: jest.fn(),
       getOpenPullRequest: jest.fn(),
+      getPullRequestChangedFilePaths: jest.fn().mockResolvedValue([]),
+      approvePullRequest: jest.fn().mockResolvedValue(undefined),
       setDependedIssueUrl: jest.fn(),
     };
 
@@ -2763,4 +2767,249 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       );
     });
   });
+
+  describe('change-target label auto-approve', () => {
+    const setupApprovedPrScenario = (issueOverrides: Partial<Issue> = {}) => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        ...issueOverrides,
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Agent report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+    };
+
+    it('should not approve PR when issue has no change-target label', async () => {
+      setupApprovedPrScenario();
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockIssueRepository.getPullRequestChangedFilePaths,
+      ).not.toHaveBeenCalled();
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Quality Check' }),
+        mockProject,
+      );
+    });
+
+    it('should approve PR when issue has change-target label and all files are confined', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:src/domain'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'src/domain/entities/Foo.ts',
+        'src/domain/usecases/Bar.ts',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockIssueRepository.getPullRequestChangedFilePaths,
+      ).toHaveBeenCalledWith('https://github.com/user/repo/pull/1');
+      expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(
+        'https://github.com/user/repo/pull/1',
+      );
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Quality Check' }),
+        mockProject,
+      );
+    });
+
+    it('should not approve PR when any changed file is outside the labeled path', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:src/domain'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'src/domain/entities/Foo.ts',
+        'src/adapter/repositories/Outside.ts',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockIssueRepository.getPullRequestChangedFilePaths,
+      ).toHaveBeenCalledWith('https://github.com/user/repo/pull/1');
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Quality Check' }),
+        mockProject,
+      );
+    });
+
+    it('should approve when files are confined under any of multiple change-target labels', async () => {
+      setupApprovedPrScenario({
+        labels: ['change-target:src/domain', 'change-target:docs'],
+      });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'src/domain/entities/Foo.ts',
+        'docs/intro.md',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(
+        'https://github.com/user/repo/pull/1',
+      );
+    });
+
+    it('should not approve when PR has more than 100 changed files and one file beyond entry 100 is outside the labeled path', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:src/domain'] });
+      const filePaths: string[] = [];
+      for (let i = 0; i < 150; i += 1) {
+        filePaths.push(`src/domain/file${i}.ts`);
+      }
+      filePaths.push('src/adapter/Outside.ts');
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue(
+        filePaths,
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+    });
+
+    it('should match boundary-safely (change-target:foo matches foo/bar.ts but not foobar/baz.ts)', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:foo'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'foo/bar.ts',
+        'foobar/baz.ts',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+    });
+
+    it('should approve when changed files match exact path or subpath of the labeled path', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:foo'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'foo/bar.ts',
+        'foo/nested/baz.ts',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(
+        'https://github.com/user/repo/pull/1',
+      );
+    });
+
+    it('should not approve when PR has zero changed files', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:src/domain'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockIssueRepository.getPullRequestChangedFilePaths,
+      ).toHaveBeenCalledWith('https://github.com/user/repo/pull/1');
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+    });
+
+    it('should not approve when there is no approved PR even if change-target label is present', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        labels: ['change-target:src/domain'],
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Agent report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockIssueRepository.getPullRequestChangedFilePaths,
+      ).not.toHaveBeenCalled();
+      expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
+    });
+
+    it('should normalize trailing slashes in change-target label paths', async () => {
+      setupApprovedPrScenario({ labels: ['change-target:src/domain/'] });
+      mockIssueRepository.getPullRequestChangedFilePaths.mockResolvedValue([
+        'src/domain/entities/Foo.ts',
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.approvePullRequest).toHaveBeenCalledWith(
+        'https://github.com/user/repo/pull/1',
+      );
+    });
+  });
 });

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -12,6 +12,7 @@ import {
   IssueRejectionEvaluator,
   PrRejectedReasonType,
 } from './IssueRejectionEvaluator';
+import { ChangeTargetPullRequestApprover } from './ChangeTargetPullRequestApprover';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -38,6 +39,7 @@ type RejectedReasonType =
 
 export class NotifyFinishedIssuePreparationUseCase {
   private readonly issueRejectionEvaluator: IssueRejectionEvaluator;
+  private readonly changeTargetPullRequestApprover: ChangeTargetPullRequestApprover;
 
   constructor(
     private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
@@ -49,6 +51,8 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'findRelatedOpenPRs'
       | 'getStoryObjectMap'
       | 'getOpenPullRequest'
+      | 'getPullRequestChangedFilePaths'
+      | 'approvePullRequest'
       | 'setDependedIssueUrl'
     >,
     private readonly issueCommentRepository: Pick<
@@ -61,6 +65,9 @@ export class NotifyFinishedIssuePreparationUseCase {
     >,
   ) {
     this.issueRejectionEvaluator = new IssueRejectionEvaluator(issueRepository);
+    this.changeTargetPullRequestApprover = new ChangeTargetPullRequestApprover(
+      issueRepository,
+    );
   }
 
   run = async (params: {
@@ -171,7 +178,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     const isTrustedAuthor = (author: string): boolean =>
       this.isAuthorTrusted(author, params.allowedIssueAuthors ?? null);
 
-    const { rejections } = await this.collectRejections(
+    const { rejections, approvedPrUrl } = await this.collectRejections(
       issue,
       comments,
       isTrustedAuthor,
@@ -225,6 +232,10 @@ export class NotifyFinishedIssuePreparationUseCase {
     }
 
     if (rejections.length <= 0) {
+      await this.changeTargetPullRequestApprover.approveIfConfined(
+        issue.labels,
+        approvedPrUrl,
+      );
       issue.status = AWAITING_QUALITY_CHECK_STATUS_NAME;
       await this.issueRepository.update(issue, project);
       await this.issueRepository.updateStatus(