github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/domain/usecases/dashboard/GenerateTokenStatusUseCase.test.ts

@@ -1,362 +0,0 @@
-import {
-  GenerateTokenStatusUseCase,
-  TokenRateLimitDecision,
-  TokenRateLimitSnapshot,
-  TokenStatus,
-  computeSevenDayWindowAggregate,
-  judgeTokenColor,
-} from './GenerateTokenStatusUseCase';
-
-const usableDecision = (
-  overrides: Partial<TokenRateLimitDecision> = {},
-): TokenRateLimitDecision => ({
-  fiveHourUtilization: 0.1,
-  sevenDayUtilization: 0.1,
-  fiveHourRejected: false,
-  sevenDayRejected: false,
-  blocked: false,
-  unifiedStatus: 'allowed',
-  sevenDaySonnetRejected: false,
-  sevenDayOpusRejected: false,
-  partial: false,
-  subscriptionDisabled: false,
-  ...overrides,
-});
-
-describe('judgeTokenColor', () => {
-  it('returns Y when there is no snapshot or the snapshot is partial', () => {
-    expect(judgeTokenColor(null)).toBe('Y');
-    expect(judgeTokenColor(usableDecision({ partial: true }))).toBe('Y');
-  });
-
-  it('returns G for a normal allowed low-utilization token', () => {
-    expect(judgeTokenColor(usableDecision())).toBe('G');
-  });
-
-  it('returns R when the subscription is disabled, whatever the utilization says', () => {
-    expect(
-      judgeTokenColor(usableDecision({ subscriptionDisabled: true })),
-    ).toBe('R');
-    expect(
-      judgeTokenColor(
-        usableDecision({
-          subscriptionDisabled: true,
-          unifiedStatus: 'allowed_warning',
-          fiveHourUtilization: 0.9,
-        }),
-      ),
-    ).toBe('R');
-  });
-
-  it('returns Y for high utilization while allowed', () => {
-    expect(judgeTokenColor(usableDecision({ fiveHourUtilization: 0.8 }))).toBe(
-      'Y',
-    );
-  });
-
-  it('keeps a token usable (G) when only Sonnet 7d is rejected but Opus is usable', () => {
-    expect(
-      judgeTokenColor(
-        usableDecision({
-          sevenDaySonnetRejected: true,
-          sevenDayOpusRejected: false,
-        }),
-      ),
-    ).toBe('G');
-  });
-
-  it('returns Y when Sonnet is rejected, Opus usable, and 7d utilization is high', () => {
-    expect(
-      judgeTokenColor(
-        usableDecision({
-          sevenDaySonnetRejected: true,
-          sevenDayOpusRejected: false,
-          sevenDayUtilization: 0.8,
-        }),
-      ),
-    ).toBe('Y');
-  });
-
-  it('returns K when both Sonnet and Opus 7d are rejected', () => {
-    expect(
-      judgeTokenColor(
-        usableDecision({
-          sevenDaySonnetRejected: true,
-          sevenDayOpusRejected: true,
-        }),
-      ),
-    ).toBe('K');
-  });
-
-  it('returns K when the general 7d window is rejected', () => {
-    expect(judgeTokenColor(usableDecision({ sevenDayRejected: true }))).toBe(
-      'K',
-    );
-  });
-
-  it('returns K when the 5h window is rejected', () => {
-    expect(judgeTokenColor(usableDecision({ fiveHourRejected: true }))).toBe(
-      'K',
-    );
-  });
-
-  it('returns K when 5h utilization is exhausted', () => {
-    expect(judgeTokenColor(usableDecision({ fiveHourUtilization: 1.0 }))).toBe(
-      'K',
-    );
-  });
-
-  it('returns Y for the allowed_warning unified status', () => {
-    expect(
-      judgeTokenColor(usableDecision({ unifiedStatus: 'allowed_warning' })),
-    ).toBe('Y');
-  });
-});
-
-const snapshot = (
-  overrides: Partial<TokenRateLimitSnapshot> = {},
-): TokenRateLimitSnapshot => ({
-  fiveHourUtilization: 0.1,
-  fiveHourReset: 0,
-  sevenDayUtilization: 0.1,
-  sevenDayReset: 0,
-  blocked: false,
-  fiveHourRejected: false,
-  sevenDayRejected: false,
-  unifiedStatus: 'allowed',
-  sevenDaySonnetRejected: false,
-  sevenDayOpusRejected: false,
-  hasWindowData: true,
-  lastUpdatedEpoch: 1_000_000,
-  subscriptionDisabled: false,
-  ...overrides,
-});
-
-describe('GenerateTokenStatusUseCase', () => {
-  const usecase = new GenerateTokenStatusUseCase();
-  const now = 1_000_000;
-
-  it('renders per-token utilization percents, color, prep and hum counts', () => {
-    const result = usecase.run({
-      tokens: [
-        {
-          name: 'alice',
-          token: 'token-a',
-          snapshot: snapshot({
-            fiveHourUtilization: 0.42,
-            fiveHourReset: now + 3600,
-            sevenDayUtilization: 0.8,
-            sevenDayReset: now + 86400,
-          }),
-        },
-        { name: 'bob', token: 'token-b', snapshot: null },
-      ],
-      prepCountByToken: new Map([['token-a', 2]]),
-      humCountByToken: new Map([['token-a', 1]]),
-      nowEpochSeconds: now,
-    });
-
-    expect(result).toEqual([
-      {
-        name: 'alice',
-        fiveHourUtilizationPercent: 42,
-        fiveHourResetSeconds: 3600,
-        sevenDayUtilizationPercent: 80,
-        sevenDayResetSeconds: 86400,
-        color: 'Y',
-        prep: 2,
-        hum: 1,
-      },
-      {
-        name: 'bob',
-        fiveHourUtilizationPercent: null,
-        fiveHourResetSeconds: null,
-        sevenDayUtilizationPercent: null,
-        sevenDayResetSeconds: null,
-        color: 'Y',
-        prep: 0,
-        hum: 0,
-      },
-    ]);
-  });
-
-  it('reports G for an allowed token with headroom on both windows', () => {
-    const result = usecase.run({
-      tokens: [
-        {
-          name: 'alice',
-          token: 'token-a',
-          snapshot: snapshot({
-            fiveHourUtilization: 0.1,
-            fiveHourReset: now + 3600,
-            sevenDayUtilization: 0.1,
-            sevenDayReset: now + 86400,
-          }),
-        },
-      ],
-      prepCountByToken: new Map(),
-      humCountByToken: new Map(),
-      nowEpochSeconds: now,
-    });
-
-    expect(result[0].color).toBe('G');
-  });
-
-  it('zeroes a window whose reset is already in the past and clears its rejection', () => {
-    const result = usecase.run({
-      tokens: [
-        {
-          name: 'alice',
-          token: 'token-a',
-          snapshot: snapshot({
-            fiveHourUtilization: 1.0,
-            fiveHourReset: now - 10,
-            fiveHourRejected: true,
-            sevenDayUtilization: 0.2,
-            sevenDayReset: now + 86400,
-          }),
-        },
-      ],
-      prepCountByToken: new Map(),
-      humCountByToken: new Map(),
-      nowEpochSeconds: now,
-    });
-
-    expect(result[0].fiveHourUtilizationPercent).toBe(0);
-    expect(result[0].fiveHourResetSeconds).toBe(0);
-    expect(result[0].color).toBe('G');
-  });
-});
-
-describe('computeSevenDayWindowAggregate', () => {
-  const tokenStatus = (
-    sevenDayUtilizationPercent: number | null,
-    name: string,
-  ): TokenStatus => ({
-    name,
-    fiveHourUtilizationPercent: null,
-    fiveHourResetSeconds: null,
-    sevenDayUtilizationPercent,
-    sevenDayResetSeconds: null,
-    color: 'G',
-    prep: 0,
-    hum: 0,
-  });
-
-  it('averages the seven day utilization of every token when all values are present', () => {
-    expect(
-      computeSevenDayWindowAggregate([
-        tokenStatus(60, 'alice'),
-        tokenStatus(64, 'bob'),
-        tokenStatus(65, 'carol'),
-      ]),
-    ).toEqual({
-      usedPercent: 63,
-      includedTokenCount: 3,
-      totalTokenCount: 3,
-    });
-  });
-
-  it('excludes tokens without a value from both numerator and denominator', () => {
-    expect(
-      computeSevenDayWindowAggregate([
-        tokenStatus(80, 'alice'),
-        tokenStatus(null, 'bob'),
-        tokenStatus(40, 'carol'),
-        tokenStatus(null, 'dave'),
-      ]),
-    ).toEqual({
-      usedPercent: 60,
-      includedTokenCount: 2,
-      totalTokenCount: 4,
-    });
-  });
-
-  it('keeps the fractional mean so the presentation layer decides the rounding', () => {
-    expect(
-      computeSevenDayWindowAggregate([
-        tokenStatus(63, 'alice'),
-        tokenStatus(64, 'bob'),
-      ]),
-    ).toEqual({
-      usedPercent: 63.5,
-      includedTokenCount: 2,
-      totalTokenCount: 2,
-    });
-  });
-
-  it('returns null when no token has a seven day utilization value', () => {
-    expect(
-      computeSevenDayWindowAggregate([
-        tokenStatus(null, 'alice'),
-        tokenStatus(null, 'bob'),
-      ]),
-    ).toBeNull();
-  });
-
-  it('returns null when there is no token at all', () => {
-    expect(computeSevenDayWindowAggregate([])).toBeNull();
-  });
-});
-
-describe('GenerateTokenStatusUseCase window rollover inference', () => {
-  const usecase = new GenerateTokenStatusUseCase();
-  const now = 2_000_000;
-
-  const runFor = (
-    snapshotOverrides: Partial<TokenRateLimitSnapshot>,
-  ): TokenStatus =>
-    usecase.run({
-      tokens: [
-        {
-          name: 'alice',
-          token: 'token-a',
-          snapshot: snapshot(snapshotOverrides),
-        },
-      ],
-      prepCountByToken: new Map(),
-      humCountByToken: new Map(),
-      nowEpochSeconds: now,
-    })[0];
-
-  it('keeps the last observed utilization when the snapshot predates the reset it reports', () => {
-    const result = runFor({
-      sevenDayUtilization: 0.98,
-      sevenDayReset: now - 3600,
-      lastUpdatedEpoch: now - 72000,
-    });
-
-    expect(result.sevenDayUtilizationPercent).toBe(98);
-  });
-
-  it('keeps a seven day rejection visible when the snapshot predates the reset it reports', () => {
-    const result = runFor({
-      sevenDayUtilization: 0.98,
-      sevenDayReset: now - 3600,
-      sevenDayRejected: true,
-      lastUpdatedEpoch: now - 72000,
-    });
-
-    expect(result.color).toBe('K');
-  });
-
-  it('reports a rolled over window as unused when the snapshot was captured after that reset', () => {
-    const result = runFor({
-      sevenDayUtilization: 0.98,
-      sevenDayReset: now - 3600,
-      lastUpdatedEpoch: now - 1800,
-    });
-
-    expect(result.sevenDayUtilizationPercent).toBe(0);
-  });
-
-  it('keeps the last observed five hour utilization when the snapshot predates the five hour reset', () => {
-    const result = runFor({
-      fiveHourUtilization: 0.91,
-      fiveHourReset: now - 600,
-      lastUpdatedEpoch: now - 72000,
-    });
-
-    expect(result.fiveHourUtilizationPercent).toBe(91);
-  });
-});

