github-issue-tower-defence-management 2.10.1 → 2.11.0

package/src/adapter/entry-points/cli/fleetConfig.test.ts

@@ -242,9 +242,108 @@ describe('loadPreparationWorkerSettings', () => {
 
     expect(loadPreparationWorkerSettings(fleetConfigFilePath)).toEqual({
       normalConcurrentLimit: 10,
+      maxConcurrentWorkers:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.maxConcurrentWorkers,
+      graphqlRateLimitFloor:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.graphqlRateLimitFloor,
     });
   });
 
+  it('reads maxConcurrentWorkers from the fleet config file', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  maxConcurrentWorkers: 25'].join('\n'),
+    );
+
+    expect(loadPreparationWorkerSettings(fleetConfigFilePath)).toEqual({
+      normalConcurrentLimit:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.normalConcurrentLimit,
+      maxConcurrentWorkers: 25,
+      graphqlRateLimitFloor:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.graphqlRateLimitFloor,
+    });
+  });
+
+  it('reads graphqlRateLimitFloor from the fleet config file', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  graphqlRateLimitFloor: 300'].join('\n'),
+    );
+
+    expect(loadPreparationWorkerSettings(fleetConfigFilePath)).toEqual({
+      normalConcurrentLimit:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.normalConcurrentLimit,
+      maxConcurrentWorkers:
+        DEFAULT_PREPARATION_WORKER_SETTINGS.maxConcurrentWorkers,
+      graphqlRateLimitFloor: 300,
+    });
+  });
+
+  it('reads all three worker settings from the fleet config file', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      [
+        'preparationWorker:',
+        '  normalConcurrentLimit: 10',
+        '  maxConcurrentWorkers: 60',
+        '  graphqlRateLimitFloor: 200',
+      ].join('\n'),
+    );
+
+    expect(loadPreparationWorkerSettings(fleetConfigFilePath)).toEqual({
+      normalConcurrentLimit: 10,
+      maxConcurrentWorkers: 60,
+      graphqlRateLimitFloor: 200,
+    });
+  });
+
+  it('throws when maxConcurrentWorkers is zero', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  maxConcurrentWorkers: 0'].join('\n'),
+    );
+
+    expect(() => loadPreparationWorkerSettings(fleetConfigFilePath)).toThrow(
+      'maxConcurrentWorkers',
+    );
+  });
+
+  it('throws when maxConcurrentWorkers is not an integer', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  maxConcurrentWorkers: 10.5'].join('\n'),
+    );
+
+    expect(() => loadPreparationWorkerSettings(fleetConfigFilePath)).toThrow(
+      'maxConcurrentWorkers',
+    );
+  });
+
+  it('accepts graphqlRateLimitFloor of zero', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  graphqlRateLimitFloor: 0'].join('\n'),
+    );
+
+    expect(loadPreparationWorkerSettings(fleetConfigFilePath)).toMatchObject({
+      graphqlRateLimitFloor: 0,
+    });
+  });
+
+  it('throws when graphqlRateLimitFloor is negative', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  graphqlRateLimitFloor: -1'].join('\n'),
+    );
+
+    expect(() => loadPreparationWorkerSettings(fleetConfigFilePath)).toThrow(
+      'graphqlRateLimitFloor',
+    );
+  });
+
+  it('throws when graphqlRateLimitFloor is not an integer', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['preparationWorker:', '  graphqlRateLimitFloor: 100.5'].join('\n'),
+    );
+
+    expect(() => loadPreparationWorkerSettings(fleetConfigFilePath)).toThrow(
+      'graphqlRateLimitFloor',
+    );
+  });
+
   it('keeps the built-in value when the preparationWorker section is absent', () => {
     const fleetConfigFilePath = writeFleetConfig('inTmuxLauncherCommand: cl\n');
 

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

@@ -15,12 +15,19 @@ export const START_PREPARATION_SECTION_KEY = 'startPreparation';
 
 export const DEFAULT_FLEET_MAXIMUM_PREPARING_ISSUES_COUNT = 80;
 
+export const DEFAULT_MAX_CONCURRENT_WORKERS = 40;
+export const DEFAULT_GRAPHQL_RATE_LIMIT_FLOOR = 500;
+
 export type PreparationWorkerSettings = {
   normalConcurrentLimit: number;
+  maxConcurrentWorkers: number;
+  graphqlRateLimitFloor: number;
 };
 
 export const DEFAULT_PREPARATION_WORKER_SETTINGS: PreparationWorkerSettings = {
   normalConcurrentLimit: NORMAL_CONCURRENT_LIMIT,
+  maxConcurrentWorkers: DEFAULT_MAX_CONCURRENT_WORKERS,
+  graphqlRateLimitFloor: DEFAULT_GRAPHQL_RATE_LIMIT_FLOOR,
 };
 
 export type StartPreparationFleetSettings = {
@@ -178,6 +185,24 @@ export const loadPreparationWorkerSettings = (
       (value) => Number.isInteger(value) && value >= 1,
       'integer of at least 1',
     ),
+    maxConcurrentWorkers: readBoundedNumber(
+      section,
+      PREPARATION_WORKER_SECTION_KEY,
+      'maxConcurrentWorkers',
+      fleetConfigFilePath,
+      DEFAULT_PREPARATION_WORKER_SETTINGS.maxConcurrentWorkers,
+      (value) => Number.isInteger(value) && value >= 1,
+      'integer of at least 1',
+    ),
+    graphqlRateLimitFloor: readBoundedNumber(
+      section,
+      PREPARATION_WORKER_SECTION_KEY,
+      'graphqlRateLimitFloor',
+      fleetConfigFilePath,
+      DEFAULT_PREPARATION_WORKER_SETTINGS.graphqlRateLimitFloor,
+      (value) => Number.isInteger(value) && value >= 0,
+      'non-negative integer',
+    ),
   };
 };
 

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

@@ -801,6 +801,8 @@ mysteryKey: 'value'
         labelsAsLlmAgentName: null,
         agents: null,
         normalConcurrentLimit: 6,
+        maxConcurrentWorkers: 40,
+        graphqlRateLimitFloor: 500,
       });
     });
 
