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

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

@@ -1,167 +0,0 @@
-import {
-  hasRateLimitSignals,
-  computeBoundedBackoffMs,
-  computeRateLimitResetIso,
-  fetchWithGitHubRateLimitRetry,
-  RATE_LIMIT_MAX_RETRIES,
-  RATE_LIMIT_TOTAL_BACKOFF_CAP_MS,
-} from './githubRateLimitRetry';
-
-describe('githubRateLimitRetry', () => {
-  describe('hasRateLimitSignals', () => {
-    it('detects a 403 with x-ratelimit-remaining: 0', () => {
-      const headers = new Headers({ 'x-ratelimit-remaining': '0' });
-      expect(hasRateLimitSignals(403, headers, '')).toBe(true);
-    });
-
-    it('detects a 429 with a Retry-After header', () => {
-      const headers = new Headers({ 'retry-after': '2' });
-      expect(hasRateLimitSignals(429, headers, '')).toBe(true);
-    });
-
-    it('detects a secondary rate limit message in the body', () => {
-      const headers = new Headers();
-      expect(
-        hasRateLimitSignals(
-          403,
-          headers,
-          JSON.stringify({
-            message: 'You have exceeded a secondary rate limit',
-          }),
-        ),
-      ).toBe(true);
-    });
-
-    it('does not flag a 403 without any rate-limit signal', () => {
-      const headers = new Headers({ 'x-ratelimit-remaining': '4999' });
-      expect(
-        hasRateLimitSignals(
-          403,
-          headers,
-          JSON.stringify({ message: 'Resource not accessible by integration' }),
-        ),
-      ).toBe(false);
-    });
-
-    it('does not flag non-403/429 statuses', () => {
-      const headers = new Headers({ 'retry-after': '2' });
-      expect(hasRateLimitSignals(404, headers, 'rate limit')).toBe(false);
-    });
-  });
-
-  describe('computeBoundedBackoffMs', () => {
-    it('grows exponentially from the base when no Retry-After is present', () => {
-      const headers = new Headers();
-      expect(computeBoundedBackoffMs(headers, 0, 0)).toBe(250);
-      expect(computeBoundedBackoffMs(headers, 1, 0)).toBe(500);
-      expect(computeBoundedBackoffMs(headers, 2, 0)).toBe(1000);
-    });
-
-    it('honors Retry-After only within the remaining budget', () => {
-      const headers = new Headers({ 'retry-after': '2' });
-      expect(computeBoundedBackoffMs(headers, 0, 0)).toBe(2000);
-    });
-
-    it('caps the wait so the total never exceeds the budget', () => {
-      const headers = new Headers({ 'retry-after': '3600' });
-      expect(computeBoundedBackoffMs(headers, 0, 4000)).toBe(
-        RATE_LIMIT_TOTAL_BACKOFF_CAP_MS - 4000,
-      );
-    });
-
-    it('returns 0 when the backoff budget is exhausted', () => {
-      const headers = new Headers({ 'retry-after': '3600' });
-      expect(
-        computeBoundedBackoffMs(headers, 0, RATE_LIMIT_TOTAL_BACKOFF_CAP_MS),
-      ).toBe(0);
-    });
-  });
-
-  describe('computeRateLimitResetIso', () => {
-    it('converts the x-ratelimit-reset epoch seconds to an ISO timestamp', () => {
-      const headers = new Headers({ 'x-ratelimit-reset': '1700000000' });
-      expect(computeRateLimitResetIso(headers)).toBe(
-        new Date(1700000000 * 1000).toISOString(),
-      );
-    });
-
-    it('returns null when no reset header is present', () => {
-      expect(computeRateLimitResetIso(new Headers())).toBeNull();
-    });
-  });
-
-  describe('fetchWithGitHubRateLimitRetry', () => {
-    const rateLimitResponse = (): Response =>
-      new Response(JSON.stringify({ message: 'API rate limit exceeded' }), {
-        status: 403,
-        headers: { 'x-ratelimit-remaining': '0' },
-      });
-
-    it('retries a rate-limit response and resolves with the eventual success', async () => {
-      const sleep = jest.fn().mockResolvedValue(undefined);
-      const request = jest
-        .fn<Promise<Response>, []>()
-        .mockResolvedValueOnce(rateLimitResponse())
-        .mockResolvedValueOnce(
-          new Response(JSON.stringify({ ok: true }), { status: 200 }),
-        );
-
-      const response = await fetchWithGitHubRateLimitRetry(request, sleep);
-
-      expect(response.status).toBe(200);
-      expect(request).toHaveBeenCalledTimes(2);
-      expect(sleep).toHaveBeenCalledTimes(1);
-    });
-
-    it('does not retry a genuine permission 403 without rate-limit signals', async () => {
-      const sleep = jest.fn().mockResolvedValue(undefined);
-      const request = jest.fn<Promise<Response>, []>().mockResolvedValue(
-        new Response(
-          JSON.stringify({
-            message: 'Resource not accessible by integration',
-          }),
-          { status: 403, headers: { 'x-ratelimit-remaining': '4999' } },
-        ),
-      );
-
-      const response = await fetchWithGitHubRateLimitRetry(request, sleep);
-
-      expect(response.status).toBe(403);
-      expect(request).toHaveBeenCalledTimes(1);
-      expect(sleep).not.toHaveBeenCalled();
-    });
-
-    it('stops retrying after the bounded retry cap and never blocks past the budget', async () => {
-      const sleeps: number[] = [];
-      const sleep = jest.fn(async (milliseconds: number) => {
-        sleeps.push(milliseconds);
-      });
-      const request = jest
-        .fn<Promise<Response>, []>()
-        .mockResolvedValue(rateLimitResponse());
-
-      const response = await fetchWithGitHubRateLimitRetry(request, sleep);
-
-      expect(response.status).toBe(403);
-      expect(request).toHaveBeenCalledTimes(RATE_LIMIT_MAX_RETRIES + 1);
-      expect(sleep).toHaveBeenCalledTimes(RATE_LIMIT_MAX_RETRIES);
-      const totalSlept = sleeps.reduce((sum, value) => sum + value, 0);
-      expect(totalSlept).toBeLessThanOrEqual(RATE_LIMIT_TOTAL_BACKOFF_CAP_MS);
-    });
-
-    it('preserves the response body for the caller after inspecting it for signals', async () => {
-      const sleep = jest.fn().mockResolvedValue(undefined);
-      const request = jest
-        .fn<Promise<Response>, []>()
-        .mockResolvedValueOnce(rateLimitResponse())
-        .mockResolvedValueOnce(
-          new Response(JSON.stringify({ value: 'final' }), { status: 200 }),
-        );
-
-      const response = await fetchWithGitHubRateLimitRetry(request, sleep);
-      const body: unknown = await response.json();
-
-      expect(body).toEqual({ value: 'final' });
-    });
-  });
-});

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

