github-issue-tower-defence-management 1.37.0 → 1.38.0

package/src/adapter/entry-points/cli/index.ts

@@ -18,6 +18,7 @@ import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunne
 import { OauthAPIClaudeRepository } from '../../repositories/OauthAPIClaudeRepository';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { FetchWebhookRepository } from '../../repositories/FetchWebhookRepository';
+import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { Project } from '../../../domain/entities/Project';
 
 type ConfigFile = {
@@ -32,6 +33,7 @@ type ConfigFile = {
   thresholdForAutoReject?: number;
   workflowBlockerResolvedWebhookUrl?: string;
   projectName?: string;
+  preparationProcessCheckCommand?: string;
 };
 
 type StartDaemonOptions = {
@@ -42,6 +44,7 @@ type StartDaemonOptions = {
   logFilePath?: string;
   maximumPreparingIssuesCount?: string;
   allowIssueCacheMinutes?: string;
+  preparationProcessCheckCommand?: string;
   configFilePath: string;
 };
 
@@ -106,6 +109,10 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
         'workflowBlockerResolvedWebhookUrl',
       ),
       projectName: getStringValue(parsed, 'projectName'),
+      preparationProcessCheckCommand: getStringValue(
+        parsed,
+        'preparationProcessCheckCommand',
+      ),
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -154,6 +161,10 @@ export const parseProjectReadmeConfig = (readme: string): ConfigFile => {
         parsed,
         'workflowBlockerResolvedWebhookUrl',
       ),
+      preparationProcessCheckCommand: getStringValue(
+        parsed,
+        'preparationProcessCheckCommand',
+      ),
     };
   } catch {
     console.warn('Failed to parse YAML from project README config section');
@@ -204,6 +215,10 @@ export const mergeConfigs = (
     cliOverrides.workflowBlockerResolvedWebhookUrl ??
     configFile.workflowBlockerResolvedWebhookUrl,
   projectName: configFile.projectName,
+  preparationProcessCheckCommand:
+    readmeOverrides.preparationProcessCheckCommand ??
+    cliOverrides.preparationProcessCheckCommand ??
+    configFile.preparationProcessCheckCommand,
 });
 
 type GraphqlProjectV2ReadmeResponse = {
@@ -355,6 +370,10 @@ program
     '--allowIssueCacheMinutes <minutes>',
     'Allow cache for issues in minutes (default: 0)',
   )
