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

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

@@ -109,27 +109,7 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
   }
 };
 
-export const knownProjectReadmeConfigKeys: readonly string[] = [
-  'defaultAgentName',
-  'defaultLlmModelName',
-  'defaultLlmAgentName',
-  'maximumPreparingIssuesCount',
-  'allowIssueCacheMinutes',
-  'utilizationPercentageThreshold',
-  'allowedIssueAuthors',
-  'thresholdForAutoReject',
-  'workflowBlockerResolvedWebhookUrl',
-  'preparationProcessCheckCommand',
-  'codexHomeCandidates',
-  'claudeCodeOauthTokenListJsonPath',
-  'awLogDirectoryPath',
-  'awLogStaleThresholdMinutes',
-];
-
-export const parseProjectReadmeConfig = (
-  readme: string,
-  projectUrl?: string,
-): ConfigFile => {
+export const parseProjectReadmeConfig = (readme: string): ConfigFile => {
   const detailsRegex =
     /<details>\s*<summary>config<\/summary>([\s\S]*?)<\/details>/i;
   const match = detailsRegex.exec(readme);
@@ -145,16 +125,6 @@ export const parseProjectReadmeConfig = (
     if (!isRecord(parsed)) {
       return {};
     }
-    const knownKeySet = new Set<string>(knownProjectReadmeConfigKeys);
-    const unknownKeys = Object.keys(parsed).filter(
-      (key) => !knownKeySet.has(key),
-    );
-    const projectUrlSuffix = projectUrl ? ` (project: ${projectUrl})` : '';
-    for (const unknownKey of unknownKeys) {
-      console.warn(
-        `Unknown key "${unknownKey}" in project README config section${projectUrlSuffix}`,
-      );
-    }
     return {
       defaultAgentName: getStringValue(parsed, 'defaultAgentName'),
       defaultLlmModelName: getStringValue(parsed, 'defaultLlmModelName'),

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

@@ -457,98 +457,4 @@ 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,9 +94,7 @@ export class HandleScheduledEventUseCaseHandler {
 
     const managerToken = input.credentials.manager.github.token;
     const readme = await fetchProjectReadme(input.projectUrl, managerToken);
-    const readmeConfig = readme
-      ? parseProjectReadmeConfig(readme, input.projectUrl)
-      : {};
+    const readmeConfig = readme ? parseProjectReadmeConfig(readme) : {};
 
     const mergedInput = {
       ...input,
@@ -139,50 +137,6 @@ 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/proxy/RateLimitCache.test.ts

@@ -280,6 +280,129 @@ describe('RateLimitCache', () => {
     });
   });
 
+  describe('writeRateLimit preserves previous values when response has no anthropic-ratelimit-* headers', () => {
+    it('should not write any file when no previous cache exists and headers contain no anthropic-ratelimit-*', () => {
+      const token = '429-no-headers-no-prior-token';
+      writeRateLimit(token, {
+        'content-type': 'application/json',
+      });
+      expect(fs.existsSync(cachePathForToken(token))).toBe(false);
+      expect(readRateLimit(token)).toBeNull();
+    });
+
+    it('should preserve the previous cache when a later response carries no anthropic-ratelimit-* headers (429 without headers)', () => {
+      const token = '429-no-headers-with-prior-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '42',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '17',
+      });
+      const beforeContent = fs.readFileSync(cachePathForToken(token), 'utf8');
+      writeRateLimit(token, {
+        'content-type': 'application/json',
+        'anthropic-organization-id': 'org-1',
+      });
+      const afterContent = fs.readFileSync(cachePathForToken(token), 'utf8');
+      expect(afterContent).toBe(beforeContent);
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.fiveHourUtilization).toBe(42);
+      expect(snapshot?.fiveHourReset).toBe(1700000000);
+      expect(snapshot?.sevenDayUtilization).toBe(17);
+      expect(snapshot?.sevenDayReset).toBe(1700100000);
+      expect(snapshot?.unifiedRejected).toBe(false);
+      expect(snapshot?.fiveHourRejected).toBe(false);
+      expect(snapshot?.sevenDayRejected).toBe(false);
+      expect(snapshot?.blocked).toBe(false);
+      expect(snapshot?.rejected).toBe(false);
+    });
+
+    it('should overwrite the previous cache when the response carries anthropic-ratelimit-* headers regardless of status code (429 with headers)', () => {
+      const token = '429-with-headers-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '42',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '17',
+      });
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-reset': '1700050000',
+        'anthropic-ratelimit-unified-5h-utilization': '100',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '60',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.unifiedRejected).toBe(true);
+      expect(snapshot?.fiveHourRejected).toBe(true);
+      expect(snapshot?.fiveHourUtilization).toBe(100);
+      expect(snapshot?.fiveHourReset).toBe(1700050000);
+      expect(snapshot?.sevenDayUtilization).toBe(60);
+    });
+
+    it('should overwrite the previous cache when a 200 response carries anthropic-ratelimit-* headers (200 with headers)', () => {
+      const token = '200-with-headers-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '100',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '60',
+      });
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700050000',
+        'anthropic-ratelimit-unified-5h-utilization': '30',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '20',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.unifiedRejected).toBe(false);
+      expect(snapshot?.fiveHourRejected).toBe(false);
+      expect(snapshot?.fiveHourUtilization).toBe(30);
+      expect(snapshot?.fiveHourReset).toBe(1700050000);
+      expect(snapshot?.sevenDayUtilization).toBe(20);
+      expect(snapshot?.rejected).toBe(false);
+    });
+
+    it('should not modify any header value based on response status code', () => {
+      const token = 'no-status-based-mutation-token';
+      const inputHeaders: Record<string, string> = {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '42',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '17',
+      };
+      writeRateLimit(token, inputHeaders);
+      const raw: unknown = JSON.parse(
+        fs.readFileSync(cachePathForToken(token), 'utf8'),
+      );
+      const isRecord = (value: unknown): value is Record<string, unknown> =>
+        value !== null && typeof value === 'object' && !Array.isArray(value);
+      if (!isRecord(raw) || !isRecord(raw.headers)) {
+        throw new Error('expected stored cache to contain headers object');
+      }
+      for (const [key, expectedValue] of Object.entries(inputHeaders)) {
+        expect(raw.headers[key]).toBe(expectedValue);
+      }
+    });
+  });
+
   describe('parseModelRateLimitsFromBody', () => {
     it('should extract a rejected seven_day_sonnet limit from a rate_limit event body', () => {
       const body =

package/src/adapter/proxy/RateLimitCache.ts

@@ -71,17 +71,11 @@ export const writeRateLimit = (
   token: string,
   headers: Record<string, string | string[] | undefined>,
 ): void => {
-  const dir = cacheDir();
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
   const pick = (key: string): string | undefined => {
     const value = headers[key];
     if (Array.isArray(value)) return value[0];
     return value;
   };
-  const filePath = path.join(dir, `${hashToken(token)}.json`);
-  const existing = readPayload(filePath);
   const rateLimitHeaders: Record<string, string> = {};
   for (const key of Object.keys(headers)) {
     if (key.startsWith('anthropic-ratelimit-')) {
@@ -91,6 +85,15 @@ export const writeRateLimit = (
       }
     }
   }
+  if (Object.keys(rateLimitHeaders).length === 0) {
+    return;
+  }
+  const dir = cacheDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = path.join(dir, `${hashToken(token)}.json`);
+  const existing = readPayload(filePath);
   const payload = {
     ts: Date.now() / 1000,
     headers: rateLimitHeaders,