@@ -1,109 +0,0 @@
-export class GitHubRateLimitError extends Error {
-  readonly name = 'GitHubRateLimitError';
-}
-
-export const RATE_LIMIT_MAX_RETRIES = 3;
-export const RATE_LIMIT_TOTAL_BACKOFF_CAP_MS = 5000;
-export const RATE_LIMIT_BASE_BACKOFF_MS = 250;
-
-const RATE_LIMIT_MESSAGE_PATTERN = /rate limit|secondary rate limit|abuse/i;
-
-export type Sleep = (milliseconds: number) => Promise<void>;
-
-export const realSleep: Sleep = (milliseconds) =>
-  new Promise((resolve) => setTimeout(resolve, milliseconds));
-
-const parseNonNegativeIntegerHeader = (value: string | null): number | null => {
-  if (value === null) {
-    return null;
-  }
-  const trimmed = value.trim();
-  if (!/^\d+$/.test(trimmed)) {
-    return null;
-  }
-  const parsed = Number.parseInt(trimmed, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-};
-
-export const hasRateLimitSignals = (
-  status: number,
-  headers: Headers,
-  bodyText: string,
-): boolean => {
-  if (status !== 403 && status !== 429) {
-    return false;
-  }
-  if (
-    parseNonNegativeIntegerHeader(headers.get('x-ratelimit-remaining')) === 0
-  ) {
-    return true;
-  }
-  if (headers.get('retry-after') !== null) {
-    return true;
-  }
-  return RATE_LIMIT_MESSAGE_PATTERN.test(bodyText);
-};
-
-export const computeRateLimitResetIso = (headers: Headers): string | null => {
-  const resetEpochSeconds = parseNonNegativeIntegerHeader(
-    headers.get('x-ratelimit-reset'),
-  );
-  if (resetEpochSeconds === null) {
-    return null;
-  }
-  return new Date(resetEpochSeconds * 1000).toISOString();
-};
-
-export const computeBoundedBackoffMs = (
-  headers: Headers,
-  attempt: number,
-  elapsedMs: number,
-): number => {
-  const remainingBudgetMs = RATE_LIMIT_TOTAL_BACKOFF_CAP_MS - elapsedMs;
-  if (remainingBudgetMs <= 0) {
-    return 0;
-  }
-  const exponentialMs = RATE_LIMIT_BASE_BACKOFF_MS * Math.pow(2, attempt);
-  const retryAfterSeconds = parseNonNegativeIntegerHeader(
-    headers.get('retry-after'),
-  );
-  const requestedMs =
-    retryAfterSeconds !== null ? retryAfterSeconds * 1000 : exponentialMs;
-  return Math.min(requestedMs, remainingBudgetMs);
-};
-
-export const fetchWithGitHubRateLimitRetry = async (
-  request: () => Promise<Response>,
-  sleep: Sleep = realSleep,
-  now: () => number = Date.now,
-): Promise<Response> => {
-  const startMs = now();
-  let attempt = 0;
-  for (;;) {
-    const response = await request();
-    if (response.ok) {
-      return response;
-    }
-    const bodyText = await response.clone().text();
-    if (
-      attempt >= RATE_LIMIT_MAX_RETRIES ||
-      !hasRateLimitSignals(response.status, response.headers, bodyText)
-    ) {
-      return response;
-    }
-    const elapsedMs = now() - startMs;
-    const backoffMs = computeBoundedBackoffMs(
-      response.headers,
-      attempt,
-      elapsedMs,
-    );
-    if (backoffMs <= 0) {
-      return response;
-    }
-    console.log(
-      `GitHub returned ${response.status} (rate limit). Backing off ${backoffMs}ms before retry ${attempt + 1}/${RATE_LIMIT_MAX_RETRIES}.`,
-    );
-    await sleep(backoffMs);
-    attempt++;
-  }
-};

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

@@ -1,81 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import {
-  localStorageCacheBaseDirectory,
-  projectCacheDirectory,
-  tdpmCacheDirectory,
-} from './localStorageCacheDirectory';
-
-describe('localStorageCacheBaseDirectory', () => {
-  const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-  const originalWorkingDirectory = process.cwd();
-
-  afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-      delete process.env.XDG_CACHE_HOME;
-    } else {
-      process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    process.chdir(originalWorkingDirectory);
-  });
-
-  test('places the cache below XDG_CACHE_HOME when it is set', () => {
-    process.env.XDG_CACHE_HOME = '/var/tmp/xdg-cache-home-for-test';
-
-    expect(localStorageCacheBaseDirectory()).toBe(
-      '/var/tmp/xdg-cache-home-for-test/tdpm/cache',
-    );
-  });
-
-  test('places the cache below the home cache directory when XDG_CACHE_HOME is absent', () => {
-    delete process.env.XDG_CACHE_HOME;
-
-    expect(localStorageCacheBaseDirectory()).toBe(
-      path.join(os.homedir(), '.cache', 'tdpm', 'cache'),
-    );
-  });
-
-  test('resolves to the same absolute directory from two working directories, so a session started in its own worktree reads what the other sessions cached', () => {
-    delete process.env.XDG_CACHE_HOME;
-
-    const fromCurrentDirectory = projectCacheDirectory('acme');
-    process.chdir(os.tmpdir());
-
-    expect(projectCacheDirectory('acme')).toBe(fromCurrentDirectory);
-    expect(path.isAbsolute(fromCurrentDirectory)).toBe(true);
-  });
-});
-
-describe('projectCacheDirectory', () => {
-  test('places the project below the shared base directory', () => {
-    expect(projectCacheDirectory('acme')).toBe(
-      path.join(localStorageCacheBaseDirectory(), 'acme'),
-    );
-  });
-});
-
-describe('tdpmCacheDirectory', () => {
-  const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-
-  afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-      delete process.env.XDG_CACHE_HOME;
-    } else {
-      process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-  });
-
-  test('places the tdpm directory below XDG_CACHE_HOME when it is set', () => {
-    process.env.XDG_CACHE_HOME = '/var/tmp/xdg-cache-home-for-test';
-
-    expect(tdpmCacheDirectory()).toBe('/var/tmp/xdg-cache-home-for-test/tdpm');
-  });
-
-  test('places the tdpm directory below the home cache directory when XDG_CACHE_HOME is absent', () => {
-    delete process.env.XDG_CACHE_HOME;
-
-    expect(tdpmCacheDirectory()).toBe(
-      path.join(os.homedir(), '.cache', 'tdpm'),
-    );
-  });
-});