+  .option(
+    '--preparationProcessCheckCommand <template>',
+    'Shell command template with {URL} placeholder to check if a preparation process is alive',
+  )
   .action(async (options: StartDaemonOptions) => {
     const token = process.env.GH_TOKEN;
     if (!token) {
@@ -376,6 +395,7 @@ program
       allowIssueCacheMinutes: options.allowIssueCacheMinutes
         ? Number(options.allowIssueCacheMinutes)
         : undefined,
+      preparationProcessCheckCommand: options.preparationProcessCheckCommand,
     };
 
     const tempProjectUrl =
@@ -484,6 +504,23 @@ program
     const claudeRepository = new OauthAPIClaudeRepository();
     const localCommandRunner = new NodeLocalCommandRunner();
 
+    const preparationProcessCheckCommand =
+      config.preparationProcessCheckCommand;
+    if (preparationProcessCheckCommand) {
+      const revertUseCase = new RevertOrphanedPreparationUseCase(
+        projectRepository,
+        issueRepository,
+        localCommandRunner,
+      );
+      await revertUseCase.run({
+        projectUrl,
+        preparationStatus,
+        awaitingWorkspaceStatus,
+        allowIssueCacheMinutes,
+        preparationProcessCheckCommand,
+      });
+    }
+
     const useCase = new StartPreparationUseCase(
       projectRepository,
       issueRepository,

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

@@ -33,6 +33,7 @@ import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparati
 import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
 import { StubClaudeRepository } from '../../repositories/StubClaudeRepository';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
+import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { FetchWebhookRepository } from '../../repositories/FetchWebhookRepository';
 
@@ -186,6 +187,12 @@ export class HandleScheduledEventUseCaseHandler {
         issueCommentRepository,
         webhookRepository,
       );
+    const revertOrphanedPreparationUseCase =
+      new RevertOrphanedPreparationUseCase(
+        projectRepository,
+        issueRepository,
+        nodeLocalCommandRunner,
+      );
 
     const handleScheduledEventUseCase = new HandleScheduledEventUseCase(
       actionAnnouncement,
@@ -203,6 +210,7 @@ export class HandleScheduledEventUseCaseHandler {
       updateIssueStatusByLabelUseCase,
       startPreparationUseCase,
       notifyFinishedIssuePreparationUseCase,
+      revertOrphanedPreparationUseCase,
       systemDateRepository,
       googleSpreadsheetRepository,
       projectRepository,

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

@@ -177,6 +177,27 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('getAllIssues throws when fetchProjectItems throws', () => {
+    it('should not write cache and should propagate error when fetchProjectItems throws', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const fetchError = new Error(
+        'fetchProjectItems: expected 5 items but accumulated 1',
+      );
+      graphqlProjectItemRepository.fetchProjectItems.mockRejectedValue(
+        fetchError,
+      );
+
+      await expect(
+        repository.getAllIssues('test-project-id', 1),
+      ).rejects.toThrow(fetchError);
+      expect(localStorageCacheRepository.set).not.toHaveBeenCalled();
+    });
+  });
+
   describe('updateStatus', () => {
     it('should call graphqlProjectItemRepository.updateProjectField with correct parameters', async () => {
       const { repository, graphqlProjectItemRepository } =

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

@@ -25,12 +25,16 @@ const mockJsonResponse = <T>(data: T) => ({
 });
 
 describe('GraphqlProjectItemRepository', () => {
-  const makePageResponse = (hasNextPage: boolean, endCursor: string) =>
+  const makePageResponse = (
+    hasNextPage: boolean,
+    endCursor: string,
+    totalCount = 2,
+  ) =>
     mockJsonResponse({
       data: {
         node: {
           items: {
-            totalCount: 2,
+            totalCount,
             pageInfo: {
               endCursor,
               startCursor: 'cursor-start',
@@ -101,6 +105,174 @@ describe('GraphqlProjectItemRepository', () => {
       setTimeoutSpy.mockRestore();
     });
 
+    it('should throw when response contains GraphQL errors alongside partial data', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 1,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [
+                  {
+                    id: 'item-partial',
+                    fieldValues: { nodes: [] },
+                    content: {
+                      repository: { nameWithOwner: 'owner/repo' },
+                      number: 1,
+                      title: 'Partial Issue',
+                      state: 'OPEN',
+                      url: 'https://github.com/owner/repo/issues/1',
+                      body: 'body',
+                      createdAt: '2024-01-01T00:00:00Z',
+                      labels: { nodes: [] },
+                      assignees: { nodes: [] },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          errors: [{ message: 'RATE_LIMITED' }],
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('GitHub GraphQL errors: RATE_LIMITED');
+    });
+
+    it('should throw when data is null in response', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: null,
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('No data returned from GitHub API');
+    });
+
+    it('should throw when node is null in response', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: { node: null },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('No data returned from GitHub API');
+    });
+
+    it('should throw when accumulated nodes count does not match totalCount', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 5,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [
+                  {
+                    id: 'item-1',
+                    fieldValues: { nodes: [] },
+                    content: {
+                      repository: { nameWithOwner: 'owner/repo' },
+                      number: 1,
+                      title: 'Test Issue',
+                      state: 'OPEN',
+                      url: 'https://github.com/owner/repo/issues/1',
+                      body: 'body',
+                      createdAt: '2024-01-01T00:00:00Z',
+                      labels: { nodes: [] },
+                      assignees: { nodes: [] },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow(
+        'fetchProjectItems: expected 5 items but accumulated 1',
+      );
+    });
+
+    it('should throw when page has no nodes but totalCount is positive', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 2,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [],
+              },
+            },
+          },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow(
+        'fetchProjectItems: expected 2 items but accumulated 0',
+      );
+    });
+
     it('should not sleep on first request when there is only one page', async () => {
       const localStorageRepository = new LocalStorageRepository();
       const repository = new GraphqlProjectItemRepository(
@@ -110,7 +282,7 @@ describe('GraphqlProjectItemRepository', () => {
       );
 
       const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1'));
+      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
 
       const result = await repository.fetchProjectItems('test-project-id');
 

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

@@ -281,17 +281,31 @@ query GetProjectItems($projectId: ID!, $after: String) {
                   };
                 }[];
               };
-            };
-          };
+            } | null;
+          } | null;
+          errors?: { message: string }[];
         }>();
-      if (!response.data) {
+      if (response.errors && response.errors.length > 0) {
+        throw new Error(
+          `GitHub GraphQL errors: ${response.errors.map((e) => e.message).join('; ')}`,
+        );
+      }
+      const rawData = response.data;
+      if (!rawData) {
+        throw new Error('No data returned from GitHub API');
+      }
+      const rawNode = rawData.node;
+      if (rawNode === null) {
         throw new Error('No data returned from GitHub API');
       }
-      return response.data;
+      return { node: rawNode };
     };
     const issues: ProjectItem[] = [];
     let after: string | null = null;
     let hasNextPage = true;
+    let totalCount = 0;
+    let cumulativeRawNodes = 0;
+    let pageIndex = 0;
 
     while (hasNextPage) {
       if (after !== null) {
@@ -300,6 +314,14 @@ query GetProjectItems($projectId: ID!, $after: String) {
         );
       }
       const data = await callGraphql(projectId, after);
+      const pageNodes = data.node.items.nodes;
+      const pageInfo = data.node.items.pageInfo;
+      totalCount = data.node.items.totalCount;
+      cumulativeRawNodes += pageNodes.length;
+      pageIndex++;
+      console.log(
+        `fetchProjectItems: page ${pageIndex}, nodes: ${pageNodes.length}, cumulative: ${cumulativeRawNodes}/${totalCount}`,
+      );
       const projectItems: {
         id: string;
         fieldValues: {
@@ -324,43 +346,57 @@ query GetProjectItems($projectId: ID!, $after: String) {
           labels: { nodes: { name: string }[] };
           assignees: { nodes: { login: string }[] };
         };
-      }[] = data.node.items.nodes;
-      projectItems
-        // .filter(item => item.content.repository !== undefined)
-        .forEach((item) => {
-          if (!item || !item.content || !item.content.repository) {
-            return;
-          }
-          issues.push({
-            id: item.id,
-            nameWithOwner: item.content.repository.nameWithOwner,
-            number: item.content.number,
-            title: item.content.title,
-            state: this.convertStrToState(item.content.state),
-            url: item.content.url,
-            body: item.content.body,
-            labels: item.content.labels?.nodes?.map((l) => l.name) || [],
-            assignees: item.content.assignees?.nodes?.map((a) => a.login) || [],
-            createdAt: item.content.createdAt || new Date().toISOString(),
-            customFields: item.fieldValues.nodes
-              .filter((field) => !!field.field)
-              .map((field) => {
-                return {
-                  name: field.field.name,
-                  value:
-                    field.name ??
-                    field.text ??
-                    field.number?.toString() ??
-                    field.date ??
-                    null,
-                };
-              }),
-          });
+      }[] = pageNodes;
+      projectItems.forEach((item) => {
+        if (!item || !item.content || !item.content.repository) {
+          return;
+        }
+        issues.push({
+          id: item.id,
+          nameWithOwner: item.content.repository.nameWithOwner,
+          number: item.content.number,
+          title: item.content.title,
+          state: this.convertStrToState(item.content.state),
+          url: item.content.url,
+          body: item.content.body,
+          labels: item.content.labels?.nodes?.map((l) => l.name) || [],
+          assignees: item.content.assignees?.nodes?.map((a) => a.login) || [],
+          createdAt: item.content.createdAt || new Date().toISOString(),
+          customFields: item.fieldValues.nodes
+            .filter((field) => !!field.field)
+            .map((field) => {
+              return {
+                name: field.field.name,
+                value:
+                  field.name ??
+                  field.text ??
+                  field.number?.toString() ??
+                  field.date ??
+                  null,
+              };
+            }),
         });
-      const pageInfo = data.node.items.pageInfo;
+      });
+      if (
+        pageNodes.length === 100 &&
+        !pageInfo.hasNextPage &&
+        cumulativeRawNodes < totalCount
+      ) {
+        throw new Error(
+          `fetchProjectItems: page ${pageIndex} has ${pageNodes.length} nodes with hasNextPage=false but only ${cumulativeRawNodes}/${totalCount} items accumulated`,
+        );
+      }
       hasNextPage = pageInfo.hasNextPage;
       after = pageInfo.endCursor;
     }
+    console.log(
+      `fetchProjectItems: completed, totalCount: ${totalCount}, cumulativeRawNodes: ${cumulativeRawNodes}, issues: ${issues.length}`,
+    );
+    if (cumulativeRawNodes !== totalCount) {
+      throw new Error(
+        `fetchProjectItems: expected ${totalCount} items but accumulated ${cumulativeRawNodes}`,
+      );
+    }
     return issues;
   };
   getProjectItemFieldsFromIssueUrl = async (

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

@@ -20,6 +20,7 @@ import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueTo
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
+import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -105,6 +106,8 @@ describe('HandleScheduledEventUseCase', () => {
     const mockStartPreparationUseCase = mock<StartPreparationUseCase>();
     const mockNotifyFinishedIssuePreparationUseCase =
       mock<NotifyFinishedIssuePreparationUseCase>();
+    const mockRevertOrphanedPreparationUseCase =
+      mock<RevertOrphanedPreparationUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -126,6 +129,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockUpdateIssueStatusByLabelUseCase,
       mockStartPreparationUseCase,
       mockNotifyFinishedIssuePreparationUseCase,
+      mockRevertOrphanedPreparationUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -21,6 +21,7 @@ import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueTo
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
+import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -46,6 +47,7 @@ export class HandleScheduledEventUseCase {
     readonly updateIssueStatusByLabelUseCase: UpdateIssueStatusByLabelUseCase,
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly notifyFinishedIssuePreparationUseCase: NotifyFinishedIssuePreparationUseCase,
+    readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -73,6 +75,7 @@ export class HandleScheduledEventUseCase {
       defaultAgentName: string;
       logFilePath?: string;
       maximumPreparingIssuesCount: number | null;
+      preparationProcessCheckCommand?: string;
     } | null;
     notifyFinishedPreparation?: {
       preparationStatus: string;
@@ -311,6 +314,17 @@ ${JSON.stringify(e)}
       defaultStatus: input.defaultStatus,
     });
     if (input.startPreparation) {
+      if (input.startPreparation.preparationProcessCheckCommand) {
+        await this.revertOrphanedPreparationUseCase.run({
+          projectUrl: input.projectUrl,
+          preparationStatus: input.startPreparation.preparationStatus,
+          awaitingWorkspaceStatus:
+            input.startPreparation.awaitingWorkspaceStatus,
+          allowIssueCacheMinutes: input.allowIssueCacheMinutes,
+          preparationProcessCheckCommand:
+            input.startPreparation.preparationProcessCheckCommand,
+        });
+      }
       await this.startPreparationUseCase.run({
         projectUrl: input.projectUrl,
         awaitingWorkspaceStatus: input.startPreparation.awaitingWorkspaceStatus,