package/src/domain/usecases/dashboard/GenerateTokenStatusUseCase.ts

@@ -1,234 +0,0 @@
-export type TokenStatusColor = 'G' | 'Y' | 'K' | 'R';
-
-export type TokenRateLimitSnapshot = {
-  fiveHourUtilization: number;
-  fiveHourReset: number;
-  sevenDayUtilization: number;
-  sevenDayReset: number;
-  blocked: boolean;
-  fiveHourRejected: boolean;
-  sevenDayRejected: boolean;
-  unifiedStatus: string | null;
-  sevenDaySonnetRejected: boolean;
-  sevenDayOpusRejected: boolean;
-  hasWindowData: boolean;
-  lastUpdatedEpoch: number;
-  subscriptionDisabled: boolean;
-};
-
-export type TokenRateLimitDecision = {
-  subscriptionDisabled: boolean;
-  fiveHourUtilization: number | null;
-  sevenDayUtilization: number | null;
-  fiveHourRejected: boolean;
-  sevenDayRejected: boolean;
-  blocked: boolean;
-  unifiedStatus: string | null;
-  sevenDaySonnetRejected: boolean;
-  sevenDayOpusRejected: boolean;
-  partial: boolean;
-};
-
-export type TokenStatus = {
-  name: string;
-  fiveHourUtilizationPercent: number | null;
-  fiveHourResetSeconds: number | null;
-  sevenDayUtilizationPercent: number | null;
-  sevenDayResetSeconds: number | null;
-  color: TokenStatusColor;
-  prep: number;
-  hum: number;
-};
-
-export type SevenDayWindowAggregate = {
-  usedPercent: number;
-  includedTokenCount: number;
-  totalTokenCount: number;
-};
-
-export type TokenStatusInput = {
-  name: string;
-  token: string;
-  snapshot: TokenRateLimitSnapshot | null;
-};
-
-export type GenerateTokenStatusInput = {
-  tokens: TokenStatusInput[];
-  prepCountByToken: Map<string, number>;
-  humCountByToken: Map<string, number>;
-  nowEpochSeconds: number;
-};
-
-const HIGH_UTILIZATION_THRESHOLD = 0.7;
-const ALLOWED_WARNING_STATUS = 'allowed_warning';
-
-export const judgeTokenColor = (
-  decision: TokenRateLimitDecision | null,
-): TokenStatusColor => {
-  if (decision !== null && decision.subscriptionDisabled) {
-    return 'R';
-  }
-  if (decision === null || decision.partial) {
-    return 'Y';
-  }
-  const fiveHourUtilization = decision.fiveHourUtilization ?? 0;
-  const sevenDayUtilization = decision.sevenDayUtilization ?? 0;
-  const fiveHourExhausted =
-    fiveHourUtilization >= 1.0 || decision.fiveHourRejected;
-  const generalSevenDayRejected = decision.sevenDayRejected;
-  const bothModelsSevenDayRejected =
-    decision.sevenDaySonnetRejected && decision.sevenDayOpusRejected;
-  const noModelUsable =
-    decision.blocked ||
-    fiveHourExhausted ||
-    generalSevenDayRejected ||
-    bothModelsSevenDayRejected;
-  if (noModelUsable) {
-    return 'K';
-  }
-  if (decision.unifiedStatus === ALLOWED_WARNING_STATUS) {
-    return 'Y';
-  }
-  if (
-    fiveHourUtilization >= HIGH_UTILIZATION_THRESHOLD ||
-    sevenDayUtilization >= HIGH_UTILIZATION_THRESHOLD
-  ) {
-    return 'Y';
-  }
-  return 'G';
-};
-
-export const computeSevenDayWindowAggregate = (
-  tokens: TokenStatus[],
-): SevenDayWindowAggregate | null => {
-  const utilizations = tokens
-    .map((token) => token.sevenDayUtilizationPercent)
-    .filter((percent): percent is number => percent !== null);
-  if (utilizations.length === 0) {
-    return null;
-  }
-  const total = utilizations.reduce((sum, percent) => sum + percent, 0);
-  return {
-    usedPercent: total / utilizations.length,
-    includedTokenCount: utilizations.length,
-    totalTokenCount: tokens.length,
-  };
-};
-
-export class GenerateTokenStatusUseCase {
-  run = (input: GenerateTokenStatusInput): TokenStatus[] => {
-    const { tokens, prepCountByToken, humCountByToken, nowEpochSeconds } =
-      input;
-    return tokens.map((tokenInput) => {
-      const decision = this.toDecision(tokenInput.snapshot, nowEpochSeconds);
-      const normalized = this.normalizeWindows(
-        tokenInput.snapshot,
-        nowEpochSeconds,
-      );
-      return {
-        name: tokenInput.name,
-        fiveHourUtilizationPercent: normalized.fiveHourUtilizationPercent,
-        fiveHourResetSeconds: normalized.fiveHourResetSeconds,
-        sevenDayUtilizationPercent: normalized.sevenDayUtilizationPercent,
-        sevenDayResetSeconds: normalized.sevenDayResetSeconds,
-        color: judgeTokenColor(decision),
-        prep: prepCountByToken.get(tokenInput.token) ?? 0,
-        hum: humCountByToken.get(tokenInput.token) ?? 0,
-      };
-    });
-  };
-
-  private normalizeWindows = (
-    snapshot: TokenRateLimitSnapshot | null,
-    nowEpochSeconds: number,
-  ): {
-    fiveHourUtilizationPercent: number | null;
-    fiveHourResetSeconds: number | null;
-    sevenDayUtilizationPercent: number | null;
-    sevenDayResetSeconds: number | null;
-  } => {
-    if (snapshot === null || !snapshot.hasWindowData) {
-      return {
-        fiveHourUtilizationPercent: null,
-        fiveHourResetSeconds: null,
-        sevenDayUtilizationPercent: null,
-        sevenDayResetSeconds: null,
-      };
-    }
-    const fiveHourReset =
-      snapshot.fiveHourReset > 0 ? snapshot.fiveHourReset : null;
-    const sevenDayReset =
-      snapshot.sevenDayReset > 0 ? snapshot.sevenDayReset : null;
-    const fiveHourExpired =
-      fiveHourReset !== null &&
-      fiveHourReset < nowEpochSeconds &&
-      snapshot.lastUpdatedEpoch >= fiveHourReset;
-    const sevenDayExpired =
-      sevenDayReset !== null &&
-      sevenDayReset < nowEpochSeconds &&
-      snapshot.lastUpdatedEpoch >= sevenDayReset;
-    return {
-      fiveHourUtilizationPercent: fiveHourExpired
-        ? 0
-        : Math.trunc(snapshot.fiveHourUtilization * 100),
-      fiveHourResetSeconds:
-        fiveHourReset === null
-          ? null
-          : Math.max(0, fiveHourReset - nowEpochSeconds),
-      sevenDayUtilizationPercent: sevenDayExpired
-        ? 0
-        : Math.trunc(snapshot.sevenDayUtilization * 100),
-      sevenDayResetSeconds:
-        sevenDayReset === null
-          ? null
-          : Math.max(0, sevenDayReset - nowEpochSeconds),
-    };
-  };
-
-  private toDecision = (
-    snapshot: TokenRateLimitSnapshot | null,
-    nowEpochSeconds: number,
-  ): TokenRateLimitDecision | null => {
-    if (snapshot === null) {
-      return null;
-    }
-    if (!snapshot.hasWindowData) {
-      return {
-        fiveHourUtilization: null,
-        sevenDayUtilization: null,
-        fiveHourRejected: snapshot.fiveHourRejected,
-        sevenDayRejected: snapshot.sevenDayRejected,
-        blocked: snapshot.blocked,
-        unifiedStatus: snapshot.unifiedStatus,
-        sevenDaySonnetRejected: snapshot.sevenDaySonnetRejected,
-        sevenDayOpusRejected: snapshot.sevenDayOpusRejected,
-        partial: true,
-        subscriptionDisabled: snapshot.subscriptionDisabled,
-      };
-    }
-    const fiveHourExpired =
-      snapshot.fiveHourReset > 0 &&
-      snapshot.fiveHourReset < nowEpochSeconds &&
-      snapshot.lastUpdatedEpoch >= snapshot.fiveHourReset;
-    const sevenDayExpired =
-      snapshot.sevenDayReset > 0 &&
-      snapshot.sevenDayReset < nowEpochSeconds &&
-      snapshot.lastUpdatedEpoch >= snapshot.sevenDayReset;
-    return {
-      fiveHourUtilization: fiveHourExpired ? 0 : snapshot.fiveHourUtilization,
-      sevenDayUtilization: sevenDayExpired ? 0 : snapshot.sevenDayUtilization,
-      fiveHourRejected: fiveHourExpired ? false : snapshot.fiveHourRejected,
-      sevenDayRejected: sevenDayExpired ? false : snapshot.sevenDayRejected,
-      blocked: snapshot.blocked,
-      unifiedStatus: snapshot.unifiedStatus,
-      sevenDaySonnetRejected:
-        snapshot.sevenDaySonnetRejected ||
-        (sevenDayExpired ? false : snapshot.sevenDayRejected),
-      sevenDayOpusRejected:
-        snapshot.sevenDayOpusRejected ||
-        (sevenDayExpired ? false : snapshot.sevenDayRejected),
-      partial: false,
-      subscriptionDisabled: snapshot.subscriptionDisabled,
-    };
-  };
-}