package/src/adapter/repositories/localStorageCacheDirectory.ts

@@ -1,13 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-export const tdpmCacheDirectory = (): string => {
-  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
-  return path.join(base, 'tdpm');
-};
-
-export const localStorageCacheBaseDirectory = (): string =>
-  path.join(tdpmCacheDirectory(), 'cache');
-
-export const projectCacheDirectory = (projectName: string): string =>
-  path.join(localStorageCacheBaseDirectory(), projectName);

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

@@ -1,191 +0,0 @@
-import {
-  ProjectFieldDefinition,
-  convertToFieldOptionColor,
-  projectFromDefinition,
-} from './projectFieldDefinition';
-
-describe('convertToFieldOptionColor', () => {
-  it('should preserve PINK so the Todo by human status button renders pink', () => {
-    expect(convertToFieldOptionColor('PINK')).toEqual('PINK');
-  });
-
-  it('should preserve ORANGE so the Unread status button renders orange', () => {
-    expect(convertToFieldOptionColor('ORANGE')).toEqual('ORANGE');
-  });
-
-  it('should preserve the remaining GitHub project option colors', () => {
-    expect(convertToFieldOptionColor('RED')).toEqual('RED');
-    expect(convertToFieldOptionColor('YELLOW')).toEqual('YELLOW');
-    expect(convertToFieldOptionColor('GREEN')).toEqual('GREEN');
-    expect(convertToFieldOptionColor('BLUE')).toEqual('BLUE');
-    expect(convertToFieldOptionColor('PURPLE')).toEqual('PURPLE');
-    expect(convertToFieldOptionColor('GRAY')).toEqual('GRAY');
-  });
-
-  it('should fall back to GRAY for an unknown color value', () => {
-    expect(convertToFieldOptionColor('UNKNOWN')).toEqual('GRAY');
-  });
-});
-
-describe('projectFromDefinition', () => {
-  const statusField: ProjectFieldDefinition = {
-    fieldId: 'PVTSSF_status',
-    databaseId: 12940049,
-    name: 'Status',
-    options: [
-      {
-        id: 'f75ad846',
-        name: 'Unread',
-        color: 'ORANGE',
-        description: '',
-      },
-    ],
-  };
-  const storyField: ProjectFieldDefinition = {
-    fieldId: 'PVTSSF_story',
-    databaseId: 133939017,
-    name: 'story',
-    options: [
-      {
-        id: '6dc26727',
-        name: 'regular / workflow management',
-        color: 'BLUE',
-        description: 'workflow',
-      },
-      {
-        id: '4ada6c4c',
-        name: 'regular / entertainment',
-        color: 'BLUE',
-        description: '',
-      },
-    ],
-  };
-
-  it('should map the status field and every optional field it finds by name', () => {
-    const project = projectFromDefinition({
-      id: 'PVT_project',
-      url: 'https://github.com/users/HiromiShikata/projects/48',
-      databaseId: 1403371,
-      name: 'UMINO',
-      fields: [
-        statusField,
-        storyField,
-        {
-          fieldId: 'PVTF_nextactiondate',
-          databaseId: 35978365,
-          name: 'nextactiondate',
-          options: [],
-        },
-        {
-          fieldId: 'PVTSSF_nextactionhour',
-          databaseId: 133948391,
-          name: 'nextactionhour',
-          options: [],
-        },
-        {
-          fieldId: 'PVTF_remaining',
-          databaseId: 1,
-          name: 'remaining estimation minutes',
-          options: [],
-        },
-        {
-          fieldId: 'PVTF_depended',
-          databaseId: 156128545,
-          name: 'Depended Issue URL separated by comma',
-          options: [],
-        },
-        {
-          fieldId: 'PVTF_completion',
-          databaseId: 2,
-          name: 'Completion Date (50% Confidence)',
-          options: [],
-        },
-      ],
-    });
-
-    expect(project).toEqual({
-      id: 'PVT_project',
-      url: 'https://github.com/users/HiromiShikata/projects/48',
-      databaseId: 1403371,
-      name: 'UMINO',
-      status: {
-        name: 'Status',
-        fieldId: 'PVTSSF_status',
-        statuses: statusField.options,
-      },
-      nextActionDate: {
-        name: 'nextactiondate',
-        fieldId: 'PVTF_nextactiondate',
-      },
-      nextActionHour: {
-        name: 'nextactionhour',
-        fieldId: 'PVTSSF_nextactionhour',
-        options: [],
-      },
-      story: {
-        name: 'story',
-        fieldId: 'PVTSSF_story',
-        databaseId: 133939017,
-        stories: storyField.options,
-        workflowManagementStory: storyField.options[0],
-      },
-      remainingEstimationMinutes: {
-        name: 'remaining estimation minutes',
-        fieldId: 'PVTF_remaining',
-      },
-      dependedIssueUrlSeparatedByComma: {
-        name: 'Depended Issue URL separated by comma',
-        fieldId: 'PVTF_depended',
-      },
-      completionDate50PercentConfidence: {
-        name: 'Completion Date (50% Confidence)',
-        fieldId: 'PVTF_completion',
-      },
-      agent: null,
-    });
-  });
-
-  it('should leave every optional field null when the project carries only the status field', () => {
-    const project = projectFromDefinition({
-      id: 'PVT_project',
-      url: 'https://github.com/orgs/X-Mile/projects/7',
-      databaseId: 7,
-      name: 'minimal',
-      fields: [statusField],
-    });
-
-    expect(project.story).toBeNull();
-    expect(project.nextActionDate).toBeNull();
-    expect(project.nextActionHour).toBeNull();
-    expect(project.remainingEstimationMinutes).toBeNull();
-    expect(project.dependedIssueUrlSeparatedByComma).toBeNull();
-    expect(project.completionDate50PercentConfidence).toBeNull();
-  });
-
-  it('should leave the story null when no option names the workflow management story', () => {
-    const project = projectFromDefinition({
-      id: 'PVT_project',
-      url: 'https://github.com/users/HiromiShikata/projects/48',
-      databaseId: 1403371,
-      name: 'UMINO',
-      fields: [
-        statusField,
-        { ...storyField, options: [storyField.options[1]] },
-      ],
-    });
-
-    expect(project.story).toBeNull();
-  });
-
-  it('should throw when the project has no status field', () => {
-    expect(() =>
-      projectFromDefinition({
-        id: 'PVT_project',
-        url: 'https://github.com/users/HiromiShikata/projects/48',
-        databaseId: 1403371,
-        name: 'UMINO',
-        fields: [storyField],
-      }),
-    ).toThrow('status field is not found');
-  });
-});

