github-issue-tower-defence-management 1.67.1 → 1.67.3

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

@@ -457,4 +457,98 @@ claudeCodeOauthTokenListJsonPath: /readme/tokens.json
       );
     });
   });
+
+  describe('effective config logging', () => {
+    let consoleLogSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should log the effective values with configFile source when only the YAML config sets them', async () => {
+      const configWithPreparation = {
+        ...validConfig,
+        startPreparation: {
+          defaultAgentName: 'yaml-agent',
+          defaultLlmModelName: 'yaml-model',
+          configFilePath: './config.yml',
+          maximumPreparingIssuesCount: 10,
+        },
+      };
+      mockFetchReturningReadme(null);
+      jest
+        .mocked(fs.readFileSync)
+        .mockReturnValue(YAML.stringify(configWithPreparation));
+
+      const handler = new HandleScheduledEventUseCaseHandler();
+      await handler.handle('config.yml', false);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective maximumPreparingIssuesCount: 10 (source: configFile)',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultLlmModelName: yaml-model (source: configFile)',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultAgentName: yaml-agent (source: configFile)',
+      );
+    });
+
+    it('should log the effective values with readmeOverride source when the README config overrides them', async () => {
+      const readmeContent = `<details>
+<summary>config</summary>
+maximumPreparingIssuesCount: 3
+defaultLlmModelName: readme-model
+defaultAgentName: readme-agent
+</details>`;
+      mockFetchReturningReadme(readmeContent);
+      const configWithPreparation = {
+        ...validConfig,
+        startPreparation: {
+          defaultAgentName: 'yaml-agent',
+          defaultLlmModelName: 'yaml-model',
+          configFilePath: './config.yml',
+          maximumPreparingIssuesCount: 10,
+        },
+      };
+      jest
+        .mocked(fs.readFileSync)
+        .mockReturnValue(YAML.stringify(configWithPreparation));
+
+      const handler = new HandleScheduledEventUseCaseHandler();
+      await handler.handle('config.yml', false);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective maximumPreparingIssuesCount: 3 (source: readmeOverride)',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultLlmModelName: readme-model (source: readmeOverride)',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultAgentName: readme-agent (source: readmeOverride)',
+      );
+    });
+
+    it('should log null with unset (default) source when neither README nor config provides the value', async () => {
+      mockFetchReturningReadme(null);
+      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
+
+      const handler = new HandleScheduledEventUseCaseHandler();
+      await handler.handle('config.yml', false);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective maximumPreparingIssuesCount: null (source: unset (default))',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultLlmModelName: null (source: unset (default))',
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Effective defaultAgentName: null (source: unset (default))',
+      );
+    });
+  });
 });

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