package/src/domain/usecases/ensureAgentOptionAndGetId.ts

@@ -1,47 +0,0 @@
-import { FieldOption, Project } from '../entities/Project';
-import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
-import { AGENT_FIELD_NAME } from '../entities/RequiredProjectField';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-
-export const ensureAgentOptionAndGetId = async (
-  projectRepository: Pick<
-    ProjectRepository,
-    'createField' | 'getByUrl' | 'updateAgentList'
-  >,
-  project: Project,
-  agentName: string,
-): Promise<string | null> => {
-  const normalizedTarget = normalizeProjectFieldName(agentName);
-  if (!project.agent) {
-    await projectRepository.createField(project, {
-      name: AGENT_FIELD_NAME,
-      dataType: 'SINGLE_SELECT',
-      options: [{ name: agentName, color: 'GRAY' as const, description: '' }],
-    });
-    const refreshed = await projectRepository.getByUrl(project.url);
-    const created = refreshed.agent?.options.find(
-      (option) => normalizeProjectFieldName(option.name) === normalizedTarget,
-    );
-    return created?.id ?? null;
-  }
-  const existing = project.agent.options.find(
-    (option) => normalizeProjectFieldName(option.name) === normalizedTarget,
-  );
-  if (existing) {
-    return existing.id;
-  }
-  const mergedOptions: (Omit<FieldOption, 'id'> & {
-    id: FieldOption['id'] | null;
-  })[] = [
-    ...project.agent.options.map((option) => ({ ...option })),
-    { id: null, name: agentName, color: 'GRAY' as const, description: '' },
-  ];
-  const updatedOptions = await projectRepository.updateAgentList(
-    project,
-    mergedOptions,
-  );
-  const created = updatedOptions.find(
-    (option) => normalizeProjectFieldName(option.name) === normalizedTarget,
-  );
-  return created?.id ?? null;
-};

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