package/src/adapter/repositories/projectFieldDefinition.ts

@@ -1,144 +0,0 @@
-import { FieldOption, Project } from '../../domain/entities/Project';
-import {
-  AGENT_FIELD_NAME,
-  DEPENDED_ISSUE_URL_FIELD_NAME,
-  NEXT_ACTION_DATE_FIELD_NAME,
-  NEXT_ACTION_HOUR_FIELD_NAME,
-  STORY_FIELD_NAME,
-} from '../../domain/entities/RequiredProjectField';
-import { normalizeFieldName } from './utils';
-
-export type ProjectFieldDefinition = {
-  fieldId: string;
-  databaseId: number;
-  name: string;
-  options: FieldOption[];
-};
-
-export type ProjectDefinition = {
-  id: string;
-  url: string;
-  databaseId: number;
-  name: string;
-  fields: ProjectFieldDefinition[];
-};
-
-export const convertToFieldOptionColor = (
-  color: string,
-): FieldOption['color'] => {
-  switch (color) {
-    case 'RED':
-    case 'YELLOW':
-    case 'GREEN':
-    case 'BLUE':
-    case 'PURPLE':
-    case 'ORANGE':
-    case 'PINK':
-    case 'GRAY':
-      return color;
-    default:
-      return 'GRAY';
-  }
-};
-
-export const projectFromDefinition = (
-  definition: ProjectDefinition,
-): Project => {
-  const nextActionDate = definition.fields.find(
-    (field) =>
-      normalizeFieldName(field.name) ===
-      normalizeFieldName(NEXT_ACTION_DATE_FIELD_NAME),
-  );
-  const nextActionHour = definition.fields.find(
-    (field) =>
-      normalizeFieldName(field.name) ===
-      normalizeFieldName(NEXT_ACTION_HOUR_FIELD_NAME),
-  );
-  const status = definition.fields.find(
-    (field) => normalizeFieldName(field.name) === 'status',
-  );
-  if (!status) {
-    throw new Error('status field is not found');
-  }
-  const story = definition.fields.find(
-    (field) =>
-      normalizeFieldName(field.name) === normalizeFieldName(STORY_FIELD_NAME),
-  );
-  const workflowManagementStory = story?.options.find((option) =>
-    normalizeFieldName(option.name).includes('workflowmanagement'),
-  );
-  const remainingEstimationMinutes = definition.fields.find(
-    (field) => normalizeFieldName(field.name) === 'remainingestimationminutes',
-  );
-  const dependedIssueUrlSeparatedByComma = definition.fields.find((field) =>
-    normalizeFieldName(field.name).startsWith(
-      normalizeFieldName(DEPENDED_ISSUE_URL_FIELD_NAME),
-    ),
-  );
-  const completionDate50PercentConfidence = definition.fields.find((field) =>
-    normalizeFieldName(field.name).startsWith('completiondate'),
-  );
-  const agentField = definition.fields.find(
-    (field) =>
-      normalizeFieldName(field.name) === normalizeFieldName(AGENT_FIELD_NAME),
-  );
-  return {
-    id: definition.id,
-    url: definition.url,
-    databaseId: definition.databaseId,
-    name: definition.name,
-    status: {
-      name: status.name,
-      fieldId: status.fieldId,
-      statuses: status.options,
-    },
-    nextActionDate: nextActionDate
-      ? {
-          name: nextActionDate.name,
-          fieldId: nextActionDate.fieldId,
-        }
-      : null,
-    nextActionHour: nextActionHour
-      ? {
-          name: nextActionHour.name,
-          fieldId: nextActionHour.fieldId,
-          options: nextActionHour.options,
-        }
-      : null,
-    story:
-      story && workflowManagementStory
-        ? {
-            name: story.name,
-            fieldId: story.fieldId,
-            databaseId: story.databaseId,
-            stories: story.options,
-            workflowManagementStory,
-          }
-        : null,
-    remainingEstimationMinutes: remainingEstimationMinutes
-      ? {
-          name: remainingEstimationMinutes.name,
-          fieldId: remainingEstimationMinutes.fieldId,
-        }
-      : null,
-    dependedIssueUrlSeparatedByComma: dependedIssueUrlSeparatedByComma
-      ? {
-          name: dependedIssueUrlSeparatedByComma.name,
-          fieldId: dependedIssueUrlSeparatedByComma.fieldId,
-        }
-      : null,
-    completionDate50PercentConfidence: completionDate50PercentConfidence
-      ? {
-          name: completionDate50PercentConfidence.name,
-          fieldId: completionDate50PercentConfidence.fieldId,
-        }
-      : null,
-    agent: agentField
-      ? {
-          name: agentField.name,
-          fieldId: agentField.fieldId,
-          options: agentField.options,
-        }
-      : null,
-  };
-};