@@ -94,7 +94,9 @@ export class HandleScheduledEventUseCaseHandler {
 
     const managerToken = input.credentials.manager.github.token;
     const readme = await fetchProjectReadme(input.projectUrl, managerToken);
-    const readmeConfig = readme ? parseProjectReadmeConfig(readme) : {};
+    const readmeConfig = readme
+      ? parseProjectReadmeConfig(readme, input.projectUrl)
+      : {};
 
     const mergedInput = {
       ...input,
@@ -137,6 +139,50 @@ export class HandleScheduledEventUseCaseHandler {
         : input.startPreparation,
     };
 
+    type EffectiveConfigValue = string | number | null | undefined;
+
+    const resolveConfigSource = (
+      readmeValue: EffectiveConfigValue,
+      configFileValue: EffectiveConfigValue,
+    ): 'readmeOverride' | 'configFile' | 'unset (default)' => {
+      if (readmeValue !== undefined && readmeValue !== null) {
+        return 'readmeOverride';
+      }
+      if (configFileValue !== undefined && configFileValue !== null) {
+        return 'configFile';
+      }
+      return 'unset (default)';
+    };
+
+    const formatEffectiveConfig = (
+      value: EffectiveConfigValue,
+      readmeValue: EffectiveConfigValue,
+      configFileValue: EffectiveConfigValue,
+    ): string =>
+      `${value ?? 'null'} (source: ${resolveConfigSource(readmeValue, configFileValue)})`;
+
+    console.log(
+      `Effective maximumPreparingIssuesCount: ${formatEffectiveConfig(
+        mergedInput.startPreparation?.maximumPreparingIssuesCount,
+        readmeConfig.maximumPreparingIssuesCount,
+        input.startPreparation?.maximumPreparingIssuesCount,
+      )}`,
+    );
+    console.log(
+      `Effective defaultLlmModelName: ${formatEffectiveConfig(
+        mergedInput.startPreparation?.defaultLlmModelName,
+        readmeConfig.defaultLlmModelName,
+        input.startPreparation?.defaultLlmModelName,
+      )}`,
+    );
+    console.log(
+      `Effective defaultAgentName: ${formatEffectiveConfig(
+        mergedInput.startPreparation?.defaultAgentName,
+        readmeConfig.defaultAgentName,
+        input.startPreparation?.defaultAgentName,
+      )}`,
+    );
+
     const systemDateRepository = new SystemDateRepository();
     const localStorageRepository = new LocalStorageRepository();
     const googleSpreadsheetRepository = new GoogleSpreadsheetRepository(

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

@@ -24,6 +24,38 @@ const mockJsonResponse = <T>(data: T) => ({
   json: jest.fn().mockResolvedValue(data),
 });
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const extractRequestedFirstFromMockCall = (
+  call: unknown,
+): number | undefined => {
+  if (!Array.isArray(call)) {
+    return undefined;
+  }
+  const second: unknown = call[1];
+  if (!isRecord(second)) {
+    return undefined;
+  }
+  const json: unknown = second.json;
+  if (!isRecord(json)) {
+    return undefined;
+  }
+  const variables: unknown = json.variables;
+  if (!isRecord(variables)) {
+    return undefined;
+  }
+  const first: unknown = variables.first;
+  return typeof first === 'number' ? first : undefined;
+};
+
+const extractErrorMessage = (value: unknown): string => {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  return '';
+};
+
 describe('GraphqlProjectItemRepository', () => {
   const makePageResponse = (
     hasNextPage: boolean,
@@ -76,7 +108,7 @@ describe('GraphqlProjectItemRepository', () => {
 
     afterEach(() => {
       jest.useRealTimers();
-      mockPost.mockClear();
+      mockPost.mockReset();
     });
 
     it('should sleep between paginated requests to avoid 403', async () => {
@@ -111,7 +143,7 @@ describe('GraphqlProjectItemRepository', () => {
         'dummy-token',
       );
 
-      mockPost.mockReturnValueOnce(
+      mockPost.mockImplementation(() =>
         mockJsonResponse({
           data: {
             node: {
@@ -148,7 +180,7 @@ describe('GraphqlProjectItemRepository', () => {
 
       await expect(
         repository.fetchProjectItems('test-project-id'),
-      ).rejects.toThrow('GitHub GraphQL errors: RATE_LIMITED');
+      ).rejects.toThrow('GitHub GraphQL errors: [{"message":"RATE_LIMITED"}]');
     });
 
     it('should throw when data is null in response', async () => {
@@ -158,7 +190,7 @@ describe('GraphqlProjectItemRepository', () => {
         'dummy-token',
       );
 
-      mockPost.mockReturnValueOnce(
+      mockPost.mockImplementation(() =>
         mockJsonResponse({
           data: null,
         }),
@@ -176,7 +208,7 @@ describe('GraphqlProjectItemRepository', () => {
         'dummy-token',
       );
 
-      mockPost.mockReturnValueOnce(
+      mockPost.mockImplementation(() =>
         mockJsonResponse({
           data: { node: null },
         }),
@@ -187,7 +219,7 @@ describe('GraphqlProjectItemRepository', () => {
       ).rejects.toThrow('No data returned from GitHub API');
     });
 
-    it('should throw when accumulated nodes count does not match totalCount', async () => {
+    it('should throw when a returned page contains nodes, declares hasNextPage=false, yet totalCount still indicates more items remain', async () => {
       const localStorageRepository = new LocalStorageRepository();
       const repository = new GraphqlProjectItemRepository(
         localStorageRepository,
@@ -231,7 +263,7 @@ describe('GraphqlProjectItemRepository', () => {
       await expect(
         repository.fetchProjectItems('test-project-id'),
       ).rejects.toThrow(
-        'fetchProjectItems: expected 5 items but accumulated 1',
+        'fetchProjectItems: page 1 has 1 nodes with hasNextPage=false but only 1/5 items accumulated',
       );
     });
 
@@ -287,6 +319,103 @@ describe('GraphqlProjectItemRepository', () => {
       );
       setTimeoutSpy.mockRestore();
     });
+
+    it('should stringify full response errors payload including extensions when callGraphql throws', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost.mockImplementation(() =>
+        mockJsonResponse({
+          errors: [
+            {
+              message: 'Something went wrong while executing your query.',
+              path: ['node', 'items', 'nodes', 7, 'id'],
+              locations: [{ line: 11, column: 11 }],
+              extensions: { code: 'INTERNAL' },
+            },
+          ],
+        }),
+      );
+
+      let capturedError: unknown = null;
+      await expect(
+        repository
+          .fetchProjectItems('test-project-id')
+          .catch((error: unknown) => {
+            capturedError = error;
+            throw error;
+          }),
+      ).rejects.toThrow(/^GitHub GraphQL errors: /);
+      expect(capturedError).toBeInstanceOf(Error);
+      const message = extractErrorMessage(capturedError);
+      expect(message).toContain('"extensions":{"code":"INTERNAL"}');
+      expect(message).toContain('"path":["node","items","nodes",7,"id"]');
+      expect(message).toContain('"locations":[{"line":11,"column":11}]');
+    });
+
+    it('should fall back to half the page size when first=50 fails and first=25 succeeds', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      const failingResponse = mockJsonResponse({
+        errors: [
+          { message: 'Something went wrong while executing your query.' },
+        ],
+      });
+      const successPageResponse = makePageResponse(false, 'cursor-1', 1);
+
+      mockPost
+        .mockReturnValueOnce(failingResponse)
+        .mockReturnValueOnce(successPageResponse);
+
+      const result = await repository.fetchProjectItems('test-project-id');
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      expect(result).toHaveLength(1);
+      expect(extractRequestedFirstFromMockCall(mockPost.mock.calls[0])).toBe(
+        50,
+      );
+      expect(extractRequestedFirstFromMockCall(mockPost.mock.calls[1])).toBe(
+        25,
+      );
+    });
+
+    it('should exhaust halving down to first=1 and rethrow the stringified errors payload', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost.mockImplementation(() =>
+        mockJsonResponse({
+          errors: [
+            {
+              message: 'Something went wrong while executing your query.',
+              extensions: { code: 'INTERNAL' },
+            },
+          ],
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow(
+        /GitHub GraphQL errors: .*"extensions":\{"code":"INTERNAL"\}.*/,
+      );
+
+      expect(mockPost).toHaveBeenCalledTimes(6);
+      const requestedFirstSeries = mockPost.mock.calls.map((call) =>
+        extractRequestedFirstFromMockCall(call),
+      );
+      expect(requestedFirstSeries).toEqual([50, 25, 12, 6, 3, 1]);
+    });
   });
 
   describe('getProjectItemFields', () => {

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

@@ -20,6 +20,21 @@ export type ProjectItem = {
   }[];
 };
 export const PAGINATION_DELAY_MS = 5000;
+export const FETCH_PROJECT_ITEMS_INITIAL_PAGE_SIZE = 50;
+export const FETCH_PROJECT_ITEMS_GRAPHQL_ERROR_PAYLOAD_MAX_LENGTH = 4000;
+
+const stringifyGraphqlErrorsForLog = (
+  errors: { message: string }[],
+): string => {
+  const serialized = JSON.stringify(errors);
+  if (
+    serialized.length <= FETCH_PROJECT_ITEMS_GRAPHQL_ERROR_PAYLOAD_MAX_LENGTH
+  ) {
+    return serialized;
+  }
+  return `${serialized.slice(0, FETCH_PROJECT_ITEMS_GRAPHQL_ERROR_PAYLOAD_MAX_LENGTH)}...[truncated]`;
+};
+
 export class GraphqlProjectItemRepository extends BaseGitHubRepository {
   fetchItemId = async (
     projectId: string,
@@ -97,10 +112,10 @@ export class GraphqlProjectItemRepository extends BaseGitHubRepository {
   };
   fetchProjectItems = async (projectId: string): Promise<ProjectItem[]> => {
     const graphqlQueryString = `
-query GetProjectItems($projectId: ID!, $after: String) {
+query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
   node(id: $projectId) {
     ... on ProjectV2 {
-      items(first: 100, after: $after) {
+      items(first: $first, after: $after) {
         totalCount
         pageInfo {
           endCursor
@@ -210,6 +225,7 @@ query GetProjectItems($projectId: ID!, $after: String) {
     const callGraphql = async (
       projectId: string,
       after: string | null,
+      first: number,
     ): Promise<{
       node: {
         items: {
@@ -251,6 +267,7 @@ query GetProjectItems($projectId: ID!, $after: String) {
         variables: {
           projectId: projectId,
           after: after,
+          first: first,
         },
       };
       const response = await ky
@@ -301,7 +318,7 @@ query GetProjectItems($projectId: ID!, $after: String) {
         }>();
       if (response.errors && response.errors.length > 0) {
         throw new Error(
-          `GitHub GraphQL errors: ${response.errors.map((e) => e.message).join('; ')}`,
+          `GitHub GraphQL errors: ${stringifyGraphqlErrorsForLog(response.errors)}`,
         );
       }
       const rawData = response.data;
@@ -314,6 +331,65 @@ query GetProjectItems($projectId: ID!, $after: String) {
       }
       return { node: rawNode };
     };
+    const callGraphqlWithHalvingFallback = async (
+      after: string | null,
+    ): Promise<{
+      node: {
+        items: {
+          totalCount: number;
+          pageInfo: {
+            endCursor: string;
+            startCursor: string;
+            hasNextPage: boolean;
+          };
+          nodes: {
+            id: string;
+            fieldValues: {
+              nodes: {
+                text: string;
+                number: number;
+                date: string;
+                field: {
+                  name: string;
+                };
+              }[];
+            };
+            content: {
+              repository: { nameWithOwner: string };
+              number: number;
+              title: string;
+              state: string;
+              url: string;
+              createdAt: string;
+              author: { login: string } | null;
+              labels: { nodes: { name: string }[] };
+              assignees: { nodes: { login: string }[] };
+            };
+          }[];
+        };
+      };
+    }> => {
+      let attemptFirst = FETCH_PROJECT_ITEMS_INITIAL_PAGE_SIZE;
+      let lastError: unknown = null;
+      while (attemptFirst >= 1) {
+        try {
+          return await callGraphql(projectId, after, attemptFirst);
+        } catch (error) {
+          lastError = error;
+          if (attemptFirst === 1) {
+            throw error;
+          }
+          const nextFirst = Math.max(1, Math.floor(attemptFirst / 2));
+          console.log(
+            `fetchProjectItems: page request with first=${attemptFirst} failed, halving to first=${nextFirst}: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          attemptFirst = nextFirst;
+        }
+      }
+      throw lastError instanceof Error
+        ? lastError
+        : new Error(String(lastError));
+    };
     const issues: ProjectItem[] = [];
     let after: string | null = null;
     let hasNextPage = true;
@@ -327,7 +403,7 @@ query GetProjectItems($projectId: ID!, $after: String) {
           setTimeout(resolve, PAGINATION_DELAY_MS),
         );
       }
-      const data = await callGraphql(projectId, after);
+      const data = await callGraphqlWithHalvingFallback(after);
       const pageNodes = data.node.items.nodes;
       const pageInfo = data.node.items.pageInfo;
       totalCount = data.node.items.totalCount;
@@ -393,7 +469,7 @@ query GetProjectItems($projectId: ID!, $after: String) {
         });
       });
       if (
-        pageNodes.length === 100 &&
+        pageNodes.length > 0 &&
         !pageInfo.hasNextPage &&
         cumulativeRawNodes < totalCount
       ) {