npm - github-issue-tower-defence-management - Versions diffs - 1.147.4 → 1.148.0 - Mend

github-issue-tower-defence-management 1.147.4 → 1.148.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-CtUryuGr.js"></script>
+    <script type="module" crossorigin src="/assets/index-D7Yt5Ya6.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BihdmZb-.css">
   </head>
   <body>

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

@@ -10,6 +10,7 @@ import {
 } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { Project } from '../../../domain/entities/Project';
 import { Issue } from '../../../domain/entities/Issue';
+import { SearchedIssue } from '../../../domain/entities/SearchedIssue';
 import { StoryObjectMap } from '../../../domain/entities/StoryObjectMap';
 import { ApiV3IssueRepository } from './ApiV3IssueRepository';
 import { normalizeGitHubRawUrl } from './gitHubRawUrl';
@@ -455,6 +456,7 @@ export class ApiV3CheerioRestIssueRepository
       | 'updateLabels'
       | 'removeLabel'
       | 'updateAssigneeList'
+      | 'searchIssues'
     >,
     readonly graphqlProjectItemRepository: Pick<
       GraphqlProjectItemRepository,
@@ -935,11 +937,14 @@ export class ApiV3CheerioRestIssueRepository
     return this.restIssueRepository.removeLabel(issue, label);
   };
   updateAssigneeList = (
-    issue: Issue,
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
     assigneeList: Member['name'][],
   ): Promise<void> => {
     return this.restIssueRepository.updateAssigneeList(issue, assigneeList);
   };
+  searchIssues = (query: string): Promise<SearchedIssue[]> => {
+    return this.restIssueRepository.searchIssues(query);
+  };
   get = async (_issueUrl: string, _project: Project): Promise<Issue | null> => {
     return this.getIssueByUrl(_issueUrl);
   };

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

@@ -262,4 +262,111 @@ describe('RestIssueRepository', () => {
       );
     });
   });
+  describe('searchIssues', () => {
+    const buildSearchItem = (
+      overrides: Partial<{
+        html_url: string;
+        state: string;
+        user: { login: string } | null;
+        assignees: { login: string }[];
+        pull_request: { merged_at: string | null } | null;
+      }> = {},
+    ) => ({
+      html_url: 'https://github.com/HiromiShikata/test-repository/pull/12',
+      state: 'open',
+      user: { login: 'dependabot[bot]' },
+      assignees: [],
+      pull_request: { merged_at: null },
+      ...overrides,
+    });
+    it('sends the query to the search endpoint and maps the response', async () => {
+      mockGet.mockReturnValueOnce(
+        mockJsonResponse({ items: [buildSearchItem()] }),
+      );
+      const searchedIssues = await restIssueRepository.searchIssues(
+        'repo:HiromiShikata/test-repository is:open no:project',
+      );
+      expect(mockGet).toHaveBeenCalledWith(
+        'https://api.github.com/search/issues',
+        {
+          searchParams: {
+            q: 'repo:HiromiShikata/test-repository is:open no:project',
+            per_page: 100,
+            page: 1,
+            advanced_search: 'true',
+          },
+          headers: { Authorization: 'token dummy-token' },
+        },
+      );
+      expect(searchedIssues).toEqual([
+        {
+          url: 'https://github.com/HiromiShikata/test-repository/pull/12',
+          org: 'HiromiShikata',
+          repo: 'test-repository',
+          number: 12,
+          state: 'OPEN',
+          author: 'dependabot',
+          assignees: [],
+        },
+      ]);
+    });
+    it('keeps the author login of a human account unchanged', async () => {
+      mockGet.mockReturnValueOnce(
+        mockJsonResponse({
+          items: [buildSearchItem({ user: { login: 'HiromiShikata' } })],
+        }),
+      );
+      const searchedIssues = await restIssueRepository.searchIssues('anything');
+      expect(searchedIssues[0].author).toBe('HiromiShikata');
+    });
+    it('maps a merged pull request and a closed issue to their states', async () => {
+      mockGet.mockReturnValueOnce(
+        mockJsonResponse({
+          items: [
+            buildSearchItem({
+              state: 'closed',
+              pull_request: { merged_at: '2026-08-09T00:00:00Z' },
+            }),
+            buildSearchItem({
+              html_url:
+                'https://github.com/HiromiShikata/test-repository/issues/13',
+              state: 'closed',
+              pull_request: null,
+            }),
+          ],
+        }),
+      );
+      const searchedIssues = await restIssueRepository.searchIssues('anything');
+      expect(searchedIssues.map((issue) => issue.state)).toEqual([
+        'MERGED',
+        'CLOSED',
+      ]);
+    });
+    it('requests the next page while a full page is returned', async () => {
+      const fullPage = Array.from({ length: 100 }, (_unused, index) =>
+        buildSearchItem({
+          html_url: `https://github.com/HiromiShikata/test-repository/pull/${index + 1}`,
+        }),
+      );
+      mockGet
+        .mockReturnValueOnce(mockJsonResponse({ items: fullPage }))
+        .mockReturnValueOnce(mockJsonResponse({ items: [buildSearchItem()] }));
+      const searchedIssues = await restIssueRepository.searchIssues('anything');
+      expect(mockGet).toHaveBeenCalledTimes(2);
+      expect(searchedIssues).toHaveLength(101);
+    });
+  });
 });

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