@@ -876,6 +878,8 @@ mysteryKey: 'value'
         labelsAsLlmAgentName: null,
         agents: null,
         normalConcurrentLimit: 6,
+        maxConcurrentWorkers: 40,
+        graphqlRateLimitFloor: 500,
       });
     });
 

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

@@ -34,6 +34,7 @@ import { projectCacheDirectory } from '../../repositories/localStorageCacheDirec
 import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
 import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
 import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwnershipSpawnRepository';
+import { CliGitHubGraphqlRateLimitRepository } from '../../repositories/CliGitHubGraphqlRateLimitRepository';
 import { DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP } from '../../../domain/usecases/resolveNextStepAgentDispatchRepetition';
 import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
 import { SystemDateRepository } from '../../repositories/SystemDateRepository';
@@ -324,7 +325,7 @@ program
   )
   .option(
     '--fleetConfigFilePath <path>',
-    'Path to the fleet-wide YAML config file holding the preparationWorker mapping (normalConcurrentLimit); falls back to the TDPM_FLEET_CONFIG environment variable, and to the built-in values when neither is set',
+    'Path to the fleet-wide YAML config file holding the preparationWorker mapping (normalConcurrentLimit, maxConcurrentWorkers, graphqlRateLimitFloor); falls back to the TDPM_FLEET_CONFIG environment variable, and to the built-in values when neither is set',
   )
   .action(async (options: StartDaemonOptions) => {
     const token = process.env.GH_TOKEN;
@@ -423,8 +424,18 @@ program
     );
     const preparationWorkerSettings =
       loadPreparationWorkerSettings(fleetConfigFilePath);
+    const fleetConfigSource =
+      fleetConfigFilePath !== null
+        ? ' (source: fleetConfig)'
+        : ' (source: built-in default)';
     console.log(
-      `Effective normalConcurrentLimit: ${preparationWorkerSettings.normalConcurrentLimit}${fleetConfigFilePath !== null ? ' (source: fleetConfig)' : ' (source: built-in default)'}`,
+      `Effective normalConcurrentLimit: ${preparationWorkerSettings.normalConcurrentLimit}${fleetConfigSource}`,
+    );
+    console.log(
+      `Effective maxConcurrentWorkers: ${preparationWorkerSettings.maxConcurrentWorkers}${fleetConfigSource}`,
+    );
+    console.log(
+      `Effective graphqlRateLimitFloor: ${preparationWorkerSettings.graphqlRateLimitFloor}${fleetConfigSource}`,
     );
 
     const projectName = config.projectName ?? 'default';
@@ -496,6 +507,7 @@ program
       localCommandRunner,
       claudeTokenUsageRepository,
       new ProcTakeOwnershipSpawnRepository(),
+      new CliGitHubGraphqlRateLimitRepository(localCommandRunner),
     );
 
     const rawAllowedIssueAuthors = config.allowedIssueAuthors;