@@ -1,40 +0,0 @@
-import { extractFencedJsonBlocks } from './extractFencedJsonBlocks';
-
-describe('extractFencedJsonBlocks', () => {
-  it('returns every fenced json block in the order they appear', () => {
-    expect(
-      extractFencedJsonBlocks(
-        'From: :robot: agent (model)\n\n```json\n{ "pullRequestRequired": false }\n```\n\ntext\n\n```json\n{ "nextStepAgent": "developer" }\n```\n',
-        'test',
-      ),
-    ).toEqual([{ pullRequestRequired: false }, { nextStepAgent: 'developer' }]);
-  });
-
-  it('returns an empty list when the body carries no fenced json block', () => {
-    expect(extractFencedJsonBlocks('Please go ahead.', 'test')).toEqual([]);
-  });
-
-  it('skips an unparseable block, reports it, and still returns the parseable ones', () => {
-    const consoleWarn = jest.spyOn(console, 'warn').mockImplementation();
-    expect(
-      extractFencedJsonBlocks(
-        'From: :robot: agent (model)\n\n```json\n{ "broken": \n```\n\n```json\n{ "ok": true }\n```\n',
-        'test',
-      ),
-    ).toEqual([{ ok: true }]);
-    expect(consoleWarn).toHaveBeenCalledWith(
-      'Invalid JSON in report body while checking test:',
-      expect.anything(),
-    );
-    consoleWarn.mockRestore();
-  });
-
-  it('reads blocks whose code fence backticks are backslash escaped', () => {
-    expect(
-      extractFencedJsonBlocks(
-        'From: :robot: agent (model)\n\n\\`\\`\\`json\n{ "nextStepAgent": "developer" }\n\\`\\`\\`\n',
-        'test',
-      ),
-    ).toEqual([{ nextStepAgent: 'developer' }]);
-  });
-});

package/src/domain/usecases/extractFencedJsonBlocks.ts

@@ -1,21 +0,0 @@
-import { normalizeReportBody } from './normalizeReportBody';
-
-export const extractFencedJsonBlocks = (
-  body: string,
-  context: string,
-): unknown[] => {
-  const blocks: unknown[] = [];
-  for (const match of normalizeReportBody(body).matchAll(
-    /```json\n([\s\S]*?)\n```/g,
-  )) {
-    try {
-      blocks.push(JSON.parse(match[1]));
-    } catch (error) {
-      console.warn(
-        `Invalid JSON in report body while checking ${context}:`,
-        error,
-      );
-    }
-  }
-  return blocks;
-};