@@ -3,10 +3,24 @@ import { BaseGitHubRepository } from '../BaseGitHubRepository';
 import { Issue } from '../../../domain/entities/Issue';
 import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { Member } from '../../../domain/entities/Member';
+import { SearchedIssue } from '../../../domain/entities/SearchedIssue';
+type SearchIssuesResponseItem = {
+  html_url: string;
+  state: string;
+  user: { login: string } | null;
+  assignees: { login: string }[];
+  pull_request?: { merged_at: string | null } | null;
+};
+type SearchIssuesResponse = {
+  items: SearchIssuesResponseItem[];
+};
 export class RestIssueRepository
   extends BaseGitHubRepository
-  implements Pick<IssueRepository, 'updateAssigneeList' | 'removeLabel'>
+  implements
+    Pick<IssueRepository, 'updateAssigneeList' | 'removeLabel' | 'searchIssues'>
 {
   createComment = async (issueUrl: string, comment: string) => {
     const { owner, repo, issueNumber } = this.extractIssueFromUrl(issueUrl);
@@ -128,7 +142,7 @@ export class RestIssueRepository
   };
   updateAssigneeList = async (
-    issue: Issue,
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
     assigneeList: Member['name'][],
   ): Promise<void> => {
     await ky.patch(
@@ -139,4 +153,57 @@ export class RestIssueRepository
       },
     );
   };
+  searchIssues = async (query: string): Promise<SearchedIssue[]> => {
+    const perPage = 100;
+    const maxPageCount = 10;
+    const searchedIssues: SearchedIssue[] = [];
+    for (let page = 1; page <= maxPageCount; page++) {
+      const response = await ky
+        .get('https://api.github.com/search/issues', {
+          searchParams: {
+            q: query,
+            per_page: perPage,
+            page,
+            advanced_search: 'true',
+          },
+          headers: { Authorization: `token ${this.ghToken}` },
+        })
+        .json<SearchIssuesResponse>();
+      for (const item of response.items) {
+        const parsed = this.parseSearchedIssue(item);
+        if (parsed) {
+          searchedIssues.push(parsed);
+        }
+      }
+      if (response.items.length < perPage) {
+        break;
+      }
+    }
+    return searchedIssues;
+  };
+  private parseSearchedIssue = (
+    item: SearchIssuesResponseItem,
+  ): SearchedIssue | null => {
+    const matched = item.html_url.match(
+      /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(?:issues|pull)\/(\d+)$/,
+    );
+    if (!matched) {
+      return null;
+    }
+    return {
+      url: item.html_url,
+      org: matched[1],
+      repo: matched[2],
+      number: Number(matched[3]),
+      state: item.pull_request?.merged_at
+        ? 'MERGED'
+        : item.state === 'open'
+          ? 'OPEN'
+          : 'CLOSED',
+      author: (item.user?.login ?? '').replace(/\[bot\]$/, ''),
+      assignees: item.assignees.map((assignee) => assignee.login),
+    };
+  };
 }