@@ -545,6 +557,8 @@ program
       labelsAsLlmAgentName: config.labelsAsLlmAgentName ?? null,
       agents: config.agents ?? null,
       normalConcurrentLimit: preparationWorkerSettings.normalConcurrentLimit,
+      maxConcurrentWorkers: preparationWorkerSettings.maxConcurrentWorkers,
+      graphqlRateLimitFloor: preparationWorkerSettings.graphqlRateLimitFloor,
     });
     if (preparationResult.rotationOrder !== null) {
       writeRotationOrderFile(preparationResult.rotationOrder);

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -625,6 +625,7 @@ const createStubIssueRepository = (
         }
       : null,
   setIssueAgentField: async (): Promise<void> => undefined,
+  updateBranch: async (): Promise<boolean> => false,
   updateStoryOptionColor: async (
     _project,
     storyOptionId: string,

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

@@ -68,6 +68,7 @@ import { UpdateIssueStatusByLabelUseCase } from '../../../domain/usecases/Update
 import { IssueNoStatusUpdateUseCase } from '../../../domain/usecases/IssueNoStatusUpdateUseCase';
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
 import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
+import { CliGitHubGraphqlRateLimitRepository } from '../../repositories/CliGitHubGraphqlRateLimitRepository';
 import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwnershipSpawnRepository';
 import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
 import { ProxyRateLimitCacheRepository } from '../../repositories/ProxyRateLimitCacheRepository';
@@ -499,6 +500,7 @@ export class HandleScheduledEventUseCaseHandler {
       nodeLocalCommandRunner,
       claudeTokenUsageRepository,
       new ProcTakeOwnershipSpawnRepository(),
+      new CliGitHubGraphqlRateLimitRepository(nodeLocalCommandRunner),
     );
     const proxyRateLimitCacheRepository = new ProxyRateLimitCacheRepository(
       mergedInput.claudeCodeOauthTokenListJsonPath ?? null,

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

@@ -0,0 +1,71 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { CliGitHubGraphqlRateLimitRepository } from './CliGitHubGraphqlRateLimitRepository';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+describe('CliGitHubGraphqlRateLimitRepository', () => {
+  let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
+  let repository: CliGitHubGraphqlRateLimitRepository;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    mockLocalCommandRunner = {
+      runCommand: jest.fn(),
+      spawnInteractive: jest.fn(),
+    };
+    repository = new CliGitHubGraphqlRateLimitRepository(
+      mockLocalCommandRunner,
+    );
+  });
+
+  it('returns the remaining GraphQL request count when gh succeeds', async () => {
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '4873\n',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const result = await repository.getRemainingRequestCount();
+
+    expect(result).toBe(4873);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toEqual([
+      ['gh', ['api', 'rate_limit', '--jq', '.resources.graphql.remaining']],
+    ]);
+  });
+
+  it('returns null when gh exits with a non-zero code', async () => {
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: 'error: authentication required',
+      exitCode: 1,
+    });
+
+    const result = await repository.getRemainingRequestCount();
+
+    expect(result).toBeNull();
+  });
+
+  it('returns null when the output is not a valid integer', async () => {
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: 'not-a-number\n',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const result = await repository.getRemainingRequestCount();
+
+    expect(result).toBeNull();
+  });
+
+  it('returns zero when the remaining count is zero', async () => {
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '0\n',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const result = await repository.getRemainingRequestCount();
+
+    expect(result).toBe(0);
+  });
+});

package/src/adapter/repositories/CliGitHubGraphqlRateLimitRepository.ts

