github-issue-tower-defence-management 1.163.0 → 1.165.0

package/src/adapter/repositories/GraphqlProjectRepository.test.ts

@@ -72,6 +72,7 @@ describeWhenCredentials('GraphqlProjectRepository', () => {
           name: 'Workflow Management',
         },
       },
+      agent: null,
     };
 
     it('should add a new option while preserving all existing options', async () => {
@@ -151,6 +152,7 @@ describeWhenCredentials('GraphqlProjectRepository', () => {
         },
         completionDate50PercentConfidence: null,
         dependedIssueUrlSeparatedByComma: null,
+        agent: null,
 
         status: {
           fieldId: 'PVTSSF_lAHOAGJHa84AFhgFzgDLt0c',

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -601,6 +601,56 @@ export class GraphqlProjectRepository
     );
     return options;
   };
+  updateAgentList = async (
+    project: Project,
+    newAgentList: (Omit<FieldOption, 'id'> & {
+      id: FieldOption['id'] | null;
+    })[],
+  ): Promise<FieldOption[]> => {
+    if (!project.agent) {
+      throw new Error('Project has no agent field');
+    }
+    const mutation = `mutation UpdateAgentOptions($fieldId: ID!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
+  updateProjectV2Field(input: {
+    fieldId: $fieldId
+    singleSelectOptions: $options
+  }) {
+    projectV2Field {
+      ... on ProjectV2SingleSelectField {
+        options {
+          id
+          name
+          color
+          description
+        }
+      }
+    }
+  }
+}`;
+    const variables = {
+      fieldId: project.agent.fieldId,
+      options: newAgentList.map(({ id, name, color, description }) => ({
+        ...(id !== null ? { id } : {}),
+        name,
+        color,
+        description,
+      })),
+    };
+    const response = await postGithubGraphqlJson<{
+      data: {
+        updateProjectV2Field: {
+          projectV2Field: {
+            options: FieldOption[];
+          };
+        };
+      };
+    }>({
+      ghToken: this.ghToken,
+      query: mutation,
+      variables,
+    });
+    return response.data.updateProjectV2Field.projectV2Field.options;
+  };
   updateStatusList = async (
     project: Project,
     newStatusList: (Omit<FieldOption, 'id'> & {

package/src/adapter/repositories/GraphqlProjectRepositoryProjectLocation.test.ts

@@ -186,6 +186,7 @@ describe('GraphqlProjectRepository project location', () => {
       remainingEstimationMinutes: null,
       dependedIssueUrlSeparatedByComma: null,
       completionDate50PercentConfidence: null,
+      agent: null,
     });
 
     expect(mockPostGithubGraphqlJson).not.toHaveBeenCalled();

package/src/adapter/repositories/ProjectIssuesCacheRepository.test.ts

@@ -55,6 +55,7 @@ const cachedProject: Project = {
   remainingEstimationMinutes: null,
   dependedIssueUrlSeparatedByComma: null,
   completionDate50PercentConfidence: null,
+  agent: null,
 };
 
 const savedStoryOptions: FieldOption[] = [

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

@@ -28,6 +28,7 @@ const buildTestProject = (id: string): Project => ({
   remainingEstimationMinutes: null,
   dependedIssueUrlSeparatedByComma: null,
   completionDate50PercentConfidence: null,
+  agent: null,
 });
 
 const buildCachedIssueRecord = (url: string, title: string) => ({
@@ -151,6 +152,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           closingIssueReferenceUrls: [
             'https://github.com/HiromiShikata/test-repository/issues/7',
           ],
+          agent: null,
         },
       },
       {
@@ -207,6 +209,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           createdAt: new Date('2024-01-01T00:00:00Z'),
           author: '',
           closingIssueReferenceUrls: [],
+          agent: null,
         },
       },
     ];
@@ -716,6 +719,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         remainingEstimationMinutes: null,
         dependedIssueUrlSeparatedByComma: null,
         completionDate50PercentConfidence: null,
+        agent: null,
       };
       const issue = {
         nameWithOwner: 'HiromiShikata/test-repository',
@@ -742,6 +746,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         createdAt: new Date('2024-01-01'),
         author: '',
         closingIssueReferenceUrls: [],
+        agent: null,
       };
       const statusId = 'new-status-id';
 
@@ -1171,6 +1176,157 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('mergePullRequest', () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should PUT to the GitHub merge API with no merge_method when the repository allows merge commits', async () => {
+      const fetchSpy = jest
+        .spyOn(global, 'fetch')
+        .mockResolvedValueOnce(new Response(null, { status: 204 }));
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await repository.mergePullRequest(
+        'https://github.com/HiromiShikata/test-repository/pull/42',
+      );
+
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+      expect(fetchSpy).toHaveBeenCalledWith(
+        'https://api.github.com/repos/HiromiShikata/test-repository/pulls/42/merge',
+        expect.objectContaining({
+          method: 'PUT',
+          body: JSON.stringify({}),
+        }),
+      );
+    });
+
+    it('should fall back to squash merge when the repository disallows merge commits (HTTP 405)', async () => {
+      const fetchSpy = jest
+        .spyOn(global, 'fetch')
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              message: 'Merge commits are not allowed on this repository.',
+            }),
+            { status: 405, headers: { 'Content-Type': 'application/json' } },
+          ),
+        )
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              allow_squash_merge: true,
+              allow_rebase_merge: true,
+            }),
+            { status: 200, headers: { 'Content-Type': 'application/json' } },
+          ),
+        )
+        .mockResolvedValueOnce(new Response(null, { status: 204 }));
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await repository.mergePullRequest(
+        'https://github.com/HiromiShikata/test-repository/pull/42',
+      );
+
+      expect(fetchSpy).toHaveBeenCalledTimes(3);
+      expect(fetchSpy).toHaveBeenNthCalledWith(
+        3,
+        'https://api.github.com/repos/HiromiShikata/test-repository/pulls/42/merge',
+        expect.objectContaining({
+          method: 'PUT',
+          body: JSON.stringify({ merge_method: 'squash' }),
+        }),
+      );
+    });
+
+    it('should fall back to rebase merge when squash merge is also disallowed', async () => {
+      const fetchSpy = jest
+        .spyOn(global, 'fetch')
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              message: 'Merge commits are not allowed on this repository.',
+            }),
+            { status: 405, headers: { 'Content-Type': 'application/json' } },
+          ),
+        )
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              allow_squash_merge: false,
+              allow_rebase_merge: true,
+            }),
+            { status: 200, headers: { 'Content-Type': 'application/json' } },
+          ),
+        )
+        .mockResolvedValueOnce(new Response(null, { status: 204 }));
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await repository.mergePullRequest(
+        'https://github.com/HiromiShikata/test-repository/pull/42',
+      );
+
+      expect(fetchSpy).toHaveBeenCalledTimes(3);
+      expect(fetchSpy).toHaveBeenNthCalledWith(
+        3,
+        'https://api.github.com/repos/HiromiShikata/test-repository/pulls/42/merge',
+        expect.objectContaining({
+          method: 'PUT',
+          body: JSON.stringify({ merge_method: 'rebase' }),
+        }),
+      );
+    });
+
+    it('should throw with the original error when no alternative merge method is available after HTTP 405', async () => {
+      jest
+        .spyOn(global, 'fetch')
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              message: 'Merge commits are not allowed on this repository.',
+            }),
+            { status: 405, headers: { 'Content-Type': 'application/json' } },
+          ),
+        )
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              allow_squash_merge: false,
+              allow_rebase_merge: false,
+            }),
+            { status: 200, headers: { 'Content-Type': 'application/json' } },
+          ),
+        );
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await expect(
+        repository.mergePullRequest(
+          'https://github.com/HiromiShikata/test-repository/pull/42',
+        ),
+      ).rejects.toThrow(
+        'Failed to merge PR https://github.com/HiromiShikata/test-repository/pull/42: HTTP 405 Merge commits are not allowed on this repository.',
+      );
+    });
+
+    it('should throw when the merge API responds with a non-405 error', async () => {
+      jest.spyOn(global, 'fetch').mockResolvedValueOnce(
+        new Response(JSON.stringify({ message: 'Not Found' }), {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await expect(
+        repository.mergePullRequest(
+          'https://github.com/HiromiShikata/test-repository/pull/42',
+        ),
+      ).rejects.toThrow(
+        'Failed to merge PR https://github.com/HiromiShikata/test-repository/pull/42: HTTP 404 Not Found',
+      );
+    });
+  });
+
   describe('rate-limit-aware retry on console operations', () => {
     afterEach(() => {
       jest.restoreAllMocks();

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

@@ -362,6 +362,12 @@ function isRefContainer(value: unknown): value is { ref: string } {
   return isRecord(value) && typeof value.ref === 'string';
 }
 
+function isRepoMergeSettings(
+  value: unknown,
+): value is { allow_squash_merge?: boolean; allow_rebase_merge?: boolean } {
+  return isRecord(value);
+}
+
 type IssueOrPullRequestBodyResponse = {
   body: string | null;
 };
@@ -527,6 +533,7 @@ export class ApiV3CheerioRestIssueRepository
       | 'removeLabel'
       | 'updateAssigneeList'
       | 'searchIssues'
+      | 'getOrCreateLabel'
     >,
     readonly graphqlProjectItemRepository: Pick<
       GraphqlProjectItemRepository,
@@ -614,6 +621,10 @@ export class ApiV3CheerioRestIssueRepository
     const status = item.customFields.find(
       (field) => normalizeFieldName(field.name) === 'status',
     )?.value;
+    const agent =
+      item.customFields.find(
+        (field) => normalizeFieldName(field.name) === 'agent',
+      )?.value ?? null;
     const { owner, repo } = this.extractIssueFromUrl(item.url);
 
     return {
@@ -643,6 +654,7 @@ export class ApiV3CheerioRestIssueRepository
       createdAt: new Date(item.createdAt || '2000-01-01'),
       author: item.author,
       closingIssueReferenceUrls: item.closingIssueReferenceUrls,
+      agent,
     };
   };
   private restoreIssuesFromCache = (rawIssues: unknown): Issue[] | null => {
@@ -914,6 +926,33 @@ export class ApiV3CheerioRestIssueRepository
     );
   };
 
+  setIssueAgentField = async (
+    issueUrl: string,
+    project: Project,
+    agentOptionId: string,
+  ): Promise<void> => {
+    if (!project.agent) {
+      return;
+    }
+    const existingProjectItem =
+      await this.graphqlProjectItemRepository.fetchProjectItemByUrl(
+        issueUrl,
+        project.id,
+      );
+    const projectItemId =
+      existingProjectItem?.id ??
+      (await this.graphqlProjectItemRepository.addIssueToProject(
+        project.id,
+        issueUrl,
+      ));
+    await this.graphqlProjectItemRepository.updateProjectField(
+      project.id,
+      project.agent.fieldId,
+      projectItemId,
+      { singleSelectOptionId: agentOptionId },
+    );
+  };
+
   updateNextActionDate = async (
     issueUrl: string,
     project: Project,
@@ -1006,6 +1045,13 @@ export class ApiV3CheerioRestIssueRepository
   removeLabel = (issue: Issue, label: string): Promise<void> => {
     return this.restIssueRepository.removeLabel(issue, label);
   };
+  getOrCreateLabel = (
+    org: string,
+    repo: string,
+    labelName: string,
+  ): Promise<void> => {
+    return this.restIssueRepository.getOrCreateLabel(org, repo, labelName);
+  };
   updateAssigneeList = (
     issue: Pick<Issue, 'org' | 'repo' | 'number'>,
     assigneeList: Member['name'][],
@@ -2239,24 +2285,71 @@ export class ApiV3CheerioRestIssueRepository
 
   mergePullRequest = async (prUrl: string): Promise<void> => {
     const { owner, repo, issueNumber: prNumber } = this.parseIssueUrl(prUrl);
+    const mergeUrl = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${prNumber}/merge`;
+    const headers = {
+      Authorization: `Bearer ${this.ghToken}`,
+      'Content-Type': 'application/json',
+      Accept: 'application/vnd.github+json',
+    };
+    const mergeWith = (mergeMethod?: 'squash' | 'rebase') =>
+      this.fetchWithRateLimitRetry(() =>
+        fetch(mergeUrl, {
+          method: 'PUT',
+          headers,
+          body: JSON.stringify(
+            mergeMethod ? { merge_method: mergeMethod } : {},
+          ),
+        }),
+      );
+    const response = await mergeWith();
+    if (response.ok) {
+      return;
+    }
+    if (response.status === 405) {
+      const fallbackMethod = await this.resolveAllowedMergeMethod(owner, repo);
+      if (fallbackMethod !== null) {
+        const retryResponse = await mergeWith(fallbackMethod);
+        if (retryResponse.ok) {
+          return;
+        }
+        const retryReason =
+          await this.formatGitHubErrorWithStatus(retryResponse);
+        throw new Error(`Failed to merge PR ${prUrl}: ${retryReason}`);
+      }
+    }
+    const reason = await this.formatGitHubErrorWithStatus(response);
+    throw new Error(`Failed to merge PR ${prUrl}: ${reason}`);
+  };
+
+  private resolveAllowedMergeMethod = async (
+    owner: string,
+    repo: string,
+  ): Promise<'squash' | 'rebase' | null> => {
     const response = await this.fetchWithRateLimitRetry(() =>
       fetch(
-        `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${prNumber}/merge`,
+        `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`,
         {
-          method: 'PUT',
           headers: {
             Authorization: `Bearer ${this.ghToken}`,
-            'Content-Type': 'application/json',
             Accept: 'application/vnd.github+json',
           },
-          body: JSON.stringify({}),
         },
       ),
     );
     if (!response.ok) {
-      const reason = await this.formatGitHubErrorWithStatus(response);
-      throw new Error(`Failed to merge PR ${prUrl}: ${reason}`);
+      return null;
+    }
+    const data: unknown = await response.json();
+    if (!isRepoMergeSettings(data)) {
+      return null;
     }
+    if (data.allow_squash_merge === true) {
+      return 'squash';
+    }
+    if (data.allow_rebase_merge === true) {
+      return 'rebase';
+    }
+    return null;
   };
 
   requestChangesWithInlineComment = async (

package/src/adapter/repositories/issue/RestIssueRepository.test.ts

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

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

@@ -154,6 +154,36 @@ export class RestIssueRepository
     }
   };
 
+  getOrCreateLabel = async (
+    org: string,
+    repo: string,
+    labelName: string,
+  ): Promise<void> => {
+    try {
+      await ky.get(
+        `https://api.github.com/repos/${org}/${repo}/labels/${encodeURIComponent(labelName)}`,
+        {
+          headers: {
+            Authorization: `token ${this.ghToken}`,
+            Accept: 'application/vnd.github.v3+json',
+          },
+        },
+      );
+    } catch (e) {
+      if (e instanceof HTTPError && e.response.status === 404) {
+        await ky.post(`https://api.github.com/repos/${org}/${repo}/labels`, {
+          json: { name: labelName, color: 'ededed' },
+          headers: {
+            Authorization: `token ${this.ghToken}`,
+            Accept: 'application/vnd.github.v3+json',
+          },
+        });
+      } else {
+        throw e;
+      }
+    }
+  };
+
   updateAssigneeList = async (
     issue: Pick<Issue, 'org' | 'repo' | 'number'>,
     assigneeList: Member['name'][],

package/src/adapter/repositories/projectFieldDefinition.test.ts

@@ -140,6 +140,7 @@ describe('projectFromDefinition', () => {
         name: 'Completion Date (50% Confidence)',
         fieldId: 'PVTF_completion',
       },
+      agent: null,
     });
   });
 

package/src/adapter/repositories/projectFieldDefinition.ts

@@ -1,5 +1,6 @@
 import { FieldOption, Project } from '../../domain/entities/Project';
 import {
+  AGENT_FIELD_NAME,
   DEPENDED_ISSUE_URL_FIELD_NAME,
   NEXT_ACTION_DATE_FIELD_NAME,
   NEXT_ACTION_HOUR_FIELD_NAME,
@@ -77,6 +78,10 @@ export const projectFromDefinition = (
   const completionDate50PercentConfidence = definition.fields.find((field) =>
     normalizeFieldName(field.name).startsWith('completiondate'),
   );
+  const agentField = definition.fields.find(
+    (field) =>
+      normalizeFieldName(field.name) === normalizeFieldName(AGENT_FIELD_NAME),
+  );
   return {
     id: definition.id,
     url: definition.url,
@@ -127,5 +132,12 @@ export const projectFromDefinition = (
           fieldId: completionDate50PercentConfidence.fieldId,
         }
       : null,
+    agent: agentField
+      ? {
+          name: agentField.name,
+          fieldId: agentField.fieldId,
+          options: agentField.options,
+        }
+      : null,
   };
 };

package/src/domain/entities/Issue.ts

@@ -25,4 +25,5 @@ export type Issue = {
   createdAt: Date;
   author: string;
   closingIssueReferenceUrls: string[];
+  agent: string | null;
 };

package/src/domain/entities/Project.ts

@@ -47,4 +47,9 @@ export type Project = {
     name: string;
     fieldId: string;
   } | null;
+  agent: {
+    name: string;
+    fieldId: string;
+    options: FieldOption[];
+  } | null;
 };

package/src/domain/entities/RequiredProjectField.ts

@@ -40,6 +40,7 @@ export const NEXT_ACTION_DATE_FIELD_NAME = 'Next Action Date';
 export const NEXT_ACTION_HOUR_FIELD_NAME = 'Next Action Hour';
 export const DEPENDED_ISSUE_URL_FIELD_NAME =
   'Depended Issue URL separated by comma';
+export const AGENT_FIELD_NAME = 'Agent';
 
 export const REQUIRED_PROJECT_FIELDS: RequiredProjectFieldDefinition[] = [
   {
@@ -62,4 +63,9 @@ export const REQUIRED_PROJECT_FIELDS: RequiredProjectFieldDefinition[] = [
     dataType: 'TEXT',
     options: [],
   },
+  {
+    name: AGENT_FIELD_NAME,
+    dataType: 'SINGLE_SELECT',
+    options: [],
+  },
 ];

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

@@ -28,6 +28,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   createdAt: new Date('2000-01-01T00:00:00Z'),
   author: 'test-user',
   closingIssueReferenceUrls: [],
+  agent: null,
   ...overrides,
 });
 

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