package/src/domain/entities/SearchedIssue.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { Member } from './Member';
+export type SearchedIssue = {
+  url: string;
+  org: string;
+  repo: string;
+  number: number;
+  state: 'OPEN' | 'CLOSED' | 'MERGED';
+  author: string;
+  assignees: Member['name'][];
+};

package/src/domain/usecases/AssignNoAssigneeIssueToManagerUseCase.test.ts CHANGED Viewed

@@ -2,6 +2,8 @@ import { mock } from 'jest-mock-extended';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { SearchedIssue } from '../entities/SearchedIssue';
 describe('AssignNoAssigneeIssueToManagerUseCase', () => {
   const mockIssueRepository = mock<IssueRepository>();
@@ -275,6 +277,212 @@ describe('AssignNoAssigneeIssueToManagerUseCase', () => {
       ]);
     });
+    describe('issues matched by queryToAddProject', () => {
+      const project = { ...mock<Project>(), id: 'project-1' };
+      const searchedIssue: SearchedIssue = {
+        url: 'https://github.com/testOrg/testRepo/pull/7',
+        org: 'testOrg',
+        repo: 'testRepo',
+        number: 7,
+        state: 'OPEN',
+        author: 'dependabot',
+        assignees: [],
+      };
+      it('adds a matched issue that is not a project item to the project and assigns the manager', async () => {
+        mockIssueRepository.searchIssues.mockResolvedValueOnce([searchedIssue]);
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.searchIssues.mock.calls).toEqual([
+          ['repo:testOrg/testRepo is:open no:project'],
+        ]);
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([
+          [project, searchedIssue.url],
+        ]);
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+          [{ org: 'testOrg', repo: 'testRepo', number: 7 }, ['manager1']],
+        ]);
+      });
+      it('does not add or assign a matched issue whose author is outside autoAssignManagerAuthors', async () => {
+        mockIssueRepository.searchIssues.mockResolvedValueOnce([
+          { ...searchedIssue, author: 'human-author' },
+        ]);
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([]);
+      });
+      it('does not add or assign a matched issue that already has an assignee or is not open', async () => {
+        mockIssueRepository.searchIssues.mockResolvedValueOnce([
+          { ...searchedIssue, assignees: ['someone'] },
+          { ...searchedIssue, number: 8, state: 'CLOSED' },
+        ]);
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([]);
+      });
+      it('assigns a matched issue that is already a project item only once and does not re-add it', async () => {
+        const projectItem = {
+          ...basicIssue,
+          url: searchedIssue.url,
+          author: 'dependabot',
+        };
+        mockIssueRepository.searchIssues.mockResolvedValueOnce([searchedIssue]);
+        await useCase.run({
+          issues: [projectItem],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+          [projectItem, ['manager1']],
+        ]);
+      });
+      it('does not search when no query is configured', async () => {
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: null,
+        });
+        expect(mockIssueRepository.searchIssues.mock.calls).toEqual([]);
+      });
+      it('does not search when queryToAddProjectEnabled is false', async () => {
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: false,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.searchIssues.mock.calls).toEqual([]);
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+      });
+      it('does not search when queryToAddProjectEnabled is not configured', async () => {
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(mockIssueRepository.searchIssues.mock.calls).toEqual([]);
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+      });
+      it('logs and returns without throwing when the search fails', async () => {
+        mockIssueRepository.searchIssues.mockRejectedValueOnce(
+          new Error('Validation Failed'),
+        );
+        const consoleErrorSpy = jest
+          .spyOn(console, 'error')
+          .mockImplementation(() => undefined);
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+          'Failed to search issues by repo:testOrg/testRepo is:open no:project: Validation Failed',
+        );
+        expect(mockIssueRepository.addIssueToProject.mock.calls).toEqual([]);
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([]);
+        consoleErrorSpy.mockRestore();
+      });
+      it('logs and continues when adding a matched issue to the project fails', async () => {
+        mockIssueRepository.searchIssues.mockResolvedValueOnce([
+          searchedIssue,
+          {
+            ...searchedIssue,
+            url: 'https://github.com/testOrg/testRepo/pull/9',
+            number: 9,
+          },
+        ]);
+        mockIssueRepository.addIssueToProject.mockRejectedValueOnce(
+          new Error('Content not found'),
+        );
+        const consoleErrorSpy = jest
+          .spyOn(console, 'error')
+          .mockImplementation(() => undefined);
+        await useCase.run({
+          issues: [],
+          manager: 'manager1',
+          cacheUsed: false,
+          autoAssignManagerAuthors: ['dependabot'],
+          projectToAddSearchedIssues: project,
+          queryToAddProjectEnabled: true,
+          queryToAddProject: 'repo:testOrg/testRepo is:open no:project',
+        });
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+          'Failed to add issue https://github.com/testOrg/testRepo/pull/7 to project: Content not found',
+        );
+        expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+          [{ org: 'testOrg', repo: 'testRepo', number: 9 }, ['manager1']],
+        ]);
+        consoleErrorSpy.mockRestore();
+      });
+    });
     it('should rethrow non-Error thrown values without logging', async () => {
       const failingIssue = {
         ...basicIssue,

package/src/domain/usecases/AssignNoAssigneeIssueToManagerUseCase.ts CHANGED Viewed

@@ -1,10 +1,15 @@
 import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { SearchedIssue } from '../entities/SearchedIssue';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { Member } from '../entities/Member';
 export class AssignNoAssigneeIssueToManagerUseCase {
   constructor(
-    readonly issueRepository: Pick<IssueRepository, 'updateAssigneeList'>,
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'updateAssigneeList' | 'searchIssues' | 'addIssueToProject'
+    >,
   ) {}
   run = async (input: {
@@ -12,6 +17,9 @@ export class AssignNoAssigneeIssueToManagerUseCase {
     manager: Member['name'];
     cacheUsed: boolean;
     autoAssignManagerAuthors?: string[] | null;
+    projectToAddSearchedIssues?: Project | null;
+    queryToAddProjectEnabled?: boolean | null;
+    queryToAddProject?: string | null;
   }): Promise<void> => {
     if (input.cacheUsed) {
       return;
@@ -21,25 +29,108 @@ export class AssignNoAssigneeIssueToManagerUseCase {
       input.autoAssignManagerAuthors.length > 0
         ? input.autoAssignManagerAuthors
         : null;
+    const isAssignable = (target: {
+      assignees: Member['name'][];
+      state: Issue['state'];
+      author: string;
+    }): boolean => {
+      if (target.assignees.length > 0 || target.state !== 'OPEN') {
+        return false;
+      }
+      return (
+        authorAllowList === null || authorAllowList.includes(target.author)
+      );
+    };
     for (const issue of input.issues) {
-      if (issue.assignees.length > 0 || issue.state !== 'OPEN') {
+      if (!isAssignable(issue)) {
+        continue;
+      }
+      await this.assignManager(issue, issue.url, input.manager);
+    }
+    const project = input.projectToAddSearchedIssues;
+    const query = input.queryToAddProject;
+    if (!input.queryToAddProjectEnabled || !project || !query) {
+      return;
+    }
+    const projectItemUrls = new Set(input.issues.map((issue) => issue.url));
+    const searchedIssues = await this.searchIssues(query);
+    for (const searchedIssue of searchedIssues) {
+      if (
+        projectItemUrls.has(searchedIssue.url) ||
+        !isAssignable(searchedIssue)
+      ) {
         continue;
       }
-      if (authorAllowList !== null && !authorAllowList.includes(issue.author)) {
+      if (!(await this.addToProject(project, searchedIssue))) {
         continue;
       }
-      try {
-        await this.issueRepository.updateAssigneeList(issue, [input.manager]);
-      } catch (e) {
-        if (!(e instanceof Error)) {
-          throw e;
-        }
-        console.error(
-          `Failed to update assignee for issue ${issue.url}: ${e.message}`,
-        );
+      if (
+        !(await this.assignManager(
+          {
+            org: searchedIssue.org,
+            repo: searchedIssue.repo,
+            number: searchedIssue.number,
+          },
+          searchedIssue.url,
+          input.manager,
+        ))
+      ) {
         continue;
       }
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await this.waitBeforeNextRequest();
+    }
+  };
+  private searchIssues = async (query: string): Promise<SearchedIssue[]> => {
+    try {
+      return await this.issueRepository.searchIssues(query);
+    } catch (e) {
+      if (!(e instanceof Error)) {
+        throw e;
+      }
+      console.error(`Failed to search issues by ${query}: ${e.message}`);
+      return [];
     }
   };
+  private addToProject = async (
+    project: Project,
+    searchedIssue: SearchedIssue,
+  ): Promise<boolean> => {
+    try {
+      await this.issueRepository.addIssueToProject(project, searchedIssue.url);
+    } catch (e) {
+      if (!(e instanceof Error)) {
+        throw e;
+      }
+      console.error(
+        `Failed to add issue ${searchedIssue.url} to project: ${e.message}`,
+      );
+      return false;
+    }
+    return true;
+  };
+  private assignManager = async (
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
+    issueUrl: string,
+    manager: Member['name'],
+  ): Promise<boolean> => {
+    try {
+      await this.issueRepository.updateAssigneeList(issue, [manager]);
+    } catch (e) {
+      if (!(e instanceof Error)) {
+        throw e;
+      }
+      console.error(
+        `Failed to update assignee for issue ${issueUrl}: ${e.message}`,
+      );
+      return false;
+    }
+    return true;
+  };
+  private waitBeforeNextRequest = async (): Promise<void> => {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  };
 }

package/src/domain/usecases/HandleScheduledEventUseCase.ts CHANGED Viewed

@@ -178,6 +178,8 @@ export class HandleScheduledEventUseCase {
     } | null;
     thresholdForAutoReject?: number;
     createTaskFromStoryBodyCheckboxEnabled?: boolean;
+    queryToAddProjectEnabled?: boolean;
+    queryToAddProject?: string | null;
     storyProgressCommentEnabled?: boolean;
     dailySecurityScan?: DailySecurityScanConfig | null;
   }): Promise<{
@@ -568,6 +570,9 @@ ${JSON.stringify(e)}
       manager: input.manager,
       cacheUsed,
       autoAssignManagerAuthors: input.autoAssignManagerAuthors ?? null,
+      projectToAddSearchedIssues: project,
+      queryToAddProjectEnabled: input.queryToAddProjectEnabled ?? false,
+      queryToAddProject: input.queryToAddProject ?? null,
     });
     await this.updateIssueStatusByLabelUseCase.run({
       project,

package/src/domain/usecases/adapter-interfaces/IssueRepository.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { Issue, Label } from '../../entities/Issue';
 import { FieldOption, Project } from '../../entities/Project';
 import { Member } from '../../entities/Member';
+import { SearchedIssue } from '../../entities/SearchedIssue';
 import { StoryObjectMap } from '../../entities/StoryObjectMap';
 export type RelatedPullRequest = {
@@ -127,9 +128,10 @@ export interface IssueRepository {
   updateLabels: (issue: Issue, labels: Issue['labels']) => Promise<void>;
   removeLabel: (issue: Issue, label: Label) => Promise<void>;
   updateAssigneeList: (
-    issue: Issue,
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
     assigneeList: Member['name'][],
   ) => Promise<void>;
+  searchIssues: (query: string) => Promise<SearchedIssue[]>;
   get: (issueUrl: string, project: Project) => Promise<Issue | null>;
   update: (issue: Issue, project: Project) => Promise<void>;
   findRelatedOpenPRs: (issueUrl: string) => Promise<RelatedPullRequest[]>;