@@ -0,0 +1,21 @@
+import { GitHubGraphqlRateLimitRepository } from '../../domain/usecases/adapter-interfaces/GitHubGraphqlRateLimitRepository';
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+
+export class CliGitHubGraphqlRateLimitRepository implements GitHubGraphqlRateLimitRepository {
+  constructor(private readonly localCommandRunner: LocalCommandRunner) {}
+
+  getRemainingRequestCount = async (): Promise<number | null> => {
+    const result = await this.localCommandRunner.runCommand('gh', [
+      'api',
+      'rate_limit',
+      '--jq',
+      '.resources.graphql.remaining',
+    ]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const trimmed = result.stdout.trim();
+    const parsed = Number(trimmed);
+    return trimmed !== '' && Number.isInteger(parsed) ? parsed : null;
+  };
+}

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

@@ -1,8 +1,56 @@
 import dotenv from 'dotenv';
-import { KySlackRepository } from './KySlackRepository';
 import fs from 'fs';
 import https from 'https';
 import path from 'path';
+import { KySlackRepository } from './KySlackRepository';
+
+describe('KySlackRepository', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe('postMessageToDirectMessage', () => {
+    it('does not hang on 429 Retry-After responses from Slack', async () => {
+      jest.useFakeTimers();
+
+      jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response('{"ok":false}', {
+          status: 429,
+          headers: { 'Retry-After': '30' },
+        }),
+      );
+
+      const slackRepository = new KySlackRepository('xoxp-test-token-unit');
+
+      // Attach .catch() immediately to prevent unhandled rejection when the
+      // promise rejects during jest.advanceTimersByTimeAsync below.
+      const settledValue: { value: unknown } = { value: 'not-yet-settled' };
+      slackRepository
+        .postMessageToDirectMessage('test message', 'non-existent-user')
+        .then(() => {
+          settledValue.value = 'resolved';
+        })
+        .catch((e: unknown) => {
+          settledValue.value = e;
+        });
+
+      // Advance 60 seconds of fake time.
+      // With maxRetryAfter bounded (e.g. 10s), all 3 retry delays (3×10s=30s) fire
+      // within this window, exhausting retries and settling the promise.
+      // With the default maxRetryAfter=INFINITY, only 2 of 3 delays fire (2×30s=60s),
+      // leaving the promise pending — causing CI to hang for the full Jest timeout.
+      await jest.advanceTimersByTimeAsync(60000);
+      jest.clearAllTimers();
+      jest.useRealTimers();
+
+      // Drain microtasks so the .then()/.catch() callbacks above have run.
+      await Promise.resolve();
+
+      expect(settledValue.value).not.toBe('not-yet-settled');
+    }, 5000);
+  });
+});
 
 dotenv.config();
 

package/src/adapter/repositories/KySlackRepository.ts

@@ -1,6 +1,6 @@
-import ky from 'ky';
 import fs from 'fs';
-import { SlackRepository } from '../../domain/usecases/adapter-interfaces/SlackRepository';
+import ky from 'ky';
+import type { SlackRepository } from '../../domain/usecases/adapter-interfaces/SlackRepository';
 
 type ConversationsListResponse = {
   ok: boolean;
@@ -87,6 +87,7 @@ export class KySlackRepository implements SlackRepository {
         limit: 3,
         methods: ['get', 'post'],
         statusCodes: [429, 500, 502, 503, 504],
+        maxRetryAfter: 10000,
       },
     });
   }

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

@@ -2786,6 +2786,30 @@ export class ApiV3CheerioRestIssueRepository
     return `${status} ${reason}`;
   };
 
+  updateBranch = async (prUrl: string): Promise<boolean> => {
+    const { owner, repo, issueNumber: prNumber } = this.parseIssueUrl(prUrl);
+    const response = await this.fetchWithRateLimitRetry(() =>
+      fetch(
+        `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${prNumber}/update-branch`,
+        {
+          method: 'PUT',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      ),
+    );
+    if (response.ok) {
+      return true;
+    }
+    if (response.status === 422) {
+      return false;
+    }
+    const reason = await this.formatGitHubErrorWithStatus(response);
+    throw new Error(`Failed to update branch for PR ${prUrl}: ${reason}`);
+  };
+
   deletePullRequestBranch = async (
     prUrl: string,
     branchName: string,