@@ -41,6 +41,7 @@ describe('GetStoryObjectMapUseCase', () => {
     remainingEstimationMinutes: null,
     dependedIssueUrlSeparatedByComma: null,
     completionDate50PercentConfidence: null,
+    agent: null,
   };
 
   const createBasicIssue = (overrides: Partial<Issue> = {}): Issue => ({
@@ -68,6 +69,7 @@ describe('GetStoryObjectMapUseCase', () => {
     createdAt: new Date(),
     author: '',
     closingIssueReferenceUrls: [],
+    agent: null,
     ...overrides,
   });
 

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

@@ -683,6 +683,7 @@ describe('HandleScheduledEventUseCase', () => {
         remainingEstimationMinutes: null,
         dependedIssueUrlSeparatedByComma: null,
         completionDate50PercentConfidence: null,
+        agent: null,
       };
 
       const capturedLogs: string[] = [];

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -160,6 +160,7 @@ export class HandleScheduledEventUseCase {
     changeTargetPathAliases?: Record<string, string> | null;
     allowedIssueAuthors?: string[] | null;
     autoAssignManagerAuthors?: string[] | null;
+    agents?: string[] | null;
     startPreparation?: {
       defaultAgentName: string;
       defaultLlmModelName?: string | null;
@@ -195,6 +196,7 @@ export class HandleScheduledEventUseCase {
     }
     await this.projectRequiredFieldCreateUseCase.run({
       projectUrl: input.projectUrl,
+      agents: input.agents ?? null,
     });
     await this.setupTowerDefenceProjectUseCase.run({
       projectUrl: input.projectUrl,

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

@@ -51,6 +51,7 @@ const issue = (url: string, status: string): Issue => ({
   createdAt: new Date('2026-01-01T00:00:00Z'),
   author: 'hiromi',
   closingIssueReferenceUrls: [],
+  agent: null,
 });
 
 describe('InTmuxByHumanSessionTokenCountUseCase', () => {